From 3a0bb4acef01095421eaa32e8cd6819754989dac Mon Sep 17 00:00:00 2001
From: Phi Bang Nguyen <phibang.nguyen@nxp.com>
Date: Fri, 10 Oct 2025 01:17:12 +0200
Subject: [PATCH 1/5] drivers: video: Add helper to estimate format size

Add a helper to estimate format size and pitch.

Signed-off-by: Phi Bang Nguyen <phibang.nguyen@nxp.com>
---
 drivers/video/video_common.c   | 25 +++++++++++++++++++++++++
 include/zephyr/drivers/video.h | 16 ++++++++++++++++
 2 files changed, 41 insertions(+)

diff --git a/drivers/video/video_common.c b/drivers/video/video_common.c
index c77b3e704f06b..95793e66db689 100644
--- a/drivers/video/video_common.c
+++ b/drivers/video/video_common.c
@@ -443,3 +443,28 @@ int64_t video_get_csi_link_freq(const struct device *dev, uint8_t bpp, uint8_t l
 	/* CSI D-PHY is using a DDR data bus so bitrate is twice the frequency */
 	return ctrl.val64 * bpp / (2 * lane_nb);
 }
+
+int video_estimate_fmt_size(struct video_format *fmt)
+{
+	if (fmt == NULL) {
+		return -EINVAL;
+	}
+
+	switch (fmt->pixelformat) {
+	case VIDEO_PIX_FMT_JPEG:
+		/* Rough estimate for the worst case (quality = 100) */
+		fmt->pitch = 0;
+		fmt->size = fmt->width * fmt->height * 2;
+		break;
+	default:
+		/* Uncompressed format */
+		fmt->pitch = fmt->width * video_bits_per_pixel(fmt->pixelformat) / BITS_PER_BYTE;
+		if (fmt->pitch == 0) {
+			return -ENOTSUP;
+		}
+		fmt->size = fmt->pitch * fmt->height;
+		break;
+	}
+
+	return 0;
+}
diff --git a/include/zephyr/drivers/video.h b/include/zephyr/drivers/video.h
index 87eb0314a48d8..0ad4f753b6acb 100644
--- a/include/zephyr/drivers/video.h
+++ b/include/zephyr/drivers/video.h
@@ -988,6 +988,22 @@ void video_closest_frmival(const struct device *dev, struct video_frmival_enum *
  */
 int64_t video_get_csi_link_freq(const struct device *dev, uint8_t bpp, uint8_t lane_nb);
 
+/**
+ * @brief Estimate the size and pitch in bytes of a @ref video_format
+ *
+ * This helper should only be used by drivers that support the whole image frame.
+ *
+ * For uncompressed formats, it gives the actual size and pitch of the
+ * whole raw image without any padding.
+ *
+ * For compressed formats, it gives a rough estimate size of a complete
+ * compressed frame.
+ *
+ * @param fmt Pointer to the video format structure
+ * @return 0 on success, otherwise a negative errno code
+ */
+int video_estimate_fmt_size(struct video_format *fmt);
+
 /**
  * @defgroup video_pixel_formats Video pixel formats
  * The '|' characters separate the pixels or logical blocks, and spaces separate the bytes.

From 57f47a5ed9fed4d93539716356cf7b199ed77441 Mon Sep 17 00:00:00 2001
From: Phi Bang Nguyen <phibang.nguyen@nxp.com>
Date: Wed, 8 Oct 2025 23:08:49 +0200
Subject: [PATCH 2/5] drivers: video: Set format size

Receiver drivers now need to set the format's size to expose it to
the application.

Application should base on the format size to allocate buffers. The
caps' min/max_line_count (which are needed only for HWs that cannot
support the whole image frame) can hence be dropped.

Signed-off-by: Phi Bang Nguyen <phibang.nguyen@nxp.com>
---
 drivers/video/video_emul_rx.c                 | 12 +++++++---
 drivers/video/video_esp32_dvp.c               | 13 ++++++-----
 drivers/video/video_mcux_csi.c                |  7 ++----
 drivers/video/video_mcux_smartdma.c           |  4 ++--
 drivers/video/video_renesas_ra_ceu.c          | 11 +++++-----
 drivers/video/video_shell.c                   |  2 --
 drivers/video/video_st_mipid02.c              |  2 --
 drivers/video/video_stm32_dcmi.c              | 13 ++++++-----
 drivers/video/video_stm32_dcmipp.c            |  5 +++--
 drivers/video/video_stm32_venc.c              |  1 -
 drivers/video/video_sw_generator.c            |  9 ++++----
 include/zephyr/drivers/video.h                | 22 -------------------
 samples/drivers/video/capture/src/main.c      | 12 ++--------
 .../drivers/video/capture_to_lvgl/src/main.c  | 10 +--------
 .../drivers/video/tcpserversink/src/main.c    | 15 +------------
 samples/subsys/usb/uvc/src/main.c             | 10 +--------
 16 files changed, 47 insertions(+), 101 deletions(-)

diff --git a/drivers/video/video_emul_rx.c b/drivers/video/video_emul_rx.c
index 1048486974bd0..4506ace4568af 100644
--- a/drivers/video/video_emul_rx.c
+++ b/drivers/video/video_emul_rx.c
@@ -67,7 +67,11 @@ static int emul_rx_set_fmt(const struct device *const dev, struct video_format *
 	}
 
 	/* Cache the format selected locally to use it for getting the size of the buffer  */
-	fmt->pitch = fmt->width * video_bits_per_pixel(fmt->pixelformat) / BITS_PER_BYTE;
+	ret = video_estimate_fmt_size(fmt);
+	if (ret < 0) {
+		return ret;
+	}
+
 	data->fmt = *fmt;
 
 	return 0;
@@ -218,8 +222,10 @@ int emul_rx_init(const struct device *dev)
 		return ret;
 	}
 
