/*

* Copyright (c) 2013 Jens Kuske <jenskuske@gmail.com>

*

* This library is free software; you can redistribute it and/or

* modify it under the terms of the GNU Lesser General Public

* License as published by the Free Software Foundation; either

* version 2.1 of the License, or (at your option) any later version.

*

* This library is distributed in the hope that it will be useful,

* but WITHOUT ANY WARRANTY; without even the implied warranty of

* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU

* Lesser General Public License for more details.

*

* You should have received a copy of the GNU Lesser General Public

* License along with this library; if not, write to the Free Software

* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA

*

*/

#include "vdpau_private.h"

#include "ve.h"

#include <vdpau/vdpau_x11.h>

#include <string.h>

#include <sys/types.h>

#include <sys/stat.h>

#include <fcntl.h>

#include <stdlib.h>

VdpStatus vdp_imp_device_create_x11(Display *display, int screen, VdpDevice *device, VdpGetProcAddress **get_proc_address)

{

if (!device || !get_proc_address) {

VDPAU_DBG_ONCE("device=NULL || get_proc_address");

return VDP_STATUS_INVALID_POINTER;

}

device_ctx_t *dev = handle_create(sizeof(*dev), device, htype_device);

if (!dev)

return VDP_STATUS_RESOURCES;

//dev->display = XOpenDisplay(XDisplayString(display));

dev->screen = screen;

dev->fb_id = 0;

if (!cedarv_open())

{

VDPAU_DBG_ONCE("cedarv_open failed");

handle_destroy(*device);

return VDP_STATUS_ERROR;

}

char *env_vdpau_osd = getenv("VDPAU_OSD");

if (env_vdpau_osd && strncmp(env_vdpau_osd, "1", 1) == 0)

{

dev->g2d_fd = open("/dev/g2d", O_RDWR);

if (dev->g2d_fd != -1)

dev->osd_enabled = 1;

else

VDPAU_DBG("Failed to open /dev/g2d! OSD disabled.");

}

VDPAU_DBG("VE version 0x%04x opened", cedarv_get_version());

*get_proc_address = &vdp_get_proc_address;

return VDP_STATUS_OK;

}

VdpStatus vdp_device_destroy(VdpDevice device)

{

device_ctx_t *dev = handle_get(device);

if (!dev)

return VDP_STATUS_INVALID_HANDLE;

cedarv_close();

//XCloseDisplay(dev->display);

handle_release(device);

handle_destroy(device);

return VDP_STATUS_OK;

}

VdpStatus vdp_preemption_callback_register(VdpDevice device, VdpPreemptionCallback callback, void *context)

{

if (!callback)

return VDP_STATUS_INVALID_POINTER;

device_ctx_t *dev = handle_get(device);

if (!dev)

return VDP_STATUS_INVALID_HANDLE;

dev->preemption_callback = callback;

dev->preemption_callback_context = context;

handle_release(device);

return VDP_STATUS_OK;

}

static void *const functions[] =

