const struct imx_media_pixfmt *cc;
        struct v4l2_pix_format vdev_fmt;
        struct v4l2_mbus_framefmt *fmt;
+       struct v4l2_rect vdev_compose;
        int ret = 0;
 
        if (sdformat->pad >= PRPENCVF_NUM_PADS)
        priv->cc[sdformat->pad] = cc;
 
        /* propagate output pad format to capture device */
-       imx_media_mbus_fmt_to_pix_fmt(&vdev_fmt,
+       imx_media_mbus_fmt_to_pix_fmt(&vdev_fmt, &vdev_compose,
                                      &priv->format_mbus[PRPENCVF_SRC_PAD],
                                      priv->cc[PRPENCVF_SRC_PAD]);
        mutex_unlock(&priv->lock);
-       imx_media_capture_device_set_format(vdev, &vdev_fmt);
+       imx_media_capture_device_set_format(vdev, &vdev_fmt, &vdev_compose);
 
        return 0;
 out:
 
 
 static int __capture_try_fmt_vid_cap(struct capture_priv *priv,
                                     struct v4l2_subdev_format *fmt_src,
-                                    struct v4l2_format *f)
+                                    struct v4l2_format *f,
+                                    struct v4l2_rect *compose)
 {
        const struct imx_media_pixfmt *cc, *cc_src;
 
                }
        }
 
-       imx_media_mbus_fmt_to_pix_fmt(&f->fmt.pix, &fmt_src->format, cc);
+       imx_media_mbus_fmt_to_pix_fmt(&f->fmt.pix, compose,
+                                     &fmt_src->format, cc);
 
        return 0;
 }
        if (ret)
                return ret;
 
-       return __capture_try_fmt_vid_cap(priv, &fmt_src, f);
+       return __capture_try_fmt_vid_cap(priv, &fmt_src, f, NULL);
 }
 
 static int capture_s_fmt_vid_cap(struct file *file, void *fh,
 {
        struct capture_priv *priv = video_drvdata(file);
        struct v4l2_subdev_format fmt_src;
+       struct v4l2_rect compose;
        int ret;
 
        if (vb2_is_busy(&priv->q)) {
        if (ret)
                return ret;
 
-       ret = __capture_try_fmt_vid_cap(priv, &fmt_src, f);
+       ret = __capture_try_fmt_vid_cap(priv, &fmt_src, f, &compose);
        if (ret)
                return ret;
 
        priv->vdev.fmt.fmt.pix = f->fmt.pix;
        priv->vdev.cc = imx_media_find_format(f->fmt.pix.pixelformat,
                                              CS_SEL_ANY, true);
-       priv->vdev.compose.left = 0;
-       priv->vdev.compose.top = 0;
-       priv->vdev.compose.width = fmt_src.format.width;
-       priv->vdev.compose.height = fmt_src.format.height;
+       priv->vdev.compose = compose;
 
        return 0;
 }
 };
 
 void imx_media_capture_device_set_format(struct imx_media_video_dev *vdev,
-                                        struct v4l2_pix_format *pix)
+                                        const struct v4l2_pix_format *pix,
+                                        const struct v4l2_rect *compose)
 {
        struct capture_priv *priv = to_capture_priv(vdev);
 
        priv->vdev.fmt.fmt.pix = *pix;
        priv->vdev.cc = imx_media_find_format(pix->pixelformat, CS_SEL_ANY,
                                              true);
+       priv->vdev.compose = *compose;
        mutex_unlock(&priv->mutex);
 }
 EXPORT_SYMBOL_GPL(imx_media_capture_device_set_format);
        }
 
        vdev->fmt.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
-       imx_media_mbus_fmt_to_pix_fmt(&vdev->fmt.fmt.pix,
+       imx_media_mbus_fmt_to_pix_fmt(&vdev->fmt.fmt.pix, &vdev->compose,
                                      &fmt_src.format, NULL);
-       vdev->compose.width = fmt_src.format.width;
-       vdev->compose.height = fmt_src.format.height;
        vdev->cc = imx_media_find_format(vdev->fmt.fmt.pix.pixelformat,
                                         CS_SEL_ANY, false);
 
 
        struct v4l2_pix_format vdev_fmt;
        struct v4l2_mbus_framefmt *fmt;
        struct v4l2_rect *crop, *compose;
+       struct v4l2_rect vdev_compose;
        int ret;
 
        if (sdformat->pad >= CSI_NUM_PADS)
        priv->cc[sdformat->pad] = cc;
 
        /* propagate IDMAC output pad format to capture device */
-       imx_media_mbus_fmt_to_pix_fmt(&vdev_fmt,
+       imx_media_mbus_fmt_to_pix_fmt(&vdev_fmt, &vdev_compose,
                                      &priv->format_mbus[CSI_SRC_PAD_IDMAC],
                                      priv->cc[CSI_SRC_PAD_IDMAC]);
        mutex_unlock(&priv->lock);
-       imx_media_capture_device_set_format(vdev, &vdev_fmt);
+       imx_media_capture_device_set_format(vdev, &vdev_fmt, &vdev_compose);
 
        return 0;
 out:
 
 EXPORT_SYMBOL_GPL(imx_media_fill_default_mbus_fields);
 
 int imx_media_mbus_fmt_to_pix_fmt(struct v4l2_pix_format *pix,
-                                 struct v4l2_mbus_framefmt *mbus,
+                                 struct v4l2_rect *compose,
+                                 const struct v4l2_mbus_framefmt *mbus,
                                  const struct imx_media_pixfmt *cc)
 {
        u32 width;
        pix->sizeimage = cc->planar ? ((stride * pix->height * cc->bpp) >> 3) :
                         stride * pix->height;
 
+       /*
+        * set capture compose rectangle, which is fixed to the
+        * source subdevice mbus format.
+        */
+       if (compose) {
+               compose->left = 0;
+               compose->top = 0;
+               compose->width = mbus->width;
+               compose->height = mbus->height;
+       }
+
        return 0;
 }
 EXPORT_SYMBOL_GPL(imx_media_mbus_fmt_to_pix_fmt);
 
        memset(image, 0, sizeof(*image));
 
-       ret = imx_media_mbus_fmt_to_pix_fmt(&image->pix, mbus, NULL);
+       ret = imx_media_mbus_fmt_to_pix_fmt(&image->pix, &image->rect,
+                                           mbus, NULL);
        if (ret)
                return ret;
 
-       image->rect.width = mbus->width;
-       image->rect.height = mbus->height;
-
        return 0;
 }
 EXPORT_SYMBOL_GPL(imx_media_mbus_fmt_to_ipu_image);
 
                                        struct v4l2_mbus_framefmt *fmt,
                                        bool ic_route);
 int imx_media_mbus_fmt_to_pix_fmt(struct v4l2_pix_format *pix,
-                                 struct v4l2_mbus_framefmt *mbus,
+                                 struct v4l2_rect *compose,
+                                 const struct v4l2_mbus_framefmt *mbus,
                                  const struct imx_media_pixfmt *cc);
 int imx_media_mbus_fmt_to_ipu_image(struct ipu_image *image,
                                    struct v4l2_mbus_framefmt *mbus);
 struct imx_media_buffer *
 imx_media_capture_device_next_buf(struct imx_media_video_dev *vdev);
 void imx_media_capture_device_set_format(struct imx_media_video_dev *vdev,
-                                        struct v4l2_pix_format *pix);
+                                        const struct v4l2_pix_format *pix,
+                                        const struct v4l2_rect *compose);
 void imx_media_capture_device_error(struct imx_media_video_dev *vdev);
 
 /* subdev group ids */