libva-v4l2-request-fourier/tests/cap_pool_probe_pattern.c

/*
 * cap_pool_probe_pattern.c — synthetic regression test for the
 * iter5 sonnet C4 / iter6 candidate A "cap_pool resolution-change race."
 *
 * Exercises the surface-allocation pattern that originally tripped
 * REQBUFS-EBUSY on the iter5-end driver: vaCreateSurfaces at one
 * resolution, then vaDestroySurfaces, then vaCreateSurfaces at a
 * different resolution. iter6's REINIT discipline + cap_pool's
 * REQBUFS(0)-on-CAPTURE-and-OUTPUT during S_FMT-on-resolution-change
 * (CreateSurfaces2 in surface.c) closes this race; this test anchors
 * that fact with a deterministic repro.
 *
 * Build:
 *   gcc -O2 -Wall -Wextra -o cap_pool_probe_pattern \
 *       cap_pool_probe_pattern.c \
 *       $(pkg-config --cflags --libs libva libva-drm)
 *
 * Run:
 *   LIBVA_DRIVER_NAME=v4l2_request \
 *   LIBVA_V4L2_REQUEST_VIDEO_PATH=/dev/video1 \
 *   LIBVA_V4L2_REQUEST_MEDIA_PATH=/dev/media0 \
 *     ./cap_pool_probe_pattern
 *
 * Pass criterion (on iter6 driver and later):
 *   - Exit code 0
 *   - No "REQBUFS" / "EBUSY" / "Unable to request buffers" /
 *     "Unable to set format" lines on the v4l2-request driver's stderr
 *   - vainfo or visual inspection confirms the test program reached
 *     the "PASS" line on stdout
 *
 * Fail behavior pre-iter5: vaCreateSurfaces at the second resolution
 * would emit REQBUFS-EBUSY because OUTPUT/CAPTURE buffers from the
 * first allocation hadn't been torn down before S_FMT was attempted
 * on the new resolution. iter5's CreateSurfaces2 added the dual
 * REQBUFS(0) drain; iter6's REINIT keeps the OUTPUT pool's request_fd
 * lifecycle clean across the destroy-recreate cycle.
 */

#include <errno.h>
#include <fcntl.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>

#include <va/va.h>
#include <va/va_drm.h>

#define DRM_RENDER_NODE "/dev/dri/renderD128"

static const char *va_status_str(VAStatus s)
{
	return vaErrorStr(s);
}

#define VA_OK_OR_FAIL(call, msg) do { \
	VAStatus _vs = (call); \
	if (_vs != VA_STATUS_SUCCESS) { \
		fprintf(stderr, "FAIL: %s: %s (0x%x)\n", \
			(msg), va_status_str(_vs), _vs); \
		return 10; \
	} \
} while (0)