{

[VDP_FUNC_ID_GET_ERROR_STRING] = &vdp_get_error_string,

[VDP_FUNC_ID_GET_PROC_ADDRESS] = &vdp_get_proc_address,

[VDP_FUNC_ID_GET_API_VERSION] = &vdp_get_api_version,

[VDP_FUNC_ID_GET_INFORMATION_STRING] = &vdp_get_information_string,

[VDP_FUNC_ID_DEVICE_DESTROY] = &vdp_device_destroy,

[VDP_FUNC_ID_GENERATE_CSC_MATRIX] = &vdp_generate_csc_matrix,

[VDP_FUNC_ID_VIDEO_SURFACE_QUERY_CAPABILITIES] = &vdp_video_surface_query_capabilities,

[VDP_FUNC_ID_VIDEO_SURFACE_QUERY_GET_PUT_BITS_Y_CB_CR_CAPABILITIES] = &vdp_video_surface_query_get_put_bits_y_cb_cr_capabilities,

[VDP_FUNC_ID_VIDEO_SURFACE_CREATE] = &vdp_video_surface_create,

[VDP_FUNC_ID_VIDEO_SURFACE_DESTROY] = &vdp_video_surface_destroy,

[VDP_FUNC_ID_VIDEO_SURFACE_GET_PARAMETERS] = &vdp_video_surface_get_parameters,

[VDP_FUNC_ID_VIDEO_SURFACE_GET_BITS_Y_CB_CR] = &vdp_video_surface_get_bits_y_cb_cr,

[VDP_FUNC_ID_VIDEO_SURFACE_PUT_BITS_Y_CB_CR] = &vdp_video_surface_put_bits_y_cb_cr,

[VDP_FUNC_ID_OUTPUT_SURFACE_QUERY_CAPABILITIES] = &vdp_output_surface_query_capabilities,

[VDP_FUNC_ID_OUTPUT_SURFACE_QUERY_GET_PUT_BITS_NATIVE_CAPABILITIES] = &vdp_output_surface_query_get_put_bits_native_capabilities,

[VDP_FUNC_ID_OUTPUT_SURFACE_QUERY_PUT_BITS_INDEXED_CAPABILITIES] = &vdp_output_surface_query_put_bits_indexed_capabilities,

[VDP_FUNC_ID_OUTPUT_SURFACE_QUERY_PUT_BITS_Y_CB_CR_CAPABILITIES] = &vdp_output_surface_query_put_bits_y_cb_cr_capabilities,

[VDP_FUNC_ID_OUTPUT_SURFACE_CREATE] = &vdp_output_surface_create,

[VDP_FUNC_ID_OUTPUT_SURFACE_DESTROY] = &vdp_output_surface_destroy,

[VDP_FUNC_ID_OUTPUT_SURFACE_GET_PARAMETERS] = &vdp_output_surface_get_parameters,

[VDP_FUNC_ID_OUTPUT_SURFACE_GET_BITS_NATIVE] = &vdp_output_surface_get_bits_native,

[VDP_FUNC_ID_OUTPUT_SURFACE_PUT_BITS_NATIVE] = &vdp_output_surface_put_bits_native,

[VDP_FUNC_ID_OUTPUT_SURFACE_PUT_BITS_INDEXED] = &vdp_output_surface_put_bits_indexed,

[VDP_FUNC_ID_OUTPUT_SURFACE_PUT_BITS_Y_CB_CR] = &vdp_output_surface_put_bits_y_cb_cr,

[VDP_FUNC_ID_BITMAP_SURFACE_QUERY_CAPABILITIES] = &vdp_bitmap_surface_query_capabilities,

[VDP_FUNC_ID_BITMAP_SURFACE_CREATE] = &vdp_bitmap_surface_create,

[VDP_FUNC_ID_BITMAP_SURFACE_DESTROY] = &vdp_bitmap_surface_destroy,

[VDP_FUNC_ID_BITMAP_SURFACE_GET_PARAMETERS] = &vdp_bitmap_surface_get_parameters,

[VDP_FUNC_ID_BITMAP_SURFACE_PUT_BITS_NATIVE] = &vdp_bitmap_surface_put_bits_native,

[VDP_FUNC_ID_OUTPUT_SURFACE_RENDER_OUTPUT_SURFACE] = &vdp_output_surface_render_output_surface,

[VDP_FUNC_ID_OUTPUT_SURFACE_RENDER_BITMAP_SURFACE] = &vdp_output_surface_render_bitmap_surface,

[VDP_FUNC_ID_OUTPUT_SURFACE_RENDER_VIDEO_SURFACE_LUMA] = NULL,

[VDP_FUNC_ID_DECODER_QUERY_CAPABILITIES] = &vdp_decoder_query_capabilities,

[VDP_FUNC_ID_DECODER_CREATE] = &vdp_decoder_create,

[VDP_FUNC_ID_DECODER_DESTROY] = &vdp_decoder_destroy,

[VDP_FUNC_ID_DECODER_GET_PARAMETERS] = &vdp_decoder_get_parameters,

[VDP_FUNC_ID_DECODER_RENDER] = &vdp_decoder_render,

[VDP_FUNC_ID_VIDEO_MIXER_QUERY_FEATURE_SUPPORT] = &vdp_video_mixer_query_feature_support,

[VDP_FUNC_ID_VIDEO_MIXER_QUERY_PARAMETER_SUPPORT] = &vdp_video_mixer_query_parameter_support,

[VDP_FUNC_ID_VIDEO_MIXER_QUERY_ATTRIBUTE_SUPPORT] = &vdp_video_mixer_query_attribute_support,

[VDP_FUNC_ID_VIDEO_MIXER_QUERY_PARAMETER_VALUE_RANGE] = &vdp_video_mixer_query_parameter_value_range,

[VDP_FUNC_ID_VIDEO_MIXER_QUERY_ATTRIBUTE_VALUE_RANGE] = &vdp_video_mixer_query_attribute_value_range,

[VDP_FUNC_ID_VIDEO_MIXER_CREATE] = &vdp_video_mixer_create,

[VDP_FUNC_ID_VIDEO_MIXER_SET_FEATURE_ENABLES] = &vdp_video_mixer_set_feature_enables,

[VDP_FUNC_ID_VIDEO_MIXER_SET_ATTRIBUTE_VALUES] = &vdp_video_mixer_set_attribute_values,

[VDP_FUNC_ID_VIDEO_MIXER_GET_FEATURE_SUPPORT] = &vdp_video_mixer_get_feature_support,

[VDP_FUNC_ID_VIDEO_MIXER_GET_FEATURE_ENABLES] = &vdp_video_mixer_get_feature_enables,

[VDP_FUNC_ID_VIDEO_MIXER_GET_PARAMETER_VALUES] = &vdp_video_mixer_get_parameter_values,

[VDP_FUNC_ID_VIDEO_MIXER_GET_ATTRIBUTE_VALUES] = &vdp_video_mixer_get_attribute_values,

[VDP_FUNC_ID_VIDEO_MIXER_DESTROY] = &vdp_video_mixer_destroy,

[VDP_FUNC_ID_VIDEO_MIXER_RENDER] = &vdp_video_mixer_render,

[VDP_FUNC_ID_PRESENTATION_QUEUE_TARGET_DESTROY] = &vdp_presentation_queue_target_destroy,

[VDP_FUNC_ID_PRESENTATION_QUEUE_CREATE] = &vdp_presentation_queue_create,

[VDP_FUNC_ID_PRESENTATION_QUEUE_DESTROY] = &vdp_presentation_queue_destroy,

[VDP_FUNC_ID_PRESENTATION_QUEUE_SET_BACKGROUND_COLOR] = &vdp_presentation_queue_set_background_color,

[VDP_FUNC_ID_PRESENTATION_QUEUE_GET_BACKGROUND_COLOR] = &vdp_presentation_queue_get_background_color,

[VDP_FUNC_ID_PRESENTATION_QUEUE_GET_TIME] = &vdp_presentation_queue_get_time,

[VDP_FUNC_ID_PRESENTATION_QUEUE_DISPLAY] = &vdp_presentation_queue_display,

[VDP_FUNC_ID_PRESENTATION_QUEUE_BLOCK_UNTIL_SURFACE_IDLE] = &vdp_presentation_queue_block_until_surface_idle,

[VDP_FUNC_ID_PRESENTATION_QUEUE_QUERY_SURFACE_STATUS] = &vdp_presentation_queue_query_surface_status,

[VDP_FUNC_ID_PREEMPTION_CALLBACK_REGISTER] = &vdp_preemption_callback_register,

};