-	data->fmt.pitch =
-		data->fmt.width * video_bits_per_pixel(data->fmt.pixelformat) / BITS_PER_BYTE;
+	ret = video_estimate_fmt_size(&data->fmt);
+	if (ret < 0) {
+		return ret;
+	}
 
 	k_fifo_init(&data->fifo_in);
 	k_fifo_init(&data->fifo_out);
diff --git a/drivers/video/video_esp32_dvp.c b/drivers/video/video_esp32_dvp.c
index 3ffeedd39c99e..5bd7d909a9b6d 100644
--- a/drivers/video/video_esp32_dvp.c
+++ b/drivers/video/video_esp32_dvp.c
@@ -248,9 +248,6 @@ static int video_esp32_get_caps(const struct device *dev, struct video_caps *cap
 	/* Two buffers are needed to perform transfers */
 	caps->min_vbuf_count = 2;
 
-	/* ESP32 produces full frames */
-	caps->min_line_count = caps->max_line_count = LINE_COUNT_HEIGHT;
-
 	/* Forward the message to the source device */
 	return video_get_caps(config->source_dev, caps);
 }
@@ -268,7 +265,10 @@ static int video_esp32_get_fmt(const struct device *dev, struct video_format *fm
 		return ret;
 	}
 
-	fmt->pitch = fmt->width * video_bits_per_pixel(fmt->pixelformat) / BITS_PER_BYTE;
+	ret = video_estimate_fmt_size(fmt);
+	if (ret < 0) {
+		return ret;
+	}
 
 	return 0;
 }
@@ -284,7 +284,10 @@ static int video_esp32_set_fmt(const struct device *dev, struct video_format *fm
 		return ret;
 	}
 
-	fmt->pitch = fmt->width * video_bits_per_pixel(fmt->pixelformat) / BITS_PER_BYTE;
+	ret = video_estimate_fmt_size(fmt);
+	if (ret < 0) {
+		return ret;
+	}
 
 	data->video_format = *fmt;
 
