drivers: video: Move format pitch setting to bridge drivers

ngphibang · kartben · commit 0c1e2c9e6db0 · 2025-05-20T18:27:35.000+02:00
The format pitch (bytesperline) field is typically set by the bridge
drivers, i.e. DMA, ISP drivers who actually handle the memory as they
know exactly the memory layout constraints.

Application just set the pixel format and resolution and must always
read back this field to see what the driver actually sets (to allocate
buffers for example).

Also, drop format pitch setting in sensor drivers as this is not needed.

Signed-off-by: Phi Bang Nguyen &lt;phibang.nguyen@nxp.com&gt;
diff --git a/drivers/video/gc2145.c b/drivers/video/gc2145.c
@@ -1183,7 +1183,6 @@ static int gc2145_init(const struct device *dev)
 	fmt.pixelformat = VIDEO_PIX_FMT_RGB565;
 	fmt.width = RESOLUTION_QVGA_W;
 	fmt.height = RESOLUTION_QVGA_H;
-	fmt.pitch = RESOLUTION_QVGA_W * video_bits_per_pixel(fmt.pixelformat) / BITS_PER_BYTE;
 
 	ret = gc2145_set_fmt(dev, &fmt);
 	if (ret) {
diff --git a/drivers/video/mt9m114.c b/drivers/video/mt9m114.c
@@ -564,7 +564,6 @@ static int mt9m114_init(const struct device *dev)
 	fmt.pixelformat = VIDEO_PIX_FMT_RGB565;
 	fmt.width = 480;
 	fmt.height = 272;
-	fmt.pitch = fmt.width * video_bits_per_pixel(fmt.pixelformat) / BITS_PER_BYTE;
 
 	ret = mt9m114_set_fmt(dev, &fmt);
 	if (ret) {
diff --git a/drivers/video/ov2640.c b/drivers/video/ov2640.c
@@ -1032,7 +1032,6 @@ static int ov2640_init(const struct device *dev)
 	fmt.pixelformat = VIDEO_PIX_FMT_RGB565;
 	fmt.width = SVGA_HSIZE;
 	fmt.height = SVGA_VSIZE;
-	fmt.pitch = SVGA_HSIZE * video_bits_per_pixel(fmt.pixelformat) / BITS_PER_BYTE;
 	ret = ov2640_set_fmt(dev, &fmt);
 	if (ret) {
 		LOG_ERR("Unable to configure default format");
diff --git a/drivers/video/ov5640.c b/drivers/video/ov5640.c
@@ -1433,7 +1433,6 @@ static int ov5640_init(const struct device *dev)
 		fmt.width = 1280;
 		fmt.height = 720;
 	}
-	fmt.pitch = fmt.width * video_bits_per_pixel(fmt.pixelformat) / BITS_PER_BYTE;
 	ret = ov5640_set_fmt(dev, &fmt);
 	if (ret) {
 		LOG_ERR("Unable to configure default format");
diff --git a/drivers/video/ov7670.c b/drivers/video/ov7670.c
@@ -554,7 +554,6 @@ static int ov7670_init(const struct device *dev)
 	fmt.pixelformat = VIDEO_PIX_FMT_YUYV;
 	fmt.width = 640;
 	fmt.height = 480;
-	fmt.pitch = fmt.width * video_bits_per_pixel(fmt.pixelformat) / BITS_PER_BYTE;
 	ret = ov7670_set_fmt(dev, &fmt);
 	if (ret < 0) {
 		return ret;
diff --git a/drivers/video/ov7725.c b/drivers/video/ov7725.c
@@ -592,7 +592,6 @@ static int ov7725_init(const struct device *dev)
 	fmt.pixelformat = VIDEO_PIX_FMT_RGB565;
 	fmt.width = 640;
 	fmt.height = 480;
-	fmt.pitch = fmt.width * video_bits_per_pixel(fmt.pixelformat) / BITS_PER_BYTE;
 	ret = ov7725_set_fmt(dev, &fmt);
 	if (ret) {
 		LOG_ERR("Unable to configure default format");
diff --git a/drivers/video/video_emul_imager.c b/drivers/video/video_emul_imager.c
@@ -368,7 +368,6 @@ int emul_imager_init(const struct device *dev)
 	fmt.pixelformat = fmts[0].pixelformat;
 	fmt.width = fmts[0].width_min;
 	fmt.height = fmts[0].height_min;
-	fmt.pitch = fmt.width * video_bits_per_pixel(fmt.pixelformat) / BITS_PER_BYTE;
 
 	ret = emul_imager_set_fmt(dev, &fmt);
 	if (ret < 0) {
diff --git a/drivers/video/video_emul_rx.c b/drivers/video/video_emul_rx.c
@@ -67,7 +67,9 @@ 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;
 	data->fmt = *fmt;
+
 	return 0;
 }
 
@@ -216,6 +218,9 @@ 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;
+
 	k_fifo_init(&data->fifo_in);
 	k_fifo_init(&data->fifo_out);
 	k_work_init(&data->work, &emul_rx_worker);
diff --git a/drivers/video/video_esp32_dvp.c b/drivers/video/video_esp32_dvp.c
@@ -269,21 +269,31 @@ 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;
+
 	return 0;
 }
 
 static int video_esp32_set_fmt(const struct device *dev, struct video_format *fmt)
 {
 	const struct video_esp32_config *cfg = dev->config;
 	struct video_esp32_data *data = dev->data;
+	int ret;
 
 	if (fmt == NULL) {
 		return -EINVAL;
 	}
 
+	ret = video_set_format(cfg->source_dev, fmt);
+	if (ret < 0) {
+		return ret;
+	}
+
+	fmt->pitch = fmt->width * video_bits_per_pixel(fmt->pixelformat) / BITS_PER_BYTE;
+
 	data->video_format = *fmt;
 
-	return video_set_format(cfg->source_dev, fmt);
+	return 0;
 }
 
 static int video_esp32_enqueue(const struct device *dev, struct video_buffer *vbuf)
diff --git a/drivers/video/video_mcux_csi.c b/drivers/video/video_mcux_csi.c
@@ -133,16 +133,11 @@ static int video_mcux_csi_set_fmt(const struct device *dev, struct video_format
 {
 	const struct video_mcux_csi_config *config = dev->config;
 	struct video_mcux_csi_data *data = dev->data;
-	unsigned int bpp = video_bits_per_pixel(fmt->pixelformat) / BITS_PER_BYTE;
 	status_t ret;
 	struct video_format format = *fmt;
 
-	if (bpp == 0) {
-		return -EINVAL;
-	}
-
-	data->csi_config.bytesPerPixel = bpp;
-	data->csi_config.linePitch_Bytes = fmt->pitch;
+	data->csi_config.bytesPerPixel = video_bits_per_pixel(fmt->pixelformat) / BITS_PER_BYTE;
+	data->csi_config.linePitch_Bytes = fmt->width * data->csi_config.bytesPerPixel;
 #if defined(CONFIG_VIDEO_MCUX_MIPI_CSI2RX)
 	if (fmt->pixelformat != VIDEO_PIX_FMT_XRGB32 && fmt->pixelformat != VIDEO_PIX_FMT_XYUV32) {
 		return -ENOTSUP;
@@ -172,6 +167,8 @@ static int video_mcux_csi_set_fmt(const struct device *dev, struct video_format
 		return -EIO;
 	}
 
+	fmt->pitch = data->csi_config.linePitch_Bytes;
+
 	return 0;
 }
 
diff --git a/drivers/video/video_mcux_smartdma.c b/drivers/video/video_mcux_smartdma.c
@@ -218,6 +218,7 @@ static const struct video_format_cap fmts[] = {
 static int nxp_video_sdma_set_format(const struct device *dev, struct video_format *fmt)
 {
 	const struct nxp_video_sdma_config *config = dev->config;
+	int ret;
 
 	if (fmt == NULL) {
 		return -EINVAL;
@@ -230,14 +231,20 @@ static int nxp_video_sdma_set_format(const struct device *dev, struct video_form
 
 	if ((fmt->pixelformat != fmts[0].pixelformat) ||
 	    (fmt->width != fmts[0].width_min) ||
-	    (fmt->height != fmts[0].height_min) ||
-	    (fmt->pitch != fmts[0].width_min * 2)) {
+	    (fmt->height != fmts[0].height_min)) {
 		LOG_ERR("Unsupported format");
 		return -ENOTSUP;
 	}
 
 	/* Forward format to sensor device */
-	return video_set_format(config->sensor_dev, fmt);
+	ret = video_set_format(config->sensor_dev, fmt);
+	if (ret < 0) {
+		return ret;
+	}
+
+	fmt->pitch = fmt->width * video_bits_per_pixel(fmt->pixelformat) / BITS_PER_BYTE;
+
+	return 0;
 }
 
 static int nxp_video_sdma_get_format(const struct device *dev, struct video_format *fmt)
@@ -267,8 +274,7 @@ static int nxp_video_sdma_get_format(const struct device *dev, struct video_form
 	/* Verify that format is RGB565 */
 	if ((fmt->pixelformat != fmts[0].pixelformat) ||
 	    (fmt->width != fmts[0].width_min) ||
-	    (fmt->height != fmts[0].height_min) ||
-	    (fmt->pitch != fmts[0].width_min * 2)) {
+	    (fmt->height != fmts[0].height_min)) {
 		/* Update format of sensor */
 		fmt->pixelformat = fmts[0].pixelformat;
 		fmt->width = fmts[0].width_min;
@@ -281,6 +287,8 @@ 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;
+
 	return 0;
 }
 
diff --git a/drivers/video/video_stm32_dcmi.c b/drivers/video/video_stm32_dcmi.c
@@ -197,6 +197,8 @@ 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;
+
 	data->fmt = *fmt;
 
 	return 0;
@@ -218,6 +220,8 @@ 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;
+
 	data->fmt = *fmt;
 
 	return 0;
diff --git a/drivers/video/video_sw_generator.c b/drivers/video/video_sw_generator.c
@@ -81,6 +81,8 @@ static int video_sw_generator_set_fmt(const struct device *dev, struct video_for
 		return -ENOTSUP;
 	}
 
+	fmt->pitch = fmt->width * video_bits_per_pixel(fmt->pixelformat) / BITS_PER_BYTE;
+
 	data->fmt = *fmt;
 
 	return 0;
diff --git a/samples/drivers/video/capture/src/main.c b/samples/drivers/video/capture/src/main.c
@@ -150,7 +150,6 @@ int main(void)
 
 #if CONFIG_VIDEO_FRAME_WIDTH
 	fmt.width = CONFIG_VIDEO_FRAME_WIDTH;
-	fmt.pitch = fmt.width * video_bits_per_pixel(fmt.pixelformat) / BITS_PER_BYTE;
 #endif
 
 	if (strcmp(CONFIG_VIDEO_PIXEL_FORMAT, "")) {
diff --git a/samples/drivers/video/capture_to_lvgl/src/main.c b/samples/drivers/video/capture_to_lvgl/src/main.c
@@ -79,7 +79,6 @@ int main(void)
 	/* Set format */
 	fmt.width = CONFIG_VIDEO_WIDTH;
 	fmt.height = CONFIG_VIDEO_HEIGHT;
-	fmt.pitch = fmt.width * video_bits_per_pixel(fmt.pixelformat) / BITS_PER_BYTE;
 	fmt.pixelformat = VIDEO_PIX_FMT_RGB565;
 
 	if (video_set_format(video_dev, &fmt)) {
diff --git a/tests/drivers/video/api/src/video_common.c b/tests/drivers/video/api/src/video_common.c
@@ -36,40 +36,34 @@ ZTEST(video_common, test_video_format_caps_index)
 
 	fmt.width = 100;
 	fmt.height = 100;
-	fmt.pitch = 100 * 2;
 	ret = video_format_caps_index(fmts, &fmt, &idx);
 	zassert_ok(ret, "expecting minimum value to match");
 	zassert_equal(idx, YUYV_A);
 
 	fmt.width = 1000;
 	fmt.height = 1000;
-	fmt.pitch = 1000 * 2;
 	ret = video_format_caps_index(fmts, &fmt, &idx);
 	zassert_ok(ret, "expecting maximum value to match");
 	zassert_equal(idx, YUYV_A);
 
 	fmt.width = 1920;
 	fmt.height = 1080;
-	fmt.pitch = 1920 * 2;
 	ret = video_format_caps_index(fmts, &fmt, &idx);
 	zassert_ok(ret, "expecting exact match to work");
 	zassert_equal(idx, YUYV_B);
 
 	fmt.width = 1001;
 	fmt.height = 1000;
-	fmt.pitch = 1001 * 2;
 	ret = video_format_caps_index(fmts, &fmt, &idx);
 	zassert_not_ok(ret, "expecting 1 above maximum width to mismatch");
 
 	fmt.width = 1000;
 	fmt.height = 1001;
-	fmt.pitch = 1000 * 2;
 	ret = video_format_caps_index(fmts, &fmt, &idx);
 	zassert_not_ok(ret, "expecting 1 above maximum height to mismatch");
 
 	fmt.width = 1280;
 	fmt.height = 720;
-	fmt.pitch = 1280 * 2;
 	ret = video_format_caps_index(fmts, &fmt, &idx);
 	zassert_not_ok(ret);
 	zassert_not_ok(ret, "expecting wrong format to mismatch");
@@ -78,13 +72,11 @@ ZTEST(video_common, test_video_format_caps_index)
 
 	fmt.width = 1000;
 	fmt.height = 1000;
-	fmt.pitch = 1000 * 2;
 	ret = video_format_caps_index(fmts, &fmt, &idx);
 	zassert_not_ok(ret, "expecting wrong format to mismatch");
 
 	fmt.width = 1280;
 	fmt.height = 720;
-	fmt.pitch = 1280 * 2;
 	ret = video_format_caps_index(fmts, &fmt, &idx);
 	zassert_ok(ret, "expecting exact match to work");
 	zassert_equal(idx, RGB565);
diff --git a/tests/drivers/video/api/src/video_emul.c b/tests/drivers/video/api/src/video_emul.c
@@ -158,7 +158,6 @@ ZTEST(video_common, test_video_vbuf)
 	fmt.pixelformat = caps.format_caps[0].pixelformat;
 	fmt.width = caps.format_caps[0].width_max;
 	fmt.height = caps.format_caps[0].height_max;
-	fmt.pitch = fmt.width * video_bits_per_pixel(fmt.pixelformat) / BITS_PER_BYTE;
 	fmt.type = type;
 	zexpect_ok(video_set_format(rx_dev, &fmt));
 

Original file line number	Diff line number	Diff line change
`@@ -1433,7 +1433,6 @@ static int ov5640_init(const struct device *dev)`
`1433`	`1433`	`fmt.width = 1280;`
`1434`	`1434`	`fmt.height = 720;`
`1435`	`1435`	`}`
`1436`		`- fmt.pitch = fmt.width * video_bits_per_pixel(fmt.pixelformat) / BITS_PER_BYTE;`
`1437`	`1436`	`ret = ov5640_set_fmt(dev, &fmt);`
`1438`	`1437`	`if (ret) {`
`1439`	`1438`	`LOG_ERR("Unable to configure default format");`
Original file line number	Diff line number	Diff line change
`@@ -67,7 +67,9 @@ static int emul_rx_set_fmt(const struct device const dev, struct video_format `
`67`	`67`	`}`
`68`	`68`
`69`	`69`	`/* Cache the format selected locally to use it for getting the size of the buffer */`
	`70`	`+ fmt->pitch = fmt->width * video_bits_per_pixel(fmt->pixelformat) / BITS_PER_BYTE;`
`70`	`71`	`data->fmt = *fmt;`
	`72`	`+`
`71`	`73`	`return 0;`
`72`	`74`	`}`
`73`	`75`
`@@ -216,6 +218,9 @@ int emul_rx_init(const struct device *dev)`
`216`	`218`	`return ret;`
`217`	`219`	`}`
`218`	`220`
	`221`	`+ data->fmt.pitch =`
	`222`	`+ data->fmt.width * video_bits_per_pixel(data->fmt.pixelformat) / BITS_PER_BYTE;`
	`223`	`+`
`219`	`224`	`k_fifo_init(&data->fifo_in);`
`220`	`225`	`k_fifo_init(&data->fifo_out);`
`221`	`226`	`k_work_init(&data->work, &emul_rx_worker);`
Original file line number	Diff line number	Diff line change
`@@ -269,21 +269,31 @@ static int video_esp32_get_fmt(const struct device dev, struct video_format fm`
`269`	`269`	`return ret;`
`270`	`270`	`}`
`271`	`271`
	`272`	`+ fmt->pitch = fmt->width * video_bits_per_pixel(fmt->pixelformat) / BITS_PER_BYTE;`
	`273`	`+`
`272`	`274`	`return 0;`
`273`	`275`	`}`
`274`	`276`
`275`	`277`	`static int video_esp32_set_fmt(const struct device dev, struct video_format fmt)`
`276`	`278`	`{`
`277`	`279`	`const struct video_esp32_config *cfg = dev->config;`
`278`	`280`	`struct video_esp32_data *data = dev->data;`
	`281`	`+ int ret;`
`279`	`282`
`280`	`283`	`if (fmt == NULL) {`
`281`	`284`	`return -EINVAL;`
`282`	`285`	`}`
`283`	`286`
	`287`	`+ ret = video_set_format(cfg->source_dev, fmt);`
	`288`	`+ if (ret < 0) {`
	`289`	`+ return ret;`
	`290`	`+ }`
	`291`	`+`
	`292`	`+ fmt->pitch = fmt->width * video_bits_per_pixel(fmt->pixelformat) / BITS_PER_BYTE;`
	`293`	`+`
`284`	`294`	`data->video_format = *fmt;`
`285`	`295`
`286`		`- return video_set_format(cfg->source_dev, fmt);`
	`296`	`+ return 0;`
`287`	`297`	`}`
`288`	`298`
`289`	`299`	`static int video_esp32_enqueue(const struct device dev, struct video_buffer vbuf)`