Context Navigation

Changes between Version 1 and Version 2 of linux/v4l2

Timestamp:: 10/01/2018 11:10:51 PM (6 years ago)
Author:: Tim Harvey
Comment:: convert restored html back to wiki markup

Legend:

: Unmodified
: Added
: Removed
: Modified

linux/v4l2

-              v1
+              v2
+{{{#!html
+          <div id="wikipage" class="trac-content"><p>
+</p><div class="wiki-toc">
+<ol>
+  <li>
+    <a href="#LinuxVideo4Linux2APIv4l2">Linux Video4Linux2 API (v4l2)</a>
+    <ol>
+      <li>
+        <a href="#v4l2-ctlutility">v4l2-ctl utility</a>
+        <ol>
+          <li>
+            <a href="#videostandards">video standards</a>
+          </li>
+          <li>
+            <a href="#videoinputs">video inputs</a>
+          </li>
+          <li>
+            <a href="#pixelformatsframesizesandframerates">pixel formats, framesizes, and framerates</a>
+          </li>
+          <li>
+            <a href="#capturingvideoframes">capturing video frames</a>
+          </li>
+        </ol>
+      </li>
+      <li>
+        <a href="#v4l2applicationcode">v4l2 application code</a>
+      </li>
+      <li>
+        <a href="#IMX6Ventanamxc_v4l2_capturedriver">IMX6 Ventana mxc_v4l2_capture driver</a>
+      </li>
+    </ol>
+  </li>
+</ol>
+</div><p>
+</p>
+<h1 id="LinuxVideo4Linux2APIv4l2">Linux Video4Linux2 API (v4l2)</h1>
+<p>
+[[PageOutline]]
+= Linux Video4Linux2 API (v4l2)
 The Linux Video4Linux2 (v4l2) API is the kernel's video input and output interface.
+</p>
+<p>
+<span class="wikianchor" id="v4l2-ctl"></span>
+</p>
+<h2 id="v4l2-ctlutility">v4l2-ctl utility</h2>
+<p>
+The <tt>v4l2-ctl</tt> userspace application can be used to query or configure a v4l2 device.  For complete information, including output resolutions etc , use the following:
+</p>
+<div class="code"><pre>root@ventana:~# v4l2-ctl --device /dev/video3 --all <span class="c"># query all details about /dev/video3
+</span></pre></div><p>
+== v4l2-ctl utility
+The {{{v4l2-ctl}}} userspace application can be used to query or configure a v4l2 device. For complete information, including output resolutions etc , use the following:
+{{{#!bash
+root@ventana:~# v4l2-ctl --device /dev/video3 --all # query all details about /dev/video3
+}}}
 See Also:
+</p>
+<ul><li><a class="wiki" href="/wiki/Yocto/gstreamer">GStreamer</a>
+</li></ul><p>
+<span class="wikianchor" id="standard"></span>
+</p>
+<h3 id="videostandards">video standards</h3>
+<p>
+* [wiki:Yocto/gstreamer GStreamer]
+=== video standards
 Analog video v4l2 capture devices will support one or more of the various analog video standards used throughout the world. For example the ADV7180 supports NTSC, PAL, and SECAM standards.
+</p>
+<p>
+You can use the Video4Linux API to determine if an input is detected and what mode by using the <tt>v4l2-ctl --get-standard</tt> command which reports one of the following:
+</p>
+<ul><li>No supported input detected - Video Standard = 0x00ffffff
+</li><li>NTSC - Video Standard = 0x000000ff
+</li><li>PAL - Video Standard = 0x000000ff
+</li></ul><p>
+You can use the Video4Linux API to determine if an input is detected and what mode by using the {{{v4l2-ctl --get-standard}}} command which reports one of the following:
+ * No supported input detected - Video Standard = 0x00ffffff
+ * NTSC - Video Standard = 0x000000ff
+ * PAL - Video Standard = 0x000000ff
 Example:
+</p>
+<ul><li>Show Analog Video status on GW51xx/GW52xx/GW53xx (/dev/video0):
+<div class="code"><pre>v4l2-ctl --device /dev/video0 --get-standard
+</pre></div></li><li>Show Analog Video status on GW54xx (/dev/video1)
+<div class="code"><pre>v4l2-ctl --device /devivideo0 --get-standard
+</pre></div></li></ul><p>
+<span class="wikianchor" id="input"></span>
+</p>
+<h3 id="videoinputs">video inputs</h3>
+<p>
+Some capture devices have multiple video inputs. The <tt>v4l2-ctl</tt> application can be used to get or set the current input.
+</p>
+<p>
+ * Show Analog Video status on GW51xx/GW52xx/GW53xx (/dev/video0):
+{{{#!bash
+v4l2-ctl --device /dev/video0 --get-standard
+}}}
+ * Show Analog Video status on GW54xx (/dev/video1)
+{{{#!bash
+v4l2-ctl --device /devivideo0 --get-standard
+}}}
+=== video inputs
+Some capture devices have multiple video inputs. The {{{v4l2-ctl}}} application can be used to get or set the current input.
 Examples:
+</p>
+<ul><li>show current inputs that <tt>/dev/video3</tt> supports:
+<div class="code"><pre>v4l2-ctl --device /dev/video3 --get-input
+</pre></div></li><li>select input1:
+<div class="code"><pre>v4l2-ctl --device /dev/video3 --set-input<span class="o">=</span>1
+</pre></div></li></ul><p>
+<span class="wikianchor" id="format"></span>
+</p>
+<h3 id="pixelformatsframesizesandframerates">pixel formats, framesizes, and framerates</h3>
+<p>
+You can use <tt>v4l2-ctl</tt> to show what pixel formats a video device supports and select a desired format. Note that v4l2 devices support one or more pixel formats, and various resolutions and framerates for each format. You must ask what resolutions are supported for a particular format, and what framerates are supported for a particular resolution/format.
+</p>
+<p>
+ * show current inputs that /dev/video3 supports:
+{{{#!bash
+v4l2-ctl --device /dev/video3 --get-input
+}}}
+ * select input1:
+{{{#!bash
+v4l2-ctl --device /dev/video3 --set-input=1
+}}}
+=== pixel formats, framesizes, and framerates
+You can use {{{v4l2-ctl}}} to show what pixel formats a video device supports and select a desired format. Note that v4l2 devices support one or more pixel formats, and various resolutions and framerates for each format. You must ask what resolutions are supported for a particular format, and what framerates are supported for a particular resolution/format.
 Examples:
+</p>
+<ul><li>show formats that <tt>/dev/video3</tt> supports:
+<div class="code"><pre>v4l2-ctl --device /dev/video3 --list-formats-ext
+</pre></div></li><li>show what resolutions <tt>/dev/video3</tt> supports for the UYVY pixel format:
+<div class="code"><pre>v4l2-ctl --device /dev/video3 --list-framesizes<span class="o">=</span>UYVY
+</pre></div></li><li>show what framerates <tt>/dev/video3</tt> supports for UYVY at 640x480:
+<div class="code"><pre>v4l2-ctl --device /dev/video3 --list-frameintervals<span class="o">=</span><span class="nv">width</span><span class="o">=</span>640,height<span class="o">=</span>480,pixelformat<span class="o">=</span>UYVY
+</pre></div></li><li>set format for <tt>/dev/video0</tt> to 1280x720 UYVY:
+<div class="code"><pre>v4l2-ctl --device /dev/video0 --set-fmt-video<span class="o">=</span><span class="nv">width</span><span class="o">=</span>1280,height<span class="o">=</span>720,pixelformat<span class="o">=</span>UYVY
+</pre></div></li></ul><p>
+It is not uncommon for a v4l2 driver to not properly support the enumeration of various formats, resolutions, and framerates. If you find that a device is not returning anything useful for <tt>--list-formats</tt> <tt>--list-formats-ext</tt> <tt>--list-framesizes</tt> <tt>--list-framerates</tt> then you can try <tt>--all</tt> to get the default configuration of the device.
+</p>
+<p>
+ * show formats that {{{/dev/video3}}} supports:
+{{{#!bash
+v4l2-ctl --device /dev/video3 --list-formats-ext
+}}}
+ * show what resolutions {{{/dev/video3}}} supports for the UYVY pixel format:
+{{{#!bash
+v4l2-ctl --device /dev/video3 --list-framesizes=UYVY
+}}}
+ * show what framerates {{{/dev/video3}}} supports for UYVY at 640x480:
+{{{#!bash
+v4l2-ctl --device /dev/video3 --list-frameintervals=width=640,height=480,pixelformat=UYVY
+}}}
+ * set format for {{{/dev/video0}}} to 1280x720 UYVY:
+{{{#!bash
+v4l2-ctl --device /dev/video0 --set-fmt-video=width=1280,height=720,pixelformat=UYVY
+}}}
+It is not uncommon for a v4l2 driver to not properly support the enumeration of various formats, resolutions, and framerates. If you find that a device is not returning anything useful for {{{--list-formats}}} {{{--list-formats-ext}}} {{{--list-framesizes}}} {{{--list-framerates}}} then you can try {{{--all}}} to get the default configuration of the device.
 Examples:
+</p>
+<ul><li>the TDA1997x HDMI receiver on a GW54xx
 <div class="code"><pre>root@ventana:~# v4l2-ctl --device /dev/video0 --all
 Driver Info <span class="o">(</span>not using libv4l2<span class="o">)</span>:
+ * the TDA1997x HDMI receiver on a GW54xx
+{{{#!bash
+root@ventana:~# v4l2-ctl --device /dev/video0 --all
+Driver Info (not using libv4l2):
         Driver name   : mxc_v4l2
         Card <span class="nb">type</span>     :
+        Card type     :
         Bus info      :
         Driver version: 0.1.11
 …
                 Read/Write
                 Streaming
 Video input : 0 <span class="o">(</span>CSI IC MEM: ok<span class="o">)</span>
 Video output: 0 <span class="o">(</span>DISP3 BG<span class="o">)</span>
 Video <span class="nv">Standard</span> <span class="o">=</span> 0x00000000
+Video input : 0 (CSI IC MEM: ok)
+Video output: 0 (DISP3 BG)
+Video Standard = 0x00000000
 Format Video Capture:
         Width/Height  : 288/352
         Pixel Format  : <span class="s1">'UYVY'</span>
+        Pixel Format  : 'UYVY'
         Field         : Any
         Bytes per Line: 432
         Size Image    : 152064
         Colorspace    : Unknown <span class="o">(</span>00000000<span class="o">)</span>
+        Colorspace    : Unknown (00000000)
 Format Video Overlay:
         Left/Top    : 0/0
 …
         Width         : 0
         Height        : 0
         Pixel Format  : <span class="s1">''</span>
+        Pixel Format  : ''
 Crop Capability Video Capture:
         Bounds      : Left 0, Top 0, Width 1920, Height 1080
 …
 Crop: Left 0, Top 0, Width 1920, Height 1080
 Streaming Parameters Video Capture:
         Frames per second: 60.000 <span class="o">(</span>60/1<span class="o">)</span>
+        Frames per second: 60.000 (60/1)
         Read buffers     : 0
 Streaming Parameters Video Output:
         Frames per second: invalid <span class="o">(</span>0/0<span class="o">)</span>
+        Frames per second: invalid (0/0)
         Write buffers    : 0
+</pre></div><ul><li>Note that the width/height does not reflect the resolution of the current video input source. In the above case a 1080p@60Hz input is attached. You can determine the source resolution via the crop parameters.
+</li></ul></li><li>the ADV7180 Analog Video Decoder on a GW5400:
+<div class="code"><pre>root@ventana:~# v4l2-ctl --device /dev/video1 --all
+Driver Info <span class="o">(</span>not using libv4l2<span class="o">)</span>:<span class="o">[</span> 1863.994275<span class="o">]</span> ERROR: unrecognized std! ffffff <span class="o">(</span><span class="nv">PAL</span><span class="o">=</span>ff, <span class="nv">NTSC</span><span class="o">=</span>b000
+}}}
+  - Note that the width/height does not reflect the resolution of the current video input source. In the above case a 1080p@60Hz input is attached. You can determine the source resolution via the crop parameters.
+ * the ADV7180 Analog Video Decoder on a GW5400:
+{{{#!bash
+root@ventana:~# v4l2-ctl --device /dev/video1 --all
+Driver Info (not using libv4l2):[ 1863.994275] ERROR: unrecognized std! ffffff (PAL=ff, NTSC=b000
         Driver name   : mxc_v4l2
         Card <span class="nb">type</span>     :
+        Card type     :
         Bus info      :
         Driver version: 0.1.11
 …
                 Read/Write
                 Streaming
 Video input : 0 <span class="o">(</span>CSI IC MEM: ok<span class="o">)</span>
 Video output: 0 <span class="o">(</span>DISP3 BG<span class="o">)</span>
 Video <span class="nv">Standard</span> <span class="o">=</span> 0x00ffffff
+Video input : 0 (CSI IC MEM: ok)
+Video output: 0 (DISP3 BG)
+Video Standard = 0x00ffffff
         PAL-B/B1/G/H/I/D/D1/K/M/N/Nc/60
         NTSC-M/M-JP/443/M-KR
 …
 Format Video Capture:
         Width/Height  : 288/352
         Pixel Format  : <span class="s1">'YU12'</span>
+        Pixel Format  : 'YU12'
         Field         : Any
         Bytes per Line: 432
         Size Image    : 152064
         Colorspace    : Unknown <span class="o">(</span>00000000<span class="o">)</span>
+        Colorspace    : Unknown (00000000)
 Format Video Overlay:
         Left/Top    : 0/0
 …
         Width         : 0
         Height        : 0
         Pixel Format  : <span class="s1">''</span>
+        Pixel Format  : ''
 Crop Capability Video Capture:
         Bounds      : Left 0, Top 0, Width 720, Height 625
 …
 Crop: Left 0, Top 0, Width 720, Height 576
 Streaming Parameters Video Capture:
         Frames per second: 30.000 <span class="o">(</span>30/1<span class="o">)</span>
+        Frames per second: 30.000 (30/1)
         Read buffers     : 0
 Streaming Parameters Video Output:
         Frames per second: invalid <span class="o">(</span>0/0<span class="o">)</span>
+        Frames per second: invalid (0/0)
         Write buffers    : 0
+</pre></div></li></ul><p>
+<span class="wikianchor" id="capture"></span>
+</p>
+<h3 id="capturingvideoframes">capturing video frames</h3>
+<p>
+You can use <tt>v4l2-ctl</tt> to capture frames as well.
+</p>
+<p>
+}}}
+=== capturing video frames
+You can use {{{v4l2-ctl}}} to capture frames as well.
 Examples:
+</p>
+<ul><li>capture a single raw frame using mmap method:
 <div class="code"><pre>v4l2-ctl --device /dev/video0 --stream-mmap --stream-to<span class="o">=</span>frame.raw --stream-count<span class="o">=</span>1
+</pre></div></li></ul><p>
+Note that the <tt>convert</tt> tool from the <a class="ext-link" href="http://www.imagemagick.org/"><span class="icon"></span>ImageMagick</a> package is useful for image format conversions as long as you know the specific details of the raw image.
+</p>
+<p>
+ * capture a single raw frame using mmap method:
+{{{#!bash
+v4l2-ctl --device /dev/video0 --stream-mmap --stream-to=frame.raw --stream-count=1
+}}}
+Note that the convert tool from the [http://www.imagemagick.org/ ImageMagick] package is useful for image format conversions as long as you know the specific details of the raw image.
 Examples:
+</p>
+<ul><li>convert a raw 640x480 16bit UYVY to png:
+<div class="code"><pre>convert -size 640x480 -depth 16 uyvy:frame.raw frame.png
+</pre></div></li></ul><p>
+For an example v4l2 application for capturing frames see <a class="ext-link" href="https://linuxtv.org/downloads/v4l-dvb-apis/capture-example.html"><span class="icon"></span>here</a>
+</p>
+<p>
+For capturing video we recommend using more full-featured applications such as <a class="wiki" href="/wiki/Yocto/gstreamer">GStreamer</a>
+</p>
+<p>
+<span class="wikianchor" id="code"></span>
+</p>
+<h2 id="v4l2applicationcode">v4l2 application code</h2>
+<p>
+If you are coding an application that uses the v4l2 API the best examples are the v4l2-util application. You can find its source at <a class="ext-link" href="https://git.linuxtv.org/v4l-utils.git/tree/"><span class="icon"></span>https://git.linuxtv.org/v4l-utils.git/tree/</a>
+</p>
+<p>
+ * convert a raw 640x480 16bit UYVY to png:
+{{{#!bash
+convert -size 640x480 -depth 16 uyvy:frame.raw frame.png
+}}}
+For an example v4l2 application for capturing frames see [https://linuxtv.org/downloads/v4l-dvb-apis/capture-example.html here].
+For capturing video we recommend using more full-featured applications such as [wiki:Yocto/gstreamer GStreamer]
+== v4l2 application code
+If you are coding an application that uses the v4l2 API the best examples are the v4l2-util application. You can find its source at https://git.linuxtv.org/v4l-utils.git/tree/
 The API documentation can be found at:
+</p>
+<ul><li><a class="ext-link" href="http://www.linuxtv.org/downloads/v4l-dvb-apis/"><span class="icon"></span>http://www.linuxtv.org/downloads/v4l-dvb-apis/</a>
+<ul><li>Note that there are many references online to what is considered the 'legacy' API used prior to the 3.0 kernel. Be sure to use the documentation above for the current version of the v4l2 API.
+</li></ul></li></ul><p>
+ * http://www.linuxtv.org/downloads/v4l-dvb-apis/
+Note that there are many references online to what is considered the 'legacy' API used prior to the 3.0 kernel. Be sure to use the documentation above for the current version of the v4l2 API.
 Examples:
+</p>
+<ul><li>get/set/list video standard - <a class="ext-link" href="https://git.linuxtv.org/v4l-utils.git/tree/utils/v4l2-ctl/v4l2-ctl-stds.cpp"><span class="icon"></span>v4l2-ctl-stds.cpp</a>
+</li><li>get/set/list video input - <a class="ext-link" href="https://git.linuxtv.org/v4l-utils.git/tree/utils/v4l2-ctl/v4l2-ctl-io.cpp"><span class="icon"></span>v4l2-ctl-io.cpp</a>
+</li><li>get/set/list video pixel format - <a class="ext-link" href="https://git.linuxtv.org/v4l-utils.git/tree/utils/v4l2-ctl/v4l2-ctl-vidcap.cpp"><span class="icon"></span>v4l2-ctl-vidcap.cpp</a>
+</li><li>get/set/list video framesizes - <a class="ext-link" href="https://git.linuxtv.org/v4l-utils.git/tree/utils/v4l2-ctl/v4l2-ctl-vidcap.cpp"><span class="icon"></span>v4l2-ctl-vidcap.cpp</a>
+</li><li>get/set/list video framerates - <a class="ext-link" href="https://git.linuxtv.org/v4l-utils.git/tree/utils/v4l2-ctl/v4l2-ctl-vidcap.cpp"><span class="icon"></span>v4l2-ctl-vidcap.cpp</a>
+</li><li>video capture - <a class="ext-link" href="https://git.linuxtv.org/v4l-utils.git/tree/utils/v4l2-ctl/v4l2-ctl-streaming.cpp"><span class="icon"></span>v4l2-ctl-streaming.cpp</a>
+</li></ul><p>
+As a rule of thumb it is best to configure all aspects of a device within your code to eliminate any dependence on the initial state of a video device and/or requiring configuring a device outside of your application with something like <tt>v4l2-ctl</tt>. For completeness set the following:
+</p>
+<ul><li>input (VIDIOC_S_INPUT)
+</li><li>standard (VIDIOC_S_STD)
+</li><li>format (VIDIOC_S_FMT) including width, height, pixel format, fields
+</li><li>framerate (VIDIOC_S_PARM)
+</li></ul><p>
+Be aware that the <tt>ioctl</tt> syscall can return a -1 result with errno = EINTR to indicate the syscall was interrupted in which case it should be tried again. Because of this you should consider providing a wrapper for ioctl such as:
+</p>
+<div class="code"><pre><span class="k">static</span> <span class="kt">int</span> <span class="nf">xioctl</span><span class="p">(</span><span class="kt">int</span> fh<span class="p">,</span> <span class="kt">int</span> request<span class="p">,</span> <span class="kt">void</span> <span class="o">*</span>arg<span class="p">)</span>
+<span class="p">{</span>
+        <span class="kt">int</span> r<span class="p">;</span>
+        <span class="k">do</span> <span class="p">{</span>
+                r <span class="o">=</span> ioctl<span class="p">(</span>fh<span class="p">,</span> request<span class="p">,</span> arg<span class="p">);</span>
+        <span class="p">}</span> <span class="k">while</span> <span class="p">(</span><span class="o">-</span><span class="mi">1</span> <span class="o">==</span> r <span class="o">&amp;&amp;</span> EINTR <span class="o">==</span> errno<span class="p">);</span>
+        <span class="k">return</span> r<span class="p">;</span>
+<span class="p">}</span>
+</pre></div><p>
+<span class="wikianchor" id="ventana"></span>
+</p>
+<h2 id="IMX6Ventanamxc_v4l2_capturedriver">IMX6 Ventana mxc_v4l2_capture driver</h2>
+<p>
+ * get/set/list video standard - [https://git.linuxtv.org/v4l-utils.git/tree/utils/v4l2-ctl/v4l2-ctl-stds.cpp v4l2-ctl-stds.cpp]
+ * get/set/list video input - [https://git.linuxtv.org/v4l-utils.git/tree/utils/v4l2-ctl/v4l2-ctl-io.cpp v4l2-ctl-io.cpp]
+ * get/set/list video pixel format - [https://git.linuxtv.org/v4l-utils.git/tree/utils/v4l2-ctl/v4l2-ctl-vidcap.cpp v4l2-ctl-vidcap.cpp]
+ * get/set/list video framesizes - [https://git.linuxtv.org/v4l-utils.git/tree/utils/v4l2-ctl/v4l2-ctl-vidcap.cpp v4l2-ctl-vidcap.cpp]
+ * get/set/list video framerates - [https://git.linuxtv.org/v4l-utils.git/tree/utils/v4l2-ctl/v4l2-ctl-vidcap.cpp v4l2-ctl-vidcap.cpp]
+ * video capture - [https://git.linuxtv.org/v4l-utils.git/tree/utils/v4l2-ctl/v4l2-ctl-streaming.cpp v4l2-ctl-streaming.cpp]
+As a rule of thumb it is best to configure all aspects of a device within your code to eliminate any dependence on the initial state of a video device and/or requiring configuring a device outside of your application with something like {{{v4l2-ctl}}}. For completeness set the following:
+ * input (VIDIOC_S_INPUT)
+ * standard (VIDIOC_S_STD)
+ * format (VIDIOC_S_FMT) including width, height, pixel format, fields
+ * framerate (VIDIOC_S_PARM)
+Be aware that the {{{ioctl}}} syscall can return a -1 result with {{{errno = EINTR}}} to indicate the syscall was interrupted in which case it should be tried again. Because of this you should consider providing a wrapper for ioctl such as:
+{{{
+static int xioctl(int fh, int request, void *arg)
+{
+        int r;
+        do {
+                r = ioctl(fh, request, arg);
+        } while (-1 == r && EINTR == errno);
+        return r;
+}
+}}}
+== IMX6 Ventana mxc_v4l2_capture driver
 The Ventana product family based on the Freescale IMX6 System On Chip (SoC) has a Freescale provided capture driver (mxc_v4l2_capture) that is present in the Gateworks downstream vendor kernel used for the Yocto BSP.
+</p>
+<p>
 This capture device driver implements two video inputs which represent different pipelines in the SoC:
+</p>
+<ul><li>input0 (default) - CSI -&gt; IC -&gt; MEM: useful if you want to perform image manipulation using the IMX6 hardware blocks
+</li><li>input1 - CSI -&gt; MEM: raw image capture
+</li></ul><p>
+ * input0 (default) - CSI -> IC -> MEM: useful if you want to perform image manipulation using the IMX6 hardware blocks
+ * input1 - CSI -> MEM: raw image capture
 If capturing frames be sure to skip the first frame as the CSI has not fully synchronized on its capture input.
+</p>
+<p>
+To demonstrate a capture of a raw frame you can use the <tt>v4l2_ctl</tt> application:
+</p>
+<div class="code"><pre><span class="c"># configure input 1 for CSI -&gt; MEM (raw image capture)
+</span>v4l2-ctl --device /dev/video0 --set-input<span class="o">=</span>1
+<span class="c"># configure format
+</span>v4l2-ctl --device /dev/video0 --set-fmt-video<span class="o">=</span><span class="nv">width</span><span class="o">=</span>1920,height<span class="o">=</span>1080,pixelformat<span class="o">=</span>UYVY
+<span class="c"># capture 2nd frame
+</span>v4l2-ctl --device /dev/video0 --stream-mmap --stream-skip<span class="o">=</span>1 --stream-to<span class="o">=</span>frame.raw --stream-count<span class="o">=</span>1
+<span class="c"># Use ImageMagick to convert it from raw 16-bit UYVY to PNG
+</span>convert -size 1920x1080 -depth 16 uyvy:frame.raw frame.png
+</pre></div><p>
+To demonstrate a capture of a raw frame you can use the {{{v4l2_ctl}}} application:
+{{{#!bash
+# configure input 1 for CSI -> MEM (raw image capture)
+v4l2-ctl --device /dev/video0 --set-input=1
+# configure format
+v4l2-ctl --device /dev/video0 --set-fmt-video=width=1920,height=1080,pixelformat=UYVY
+# capture 2nd frame
+v4l2-ctl --device /dev/video0 --stream-mmap --stream-skip=1 --stream-to=frame.raw --stream-count=1
+# Use ImageMagick to convert it from raw 16-bit UYVY to PNG
+convert -size 1920x1080 -depth 16 uyvy:frame.raw frame.png
+}}}
 Notes:
+</p>
+<ul><li>The mxc_v4l2_capture driver does not support the enumeration ioctls necessary to query device capabilities (VIDIOC_ENUM_FMT, VIDIOC_ENUM_FRAMESIZES, VIDIOC_ENUM_FRAMEINTERVALS). The following format details show what is supported:
+<ul><li>HDMI In via tda1997x (GW54xx/GW551x): V4L2_PIX_FMT_UYVY non-interlaced frames (even when using the yuv422bt656 capture mode the bt656 is converted to non-interlaced frames by the IMX IC) with a resolution, framerate and colorspace dictated by the HDMI source.
+</li><li>CVBS In via adv7180: V4L2_PIX_FMT_UYVY non-interlaced frames (bt656 output is converted to non-interlaced frames by the IMX IC) with a resolution of either 720x480 (NTSC) or 720x576 (PAL) depending on the input source
+</li></ul></li></ul><p>
+ * The mxc_v4l2_capture driver does not support the enumeration ioctls necessary to query device capabilities (VIDIOC_ENUM_FMT, VIDIOC_ENUM_FRAMESIZES, VIDIOC_ENUM_FRAMEINTERVALS). The following format details show what is supported:
+  - HDMI In via tda1997x (GW54xx/GW551x): V4L2_PIX_FMT_UYVY non-interlaced frames (even when using the yuv422bt656 capture mode the bt656 is converted to non-interlaced frames by the IMX IC) with a resolution, framerate and colorspace dictated by the HDMI source.
+  - CVBS In via adv7180: V4L2_PIX_FMT_UYVY non-interlaced frames (bt656 output is converted to non-interlaced frames by the IMX IC) with a resolution of either 720x480 (NTSC) or 720x576 (PAL) depending on the input source
 Code Example:
+</p>
+<ul><li>This example code will capture raw frames from the onboard video capture devices on the Ventana boards using the IMX6 CSI. It shows how to save the raw frame, process pixels (by counting the number of red pixels in the image), and convert it to a png via imagemagick
 <div class="code"><pre><span class="cm">/*
+ * This example code will capture raw frames from the onboard video capture devices on the Ventana boards using the IMX6 CSI. It shows how to save the raw frame, process pixels (by counting the number of red pixels in the image), and convert it to a png via imagemagick
+{{{
+/*
  *  V4L2 video capture example
+ *
 …
  *      This program is provided with the V4L2 API
  * see http://linuxtv.org/docs.php for more information
  */</span>
+<span class="cp">
 #include &lt;byteswap.h&gt;
 #include &lt;stdio.h&gt;
 #include &lt;stdlib.h&gt;
 #include &lt;stdint.h&gt;
 #include &lt;string.h&gt;
 #include &lt;assert.h&gt;
 #include &lt;fcntl.h&gt;              </span><span class="cm">/* low-level i/o */</span><span class="cp">
 #include &lt;unistd.h&gt;
 #include &lt;errno.h&gt;
 #include &lt;sys/types.h&gt;
 #include &lt;sys/mman.h&gt;
 #include &lt;sys/ioctl.h&gt;
 #include &lt;linux/videodev2.h&gt;
 #define CLEAR(x) memset(&amp;(x), 0, sizeof(x))
+</span>
+<span class="k">struct</span> buffer <span class="p">{</span>
         <span class="kt">void</span>   <span class="o">*</span>start<span class="p">;</span>
         <span class="kt">size_t</span>  length<span class="p">;</span>
+<span class="p">};</span>
+<span class="k">static</span> <span class="kt">void</span> <span class="nf">errno_exit</span><span class="p">(</span><span class="k">const</span> <span class="kt">char</span> <span class="o">*</span>s<span class="p">)</span>
+<span class="p">{</span>
         fprintf<span class="p">(</span>stderr<span class="p">,</span> <span class="s">"%s error %d, %s</span><span class="se">\n</span><span class="s">"</span><span class="p">,</span> s<span class="p">,</span> errno<span class="p">,</span> strerror<span class="p">(</span>errno<span class="p">));</span>
         exit<span class="p">(</span>EXIT_FAILURE<span class="p">);</span>
+<span class="p">}</span>
+<span class="k">static</span> <span class="kt">int</span> <span class="nf">xioctl</span><span class="p">(</span><span class="kt">int</span> fh<span class="p">,</span> <span class="kt">int</span> request<span class="p">,</span> <span class="kt">void</span> <span class="o">*</span>arg<span class="p">)</span>
+<span class="p">{</span>
         <span class="kt">int</span> r<span class="p">;</span>
         <span class="k">do</span> <span class="p">{</span>
                 r <span class="o">=</span> ioctl<span class="p">(</span>fh<span class="p">,</span> request<span class="p">,</span> arg<span class="p">);</span>
         <span class="p">}</span> <span class="k">while</span> <span class="p">(</span><span class="o">-</span><span class="mi">1</span> <span class="o">==</span> r <span class="o">&amp;&amp;</span> EINTR <span class="o">==</span> errno<span class="p">);</span>
         <span class="k">return</span> r<span class="p">;</span>
+<span class="p">}</span>
+<span class="cm">/* 16bit/pixel interleaved YUV */</span>
+<span class="k">static</span> <span class="kt">void</span> <span class="nf">process_image</span><span class="p">(</span><span class="k">const</span> <span class="kt">void</span> <span class="o">*</span>_p<span class="p">,</span> <span class="k">struct</span> v4l2_pix_format <span class="o">*</span>fmt<span class="p">)</span>
+<span class="p">{</span>
         <span class="k">const</span> <span class="kt">uint8_t</span> <span class="o">*</span>p <span class="o">=</span> _p<span class="p">;</span>
         <span class="kt">int8_t</span> u<span class="p">;</span>
         <span class="kt">uint8_t</span> y1<span class="p">;</span>
         <span class="kt">int8_t</span> v<span class="p">;</span>
         <span class="kt">uint8_t</span> y2<span class="p">;</span>
         <span class="kt">int</span> r<span class="p">,</span> g<span class="p">,</span> b<span class="p">,</span> c<span class="p">,</span> d <span class="p">,</span>e<span class="p">;</span>
         <span class="kt">int</span> red<span class="p">,</span> i<span class="p">,</span> x<span class="p">,</span> y<span class="p">;</span>
         <span class="kt">int</span> size <span class="o">=</span> fmt<span class="o">-&gt;</span>sizeimage<span class="p">;</span>
         printf<span class="p">(</span><span class="s">"Processing Frame: %dx%d %c%c%c%c</span><span class="se">\n</span><span class="s">"</span><span class="p">,</span>
                 fmt<span class="o">-&gt;</span>width<span class="p">,</span> fmt<span class="o">-&gt;</span>height<span class="p">,</span>
                 <span class="p">(</span>fmt<span class="o">-&gt;</span>pixelformat <span class="o">&gt;&gt;</span> <span class="mi">0</span><span class="p">)</span> <span class="o">&amp;</span> <span class="mh">0xff</span><span class="p">,</span>
                 <span class="p">(</span>fmt<span class="o">-&gt;</span>pixelformat <span class="o">&gt;&gt;</span> <span class="mi">8</span><span class="p">)</span> <span class="o">&amp;</span> <span class="mh">0xff</span><span class="p">,</span>
                 <span class="p">(</span>fmt<span class="o">-&gt;</span>pixelformat <span class="o">&gt;&gt;</span> <span class="mi">16</span><span class="p">)</span> <span class="o">&amp;</span> <span class="mh">0xff</span><span class="p">,</span>
                 <span class="p">(</span>fmt<span class="o">-&gt;</span>pixelformat <span class="o">&gt;&gt;</span> <span class="mi">24</span><span class="p">)</span> <span class="o">&amp;</span> <span class="mh">0xff</span><span class="p">);</span>
         red <span class="o">=</span> <span class="mi">0</span><span class="p">;</span>
         <span class="k">for</span> <span class="p">(</span>i <span class="o">=</span> <span class="mi">0</span><span class="p">;</span> i <span class="o">&lt;</span> size<span class="p">;</span> i <span class="o">+=</span> <span class="mi">4</span><span class="p">)</span> <span class="p">{</span>
                 u <span class="o">=</span> p<span class="p">[</span>i<span class="o">+</span><span class="mi">0</span><span class="p">];</span>
                 y1 <span class="o">=</span> p<span class="p">[</span>i<span class="o">+</span><span class="mi">1</span><span class="p">];</span>
                 v <span class="o">=</span> p<span class="p">[</span>i<span class="o">+</span><span class="mi">2</span><span class="p">];</span>
                 y2 <span class="o">=</span> p<span class="p">[</span>i<span class="o">+</span><span class="mi">3</span><span class="p">];</span>
                 u <span class="o">-=</span> <span class="mi">128</span><span class="p">;</span>
                 v <span class="o">-=</span> <span class="mi">128</span><span class="p">;</span>
                 r <span class="o">=</span> y1 <span class="o">+</span> v <span class="o">+</span> <span class="p">(</span>v<span class="o">&gt;&gt;</span><span class="mi">2</span><span class="p">)</span> <span class="o">+</span> <span class="p">(</span>v<span class="o">&gt;&gt;</span><span class="mi">3</span><span class="p">)</span> <span class="o">+</span> <span class="p">(</span>v<span class="o">&gt;&gt;</span><span class="mi">5</span><span class="p">);</span>
                 g <span class="o">=</span> y1 <span class="o">-</span> <span class="p">((</span>u<span class="o">&gt;&gt;</span><span class="mi">2</span><span class="p">)</span> <span class="o">+</span> <span class="p">(</span>u<span class="o">&gt;&gt;</span><span class="mi">4</span><span class="p">)</span> <span class="o">+</span> <span class="p">(</span>u<span class="o">&gt;&gt;</span><span class="mi">5</span><span class="p">))</span>
                        <span class="o">-</span> <span class="p">((</span>v<span class="o">&gt;&gt;</span><span class="mi">1</span><span class="p">)</span> <span class="o">+</span> <span class="p">(</span>v<span class="o">&gt;&gt;</span><span class="mi">3</span><span class="p">)</span> <span class="o">+</span> <span class="p">(</span>v<span class="o">&gt;&gt;</span><span class="mi">4</span><span class="p">)</span> <span class="o">+</span> <span class="p">(</span>v<span class="o">&gt;&gt;</span><span class="mi">5</span><span class="p">));</span>
                 b <span class="o">=</span> y1 <span class="o">+</span> u <span class="o">+</span> <span class="p">(</span>u<span class="o">&gt;&gt;</span><span class="mi">1</span><span class="p">)</span> <span class="o">+</span> <span class="p">(</span>u<span class="o">&gt;&gt;</span><span class="mi">2</span><span class="p">)</span> <span class="o">+</span> <span class="p">(</span>u<span class="o">&gt;&gt;</span><span class="mi">6</span><span class="p">);</span>
                 <span class="k">if</span> <span class="p">(</span>r <span class="o">&gt;</span> <span class="mi">100</span> <span class="o">&amp;&amp;</span> g <span class="o">&lt;</span> <span class="mi">60</span> <span class="o">&amp;&amp;</span> b <span class="o">&lt;</span> <span class="mi">60</span><span class="p">)</span> red<span class="o">++</span><span class="p">;</span>
                 r <span class="o">=</span> y2 <span class="o">+</span> v <span class="o">+</span> <span class="p">(</span>v<span class="o">&gt;&gt;</span><span class="mi">2</span><span class="p">)</span> <span class="o">+</span> <span class="p">(</span>v<span class="o">&gt;&gt;</span><span class="mi">3</span><span class="p">)</span> <span class="o">+</span> <span class="p">(</span>v<span class="o">&gt;&gt;</span><span class="mi">5</span><span class="p">);</span>
                 g <span class="o">=</span> y2 <span class="o">-</span> <span class="p">((</span>u<span class="o">&gt;&gt;</span><span class="mi">2</span><span class="p">)</span> <span class="o">+</span> <span class="p">(</span>u<span class="o">&gt;&gt;</span><span class="mi">4</span><span class="p">)</span> <span class="o">+</span> <span class="p">(</span>u<span class="o">&gt;&gt;</span><span class="mi">5</span><span class="p">))</span>
                        <span class="o">-</span> <span class="p">((</span>v<span class="o">&gt;&gt;</span><span class="mi">1</span><span class="p">)</span> <span class="o">+</span> <span class="p">(</span>v<span class="o">&gt;&gt;</span><span class="mi">3</span><span class="p">)</span> <span class="o">+</span> <span class="p">(</span>v<span class="o">&gt;&gt;</span><span class="mi">4</span><span class="p">)</span> <span class="o">+</span> <span class="p">(</span>v<span class="o">&gt;&gt;</span><span class="mi">5</span><span class="p">));</span>
                 b <span class="o">=</span> y2 <span class="o">+</span> u <span class="o">+</span> <span class="p">(</span>u<span class="o">&gt;&gt;</span><span class="mi">1</span><span class="p">)</span> <span class="o">+</span> <span class="p">(</span>u<span class="o">&gt;&gt;</span><span class="mi">2</span><span class="p">)</span> <span class="o">+</span> <span class="p">(</span>u<span class="o">&gt;&gt;</span><span class="mi">6</span><span class="p">);</span>
                 <span class="k">if</span> <span class="p">(</span>r <span class="o">&gt;</span> <span class="mi">100</span> <span class="o">&amp;&amp;</span> g <span class="o">&lt;</span> <span class="mi">60</span> <span class="o">&amp;&amp;</span> b <span class="o">&lt;</span> <span class="mi">60</span><span class="p">)</span> red<span class="o">++</span><span class="p">;</span>
                 <span class="cm">/* describe pixels on first line every 250 pixels
+ */
+#include <byteswap.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdint.h>
+#include <string.h>
+#include <assert.h>
+#include <fcntl.h>              /* low-level i/o */
+#include <unistd.h>
+#include <errno.h>
+#include <sys/types.h>
+#include <sys/mman.h>
+#include <sys/ioctl.h>
+#include <linux/videodev2.h>
+#define CLEAR(x) memset(&(x), 0, sizeof(x))
+struct buffer {
+        void   *start;
+        size_t  length;
+};
+static void errno_exit(const char *s)
+{
+        fprintf(stderr, "%s error %d, %s\n", s, errno, strerror(errno));
+        exit(EXIT_FAILURE);
+}
+static int xioctl(int fh, int request, void *arg)
+{
+        int r;
+        do {
+                r = ioctl(fh, request, arg);
+        } while (-1 == r && EINTR == errno);
+        return r;
+}
+/* 16bit/pixel interleaved YUV */
+static void process_image(const void *_p, struct v4l2_pix_format *fmt)
+{
+        const uint8_t *p = _p;
+        int8_t u;
+        uint8_t y1;
+        int8_t v;
+        uint8_t y2;
+        int r, g, b, c, d ,e;
+        int red, i, x, y;
+        int size = fmt->sizeimage;
+        printf("Processing Frame: %dx%d %c%c%c%c\n",
+                fmt->width, fmt->height,
+                (fmt->pixelformat >> 0) & 0xff,
+                (fmt->pixelformat >> 8) & 0xff,
+                (fmt->pixelformat >> 16) & 0xff,
+                (fmt->pixelformat >> 24) & 0xff);
+        red = 0;
+        for (i = 0; i < size; i += 4) {
+                u = p[i+0];
+                y1 = p[i+1];
+                v = p[i+2];
+                y2 = p[i+3];
+                u -= 128;
+                v -= 128;
+                r = y1 + v + (v>>2) + (v>>3) + (v>>5);
+                g = y1 - ((u>>2) + (u>>4) + (u>>5))
+                       - ((v>>1) + (v>>3) + (v>>4) + (v>>5));
+                b = y1 + u + (u>>1) + (u>>2) + (u>>6);
+                if (r > 100 && g < 60 && b < 60) red++;
+                r = y2 + v + (v>>2) + (v>>3) + (v>>5);
+                g = y2 - ((u>>2) + (u>>4) + (u>>5))
+                       - ((v>>1) + (v>>3) + (v>>4) + (v>>5));
+                b = y2 + u + (u>>1) + (u>>2) + (u>>6);
+                if (r > 100 && g < 60 && b < 60) red++;
+                /* describe pixels on first line every 250 pixels
                  * (colorbars)
+                 */</span>
+                x <span class="o">=</span> <span class="p">(</span>i<span class="o">&gt;&gt;</span><span class="mi">1</span><span class="p">)</span> <span class="o">%</span> fmt<span class="o">-&gt;</span>width<span class="p">;</span>
+                y <span class="o">=</span> <span class="p">(</span>i<span class="o">&gt;&gt;</span><span class="mi">1</span><span class="p">)</span> <span class="o">/</span> fmt<span class="o">-&gt;</span>height<span class="p">;</span>
+                <span class="k">if</span> <span class="p">(</span>y <span class="o">==</span> <span class="mi">0</span> <span class="o">&amp;&amp;</span> <span class="o">!</span><span class="p">(</span>x <span class="o">%</span> <span class="mi">250</span><span class="p">))</span> <span class="p">{</span>
+                        printf<span class="p">(</span><span class="s">"[%4d,%4d] YUYV:0x%02x%02x%02x%02x "</span><span class="p">,</span>
+                                        x<span class="p">,</span>y<span class="p">,</span>y1<span class="p">,(</span><span class="kt">uint8_t</span><span class="p">)</span>u<span class="p">,</span>y2<span class="p">,(</span><span class="kt">uint8_t</span><span class="p">)</span>v<span class="p">);</span>
+                        printf<span class="p">(</span><span class="s">"RGB:0x%02x%02x%02x</span><span class="se">\n</span><span class="s">"</span><span class="p">,</span> r<span class="p">,</span>g<span class="p">,</span>b<span class="p">);</span>
+                <span class="p">}</span>
+        <span class="p">}</span>
+        printf<span class="p">(</span><span class="s">"red pixel count=%d</span><span class="se">\n</span><span class="s">"</span><span class="p">,</span> red<span class="p">);</span>
+<span class="p">}</span>
+<span class="k">static</span> <span class="kt">void</span> <span class="nf">save_frame</span><span class="p">(</span><span class="k">const</span> <span class="kt">char</span> <span class="o">*</span>path<span class="p">,</span> <span class="k">const</span> <span class="kt">void</span> <span class="o">*</span>p<span class="p">,</span> <span class="kt">int</span> size<span class="p">)</span>
+<span class="p">{</span>
+        <span class="kt">int</span> fd<span class="p">,</span> rz<span class="p">;</span>
+        fd <span class="o">=</span> open<span class="p">(</span>path<span class="p">,</span> O_WRONLY <span class="o">|</span> O_CREAT <span class="o">|</span> O_TRUNC<span class="p">,</span> <span class="mo">0755</span><span class="p">);</span>
+        <span class="k">if</span> <span class="p">(</span>fd <span class="o">&lt;</span> <span class="mi">0</span><span class="p">)</span>
+                perror<span class="p">(</span><span class="s">"open"</span><span class="p">);</span>
+        <span class="k">else</span> <span class="p">{</span>
+                rz <span class="o">=</span> write<span class="p">(</span>fd<span class="p">,</span> p<span class="p">,</span> size<span class="p">);</span>
+                printf<span class="p">(</span><span class="s">"Wrote %d of %d bytes to %s</span><span class="se">\n</span><span class="s">"</span><span class="p">,</span> rz<span class="p">,</span> size<span class="p">,</span> path<span class="p">);</span>
+                close<span class="p">(</span>fd<span class="p">);</span>
+        <span class="p">}</span>
+<span class="p">}</span>
+<span class="kt">int</span> <span class="nf">main</span><span class="p">(</span><span class="kt">int</span> argc<span class="p">,</span> <span class="kt">char</span> <span class="o">**</span>argv<span class="p">)</span>
+<span class="p">{</span>
+        <span class="k">static</span> <span class="kt">char</span> <span class="o">*</span>dev_name<span class="p">;</span>
+        <span class="kt">int</span> width<span class="p">,</span> height<span class="p">;</span>
+        <span class="k">static</span> <span class="kt">int</span> fd <span class="o">=</span> <span class="o">-</span><span class="mi">1</span><span class="p">;</span>
+        <span class="k">struct</span> stat st<span class="p">;</span>
+        <span class="k">struct</span> buffer <span class="o">*</span>buffers<span class="p">;</span>
+        <span class="k">static</span> <span class="kt">unsigned</span> <span class="kt">int</span> n_buffers<span class="p">;</span>
+        <span class="k">enum</span> v4l2_buf_type type<span class="p">;</span>
+        <span class="k">struct</span> v4l2_capability cap<span class="p">;</span>
+        <span class="k">struct</span> v4l2_format fmt<span class="p">;</span>
+        <span class="k">struct</span> v4l2_requestbuffers req<span class="p">;</span>
+        <span class="k">struct</span> v4l2_streamparm parm<span class="p">;</span>
+        <span class="k">struct</span> v4l2_input input<span class="p">;</span>
+        v4l2_std_id std_id<span class="p">;</span>
+        <span class="k">struct</span> v4l2_buffer buf<span class="p">;</span>
+        <span class="kt">unsigned</span> <span class="kt">int</span> count<span class="p">;</span>
+        <span class="kt">unsigned</span> <span class="kt">int</span> i<span class="p">;</span>
+        <span class="kt">char</span> filename<span class="p">[</span><span class="mi">32</span><span class="p">];</span>
+        <span class="cm">/* parse args */</span>
+        <span class="k">if</span> <span class="p">(</span>argc <span class="o">&lt;</span> <span class="mi">5</span><span class="p">)</span> <span class="p">{</span>
+                fprintf<span class="p">(</span>stderr<span class="p">,</span> <span class="s">"usage: %s &lt;device&gt; &lt;width&gt; &lt;height&gt; &lt;count&gt;</span><span class="se">\n</span><span class="s">"</span><span class="p">,</span>
+                        argv<span class="p">[</span><span class="mi">0</span><span class="p">]);</span>
+                exit<span class="p">(</span><span class="mi">1</span><span class="p">);</span>
+        <span class="p">}</span>
+        dev_name <span class="o">=</span> argv<span class="p">[</span><span class="mi">1</span><span class="p">];</span>
+        width <span class="o">=</span> atoi<span class="p">(</span>argv<span class="p">[</span><span class="mi">2</span><span class="p">]);</span>
+        height <span class="o">=</span> atoi<span class="p">(</span>argv<span class="p">[</span><span class="mi">3</span><span class="p">]);</span>
+        count <span class="o">=</span> atoi<span class="p">(</span>argv<span class="p">[</span><span class="mi">4</span><span class="p">]);</span>
+        <span class="cm">/* open device */</span>
+        fd <span class="o">=</span> open<span class="p">(</span>dev_name<span class="p">,</span> O_RDWR <span class="o">|</span> O_NONBLOCK<span class="p">,</span> <span class="mi">0</span><span class="p">);</span>
+        <span class="k">if</span> <span class="p">(</span><span class="o">-</span><span class="mi">1</span> <span class="o">==</span> fd<span class="p">)</span> <span class="p">{</span>
+                fprintf<span class="p">(</span>stderr<span class="p">,</span> <span class="s">"Cannot open '%s': %d, %s</span><span class="se">\n</span><span class="s">"</span><span class="p">,</span>
+                                dev_name<span class="p">,</span> errno<span class="p">,</span> strerror<span class="p">(</span>errno<span class="p">));</span>
+                exit<span class="p">(</span>EXIT_FAILURE<span class="p">);</span>
+        <span class="p">}</span>
+        <span class="cm">/* get standard (wait for it to be locked onto a signal) */</span>
+        <span class="k">if</span> <span class="p">(</span><span class="o">-</span><span class="mi">1</span> <span class="o">==</span> xioctl<span class="p">(</span>fd<span class="p">,</span> VIDIOC_G_STD<span class="p">,</span> <span class="o">&amp;</span>std_id<span class="p">))</span>
+                perror<span class="p">(</span><span class="s">"VIDIOC_G_STD"</span><span class="p">);</span>
+        <span class="k">for</span> <span class="p">(</span>i <span class="o">=</span> <span class="mi">0</span><span class="p">;</span> std_id <span class="o">==</span> V4L2_STD_ALL <span class="o">&amp;&amp;</span> i <span class="o">&lt;</span> <span class="mi">10</span><span class="p">;</span> i<span class="o">++</span><span class="p">)</span> <span class="p">{</span>
+                usleep<span class="p">(</span><span class="mi">100000</span><span class="p">);</span>
+                xioctl<span class="p">(</span>fd<span class="p">,</span> VIDIOC_G_STD<span class="p">,</span> <span class="o">&amp;</span>std_id<span class="p">);</span>
+        <span class="p">}</span>
+        <span class="cm">/* set the standard to the detected standard (this is critical for autodetect) */</span>
+        <span class="k">if</span> <span class="p">(</span>std_id <span class="o">!=</span> V4L2_STD_UNKNOWN<span class="p">)</span> <span class="p">{</span>
+                <span class="k">if</span> <span class="p">(</span><span class="o">-</span><span class="mi">1</span> <span class="o">==</span> xioctl<span class="p">(</span>fd<span class="p">,</span> VIDIOC_S_STD<span class="p">,</span> <span class="o">&amp;</span>std_id<span class="p">))</span>
+                        perror<span class="p">(</span><span class="s">"VIDIOC_S_STD"</span><span class="p">);</span>
+                <span class="k">if</span> <span class="p">(</span>std_id <span class="o">&amp;</span> V4L2_STD_NTSC<span class="p">)</span>
+                        printf<span class="p">(</span><span class="s">"found NTSC TV decoder</span><span class="se">\n</span><span class="s">"</span><span class="p">);</span>
+                <span class="k">if</span> <span class="p">(</span>std_id <span class="o">&amp;</span> V4L2_STD_SECAM<span class="p">)</span>
+                        printf<span class="p">(</span><span class="s">"found SECAM TV decoder</span><span class="se">\n</span><span class="s">"</span><span class="p">);</span>
+                <span class="k">if</span> <span class="p">(</span>std_id <span class="o">&amp;</span> V4L2_STD_PAL<span class="p">)</span>
+                        printf<span class="p">(</span><span class="s">"found PAL TV decoder</span><span class="se">\n</span><span class="s">"</span><span class="p">);</span>
+        <span class="p">}</span>
+        <span class="cm">/* ensure device has video capture capability */</span>
+        <span class="k">if</span> <span class="p">(</span><span class="o">-</span><span class="mi">1</span> <span class="o">==</span> xioctl<span class="p">(</span>fd<span class="p">,</span> VIDIOC_QUERYCAP<span class="p">,</span> <span class="o">&amp;</span>cap<span class="p">))</span> <span class="p">{</span>
+                <span class="k">if</span> <span class="p">(</span>EINVAL <span class="o">==</span> errno<span class="p">)</span> <span class="p">{</span>
+                        fprintf<span class="p">(</span>stderr<span class="p">,</span> <span class="s">"%s is no V4L2 device</span><span class="se">\n</span><span class="s">"</span><span class="p">,</span>
+                                        dev_name<span class="p">);</span>
+                        exit<span class="p">(</span>EXIT_FAILURE<span class="p">);</span>
+                <span class="p">}</span> <span class="k">else</span> <span class="p">{</span>
+                        errno_exit<span class="p">(</span><span class="s">"VIDIOC_QUERYCAP"</span><span class="p">);</span>
+                <span class="p">}</span>
+        <span class="p">}</span>
+        <span class="k">if</span> <span class="p">(</span><span class="o">!</span><span class="p">(</span>cap<span class="p">.</span>capabilities <span class="o">&amp;</span> V4L2_CAP_VIDEO_CAPTURE<span class="p">))</span> <span class="p">{</span>
+                fprintf<span class="p">(</span>stderr<span class="p">,</span> <span class="s">"%s is no video capture device</span><span class="se">\n</span><span class="s">"</span><span class="p">,</span>
+                                dev_name<span class="p">);</span>
+                exit<span class="p">(</span>EXIT_FAILURE<span class="p">);</span>
+        <span class="p">}</span>
+        <span class="k">if</span> <span class="p">(</span><span class="o">!</span><span class="p">(</span>cap<span class="p">.</span>capabilities <span class="o">&amp;</span> V4L2_CAP_STREAMING<span class="p">))</span> <span class="p">{</span>
+                fprintf<span class="p">(</span>stderr<span class="p">,</span> <span class="s">"%s does not support streaming i/o</span><span class="se">\n</span><span class="s">"</span><span class="p">,</span>
+                                dev_name<span class="p">);</span>
+                exit<span class="p">(</span>EXIT_FAILURE<span class="p">);</span>
+        <span class="p">}</span>
+        <span class="cm">/* set video input */</span>
+        CLEAR<span class="p">(</span>input<span class="p">);</span>
+        input<span class="p">.</span>index <span class="o">=</span> <span class="mi">1</span><span class="p">;</span> <span class="cm">/* IMX6 v4l2 driver: input1 is CSI&lt;-&gt;MEM */</span>
+        <span class="k">if</span> <span class="p">(</span><span class="o">-</span><span class="mi">1</span> <span class="o">==</span> xioctl<span class="p">(</span>fd<span class="p">,</span> VIDIOC_S_INPUT<span class="p">,</span> <span class="o">&amp;</span>input<span class="p">))</span>
+                perror<span class="p">(</span><span class="s">"VIDIOC_S_INPUT"</span><span class="p">);</span>
+        <span class="cm">/* set framerate */</span>
+        CLEAR<span class="p">(</span>parm<span class="p">);</span>
+        parm<span class="p">.</span>type <span class="o">=</span> V4L2_BUF_TYPE_VIDEO_CAPTURE<span class="p">;</span>
+        <span class="k">if</span> <span class="p">(</span><span class="o">-</span><span class="mi">1</span> <span class="o">==</span> xioctl<span class="p">(</span>fd<span class="p">,</span> VIDIOC_S_PARM<span class="p">,</span> <span class="o">&amp;</span>parm<span class="p">))</span>
+                perror<span class="p">(</span><span class="s">"VIDIOC_S_PARM"</span><span class="p">);</span>
+        <span class="cm">/* get framerate */</span>
+        CLEAR<span class="p">(</span>parm<span class="p">);</span>
+        parm<span class="p">.</span>type <span class="o">=</span> V4L2_BUF_TYPE_VIDEO_CAPTURE<span class="p">;</span>
+        <span class="k">if</span> <span class="p">(</span><span class="o">-</span><span class="mi">1</span> <span class="o">==</span> xioctl<span class="p">(</span>fd<span class="p">,</span> VIDIOC_G_PARM<span class="p">,</span> <span class="o">&amp;</span>parm<span class="p">))</span>
+                perror<span class="p">(</span><span class="s">"VIDIOC_G_PARM"</span><span class="p">);</span>
+        <span class="cm">/* set format */</span>
+        CLEAR<span class="p">(</span>fmt<span class="p">);</span>
+        fmt<span class="p">.</span>type <span class="o">=</span> V4L2_BUF_TYPE_VIDEO_CAPTURE<span class="p">;</span>
+        fmt<span class="p">.</span>fmt<span class="p">.</span>pix<span class="p">.</span>width       <span class="o">=</span> width<span class="p">;</span>
+        fmt<span class="p">.</span>fmt<span class="p">.</span>pix<span class="p">.</span>height      <span class="o">=</span> height<span class="p">;</span>
+        fmt<span class="p">.</span>fmt<span class="p">.</span>pix<span class="p">.</span>pixelformat <span class="o">=</span> V4L2_PIX_FMT_UYVY<span class="p">;</span>
+        fmt<span class="p">.</span>fmt<span class="p">.</span>pix<span class="p">.</span>field       <span class="o">=</span> V4L2_FIELD_ANY<span class="p">;</span>
+        <span class="k">if</span> <span class="p">(</span><span class="o">-</span><span class="mi">1</span> <span class="o">==</span> xioctl<span class="p">(</span>fd<span class="p">,</span> VIDIOC_S_FMT<span class="p">,</span> <span class="o">&amp;</span>fmt<span class="p">))</span>
+                errno_exit<span class="p">(</span><span class="s">"VIDIOC_S_FMT"</span><span class="p">);</span>
+        <span class="cm">/* get and display format */</span>
+        CLEAR<span class="p">(</span>fmt<span class="p">);</span>
+        fmt<span class="p">.</span>type <span class="o">=</span> V4L2_BUF_TYPE_VIDEO_CAPTURE<span class="p">;</span>
+        <span class="k">if</span> <span class="p">(</span><span class="o">-</span><span class="mi">1</span> <span class="o">==</span> xioctl<span class="p">(</span>fd<span class="p">,</span> VIDIOC_G_FMT<span class="p">,</span> <span class="o">&amp;</span>fmt<span class="p">))</span>
+                errno_exit<span class="p">(</span><span class="s">"VIDIOC_G_FMT"</span><span class="p">);</span>
+        printf<span class="p">(</span><span class="s">"%s: %dx%d %c%c%c%c %2.2ffps</span><span class="se">\n</span><span class="s">"</span><span class="p">,</span> dev_name<span class="p">,</span>
+                fmt<span class="p">.</span>fmt<span class="p">.</span>pix<span class="p">.</span>width<span class="p">,</span> fmt<span class="p">.</span>fmt<span class="p">.</span>pix<span class="p">.</span>height<span class="p">,</span>
+                <span class="p">(</span>fmt<span class="p">.</span>fmt<span class="p">.</span>pix<span class="p">.</span>pixelformat <span class="o">&gt;&gt;</span> <span class="mi">0</span><span class="p">)</span> <span class="o">&amp;</span> <span class="mh">0xff</span><span class="p">,</span>
+                <span class="p">(</span>fmt<span class="p">.</span>fmt<span class="p">.</span>pix<span class="p">.</span>pixelformat <span class="o">&gt;&gt;</span> <span class="mi">8</span><span class="p">)</span> <span class="o">&amp;</span> <span class="mh">0xff</span><span class="p">,</span>
+                <span class="p">(</span>fmt<span class="p">.</span>fmt<span class="p">.</span>pix<span class="p">.</span>pixelformat <span class="o">&gt;&gt;</span> <span class="mi">16</span><span class="p">)</span> <span class="o">&amp;</span> <span class="mh">0xff</span><span class="p">,</span>
+                <span class="p">(</span>fmt<span class="p">.</span>fmt<span class="p">.</span>pix<span class="p">.</span>pixelformat <span class="o">&gt;&gt;</span> <span class="mi">24</span><span class="p">)</span> <span class="o">&amp;</span> <span class="mh">0xff</span><span class="p">,</span>
+                <span class="p">(</span><span class="kt">float</span><span class="p">)</span>parm<span class="p">.</span>parm<span class="p">.</span>capture<span class="p">.</span>timeperframe<span class="p">.</span>denominator <span class="o">/</span>
+                <span class="p">(</span><span class="kt">float</span><span class="p">)</span>parm<span class="p">.</span>parm<span class="p">.</span>capture<span class="p">.</span>timeperframe<span class="p">.</span>numerator
+                <span class="p">);</span>
+        <span class="cm">/* request buffers */</span>
+        CLEAR<span class="p">(</span>req<span class="p">);</span>
+        req<span class="p">.</span>count <span class="o">=</span> <span class="mi">4</span><span class="p">;</span>
+        req<span class="p">.</span>type <span class="o">=</span> V4L2_BUF_TYPE_VIDEO_CAPTURE<span class="p">;</span>
+        req<span class="p">.</span>memory <span class="o">=</span> V4L2_MEMORY_MMAP<span class="p">;</span>
+        <span class="k">if</span> <span class="p">(</span><span class="o">-</span><span class="mi">1</span> <span class="o">==</span> xioctl<span class="p">(</span>fd<span class="p">,</span> VIDIOC_REQBUFS<span class="p">,</span> <span class="o">&amp;</span>req<span class="p">))</span> <span class="p">{</span>
+                <span class="k">if</span> <span class="p">(</span>EINVAL <span class="o">==</span> errno<span class="p">)</span> <span class="p">{</span>
+                        fprintf<span class="p">(</span>stderr<span class="p">,</span> <span class="s">"%s does not support "</span>
+                                 <span class="s">"memory mapping</span><span class="se">\n</span><span class="s">"</span><span class="p">,</span> dev_name<span class="p">);</span>
+                        exit<span class="p">(</span>EXIT_FAILURE<span class="p">);</span>
+                <span class="p">}</span> <span class="k">else</span> <span class="p">{</span>
+                        errno_exit<span class="p">(</span><span class="s">"VIDIOC_REQBUFS"</span><span class="p">);</span>
+                <span class="p">}</span>
+        <span class="p">}</span>
+        <span class="k">if</span> <span class="p">(</span>req<span class="p">.</span>count <span class="o">&lt;</span> <span class="mi">2</span><span class="p">)</span> <span class="p">{</span>
+                fprintf<span class="p">(</span>stderr<span class="p">,</span> <span class="s">"Insufficient buffer memory on %s</span><span class="se">\n</span><span class="s">"</span><span class="p">,</span>
+                         dev_name<span class="p">);</span>
+                exit<span class="p">(</span>EXIT_FAILURE<span class="p">);</span>
+        <span class="p">}</span>
+        <span class="cm">/* allocate buffers */</span>
+        buffers <span class="o">=</span> calloc<span class="p">(</span>req<span class="p">.</span>count<span class="p">,</span> <span class="k">sizeof</span><span class="p">(</span><span class="o">*</span>buffers<span class="p">));</span>
+        <span class="k">if</span> <span class="p">(</span><span class="o">!</span>buffers<span class="p">)</span> <span class="p">{</span>
+                fprintf<span class="p">(</span>stderr<span class="p">,</span> <span class="s">"Out of memory</span><span class="se">\n</span><span class="s">"</span><span class="p">);</span>
+                exit<span class="p">(</span>EXIT_FAILURE<span class="p">);</span>
+        <span class="p">}</span>
+        <span class="cm">/* mmap buffers */</span>
+        <span class="k">for</span> <span class="p">(</span>n_buffers <span class="o">=</span> <span class="mi">0</span><span class="p">;</span> n_buffers <span class="o">&lt;</span> req<span class="p">.</span>count<span class="p">;</span> <span class="o">++</span>n_buffers<span class="p">)</span> <span class="p">{</span>
+                <span class="k">struct</span> v4l2_buffer buf<span class="p">;</span>
+                CLEAR<span class="p">(</span>buf<span class="p">);</span>
+                buf<span class="p">.</span>type        <span class="o">=</span> V4L2_BUF_TYPE_VIDEO_CAPTURE<span class="p">;</span>
+                buf<span class="p">.</span>memory      <span class="o">=</span> V4L2_MEMORY_MMAP<span class="p">;</span>
+                buf<span class="p">.</span>index       <span class="o">=</span> n_buffers<span class="p">;</span>
+                <span class="k">if</span> <span class="p">(</span><span class="o">-</span><span class="mi">1</span> <span class="o">==</span> xioctl<span class="p">(</span>fd<span class="p">,</span> VIDIOC_QUERYBUF<span class="p">,</span> <span class="o">&amp;</span>buf<span class="p">))</span>
+                        errno_exit<span class="p">(</span><span class="s">"VIDIOC_QUERYBUF"</span><span class="p">);</span>
+                buffers<span class="p">[</span>n_buffers<span class="p">].</span>length <span class="o">=</span> buf<span class="p">.</span>length<span class="p">;</span>
+                buffers<span class="p">[</span>n_buffers<span class="p">].</span>start <span class="o">=</span>
+                        mmap<span class="p">(</span><span class="nb">NULL</span> <span class="cm">/* start anywhere */</span><span class="p">,</span>
+                              buf<span class="p">.</span>length<span class="p">,</span>
+                              PROT_READ <span class="o">|</span> PROT_WRITE <span class="cm">/* required */</span><span class="p">,</span>
+                              MAP_SHARED <span class="cm">/* recommended */</span><span class="p">,</span>
+                              fd<span class="p">,</span> buf<span class="p">.</span>m<span class="p">.</span>offset<span class="p">);</span>
+                <span class="k">if</span> <span class="p">(</span>MAP_FAILED <span class="o">==</span> buffers<span class="p">[</span>n_buffers<span class="p">].</span>start<span class="p">)</span>
+                        errno_exit<span class="p">(</span><span class="s">"mmap"</span><span class="p">);</span>
+        <span class="p">}</span>
+        <span class="cm">/* queue buffers */</span>
+        <span class="k">for</span> <span class="p">(</span>i <span class="o">=</span> <span class="mi">0</span><span class="p">;</span> i <span class="o">&lt;</span> n_buffers<span class="p">;</span> <span class="o">++</span>i<span class="p">)</span> <span class="p">{</span>
+                <span class="k">struct</span> v4l2_buffer buf<span class="p">;</span>
+                CLEAR<span class="p">(</span>buf<span class="p">);</span>
+                buf<span class="p">.</span>type <span class="o">=</span> V4L2_BUF_TYPE_VIDEO_CAPTURE<span class="p">;</span>
+                buf<span class="p">.</span>memory <span class="o">=</span> V4L2_MEMORY_MMAP<span class="p">;</span>
+                buf<span class="p">.</span>index <span class="o">=</span> i<span class="p">;</span>
+                <span class="k">if</span> <span class="p">(</span><span class="o">-</span><span class="mi">1</span> <span class="o">==</span> xioctl<span class="p">(</span>fd<span class="p">,</span> VIDIOC_QBUF<span class="p">,</span> <span class="o">&amp;</span>buf<span class="p">))</span>
+                        errno_exit<span class="p">(</span><span class="s">"VIDIOC_QBUF"</span><span class="p">);</span>
+        <span class="p">}</span>
+        <span class="cm">/* start capture */</span>
+        type <span class="o">=</span> V4L2_BUF_TYPE_VIDEO_CAPTURE<span class="p">;</span>
+        <span class="k">if</span> <span class="p">(</span><span class="o">-</span><span class="mi">1</span> <span class="o">==</span> xioctl<span class="p">(</span>fd<span class="p">,</span> VIDIOC_STREAMON<span class="p">,</span> <span class="o">&amp;</span>type<span class="p">))</span>
+                errno_exit<span class="p">(</span><span class="s">"VIDIOC_STREAMON"</span><span class="p">);</span>
+        <span class="cm">/* capture frame(s) (we throw away first incomplete frame ) */</span>
+        <span class="k">for</span> <span class="p">(</span>i <span class="o">=</span> <span class="mi">0</span><span class="p">;</span> i <span class="o">&lt;</span> count <span class="o">+</span> <span class="mi">1</span><span class="p">;</span> i<span class="o">++</span><span class="p">)</span> <span class="p">{</span>
+                <span class="k">for</span> <span class="p">(;;)</span> <span class="p">{</span>
+                        fd_set fds<span class="p">;</span>
+                        <span class="k">struct</span> timeval tv<span class="p">;</span>
+                        <span class="kt">int</span> r<span class="p">;</span>
+                        FD_ZERO<span class="p">(</span><span class="o">&amp;</span>fds<span class="p">);</span>
+                        FD_SET<span class="p">(</span>fd<span class="p">,</span> <span class="o">&amp;</span>fds<span class="p">);</span>
+                        <span class="cm">/* Timeout. */</span>
+                        tv<span class="p">.</span>tv_sec <span class="o">=</span> <span class="mi">2</span><span class="p">;</span>
+                        tv<span class="p">.</span>tv_usec <span class="o">=</span> <span class="mi">0</span><span class="p">;</span>
+                        r <span class="o">=</span> select<span class="p">(</span>fd <span class="o">+</span> <span class="mi">1</span><span class="p">,</span> <span class="o">&amp;</span>fds<span class="p">,</span> <span class="nb">NULL</span><span class="p">,</span> <span class="nb">NULL</span><span class="p">,</span> <span class="o">&amp;</span>tv<span class="p">);</span>
+                        <span class="k">if</span> <span class="p">(</span><span class="o">-</span><span class="mi">1</span> <span class="o">==</span> r<span class="p">)</span> <span class="p">{</span>
+                                <span class="k">if</span> <span class="p">(</span>EINTR <span class="o">==</span> errno<span class="p">)</span>
+                                        <span class="k">continue</span><span class="p">;</span>
+                                errno_exit<span class="p">(</span><span class="s">"select"</span><span class="p">);</span>
+                        <span class="p">}</span>
+                        <span class="k">if</span> <span class="p">(</span><span class="mi">0</span> <span class="o">==</span> r<span class="p">)</span> <span class="p">{</span>
+                                fprintf<span class="p">(</span>stderr<span class="p">,</span> <span class="s">"select timeout</span><span class="se">\n</span><span class="s">"</span><span class="p">);</span>
+                                exit<span class="p">(</span>EXIT_FAILURE<span class="p">);</span>
+                        <span class="p">}</span>
+                        <span class="cm">/* dequeue captured buffer */</span>
+                        CLEAR<span class="p">(</span>buf<span class="p">);</span>
+                        buf<span class="p">.</span>type <span class="o">=</span> V4L2_BUF_TYPE_VIDEO_CAPTURE<span class="p">;</span>
+                        buf<span class="p">.</span>memory <span class="o">=</span> V4L2_MEMORY_MMAP<span class="p">;</span>
+                        <span class="k">if</span> <span class="p">(</span><span class="o">-</span><span class="mi">1</span> <span class="o">==</span> xioctl<span class="p">(</span>fd<span class="p">,</span> VIDIOC_DQBUF<span class="p">,</span> <span class="o">&amp;</span>buf<span class="p">))</span> <span class="p">{</span>
+                                <span class="k">if</span> <span class="p">(</span>errno <span class="o">==</span> EAGAIN<span class="p">)</span>
+                                        <span class="k">continue</span><span class="p">;</span>
+                                errno_exit<span class="p">(</span><span class="s">"VIDIOC_DQBUF"</span><span class="p">);</span>
+                        <span class="p">}</span>
+                        assert<span class="p">(</span>buf<span class="p">.</span>index <span class="o">&lt;</span> n_buffers<span class="p">);</span>
+                        <span class="cm">/* skip first image as it may not be sync'd */</span>
+                        <span class="k">if</span> <span class="p">(</span>i <span class="o">&gt;</span> <span class="mi">0</span><span class="p">)</span> <span class="p">{</span>
+                                process_image<span class="p">(</span>buffers<span class="p">[</span>buf<span class="p">.</span>index<span class="p">].</span>start<span class="p">,</span>
+                                        <span class="o">&amp;</span>fmt<span class="p">.</span>fmt<span class="p">.</span>pix<span class="p">);</span>
+                                sprintf<span class="p">(</span>filename<span class="p">,</span> <span class="s">"frame%d.raw"</span><span class="p">,</span> i<span class="p">);</span>
+                                save_frame<span class="p">(</span>filename<span class="p">,</span>
+                                        buffers<span class="p">[</span>buf<span class="p">.</span>index<span class="p">].</span>start<span class="p">,</span>
+                                        buf<span class="p">.</span>bytesused<span class="p">);</span>
+                        <span class="p">}</span>
+                        <span class="cm">/* queue buffer */</span>
+                        <span class="k">if</span> <span class="p">(</span><span class="o">-</span><span class="mi">1</span> <span class="o">==</span> xioctl<span class="p">(</span>fd<span class="p">,</span> VIDIOC_QBUF<span class="p">,</span> <span class="o">&amp;</span>buf<span class="p">))</span>
+                                errno_exit<span class="p">(</span><span class="s">"VIDIOC_QBUF"</span><span class="p">);</span>
+                        <span class="k">break</span><span class="p">;</span>
+                <span class="p">}</span>
+        <span class="p">}</span>
+        <span class="cm">/* stop capture */</span>
+        type <span class="o">=</span> V4L2_BUF_TYPE_VIDEO_CAPTURE<span class="p">;</span>
+        <span class="k">if</span> <span class="p">(</span><span class="o">-</span><span class="mi">1</span> <span class="o">==</span> xioctl<span class="p">(</span>fd<span class="p">,</span> VIDIOC_STREAMOFF<span class="p">,</span> <span class="o">&amp;</span>type<span class="p">))</span>
+                errno_exit<span class="p">(</span><span class="s">"VIDIOC_STREAMOFF"</span><span class="p">);</span>
+        <span class="cm">/* unmap and free buffers */</span>
+        <span class="k">for</span> <span class="p">(</span>i <span class="o">=</span> <span class="mi">0</span><span class="p">;</span> i <span class="o">&lt;</span> n_buffers<span class="p">;</span> <span class="o">++</span>i<span class="p">)</span>
+                <span class="k">if</span> <span class="p">(</span><span class="o">-</span><span class="mi">1</span> <span class="o">==</span> munmap<span class="p">(</span>buffers<span class="p">[</span>i<span class="p">].</span>start<span class="p">,</span> buffers<span class="p">[</span>i<span class="p">].</span>length<span class="p">))</span>
+                        errno_exit<span class="p">(</span><span class="s">"munmap"</span><span class="p">);</span>
+        free<span class="p">(</span>buffers<span class="p">);</span>
+        <span class="cm">/* close device */</span>
+        <span class="k">if</span> <span class="p">(</span><span class="o">-</span><span class="mi">1</span> <span class="o">==</span> close<span class="p">(</span>fd<span class="p">))</span>
+                errno_exit<span class="p">(</span><span class="s">"close"</span><span class="p">);</span>
+        fprintf<span class="p">(</span>stderr<span class="p">,</span> <span class="s">"</span><span class="se">\n</span><span class="s">"</span><span class="p">);</span>
+        <span class="k">return</span> <span class="mi">0</span><span class="p">;</span>
+<span class="p">}</span>
+</pre></div></li></ul><p>
+                 */
+                x = (i>>1) % fmt->width;
+                y = (i>>1) / fmt->height;
+                if (y == 0 && !(x % 250)) {
+                        printf("[%4d,%4d] YUYV:0x%02x%02x%02x%02x ",
+                                        x,y,y1,(uint8_t)u,y2,(uint8_t)v);
+                        printf("RGB:0x%02x%02x%02x\n", r,g,b);
+                }
+        }
+        printf("red pixel count=%d\n", red);
+}
+static void save_frame(const char *path, const void *p, int size)
+{
+        int fd, rz;
+        fd = open(path, O_WRONLY | O_CREAT | O_TRUNC, 0755);
+        if (fd < 0)
+                perror("open");
+        else {
+                rz = write(fd, p, size);
+                printf("Wrote %d of %d bytes to %s\n", rz, size, path);
+                close(fd);
+        }
+}
+int main(int argc, char **argv)
+{
+        static char *dev_name;
+        int width, height;
+        static int fd = -1;
+        struct stat st;
+        struct buffer *buffers;
+        static unsigned int n_buffers;
+        enum v4l2_buf_type type;
+        struct v4l2_capability cap;
+        struct v4l2_format fmt;
+        struct v4l2_requestbuffers req;
+        struct v4l2_streamparm parm;
+        struct v4l2_input input;
+        v4l2_std_id std_id;
+        struct v4l2_buffer buf;
+        unsigned int count;
+        unsigned int i;
+        char filename[32];
+        /* parse args */
+        if (argc < 5) {
+                fprintf(stderr, "usage: %s <device> <width> <height> <count>\n",
+                        argv[0]);
+                exit(1);
+        }
+        dev_name = argv[1];
+        width = atoi(argv[2]);
+        height = atoi(argv[3]);
+        count = atoi(argv[4]);
+        /* open device */
+        fd = open(dev_name, O_RDWR | O_NONBLOCK, 0);
+        if (-1 == fd) {
+                fprintf(stderr, "Cannot open '%s': %d, %s\n",
+                                dev_name, errno, strerror(errno));
+                exit(EXIT_FAILURE);
+        }
+        /* get standard (wait for it to be locked onto a signal) */
+        if (-1 == xioctl(fd, VIDIOC_G_STD, &std_id))
+                perror("VIDIOC_G_STD");
+        for (i = 0; std_id == V4L2_STD_ALL && i < 10; i++) {
+                usleep(100000);
+                xioctl(fd, VIDIOC_G_STD, &std_id);
+        }
+        /* set the standard to the detected standard (this is critical for autodetect) */
+        if (std_id != V4L2_STD_UNKNOWN) {
+                if (-1 == xioctl(fd, VIDIOC_S_STD, &std_id))
+                        perror("VIDIOC_S_STD");
+                if (std_id & V4L2_STD_NTSC)
+                        printf("found NTSC TV decoder\n");
+                if (std_id & V4L2_STD_SECAM)
+                        printf("found SECAM TV decoder\n");
+                if (std_id & V4L2_STD_PAL)
+                        printf("found PAL TV decoder\n");
+        }
+        /* ensure device has video capture capability */
+        if (-1 == xioctl(fd, VIDIOC_QUERYCAP, &cap)) {
+                if (EINVAL == errno) {
+                        fprintf(stderr, "%s is no V4L2 device\n",
+                                        dev_name);
+                        exit(EXIT_FAILURE);
+                } else {
+                        errno_exit("VIDIOC_QUERYCAP");
+                }
+        }
+        if (!(cap.capabilities & V4L2_CAP_VIDEO_CAPTURE)) {
+                fprintf(stderr, "%s is no video capture device\n",
+                                dev_name);
+                exit(EXIT_FAILURE);
+        }
+        if (!(cap.capabilities & V4L2_CAP_STREAMING)) {
+                fprintf(stderr, "%s does not support streaming i/o\n",
+                                dev_name);
+                exit(EXIT_FAILURE);
+        }
+        /* set video input */
+        CLEAR(input);
+        input.index = 1; /* IMX6 v4l2 driver: input1 is CSI<->MEM */
+        if (-1 == xioctl(fd, VIDIOC_S_INPUT, &input))
+                perror("VIDIOC_S_INPUT");
+        /* set framerate */
+        CLEAR(parm);
+        parm.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
+        if (-1 == xioctl(fd, VIDIOC_S_PARM, &parm))
+                perror("VIDIOC_S_PARM");
+        /* get framerate */
+        CLEAR(parm);
+        parm.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
+        if (-1 == xioctl(fd, VIDIOC_G_PARM, &parm))
+                perror("VIDIOC_G_PARM");
+        /* set format */
+        CLEAR(fmt);
+        fmt.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
+        fmt.fmt.pix.width       = width;
+        fmt.fmt.pix.height      = height;
+        fmt.fmt.pix.pixelformat = V4L2_PIX_FMT_UYVY;
+        fmt.fmt.pix.field       = V4L2_FIELD_ANY;
+        if (-1 == xioctl(fd, VIDIOC_S_FMT, &fmt))
+                errno_exit("VIDIOC_S_FMT");
+        /* get and display format */
+        CLEAR(fmt);
+        fmt.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
+        if (-1 == xioctl(fd, VIDIOC_G_FMT, &fmt))
+                errno_exit("VIDIOC_G_FMT");
+        printf("%s: %dx%d %c%c%c%c %2.2ffps\n", dev_name,
+                fmt.fmt.pix.width, fmt.fmt.pix.height,
+                (fmt.fmt.pix.pixelformat >> 0) & 0xff,
+                (fmt.fmt.pix.pixelformat >> 8) & 0xff,
+                (fmt.fmt.pix.pixelformat >> 16) & 0xff,
+                (fmt.fmt.pix.pixelformat >> 24) & 0xff,
+                (float)parm.parm.capture.timeperframe.denominator /
+                (float)parm.parm.capture.timeperframe.numerator
+                );
+        /* request buffers */
+        CLEAR(req);
+        req.count = 4;
+        req.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
+        req.memory = V4L2_MEMORY_MMAP;
+        if (-1 == xioctl(fd, VIDIOC_REQBUFS, &req)) {
+                if (EINVAL == errno) {
+                        fprintf(stderr, "%s does not support "
+                                 "memory mapping\n", dev_name);
+                        exit(EXIT_FAILURE);
+                } else {
+                        errno_exit("VIDIOC_REQBUFS");
+                }
+        }
+        if (req.count < 2) {
+                fprintf(stderr, "Insufficient buffer memory on %s\n",
+                         dev_name);
+                exit(EXIT_FAILURE);
+        }
+        /* allocate buffers */
+        buffers = calloc(req.count, sizeof(*buffers));
+        if (!buffers) {
+                fprintf(stderr, "Out of memory\n");
+                exit(EXIT_FAILURE);
+        }
+        /* mmap buffers */
+        for (n_buffers = 0; n_buffers < req.count; ++n_buffers) {
+                struct v4l2_buffer buf;
+                CLEAR(buf);
+                buf.type        = V4L2_BUF_TYPE_VIDEO_CAPTURE;
+                buf.memory      = V4L2_MEMORY_MMAP;
+                buf.index       = n_buffers;
+                if (-1 == xioctl(fd, VIDIOC_QUERYBUF, &buf))
+                        errno_exit("VIDIOC_QUERYBUF");
+                buffers[n_buffers].length = buf.length;
+                buffers[n_buffers].start =
+                        mmap(NULL /* start anywhere */,
+                              buf.length,
+                              PROT_READ | PROT_WRITE /* required */,
+                              MAP_SHARED /* recommended */,
+                              fd, buf.m.offset);
+                if (MAP_FAILED == buffers[n_buffers].start)
+                        errno_exit("mmap");
+        }
+        /* queue buffers */
+        for (i = 0; i < n_buffers; ++i) {
+                struct v4l2_buffer buf;
+                CLEAR(buf);
+                buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
+                buf.memory = V4L2_MEMORY_MMAP;
+                buf.index = i;
+                if (-1 == xioctl(fd, VIDIOC_QBUF, &buf))
+                        errno_exit("VIDIOC_QBUF");
+        }
+        /* start capture */
+        type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
+        if (-1 == xioctl(fd, VIDIOC_STREAMON, &type))
+                errno_exit("VIDIOC_STREAMON");
+        /* capture frame(s) (we throw away first incomplete frame ) */
+        for (i = 0; i < count + 1; i++) {
+                for (;;) {
+                        fd_set fds;
+                        struct timeval tv;
+                        int r;
+                        FD_ZERO(&fds);
+                        FD_SET(fd, &fds);
+                        /* Timeout. */
+                        tv.tv_sec = 2;
+                        tv.tv_usec = 0;
+                        r = select(fd + 1, &fds, NULL, NULL, &tv);
+                        if (-1 == r) {
+                                if (EINTR == errno)
+                                        continue;
+                                errno_exit("select");
+                        }
+                        if (0 == r) {
+                                fprintf(stderr, "select timeout\n");
+                                exit(EXIT_FAILURE);
+                        }
+                        /* dequeue captured buffer */
+                        CLEAR(buf);
+                        buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
+                        buf.memory = V4L2_MEMORY_MMAP;
+                        if (-1 == xioctl(fd, VIDIOC_DQBUF, &buf)) {
+                                if (errno == EAGAIN)
+                                        continue;
+                                errno_exit("VIDIOC_DQBUF");
+                        }
+                        assert(buf.index < n_buffers);
+                        /* skip first image as it may not be sync'd */
+                        if (i > 0) {
+                                process_image(buffers[buf.index].start,
+                                        &fmt.fmt.pix);
+                                sprintf(filename, "frame%d.raw", i);
+                                save_frame(filename,
+                                        buffers[buf.index].start,
+                                        buf.bytesused);
+                        }
+                        /* queue buffer */
+                        if (-1 == xioctl(fd, VIDIOC_QBUF, &buf))
+                                errno_exit("VIDIOC_QBUF");
+                        break;
+                }
+        }
+        /* stop capture */
+        type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
+        if (-1 == xioctl(fd, VIDIOC_STREAMOFF, &type))
+                errno_exit("VIDIOC_STREAMOFF");
+        /* unmap and free buffers */
+        for (i = 0; i < n_buffers; ++i)
+                if (-1 == munmap(buffers[i].start, buffers[i].length))
+                        errno_exit("munmap");
+        free(buffers);
+        /* close device */
+        if (-1 == close(fd))
+                errno_exit("close");
+        fprintf(stderr, "\n");
+        return 0;
+}
+}}}
 Example usage:
+</p>
+<ul><li>Capture HDMI input on GW5400 from a 1080P HDMI source:
 <div class="code"><pre><span class="nv">$ </span>./capture /dev/video0 1920 1080 1
+ * Capture HDMI input on GW5400 from a 1080P HDMI source:
+{{{#!bash
+$ ./capture /dev/video0 1920 1080 1
 /dev/video0: 1920x1080 UYVY 60.00fps
 Processing Frame: 1920x1080 UYVY
 <span class="o">[</span>   0,   0<span class="o">]</span> YUYV:0xeb00eb00 RGB:0xebebeb
 <span class="o">[</span> 250,   0<span class="o">]</span> YUYV:0x9dad9d0d RGB:0xaeb409
 <span class="o">[</span> 500,   0<span class="o">]</span> YUYV:0x801b80ae RGB:0x0bb6ae
 <span class="o">[</span> 750,   0<span class="o">]</span> YUYV:0x6dc96dbb RGB:0x0ab50b
 <span class="o">[</span>1000,   0<span class="o">]</span> YUYV:0x52365244 RGB:0xb111b0
 red pixel <span class="nv">count</span><span class="o">=</span>259200
+[   0,   0] YUYV:0xeb00eb00 RGB:0xebebeb
+[ 250,   0] YUYV:0x9dad9d0d RGB:0xaeb409
+[ 500,   0] YUYV:0x801b80ae RGB:0x0bb6ae
+[ 750,   0] YUYV:0x6dc96dbb RGB:0x0ab50b
+[1000,   0] YUYV:0x52365244 RGB:0xb111b0
+red pixel count=259200
 Wrote 4147200 of 4147200 bytes to frame.raw
+./convert -size 1920x1080 -depth 16 uyvy:frame.raw frame.png <span class="c"># convert to png via imagemagick
+</span></pre></div></li><li>Capture CVBS input on GW5400 from NTSC camera (720x480):
+<div class="code"><pre><span class="nv">$ </span>./capture /dev/video1 720 480 1
+./convert -size 1920x1080 -depth 16 uyvy:frame.raw frame.png # convert to png via imagemagick
+}}}
+ * Capture CVBS input on GW5400 from NTSC camera (720x480):
+{{{#!bash
+$ ./capture /dev/video1 720 480 1
 /dev/video1: 720x520 UYVY 30.00fps
 Processing Frame: 720x520 UYVY
 <span class="o">[</span>   0,   0<span class="o">]</span> YUYV:0x1eff1c00 RGB:0x1c1f18
 <span class="o">[</span> 250,   0<span class="o">]</span> YUYV:0x1dfd1d01 RGB:0x1e2016
 <span class="o">[</span> 500,   0<span class="o">]</span> YUYV:0x28fa2aff RGB:0x26321e
 red pixel <span class="nv">count</span><span class="o">=</span>27
+[   0,   0] YUYV:0x1eff1c00 RGB:0x1c1f18
+[ 250,   0] YUYV:0x1dfd1d01 RGB:0x1e2016
+[ 500,   0] YUYV:0x28fa2aff RGB:0x26321e
+red pixel count=27
 Wrote 748800 of 748800 bytes to frame.raw
+./convert -size 720x480 -depth 16 uyvy:frame.raw frame.png <span class="c"># convert to png via imagemagick
+</span></pre></div></li></ul
+}}}
+./convert -size 720x480 -depth 16 uyvy:frame.raw frame.png # convert to png via imagemagick
+}}}