Documentation/DocBook/media/v4l/selection-api.xml

   1 <section id="selection-api">
   2
   3   <title>API for cropping, composing and scaling</title>
   4
   5   <section>
   6     <title>Introduction</title>
   7
   8 <para>Some video capture devices can sample a subsection of a picture and
   9 shrink or enlarge it to an image of arbitrary size. Next, the devices can
  10 insert the image into larger one. Some video output devices can crop part of an
  11 input image, scale it up or down and insert it at an arbitrary scan line and
  12 horizontal offset into a video signal. We call these abilities cropping,
  13 scaling and composing.</para>
  14
  15 <para>On a video <emphasis>capture</emphasis> device the source is a video
  16 signal, and the cropping target determine the area actually sampled. The sink
  17 is an image stored in a memory buffer.  The composing area specifies which part
  18 of the buffer is actually written to by the hardware. </para>
  19
  20 <para>On a video <emphasis>output</emphasis> device the source is an image in a
  21 memory buffer, and the cropping target is a part of an image to be shown on a
  22 display. The sink is the display or the graphics screen. The application may
  23 select the part of display where the image should be displayed. The size and
  24 position of such a window is controlled by the compose target.</para>
  25
  26 <para>Rectangles for all cropping and composing targets are defined even if the
  27 device does supports neither cropping nor composing. Their size and position
  28 will be fixed in such a case. If the device does not support scaling then the
  29 cropping and composing rectangles have the same size.</para>
  30
  31   </section>
  32
  33     <section>
  34       <title>Selection targets</title>
  35
  36       <para>
  37       <figure id="sel-targets-capture">
  38         <title>Cropping and composing targets</title>
  39         <mediaobject>
  40           <imageobject>
  41             <imagedata fileref="selection.png" format="PNG" />
  42           </imageobject>
  43           <textobject>
  44             <phrase>Targets used by a cropping, composing and scaling
  45             process</phrase>
  46           </textobject>
  47         </mediaobject>
  48       </figure>
  49       </para>
  50
  51       <para>See <xref linkend="v4l2-selection-targets" /> for more
  52     information.</para>
  53     </section>
  54
  55   <section>
  56
  57   <title>Configuration</title>
  58
  59 <para>Applications can use the <link linkend="vidioc-g-selection">selection
  60 API</link> to select an area in a video signal or a buffer, and to query for
  61 default settings and hardware limits.</para>
  62
  63 <para>Video hardware can have various cropping, composing and scaling
  64 limitations. It may only scale up or down, support only discrete scaling
  65 factors, or have different scaling abilities in the horizontal and vertical
  66 directions. Also it may not support scaling at all. At the same time the
  67 cropping/composing rectangles may have to be aligned, and both the source and
  68 the sink may have arbitrary upper and lower size limits. Therefore, as usual,
  69 drivers are expected to adjust the requested parameters and return the actual
  70 values selected. An application can control the rounding behaviour using <link
  71 linkend="v4l2-selection-flags"> constraint flags </link>.</para>
  72
  73    <section>
  74
  75    <title>Configuration of video capture</title>
  76
  77 <para>See figure <xref linkend="sel-targets-capture" /> for examples of the
  78 selection targets available for a video capture device.  It is recommended to
  79 configure the cropping targets before to the composing targets.</para>
  80
  81 <para>The range of coordinates of the top left corner, width and height of
  82 areas that can be sampled is given by the <constant>V4L2_SEL_TGT_CROP_BOUNDS</constant>
  83 target. It is recommended for the driver developers to put the
  84 top/left corner at position <constant>(0,0)</constant>.  The rectangle's
  85 coordinates are expressed in pixels.</para>
  86
  87 <para>The top left corner, width and height of the source rectangle, that is
  88 the area actually sampled, is given by the <constant>V4L2_SEL_TGT_CROP</constant>
  89 target. It uses the same coordinate system as <constant>V4L2_SEL_TGT_CROP_BOUNDS</constant>.
  90 The active cropping area must lie completely inside the capture boundaries. The
  91 driver may further adjust the requested size and/or position according to hardware
  92 limitations.</para>
  93
  94 <para>Each capture device has a default source rectangle, given by the
  95 <constant>V4L2_SEL_TGT_CROP_DEFAULT</constant> target. This rectangle shall
  96 over what the driver writer considers the complete picture.  Drivers shall set
  97 the active crop rectangle to the default when the driver is first loaded, but
  98 not later.</para>
  99
 100 <para>The composing targets refer to a memory buffer. The limits of composing
 101 coordinates are obtained using <constant>V4L2_SEL_TGT_COMPOSE_BOUNDS</constant>.
 102 All coordinates are expressed in pixels. The rectangle's top/left
 103 corner must be located at position <constant>(0,0)</constant>. The width and
 104 height are equal to the image size set by <constant>VIDIOC_S_FMT</constant>.
 105 </para>
 106
 107 <para>The part of a buffer into which the image is inserted by the hardware is
 108 controlled by the <constant>V4L2_SEL_TGT_COMPOSE</constant> target.
 109 The rectangle's coordinates are also expressed in the same coordinate system as
 110 the bounds rectangle. The composing rectangle must lie completely inside bounds
 111 rectangle. The driver must adjust the composing rectangle to fit to the
 112 bounding limits. Moreover, the driver can perform other adjustments according
 113 to hardware limitations. The application can control rounding behaviour using
 114 <link linkend="v4l2-selection-flags"> constraint flags</link>.</para>
 115
 116 <para>For capture devices the default composing rectangle is queried using
 117 <constant>V4L2_SEL_TGT_COMPOSE_DEFAULT</constant>. It is usually equal to the
 118 bounding rectangle.</para>
 119
 120 <para>The part of a buffer that is modified by the hardware is given by
 121 <constant>V4L2_SEL_TGT_COMPOSE_PADDED</constant>. It contains all pixels
 122 defined using <constant>V4L2_SEL_TGT_COMPOSE</constant> plus all
 123 padding data modified by hardware during insertion process. All pixels outside
 124 this rectangle <emphasis>must not</emphasis> be changed by the hardware. The
 125 content of pixels that lie inside the padded area but outside active area is
 126 undefined. The application can use the padded and active rectangles to detect
 127 where the rubbish pixels are located and remove them if needed.</para>
 128
 129    </section>
 130
 131    <section>
 132
 133    <title>Configuration of video output</title>
 134
 135 <para>For output devices targets and ioctls are used similarly to the video
 136 capture case. The <emphasis>composing</emphasis> rectangle refers to the
 137 insertion of an image into a video signal. The cropping rectangles refer to a
 138 memory buffer. It is recommended to configure the composing targets before to
 139 the cropping targets.</para>
 140
 141 <para>The cropping targets refer to the memory buffer that contains an image to
 142 be inserted into a video signal or graphical screen. The limits of cropping
 143 coordinates are obtained using <constant>V4L2_SEL_TGT_CROP_BOUNDS</constant>.
 144 All coordinates are expressed in pixels. The top/left corner is always point
 145 <constant>(0,0)</constant>.  The width and height is equal to the image size
 146 specified using <constant>VIDIOC_S_FMT</constant> ioctl.</para>
 147
 148 <para>The top left corner, width and height of the source rectangle, that is
 149 the area from which image date are processed by the hardware, is given by the
 150 <constant>V4L2_SEL_TGT_CROP</constant>. Its coordinates are expressed
 151 in in the same coordinate system as the bounds rectangle. The active cropping
 152 area must lie completely inside the crop boundaries and the driver may further
 153 adjust the requested size and/or position according to hardware
 154 limitations.</para>
 155
 156 <para>For output devices the default cropping rectangle is queried using
 157 <constant>V4L2_SEL_TGT_CROP_DEFAULT</constant>. It is usually equal to the
 158 bounding rectangle.</para>
 159
 160 <para>The part of a video signal or graphics display where the image is
 161 inserted by the hardware is controlled by <constant>V4L2_SEL_TGT_COMPOSE</constant>
 162 target.  The rectangle's coordinates are expressed in pixels. The composing
 163 rectangle must lie completely inside the bounds rectangle.  The driver must
 164 adjust the area to fit to the bounding limits.  Moreover, the driver can
 165 perform other adjustments according to hardware limitations.</para>
 166
 167 <para>The device has a default composing rectangle, given by the
 168 <constant>V4L2_SEL_TGT_COMPOSE_DEFAULT</constant> target. This rectangle shall cover what
 169 the driver writer considers the complete picture. It is recommended for the
 170 driver developers to put the top/left corner at position <constant>(0,0)</constant>.
 171 Drivers shall set the active composing rectangle to the default
 172 one when the driver is first loaded.</para>
 173
 174 <para>The devices may introduce additional content to video signal other than
 175 an image from memory buffers.  It includes borders around an image. However,
 176 such a padded area is driver-dependent feature not covered by this document.
 177 Driver developers are encouraged to keep padded rectangle equal to active one.
 178 The padded target is accessed by the <constant>V4L2_SEL_TGT_COMPOSE_PADDED</constant>
 179 identifier.  It must contain all pixels from the <constant>V4L2_SEL_TGT_COMPOSE</constant>
 180 target.</para>
 181
 182    </section>
 183
 184    <section>
 185
 186      <title>Scaling control</title>
 187
 188 <para>An application can detect if scaling is performed by comparing the width
 189 and the height of rectangles obtained using <constant>V4L2_SEL_TGT_CROP</constant>
 190 and <constant>V4L2_SEL_TGT_COMPOSE</constant> targets. If
 191 these are not equal then the scaling is applied. The application can compute
 192 the scaling ratios using these values.</para>
 193
 194    </section>
 195
 196   </section>
 197
 198   <section>
 199
 200     <title>Comparison with old cropping API</title>
 201
 202 <para>The selection API was introduced to cope with deficiencies of previous
 203 <link linkend="crop"> API</link>, that was designed to control simple capture
 204 devices. Later the cropping API was adopted by video output drivers. The ioctls
 205 are used to select a part of the display were the video signal is inserted. It
 206 should be considered as an API abuse because the described operation is
 207 actually the composing.  The selection API makes a clear distinction between
 208 composing and cropping operations by setting the appropriate targets.  The V4L2
 209 API lacks any support for composing to and cropping from an image inside a
 210 memory buffer.  The application could configure a capture device to fill only a
 211 part of an image by abusing V4L2 API.  Cropping a smaller image from a larger
 212 one is achieved by setting the field
 213 &v4l2-pix-format;<structfield>::bytesperline</structfield>.  Introducing an image offsets
 214 could be done by modifying field &v4l2-buffer;<structfield>::m_userptr</structfield>
 215 before calling <constant>VIDIOC_QBUF</constant>. Those
 216 operations should be avoided because they are not portable (endianness), and do
 217 not work for macroblock and Bayer formats and mmap buffers.  The selection API
 218 deals with configuration of buffer cropping/composing in a clear, intuitive and
 219 portable way.  Next, with the selection API the concepts of the padded target
 220 and constraints flags are introduced.  Finally, &v4l2-crop; and &v4l2-cropcap;
 221 have no reserved fields. Therefore there is no way to extend their functionality.
 222 The new &v4l2-selection; provides a lot of place for future
 223 extensions.  Driver developers are encouraged to implement only selection API.
 224 The former cropping API would be simulated using the new one.</para>
 225
 226   </section>
 227
 228    <section>
 229       <title>Examples</title>
 230       <example>
 231         <title>Resetting the cropping parameters</title>
 232
 233         <para>(A video capture device is assumed; change
 234 <constant>V4L2_BUF_TYPE_VIDEO_CAPTURE</constant> for other devices; change target to
 235 <constant>V4L2_SEL_TGT_COMPOSE_*</constant> family to configure composing
 236 area)</para>
 237
 238         <programlisting>
 239
 240         &v4l2-selection; sel = {
 241                 .type = V4L2_BUF_TYPE_VIDEO_CAPTURE,
 242                 .target = V4L2_SEL_TGT_CROP_DEFAULT,
 243         };
 244         ret = ioctl(fd, &VIDIOC-G-SELECTION;, &amp;sel);
 245         if (ret)
 246                 exit(-1);
 247         sel.target = V4L2_SEL_TGT_CROP;
 248         ret = ioctl(fd, &VIDIOC-S-SELECTION;, &amp;sel);
 249         if (ret)
 250                 exit(-1);
 251
 252         </programlisting>
 253       </example>
 254
 255       <example>
 256         <title>Simple downscaling</title>
 257         <para>Setting a composing area on output of size of <emphasis> at most
 258 </emphasis> half of limit placed at a center of a display.</para>
 259         <programlisting>
 260
 261         &v4l2-selection; sel = {
 262                 .type = V4L2_BUF_TYPE_VIDEO_OUTPUT,
 263                 .target = V4L2_SEL_TGT_COMPOSE_BOUNDS,
 264         };
 265         struct v4l2_rect r;
 266
 267         ret = ioctl(fd, &VIDIOC-G-SELECTION;, &amp;sel);
 268         if (ret)
 269                 exit(-1);
 270         /* setting smaller compose rectangle */
 271         r.width = sel.r.width / 2;
 272         r.height = sel.r.height / 2;
 273         r.left = sel.r.width / 4;
 274         r.top = sel.r.height / 4;
 275         sel.r = r;
 276         sel.target = V4L2_SEL_TGT_COMPOSE;
 277         sel.flags = V4L2_SEL_FLAG_LE;
 278         ret = ioctl(fd, &VIDIOC-S-SELECTION;, &amp;sel);
 279         if (ret)
 280                 exit(-1);
 281
 282         </programlisting>
 283       </example>
 284
 285       <example>
 286         <title>Querying for scaling factors</title>
 287         <para>A video output device is assumed; change
 288 <constant>V4L2_BUF_TYPE_VIDEO_OUTPUT</constant> for other devices</para>
 289         <programlisting>
 290
 291         &v4l2-selection; compose = {
 292                 .type = V4L2_BUF_TYPE_VIDEO_OUTPUT,
 293                 .target = V4L2_SEL_TGT_COMPOSE,
 294         };
 295         &v4l2-selection; crop = {
 296                 .type = V4L2_BUF_TYPE_VIDEO_OUTPUT,
 297                 .target = V4L2_SEL_TGT_CROP,
 298         };
 299         double hscale, vscale;
 300
 301         ret = ioctl(fd, &VIDIOC-G-SELECTION;, &amp;compose);
 302         if (ret)
 303                 exit(-1);
 304         ret = ioctl(fd, &VIDIOC-G-SELECTION;, &amp;crop);
 305         if (ret)
 306                 exit(-1);
 307
 308         /* computing scaling factors */
 309         hscale = (double)compose.r.width / crop.r.width;
 310         vscale = (double)compose.r.height / crop.r.height;
 311
 312         </programlisting>
 313       </example>
 314
 315    </section>
 316
 317 </section>