static void test_nv_i915_reimport_twice_check_flink_name(void)
{
drm_intel_bo *intel_bo = NULL, *intel_bo2 = NULL;
int prime_fd;
struct nouveau_bo *nvbo = NULL;
uint32_t flink_name1, flink_name2;
igt_assert(nouveau_bo_new(ndev, NOUVEAU_BO_GART | NOUVEAU_BO_MAP,
0, BO_SIZE, NULL, &nvbo) == 0);
igt_assert(nouveau_bo_set_prime(nvbo, &prime_fd) == 0);
intel_bo = drm_intel_bo_gem_create_from_prime(bufmgr, prime_fd, BO_SIZE);
igt_assert(intel_bo);
close(prime_fd);
igt_assert(nouveau_bo_set_prime(nvbo, &prime_fd) == 0);
intel_bo2 = drm_intel_bo_gem_create_from_prime(bufmgr2, prime_fd, BO_SIZE);
igt_assert(intel_bo2);
close(prime_fd);
igt_assert(drm_intel_bo_flink(intel_bo, &flink_name1) == 0);
igt_assert(drm_intel_bo_flink(intel_bo2, &flink_name2) == 0);
igt_assert_eq_u32(flink_name1, flink_name2);
nouveau_bo_ref(NULL, &nvbo);
drm_intel_bo_unreference(intel_bo);
drm_intel_bo_unreference(intel_bo2);
}
struct intel_region *
intel_region_alloc_for_fd(struct intel_screen *screen,
GLuint cpp,
GLuint width, GLuint height, GLuint pitch,
int fd, const char *name)
{
struct intel_region *region;
drm_intel_bo *buffer;
int ret;
uint32_t bit_6_swizzle, tiling;
buffer = drm_intel_bo_gem_create_from_prime(screen->bufmgr,
fd, height * pitch);
if (buffer == NULL)
return NULL;
ret = drm_intel_bo_get_tiling(buffer, &tiling, &bit_6_swizzle);
if (ret != 0) {
fprintf(stderr, "Couldn't get tiling of buffer (%s): %s\n",
name, strerror(-ret));
drm_intel_bo_unreference(buffer);
return NULL;
}
region = intel_region_alloc_internal(screen, cpp,
width, height, pitch, tiling, buffer);
if (region == NULL) {
drm_intel_bo_unreference(buffer);
return NULL;
}
return region;
}
static PixmapPtr intel_dri3_pixmap_from_fd(ScreenPtr screen,
int fd,
CARD16 width,
CARD16 height,
CARD16 stride,
CARD8 depth,
CARD8 bpp)
{
ScrnInfoPtr scrn = xf86ScreenToScrn(screen);
intel_screen_private *intel = intel_get_screen_private(scrn);
struct intel_uxa_pixmap *priv;
PixmapPtr pixmap;
dri_bo *bo;
if (depth < 8)
return NULL;
switch (bpp) {
case 8:
case 16:
case 32:
break;
default:
return NULL;
}
pixmap = fbCreatePixmap(screen, 0, 0, depth, 0);
if (!pixmap)
return NULL;
if (!screen->ModifyPixmapHeader(pixmap, width, height, 0, 0, stride, NULL))
goto free_pixmap;
bo = drm_intel_bo_gem_create_from_prime(intel->bufmgr,
fd, (uint32_t)height * stride);
if (bo == NULL)
goto free_pixmap;
intel_uxa_set_pixmap_bo(pixmap, bo);
dri_bo_unreference(bo);
priv = intel_uxa_get_pixmap_private(pixmap);
if (priv == NULL)
goto free_pixmap;
priv->pinned |= PIN_DRI3;
return pixmap;
free_pixmap:
fbDestroyPixmap(pixmap);
return NULL;
}
static __DRIimage *
intel_create_image_from_fds(__DRIscreen *screen,
int width, int height, int fourcc,
int *fds, int num_fds, int *strides, int *offsets,
void *loaderPrivate)
{
struct intel_screen *intelScreen = screen->driverPrivate;
struct intel_image_format *f;
__DRIimage *image;
int i, index;
if (fds == NULL || num_fds != 1)
return NULL;
f = intel_image_format_lookup(fourcc);
if (f == NULL)
return NULL;
if (f->nplanes == 1)
image = intel_allocate_image(f->planes[0].dri_format, loaderPrivate);
else
image = intel_allocate_image(__DRI_IMAGE_FORMAT_NONE, loaderPrivate);
if (image == NULL)
return NULL;
image->bo = drm_intel_bo_gem_create_from_prime(intelScreen->bufmgr,
fds[0],
height * strides[0]);
if (image->bo == NULL) {
free(image);
return NULL;
}
image->width = width;
image->height = height;
image->pitch = strides[0];
image->planar_format = f;
for (i = 0; i < f->nplanes; i++) {
index = f->planes[i].buffer_index;
image->offsets[index] = offsets[index];
image->strides[index] = strides[index];
}
if (f->nplanes == 1) {
image->offset = image->offsets[0];
intel_image_warn_if_unaligned(image, __func__);
}
return image;
}
/* export handle from intel driver - reimport to another intel driver bufmgr
see if you get same object */
static void test_i915_self_import_to_different_fd(void)
{
drm_intel_bo *test_intel_bo, *test_intel_bo2;
int prime_fd;
test_intel_bo = drm_intel_bo_alloc(bufmgr, "test bo", BO_SIZE, 4096);
drm_intel_bo_gem_export_to_prime(test_intel_bo, &prime_fd);
test_intel_bo2 = drm_intel_bo_gem_create_from_prime(bufmgr2, prime_fd, BO_SIZE);
close(prime_fd);
igt_assert(test_intel_bo2);
drm_intel_bo_unreference(test_intel_bo2);
drm_intel_bo_unreference(test_intel_bo);
}
struct intel_bo *
intel_winsys_import_handle(struct intel_winsys *winsys,
const char *name,
const struct winsys_handle *handle,
unsigned long height,
enum intel_tiling_mode *tiling,
unsigned long *pitch)
{
uint32_t real_tiling, swizzle;
drm_intel_bo *bo;
int err;
switch (handle->type) {
case DRM_API_HANDLE_TYPE_SHARED:
{
const uint32_t gem_name = handle->handle;
bo = drm_intel_bo_gem_create_from_name(winsys->bufmgr,
name, gem_name);
}
break;
case DRM_API_HANDLE_TYPE_FD:
{
const int fd = (int) handle->handle;
bo = drm_intel_bo_gem_create_from_prime(winsys->bufmgr,
fd, height * handle->stride);
}
break;
default:
bo = NULL;
break;
}
if (!bo)
return NULL;
err = drm_intel_bo_get_tiling(bo, &real_tiling, &swizzle);
if (err) {
drm_intel_bo_unreference(bo);
return NULL;
}
*tiling = real_tiling;
*pitch = handle->stride;
return (struct intel_bo *) bo;
}
static VAStatus
media_suface_external_memory (VADriverContextP ctx,
struct object_surface *obj_surface,
INT external_memory_type,
VASurfaceAttribExternalBuffers *
memory_attibute, INT index)
{
MEDIA_DRV_CONTEXT *drv_ctx = (MEDIA_DRV_CONTEXT *) ctx->pDriverData;
MEDIA_DRV_ASSERT (ctx);
MEDIA_DRV_ASSERT (drv_ctx);
if (!memory_attibute ||
!memory_attibute->buffers || index > memory_attibute->num_buffers)
return VA_STATUS_ERROR_INVALID_PARAMETER;
MEDIA_DRV_ASSERT (obj_surface->orig_width == memory_attibute->width);
MEDIA_DRV_ASSERT (obj_surface->orig_height == memory_attibute->height);
MEDIA_DRV_ASSERT (memory_attibute->num_planes >= 1);
obj_surface->fourcc = memory_attibute->pixel_format;
obj_surface->width = memory_attibute->pitches[0];
obj_surface->size = memory_attibute->data_size;
if (memory_attibute->num_planes == 1)
obj_surface->height = memory_attibute->data_size / obj_surface->width;
else
obj_surface->height = memory_attibute->offsets[1] / obj_surface->width;
obj_surface->x_cb_offset = 0; /* X offset is always 0 */
obj_surface->x_cr_offset = 0;
switch (obj_surface->fourcc)
{
case VA_FOURCC ('N', 'V', '1', '2'):
MEDIA_DRV_ASSERT (memory_attibute->num_planes == 2);
MEDIA_DRV_ASSERT (memory_attibute->pitches[0] ==
memory_attibute->pitches[1]);
obj_surface->subsampling = SUBSAMPLE_YUV420;
obj_surface->y_cb_offset = obj_surface->height;
obj_surface->y_cr_offset = obj_surface->height;
obj_surface->cb_cr_width = obj_surface->orig_width / 2;
obj_surface->cb_cr_height = obj_surface->orig_height / 2;
obj_surface->cb_cr_pitch = memory_attibute->pitches[1];
break;
case VA_FOURCC ('Y', 'V', '1', '2'):
case VA_FOURCC ('I', 'M', 'C', '1'):
MEDIA_DRV_ASSERT (memory_attibute->num_planes == 3);
MEDIA_DRV_ASSERT (memory_attibute->pitches[1] ==
memory_attibute->pitches[2]);
obj_surface->subsampling = SUBSAMPLE_YUV420;
obj_surface->y_cr_offset = obj_surface->height;
obj_surface->y_cb_offset =
memory_attibute->offsets[2] / obj_surface->width;
obj_surface->cb_cr_width = obj_surface->orig_width / 2;
obj_surface->cb_cr_height = obj_surface->orig_height / 2;
obj_surface->cb_cr_pitch = memory_attibute->pitches[1];
break;
case VA_FOURCC ('I', '4', '2', '0'):
case VA_FOURCC ('I', 'Y', 'U', 'V'):
case VA_FOURCC ('I', 'M', 'C', '3'):
MEDIA_DRV_ASSERT (memory_attibute->num_planes == 3);
MEDIA_DRV_ASSERT (memory_attibute->pitches[1] ==
memory_attibute->pitches[2]);
obj_surface->subsampling = SUBSAMPLE_YUV420;
obj_surface->y_cb_offset = obj_surface->height;
obj_surface->y_cr_offset =
memory_attibute->offsets[2] / obj_surface->width;
obj_surface->cb_cr_width = obj_surface->orig_width / 2;
obj_surface->cb_cr_height = obj_surface->orig_height / 2;
obj_surface->cb_cr_pitch = memory_attibute->pitches[1];
break;
case VA_FOURCC ('Y', 'U', 'Y', '2'):
case VA_FOURCC ('U', 'Y', 'V', 'Y'):
MEDIA_DRV_ASSERT (memory_attibute->num_planes == 1);
obj_surface->subsampling = SUBSAMPLE_YUV422H;
obj_surface->y_cb_offset = 0;
obj_surface->y_cr_offset = 0;
obj_surface->cb_cr_width = obj_surface->orig_width / 2;
obj_surface->cb_cr_height = obj_surface->orig_height;
obj_surface->cb_cr_pitch = memory_attibute->pitches[0];
break;
case VA_FOURCC ('R', 'G', 'B', 'A'):
case VA_FOURCC ('R', 'G', 'B', 'X'):
case VA_FOURCC ('B', 'G', 'R', 'A'):
case VA_FOURCC ('B', 'G', 'R', 'X'):
MEDIA_DRV_ASSERT (memory_attibute->num_planes == 1);
obj_surface->subsampling = SUBSAMPLE_RGBX;
obj_surface->y_cb_offset = 0;
obj_surface->y_cr_offset = 0;
obj_surface->cb_cr_width = 0;
obj_surface->cb_cr_height = 0;
obj_surface->cb_cr_pitch = 0;
break;
case VA_FOURCC ('Y', '8', '0', '0'): /* monochrome surface */
MEDIA_DRV_ASSERT (memory_attibute->num_planes == 1);
obj_surface->subsampling = SUBSAMPLE_YUV400;
obj_surface->y_cb_offset = 0;
obj_surface->y_cr_offset = 0;
obj_surface->cb_cr_width = 0;
obj_surface->cb_cr_height = 0;
obj_surface->cb_cr_pitch = 0;
break;
case VA_FOURCC ('4', '1', '1', 'P'):
MEDIA_DRV_ASSERT (memory_attibute->num_planes == 3);
MEDIA_DRV_ASSERT (memory_attibute->pitches[1] ==
memory_attibute->pitches[2]);
obj_surface->subsampling = SUBSAMPLE_YUV411;
obj_surface->y_cb_offset = 0;
obj_surface->y_cr_offset = 0;
obj_surface->cb_cr_width = obj_surface->orig_width / 4;
obj_surface->cb_cr_height = obj_surface->orig_height;
obj_surface->cb_cr_pitch = memory_attibute->pitches[1];
break;
case VA_FOURCC ('4', '2', '2', 'H'):
MEDIA_DRV_ASSERT (memory_attibute->num_planes == 3);
MEDIA_DRV_ASSERT (memory_attibute->pitches[1] ==
memory_attibute->pitches[2]);
obj_surface->subsampling = SUBSAMPLE_YUV422H;
obj_surface->y_cb_offset = obj_surface->height;
obj_surface->y_cr_offset =
memory_attibute->offsets[2] / obj_surface->width;
obj_surface->cb_cr_width = obj_surface->orig_width / 2;
obj_surface->cb_cr_height = obj_surface->orig_height;
obj_surface->cb_cr_pitch = memory_attibute->pitches[1];
break;
case VA_FOURCC ('4', '2', '2', 'V'):
MEDIA_DRV_ASSERT (memory_attibute->num_planes == 3);
MEDIA_DRV_ASSERT (memory_attibute->pitches[1] ==
memory_attibute->pitches[2]);
obj_surface->subsampling = SUBSAMPLE_YUV422H;
obj_surface->y_cb_offset = obj_surface->height;
obj_surface->y_cr_offset =
memory_attibute->offsets[2] / obj_surface->width;
obj_surface->cb_cr_width = obj_surface->orig_width;
obj_surface->cb_cr_height = obj_surface->orig_height / 2;
obj_surface->cb_cr_pitch = memory_attibute->pitches[1];
break;
case VA_FOURCC ('4', '4', '4', 'P'):
MEDIA_DRV_ASSERT (memory_attibute->num_planes == 3);
MEDIA_DRV_ASSERT (memory_attibute->pitches[1] ==
memory_attibute->pitches[2]);
obj_surface->subsampling = SUBSAMPLE_YUV444;
obj_surface->y_cb_offset = obj_surface->height;
obj_surface->y_cr_offset =
memory_attibute->offsets[2] / obj_surface->width;
obj_surface->cb_cr_width = obj_surface->orig_width;
obj_surface->cb_cr_height = obj_surface->orig_height;
obj_surface->cb_cr_pitch = memory_attibute->pitches[1];
break;
default:
return VA_STATUS_ERROR_INVALID_PARAMETER;
}
if (external_memory_type == I965_SURFACE_MEM_GEM_FLINK)
obj_surface->bo =
drm_intel_bo_gem_create_from_name (drv_ctx->drv_data.bufmgr,
"gem flinked vaapi surface",
memory_attibute->buffers[index]);
else if (external_memory_type == I965_SURFACE_MEM_DRM_PRIME)
obj_surface->bo =
drm_intel_bo_gem_create_from_prime (drv_ctx->drv_data.bufmgr,
memory_attibute->buffers[index],
obj_surface->size);
if (!obj_surface->bo)
return VA_STATUS_ERROR_INVALID_PARAMETER;
return VA_STATUS_SUCCESS;
}