diff --git a/drivers/video/video_mcux_csi.c b/drivers/video/video_mcux_csi.c
index bb935a916be42..5ba4a356450ba 100644
--- a/drivers/video/video_mcux_csi.c
+++ b/drivers/video/video_mcux_csi.c
@@ -124,8 +124,6 @@ static inline void video_pix_fmt_convert(struct video_format *fmt, bool isGetFmt
 		fmt->pixelformat = isGetFmt ? VIDEO_PIX_FMT_XYUV32 : VIDEO_PIX_FMT_YUYV;
 		break;
 	}
-
-	fmt->pitch = fmt->width * video_bits_per_pixel(fmt->pixelformat) / BITS_PER_BYTE;
 }
 #endif
 
@@ -168,6 +166,7 @@ static int video_mcux_csi_set_fmt(const struct device *dev, struct video_format
 	}
 
 	fmt->pitch = data->csi_config.linePitch_Bytes;
+	fmt->size = fmt->pitch * fmt->height;
 
 	return 0;
 }
@@ -181,7 +180,7 @@ static int video_mcux_csi_get_fmt(const struct device *dev, struct video_format
 		video_pix_fmt_convert(fmt, true);
 #endif
 
-		return 0;
+		return video_estimate_fmt_size(fmt);
 	}
 
 	return -EIO;
@@ -323,8 +322,6 @@ static int video_mcux_csi_get_caps(const struct device *dev, struct video_caps *
 
 	/* NXP MCUX CSI request at least 2 buffer before starting */
 	caps->min_vbuf_count = 2;
-	/* CSI only operates on buffers of full frame size */
-	caps->min_line_count = caps->max_line_count = LINE_COUNT_HEIGHT;
 
 	/* no source dev */
 	return err;
diff --git a/drivers/video/video_mcux_smartdma.c b/drivers/video/video_mcux_smartdma.c
index ea2be98ddef25..408fac68deba5 100644
--- a/drivers/video/video_mcux_smartdma.c
+++ b/drivers/video/video_mcux_smartdma.c
@@ -239,6 +239,7 @@ static int nxp_video_sdma_set_format(const struct device *dev, struct video_form
 	}
 
 	fmt->pitch = fmt->width * video_bits_per_pixel(fmt->pixelformat) / BITS_PER_BYTE;
+	fmt->size = fmt->pitch * SDMA_LINE_COUNT;
 
 	return 0;
 }
@@ -271,6 +272,7 @@ static int nxp_video_sdma_get_format(const struct device *dev, struct video_form
 	}
 
 	fmt->pitch = fmt->width * video_bits_per_pixel(fmt->pixelformat) / BITS_PER_BYTE;
+	fmt->size = fmt->pitch * SDMA_LINE_COUNT;
 
 	return 0;
 }
@@ -279,8 +281,6 @@ static int nxp_video_sdma_get_caps(const struct device *dev, struct video_caps *
 {
 	/* SmartDMA needs at least two buffers allocated before starting */
 	caps->min_vbuf_count = 2;
-	/* Firmware reads 30 lines per queued vbuf */
-	caps->min_line_count = caps->max_line_count = SDMA_LINE_COUNT;
 	caps->format_caps = fmts;
 	return 0;
 }
diff --git a/drivers/video/video_renesas_ra_ceu.c b/drivers/video/video_renesas_ra_ceu.c
index 0cc815e46ecd5..385c30d7f6734 100644
--- a/drivers/video/video_renesas_ra_ceu.c
+++ b/drivers/video/video_renesas_ra_ceu.c
@@ -117,9 +117,7 @@ static int video_renesas_ra_ceu_get_format(const struct device *dev, struct vide
 		return ret;
 	}
 
-	fmt->pitch = fmt->width * video_bits_per_pixel(fmt->pixelformat) / BITS_PER_BYTE;
-
-	return 0;
+	return video_estimate_fmt_size(fmt);
 }
 
 static int video_renesas_ra_ceu_set_format(const struct device *dev, struct video_format *fmt)
@@ -169,7 +167,10 @@ static int video_renesas_ra_ceu_set_format(const struct device *dev, struct vide
 		return -EIO;
 	}
 
