The flags are GF_SURFACE_CREATE_2D_ACCESSIBLE |  GF_SURFACE_CREATE_3D_ACCESSIBLE | GF_SURFACE_CREATE_SHAREABLE

> What are you passing for the flags value to gf_surface_create_layer()?  This 
> is rather odd ... hmmm ...

Derek, by the way, with which flags gf_3d_target_create() is creating surfaces for 3D rendering by default if surfaces 
are not passed to this function ?

What gf_3d_target_create() will do if only first surface is allocated and second allocation was failed ?

cpu fast access and 3D accessible, but lets not mix words, here's the source :)

int
gf_3d_target_create(gf_3d_target_t *ptarget, gf_layer_t layer,
    gf_surface_t *surfaces, int nsurfaces,
    int width, int height, gf_format_t format)
{
	struct _gf_3d_target	*target;
	int			arraysize;
	int			rc = GF_ERR_OK;
	gf_dev_t		gdev = layer->display->gdev;

	GF_ASSERT(!gf_dev_islocked(gdev));

	if (surfaces == NULL) {
		nsurfaces = 1;
	}

	arraysize = sizeof(surfaces) * (nsurfaces < 2 ? 2 : nsurfaces);
	target = calloc(1, sizeof(*target) + arraysize);

	if (target == NULL) {
		return GF_ERR_MEM;
	}

	target->surfaces = (void *)(target + 1);

	if (surfaces == NULL) {
		/*
		 * Create drawing surfaces that can both be displayed on
		 * the given layer, and targeted by the 3D engine
		 */
		if ((rc = gf_surface_create_layer(&target->surfaces[0], &layer, 1, 0,
		    width, height, format, NULL,
		    GF_SURFACE_CREATE_3D_ACCESSIBLE)) != GF_ERR_OK) {
			free(target);
			return rc;
		}
		target->internal_alloced[0] = 1;
	} else {
		memcpy(target->surfaces, surfaces, arraysize);
	}

	target->nsurfaces = nsurfaces;

	/* Try to allocate a second surface for double buffering */
	if (nsurfaces < 2) {
		disp_3d_caps_t	caps;
		unsigned	flags = GF_SURFACE_CREATE_3D_ACCESSIBLE;

		if (gdev->rendf.query_caps) {
			gdev->rendf.query_caps(gdev->handle_3d, &caps);
		}
		if (!(caps.flags & DISP_3D_CAP_ACCEL)) {
			flags |= GF_SURFACE_CREATE_CPU_FAST_ACCESS;
		}
		if (gf_surface_create_layer(&target->surfaces[1], &layer, 1, 0,
		    width, height, format, NULL,
		    flags) == GF_ERR_OK) {
			target->nsurfaces++;
			target->internal_alloced[1] = 1;
		} else {
			/*
			 * Cannot allocate two layer-displayable surfaces,
			 * and therefore cannot double-buffer.  Allocate
			 * a non-layer displayable surface, so that the
			 * the OpenGL ES library can blit from the
			 * back-buffer to the displayable buffer instead.
			 */
			if ((rc = gf_surface_create(&target->surfaces[1],
			    gdev, width, height, format, NULL,
			    flags)) != GF_ERR_OK) {
				goto fail;
			}

			target->nsurfaces++;
			target->internal_alloced[1] = 1;
		}
	}

	target->width = width;
	target->height = height;
	target->layer = layer;
	target->swap_layer = swap_layer;

	*ptarget = target;
	return GF_ERR_OK;

fail:
	if (target->internal_alloced[0]) {
		gf_surface_free(target->surfaces[0]);
	}
	free(target);

	return rc;
}