drivers: video: Move format pitch setting to bridge drivers

ngphibang · ngphibang · commit 78e6214e93be · 2025-05-16T10:27:26.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
@@ -1186,7 +1186,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, VIDEO_EP_OUT, &fmt);
 	if (ret) {
diff --git a/drivers/video/mt9m114.c b/drivers/video/mt9m114.c
@@ -567,7 +567,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, VIDEO_EP_OUT, &fmt);
 	if (ret) {
diff --git a/drivers/video/ov2640.c b/drivers/video/ov2640.c
@@ -1036,7 +1036,7 @@ 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, VIDEO_EP_OUT, &fmt);
 	if (ret) {
 		LOG_ERR("Unable to configure default format");
diff --git a/drivers/video/ov5640.c b/drivers/video/ov5640.c
@@ -1439,7 +1439,7 @@ 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, VIDEO_EP_OUT, &fmt);
 	if (ret) {
 		LOG_ERR("Unable to configure default format");
diff --git a/drivers/video/ov7670.c b/drivers/video/ov7670.c
@@ -557,7 +557,7 @@ 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, VIDEO_EP_OUT, &fmt);
 	if (ret < 0) {
 		return ret;
diff --git a/drivers/video/ov7725.c b/drivers/video/ov7725.c
@@ -598,7 +598,7 @@ 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, VIDEO_EP_OUT, &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
@@ -398,7 +398,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, VIDEO_EP_OUT, &fmt);
 	if (ret < 0) {
diff --git a/drivers/video/video_emul_rx.c b/drivers/video/video_emul_rx.c
@@ -88,7 +88,9 @@ static int emul_rx_set_fmt(const struct device *const dev, enum video_endpoint_i
 	}
 
 	/* 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;
 }
 
@@ -262,6 +264,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
@@ -275,6 +275,8 @@ static int video_esp32_get_fmt(const struct device *dev, enum video_endpoint_id
 		return ret;
 	}
 
+	fmt->pitch = fmt->width * video_bits_per_pixel(fmt->pixelformat) / BITS_PER_BYTE;
+
 	return 0;
 }
 
@@ -283,14 +285,22 @@ static int video_esp32_set_fmt(const struct device *dev, enum video_endpoint_id
 {
 	const struct video_esp32_config *cfg = dev->config;
 	struct video_esp32_data *data = dev->data;
+	int ret;
 
 	if (fmt == NULL || ep != VIDEO_EP_OUT) {
 		return -EINVAL;
 	}
 
+	ret = video_set_format(cfg->source_dev, ep, fmt);
+	if (ret) {
+		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, ep, fmt);
+	return 0;
 }
 
 static int video_esp32_enqueue(const struct device *dev, enum video_endpoint_id ep,
diff --git a/drivers/video/video_mcux_csi.c b/drivers/video/video_mcux_csi.c
@@ -134,16 +134,15 @@ static int video_mcux_csi_set_fmt(const struct device *dev, enum video_endpoint_
 {
 	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 || (ep != VIDEO_EP_OUT && ep != VIDEO_EP_ALL)) {
+	if (ep != VIDEO_EP_OUT && ep != VIDEO_EP_ALL) {
 		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;
@@ -173,6 +172,8 @@ static int video_mcux_csi_set_fmt(const struct device *dev, enum video_endpoint_
 		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
@@ -233,6 +233,7 @@ 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 || ep != VIDEO_EP_OUT)  {
 		return -EINVAL;
@@ -245,14 +246,20 @@ static int nxp_video_sdma_set_format(const struct device *dev,
 
 	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, ep, fmt);
+	ret = video_set_format(config->sensor_dev, ep, fmt);
+	if (ret) {
+		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,
@@ -284,8 +291,7 @@ static int nxp_video_sdma_get_format(const struct device *dev,
 	/* 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;
@@ -298,6 +304,8 @@ static int nxp_video_sdma_get_format(const struct device *dev,
 		}
 	}
 
+	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
@@ -203,6 +203,8 @@ static int video_stm32_dcmi_set_fmt(const struct device *dev,
 		return ret;
 	}
 
+	fmt->pitch = fmt->width * video_bits_per_pixel(fmt->pixelformat) / BITS_PER_BYTE;
+
 	data->fmt = *fmt;
 
 	return 0;
@@ -226,6 +228,8 @@ static int video_stm32_dcmi_get_fmt(const struct device *dev,
 		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
@@ -86,6 +86,8 @@ static int video_sw_generator_set_fmt(const struct device *dev, enum video_endpo
 		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
@@ -147,7 +147,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
@@ -76,7 +76,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, VIDEO_EP_OUT, &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
@@ -156,7 +156,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;
 	zexpect_ok(video_set_format(rx_dev, VIDEO_EP_OUT, &fmt));
 
 	/* Allocate a buffer, assuming prj.conf gives enough memory for it */

Original file line number	Diff line number	Diff line change
`@@ -1439,7 +1439,7 @@ static int ov5640_init(const struct device *dev)`
`1439`	`1439`	`fmt.width = 1280;`
`1440`	`1440`	`fmt.height = 720;`
`1441`	`1441`	`}`
`1442`		`- fmt.pitch = fmt.width * video_bits_per_pixel(fmt.pixelformat) / BITS_PER_BYTE;`
	`1442`	`+`
`1443`	`1443`	`ret = ov5640_set_fmt(dev, VIDEO_EP_OUT, &fmt);`
`1444`	`1444`	`if (ret) {`
`1445`	`1445`	`LOG_ERR("Unable to configure default format");`
Original file line number	Diff line number	Diff line change
`@@ -88,7 +88,9 @@ static int emul_rx_set_fmt(const struct device *const dev, enum video_endpoint_i`
`88`	`88`	`}`
`89`	`89`
`90`	`90`	`/* Cache the format selected locally to use it for getting the size of the buffer */`
	`91`	`+ fmt->pitch = fmt->width * video_bits_per_pixel(fmt->pixelformat) / BITS_PER_BYTE;`
`91`	`92`	`data->fmt = *fmt;`
	`93`	`+`
`92`	`94`	`return 0;`
`93`	`95`	`}`
`94`	`96`
`@@ -262,6 +264,9 @@ int emul_rx_init(const struct device *dev)`
`262`	`264`	`return ret;`
`263`	`265`	`}`
`264`	`266`
	`267`	`+ data->fmt.pitch =`
	`268`	`+ data->fmt.width * video_bits_per_pixel(data->fmt.pixelformat) / BITS_PER_BYTE;`
	`269`	`+`
`265`	`270`	`k_fifo_init(&data->fifo_in);`
`266`	`271`	`k_fifo_init(&data->fifo_out);`
`267`	`272`	`k_work_init(&data->work, &emul_rx_worker);`
Original file line number	Diff line number	Diff line change
`@@ -275,6 +275,8 @@ static int video_esp32_get_fmt(const struct device *dev, enum video_endpoint_id`
`275`	`275`	`return ret;`
`276`	`276`	`}`
`277`	`277`
	`278`	`+ fmt->pitch = fmt->width * video_bits_per_pixel(fmt->pixelformat) / BITS_PER_BYTE;`
	`279`	`+`
`278`	`280`	`return 0;`
`279`	`281`	`}`
`280`	`282`
`@@ -283,14 +285,22 @@ static int video_esp32_set_fmt(const struct device *dev, enum video_endpoint_id`
`283`	`285`	`{`
`284`	`286`	`const struct video_esp32_config *cfg = dev->config;`
`285`	`287`	`struct video_esp32_data *data = dev->data;`
	`288`	`+ int ret;`
`286`	`289`
`287`	`290`	`if (fmt == NULL \|\| ep != VIDEO_EP_OUT) {`
`288`	`291`	`return -EINVAL;`
`289`	`292`	`}`
`290`	`293`
	`294`	`+ ret = video_set_format(cfg->source_dev, ep, fmt);`
	`295`	`+ if (ret) {`
	`296`	`+ return ret;`
	`297`	`+ }`
	`298`	`+`
	`299`	`+ fmt->pitch = fmt->width * video_bits_per_pixel(fmt->pixelformat) / BITS_PER_BYTE;`
	`300`	`+`
`291`	`301`	`data->video_format = *fmt;`
`292`	`302`
`293`		`- return video_set_format(cfg->source_dev, ep, fmt);`
	`303`	`+ return 0;`
`294`	`304`	`}`
`295`	`305`
`296`	`306`	`static int video_esp32_enqueue(const struct device *dev, enum video_endpoint_id ep,`
Original file line number	Diff line number	Diff line change
`@@ -134,16 +134,15 @@ static int video_mcux_csi_set_fmt(const struct device *dev, enum video_endpoint_`
`134`	`134`	`{`
`135`	`135`	`const struct video_mcux_csi_config *config = dev->config;`
`136`	`136`	`struct video_mcux_csi_data *data = dev->data;`
`137`		`- unsigned int bpp = video_bits_per_pixel(fmt->pixelformat) / BITS_PER_BYTE;`
`138`	`137`	`status_t ret;`
`139`	`138`	`struct video_format format = *fmt;`
`140`	`139`
`141`		`- if (bpp == 0 \|\| (ep != VIDEO_EP_OUT && ep != VIDEO_EP_ALL)) {`
	`140`	`+ if (ep != VIDEO_EP_OUT && ep != VIDEO_EP_ALL) {`
`142`	`141`	`return -EINVAL;`
`143`	`142`	`}`
`144`	`143`
`145`		`- data->csi_config.bytesPerPixel = bpp;`
`146`		`- data->csi_config.linePitch_Bytes = fmt->pitch;`
	`144`	`+ data->csi_config.bytesPerPixel = video_bits_per_pixel(fmt->pixelformat) / BITS_PER_BYTE;`
	`145`	`+ data->csi_config.linePitch_Bytes = fmt->width * data->csi_config.bytesPerPixel;`
`147`	`146`	`#if defined(CONFIG_VIDEO_MCUX_MIPI_CSI2RX)`
`148`	`147`	`if (fmt->pixelformat != VIDEO_PIX_FMT_XRGB32 && fmt->pixelformat != VIDEO_PIX_FMT_XYUV32) {`
`149`	`148`	`return -ENOTSUP;`
`@@ -173,6 +172,8 @@ static int video_mcux_csi_set_fmt(const struct device *dev, enum video_endpoint_`
`173`	`172`	`return -EIO;`
`174`	`173`	`}`
`175`	`174`
	`175`	`+ fmt->pitch = data->csi_config.linePitch_Bytes;`
	`176`	`+`
`176`	`177`	`return 0;`
`177`	`178`	`}`
`178`	`179`