-	fmt->pitch = fmt->width * video_bits_per_pixel(fmt->pixelformat) / BITS_PER_BYTE;
+	ret = video_estimate_fmt_size(fmt);
+	if (ret < 0) {
+		return ret;
+	}
 
 	memcpy(&data->fmt, fmt, sizeof(struct video_format));
 
@@ -181,8 +182,6 @@ static int video_renesas_ra_ceu_get_caps(const struct device *dev, struct video_
 	const struct video_renesas_ra_ceu_config *config = dev->config;
 
 	caps->min_vbuf_count = 1;
-	caps->min_line_count = LINE_COUNT_HEIGHT;
-	caps->max_line_count = LINE_COUNT_HEIGHT;
 
 	return video_get_caps(config->source_dev, caps);
 }
diff --git a/drivers/video/video_shell.c b/drivers/video/video_shell.c
index 87d22bbd87a42..e59f3c9a0282e 100644
--- a/drivers/video/video_shell.c
+++ b/drivers/video/video_shell.c
@@ -499,8 +499,6 @@ static int video_shell_print_caps(const struct shell *sh, const struct device *d
 	int ret;
 
 	shell_print(sh, "min vbuf count: %u", caps->min_vbuf_count);
-	shell_print(sh, "min line count: %u", caps->min_line_count);
-	shell_print(sh, "max line count: %u", caps->max_line_count);
 
 	for (size_t i = 0; caps->format_caps[i].pixelformat != 0; i++) {
 		ret = video_shell_print_format_cap(sh, dev, caps->type, &caps->format_caps[i], i);
diff --git a/drivers/video/video_st_mipid02.c b/drivers/video/video_st_mipid02.c
index 0b2493619a601..4482e9e69fd16 100644
--- a/drivers/video/video_st_mipid02.c
+++ b/drivers/video/video_st_mipid02.c
@@ -253,8 +253,6 @@ static int mipid02_get_caps(const struct device *dev, struct video_caps *caps)
 
 	caps->format_caps = drv_data->caps;
 	caps->min_vbuf_count = 1;
-	caps->min_line_count = LINE_COUNT_HEIGHT;
-	caps->max_line_count = LINE_COUNT_HEIGHT;
 
 	return 0;
 }
diff --git a/drivers/video/video_stm32_dcmi.c b/drivers/video/video_stm32_dcmi.c
index 88013b5309734..3478d9262fda2 100644
--- a/drivers/video/video_stm32_dcmi.c
+++ b/drivers/video/video_stm32_dcmi.c
@@ -194,7 +194,10 @@ static int video_stm32_dcmi_set_fmt(const struct device *dev, struct video_forma
 		return ret;
 	}
 
-	fmt->pitch = fmt->width * video_bits_per_pixel(fmt->pixelformat) / BITS_PER_BYTE;
+	ret = video_estimate_fmt_size(fmt);
+	if (ret < 0) {
+		return ret;
+	}
 
 	data->fmt = *fmt;
 
@@ -213,7 +216,10 @@ static int video_stm32_dcmi_get_fmt(const struct device *dev, struct video_forma
 		return ret;
 	}
 
-	fmt->pitch = fmt->width * video_bits_per_pixel(fmt->pixelformat) / BITS_PER_BYTE;
+	ret = video_estimate_fmt_size(fmt);
+	if (ret < 0) {
+		return ret;
+	}
 
 	data->fmt = *fmt;
 
@@ -309,9 +315,6 @@ static int video_stm32_dcmi_get_caps(const struct device *dev, struct video_caps
 	/* 2 buffers are needed for DCMI_MODE_CONTINUOUS */
 	caps->min_vbuf_count = 2;
 
-	/* DCMI produces full frames */
-	caps->min_line_count = caps->max_line_count = LINE_COUNT_HEIGHT;
-
 	/* Forward the message to the sensor device */
 	return video_get_caps(config->sensor_dev, caps);
 }
diff --git a/drivers/video/video_stm32_dcmipp.c b/drivers/video/video_stm32_dcmipp.c
index d8608fc22f15f..37c7d1724598b 100644
--- a/drivers/video/video_stm32_dcmipp.c
+++ b/drivers/video/video_stm32_dcmipp.c
@@ -545,6 +545,9 @@ static inline void stm32_dcmipp_compute_fmt_pitch(uint32_t pipe_id, struct video
 		fmt->pitch = ROUND_UP(fmt->pitch, 16);
 	}
 #endif
+
+	/* Update the corresponding fmt->size */
+	fmt->size = fmt->pitch * fmt->height;
 }
 
 static int stm32_dcmipp_set_fmt(const struct device *dev, struct video_format *fmt)
