/**
* Copy image data from a VdpVideoSurface to application memory in a specified
* YCbCr format.
*/
VdpStatus
vlVdpVideoSurfaceGetBitsYCbCr(VdpVideoSurface surface,
VdpYCbCrFormat destination_ycbcr_format,
void *const *destination_data,
uint32_t const *destination_pitches)
{
vlVdpSurface *vlsurface;
struct pipe_context *pipe;
enum pipe_format format, buffer_format;
struct pipe_sampler_view **sampler_views;
enum getbits_conversion conversion = CONVERSION_NONE;
unsigned i, j;
vlsurface = vlGetDataHTAB(surface);
if (!vlsurface)
return VDP_STATUS_INVALID_HANDLE;
pipe = vlsurface->device->context;
if (!pipe)
return VDP_STATUS_INVALID_HANDLE;
if (!destination_data || !destination_pitches)
return VDP_STATUS_INVALID_POINTER;
format = FormatYCBCRToPipe(destination_ycbcr_format);
if (format == PIPE_FORMAT_NONE)
return VDP_STATUS_INVALID_Y_CB_CR_FORMAT;
if (vlsurface->video_buffer == NULL)
return VDP_STATUS_INVALID_VALUE;
buffer_format = vlsurface->video_buffer->buffer_format;
if (format != buffer_format) {
if (format == PIPE_FORMAT_YV12 && buffer_format == PIPE_FORMAT_NV12)
conversion = CONVERSION_NV12_TO_YV12;
else if (format == PIPE_FORMAT_NV12 && buffer_format == PIPE_FORMAT_YV12)
conversion = CONVERSION_YV12_TO_NV12;
else if ((format == PIPE_FORMAT_YUYV && buffer_format == PIPE_FORMAT_UYVY) ||
(format == PIPE_FORMAT_UYVY && buffer_format == PIPE_FORMAT_YUYV))
conversion = CONVERSION_SWAP_YUYV_UYVY;
else
return VDP_STATUS_NO_IMPLEMENTATION;
}
pipe_mutex_lock(vlsurface->device->mutex);
sampler_views = vlsurface->video_buffer->get_sampler_view_planes(vlsurface->video_buffer);
if (!sampler_views) {
pipe_mutex_unlock(vlsurface->device->mutex);
return VDP_STATUS_RESOURCES;
}
for (i = 0; i < 3; ++i) {
unsigned width, height;
struct pipe_sampler_view *sv = sampler_views[i];
if (!sv) continue;
vlVdpVideoSurfaceSize(vlsurface, i, &width, &height);
for (j = 0; j < sv->texture->array_size; ++j) {
struct pipe_box box = {
0, 0, j,
width, height, 1
};
struct pipe_transfer *transfer;
uint8_t *map;
map = pipe->transfer_map(pipe, sv->texture, 0,
PIPE_TRANSFER_READ, &box, &transfer);
if (!map) {
pipe_mutex_unlock(vlsurface->device->mutex);
return VDP_STATUS_RESOURCES;
}
if (conversion == CONVERSION_NV12_TO_YV12 && i == 1) {
u_copy_nv12_to_yv12(destination_data, destination_pitches,
i, j, transfer->stride, sv->texture->array_size,
map, box.width, box.height);
} else if (conversion == CONVERSION_YV12_TO_NV12 && i > 0) {
u_copy_yv12_to_nv12(destination_data, destination_pitches,
i, j, transfer->stride, sv->texture->array_size,
map, box.width, box.height);
} else if (conversion == CONVERSION_SWAP_YUYV_UYVY) {
u_copy_swap422_packed(destination_data, destination_pitches,
i, j, transfer->stride, sv->texture->array_size,
map, box.width, box.height);
} else {
util_copy_rect(destination_data[i] + destination_pitches[i] * j, sv->texture->format,
destination_pitches[i] * sv->texture->array_size, 0, 0,
box.width, box.height, map, transfer->stride, 0, 0);
}
pipe_transfer_unmap(pipe, transfer);
}
}
pipe_mutex_unlock(vlsurface->device->mutex);
return VDP_STATUS_OK;
}
VAStatus
vlVaGetImage(VADriverContextP ctx, VASurfaceID surface, int x, int y,
unsigned int width, unsigned int height, VAImageID image)
{
vlVaDriver *drv;
vlVaSurface *surf;
vlVaBuffer *img_buf;
VAImage *vaimage;
struct pipe_sampler_view **views;
enum pipe_format format;
bool convert = false;
void *data[3];
unsigned pitches[3], i, j;
if (!ctx)
return VA_STATUS_ERROR_INVALID_CONTEXT;
drv = VL_VA_DRIVER(ctx);
pipe_mutex_lock(drv->mutex);
surf = handle_table_get(drv->htab, surface);
if (!surf || !surf->buffer) {
pipe_mutex_unlock(drv->mutex);
return VA_STATUS_ERROR_INVALID_SURFACE;
}
vaimage = handle_table_get(drv->htab, image);
if (!vaimage) {
pipe_mutex_unlock(drv->mutex);
return VA_STATUS_ERROR_INVALID_IMAGE;
}
img_buf = handle_table_get(drv->htab, vaimage->buf);
if (!img_buf) {
pipe_mutex_unlock(drv->mutex);
return VA_STATUS_ERROR_INVALID_BUFFER;
}
format = VaFourccToPipeFormat(vaimage->format.fourcc);
if (format == PIPE_FORMAT_NONE) {
pipe_mutex_unlock(drv->mutex);
return VA_STATUS_ERROR_OPERATION_FAILED;
}
if (format != surf->buffer->buffer_format) {
/* support NV12 to YV12 and IYUV conversion now only */
if ((format == PIPE_FORMAT_YV12 &&
surf->buffer->buffer_format == PIPE_FORMAT_NV12) ||
(format == PIPE_FORMAT_IYUV &&
surf->buffer->buffer_format == PIPE_FORMAT_NV12))
convert = true;
else {
pipe_mutex_unlock(drv->mutex);
return VA_STATUS_ERROR_OPERATION_FAILED;
}
}
views = surf->buffer->get_sampler_view_planes(surf->buffer);
if (!views) {
pipe_mutex_unlock(drv->mutex);
return VA_STATUS_ERROR_OPERATION_FAILED;
}
for (i = 0; i < vaimage->num_planes; i++) {
data[i] = img_buf->data + vaimage->offsets[i];
pitches[i] = vaimage->pitches[i];
}
if (vaimage->format.fourcc == VA_FOURCC('I','4','2','0')) {
void *tmp_d;
unsigned tmp_p;
tmp_d = data[1];
data[1] = data[2];
data[2] = tmp_d;
tmp_p = pitches[1];
pitches[1] = pitches[2];
pitches[2] = tmp_p;
}
for (i = 0; i < vaimage->num_planes; i++) {
unsigned width, height;
if (!views[i]) continue;
vlVaVideoSurfaceSize(surf, i, &width, &height);
for (j = 0; j < views[i]->texture->array_size; ++j) {
struct pipe_box box = {0, 0, j, width, height, 1};
struct pipe_transfer *transfer;
uint8_t *map;
map = drv->pipe->transfer_map(drv->pipe, views[i]->texture, 0,
PIPE_TRANSFER_READ, &box, &transfer);
if (!map) {
pipe_mutex_unlock(drv->mutex);
return VA_STATUS_ERROR_OPERATION_FAILED;
}
if (i == 1 && convert) {
u_copy_nv12_to_yv12(data, pitches, i, j,
transfer->stride, views[i]->texture->array_size,
map, box.width, box.height);
} else {
util_copy_rect(data[i] + pitches[i] * j,
views[i]->texture->format,
pitches[i] * views[i]->texture->array_size, 0, 0,
box.width, box.height, map, transfer->stride, 0, 0);
}
pipe_transfer_unmap(drv->pipe, transfer);
}
}
pipe_mutex_unlock(drv->mutex);
return VA_STATUS_SUCCESS;
}