VdpStatus vdp_get_proc_address(VdpDevice device_handle, VdpFuncId function_id, void **function_pointer)

{

VdpStatus status;

if (!function_pointer)

return VDP_STATUS_INVALID_POINTER;

device_ctx_t *device = handle_get(device_handle);

if (!device)

return VDP_STATUS_INVALID_HANDLE;

if (function_id < ARRAY_SIZE(functions))

{

*function_pointer = functions[function_id];

if (*function_pointer == NULL)

status = VDP_STATUS_INVALID_FUNC_ID;

else

status = VDP_STATUS_OK;

}

else if (function_id == VDP_FUNC_ID_PRESENTATION_QUEUE_TARGET_CREATE_X11)

{

*function_pointer = &vdp_presentation_queue_target_create_x11;

status = VDP_STATUS_OK;

}

else

status = VDP_STATUS_INVALID_FUNC_ID;

handle_release(device_handle);

return status;

}

char const *vdp_get_error_string(VdpStatus status)

{

switch (status)

{

case VDP_STATUS_OK:

return "No error.";

case VDP_STATUS_NO_IMPLEMENTATION:

return "No backend implementation could be loaded.";

case VDP_STATUS_DISPLAY_PREEMPTED:

return "The display was preempted, or a fatal error occurred. The application must re-initialize VDPAU.";

case VDP_STATUS_INVALID_HANDLE:

return "An invalid handle value was provided.";

case VDP_STATUS_INVALID_POINTER:

return "An invalid pointer was provided.";

case VDP_STATUS_INVALID_CHROMA_TYPE:

return "An invalid/unsupported VdpChromaType value was supplied.";

case VDP_STATUS_INVALID_Y_CB_CR_FORMAT:

return "An invalid/unsupported VdpYCbCrFormat value was supplied.";

case VDP_STATUS_INVALID_RGBA_FORMAT:

return "An invalid/unsupported VdpRGBAFormat value was supplied.";

case VDP_STATUS_INVALID_INDEXED_FORMAT:

return "An invalid/unsupported VdpIndexedFormat value was supplied.";

case VDP_STATUS_INVALID_COLOR_STANDARD:

return "An invalid/unsupported VdpColorStandard value was supplied.";

case VDP_STATUS_INVALID_COLOR_TABLE_FORMAT:

return "An invalid/unsupported VdpColorTableFormat value was supplied.";

case VDP_STATUS_INVALID_BLEND_FACTOR:

return "An invalid/unsupported VdpOutputSurfaceRenderBlendFactor value was supplied.";

case VDP_STATUS_INVALID_BLEND_EQUATION:

return "An invalid/unsupported VdpOutputSurfaceRenderBlendEquation value was supplied.";

case VDP_STATUS_INVALID_FLAG:

return "An invalid/unsupported flag value/combination was supplied.";

case VDP_STATUS_INVALID_DECODER_PROFILE:

return "An invalid/unsupported VdpDecoderProfile value was supplied.";

case VDP_STATUS_INVALID_VIDEO_MIXER_FEATURE:

return "An invalid/unsupported VdpVideoMixerFeature value was supplied.";

case VDP_STATUS_INVALID_VIDEO_MIXER_PARAMETER:

return "An invalid/unsupported VdpVideoMixerParameter value was supplied.";

case VDP_STATUS_INVALID_VIDEO_MIXER_ATTRIBUTE:

return "An invalid/unsupported VdpVideoMixerAttribute value was supplied.";

case VDP_STATUS_INVALID_VIDEO_MIXER_PICTURE_STRUCTURE:

return "An invalid/unsupported VdpVideoMixerPictureStructure value was supplied.";

case VDP_STATUS_INVALID_FUNC_ID:

return "An invalid/unsupported VdpFuncId value was supplied.";

case VDP_STATUS_INVALID_SIZE:

return "The size of a supplied object does not match the object it is being used with.";

case VDP_STATUS_INVALID_VALUE:

return "An invalid/unsupported value was supplied.";

case VDP_STATUS_INVALID_STRUCT_VERSION:

return "An invalid/unsupported structure version was specified in a versioned structure.";

case VDP_STATUS_RESOURCES:

return "The system does not have enough resources to complete the requested operation at this time.";

case VDP_STATUS_HANDLE_DEVICE_MISMATCH:

return "The set of handles supplied are not all related to the same VdpDevice.";

case VDP_STATUS_ERROR:

return "A catch-all error, used when no other error code applies.";

default:

return "Unknown Error";

}

}

VdpStatus vdp_get_api_version(uint32_t *api_version)

{

if (!api_version)

return VDP_STATUS_INVALID_POINTER;

*api_version = 1;

return VDP_STATUS_OK;

}

VdpStatus vdp_get_information_string(char const **information_string)

{

if (!information_string)

return VDP_STATUS_INVALID_POINTER;

*information_string = "sunxi VDPAU Driver";

return VDP_STATUS_OK;

}