@@ -1370,8 +1373,6 @@ static int stm32_dcmipp_get_caps(const struct device *dev, struct video_caps *ca
 	ret = video_get_caps(config->source_dev, caps);
 
 	caps->min_vbuf_count = 1;
-	caps->min_line_count = LINE_COUNT_HEIGHT;
-	caps->max_line_count = LINE_COUNT_HEIGHT;
 
 	return ret;
 }
diff --git a/drivers/video/video_stm32_venc.c b/drivers/video/video_stm32_venc.c
index 4f26977dcce10..abd1608454dfb 100644
--- a/drivers/video/video_stm32_venc.c
+++ b/drivers/video/video_stm32_venc.c
@@ -806,7 +806,6 @@ static int stm32_venc_get_caps(const struct device *dev, struct video_caps *caps
 	}
 
 	/* VENC produces full frames */
-	caps->min_line_count = caps->max_line_count = LINE_COUNT_HEIGHT;
 	caps->min_vbuf_count = 1;
 
 	return 0;
diff --git a/drivers/video/video_sw_generator.c b/drivers/video/video_sw_generator.c
index 2effc1ef54dda..6c270646ef503 100644
--- a/drivers/video/video_sw_generator.c
+++ b/drivers/video/video_sw_generator.c
@@ -81,7 +81,10 @@ static int video_sw_generator_set_fmt(const struct device *dev, struct video_for
 		return ret;
 	}
 
-	fmt->pitch = fmt->width * video_bits_per_pixel(fmt->pixelformat) / BITS_PER_BYTE;
+	ret = video_estimate_fmt_size(fmt);
+	if (ret < 0) {
+		return ret;
+	}
 
 	data->fmt = *fmt;
 	return 0;
@@ -365,9 +368,6 @@ static int video_sw_generator_get_caps(const struct device *dev, struct video_ca
 	caps->format_caps = fmts;
 	caps->min_vbuf_count = 1;
 
-	/* SW generator produces full frames */
-	caps->min_line_count = caps->max_line_count = LINE_COUNT_HEIGHT;
-
 	return 0;
 }
 
@@ -477,6 +477,7 @@ static int video_sw_generator_init(const struct device *dev)
 		.fmt.height = 160,                                                                 \
 		.fmt.pitch = 320 * 2,                                                              \
 		.fmt.pixelformat = VIDEO_PIX_FMT_RGB565,                                           \
+		.fmt.size = 320 * 2 * 160,                                                         \
 		.frame_rate = DEFAULT_FRAME_RATE,                                                  \
 	};                                                                                         \
                                                                                                    \
