AlexIndustrial/mesa
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

vdpau: make indention and formating more sane

Browse Source
This commit is contained in:
Christian König
2011-03-18 01:06:41 +01:00
parent b90f569a0f
commit 49f4aff75c
11 changed files with 594 additions and 637 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/gallium/state_trackers/vdpau/bitmap.c
+28 -29
View File
@@ -30,46 +30,45 @@
#include <util/u_debug.h>
VdpStatus
vlVdpBitmapSurfaceCreate( VdpDevice device,
VdpRGBAFormat rgba_format,
uint32_t width, uint32_t height,
VdpBool frequently_accessed,
VdpBitmapSurface *surface)
vlVdpBitmapSurfaceCreate(VdpDevice device,
VdpRGBAFormat rgba_format,
uint32_t width, uint32_t height,
VdpBool frequently_accessed,
VdpBitmapSurface *surface)
{
debug_printf("[VDPAU] Creating a bitmap surface\n");
if (!surface)
return VDP_STATUS_INVALID_POINTER;
debug_printf("[VDPAU] Creating a bitmap surface\n");
if (!surface)
return VDP_STATUS_INVALID_POINTER;
return VDP_STATUS_NO_IMPLEMENTATION;
return VDP_STATUS_NO_IMPLEMENTATION;
}
VdpStatus
vlVdpBitmapSurfaceDestroy ( VdpBitmapSurface surface )
vlVdpBitmapSurfaceDestroy(VdpBitmapSurface surface)
{
return VDP_STATUS_NO_IMPLEMENTATION;
return VDP_STATUS_NO_IMPLEMENTATION;
}
VdpStatus
vlVdpBitmapSurfaceGetParameters ( VdpBitmapSurface surface,
VdpRGBAFormat *rgba_format,
uint32_t *width, uint32_t *height,
VdpBool *frequently_accessed)
vlVdpBitmapSurfaceGetParameters(VdpBitmapSurface surface,
VdpRGBAFormat *rgba_format,
uint32_t *width, uint32_t *height,
VdpBool *frequently_accessed)
{
if (!(rgba_format && width && height && frequently_accessed))
return VDP_STATUS_INVALID_POINTER;
return VDP_STATUS_NO_IMPLEMENTATION;
if (!(rgba_format && width && height && frequently_accessed))
return VDP_STATUS_INVALID_POINTER;
return VDP_STATUS_NO_IMPLEMENTATION;
}
VdpStatus
vlVdpBitmapSurfacePutBitsNative ( VdpBitmapSurface surface,
void const *const *source_data,
uint32_t const *source_pitches,
VdpRect const *destination_rect )
vlVdpBitmapSurfacePutBitsNative(VdpBitmapSurface surface,
void const *const *source_data,
uint32_t const *source_pitches,
VdpRect const *destination_rect )
{
if (!(source_data && source_pitches && destination_rect))
return VDP_STATUS_INVALID_POINTER;
return VDP_STATUS_NO_IMPLEMENTATION;
}
if (!(source_data && source_pitches && destination_rect))
return VDP_STATUS_INVALID_POINTER;
return VDP_STATUS_NO_IMPLEMENTATION;
}
src/gallium/state_trackers/vdpau/decode.c
+177 -186
View File
@@ -33,280 +33,271 @@
#include <util/u_debug.h>
VdpStatus
vlVdpDecoderCreate ( VdpDevice device,
VdpDecoderProfile profile,
uint32_t width, uint32_t height,
uint32_t max_references,
VdpDecoder *decoder
)
vlVdpDecoderCreate(VdpDevice device,
VdpDecoderProfile profile,
uint32_t width, uint32_t height,
uint32_t max_references,
VdpDecoder *decoder)
{
enum pipe_video_profile p_profile = PIPE_VIDEO_PROFILE_UNKNOWN;
VdpStatus ret = VDP_STATUS_OK;
vlVdpDecoder *vldecoder = NULL;
enum pipe_video_profile p_profile = PIPE_VIDEO_PROFILE_UNKNOWN;
VdpStatus ret = VDP_STATUS_OK;
vlVdpDecoder *vldecoder = NULL;
debug_printf("[VDPAU] Creating decoder\n");
debug_printf("[VDPAU] Creating decoder\n");
if (!decoder)
return VDP_STATUS_INVALID_POINTER;
if (!decoder)
return VDP_STATUS_INVALID_POINTER;
if (!(width && height))
return VDP_STATUS_INVALID_VALUE;
if (!(width && height))
return VDP_STATUS_INVALID_VALUE;
vlVdpDevice *dev = vlGetDataHTAB(device);
if (!dev) {
if (!dev) {
ret = VDP_STATUS_INVALID_HANDLE;
goto inv_device;
}
vldecoder = CALLOC(1,sizeof(vlVdpDecoder));
if (!vldecoder) {
ret = VDP_STATUS_RESOURCES;
goto no_decoder;
if (!vldecoder) {
ret = VDP_STATUS_RESOURCES;
goto no_decoder;
}
p_profile = ProfileToPipe(profile);
if (p_profile == PIPE_VIDEO_PROFILE_UNKNOWN) {
ret = VDP_STATUS_INVALID_DECODER_PROFILE;
goto inv_profile;
ret = VDP_STATUS_INVALID_DECODER_PROFILE;
goto inv_profile;
}
// TODO: Define max_references. Used mainly for H264
// TODO: Define max_references. Used mainly for H264
vldecoder->profile = p_profile;
vldecoder->height = height;
vldecoder->width = width;
vldecoder->device = dev;
vldecoder->vctx = NULL;
vldecoder->profile = p_profile;
vldecoder->height = height;
vldecoder->width = width;
vldecoder->device = dev;
vldecoder->vctx = NULL;
*decoder = vlAddDataHTAB(vldecoder);
if (*decoder == 0) {
*decoder = vlAddDataHTAB(vldecoder);
if (*decoder == 0) {
ret = VDP_STATUS_ERROR;
goto no_handle;
}
debug_printf("[VDPAU] Decoder created succesfully\n");
}
debug_printf("[VDPAU] Decoder created succesfully\n");
return VDP_STATUS_OK;
return VDP_STATUS_OK;
no_handle:
FREE(vldecoder);
inv_profile:
no_screen:
no_decoder:
inv_device:
no_handle:
FREE(vldecoder);
inv_profile:
no_screen:
no_decoder:
inv_device:
return ret;
}
VdpStatus
vlVdpDecoderDestroy (VdpDecoder decoder
)
vlVdpDecoderDestroy(VdpDecoder decoder)
{
debug_printf("[VDPAU] Destroying decoder\n");
vlVdpDecoder *vldecoder;
debug_printf("[VDPAU] Destroying decoder\n");
vlVdpDecoder *vldecoder;
vldecoder = (vlVdpDecoder *)vlGetDataHTAB(decoder);
if (!vldecoder) {
vldecoder = (vlVdpDecoder *)vlGetDataHTAB(decoder);
if (!vldecoder) {
return VDP_STATUS_INVALID_HANDLE;
}
}
if (vldecoder->vctx)
{
if (vldecoder->vctx->vscreen)
vl_screen_destroy(vldecoder->vctx->vscreen);
}
if (vldecoder->vctx) {
if (vldecoder->vctx->vscreen)
vl_screen_destroy(vldecoder->vctx->vscreen);
}
if (vldecoder->vctx)
vl_video_destroy(vldecoder->vctx);
if (vldecoder->vctx)
vl_video_destroy(vldecoder->vctx);
FREE(vldecoder);
FREE(vldecoder);
return VDP_STATUS_OK;
return VDP_STATUS_OK;
}
VdpStatus
vlVdpCreateSurfaceTarget (vlVdpDecoder *vldecoder,
vlVdpSurface *vlsurf
)
vlVdpCreateSurfaceTarget(vlVdpDecoder *vldecoder, vlVdpSurface *vlsurf)
{
struct pipe_surface surf_template;
struct pipe_resource tmplt;
struct pipe_resource *surf_tex;
struct pipe_video_context *vctx;
struct pipe_surface surf_template;
struct pipe_resource tmplt;
struct pipe_resource *surf_tex;
struct pipe_video_context *vctx;
debug_printf("[VDPAU] Creating surface\n");
debug_printf("[VDPAU] Creating surface\n");
if(!(vldecoder && vlsurf))
return VDP_STATUS_INVALID_POINTER;
if(!(vldecoder && vlsurf))
return VDP_STATUS_INVALID_POINTER;
vctx = vldecoder->vctx->vpipe;
vctx = vldecoder->vctx->vpipe;
memset(&tmplt, 0, sizeof(struct pipe_resource));
tmplt.target = PIPE_TEXTURE_2D;
tmplt.format = vctx->get_param(vctx,PIPE_CAP_DECODE_TARGET_PREFERRED_FORMAT);
tmplt.last_level = 0;
memset(&tmplt, 0, sizeof(struct pipe_resource));
tmplt.target = PIPE_TEXTURE_2D;
tmplt.format = vctx->get_param(vctx,PIPE_CAP_DECODE_TARGET_PREFERRED_FORMAT);
tmplt.last_level = 0;
if (vctx->is_format_supported(vctx, tmplt.format,
PIPE_BIND_SAMPLER_VIEW | PIPE_BIND_RENDER_TARGET,
PIPE_TEXTURE_GEOM_NON_POWER_OF_TWO)) {
if (vctx->is_format_supported(vctx, tmplt.format,
PIPE_BIND_SAMPLER_VIEW | PIPE_BIND_RENDER_TARGET,
PIPE_TEXTURE_GEOM_NON_POWER_OF_TWO)) {
tmplt.width0 = vlsurf->width;
tmplt.height0 = vlsurf->height;
}
else {
} else {
assert(vctx->is_format_supported(vctx, tmplt.format,
PIPE_BIND_SAMPLER_VIEW | PIPE_BIND_RENDER_TARGET,
PIPE_TEXTURE_GEOM_NON_SQUARE));
tmplt.width0 = util_next_power_of_two(vlsurf->width);
tmplt.height0 = util_next_power_of_two(vlsurf->height);
}
}
tmplt.depth0 = 1;
tmplt.usage = PIPE_USAGE_DEFAULT;
tmplt.bind = PIPE_BIND_SAMPLER_VIEW | PIPE_BIND_RENDER_TARGET;
tmplt.flags = 0;
tmplt.depth0 = 1;
tmplt.usage = PIPE_USAGE_DEFAULT;
tmplt.bind = PIPE_BIND_SAMPLER_VIEW | PIPE_BIND_RENDER_TARGET;
tmplt.flags = 0;
surf_tex = vctx->screen->resource_create(vctx->screen, &tmplt);
surf_tex = vctx->screen->resource_create(vctx->screen, &tmplt);
memset(&surf_template, 0, sizeof(surf_template));
surf_template.format = surf_tex->format;
surf_template.usage = PIPE_BIND_SAMPLER_VIEW | PIPE_BIND_RENDER_TARGET;
vlsurf->psurface = vctx->create_surface(vctx->screen, surf_tex, &surf_template);
memset(&surf_template, 0, sizeof(surf_template));
surf_template.format = surf_tex->format;
surf_template.usage = PIPE_BIND_SAMPLER_VIEW | PIPE_BIND_RENDER_TARGET;
vlsurf->psurface = vctx->create_surface(vctx->screen, surf_tex, &surf_template);
pipe_resource_reference(&surf_tex, NULL);
pipe_resource_reference(&surf_tex, NULL);
if (!vlsurf->psurface)
return VDP_STATUS_RESOURCES;
debug_printf("[VDPAU] Done creating surface\n");
if (!vlsurf->psurface)
return VDP_STATUS_RESOURCES;
debug_printf("[VDPAU] Done creating surface\n");
return VDP_STATUS_OK;
return VDP_STATUS_OK;
}
VdpStatus
vlVdpDecoderRenderMpeg2 (vlVdpDecoder *vldecoder,
vlVdpSurface *vlsurf,
VdpPictureInfoMPEG1Or2 *picture_info,
uint32_t bitstream_buffer_count,
VdpBitstreamBuffer const *bitstream_buffers
)
vlVdpDecoderRenderMpeg2(vlVdpDecoder *vldecoder,
vlVdpSurface *vlsurf,
VdpPictureInfoMPEG1Or2 *picture_info,
uint32_t bitstream_buffer_count,
VdpBitstreamBuffer const *bitstream_buffers)
{
struct pipe_video_context *vpipe;
vlVdpSurface *t_vdp_surf;
vlVdpSurface *p_vdp_surf;
vlVdpSurface *f_vdp_surf;
struct pipe_surface *t_surf;
struct pipe_surface *p_surf;
struct pipe_surface *f_surf;
uint32_t num_macroblocks;
struct pipe_mpeg12_macroblock *pipe_macroblocks;
VdpStatus ret;
struct pipe_video_context *vpipe;
vlVdpSurface *t_vdp_surf;
vlVdpSurface *p_vdp_surf;
vlVdpSurface *f_vdp_surf;
struct pipe_surface *t_surf;
struct pipe_surface *p_surf;
struct pipe_surface *f_surf;
uint32_t num_macroblocks;
struct pipe_mpeg12_macroblock *pipe_macroblocks;
VdpStatus ret;
debug_printf("[VDPAU] Decoding MPEG2\n");
debug_printf("[VDPAU] Decoding MPEG2\n");
t_vdp_surf = vlsurf;
t_vdp_surf = vlsurf;
/* if surfaces equals VDP_STATUS_INVALID_HANDLE, they are not used */
if (picture_info->backward_reference == VDP_INVALID_HANDLE)
p_vdp_surf = NULL;
else {
p_vdp_surf = (vlVdpSurface *)vlGetDataHTAB(picture_info->backward_reference);
if (!p_vdp_surf)
return VDP_STATUS_INVALID_HANDLE;
}
/* if surfaces equals VDP_STATUS_INVALID_HANDLE, they are not used */
if (picture_info->backward_reference == VDP_INVALID_HANDLE)
p_vdp_surf = NULL;
else {
p_vdp_surf = (vlVdpSurface *)vlGetDataHTAB(picture_info->backward_reference);
if (!p_vdp_surf)
return VDP_STATUS_INVALID_HANDLE;
}
if (picture_info->forward_reference == VDP_INVALID_HANDLE)
f_vdp_surf = NULL;
else {
f_vdp_surf = (vlVdpSurface *)vlGetDataHTAB(picture_info->forward_reference);
if (!f_vdp_surf)
return VDP_STATUS_INVALID_HANDLE;
}
if (picture_info->forward_reference == VDP_INVALID_HANDLE)
f_vdp_surf = NULL;
else {
f_vdp_surf = (vlVdpSurface *)vlGetDataHTAB(picture_info->forward_reference);
if (!f_vdp_surf)
return VDP_STATUS_INVALID_HANDLE;
}
if (f_vdp_surf == VDP_INVALID_HANDLE) f_vdp_surf = NULL;
if (f_vdp_surf == VDP_INVALID_HANDLE) f_vdp_surf = NULL;
ret = vlVdpCreateSurfaceTarget(vldecoder,t_vdp_surf);
ret = vlVdpCreateSurfaceTarget(vldecoder,t_vdp_surf);
vpipe = vldecoder->vctx->vpipe;
vpipe = vldecoder->vctx->vpipe;
if (vlVdpMPEG2BitstreamToMacroblock(vpipe->screen, bitstream_buffers, bitstream_buffer_count,
&num_macroblocks, &pipe_macroblocks))
{
debug_printf("[VDPAU] Error in frame-header. Skipping.\n");
if (vlVdpMPEG2BitstreamToMacroblock(vpipe->screen, bitstream_buffers, bitstream_buffer_count,
&num_macroblocks, &pipe_macroblocks))
{
debug_printf("[VDPAU] Error in frame-header. Skipping.\n");
ret = VDP_STATUS_OK;
goto skip_frame;
}
ret = VDP_STATUS_OK;
goto skip_frame;
}
vpipe->set_decode_target(vpipe,t_surf);
vpipe->decode_macroblocks(vpipe, p_surf, f_surf, num_macroblocks,
(struct pipe_macroblock *)pipe_macroblocks, NULL);
vpipe->set_decode_target(vpipe,t_surf);
vpipe->decode_macroblocks(vpipe, p_surf, f_surf, num_macroblocks, (struct pipe_macroblock *)pipe_macroblocks, NULL);
skip_frame:
return ret;
skip_frame:
return ret;
}
VdpStatus
vlVdpDecoderRender (VdpDecoder decoder,
VdpVideoSurface target,
VdpPictureInfo const *picture_info,
uint32_t bitstream_buffer_count,
VdpBitstreamBuffer const *bitstream_buffers
)
vlVdpDecoderRender(VdpDecoder decoder,
VdpVideoSurface target,
VdpPictureInfo const *picture_info,
uint32_t bitstream_buffer_count,
VdpBitstreamBuffer const *bitstream_buffers)
{
vlVdpDecoder *vldecoder;
vlVdpSurface *vlsurf;
struct vl_screen *vscreen;
VdpStatus ret;
debug_printf("[VDPAU] Decoding\n");
vlVdpDecoder *vldecoder;
vlVdpSurface *vlsurf;
struct vl_screen *vscreen;
VdpStatus ret;
if (!(picture_info && bitstream_buffers))
return VDP_STATUS_INVALID_POINTER;
debug_printf("[VDPAU] Decoding\n");
if (!(picture_info && bitstream_buffers))
return VDP_STATUS_INVALID_POINTER;
vldecoder = (vlVdpDecoder *)vlGetDataHTAB(decoder);
if (!vldecoder)
return VDP_STATUS_INVALID_HANDLE;
vldecoder = (vlVdpDecoder *)vlGetDataHTAB(decoder);
if (!vldecoder)
return VDP_STATUS_INVALID_HANDLE;
vlsurf = (vlVdpSurface *)vlGetDataHTAB(target);
if (!vlsurf)
return VDP_STATUS_INVALID_HANDLE;
vlsurf = (vlVdpSurface *)vlGetDataHTAB(target);
if (!vlsurf)
return VDP_STATUS_INVALID_HANDLE;
if (vlsurf->device != vldecoder->device)
return VDP_STATUS_HANDLE_DEVICE_MISMATCH;
if (vlsurf->device != vldecoder->device)
return VDP_STATUS_HANDLE_DEVICE_MISMATCH;
/* Test doesn't make sence */
/*if (vlsurf->chroma_format != vldecoder->chroma_format)
return VDP_STATUS_INVALID_CHROMA_TYPE;*/
/* Test doesn't make sence */
/*if (vlsurf->chroma_format != vldecoder->chroma_format)
return VDP_STATUS_INVALID_CHROMA_TYPE;*/
vscreen = vl_screen_create(vldecoder->device->display, vldecoder->device->screen);
if (!vscreen)
return VDP_STATUS_RESOURCES;
vscreen = vl_screen_create(vldecoder->device->display, vldecoder->device->screen);
if (!vscreen)
return VDP_STATUS_RESOURCES;
vldecoder->vctx = vl_video_create(vscreen, vldecoder->profile, vlsurf->chroma_format, vldecoder->width, vldecoder->height);
if (!vldecoder->vctx)
return VDP_STATUS_RESOURCES;
vldecoder->vctx = vl_video_create(vscreen, vldecoder->profile, vlsurf->chroma_format, vldecoder->width, vldecoder->height);
if (!vldecoder->vctx)
return VDP_STATUS_RESOURCES;
// TODO: Right now only mpeg2 is supported.
switch (vldecoder->vctx->vpipe->profile) {
case PIPE_VIDEO_PROFILE_MPEG2_SIMPLE:
case PIPE_VIDEO_PROFILE_MPEG2_MAIN:
ret = vlVdpDecoderRenderMpeg2(vldecoder,vlsurf,(VdpPictureInfoMPEG1Or2 *)picture_info,
bitstream_buffer_count,bitstream_buffers);
break;
default:
return VDP_STATUS_INVALID_DECODER_PROFILE;
}
assert(0);
// TODO: Right now only mpeg2 is supported.
switch (vldecoder->vctx->vpipe->profile) {
case PIPE_VIDEO_PROFILE_MPEG2_SIMPLE:
case PIPE_VIDEO_PROFILE_MPEG2_MAIN:
ret = vlVdpDecoderRenderMpeg2(vldecoder,vlsurf,(VdpPictureInfoMPEG1Or2 *)picture_info,
bitstream_buffer_count,bitstream_buffers);
break;
default:
return VDP_STATUS_INVALID_DECODER_PROFILE;
}
assert(0);
return ret;
return ret;
}
VdpStatus
vlVdpGenerateCSCMatrix(
VdpProcamp *procamp,
VdpColorStandard standard,
VdpCSCMatrix *csc_matrix)
vlVdpGenerateCSCMatrix(VdpProcamp *procamp,
VdpColorStandard standard,
VdpCSCMatrix *csc_matrix)
{
debug_printf("[VDPAU] Generating CSCMatrix\n");
if (!(csc_matrix && procamp))
return VDP_STATUS_INVALID_POINTER;
debug_printf("[VDPAU] Generating CSCMatrix\n");
if (!(csc_matrix && procamp))
return VDP_STATUS_INVALID_POINTER;
return VDP_STATUS_OK;
return VDP_STATUS_OK;
}
src/gallium/state_trackers/vdpau/device.c
+56 -59
View File
@@ -34,9 +34,10 @@
PUBLIC VdpStatus
vdp_imp_device_create_x11(Display *display, int screen, VdpDevice *device, VdpGetProcAddress **get_proc_address)
vdp_imp_device_create_x11(Display *display, int screen, VdpDevice *device,
VdpGetProcAddress **get_proc_address)
{
VdpStatus ret;
VdpStatus ret;
vlVdpDevice *dev = NULL;
if (!(display && device && get_proc_address))
@@ -67,7 +68,7 @@ vdp_imp_device_create_x11(Display *display, int screen, VdpDevice *device, VdpGe
ret = VDP_STATUS_ERROR;
goto no_handle;
}
*get_proc_address = &vlVdpGetProcAddress;
debug_printf("[VDPAU] Device created succesfully\n");
@@ -83,17 +84,18 @@ no_htab:
return ret;
}
PUBLIC VdpStatus
vlVdpPresentationQueueTargetCreateX11(VdpDevice device, Drawable drawable,VdpPresentationQueueTarget *target)
PUBLIC VdpStatus
vlVdpPresentationQueueTargetCreateX11(VdpDevice device, Drawable drawable,
VdpPresentationQueueTarget *target)
{
VdpStatus ret;
vlVdpPresentationQueueTarget *pqt = NULL;
debug_printf("[VDPAU] Creating PresentationQueueTarget\n");
if (!drawable)
return VDP_STATUS_INVALID_HANDLE;
vlVdpDevice *dev = vlGetDataHTAB(device);
if (!dev)
return VDP_STATUS_INVALID_HANDLE;
@@ -101,10 +103,10 @@ vlVdpPresentationQueueTargetCreateX11(VdpDevice device, Drawable drawable,VdpPre
pqt = CALLOC(1, sizeof(vlVdpPresentationQueue));
if (!pqt)
return VDP_STATUS_RESOURCES;
pqt->device = dev;
pqt->drawable = drawable;
*target = vlAddDataHTAB(pqt);
if (*target == 0) {
ret = VDP_STATUS_ERROR;
@@ -112,17 +114,17 @@ vlVdpPresentationQueueTargetCreateX11(VdpDevice device, Drawable drawable,VdpPre
}
return VDP_STATUS_OK;
no_handle:
FREE(dev);
return ret;
return VDP_STATUS_OK;
no_handle:
FREE(dev);
return ret;
}
VdpStatus
VdpStatus
vlVdpDeviceDestroy(VdpDevice device)
{
debug_printf("[VDPAU] Destroying destroy\n");
vlVdpDevice *dev = vlGetDataHTAB(device);
if (!dev)
return VDP_STATUS_INVALID_HANDLE;
@@ -134,7 +136,7 @@ vlVdpDeviceDestroy(VdpDevice device)
return VDP_STATUS_OK;
}
VdpStatus
VdpStatus
vlVdpGetProcAddress(VdpDevice device, VdpFuncId function_id, void **function_pointer)
{
vlVdpDevice *dev = vlGetDataHTAB(device);
@@ -150,49 +152,44 @@ vlVdpGetProcAddress(VdpDevice device, VdpFuncId function_id, void **function_poi
return VDP_STATUS_OK;
}
#define _ERROR_TYPE(TYPE,STRING) \
case TYPE: \
return STRING; \
break
#define _ERROR_TYPE(TYPE,STRING) case TYPE: return STRING;
char const *
vlVdpGetErrorString (
VdpStatus status)
char const *
vlVdpGetErrorString (VdpStatus status)
{
switch (status)
{
_ERROR_TYPE(VDP_STATUS_OK,"The operation completed successfully; no error.");
_ERROR_TYPE(VDP_STATUS_NO_IMPLEMENTATION,"No backend implementation could be loaded.");
_ERROR_TYPE(VDP_STATUS_DISPLAY_PREEMPTED,"The display was preempted, or a fatal error occurred. The application must re-initialize VDPAU.");
_ERROR_TYPE(VDP_STATUS_INVALID_HANDLE,"An invalid handle value was provided. Either the handle does not exist at all, or refers to an object of an incorrect type.");
_ERROR_TYPE(VDP_STATUS_INVALID_POINTER ,"An invalid pointer was provided. Typically, this means that a NULL pointer was provided for an 'output' parameter.");
_ERROR_TYPE(VDP_STATUS_INVALID_CHROMA_TYPE ,"An invalid/unsupported VdpChromaType value was supplied.");
_ERROR_TYPE(VDP_STATUS_INVALID_Y_CB_CR_FORMAT,"An invalid/unsupported VdpYCbCrFormat value was supplied.");
_ERROR_TYPE(VDP_STATUS_INVALID_RGBA_FORMAT,"An invalid/unsupported VdpRGBAFormat value was supplied.");
_ERROR_TYPE(VDP_STATUS_INVALID_INDEXED_FORMAT,"An invalid/unsupported VdpIndexedFormat value was supplied.");
_ERROR_TYPE(VDP_STATUS_INVALID_COLOR_STANDARD,"An invalid/unsupported VdpColorStandard value was supplied.");
_ERROR_TYPE(VDP_STATUS_INVALID_COLOR_TABLE_FORMAT,"An invalid/unsupported VdpColorTableFormat value was supplied.");
_ERROR_TYPE(VDP_STATUS_INVALID_BLEND_FACTOR,"An invalid/unsupported VdpOutputSurfaceRenderBlendFactor value was supplied.");
_ERROR_TYPE(VDP_STATUS_INVALID_BLEND_EQUATION,"An invalid/unsupported VdpOutputSurfaceRenderBlendEquation value was supplied.");
_ERROR_TYPE(VDP_STATUS_INVALID_FLAG,"An invalid/unsupported flag value/combination was supplied.");
_ERROR_TYPE(VDP_STATUS_INVALID_DECODER_PROFILE,"An invalid/unsupported VdpDecoderProfile value was supplied.");
_ERROR_TYPE(VDP_STATUS_INVALID_VIDEO_MIXER_FEATURE,"An invalid/unsupported VdpVideoMixerFeature value was supplied.");
_ERROR_TYPE(VDP_STATUS_INVALID_VIDEO_MIXER_PARAMETER ,"An invalid/unsupported VdpVideoMixerParameter value was supplied.");
_ERROR_TYPE(VDP_STATUS_INVALID_VIDEO_MIXER_ATTRIBUTE,"An invalid/unsupported VdpVideoMixerAttribute value was supplied.");
_ERROR_TYPE(VDP_STATUS_INVALID_VIDEO_MIXER_PICTURE_STRUCTURE,"An invalid/unsupported VdpVideoMixerPictureStructure value was supplied.");
_ERROR_TYPE(VDP_STATUS_INVALID_FUNC_ID,"An invalid/unsupported VdpFuncId value was supplied.");
_ERROR_TYPE(VDP_STATUS_INVALID_SIZE,"The size of a supplied object does not match the object it is being used with.\
For example, a VdpVideoMixer is configured to process VdpVideoSurface objects of a specific size.\
If presented with a VdpVideoSurface of a different size, this error will be raised.");
_ERROR_TYPE(VDP_STATUS_INVALID_VALUE,"An invalid/unsupported value was supplied.\
This is a catch-all error code for values of type other than those with a specific error code.");
_ERROR_TYPE(VDP_STATUS_INVALID_STRUCT_VERSION,"An invalid/unsupported structure version was specified in a versioned structure. \
This implies that the implementation is older than the header file the application was built against.");
_ERROR_TYPE(VDP_STATUS_RESOURCES,"The system does not have enough resources to complete the requested operation at this time.");
_ERROR_TYPE(VDP_STATUS_HANDLE_DEVICE_MISMATCH,"The set of handles supplied are not all related to the same VdpDevice.When performing operations \
that operate on multiple surfaces, such as VdpOutputSurfaceRenderOutputSurface or VdpVideoMixerRender, \
all supplied surfaces must have been created within the context of the same VdpDevice object. \
This error is raised if they were not.");
_ERROR_TYPE(VDP_STATUS_ERROR,"A catch-all error, used when no other error code applies.");
}
switch (status) {
_ERROR_TYPE(VDP_STATUS_OK,"The operation completed successfully; no error.");
_ERROR_TYPE(VDP_STATUS_NO_IMPLEMENTATION,"No backend implementation could be loaded.");
_ERROR_TYPE(VDP_STATUS_DISPLAY_PREEMPTED,"The display was preempted, or a fatal error occurred. The application must re-initialize VDPAU.");
_ERROR_TYPE(VDP_STATUS_INVALID_HANDLE,"An invalid handle value was provided. Either the handle does not exist at all, or refers to an object of an incorrect type.");
_ERROR_TYPE(VDP_STATUS_INVALID_POINTER ,"An invalid pointer was provided. Typically, this means that a NULL pointer was provided for an 'output' parameter.");
_ERROR_TYPE(VDP_STATUS_INVALID_CHROMA_TYPE ,"An invalid/unsupported VdpChromaType value was supplied.");
_ERROR_TYPE(VDP_STATUS_INVALID_Y_CB_CR_FORMAT,"An invalid/unsupported VdpYCbCrFormat value was supplied.");
_ERROR_TYPE(VDP_STATUS_INVALID_RGBA_FORMAT,"An invalid/unsupported VdpRGBAFormat value was supplied.");
_ERROR_TYPE(VDP_STATUS_INVALID_INDEXED_FORMAT,"An invalid/unsupported VdpIndexedFormat value was supplied.");
_ERROR_TYPE(VDP_STATUS_INVALID_COLOR_STANDARD,"An invalid/unsupported VdpColorStandard value was supplied.");
_ERROR_TYPE(VDP_STATUS_INVALID_COLOR_TABLE_FORMAT,"An invalid/unsupported VdpColorTableFormat value was supplied.");
_ERROR_TYPE(VDP_STATUS_INVALID_BLEND_FACTOR,"An invalid/unsupported VdpOutputSurfaceRenderBlendFactor value was supplied.");
_ERROR_TYPE(VDP_STATUS_INVALID_BLEND_EQUATION,"An invalid/unsupported VdpOutputSurfaceRenderBlendEquation value was supplied.");
_ERROR_TYPE(VDP_STATUS_INVALID_FLAG,"An invalid/unsupported flag value/combination was supplied.");
_ERROR_TYPE(VDP_STATUS_INVALID_DECODER_PROFILE,"An invalid/unsupported VdpDecoderProfile value was supplied.");
_ERROR_TYPE(VDP_STATUS_INVALID_VIDEO_MIXER_FEATURE,"An invalid/unsupported VdpVideoMixerFeature value was supplied.");
_ERROR_TYPE(VDP_STATUS_INVALID_VIDEO_MIXER_PARAMETER ,"An invalid/unsupported VdpVideoMixerParameter value was supplied.");
_ERROR_TYPE(VDP_STATUS_INVALID_VIDEO_MIXER_ATTRIBUTE,"An invalid/unsupported VdpVideoMixerAttribute value was supplied.");
_ERROR_TYPE(VDP_STATUS_INVALID_VIDEO_MIXER_PICTURE_STRUCTURE,"An invalid/unsupported VdpVideoMixerPictureStructure value was supplied.");
_ERROR_TYPE(VDP_STATUS_INVALID_FUNC_ID,"An invalid/unsupported VdpFuncId value was supplied.");
_ERROR_TYPE(VDP_STATUS_INVALID_SIZE,"The size of a supplied object does not match the object it is being used with.\
For example, a VdpVideoMixer is configured to process VdpVideoSurface objects of a specific size.\
If presented with a VdpVideoSurface of a different size, this error will be raised.");
_ERROR_TYPE(VDP_STATUS_INVALID_VALUE,"An invalid/unsupported value was supplied.\
This is a catch-all error code for values of type other than those with a specific error code.");
_ERROR_TYPE(VDP_STATUS_INVALID_STRUCT_VERSION,"An invalid/unsupported structure version was specified in a versioned structure. \
This implies that the implementation is older than the header file the application was built against.");
_ERROR_TYPE(VDP_STATUS_RESOURCES,"The system does not have enough resources to complete the requested operation at this time.");
_ERROR_TYPE(VDP_STATUS_HANDLE_DEVICE_MISMATCH,"The set of handles supplied are not all related to the same VdpDevice.When performing operations \
that operate on multiple surfaces, such as VdpOutputSurfaceRenderOutputSurface or VdpVideoMixerRender, \
all supplied surfaces must have been created within the context of the same VdpDevice object. \
This error is raised if they were not.");
_ERROR_TYPE(VDP_STATUS_ERROR,"A catch-all error, used when no other error code applies.");
}
}
src/gallium/state_trackers/vdpau/mixer.c
+89 -94
View File
@@ -24,117 +24,112 @@
* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*
**************************************************************************/
#include <vdpau/vdpau.h>
#include <util/u_memory.h>
#include <util/u_debug.h>
#include "vdpau_private.h"
VdpStatus
vlVdpVideoMixerCreate (VdpDevice device,
uint32_t feature_count,
VdpVideoMixerFeature const *features,
uint32_t parameter_count,
VdpVideoMixerParameter const *parameters,
void const *const *parameter_values,
VdpVideoMixer *mixer)
#include <vdpau/vdpau.h>
#include <util/u_memory.h>
#include <util/u_debug.h>
#include "vdpau_private.h"
VdpStatus
vlVdpVideoMixerCreate(VdpDevice device,
uint32_t feature_count,
VdpVideoMixerFeature const *features,
uint32_t parameter_count,
VdpVideoMixerParameter const *parameters,
void const *const *parameter_values,
VdpVideoMixer *mixer)
{
VdpStatus ret;
vlVdpVideoMixer *vmixer = NULL;
debug_printf("[VDPAU] Creating VideoMixer\n");
vlVdpDevice *dev = vlGetDataHTAB(device);
if (!dev)
VdpStatus ret;
vlVdpVideoMixer *vmixer = NULL;
debug_printf("[VDPAU] Creating VideoMixer\n");
vlVdpDevice *dev = vlGetDataHTAB(device);
if (!dev)
return VDP_STATUS_INVALID_HANDLE;
vmixer = CALLOC(1, sizeof(vlVdpVideoMixer));
if (!vmixer)
vmixer = CALLOC(1, sizeof(vlVdpVideoMixer));
if (!vmixer)
return VDP_STATUS_RESOURCES;
vmixer->device = dev;
/*
* TODO: Handle features and parameters
* */
*mixer = vlAddDataHTAB(vmixer);
if (*mixer == 0) {
vmixer->device = dev;
/*
* TODO: Handle features and parameters
* */
*mixer = vlAddDataHTAB(vmixer);
if (*mixer == 0) {
ret = VDP_STATUS_ERROR;
goto no_handle;
}
}
return VDP_STATUS_OK;
no_handle:
no_handle:
return ret;
}
VdpStatus
vlVdpVideoMixerSetFeatureEnables (
VdpVideoMixer mixer,
uint32_t feature_count,
VdpVideoMixerFeature const *features,
VdpBool const *feature_enables)
vlVdpVideoMixerSetFeatureEnables(VdpVideoMixer mixer,
uint32_t feature_count,
VdpVideoMixerFeature const *features,
VdpBool const *feature_enables)
{
debug_printf("[VDPAU] Setting VideoMixer features\n");
if (!(features && feature_enables))
return VDP_STATUS_INVALID_POINTER;
vlVdpVideoMixer *vmixer = vlGetDataHTAB(mixer);
if (!vmixer)
return VDP_STATUS_INVALID_HANDLE;
/*
* TODO: Set features
* */
return VDP_STATUS_OK;
debug_printf("[VDPAU] Setting VideoMixer features\n");
if (!(features && feature_enables))
return VDP_STATUS_INVALID_POINTER;
vlVdpVideoMixer *vmixer = vlGetDataHTAB(mixer);
if (!vmixer)
return VDP_STATUS_INVALID_HANDLE;
/*
* TODO: Set features
* */
return VDP_STATUS_OK;
}
VdpStatus vlVdpVideoMixerRender (
VdpVideoMixer mixer,
VdpOutputSurface background_surface,
VdpRect const *background_source_rect,
VdpVideoMixerPictureStructure current_picture_structure,
uint32_t video_surface_past_count,
VdpVideoSurface const *video_surface_past,
VdpVideoSurface video_surface_current,
uint32_t video_surface_future_count,
VdpVideoSurface const *video_surface_future,
VdpRect const *video_source_rect,
VdpOutputSurface destination_surface,
VdpRect const *destination_rect,
VdpRect const *destination_video_rect,
uint32_t layer_count,
VdpLayer const *layers)
VdpStatus vlVdpVideoMixerRender(VdpVideoMixer mixer,
VdpOutputSurface background_surface,
VdpRect const *background_source_rect,
VdpVideoMixerPictureStructure current_picture_structure,
uint32_t video_surface_past_count,
VdpVideoSurface const *video_surface_past,
VdpVideoSurface video_surface_current,
uint32_t video_surface_future_count,
VdpVideoSurface const *video_surface_future,
VdpRect const *video_source_rect,
VdpOutputSurface destination_surface,
VdpRect const *destination_rect,
VdpRect const *destination_video_rect,
uint32_t layer_count,
VdpLayer const *layers)
{
if (!(background_source_rect && video_surface_past && video_surface_future && video_source_rect && destination_rect && destination_video_rect && layers))
return VDP_STATUS_INVALID_POINTER;
if (!(background_source_rect && video_surface_past && video_surface_future &&
video_source_rect && destination_rect && destination_video_rect && layers))
return VDP_STATUS_INVALID_POINTER;
return VDP_STATUS_NO_IMPLEMENTATION;
return VDP_STATUS_NO_IMPLEMENTATION;
}
VdpStatus
vlVdpVideoMixerSetAttributeValues (
VdpVideoMixer mixer,
uint32_t attribute_count,
VdpVideoMixerAttribute const *attributes,
void const *const *attribute_values)
vlVdpVideoMixerSetAttributeValues(VdpVideoMixer mixer,
uint32_t attribute_count,
VdpVideoMixerAttribute const *attributes,
void const *const *attribute_values)
{
if (!(attributes && attribute_values))
return VDP_STATUS_INVALID_POINTER;
vlVdpVideoMixer *vmixer = vlGetDataHTAB(mixer);
if (!vmixer)
return VDP_STATUS_INVALID_HANDLE;
/*
* TODO: Implement the function
*
* */
return VDP_STATUS_OK;
}
if (!(attributes && attribute_values))
return VDP_STATUS_INVALID_POINTER;
vlVdpVideoMixer *vmixer = vlGetDataHTAB(mixer);
if (!vmixer)
return VDP_STATUS_INVALID_HANDLE;
/*
* TODO: Implement the function
*
* */
return VDP_STATUS_OK;
}
src/gallium/state_trackers/vdpau/mpeg2_bitstream_parser.c
+92 -109
View File
@@ -31,119 +31,102 @@
int
vlVdpMPEG2NextStartCode(struct vdpMPEG2BitstreamParser *parser)
{
uint32_t integer = 0xffffff00;
uint8_t * ptr_read = parser->ptr_bitstream;
int8_t * bytes_to_end;
bytes_to_end = parser->ptr_bitstream_end - parser->ptr_bitstream;
/* Read byte after byte, until startcode is found */
while(integer != 0x00000100)
{
if (bytes_to_end <= 0)
{
parser->state = MPEG2_BITSTREAM_DONE;
parser->code = 0;
return 0;
}
integer = ( integer | *ptr_read++ ) << 8;
bytes_to_end--;
}
parser->ptr_bitstream = ptr_read;
parser->code = parser->ptr_bitstream;
/* start_code found. rewind cursor a byte */
//parser->cursor -= 8;
return 0;
uint32_t integer = 0xffffff00;
uint8_t * ptr_read = parser->ptr_bitstream;
int8_t * bytes_to_end;
bytes_to_end = parser->ptr_bitstream_end - parser->ptr_bitstream;
/* Read byte after byte, until startcode is found */
while(integer != 0x00000100) {
if (bytes_to_end <= 0) {
parser->state = MPEG2_BITSTREAM_DONE;
parser->code = 0;
return 0;
}
integer = ( integer | *ptr_read++ ) << 8;
bytes_to_end--;
}
parser->ptr_bitstream = ptr_read;
parser->code = parser->ptr_bitstream;
/* start_code found. rewind cursor a byte */
//parser->cursor -= 8;
return 0;
}
int
vlVdpMPEG2BitstreamToMacroblock (
struct pipe_screen *screen,
VdpBitstreamBuffer const *bitstream_buffers,
uint32_t bitstream_buffer_count,
unsigned int *num_macroblocks,
struct pipe_mpeg12_macroblock **pipe_macroblocks)
vlVdpMPEG2BitstreamToMacroblock(struct pipe_screen *screen,
VdpBitstreamBuffer const *bitstream_buffers,
uint32_t bitstream_buffer_count,
unsigned int *num_macroblocks,
struct pipe_mpeg12_macroblock **pipe_macroblocks)
{
bool b_header_done = false;
struct vdpMPEG2BitstreamParser parser;
#if(1)
FILE *fp;
if ((fp = fopen("binout", "w"))==NULL) {
printf("Cannot open file.\n");
exit(1);
}
fwrite(bitstream_buffers[0].bitstream, 1, bitstream_buffers[0].bitstream_bytes, fp);
fclose(fp);
#endif
debug_printf("[VDPAU] Starting decoding MPEG2 stream\n");
num_macroblocks[0] = 0;
memset(&parser,0,sizeof(parser));
parser.state = MPEG2_HEADER_START_CODE;
parser.ptr_bitstream = (unsigned char *)bitstream_buffers[0].bitstream;
parser.ptr_bitstream_end = parser.ptr_bitstream + bitstream_buffers[0].bitstream_bytes;
/* Main header parser loop */
while(!b_header_done)
{
switch (parser.state)
{
case MPEG2_SEEK_HEADER:
if (vlVdpMPEG2NextStartCode(&parser))
exit(1);
break;
/* Start_code found */
switch (parser.code)
{
/* sequence_header_code */
case 0xB3:
debug_printf("[VDPAU][Bitstream parser] Sequence header code found\n");
/* We dont need to read this, because we already have this information */
break;
case 0xB5:
debug_printf("[VDPAU][Bitstream parser] Extension start code found\n");
//exit(1);
break;
case 0xB8:
debug_printf("[VDPAU][Bitstream parser] Extension start code found\n");
//exit(1);
break;
}
break;
case MPEG2_BITSTREAM_DONE:
if (parser.cur_bitstream < bitstream_buffer_count - 1)
{
debug_printf("[VDPAU][Bitstream parser] Done parsing current bitstream. Moving to the next\n");
parser.cur_bitstream++;
parser.ptr_bitstream = (unsigned char *)bitstream_buffers[parser.cur_bitstream].bitstream;
parser.ptr_bitstream_end = parser.ptr_bitstream + bitstream_buffers[parser.cur_bitstream].bitstream_bytes;
parser.state = MPEG2_HEADER_START_CODE;
}
else
{
debug_printf("[VDPAU][Bitstream parser] Done with frame\n");
exit(0);
// return 0;
}
break;
}
}
bool b_header_done = false;
struct vdpMPEG2BitstreamParser parser;
return 0;
#if(1)
FILE *fp;
if ((fp = fopen("binout", "w"))==NULL) {
printf("Cannot open file.\n");
exit(1);
}
fwrite(bitstream_buffers[0].bitstream, 1, bitstream_buffers[0].bitstream_bytes, fp);
fclose(fp);
#endif
debug_printf("[VDPAU] Starting decoding MPEG2 stream\n");
num_macroblocks[0] = 0;
memset(&parser,0,sizeof(parser));
parser.state = MPEG2_HEADER_START_CODE;
parser.ptr_bitstream = (unsigned char *)bitstream_buffers[0].bitstream;
parser.ptr_bitstream_end = parser.ptr_bitstream + bitstream_buffers[0].bitstream_bytes;
/* Main header parser loop */
while(!b_header_done) {
switch (parser.state) {
case MPEG2_SEEK_HEADER:
if (vlVdpMPEG2NextStartCode(&parser))
exit(1);
break;
/* Start_code found */
switch (parser.code) {
/* sequence_header_code */
case 0xB3:
debug_printf("[VDPAU][Bitstream parser] Sequence header code found\n");
/* We dont need to read this, because we already have this information */
break;
case 0xB5:
debug_printf("[VDPAU][Bitstream parser] Extension start code found\n");
//exit(1);
break;
case 0xB8:
debug_printf("[VDPAU][Bitstream parser] Extension start code found\n");
//exit(1);
break;
}
break;
case MPEG2_BITSTREAM_DONE:
if (parser.cur_bitstream < bitstream_buffer_count - 1) {
debug_printf("[VDPAU][Bitstream parser] Done parsing current bitstream. Moving to the next\n");
parser.cur_bitstream++;
parser.ptr_bitstream = (unsigned char *)bitstream_buffers[parser.cur_bitstream].bitstream;
parser.ptr_bitstream_end = parser.ptr_bitstream + bitstream_buffers[parser.cur_bitstream].bitstream_bytes;
parser.state = MPEG2_HEADER_START_CODE;
}
else {
debug_printf("[VDPAU][Bitstream parser] Done with frame\n");
exit(0);
// return 0;
}
break;
}
}
return 0;
}
src/gallium/state_trackers/vdpau/mpeg2_bitstream_parser.h
+17 -19
View File
@@ -34,32 +34,30 @@
enum vdpMPEG2States
{
MPEG2_SEEK_HEADER,
MPEG2_HEADER_DONE,
MPEG2_BITSTREAM_DONE,
MPEG2_HEADER_START_CODE
MPEG2_SEEK_HEADER,
MPEG2_HEADER_DONE,
MPEG2_BITSTREAM_DONE,
MPEG2_HEADER_START_CODE
};
struct vdpMPEG2BitstreamParser
{
enum vdpMPEG2States state;
uint32_t cur_bitstream;
const uint8_t *ptr_bitstream_end;
const uint8_t *ptr_bitstream;
uint8_t code;
/* The decoded bitstream goes here: */
/* Sequence_header_info */
uint32_t horizontal_size_value;
enum vdpMPEG2States state;
uint32_t cur_bitstream;
const uint8_t *ptr_bitstream_end;
const uint8_t *ptr_bitstream;
uint8_t code;
/* The decoded bitstream goes here: */
/* Sequence_header_info */
uint32_t horizontal_size_value;
};
int
vlVdpMPEG2BitstreamToMacroblock(struct pipe_screen *screen,
VdpBitstreamBuffer const *bitstream_buffers,
uint32_t bitstream_buffer_count,
unsigned int *num_macroblocks,
struct pipe_mpeg12_macroblock **pipe_macroblocks);
VdpBitstreamBuffer const *bitstream_buffers,
uint32_t bitstream_buffer_count,
unsigned int *num_macroblocks,
struct pipe_mpeg12_macroblock **pipe_macroblocks);
#endif // MPEG2_BITSTREAM_PARSER_H
src/gallium/state_trackers/vdpau/output.c
+25 -25
View File
@@ -31,34 +31,34 @@
#include <util/u_memory.h>
VdpStatus
vlVdpOutputSurfaceCreate ( VdpDevice device,
VdpRGBAFormat rgba_format,
uint32_t width, uint32_t height,
VdpOutputSurface *surface)
vlVdpOutputSurfaceCreate(VdpDevice device,
VdpRGBAFormat rgba_format,
uint32_t width, uint32_t height,
VdpOutputSurface *surface)
{
vlVdpOutputSurface *vlsurface = NULL;
debug_printf("[VDPAU] Creating output surface\n");
if (!(width && height))
return VDP_STATUS_INVALID_SIZE;
vlVdpDevice *dev = vlGetDataHTAB(device);
if (!dev)
vlVdpOutputSurface *vlsurface = NULL;
debug_printf("[VDPAU] Creating output surface\n");
if (!(width && height))
return VDP_STATUS_INVALID_SIZE;
vlVdpDevice *dev = vlGetDataHTAB(device);
if (!dev)
return VDP_STATUS_INVALID_HANDLE;
vlsurface = CALLOC(1, sizeof(vlVdpOutputSurface));
if (!vlsurface)
vlsurface = CALLOC(1, sizeof(vlVdpOutputSurface));
if (!vlsurface)
return VDP_STATUS_RESOURCES;
vlsurface->width = width;
vlsurface->height = height;
vlsurface->format = FormatRGBAToPipe(rgba_format);
*surface = vlAddDataHTAB(vlsurface);
vlsurface->width = width;
vlsurface->height = height;
vlsurface->format = FormatRGBAToPipe(rgba_format);
*surface = vlAddDataHTAB(vlsurface);
if (*surface == 0) {
FREE(dev);
return VDP_STATUS_ERROR;
return VDP_STATUS_ERROR;
}
return VDP_STATUS_OK;
}
return VDP_STATUS_OK;
}
src/gallium/state_trackers/vdpau/preemption.c
+9 -9
View File
@@ -24,16 +24,16 @@
* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*
**************************************************************************/
#include <vdpau/vdpau.h>
void vlVdpPreemptionCallback (VdpDevice device, void *context)
void vlVdpPreemptionCallback(VdpDevice device, void *context)
{
/* TODO: Implement preemption */
/* TODO: Implement preemption */
}
VdpStatus vlVdpPreemptionCallbackRegister (VdpDevice device, VdpPreemptionCallback callback, void *context)
VdpStatus vlVdpPreemptionCallbackRegister(VdpDevice device, VdpPreemptionCallback callback,
void *context)
{
return VDP_STATUS_OK;
}
return VDP_STATUS_OK;
}
src/gallium/state_trackers/vdpau/presentation.c
+64 -68
View File
@@ -31,119 +31,115 @@
#include <util/u_memory.h>
VdpStatus
vlVdpPresentationQueueTargetDestroy (VdpPresentationQueueTarget presentation_queue_target)
vlVdpPresentationQueueTargetDestroy(VdpPresentationQueueTarget presentation_queue_target)
{
return VDP_STATUS_NO_IMPLEMENTATION;
return VDP_STATUS_NO_IMPLEMENTATION;
}
VdpStatus
vlVdpPresentationQueueCreate ( VdpDevice device,
VdpPresentationQueueTarget presentation_queue_target,
VdpPresentationQueue *presentation_queue)
vlVdpPresentationQueueCreate(VdpDevice device,
VdpPresentationQueueTarget presentation_queue_target,
VdpPresentationQueue *presentation_queue)
{
debug_printf("[VDPAU] Creating PresentationQueue\n");
VdpStatus ret;
vlVdpPresentationQueue *pq = NULL;
if (!presentation_queue)
return VDP_STATUS_INVALID_POINTER;
debug_printf("[VDPAU] Creating PresentationQueue\n");
VdpStatus ret;
vlVdpPresentationQueue *pq = NULL;
if (!presentation_queue)
return VDP_STATUS_INVALID_POINTER;
vlVdpDevice *dev = vlGetDataHTAB(device);
if (!dev)
return VDP_STATUS_INVALID_HANDLE;
vlVdpPresentationQueueTarget *pqt = vlGetDataHTAB(presentation_queue_target);
if (!pqt)
return VDP_STATUS_INVALID_HANDLE;
if (dev != pqt->device)
return VDP_STATUS_HANDLE_DEVICE_MISMATCH;
return VDP_STATUS_INVALID_HANDLE;
if (dev != pqt->device)
return VDP_STATUS_HANDLE_DEVICE_MISMATCH;
pq = CALLOC(1, sizeof(vlVdpPresentationQueue));
if (!pq)
return VDP_STATUS_RESOURCES;
*presentation_queue = vlAddDataHTAB(pq);
*presentation_queue = vlAddDataHTAB(pq);
if (*presentation_queue == 0) {
ret = VDP_STATUS_ERROR;
goto no_handle;
}
return VDP_STATUS_OK;
no_handle:
FREE(pq);
return ret;
return VDP_STATUS_OK;
no_handle:
FREE(pq);
return ret;
}
VdpStatus
vlVdpPresentationQueueDestroy (VdpPresentationQueue presentation_queue)
vlVdpPresentationQueueDestroy(VdpPresentationQueue presentation_queue)
{
return VDP_STATUS_NO_IMPLEMENTATION;
return VDP_STATUS_NO_IMPLEMENTATION;
}
VdpStatus
vlVdpPresentationQueueSetBackgroundColor ( VdpPresentationQueue presentation_queue,
VdpColor *const background_color)
vlVdpPresentationQueueSetBackgroundColor(VdpPresentationQueue presentation_queue,
VdpColor *const background_color)
{
if (!background_color)
return VDP_STATUS_INVALID_POINTER;
return VDP_STATUS_NO_IMPLEMENTATION;
if (!background_color)
return VDP_STATUS_INVALID_POINTER;
return VDP_STATUS_NO_IMPLEMENTATION;
}
VdpStatus
vlVdpPresentationQueueGetBackgroundColor ( VdpPresentationQueue presentation_queue,
VdpColor *const background_color)
vlVdpPresentationQueueGetBackgroundColor(VdpPresentationQueue presentation_queue,
VdpColor *const background_color)
{
if (!background_color)
return VDP_STATUS_INVALID_POINTER;
return VDP_STATUS_NO_IMPLEMENTATION;
if (!background_color)
return VDP_STATUS_INVALID_POINTER;
return VDP_STATUS_NO_IMPLEMENTATION;
}
VdpStatus
vlVdpPresentationQueueGetTime ( VdpPresentationQueue presentation_queue,
VdpTime *current_time)
vlVdpPresentationQueueGetTime(VdpPresentationQueue presentation_queue,
VdpTime *current_time)
{
if (!current_time)
return VDP_STATUS_INVALID_POINTER;
return VDP_STATUS_NO_IMPLEMENTATION;
if (!current_time)
return VDP_STATUS_INVALID_POINTER;
return VDP_STATUS_NO_IMPLEMENTATION;
}
VdpStatus
vlVdpPresentationQueueDisplay ( VdpPresentationQueue presentation_queue,
VdpOutputSurface surface,
uint32_t clip_width,
uint32_t clip_height,
VdpTime earliest_presentation_time)
vlVdpPresentationQueueDisplay(VdpPresentationQueue presentation_queue,
VdpOutputSurface surface,
uint32_t clip_width,
uint32_t clip_height,
VdpTime earliest_presentation_time)
{
return VDP_STATUS_NO_IMPLEMENTATION;
return VDP_STATUS_NO_IMPLEMENTATION;
}
VdpStatus
vlVdpPresentationQueueBlockUntilSurfaceIdle ( VdpPresentationQueue presentation_queue,
VdpOutputSurface surface,
VdpTime *first_presentation_time)
vlVdpPresentationQueueBlockUntilSurfaceIdle(VdpPresentationQueue presentation_queue,
VdpOutputSurface surface,
VdpTime *first_presentation_time)
{
if (!first_presentation_time)
return VDP_STATUS_INVALID_POINTER;
return VDP_STATUS_NO_IMPLEMENTATION;
if (!first_presentation_time)
return VDP_STATUS_INVALID_POINTER;
return VDP_STATUS_NO_IMPLEMENTATION;
}
VdpStatus
vlVdpPresentationQueueQuerySurfaceStatus ( VdpPresentationQueue presentation_queue,
VdpOutputSurface surface,
VdpPresentationQueueStatus *status,
VdpTime *first_presentation_time)
vlVdpPresentationQueueQuerySurfaceStatus(VdpPresentationQueue presentation_queue,
VdpOutputSurface surface,
VdpPresentationQueueStatus *status,
VdpTime *first_presentation_time)
{
if (!(status && first_presentation_time))
return VDP_STATUS_INVALID_POINTER;
return VDP_STATUS_NO_IMPLEMENTATION;
}
if (!(status && first_presentation_time))
return VDP_STATUS_INVALID_POINTER;
return VDP_STATUS_NO_IMPLEMENTATION;
}
src/gallium/state_trackers/vdpau/query.c
+30 -30
View File
@@ -61,7 +61,7 @@ vlVdpVideoSurfaceQueryCapabilities(VdpDevice device, VdpChromaType surface_chrom
struct vl_screen *vlscreen;
uint32_t max_2d_texture_level;
VdpStatus ret;
debug_printf("[VDPAU] Querying video surfaces\n");
if (!(is_supported && max_width && max_height))
@@ -70,12 +70,12 @@ vlVdpVideoSurfaceQueryCapabilities(VdpDevice device, VdpChromaType surface_chrom
vlVdpDevice *dev = vlGetDataHTAB(device);
if (!dev)
return VDP_STATUS_INVALID_HANDLE;
vlscreen = vl_screen_create(dev->display, dev->screen);
if (!vlscreen)
return VDP_STATUS_RESOURCES;
/* XXX: Current limits */
/* XXX: Current limits */
*is_supported = true;
if (surface_chroma_type != VDP_CHROMA_TYPE_420) {
*is_supported = false;
@@ -90,9 +90,9 @@ vlVdpVideoSurfaceQueryCapabilities(VdpDevice device, VdpChromaType surface_chrom
/* I am not quite sure if it is max_2d_texture_level-1 or just max_2d_texture_level */
*max_width = *max_height = pow(2,max_2d_texture_level-1);
vl_screen_destroy(vlscreen);
return VDP_STATUS_OK;
no_sup:
return ret;
@@ -103,10 +103,10 @@ vlVdpVideoSurfaceQueryGetPutBitsYCbCrCapabilities(VdpDevice device, VdpChromaTyp
VdpYCbCrFormat bits_ycbcr_format,
VdpBool *is_supported)
{
struct vl_screen *vlscreen;
debug_printf("[VDPAU] Querying get put video surfaces\n");
struct vl_screen *vlscreen;
debug_printf("[VDPAU] Querying get put video surfaces\n");
if (!is_supported)
return VDP_STATUS_INVALID_POINTER;
@@ -118,16 +118,16 @@ vlVdpVideoSurfaceQueryGetPutBitsYCbCrCapabilities(VdpDevice device, VdpChromaTyp
if (!vlscreen)
return VDP_STATUS_RESOURCES;
if (bits_ycbcr_format != VDP_YCBCR_FORMAT_Y8U8V8A8 && bits_ycbcr_format != VDP_YCBCR_FORMAT_V8U8Y8A8)
*is_supported = vlscreen->pscreen->is_format_supported(vlscreen->pscreen,
FormatToPipe(bits_ycbcr_format),
PIPE_TEXTURE_2D,
1,
PIPE_BIND_RENDER_TARGET,
PIPE_TEXTURE_GEOM_NON_SQUARE );
if (bits_ycbcr_format != VDP_YCBCR_FORMAT_Y8U8V8A8 && bits_ycbcr_format != VDP_YCBCR_FORMAT_V8U8Y8A8)
*is_supported = vlscreen->pscreen->is_format_supported(vlscreen->pscreen,
FormatToPipe(bits_ycbcr_format),
PIPE_TEXTURE_2D,
1,
PIPE_BIND_RENDER_TARGET,
PIPE_TEXTURE_GEOM_NON_SQUARE);
vl_screen_destroy(vlscreen);
return VDP_STATUS_OK;
}
@@ -141,16 +141,16 @@ vlVdpDecoderQueryCapabilities(VdpDevice device, VdpDecoderProfile profile,
uint32_t max_decode_height;
uint32_t max_2d_texture_level;
struct vl_screen *vlscreen;
debug_printf("[VDPAU] Querying decoder\n");
if (!(is_supported && max_level && max_macroblocks && max_width && max_height))
return VDP_STATUS_INVALID_POINTER;
vlVdpDevice *dev = vlGetDataHTAB(device);
if (!dev)
return VDP_STATUS_INVALID_HANDLE;
vlscreen = vl_screen_create(dev->display, dev->screen);
if (!vlscreen)
return VDP_STATUS_RESOURCES;
@@ -160,24 +160,24 @@ vlVdpDecoderQueryCapabilities(VdpDevice device, VdpDecoderProfile profile,
*is_supported = false;
return VDP_STATUS_OK;
}
if (p_profile != PIPE_VIDEO_PROFILE_MPEG2_SIMPLE && p_profile != PIPE_VIDEO_PROFILE_MPEG2_MAIN) {
*is_supported = false;
return VDP_STATUS_OK;
}
/* XXX hack, need to implement something more sane when the decoders have been implemented */
max_2d_texture_level = vlscreen->pscreen->get_param( vlscreen->pscreen, PIPE_CAP_MAX_TEXTURE_2D_LEVELS );
max_decode_width = max_decode_height = pow(2,max_2d_texture_level-2);
if (!(max_decode_width && max_decode_height))
if (!(max_decode_width && max_decode_height))
return VDP_STATUS_RESOURCES;
*is_supported = true;
*max_width = max_decode_width;
*max_height = max_decode_height;
*max_level = 16;
*max_macroblocks = (max_decode_width/16) * (max_decode_height/16);
vl_screen_destroy(vlscreen);
return VDP_STATUS_OK;
@@ -186,10 +186,10 @@ vlVdpDecoderQueryCapabilities(VdpDevice device, VdpDecoderProfile profile,
VdpStatus
vlVdpOutputSurfaceQueryCapabilities(VdpDevice device, VdpRGBAFormat surface_rgba_format,
VdpBool *is_supported, uint32_t *max_width, uint32_t *max_height)
{
{
if (!(is_supported && max_width && max_height))
return VDP_STATUS_INVALID_POINTER;
debug_printf("[VDPAU] Querying ouput surfaces\n");
return VDP_STATUS_NO_IMPLEMENTATION;
@@ -200,7 +200,7 @@ vlVdpOutputSurfaceQueryGetPutBitsNativeCapabilities(VdpDevice device, VdpRGBAFor
VdpBool *is_supported)
{
debug_printf("[VDPAU] Querying output surfaces get put native cap\n");
if (!is_supported)
return VDP_STATUS_INVALID_POINTER;
src/gallium/state_trackers/vdpau/vdpau_private.h
+7 -9
View File
@@ -28,7 +28,6 @@
#ifndef VDPAU_PRIVATE_H
#define VDPAU_PRIVATE_H
#include <vdpau/vdpau.h>
#include <vdpau/vdpau_x11.h>
#include <pipe/p_compiler.h>
@@ -182,7 +181,7 @@ typedef struct
typedef struct
{
vlVdpDevice *device;
vlVdpDevice *device;
} vlVdpVideoMixer;
typedef struct
@@ -206,12 +205,12 @@ typedef struct
typedef struct
{
vlVdpDevice *device;
struct vl_context *vctx;
enum pipe_video_chroma_format chroma_format;
enum pipe_video_profile profile;
uint32_t width;
uint32_t height;
vlVdpDevice *device;
struct vl_context *vctx;
enum pipe_video_chroma_format chroma_format;
enum pipe_video_profile profile;
uint32_t width;
uint32_t height;
} vlVdpDecoder;
typedef uint32_t vlHandle;
@@ -274,5 +273,4 @@ VdpVideoMixerRender vlVdpVideoMixerRender;
VdpVideoMixerSetAttributeValues vlVdpVideoMixerSetAttributeValues;
VdpGenerateCSCMatrix vlVdpGenerateCSCMatrix;
#endif // VDPAU_PRIVATE_H