0,0 → 1,1232 |
/* |
* Copyright (c) 2007 Intel Corporation. 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, sub license, 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 NON-INFRINGEMENT. |
* IN NO EVENT SHALL PRECISION INSIGHT AND/OR ITS SUPPLIERS 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. |
*/ |
|
#include "config.h" |
#include <va/va_backend.h> |
|
#include "dummy_drv_video.h" |
|
#include "assert.h" |
#include <stdio.h> |
#include <stdlib.h> |
#include <string.h> |
#include <stdarg.h> |
|
#define ASSERT assert |
|
#define INIT_DRIVER_DATA struct dummy_driver_data * const driver_data = (struct dummy_driver_data *) ctx->pDriverData; |
|
#define CONFIG(id) ((object_config_p) object_heap_lookup( &driver_data->config_heap, id )) |
#define CONTEXT(id) ((object_context_p) object_heap_lookup( &driver_data->context_heap, id )) |
#define SURFACE(id) ((object_surface_p) object_heap_lookup( &driver_data->surface_heap, id )) |
#define BUFFER(id) ((object_buffer_p) object_heap_lookup( &driver_data->buffer_heap, id )) |
|
#define CONFIG_ID_OFFSET 0x01000000 |
#define CONTEXT_ID_OFFSET 0x02000000 |
#define SURFACE_ID_OFFSET 0x04000000 |
#define BUFFER_ID_OFFSET 0x08000000 |
|
static void dummy__error_message(const char *msg, ...) |
{ |
va_list args; |
|
fprintf(stderr, "dummy_drv_video error: "); |
va_start(args, msg); |
vfprintf(stderr, msg, args); |
va_end(args); |
} |
|
static void dummy__information_message(const char *msg, ...) |
{ |
va_list args; |
|
fprintf(stderr, "dummy_drv_video: "); |
va_start(args, msg); |
vfprintf(stderr, msg, args); |
va_end(args); |
} |
|
VAStatus dummy_QueryConfigProfiles( |
VADriverContextP ctx, |
VAProfile *profile_list, /* out */ |
int *num_profiles /* out */ |
) |
{ |
int i = 0; |
|
profile_list[i++] = VAProfileMPEG2Simple; |
profile_list[i++] = VAProfileMPEG2Main; |
profile_list[i++] = VAProfileMPEG4Simple; |
profile_list[i++] = VAProfileMPEG4AdvancedSimple; |
profile_list[i++] = VAProfileMPEG4Main; |
profile_list[i++] = VAProfileH264Baseline; |
profile_list[i++] = VAProfileH264Main; |
profile_list[i++] = VAProfileH264High; |
profile_list[i++] = VAProfileVC1Simple; |
profile_list[i++] = VAProfileVC1Main; |
profile_list[i++] = VAProfileVC1Advanced; |
|
/* If the assert fails then DUMMY_MAX_PROFILES needs to be bigger */ |
ASSERT(i <= DUMMY_MAX_PROFILES); |
*num_profiles = i; |
|
return VA_STATUS_SUCCESS; |
} |
|
VAStatus dummy_QueryConfigEntrypoints( |
VADriverContextP ctx, |
VAProfile profile, |
VAEntrypoint *entrypoint_list, /* out */ |
int *num_entrypoints /* out */ |
) |
{ |
switch (profile) { |
case VAProfileMPEG2Simple: |
case VAProfileMPEG2Main: |
*num_entrypoints = 2; |
entrypoint_list[0] = VAEntrypointVLD; |
entrypoint_list[1] = VAEntrypointMoComp; |
break; |
|
case VAProfileMPEG4Simple: |
case VAProfileMPEG4AdvancedSimple: |
case VAProfileMPEG4Main: |
*num_entrypoints = 1; |
entrypoint_list[0] = VAEntrypointVLD; |
break; |
|
case VAProfileH264Baseline: |
case VAProfileH264Main: |
case VAProfileH264High: |
*num_entrypoints = 1; |
entrypoint_list[0] = VAEntrypointVLD; |
break; |
|
case VAProfileVC1Simple: |
case VAProfileVC1Main: |
case VAProfileVC1Advanced: |
*num_entrypoints = 1; |
entrypoint_list[0] = VAEntrypointVLD; |
break; |
|
default: |
*num_entrypoints = 0; |
break; |
} |
|
/* If the assert fails then DUMMY_MAX_ENTRYPOINTS needs to be bigger */ |
ASSERT(*num_entrypoints <= DUMMY_MAX_ENTRYPOINTS); |
return VA_STATUS_SUCCESS; |
} |
|
VAStatus dummy_GetConfigAttributes( |
VADriverContextP ctx, |
VAProfile profile, |
VAEntrypoint entrypoint, |
VAConfigAttrib *attrib_list, /* in/out */ |
int num_attribs |
) |
{ |
int i; |
|
/* Other attributes don't seem to be defined */ |
/* What to do if we don't know the attribute? */ |
for (i = 0; i < num_attribs; i++) |
{ |
switch (attrib_list[i].type) |
{ |
case VAConfigAttribRTFormat: |
attrib_list[i].value = VA_RT_FORMAT_YUV420; |
break; |
|
default: |
/* Do nothing */ |
attrib_list[i].value = VA_ATTRIB_NOT_SUPPORTED; |
break; |
} |
} |
|
return VA_STATUS_SUCCESS; |
} |
|
static VAStatus dummy__update_attribute(object_config_p obj_config, VAConfigAttrib *attrib) |
{ |
int i; |
/* Check existing attrbiutes */ |
for(i = 0; obj_config->attrib_count < i; i++) |
{ |
if (obj_config->attrib_list[i].type == attrib->type) |
{ |
/* Update existing attribute */ |
obj_config->attrib_list[i].value = attrib->value; |
return VA_STATUS_SUCCESS; |
} |
} |
if (obj_config->attrib_count < DUMMY_MAX_CONFIG_ATTRIBUTES) |
{ |
i = obj_config->attrib_count; |
obj_config->attrib_list[i].type = attrib->type; |
obj_config->attrib_list[i].value = attrib->value; |
obj_config->attrib_count++; |
return VA_STATUS_SUCCESS; |
} |
return VA_STATUS_ERROR_MAX_NUM_EXCEEDED; |
} |
|
VAStatus dummy_CreateConfig( |
VADriverContextP ctx, |
VAProfile profile, |
VAEntrypoint entrypoint, |
VAConfigAttrib *attrib_list, |
int num_attribs, |
VAConfigID *config_id /* out */ |
) |
{ |
INIT_DRIVER_DATA |
VAStatus vaStatus; |
int configID; |
object_config_p obj_config; |
int i; |
|
/* Validate profile & entrypoint */ |
switch (profile) { |
case VAProfileMPEG2Simple: |
case VAProfileMPEG2Main: |
if ((VAEntrypointVLD == entrypoint) || |
(VAEntrypointMoComp == entrypoint)) |
{ |
vaStatus = VA_STATUS_SUCCESS; |
} |
else |
{ |
vaStatus = VA_STATUS_ERROR_UNSUPPORTED_ENTRYPOINT; |
} |
break; |
|
case VAProfileMPEG4Simple: |
case VAProfileMPEG4AdvancedSimple: |
case VAProfileMPEG4Main: |
if (VAEntrypointVLD == entrypoint) |
{ |
vaStatus = VA_STATUS_SUCCESS; |
} |
else |
{ |
vaStatus = VA_STATUS_ERROR_UNSUPPORTED_ENTRYPOINT; |
} |
break; |
|
case VAProfileH264Baseline: |
case VAProfileH264Main: |
case VAProfileH264High: |
if (VAEntrypointVLD == entrypoint) |
{ |
vaStatus = VA_STATUS_SUCCESS; |
} |
else |
{ |
vaStatus = VA_STATUS_ERROR_UNSUPPORTED_ENTRYPOINT; |
} |
break; |
|
case VAProfileVC1Simple: |
case VAProfileVC1Main: |
case VAProfileVC1Advanced: |
if (VAEntrypointVLD == entrypoint) |
{ |
vaStatus = VA_STATUS_SUCCESS; |
} |
else |
{ |
vaStatus = VA_STATUS_ERROR_UNSUPPORTED_ENTRYPOINT; |
} |
break; |
|
default: |
vaStatus = VA_STATUS_ERROR_UNSUPPORTED_PROFILE; |
break; |
} |
|
if (VA_STATUS_SUCCESS != vaStatus) |
{ |
return vaStatus; |
} |
|
configID = object_heap_allocate( &driver_data->config_heap ); |
obj_config = CONFIG(configID); |
if (NULL == obj_config) |
{ |
vaStatus = VA_STATUS_ERROR_ALLOCATION_FAILED; |
return vaStatus; |
} |
|
obj_config->profile = profile; |
obj_config->entrypoint = entrypoint; |
obj_config->attrib_list[0].type = VAConfigAttribRTFormat; |
obj_config->attrib_list[0].value = VA_RT_FORMAT_YUV420; |
obj_config->attrib_count = 1; |
|
for(i = 0; i < num_attribs; i++) |
{ |
vaStatus = dummy__update_attribute(obj_config, &(attrib_list[i])); |
if (VA_STATUS_SUCCESS != vaStatus) |
{ |
break; |
} |
} |
|
/* Error recovery */ |
if (VA_STATUS_SUCCESS != vaStatus) |
{ |
object_heap_free( &driver_data->config_heap, (object_base_p) obj_config); |
} |
else |
{ |
*config_id = configID; |
} |
|
return vaStatus; |
} |
|
VAStatus dummy_DestroyConfig( |
VADriverContextP ctx, |
VAConfigID config_id |
) |
{ |
INIT_DRIVER_DATA |
VAStatus vaStatus; |
object_config_p obj_config; |
|
obj_config = CONFIG(config_id); |
if (NULL == obj_config) |
{ |
vaStatus = VA_STATUS_ERROR_INVALID_CONFIG; |
return vaStatus; |
} |
|
object_heap_free( &driver_data->config_heap, (object_base_p) obj_config); |
return VA_STATUS_SUCCESS; |
} |
|
VAStatus dummy_QueryConfigAttributes( |
VADriverContextP ctx, |
VAConfigID config_id, |
VAProfile *profile, /* out */ |
VAEntrypoint *entrypoint, /* out */ |
VAConfigAttrib *attrib_list, /* out */ |
int *num_attribs /* out */ |
) |
{ |
INIT_DRIVER_DATA |
VAStatus vaStatus = VA_STATUS_SUCCESS; |
object_config_p obj_config; |
int i; |
|
obj_config = CONFIG(config_id); |
ASSERT(obj_config); |
|
*profile = obj_config->profile; |
*entrypoint = obj_config->entrypoint; |
*num_attribs = obj_config->attrib_count; |
for(i = 0; i < obj_config->attrib_count; i++) |
{ |
attrib_list[i] = obj_config->attrib_list[i]; |
} |
|
return vaStatus; |
} |
|
VAStatus dummy_CreateSurfaces( |
VADriverContextP ctx, |
int width, |
int height, |
int format, |
int num_surfaces, |
VASurfaceID *surfaces /* out */ |
) |
{ |
INIT_DRIVER_DATA |
VAStatus vaStatus = VA_STATUS_SUCCESS; |
int i; |
|
/* We only support one format */ |
if (VA_RT_FORMAT_YUV420 != format) |
{ |
return VA_STATUS_ERROR_UNSUPPORTED_RT_FORMAT; |
} |
|
for (i = 0; i < num_surfaces; i++) |
{ |
int surfaceID = object_heap_allocate( &driver_data->surface_heap ); |
object_surface_p obj_surface = SURFACE(surfaceID); |
if (NULL == obj_surface) |
{ |
vaStatus = VA_STATUS_ERROR_ALLOCATION_FAILED; |
break; |
} |
obj_surface->surface_id = surfaceID; |
surfaces[i] = surfaceID; |
} |
|
/* Error recovery */ |
if (VA_STATUS_SUCCESS != vaStatus) |
{ |
/* surfaces[i-1] was the last successful allocation */ |
for(; i--; ) |
{ |
object_surface_p obj_surface = SURFACE(surfaces[i]); |
surfaces[i] = VA_INVALID_SURFACE; |
ASSERT(obj_surface); |
object_heap_free( &driver_data->surface_heap, (object_base_p) obj_surface); |
} |
} |
|
return vaStatus; |
} |
|
VAStatus dummy_DestroySurfaces( |
VADriverContextP ctx, |
VASurfaceID *surface_list, |
int num_surfaces |
) |
{ |
INIT_DRIVER_DATA |
int i; |
for(i = num_surfaces; i--; ) |
{ |
object_surface_p obj_surface = SURFACE(surface_list[i]); |
ASSERT(obj_surface); |
object_heap_free( &driver_data->surface_heap, (object_base_p) obj_surface); |
} |
return VA_STATUS_SUCCESS; |
} |
|
VAStatus dummy_QueryImageFormats( |
VADriverContextP ctx, |
VAImageFormat *format_list, /* out */ |
int *num_formats /* out */ |
) |
{ |
/* TODO */ |
return VA_STATUS_SUCCESS; |
} |
|
VAStatus dummy_CreateImage( |
VADriverContextP ctx, |
VAImageFormat *format, |
int width, |
int height, |
VAImage *image /* out */ |
) |
{ |
/* TODO */ |
return VA_STATUS_SUCCESS; |
} |
|
VAStatus dummy_DeriveImage( |
VADriverContextP ctx, |
VASurfaceID surface, |
VAImage *image /* out */ |
) |
{ |
/* TODO */ |
return VA_STATUS_SUCCESS; |
} |
|
VAStatus dummy_DestroyImage( |
VADriverContextP ctx, |
VAImageID image |
) |
{ |
/* TODO */ |
return VA_STATUS_SUCCESS; |
} |
|
VAStatus dummy_SetImagePalette( |
VADriverContextP ctx, |
VAImageID image, |
unsigned char *palette |
) |
{ |
/* TODO */ |
return VA_STATUS_SUCCESS; |
} |
|
VAStatus dummy_GetImage( |
VADriverContextP ctx, |
VASurfaceID surface, |
int x, /* coordinates of the upper left source pixel */ |
int y, |
unsigned int width, /* width and height of the region */ |
unsigned int height, |
VAImageID image |
) |
{ |
/* TODO */ |
return VA_STATUS_SUCCESS; |
} |
|
|
VAStatus dummy_PutImage( |
VADriverContextP ctx, |
VASurfaceID surface, |
VAImageID image, |
int src_x, |
int src_y, |
unsigned int src_width, |
unsigned int src_height, |
int dest_x, |
int dest_y, |
unsigned int dest_width, |
unsigned int dest_height |
) |
{ |
/* TODO */ |
return VA_STATUS_SUCCESS; |
} |
|
VAStatus dummy_QuerySubpictureFormats( |
VADriverContextP ctx, |
VAImageFormat *format_list, /* out */ |
unsigned int *flags, /* out */ |
unsigned int *num_formats /* out */ |
) |
{ |
/* TODO */ |
return VA_STATUS_SUCCESS; |
} |
|
VAStatus dummy_CreateSubpicture( |
VADriverContextP ctx, |
VAImageID image, |
VASubpictureID *subpicture /* out */ |
) |
{ |
/* TODO */ |
return VA_STATUS_SUCCESS; |
} |
|
VAStatus dummy_DestroySubpicture( |
VADriverContextP ctx, |
VASubpictureID subpicture |
) |
{ |
/* TODO */ |
return VA_STATUS_SUCCESS; |
} |
|
VAStatus dummy_SetSubpictureImage( |
VADriverContextP ctx, |
VASubpictureID subpicture, |
VAImageID image |
) |
{ |
/* TODO */ |
return VA_STATUS_SUCCESS; |
} |
|
VAStatus dummy_SetSubpicturePalette( |
VADriverContextP ctx, |
VASubpictureID subpicture, |
/* |
* pointer to an array holding the palette data. The size of the array is |
* num_palette_entries * entry_bytes in size. The order of the components |
* in the palette is described by the component_order in VASubpicture struct |
*/ |
unsigned char *palette |
) |
{ |
/* TODO */ |
return VA_STATUS_SUCCESS; |
} |
|
VAStatus dummy_SetSubpictureChromakey( |
VADriverContextP ctx, |
VASubpictureID subpicture, |
unsigned int chromakey_min, |
unsigned int chromakey_max, |
unsigned int chromakey_mask |
) |
{ |
/* TODO */ |
return VA_STATUS_SUCCESS; |
} |
|
VAStatus dummy_SetSubpictureGlobalAlpha( |
VADriverContextP ctx, |
VASubpictureID subpicture, |
float global_alpha |
) |
{ |
/* TODO */ |
return VA_STATUS_SUCCESS; |
} |
|
|
VAStatus dummy_AssociateSubpicture( |
VADriverContextP ctx, |
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 |
) |
{ |
/* TODO */ |
return VA_STATUS_SUCCESS; |
} |
|
VAStatus dummy_DeassociateSubpicture( |
VADriverContextP ctx, |
VASubpictureID subpicture, |
VASurfaceID *target_surfaces, |
int num_surfaces |
) |
{ |
/* TODO */ |
return VA_STATUS_SUCCESS; |
} |
|
VAStatus dummy_CreateContext( |
VADriverContextP ctx, |
VAConfigID config_id, |
int picture_width, |
int picture_height, |
int flag, |
VASurfaceID *render_targets, |
int num_render_targets, |
VAContextID *context /* out */ |
) |
{ |
INIT_DRIVER_DATA |
VAStatus vaStatus = VA_STATUS_SUCCESS; |
object_config_p obj_config; |
int i; |
|
obj_config = CONFIG(config_id); |
if (NULL == obj_config) |
{ |
vaStatus = VA_STATUS_ERROR_INVALID_CONFIG; |
return vaStatus; |
} |
|
/* Validate flag */ |
/* Validate picture dimensions */ |
|
int contextID = object_heap_allocate( &driver_data->context_heap ); |
object_context_p obj_context = CONTEXT(contextID); |
if (NULL == obj_context) |
{ |
vaStatus = VA_STATUS_ERROR_ALLOCATION_FAILED; |
return vaStatus; |
} |
|
obj_context->context_id = contextID; |
*context = contextID; |
obj_context->current_render_target = -1; |
obj_context->config_id = config_id; |
obj_context->picture_width = picture_width; |
obj_context->picture_height = picture_height; |
obj_context->num_render_targets = num_render_targets; |
obj_context->render_targets = (VASurfaceID *) malloc(num_render_targets * sizeof(VASurfaceID)); |
if (obj_context->render_targets == NULL) |
{ |
vaStatus = VA_STATUS_ERROR_ALLOCATION_FAILED; |
return vaStatus; |
} |
|
for(i = 0; i < num_render_targets; i++) |
{ |
if (NULL == SURFACE(render_targets[i])) |
{ |
vaStatus = VA_STATUS_ERROR_INVALID_SURFACE; |
break; |
} |
obj_context->render_targets[i] = render_targets[i]; |
} |
obj_context->flags = flag; |
|
/* Error recovery */ |
if (VA_STATUS_SUCCESS != vaStatus) |
{ |
obj_context->context_id = -1; |
obj_context->config_id = -1; |
free(obj_context->render_targets); |
obj_context->render_targets = NULL; |
obj_context->num_render_targets = 0; |
obj_context->flags = 0; |
object_heap_free( &driver_data->context_heap, (object_base_p) obj_context); |
} |
|
return vaStatus; |
} |
|
|
VAStatus dummy_DestroyContext( |
VADriverContextP ctx, |
VAContextID context |
) |
{ |
INIT_DRIVER_DATA |
object_context_p obj_context = CONTEXT(context); |
ASSERT(obj_context); |
|
obj_context->context_id = -1; |
obj_context->config_id = -1; |
obj_context->picture_width = 0; |
obj_context->picture_height = 0; |
if (obj_context->render_targets) |
{ |
free(obj_context->render_targets); |
} |
obj_context->render_targets = NULL; |
obj_context->num_render_targets = 0; |
obj_context->flags = 0; |
|
obj_context->current_render_target = -1; |
|
object_heap_free( &driver_data->context_heap, (object_base_p) obj_context); |
|
return VA_STATUS_SUCCESS; |
} |
|
|
|
static VAStatus dummy__allocate_buffer(object_buffer_p obj_buffer, int size) |
{ |
VAStatus vaStatus = VA_STATUS_SUCCESS; |
|
obj_buffer->buffer_data = realloc(obj_buffer->buffer_data, size); |
if (NULL == obj_buffer->buffer_data) |
{ |
vaStatus = VA_STATUS_ERROR_ALLOCATION_FAILED; |
} |
return vaStatus; |
} |
|
VAStatus dummy_CreateBuffer( |
VADriverContextP ctx, |
VAContextID context, /* in */ |
VABufferType type, /* in */ |
unsigned int size, /* in */ |
unsigned int num_elements, /* in */ |
void *data, /* in */ |
VABufferID *buf_id /* out */ |
) |
{ |
INIT_DRIVER_DATA |
VAStatus vaStatus = VA_STATUS_SUCCESS; |
int bufferID; |
object_buffer_p obj_buffer; |
|
/* Validate type */ |
switch (type) |
{ |
case VAPictureParameterBufferType: |
case VAIQMatrixBufferType: |
case VABitPlaneBufferType: |
case VASliceGroupMapBufferType: |
case VASliceParameterBufferType: |
case VASliceDataBufferType: |
case VAMacroblockParameterBufferType: |
case VAResidualDataBufferType: |
case VADeblockingParameterBufferType: |
case VAImageBufferType: |
/* Ok */ |
break; |
default: |
vaStatus = VA_STATUS_ERROR_UNSUPPORTED_BUFFERTYPE; |
return vaStatus; |
} |
|
bufferID = object_heap_allocate( &driver_data->buffer_heap ); |
obj_buffer = BUFFER(bufferID); |
if (NULL == obj_buffer) |
{ |
vaStatus = VA_STATUS_ERROR_ALLOCATION_FAILED; |
return vaStatus; |
} |
|
obj_buffer->buffer_data = NULL; |
|
vaStatus = dummy__allocate_buffer(obj_buffer, size * num_elements); |
if (VA_STATUS_SUCCESS == vaStatus) |
{ |
obj_buffer->max_num_elements = num_elements; |
obj_buffer->num_elements = num_elements; |
if (data) |
{ |
memcpy(obj_buffer->buffer_data, data, size * num_elements); |
} |
} |
|
if (VA_STATUS_SUCCESS == vaStatus) |
{ |
*buf_id = bufferID; |
} |
|
return vaStatus; |
} |
|
|
VAStatus dummy_BufferSetNumElements( |
VADriverContextP ctx, |
VABufferID buf_id, /* in */ |
unsigned int num_elements /* in */ |
) |
{ |
INIT_DRIVER_DATA |
VAStatus vaStatus = VA_STATUS_SUCCESS; |
object_buffer_p obj_buffer = BUFFER(buf_id); |
ASSERT(obj_buffer); |
|
if ((num_elements < 0) || (num_elements > obj_buffer->max_num_elements)) |
{ |
vaStatus = VA_STATUS_ERROR_UNKNOWN; |
} |
if (VA_STATUS_SUCCESS == vaStatus) |
{ |
obj_buffer->num_elements = num_elements; |
} |
|
return vaStatus; |
} |
|
VAStatus dummy_MapBuffer( |
VADriverContextP ctx, |
VABufferID buf_id, /* in */ |
void **pbuf /* out */ |
) |
{ |
INIT_DRIVER_DATA |
VAStatus vaStatus = VA_STATUS_ERROR_UNKNOWN; |
object_buffer_p obj_buffer = BUFFER(buf_id); |
ASSERT(obj_buffer); |
if (NULL == obj_buffer) |
{ |
vaStatus = VA_STATUS_ERROR_INVALID_BUFFER; |
return vaStatus; |
} |
|
if (NULL != obj_buffer->buffer_data) |
{ |
*pbuf = obj_buffer->buffer_data; |
vaStatus = VA_STATUS_SUCCESS; |
} |
return vaStatus; |
} |
|
VAStatus dummy_UnmapBuffer( |
VADriverContextP ctx, |
VABufferID buf_id /* in */ |
) |
{ |
/* Do nothing */ |
return VA_STATUS_SUCCESS; |
} |
|
static void dummy__destroy_buffer(struct dummy_driver_data *driver_data, object_buffer_p obj_buffer) |
{ |
if (NULL != obj_buffer->buffer_data) |
{ |
free(obj_buffer->buffer_data); |
obj_buffer->buffer_data = NULL; |
} |
|
object_heap_free( &driver_data->buffer_heap, (object_base_p) obj_buffer); |
} |
|
VAStatus dummy_DestroyBuffer( |
VADriverContextP ctx, |
VABufferID buffer_id |
) |
{ |
INIT_DRIVER_DATA |
object_buffer_p obj_buffer = BUFFER(buffer_id); |
ASSERT(obj_buffer); |
|
dummy__destroy_buffer(driver_data, obj_buffer); |
return VA_STATUS_SUCCESS; |
} |
|
VAStatus dummy_BeginPicture( |
VADriverContextP ctx, |
VAContextID context, |
VASurfaceID render_target |
) |
{ |
INIT_DRIVER_DATA |
VAStatus vaStatus = VA_STATUS_SUCCESS; |
object_context_p obj_context; |
object_surface_p obj_surface; |
|
obj_context = CONTEXT(context); |
ASSERT(obj_context); |
|
obj_surface = SURFACE(render_target); |
ASSERT(obj_surface); |
|
obj_context->current_render_target = obj_surface->base.id; |
|
return vaStatus; |
} |
|
VAStatus dummy_RenderPicture( |
VADriverContextP ctx, |
VAContextID context, |
VABufferID *buffers, |
int num_buffers |
) |
{ |
INIT_DRIVER_DATA |
VAStatus vaStatus = VA_STATUS_SUCCESS; |
object_context_p obj_context; |
object_surface_p obj_surface; |
int i; |
|
obj_context = CONTEXT(context); |
ASSERT(obj_context); |
|
obj_surface = SURFACE(obj_context->current_render_target); |
ASSERT(obj_surface); |
|
/* verify that we got valid buffer references */ |
for(i = 0; i < num_buffers; i++) |
{ |
object_buffer_p obj_buffer = BUFFER(buffers[i]); |
ASSERT(obj_buffer); |
if (NULL == obj_buffer) |
{ |
vaStatus = VA_STATUS_ERROR_INVALID_BUFFER; |
break; |
} |
} |
|
/* Release buffers */ |
for(i = 0; i < num_buffers; i++) |
{ |
object_buffer_p obj_buffer = BUFFER(buffers[i]); |
ASSERT(obj_buffer); |
dummy__destroy_buffer(driver_data, obj_buffer); |
} |
|
return vaStatus; |
} |
|
VAStatus dummy_EndPicture( |
VADriverContextP ctx, |
VAContextID context |
) |
{ |
INIT_DRIVER_DATA |
VAStatus vaStatus = VA_STATUS_SUCCESS; |
object_context_p obj_context; |
object_surface_p obj_surface; |
|
obj_context = CONTEXT(context); |
ASSERT(obj_context); |
|
obj_surface = SURFACE(obj_context->current_render_target); |
ASSERT(obj_surface); |
|
// For now, assume that we are done with rendering right away |
obj_context->current_render_target = -1; |
|
return vaStatus; |
} |
|
|
VAStatus dummy_SyncSurface( |
VADriverContextP ctx, |
VASurfaceID render_target |
) |
{ |
INIT_DRIVER_DATA |
VAStatus vaStatus = VA_STATUS_SUCCESS; |
object_surface_p obj_surface; |
|
obj_surface = SURFACE(render_target); |
ASSERT(obj_surface); |
|
return vaStatus; |
} |
|
VAStatus dummy_QuerySurfaceStatus( |
VADriverContextP ctx, |
VASurfaceID render_target, |
VASurfaceStatus *status /* out */ |
) |
{ |
INIT_DRIVER_DATA |
VAStatus vaStatus = VA_STATUS_SUCCESS; |
object_surface_p obj_surface; |
|
obj_surface = SURFACE(render_target); |
ASSERT(obj_surface); |
|
*status = VASurfaceReady; |
|
return vaStatus; |
} |
|
VAStatus dummy_PutSurface( |
VADriverContextP ctx, |
VASurfaceID surface, |
void *draw, /* X Drawable */ |
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 */ |
) |
{ |
/* TODO */ |
return VA_STATUS_ERROR_UNKNOWN; |
} |
|
/* |
* Query display attributes |
* The caller must provide a "attr_list" array that can hold at |
* least vaMaxNumDisplayAttributes() entries. The actual number of attributes |
* returned in "attr_list" is returned in "num_attributes". |
*/ |
VAStatus dummy_QueryDisplayAttributes ( |
VADriverContextP ctx, |
VADisplayAttribute *attr_list, /* out */ |
int *num_attributes /* out */ |
) |
{ |
/* TODO */ |
return VA_STATUS_ERROR_UNKNOWN; |
} |
|
/* |
* Get display attributes |
* This function returns the current attribute values in "attr_list". |
* Only attributes returned with VA_DISPLAY_ATTRIB_GETTABLE set in the "flags" field |
* from vaQueryDisplayAttributes() can have their values retrieved. |
*/ |
VAStatus dummy_GetDisplayAttributes ( |
VADriverContextP ctx, |
VADisplayAttribute *attr_list, /* in/out */ |
int num_attributes |
) |
{ |
/* TODO */ |
return VA_STATUS_ERROR_UNKNOWN; |
} |
|
/* |
* Set display attributes |
* Only attributes returned with VA_DISPLAY_ATTRIB_SETTABLE set in the "flags" field |
* from vaQueryDisplayAttributes() can be set. If the attribute is not settable or |
* the value is out of range, the function returns VA_STATUS_ERROR_ATTR_NOT_SUPPORTED |
*/ |
VAStatus dummy_SetDisplayAttributes ( |
VADriverContextP ctx, |
VADisplayAttribute *attr_list, |
int num_attributes |
) |
{ |
/* TODO */ |
return VA_STATUS_ERROR_UNKNOWN; |
} |
|
|
VAStatus dummy_BufferInfo( |
VADriverContextP ctx, |
VABufferID buf_id, /* in */ |
VABufferType *type, /* out */ |
unsigned int *size, /* out */ |
unsigned int *num_elements /* out */ |
) |
{ |
/* TODO */ |
return VA_STATUS_ERROR_UNIMPLEMENTED; |
} |
|
|
|
VAStatus dummy_LockSurface( |
VADriverContextP ctx, |
VASurfaceID surface, |
unsigned int *fourcc, /* following are output argument */ |
unsigned int *luma_stride, |
unsigned int *chroma_u_stride, |
unsigned int *chroma_v_stride, |
unsigned int *luma_offset, |
unsigned int *chroma_u_offset, |
unsigned int *chroma_v_offset, |
unsigned int *buffer_name, |
void **buffer |
) |
{ |
/* TODO */ |
return VA_STATUS_ERROR_UNIMPLEMENTED; |
} |
|
VAStatus dummy_UnlockSurface( |
VADriverContextP ctx, |
VASurfaceID surface |
) |
{ |
/* TODO */ |
return VA_STATUS_ERROR_UNIMPLEMENTED; |
} |
|
VAStatus dummy_Terminate( VADriverContextP ctx ) |
{ |
INIT_DRIVER_DATA |
object_buffer_p obj_buffer; |
object_config_p obj_config; |
object_heap_iterator iter; |
|
/* Clean up left over buffers */ |
obj_buffer = (object_buffer_p) object_heap_first( &driver_data->buffer_heap, &iter); |
while (obj_buffer) |
{ |
dummy__information_message("vaTerminate: bufferID %08x still allocated, destroying\n", obj_buffer->base.id); |
dummy__destroy_buffer(driver_data, obj_buffer); |
obj_buffer = (object_buffer_p) object_heap_next( &driver_data->buffer_heap, &iter); |
} |
object_heap_destroy( &driver_data->buffer_heap ); |
|
/* TODO cleanup */ |
object_heap_destroy( &driver_data->surface_heap ); |
|
/* TODO cleanup */ |
object_heap_destroy( &driver_data->context_heap ); |
|
/* Clean up configIDs */ |
obj_config = (object_config_p) object_heap_first( &driver_data->config_heap, &iter); |
while (obj_config) |
{ |
object_heap_free( &driver_data->config_heap, (object_base_p) obj_config); |
obj_config = (object_config_p) object_heap_next( &driver_data->config_heap, &iter); |
} |
object_heap_destroy( &driver_data->config_heap ); |
|
free(ctx->pDriverData); |
ctx->pDriverData = NULL; |
|
return VA_STATUS_SUCCESS; |
} |
|
VAStatus VA_DRIVER_INIT_FUNC( VADriverContextP ctx ) |
{ |
struct VADriverVTable * const vtable = ctx->vtable; |
int result; |
struct dummy_driver_data *driver_data; |
|
ctx->version_major = VA_MAJOR_VERSION; |
ctx->version_minor = VA_MINOR_VERSION; |
ctx->max_profiles = DUMMY_MAX_PROFILES; |
ctx->max_entrypoints = DUMMY_MAX_ENTRYPOINTS; |
ctx->max_attributes = DUMMY_MAX_CONFIG_ATTRIBUTES; |
ctx->max_image_formats = DUMMY_MAX_IMAGE_FORMATS; |
ctx->max_subpic_formats = DUMMY_MAX_SUBPIC_FORMATS; |
ctx->max_display_attributes = DUMMY_MAX_DISPLAY_ATTRIBUTES; |
ctx->str_vendor = DUMMY_STR_VENDOR; |
|
vtable->vaTerminate = dummy_Terminate; |
vtable->vaQueryConfigEntrypoints = dummy_QueryConfigEntrypoints; |
vtable->vaQueryConfigProfiles = dummy_QueryConfigProfiles; |
vtable->vaQueryConfigEntrypoints = dummy_QueryConfigEntrypoints; |
vtable->vaQueryConfigAttributes = dummy_QueryConfigAttributes; |
vtable->vaCreateConfig = dummy_CreateConfig; |
vtable->vaDestroyConfig = dummy_DestroyConfig; |
vtable->vaGetConfigAttributes = dummy_GetConfigAttributes; |
vtable->vaCreateSurfaces = dummy_CreateSurfaces; |
vtable->vaDestroySurfaces = dummy_DestroySurfaces; |
vtable->vaCreateContext = dummy_CreateContext; |
vtable->vaDestroyContext = dummy_DestroyContext; |
vtable->vaCreateBuffer = dummy_CreateBuffer; |
vtable->vaBufferSetNumElements = dummy_BufferSetNumElements; |
vtable->vaMapBuffer = dummy_MapBuffer; |
vtable->vaUnmapBuffer = dummy_UnmapBuffer; |
vtable->vaDestroyBuffer = dummy_DestroyBuffer; |
vtable->vaBeginPicture = dummy_BeginPicture; |
vtable->vaRenderPicture = dummy_RenderPicture; |
vtable->vaEndPicture = dummy_EndPicture; |
vtable->vaSyncSurface = dummy_SyncSurface; |
vtable->vaQuerySurfaceStatus = dummy_QuerySurfaceStatus; |
vtable->vaPutSurface = dummy_PutSurface; |
vtable->vaQueryImageFormats = dummy_QueryImageFormats; |
vtable->vaCreateImage = dummy_CreateImage; |
vtable->vaDeriveImage = dummy_DeriveImage; |
vtable->vaDestroyImage = dummy_DestroyImage; |
vtable->vaSetImagePalette = dummy_SetImagePalette; |
vtable->vaGetImage = dummy_GetImage; |
vtable->vaPutImage = dummy_PutImage; |
vtable->vaQuerySubpictureFormats = dummy_QuerySubpictureFormats; |
vtable->vaCreateSubpicture = dummy_CreateSubpicture; |
vtable->vaDestroySubpicture = dummy_DestroySubpicture; |
vtable->vaSetSubpictureImage = dummy_SetSubpictureImage; |
vtable->vaSetSubpictureChromakey = dummy_SetSubpictureChromakey; |
vtable->vaSetSubpictureGlobalAlpha = dummy_SetSubpictureGlobalAlpha; |
vtable->vaAssociateSubpicture = dummy_AssociateSubpicture; |
vtable->vaDeassociateSubpicture = dummy_DeassociateSubpicture; |
vtable->vaQueryDisplayAttributes = dummy_QueryDisplayAttributes; |
vtable->vaGetDisplayAttributes = dummy_GetDisplayAttributes; |
vtable->vaSetDisplayAttributes = dummy_SetDisplayAttributes; |
vtable->vaLockSurface = dummy_LockSurface; |
vtable->vaUnlockSurface = dummy_UnlockSurface; |
vtable->vaBufferInfo = dummy_BufferInfo; |
|
driver_data = (struct dummy_driver_data *) malloc( sizeof(*driver_data) ); |
ctx->pDriverData = (void *) driver_data; |
|
result = object_heap_init( &driver_data->config_heap, sizeof(struct object_config), CONFIG_ID_OFFSET ); |
ASSERT( result == 0 ); |
|
result = object_heap_init( &driver_data->context_heap, sizeof(struct object_context), CONTEXT_ID_OFFSET ); |
ASSERT( result == 0 ); |
|
result = object_heap_init( &driver_data->surface_heap, sizeof(struct object_surface), SURFACE_ID_OFFSET ); |
ASSERT( result == 0 ); |
|
result = object_heap_init( &driver_data->buffer_heap, sizeof(struct object_buffer), BUFFER_ID_OFFSET ); |
ASSERT( result == 0 ); |
|
|
return VA_STATUS_SUCCESS; |
} |
|