diff --git a/include/zephyr/drivers/video.h b/include/zephyr/drivers/video.h
index 0ad4f753b6acb..e50f49b0e382f 100644
--- a/include/zephyr/drivers/video.h
+++ b/include/zephyr/drivers/video.h
@@ -34,12 +34,6 @@
 extern "C" {
 #endif
 
-/*
- * Flag used by @ref video_caps structure to indicate endpoint operates on
- * buffers the size of the video frame
- */
-#define LINE_COUNT_HEIGHT (-1)
-
 struct video_control;
 
 /**
@@ -128,22 +122,6 @@ struct video_caps {
 	 * the stream.
 	 */
 	uint8_t min_vbuf_count;
-	/** Denotes minimum line count of a video buffer that this endpoint
-	 * can fill or process. Each line is expected to consume the number
-	 * of bytes the selected video format's pitch uses, so the video
-	 * buffer must be at least `pitch` * `min_line_count` bytes.
-	 * `LINE_COUNT_HEIGHT` is a special value, indicating the endpoint
-	 * only supports video buffers with at least enough bytes to store
-	 * a full video frame
-	 */
-	int16_t min_line_count;
-	/**
-	 * Denotes maximum line count of a video buffer that this endpoint
-	 * can fill or process. Similar constraints to `min_line_count`,
-	 * but `LINE_COUNT_HEIGHT` indicates that the endpoint will never
-	 * fill or process more than a full video frame in one video buffer.
-	 */
-	int16_t max_line_count;
 };
 
 /**
diff --git a/samples/drivers/video/capture/src/main.c b/samples/drivers/video/capture/src/main.c
index bfb8e051f2993..fe702a1bdb367 100644
--- a/samples/drivers/video/capture/src/main.c
+++ b/samples/drivers/video/capture/src/main.c
@@ -105,7 +105,6 @@ int main(void)
 	};
 #endif
 	unsigned int frame = 0;
-	size_t bsize;
 	int i = 0;
 	int err;
 
@@ -276,16 +275,9 @@ int main(void)
 	}
 #endif
 
-	/* Size to allocate for each buffer */
-	if (caps.min_line_count == LINE_COUNT_HEIGHT) {
-		bsize = fmt.pitch * fmt.height;
-	} else {
-		bsize = fmt.pitch * caps.min_line_count;
-	}
-
 	/* Alloc video buffers and enqueue for capture */
 	if (caps.min_vbuf_count > CONFIG_VIDEO_BUFFER_POOL_NUM_MAX ||
-	    bsize > CONFIG_VIDEO_BUFFER_POOL_SZ_MAX) {
+	    fmt.size > CONFIG_VIDEO_BUFFER_POOL_SZ_MAX) {
 		LOG_ERR("Not enough buffers or memory to start streaming");
 		return 0;
 	}
@@ -295,7 +287,7 @@ int main(void)
 		 * For some hardwares, such as the PxP used on i.MX RT1170 to do image rotation,
 		 * buffer alignment is needed in order to achieve the best performance
 		 */