int main(void)
{
	int drm_fd;
	VADisplay dpy;
	int va_major = 0, va_minor = 0;
	VAConfigID config = VA_INVALID_ID;
	VAContextID context = VA_INVALID_ID;
	VASurfaceID small_surfaces[4];
	VASurfaceID big_surfaces[4];
	const unsigned int small_w = 128, small_h = 128;
	const unsigned int big_w = 1920, big_h = 1080;

	/* Open render node + libva display. */
	drm_fd = open(DRM_RENDER_NODE, O_RDWR);
	if (drm_fd < 0) {
		fprintf(stderr, "FAIL: open(%s): %s\n",
			DRM_RENDER_NODE, strerror(errno));
		return 1;
	}

	dpy = vaGetDisplayDRM(drm_fd);
	if (dpy == NULL) {
		fprintf(stderr, "FAIL: vaGetDisplayDRM returned NULL\n");
		close(drm_fd);
		return 2;
	}

	VA_OK_OR_FAIL(vaInitialize(dpy, &va_major, &va_minor),
		      "vaInitialize");
	printf("libva %d.%d initialized via %s\n", va_major, va_minor,
	       DRM_RENDER_NODE);

	/*
	 * vaCreateConfig with H.264 Main + VLD entrypoint forces our
	 * driver's RequestCreateConfig to set up the H.264 decode path,
	 * which is the path that reaches CreateSurfaces2 (and the
	 * resolution-change handling there).
	 */
	VA_OK_OR_FAIL(vaCreateConfig(dpy, VAProfileH264Main, VAEntrypointVLD,
				     NULL, 0, &config),
		      "vaCreateConfig(H264Main, VLD)");

	/* Phase 1: allocate small probe-pattern surfaces + context.
	 *
	 * vaCreateContext on our driver triggers RequestCreateContext, which
	 * runs the OUTPUT pool's request_pool_init (allocates 16 OUTPUT
	 * V4L2 buffers via VIDIOC_CREATE_BUFS at the small resolution) and
	 * the device-init S_EXT_CTRLS (DECODE_MODE / START_CODE). Without
	 * the context, vaCreateSurfaces alone would not exercise the path
	 * that the iter5 C4 race fired on (REQBUFS-EBUSY when the pool
	 * already has buffers at the previous resolution).
	 */
	printf("Phase 1: vaCreateSurfaces %ux%u, count=4; vaCreateContext\n",
	       small_w, small_h);
	VA_OK_OR_FAIL(vaCreateSurfaces(dpy, VA_RT_FORMAT_YUV420,
				       small_w, small_h, small_surfaces, 4,
				       NULL, 0),
		      "vaCreateSurfaces (small)");
	VA_OK_OR_FAIL(vaCreateContext(dpy, config,
				      (int)small_w, (int)small_h, 0,
				      small_surfaces, 4, &context),
		      "vaCreateContext (small)");

	/* Phase 2: dispose context + small surfaces. The driver-wide OUTPUT
	 * pool stays initialized (RequestDestroyContext does NOT call
	 * request_pool_destroy — only RequestTerminate does), so the
	 * REQBUFS(0) drain on the next CreateSurfaces2 is the actual
	 * race-hitting path.
	 */
	printf("Phase 2: vaDestroyContext; vaDestroySurfaces (small)\n");
	VA_OK_OR_FAIL(vaDestroyContext(dpy, context),
		      "vaDestroyContext (small)");
	context = VA_INVALID_ID;
	VA_OK_OR_FAIL(vaDestroySurfaces(dpy, small_surfaces, 4),
		      "vaDestroySurfaces (small)");

	/* Phase 3: allocate at the new (much larger) resolution. This is
	 * where pre-iter5 hit REQBUFS-EBUSY because OUTPUT/CAPTURE buffers
	 * from the small allocation hadn't been torn down before S_FMT on
	 * the new size. iter5's CreateSurfaces2 added the dual REQBUFS(0)
	 * drain; iter6's REINIT keeps the OUTPUT pool's request_fd
	 * lifecycle clean across the destroy-recreate cycle.
	 */
	printf("Phase 3: vaCreateSurfaces %ux%u, count=4 (resolution change); vaCreateContext\n",
	       big_w, big_h);
	VA_OK_OR_FAIL(vaCreateSurfaces(dpy, VA_RT_FORMAT_YUV420,
				       big_w, big_h, big_surfaces, 4,
				       NULL, 0),
		      "vaCreateSurfaces (big)");
	VA_OK_OR_FAIL(vaCreateContext(dpy, config,
				      (int)big_w, (int)big_h, 0,
				      big_surfaces, 4, &context),
		      "vaCreateContext (big)");

	/* Phase 4: clean up. */
	printf("Phase 4: cleanup\n");
	VA_OK_OR_FAIL(vaDestroyContext(dpy, context),
		      "vaDestroyContext (big)");
	VA_OK_OR_FAIL(vaDestroySurfaces(dpy, big_surfaces, 4),
		      "vaDestroySurfaces (big)");
	VA_OK_OR_FAIL(vaDestroyConfig(dpy, config),
		      "vaDestroyConfig");
	VA_OK_OR_FAIL(vaTerminate(dpy),
		      "vaTerminate");
	close(drm_fd);

	printf("PASS: cap_pool probe-pattern resolution-change handled cleanly.\n");
	printf("Inspect driver stderr for absence of REQBUFS/EBUSY/Unable lines.\n");
	return 0;
}