VdpStatus
softVdpPresentationQueueCreate(VdpDevice device,
VdpPresentationQueueTarget presentation_queue_target,
VdpPresentationQueue *presentation_queue)
{
if (!presentation_queue)
return VDP_STATUS_INVALID_POINTER;
VdpDeviceData *deviceData = handle_acquire(device, HANDLETYPE_DEVICE);
if (NULL == deviceData)
return VDP_STATUS_INVALID_HANDLE;
VdpPresentationQueueTargetData *targetData =
handle_acquire(presentation_queue_target, HANDLETYPE_PRESENTATION_QUEUE_TARGET);
if (NULL == targetData) {
handle_release(device);
return VDP_STATUS_INVALID_HANDLE;
}
VdpPresentationQueueData *data = calloc(1, sizeof(VdpPresentationQueueData));
if (NULL == data) {
handle_release(device);
handle_release(presentation_queue_target);
return VDP_STATUS_RESOURCES;
}
data->type = HANDLETYPE_PRESENTATION_QUEUE;
data->device = deviceData;
data->target = targetData;
data->bg_color.red = 0.0;
data->bg_color.green = 0.0;
data->bg_color.blue = 0.0;
data->bg_color.alpha = 0.0;
deviceData->refcount ++;
targetData->refcount ++;
*presentation_queue = handle_insert(data);
// initialize queue
data->queue.head = -1;
data->queue.used = 0;
for (unsigned int k = 0; k < PRESENTATION_QUEUE_LENGTH; k ++) {
data->queue.item[k].next = -1;
// other fields are zero due to calloc
}
for (unsigned int k = 0; k < PRESENTATION_QUEUE_LENGTH - 1; k ++)
data->queue.freelist[k] = k + 1;
data->queue.freelist[PRESENTATION_QUEUE_LENGTH - 1] = -1;
data->queue.firstfree = 0;
pthread_mutex_init(&data->queue_mutex, NULL);
pthread_cond_init(&data->new_work_available, NULL);
// launch worker thread
pthread_create(&data->worker_thread, NULL, presentation_thread,
(void *)(size_t)(*presentation_queue));
handle_release(device);
handle_release(presentation_queue_target);
return VDP_STATUS_OK;
}
VdpStatus
softVdpPresentationQueueTargetDestroy(VdpPresentationQueueTarget presentation_queue_target)
{
VdpPresentationQueueTargetData *pqTargetData =
handle_acquire(presentation_queue_target, HANDLETYPE_PRESENTATION_QUEUE_TARGET);
if (NULL == pqTargetData)
return VDP_STATUS_INVALID_HANDLE;
VdpDeviceData *deviceData = pqTargetData->device;
if (0 != pqTargetData->refcount) {
traceError("warning (softVdpPresentationQueueTargetDestroy): non-zero reference"
"count (%d)\n", pqTargetData->refcount);
handle_release(presentation_queue_target);
return VDP_STATUS_ERROR;
}
// drawable may be destroyed already, so one should activate global context
glx_context_push_thread_local(deviceData);
glXDestroyContext(deviceData->display, pqTargetData->glc);
GLenum gl_error = glGetError();
glx_context_pop();
if (GL_NO_ERROR != gl_error) {
traceError("error (VdpPresentationQueueTargetDestroy): gl error %d\n", gl_error);
handle_release(presentation_queue_target);
return VDP_STATUS_ERROR;
}
deviceData->refcount --;
handle_expunge(presentation_queue_target);
free(pqTargetData);
return VDP_STATUS_OK;
}
VdpStatus
softVdpPresentationQueueBlockUntilSurfaceIdle(VdpPresentationQueue presentation_queue,
VdpOutputSurface surface,
VdpTime *first_presentation_time)
{
if (!first_presentation_time)
return VDP_STATUS_INVALID_POINTER;
VdpPresentationQueueData *pqData =
handle_acquire(presentation_queue, HANDLETYPE_PRESENTATION_QUEUE);
if (NULL == pqData)
return VDP_STATUS_INVALID_HANDLE;
handle_release(presentation_queue);
VdpOutputSurfaceData *surfData = handle_acquire(surface, HANDLETYPE_OUTPUT_SURFACE);
if (NULL == surfData)
return VDP_STATUS_INVALID_HANDLE;
// TODO: use locking instead of busy loop
while (surfData->status != VDP_PRESENTATION_QUEUE_STATUS_IDLE) {
handle_release(surface);
usleep(1000);
surfData = handle_acquire(surface, HANDLETYPE_OUTPUT_SURFACE);
if (!surfData)
return VDP_STATUS_ERROR;
}
*first_presentation_time = surfData->first_presentation_time;
handle_release(surface);
return VDP_STATUS_OK;
}
VdpStatus
softVdpPresentationQueueQuerySurfaceStatus(VdpPresentationQueue presentation_queue,
VdpOutputSurface surface,
VdpPresentationQueueStatus *status,
VdpTime *first_presentation_time)
{
if (!status || !first_presentation_time)
return VDP_STATUS_INVALID_POINTER;
VdpPresentationQueueData *pqData =
handle_acquire(presentation_queue, HANDLETYPE_PRESENTATION_QUEUE);
if (NULL == pqData)
return VDP_STATUS_INVALID_HANDLE;
VdpOutputSurfaceData *surfData = handle_acquire(surface, HANDLETYPE_OUTPUT_SURFACE);
if (NULL == surfData) {
handle_release(presentation_queue);
return VDP_STATUS_INVALID_HANDLE;
}
*status = surfData->status;
*first_presentation_time = surfData->first_presentation_time;
handle_release(presentation_queue);
handle_release(surface);
return VDP_STATUS_OK;
}
VdpStatus vdp_decoder_render(VdpDecoder decoder, VdpVideoSurface target, VdpPictureInfo const *picture_info, uint32_t bitstream_buffer_count, VdpBitstreamBuffer const *bitstream_buffers)
{
VdpStatus status = VDP_STATUS_INVALID_HANDLE;
decoder_ctx_t *dec = handle_get(decoder);
if (!dec)
return VDP_STATUS_INVALID_HANDLE;
video_surface_ctx_t *vid = handle_get(target);
if (!vid)
{
handle_release(decoder);
return VDP_STATUS_INVALID_HANDLE;
}
vid->source_format = INTERNAL_YCBCR_FORMAT;
unsigned int i, pos = 0;
for (i = 0; i < bitstream_buffer_count; i++)
{
cedarv_memcpy(dec->data, pos, bitstream_buffers[i].bitstream, bitstream_buffers[i].bitstream_bytes);
pos += bitstream_buffers[i].bitstream_bytes;
}
//memory is mapped unchached, therefore no flush necessary. hopefully ;)
cedarv_flush_cache(dec->data, pos);
status = dec->decode(dec, picture_info, pos, vid);
handle_release(target);
handle_release(decoder);
return status;
}
VdpStatus
softVdpDecoderRender(VdpDecoder decoder, VdpVideoSurface target,
VdpPictureInfo const *picture_info, uint32_t bitstream_buffer_count,
VdpBitstreamBuffer const *bitstream_buffers)
{
VdpStatus err_code;
if (!picture_info || !bitstream_buffers)
return VDP_STATUS_INVALID_POINTER;
VdpDecoderData *decoderData = handle_acquire(decoder, HANDLETYPE_DECODER);
VdpVideoSurfaceData *dstSurfData = handle_acquire(target, HANDLETYPE_VIDEO_SURFACE);
if (NULL == decoderData || NULL == dstSurfData) {
err_code = VDP_STATUS_INVALID_HANDLE;
goto quit;
}
if (VDP_DECODER_PROFILE_H264_BASELINE == decoderData->profile ||
VDP_DECODER_PROFILE_H264_MAIN == decoderData->profile ||
VDP_DECODER_PROFILE_H264_HIGH == decoderData->profile)
{
// TODO: check exit code
softVdpDecoderRender_h264(decoder, decoderData, dstSurfData, picture_info,
bitstream_buffer_count, bitstream_buffers);
} else {
traceError("error (softVdpDecoderRender): no implementation for profile %s\n",
reverse_decoder_profile(decoderData->profile));
err_code = VDP_STATUS_NO_IMPLEMENTATION;
goto quit;
}
err_code = VDP_STATUS_OK;
quit:
handle_release(decoder);
handle_release(target);
return err_code;
}
VdpStatus vdp_video_mixer_render(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)
{
mixer_ctx_t *mix = handle_get(mixer);
if (!mix)
return VDP_STATUS_INVALID_HANDLE;
if (background_surface != VDP_INVALID_HANDLE)
VDPAU_DBG_ONCE("Requested unimplemented background_surface");
if (current_picture_structure != VDP_VIDEO_MIXER_PICTURE_STRUCTURE_FRAME)
VDPAU_DBG_ONCE("Requested unimplemented picture_structure");
output_surface_ctx_t *os = handle_get(destination_surface);
if (!os)
return VDP_STATUS_INVALID_HANDLE;
os->vs = handle_get(video_surface_current);
if (!(os->vs))
return VDP_STATUS_INVALID_HANDLE;
if (destination_video_rect)
{
os->video_dst_rect = *destination_video_rect;
if (video_source_rect)
os->video_src_rect = *video_source_rect;
else
{
os->video_src_rect.x0 = os->video_src_rect.y0 = 0;
os->video_src_rect.x1 = os->vs->width;
os->video_src_rect.y1 = os->vs->height;
}
}
os->csc_change = mix->csc_change;
os->brightness = mix->brightness;
os->contrast = mix->contrast;
os->saturation = mix->saturation;
os->hue = mix->hue;
mix->csc_change = 0;
if (layer_count != 0)
VDPAU_DBG_ONCE("Requested unimplemented additional layers");
handle_release(mixer);
handle_release(destination_surface);
handle_release(video_surface_current);
return VDP_STATUS_OK;
}
VdpStatus vdp_output_surface_create(VdpDevice device, VdpRGBAFormat rgba_format, uint32_t width, uint32_t height, VdpOutputSurface *surface)
{
int status = VDP_STATUS_OK;
if (!surface)
return VDP_STATUS_INVALID_POINTER;
if (!width || !height)
return VDP_STATUS_INVALID_SIZE;
device_ctx_t *dev = handle_get(device);
if (!dev)
return VDP_STATUS_INVALID_HANDLE;
output_surface_ctx_t *out = handle_create(sizeof(*out), surface, htype_output);
if (out)
{
memset(out, 0, sizeof(*out));
out->width = width;
out->height = height;
out->rgba_format = rgba_format;
out->contrast = 1.0;
out->saturation = 1.0;
out->device = dev;
}
else{
status = VDP_STATUS_RESOURCES;
}
handle_release(device);
return status;
}
VdpStatus vdp_video_surface_destroy(VdpVideoSurface surface)
{
video_surface_ctx_t *vs = handle_get(surface);
if (!vs)
return VDP_STATUS_INVALID_HANDLE;
if (vs->decoder_private_free)
vs->decoder_private_free(vs);
if( cedarv_isValid(vs->dataY) )
cedarv_free(vs->dataY);
if( cedarv_isValid(vs->dataU) )
cedarv_free(vs->dataU);
if (cedarv_isValid(vs->dataV) )
cedarv_free(vs->dataV);
cedarv_setBufferInvalid(vs->dataY);
cedarv_setBufferInvalid(vs->dataU);
cedarv_setBufferInvalid(vs->dataV);
VDPAU_DBG("vdpau video surface=%d destroyed", surface);
handle_release(surface);
handle_destroy(surface);
return VDP_STATUS_OK;
}
static int bsc_handle_lchan_signal(unsigned int subsys, unsigned int signal,
void *handler_data, void *signal_data)
{
struct bsc_api *bsc;
struct gsm_lchan *lchan;
struct lchan_signal_data *lchan_data;
if (subsys != SS_LCHAN)
return 0;
lchan_data = signal_data;
if (!lchan_data->lchan || !lchan_data->lchan->conn)
return 0;
lchan = lchan_data->lchan;
bsc = lchan->ts->trx->bts->network->bsc_api;
if (!bsc)
return 0;
switch (signal) {
case S_LCHAN_UNEXPECTED_RELEASE:
handle_release(lchan->conn, bsc, lchan);
break;
case S_LCHAN_ACTIVATE_ACK:
handle_chan_ack(lchan->conn, bsc, lchan);
break;
case S_LCHAN_ACTIVATE_NACK:
handle_chan_nack(lchan->conn, bsc, lchan);
break;
}
return 0;
}
VdpStatus vdp_video_mixer_query_parameter_support(VdpDevice device, VdpVideoMixerParameter parameter, VdpBool *is_supported)
{
if (!is_supported)
return VDP_STATUS_INVALID_POINTER;
device_ctx_t *dev = handle_get(device);
if (!dev)
return VDP_STATUS_INVALID_HANDLE;
switch (parameter)
{
case VDP_VIDEO_MIXER_PARAMETER_CHROMA_TYPE:
case VDP_VIDEO_MIXER_PARAMETER_LAYERS:
case VDP_VIDEO_MIXER_PARAMETER_VIDEO_SURFACE_HEIGHT:
case VDP_VIDEO_MIXER_PARAMETER_VIDEO_SURFACE_WIDTH:
*is_supported = VDP_TRUE;
break;
default:
*is_supported = VDP_FALSE;
break;
}
handle_release(device);
return VDP_STATUS_OK;
}
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;
}
static int memcachefs_mknod(const char *path, mode_t mode, dev_t rdev)
{
int ret;
handle_t *handle;
char *key;
size_t keylen;
if(opt.verbose){
fprintf(stderr, "%s(\"%s\", 0%o)\n", __func__, path, mode);
}
if(!S_ISREG(mode)){
return -ENOSYS;
}
handle = handle_get(pool);
if(!handle){
return -EMFILE;
}
key = (char *)path + 1;
keylen = strlen(key);
ret = mc_set(handle->mc, key, keylen, "", 0, 0, 0);
handle_release(pool, handle->index);
if(ret){
return -EIO;
}
return 0;
}
static int memcachefs_truncate(const char* path, off_t length)
{
int ret;
handle_t *handle;
char *key;
size_t keylen;
if(opt.verbose){
fprintf(stderr, "%s(\"%s\", %lld)\n", __func__, path, length);
}
if(length != 0){
return -ENOSYS;
}
handle = handle_get(pool);
if(!handle){
return -EMFILE;
}
key = (char *)path + 1;
keylen = strlen(key);
ret = mc_set(handle->mc, key, keylen, "", 0, 0, 0);
handle_release(pool, handle->index);
if(ret){
return -EIO;
}
return 0;
}
VdpStatus vdp_video_mixer_query_parameter_value_range(VdpDevice device, VdpVideoMixerParameter parameter, void *min_value, void *max_value)
{
if (!min_value || !max_value)
return VDP_STATUS_INVALID_POINTER;
device_ctx_t *dev = handle_get(device);
if (!dev)
return VDP_STATUS_INVALID_HANDLE;
switch (parameter)
{
case VDP_VIDEO_MIXER_PARAMETER_LAYERS:
*(uint32_t *)min_value = 0;
*(uint32_t *)max_value = 0;
return VDP_STATUS_OK;
case VDP_VIDEO_MIXER_PARAMETER_VIDEO_SURFACE_HEIGHT:
case VDP_VIDEO_MIXER_PARAMETER_VIDEO_SURFACE_WIDTH:
*(uint32_t *)min_value = 0;
*(uint32_t *)max_value = 8192;
return VDP_STATUS_OK;
}
handle_release(device);
return VDP_STATUS_ERROR;
}
VdpStatus vdp_output_surface_render_output_surface(VdpOutputSurface destination_surface, VdpRect const *destination_rect, VdpOutputSurface source_surface, VdpRect const *source_rect, VdpColor const *colors, VdpOutputSurfaceRenderBlendState const *blend_state, uint32_t flags)
{
output_surface_ctx_t *out = handle_get(destination_surface);
if (!out)
return VDP_STATUS_INVALID_HANDLE;
output_surface_ctx_t *in = handle_get(source_surface);
if (!in)
return VDP_STATUS_INVALID_HANDLE;
VDPAU_DBG_ONCE("%s called but unimplemented!", __func__);
handle_release(destination_surface);
handle_release(source_surface);
return VDP_STATUS_OK;
}
static int memcachefs_getattr(const char *path, struct stat *stbuf)
{
handle_t *handle;
char *key;
size_t keylen;
void *val;
size_t vallen;
if(opt.verbose){
fprintf(stderr, "%s(\"%s\")\n", __func__, path);
}
memset(stbuf, 0, sizeof(struct stat));
if(!strcmp(path, "/")){
stbuf->st_ino = 1;
stbuf->st_mode = S_IFDIR | 0755;
// stbuf->st_mode = S_IFDIR;
stbuf->st_uid = fuse_get_context()->uid;
stbuf->st_gid = fuse_get_context()->gid;
stbuf->st_nlink = 1;
stbuf->st_atime = 0;
stbuf->st_mtime = 0;
stbuf->st_size = 0;
return 0;
}
handle = handle_get(pool);
if(!handle){
return -EMFILE;
}
key = (char *)path + 1;
keylen = strlen(key);
val = (char*)mc_aget2(handle->mc, key, keylen, &vallen);
handle_release(pool, handle->index);
if(!val){
return -ENOENT;
}
// get file attrs
char *attrs = get_attrvalue(key);
if (attrs != NULL) {
stbuf->st_mode = S_IFDIR | 0666;
} else {
stbuf->st_mode = S_IFREG | 0666;
}
// printf("SAIDA: %s\n", attrs);
// stbuf->st_mode = S_IFREG | 0666;
// stbuf->st_mode = S_IFDIR | 0666;
stbuf->st_uid = fuse_get_context()->uid;
stbuf->st_gid = fuse_get_context()->gid;
stbuf->st_nlink = 1;
stbuf->st_size = vallen;
free(val);
free(attrs);
return 0;
}
VdpStatus vdp_video_surface_get_bits_y_cb_cr(VdpVideoSurface surface, VdpYCbCrFormat destination_ycbcr_format, void *const *destination_data, uint32_t const *destination_pitches)
{
video_surface_ctx_t *vs = handle_get(surface);
if (!vs)
return VDP_STATUS_INVALID_HANDLE;
handle_release(surface);
return VDP_STATUS_ERROR;
}
VdpStatus vdp_output_surface_get_bits_native(VdpOutputSurface surface, VdpRect const *source_rect, void *const *destination_data, uint32_t const *destination_pitches)
{
output_surface_ctx_t *out = handle_get(surface);
if (!out)
return VDP_STATUS_INVALID_HANDLE;
handle_release(surface);
return VDP_STATUS_ERROR;
}
static int memcachefs_release(const char *path, struct fuse_file_info *fi)
{
if(opt.verbose){
fprintf(stderr, "%s(\"%s\")\n", __func__, path);
}
handle_release(pool, fi->fh);
return 0;
}
VdpStatus
softVdpPresentationQueueTargetCreateX11(VdpDevice device, Drawable drawable,
VdpPresentationQueueTarget *target)
{
if (!target)
return VDP_STATUS_INVALID_POINTER;
VdpDeviceData *deviceData = handle_acquire(device, HANDLETYPE_DEVICE);
if (NULL == deviceData)
return VDP_STATUS_INVALID_HANDLE;
VdpPresentationQueueTargetData *data = calloc(1, sizeof(VdpPresentationQueueTargetData));
if (NULL == data) {
handle_release(device);
return VDP_STATUS_RESOURCES;
}
data->type = HANDLETYPE_PRESENTATION_QUEUE_TARGET;
data->device = deviceData;
data->drawable = drawable;
data->refcount = 0;
pthread_mutex_lock(&global.glx_ctx_stack_mutex);
GLint att[] = { GLX_RGBA, GLX_DEPTH_SIZE, 24, GLX_DOUBLEBUFFER, None };
XVisualInfo *vi;
vi = glXChooseVisual(deviceData->display, deviceData->screen, att);
if (NULL == vi) {
traceError("error (softVdpPresentationQueueTargetCreateX11): glXChooseVisual failed\n");
free(data);
pthread_mutex_unlock(&global.glx_ctx_stack_mutex);
handle_release(device);
return VDP_STATUS_ERROR;
}
// create context for dislaying result (can share display lists with deviceData->glc
data->glc = glXCreateContext(deviceData->display, vi, deviceData->root_glc, GL_TRUE);
deviceData->refcount ++;
*target = handle_insert(data);
pthread_mutex_unlock(&global.glx_ctx_stack_mutex);
handle_release(device);
return VDP_STATUS_OK;
}
VdpStatus
vdpVideoSurfaceDestroy(VdpVideoSurface surface)
{
VdpVideoSurfaceData *videoSurfData = handle_acquire(surface, HANDLETYPE_VIDEO_SURFACE);
if (NULL == videoSurfData)
return VDP_STATUS_INVALID_HANDLE;
VdpDeviceData *deviceData = videoSurfData->deviceData;
glx_ctx_push_thread_local(deviceData);
glDeleteTextures(1, &videoSurfData->tex_id);
GLenum gl_error = glGetError();
glx_ctx_pop();
if (GL_NO_ERROR != gl_error) {
traceError("error (%s): gl error %d\n", __func__, gl_error);
handle_release(surface);
return VDP_STATUS_ERROR;
}
if (deviceData->va_available) {
// return VA surface to the free list
if (videoSurfData->decoder != VDP_INVALID_HANDLE) {
VdpDecoderData *dd = handle_acquire(videoSurfData->decoder, HANDLETYPE_DECODER);
if (NULL != dd) {
free_list_push(dd->free_list, &dd->free_list_head, videoSurfData->rt_idx);
handle_release(videoSurfData->decoder);
}
}
// .va_surf will be freed in VdpDecoderDestroy
}
if (videoSurfData->y_plane)
free(videoSurfData->y_plane);
if (videoSurfData->u_plane)
free(videoSurfData->u_plane);
// do not free videoSurfData->v_plane, it's just pointer into the middle of u_plane
unref_device(deviceData);
handle_expunge(surface);
free(videoSurfData);
return VDP_STATUS_OK;
}
VdpStatus vdp_video_mixer_destroy(VdpVideoMixer mixer)
{
mixer_ctx_t *mix = handle_get(mixer);
if (!mix)
return VDP_STATUS_INVALID_HANDLE;
handle_release(mixer);
handle_destroy(mixer);
return VDP_STATUS_OK;
}
static int memcachefs_rename(const char *from, const char *to)
{
int ret;
handle_t *handle;
char *key;
size_t keylen;
void *val;
size_t vallen;
if(opt.verbose){
fprintf(stderr, "%s(%s -> %s)\n", __func__, from, to);
}
handle = handle_get(pool);
key = (char *)from + 1;
keylen = strlen(key);
val = (char*)mc_aget2(handle->mc, key, keylen, &vallen);
if(!val){
handle_release(pool, handle->index);
return -ENOENT;
}
key = (char *)to + 1;
keylen = strlen(key);
ret = mc_set(handle->mc, key, keylen, val, vallen, 0, 0);
if(ret){
handle_release(pool, handle->index);
return -EIO;
}
key = (char *)from + 1;
keylen = strlen(key);
ret = mc_delete(handle->mc, key, keylen, 0);
if(ret){
handle_release(pool, handle->index);
return -EIO;
}
free(val);
return 0;
}
VdpStatus vdp_video_mixer_get_attribute_values(VdpVideoMixer mixer, uint32_t attribute_count, VdpVideoMixerAttribute const *attributes, void *const *attribute_values)
{
if (!attributes || !attribute_values)
return VDP_STATUS_INVALID_POINTER;
mixer_ctx_t *mix = handle_get(mixer);
if (!mix)
return VDP_STATUS_INVALID_HANDLE;
handle_release(mixer);
return VDP_STATUS_ERROR;
}
VdpStatus vdp_output_surface_put_bits_y_cb_cr(VdpOutputSurface surface, VdpYCbCrFormat source_ycbcr_format, void const *const *source_data, uint32_t const *source_pitches, VdpRect const *destination_rect, VdpCSCMatrix const *csc_matrix)
{
output_surface_ctx_t *out = handle_get(surface);
if (!out)
return VDP_STATUS_INVALID_HANDLE;
VDPAU_DBG_ONCE("%s called but unimplemented!", __func__);
handle_release(surface);
return VDP_STATUS_OK;
}
VdpStatus vdp_video_mixer_get_parameter_values(VdpVideoMixer mixer, uint32_t parameter_count, VdpVideoMixerParameter const *parameters, void *const *parameter_values)
{
if (!parameters || !parameter_values)
return VDP_STATUS_INVALID_POINTER;
mixer_ctx_t *mix = handle_get(mixer);
if (!mix)
return VDP_STATUS_INVALID_HANDLE;
handle_release(mixer);
return VDP_STATUS_ERROR;
}
VdpStatus vdp_output_surface_put_bits_indexed(VdpOutputSurface surface, VdpIndexedFormat source_indexed_format, void const *const *source_data, uint32_t const *source_pitch, VdpRect const *destination_rect, VdpColorTableFormat color_table_format, void const *color_table)
{
output_surface_ctx_t *out = handle_get(surface);
if (!out)
return VDP_STATUS_INVALID_HANDLE;
VDPAU_DBG_ONCE("%s called but unimplemented!", __func__);
handle_release(surface);
return VDP_STATUS_OK;
}
VdpStatus vdp_video_mixer_get_feature_enables(VdpVideoMixer mixer, uint32_t feature_count, VdpVideoMixerFeature const *features, VdpBool *feature_enables)
{
if (!features || !feature_enables)
return VDP_STATUS_INVALID_POINTER;
mixer_ctx_t *mix = handle_get(mixer);
if (!mix)
return VDP_STATUS_INVALID_HANDLE;
handle_release(mixer);
return VDP_STATUS_ERROR;
}
VdpStatus vdp_output_surface_put_bits_native(VdpOutputSurface surface, void const *const *source_data, uint32_t const *source_pitches, VdpRect const *destination_rect)
{
output_surface_ctx_t *out = handle_get(surface);
if (!out)
return VDP_STATUS_INVALID_HANDLE;
VDPAU_DBG_ONCE("%s called but unimplemented!", __func__);
handle_release(surface);
return VDP_STATUS_OK;
}