-		vbuf = video_buffer_aligned_alloc(bsize, CONFIG_VIDEO_BUFFER_POOL_ALIGN,
+		vbuf = video_buffer_aligned_alloc(fmt.size, CONFIG_VIDEO_BUFFER_POOL_ALIGN,
 							K_FOREVER);
 		if (vbuf == NULL) {
 			LOG_ERR("Unable to alloc video buffer");
diff --git a/samples/drivers/video/capture_to_lvgl/src/main.c b/samples/drivers/video/capture_to_lvgl/src/main.c
index 020397cbf61c6..b57a9d1312130 100644
--- a/samples/drivers/video/capture_to_lvgl/src/main.c
+++ b/samples/drivers/video/capture_to_lvgl/src/main.c
@@ -34,7 +34,6 @@ int main(void)
 	struct video_selection sel = {
 		.type = VIDEO_BUF_TYPE_OUTPUT,
 	};
-	size_t bsize;
 	int i = 0;
 	int err;
 
@@ -131,16 +130,9 @@ int main(void)
 		(char)(fmt.pixelformat >> 16), (char)(fmt.pixelformat >> 24), fmt.width, fmt.height,
 		fmt.pitch);
 
-	if (caps.min_line_count != LINE_COUNT_HEIGHT) {
-		LOG_ERR("Partial framebuffers not supported by this sample");
-		return 0;
-	}
-	/* Size to allocate for each buffer */
-	bsize = fmt.pitch * fmt.height;
-
 	/* Alloc video buffers and enqueue for capture */
 	for (i = 0; i < ARRAY_SIZE(buffers); i++) {
-		buffers[i] = video_buffer_aligned_alloc(bsize, CONFIG_VIDEO_BUFFER_POOL_ALIGN,
+		buffers[i] = video_buffer_aligned_alloc(fmt.size, CONFIG_VIDEO_BUFFER_POOL_ALIGN,
 							K_FOREVER);
 		if (buffers[i] == NULL) {
 			LOG_ERR("Unable to alloc video buffer");
diff --git a/samples/drivers/video/tcpserversink/src/main.c b/samples/drivers/video/tcpserversink/src/main.c
index 3ee04c1b32b7d..39c8810ac930b 100644
--- a/samples/drivers/video/tcpserversink/src/main.c
+++ b/samples/drivers/video/tcpserversink/src/main.c
@@ -211,7 +211,6 @@ int main(void)
 		.type = VIDEO_BUF_TYPE_OUTPUT,
 	};
 #endif
-	size_t bsize;
 	int i = 0;
 #if CONFIG_VIDEO_FRAME_HEIGHT || CONFIG_VIDEO_FRAME_WIDTH
 	int err;
@@ -279,11 +278,6 @@ int main(void)
 	LOG_INF("Video device detected, format: %s %ux%u",
 		VIDEO_FOURCC_TO_STR(fmt.pixelformat), fmt.width, fmt.height);
 
-	if (caps.min_line_count != LINE_COUNT_HEIGHT) {
-		LOG_ERR("Partial framebuffers not supported by this sample");
-		return 0;
-	}
-
 	/* Set the crop setting if necessary */
 #if CONFIG_VIDEO_SOURCE_CROP_WIDTH && CONFIG_VIDEO_SOURCE_CROP_HEIGHT
 	sel.target = VIDEO_SEL_TGT_CROP;
@@ -392,20 +386,13 @@ int main(void)
 		tp_set_ret = video_set_ctrl(video_dev, &ctrl);
 	}
 
-	/* Size to allocate for each buffer */
-	if (caps.min_line_count == LINE_COUNT_HEIGHT) {
-		bsize = fmt.pitch * fmt.height;
-	} else {
-		bsize = fmt.pitch * caps.min_line_count;
-	}
-
 	/* Alloc Buffers */
 	for (i = 0; i < ARRAY_SIZE(buffers); i++) {
 		/*
 		 * For some hardwares, such as the PxP used on i.MX RT1170 to do image rotation,
 		 * buffer alignment is needed in order to achieve the best performance
 		 */
-		buffers[i] = video_buffer_aligned_alloc(bsize, CONFIG_VIDEO_BUFFER_POOL_ALIGN,
+		buffers[i] = video_buffer_aligned_alloc(fmt.size, CONFIG_VIDEO_BUFFER_POOL_ALIGN,
 							K_FOREVER);
 		if (buffers[i] == NULL) {
 			LOG_ERR("Unable to alloc video buffer");
diff --git a/samples/subsys/usb/uvc/src/main.c b/samples/subsys/usb/uvc/src/main.c
index e2520556ba10e..454bed7bdd9c5 100644
--- a/samples/subsys/usb/uvc/src/main.c
+++ b/samples/subsys/usb/uvc/src/main.c
@@ -29,7 +29,6 @@ int main(void)
 	struct k_poll_signal sig;
 	struct k_poll_event evt[1];
 	k_timeout_t timeout = K_FOREVER;
-	size_t bsize;
 	int ret;
 
 	if (!device_is_ready(video_dev)) {
@@ -79,15 +78,8 @@ int main(void)
 		VIDEO_FOURCC_TO_STR(fmt.pixelformat), fmt.width, fmt.height,
 		CONFIG_VIDEO_BUFFER_POOL_NUM_MAX, fmt.pitch * fmt.height);
 
-	/* Size to allocate for each buffer */
-	if (caps.min_line_count == LINE_COUNT_HEIGHT) {
-		bsize = fmt.pitch * fmt.height;
-	} else {
-		bsize = fmt.pitch * caps.min_line_count;
-	}
-
 	for (int i = 0; i < CONFIG_VIDEO_BUFFER_POOL_NUM_MAX; i++) {
-		vbuf = video_buffer_alloc(bsize, K_NO_WAIT);
+		vbuf = video_buffer_alloc(fmt.size, K_NO_WAIT);
 		if (vbuf == NULL) {
 			LOG_ERR("Could not allocate the video buffer");
 			return -ENOMEM;

From 7aa63f7305b33e060b5daee109c285e75744689d Mon Sep 17 00:00:00 2001
From: Phi Bang Nguyen <phibang.nguyen@nxp.com>
Date: Wed, 8 Oct 2025 22:32:51 +0200
Subject: [PATCH 3/5] drivers: video: st_mipid02: Drop caps' min_vbuf_count

The mipid02 is just a bridge driver which does not deal with memory so
should not expose caps' min_vbuf_count.

Signed-off-by: Phi Bang Nguyen <phibang.nguyen@nxp.com>
---
 drivers/video/video_st_mipid02.c | 1 -
 1 file changed, 1 deletion(-)

diff --git a/drivers/video/video_st_mipid02.c b/drivers/video/video_st_mipid02.c
index 4482e9e69fd16..61d8b57b77bd9 100644
--- a/drivers/video/video_st_mipid02.c
+++ b/drivers/video/video_st_mipid02.c
@@ -252,7 +252,6 @@ static int mipid02_get_caps(const struct device *dev, struct video_caps *caps)
 	}
 
 	caps->format_caps = drv_data->caps;
-	caps->min_vbuf_count = 1;
 
 	return 0;
 }

From c3511b5837fe8c827c24b171977a76fe5afb0adb Mon Sep 17 00:00:00 2001
From: Phi Bang Nguyen <phibang.nguyen@nxp.com>
Date: Thu, 9 Oct 2025 11:34:24 +0200
Subject: [PATCH 4/5] doc: migration-guide-4.3: Mention some changes in video
 structures

Mention some dropped fields in the video_caps structure and the buffer
allocation size for application.

Signed-off-by: Phi Bang Nguyen <phibang.nguyen@nxp.com>
---
 doc/releases/migration-guide-4.3.rst | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/doc/releases/migration-guide-4.3.rst b/doc/releases/migration-guide-4.3.rst
index 757041e1b2a13..eee53fe79c626 100644
--- a/doc/releases/migration-guide-4.3.rst
+++ b/doc/releases/migration-guide-4.3.rst
@@ -251,6 +251,12 @@ PTP Clock
   ratio adjusting based on nominal frequency. Drivers implementing :c:func:`ptp_clock_rate_adjust`
   should be adjusted to account for the new behavior.
 
+Video
+*****
+
+* The ``min_line_count`` and ``max_line_count`` fields have been removed from :c:struct:`video_caps`.
+  Application should base on the new :c:member:`video_format.size` to allocate buffers.
+
 Other subsystems
 ****************
 

From ab8ea7b765751e23a3bc7907b2d708cceed6f1aa Mon Sep 17 00:00:00 2001
From: Phi Bang Nguyen <phibang.nguyen@nxp.com>
Date: Fri, 10 Oct 2025 01:22:48 +0200
Subject: [PATCH 5/5] doc: release-note-4.3: Add video format estimation helper

Mention a new video_estimate_fmt_size helper.

Signed-off-by: Phi Bang Nguyen <phibang.nguyen@nxp.com>
---
 doc/releases/release-notes-4.3.rst | 1 +
 1 file changed, 1 insertion(+)

diff --git a/doc/releases/release-notes-4.3.rst b/doc/releases/release-notes-4.3.rst
index c4d94c0f75bae..f6afed833f054 100644
--- a/doc/releases/release-notes-4.3.rst
+++ b/doc/releases/release-notes-4.3.rst
@@ -279,6 +279,7 @@ New APIs and options
 * Video
 
   * :c:member:`video_format.size` field
+  * :c:func:`video_estimate_fmt_size`
 
 .. zephyr-keep-sorted-stop