├── .idea
    ├── libv4l2cxx.iml
    ├── misc.xml
    ├── vcs.xml
    ├── preferred-vcs.xml
    ├── modules.xml
    └── codeStyles
    │   └── Project.xml
├── CMakeLists.txt
├── examples
    ├── example1.cpp
    └── main.cpp
├── LICENSE
├── README.md
└── src
    ├── v4l2cxx.h
    └── util_v4l2.h


/.idea/libv4l2cxx.iml:
--------------------------------------------------------------------------------
1 | <?xml version="1.0" encoding="UTF-8"?>
2 | <module classpath="CMake" type="CPP_MODULE" version="4" />


--------------------------------------------------------------------------------
/.idea/misc.xml:
--------------------------------------------------------------------------------
1 | <?xml version="1.0" encoding="UTF-8"?>
2 | <project version="4">
3 |   <component name="CMakeWorkspace" PROJECT_DIR="$PROJECT_DIR$" />
4 | </project>


--------------------------------------------------------------------------------
/.idea/vcs.xml:
--------------------------------------------------------------------------------
1 | <?xml version="1.0" encoding="UTF-8"?>
2 | <project version="4">
3 |   <component name="VcsDirectoryMappings">
4 |     <mapping directory="$PROJECT_DIR$" vcs="Git" />
5 |   </component>
6 | </project>


--------------------------------------------------------------------------------
/.idea/preferred-vcs.xml:
--------------------------------------------------------------------------------
1 | <?xml version="1.0" encoding="UTF-8"?>
2 | <project version="4">
3 |   <component name="PreferredVcsStorage">
4 |     <preferredVcsName>ApexVCS</preferredVcsName>
5 |   </component>
6 | </project>


--------------------------------------------------------------------------------
/.idea/modules.xml:
--------------------------------------------------------------------------------
1 | <?xml version="1.0" encoding="UTF-8"?>
2 | <project version="4">
3 |   <component name="ProjectModuleManager">
4 |     <modules>
5 |       <module fileurl="file://$PROJECT_DIR$/.idea/libv4l2cxx.iml" filepath="$PROJECT_DIR$/.idea/libv4l2cxx.iml" />
6 |     </modules>
7 |   </component>
8 | </project>


--------------------------------------------------------------------------------
/CMakeLists.txt:
--------------------------------------------------------------------------------
 1 | cmake_minimum_required(VERSION 3.5.1)
 2 | project(libv4l2cxx)
 3 | 
 4 | set(CMAKE_CXX_STANDARD 17)
 5 | 
 6 | 
 7 | set(HEADER_FILES src/util_v4l2.h src/v4l2cxx.h)
 8 | 
 9 | set(SOURCE_FILES examples/main.cpp )
10 | add_executable(libv4l2cxx ${SOURCE_FILES} ${HEADER_FILES})
11 | 
12 | set(EXAMPLE1_FILES examples/example1.cpp )
13 | add_executable(example1 ${EXAMPLE1_FILES} ${HEADER_FILES})
14 | 
15 | 


--------------------------------------------------------------------------------
/examples/example1.cpp:
--------------------------------------------------------------------------------
 1 | //
 2 | // Created by dan on 4/29/18.
 3 | //
 4 | 
 5 | #include "../src/v4l2cxx.h"
 6 | 
 7 | 
 8 | 
 9 | void callback_stdout_pipe(uint8_t *p_data, size_t len) {
10 | 
11 |     uint8_t outBuff[921600];
12 |     util_v4l2::raw_to_rgb(p_data, 0, outBuff, 921600, 640 * 480, 8);
13 |     fwrite(outBuff, 640*480*3, 1, stdout);
14 | }
15 | 
16 | 
17 | int main() {
18 | 
19 |     ///////////////////////////////////////////////////////////////////////////////////////////////////
20 | 
21 |     capture cap("/dev/video0", 640,480,pixel_format ::V4L2CXX_PIX_FMT_YUYV,callback_stdout_pipe);
22 |     cap.run();
23 | 
24 |     }


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | MIT License
 2 | 
 3 | Copyright (c) 2018 Dan Yerushalmi dan.yerushalmi@gmail.com
 4 | https://github.com/narfster/v4l2cxx/
 5 | 
 6 | Permission is hereby granted, free of charge, to any person obtaining a copy
 7 | of this software and associated documentation files (the "Software"), to deal
 8 | in the Software without restriction, including without limitation the rights
 9 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
10 | copies of the Software, and to permit persons to whom the Software is
11 | furnished to do so, subject to the following conditions:
12 | 
13 | The above copyright notice and this permission notice shall be included in all
14 | copies or substantial portions of the Software.
15 | 
16 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
19 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
22 | SOFTWARE.
23 | 


--------------------------------------------------------------------------------
/.idea/codeStyles/Project.xml:
--------------------------------------------------------------------------------
 1 | <component name="ProjectCodeStyleConfiguration">
 2 |   <code_scheme name="Project" version="173">
 3 |     <Objective-C-extensions>
 4 |       <file>
 5 |         <option name="com.jetbrains.cidr.lang.util.OCDeclarationKind" value="Import" />
 6 |         <option name="com.jetbrains.cidr.lang.util.OCDeclarationKind" value="Macro" />
 7 |         <option name="com.jetbrains.cidr.lang.util.OCDeclarationKind" value="Typedef" />
 8 |         <option name="com.jetbrains.cidr.lang.util.OCDeclarationKind" value="Enum" />
 9 |         <option name="com.jetbrains.cidr.lang.util.OCDeclarationKind" value="Constant" />
10 |         <option name="com.jetbrains.cidr.lang.util.OCDeclarationKind" value="Global" />
11 |         <option name="com.jetbrains.cidr.lang.util.OCDeclarationKind" value="Struct" />
12 |         <option name="com.jetbrains.cidr.lang.util.OCDeclarationKind" value="FunctionPredecl" />
13 |         <option name="com.jetbrains.cidr.lang.util.OCDeclarationKind" value="Function" />
14 |       </file>
15 |       <class>
16 |         <option name="com.jetbrains.cidr.lang.util.OCDeclarationKind" value="Property" />
17 |         <option name="com.jetbrains.cidr.lang.util.OCDeclarationKind" value="Synthesize" />
18 |         <option name="com.jetbrains.cidr.lang.util.OCDeclarationKind" value="InitMethod" />
19 |         <option name="com.jetbrains.cidr.lang.util.OCDeclarationKind" value="StaticMethod" />
20 |         <option name="com.jetbrains.cidr.lang.util.OCDeclarationKind" value="InstanceMethod" />
21 |         <option name="com.jetbrains.cidr.lang.util.OCDeclarationKind" value="DeallocMethod" />
22 |       </class>
23 |       <extensions>
24 |         <pair source="cpp" header="h" fileNamingConvention="NONE" />
25 |         <pair source="c" header="h" fileNamingConvention="NONE" />
26 |       </extensions>
27 |     </Objective-C-extensions>
28 |   </code_scheme>
29 | </component>


--------------------------------------------------------------------------------
/examples/main.cpp:
--------------------------------------------------------------------------------
 1 | 
 2 | #include "../src/v4l2cxx.h"
 3 | 
 4 | 
 5 | 
 6 | 
 7 | int main(){
 8 | 
 9 | 
10 |     error_code err = error_code::ERR_NO_ERROR;
11 | 
12 |     int fd = util_v4l2::open_device("/dev/video0", &err);
13 | 
14 |     auto vec = v4l2cxx::get_video_formats_ext(fd);
15 | 
16 |     v4l2cxx::print_fmt_ext(vec);
17 | 
18 |     ///////////////////////////////////////////////////////////////////////////////////////////////////
19 | 
20 | //#elif (TEST_RUN == 2)
21 | //    capture cap("/dev/video0", 640,480,pixel_format ::V4L2CXX_PIX_FMT_YUYV,callback_stdout_pipe);
22 | //    while(1){
23 | //        cap.read();
24 | //        std::this_thread::sleep_for(std::chrono::milliseconds(16));
25 | //    }
26 | //
27 | //    ///////////////////////////////////////////////////////////////////////////////////////////////////
28 | //
29 | //#elif (TEST_RUN == 3)
30 | 
31 | //    struct util_v4l2::buffer buffers[4];
32 | //
33 | //    error_code err = error_code::ERR_NO_ERROR;
34 | //
35 | //    int fd = util_v4l2::open_device("/dev/video0", &err);
36 | //    ASSERT_ERR_CODE(err);
37 | //
38 | //    auto vec = v4l2cxx::get_video_formats_ext(fd);
39 | //
40 | //    v4l2cxx::print_fmt_ext(vec);
41 | 
42 | //    auto cap = util_v4l2::query_capabilites(fd, &err);
43 | //
44 | //    auto vec = util_v4l2::query_formats(fd, &err);
45 | //
46 | //    util_v4l2::set_format(fd, 640, 480, pixel_format::V4L2CXX_PIX_FMT_YVYU, &err);
47 | //
48 | //    auto vec_format = util_v4l2::get_current_format(fd, &err);
49 | //
50 | //    //util_v4l2::printv4l2_fmt(vec_format);
51 | //
52 | //    util_v4l2::init_mmap(fd, buffers, &err);
53 | //
54 | //    util_v4l2::set_capture_steamon(fd,&err);
55 | //
56 | //    util_v4l2::queue_frames(fd, 4, &err);
57 | //
58 | //    util_v4l2::mainloop(fd, buffers, callback_stdout_pipe,&err);
59 | 
60 |     ///////////////////////////////////////////////////////////////////////////////////////////////////
61 | 
62 | 
63 | 
64 | }
65 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # Video4Linux2 C++ simple wrapper
 2 | 
 3 | - [Intro](#Intro)
 4 | - [How to use](#How-to-use)
 5 | - [Examples](#examples)
 6 |   - [Pipe to ffplay](#pipe-to-ffplay)
 7 | - [ffmpeg commands](#ffmpeg-commands)
 8 | 
 9 | 
10 | ## Intro
11 | A simple C++ header library to capture frames from a usb camera into a callback function for image processing.
12 | 
13 | 
14 | ## How to use
15 | 
16 | Run a simple hello camera to see how easy. no more v4l2 boilrplate code.
17 | ```cpp
18 | // callback function to pipe out image to stdout 
19 | // later pipe to ffplay to display image
20 | void callback_stdout_pipe(uint8_t *p_data, size_t len) {
21 |     uint8_t outBuff[921600];
22 |     util_v4l2::raw_to_rgb(p_data, 0, outBuff, 921600, 640 * 480, 8);
23 |     fwrite(outBuff, 640*480*3, 1, stdout);
24 | }
25 | 
26 | int main() {
27 |     // a capture instance 
28 |     // device, resolution, pixel format , and callback function this should be known in advance you can use 
29 |     // v4l2-ctl command to figure that out.
30 |     capture cap("/dev/video0", 640,480,pixel_format ::V4L2CXX_PIX_FMT_YUYV,callback_stdout_pipe);
31 |     // start streaming - a blocking function.
32 |     cap.run();
33 | }
34 | ```
35 | 
36 | ## Examples
37 | - TODO ; cmake; See example folder
38 | 
39 | ## v4l2 Extension unit
40 | - TODO 
41 | - TODO example with LI-USB30-V034M
42 | 
43 | ### pipe to ffplay
44 | ./libv4l2cxx | ffplay -f rawvideo -i pipe:0 -video_size 640x480 -pixel_format rgb24 -framerate 60
45 | 
46 | 
47 | ## ffmpeg commands
48 | 
49 | #### Play video device
50 | > ffplay -f v4l2 -i /dev/video0 -video_size 640x480  -pixel_format yuyv422 -framerate 30
51 | 
52 | > ffplay -f v4l2 -i /dev/video0 -video_size 640x480  -pixel_format mjpeg
53 | 
54 | > ffplay -f v4l2 -i /dev/video0 -video_size 1280x720 -pixel_format mjpeg -framerate 30
55 | 
56 | #### Pipe libv4l2 to ffplay, tell ffplay to use input (-i pipe:0 = stdin standrd input) 
57 | > ./libv4l2cxx | ffplay -f rawvideo -i pipe:0 -video_size 640x480 -pixel_format rgb24 -framerate 60
58 | 
59 | #### List formats for device
60 | > v4l2-ctl --list-formats
61 | 
62 | #### List exdtended formats including resolution info for device
63 | > v4l2-ctl --list-formats-ext
64 | 
65 | > v4l2-ctl -L
66 | 
67 | #### List controls for device
68 | > v4l2-ctl --all 
69 | 
70 | #### Change control option to value
71 | > v4l2-ctl -c \<option>=\<value>
72 | 
73 | > v4l2-ctl -d /dev/video1 -c exposure_absolute=100
74 | 
75 | >
76 | 


--------------------------------------------------------------------------------
/src/v4l2cxx.h:
--------------------------------------------------------------------------------
  1 | 
  2 | /*
  3 | MIT License
  4 | 
  5 | Copyright (c) 2018 Dan Yerushalmi dan.yerushalmi@gmail.com
  6 | https://github.com/narfster/v4l2cxx/
  7 | 
  8 | Permission is hereby granted, free of charge, to any person obtaining a copy
  9 | of this software and associated documentation files (the "Software"), to deal
 10 | in the Software without restriction, including without limitation the rights
 11 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 12 | copies of the Software, and to permit persons to whom the Software is
 13 | furnished to do so, subject to the following conditions:
 14 | 
 15 | The above copyright notice and this permission notice shall be included in all
 16 | copies or substantial portions of the Software.
 17 | 
 18 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 19 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 20 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 21 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 22 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 23 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 24 | SOFTWARE.
 25 | */
 26 | 
 27 | #pragma once
 28 | 
 29 | 
 30 | #include "util_v4l2.h"
 31 | 
 32 | 
 33 | namespace v4l2cxx {
 34 | 
 35 | 
 36 |     struct frm_size_t {
 37 |         frm_size_t(v4l2_frmsizeenum frmsize):
 38 |                 frmsize_(frmsize) {
 39 |             if(frmsize.type == V4L2_FRMSIZE_TYPE_DISCRETE) {
 40 |                 frmsize_discrete_ = frmsize.discrete;
 41 |             }
 42 |             else if(frmsize.type == V4L2_FRMSIZE_TYPE_STEPWISE){
 43 |                 frmsize_stepwise_ = frmsize.stepwise;
 44 |             }
 45 |             frame_size_num = frmsize.index;
 46 |             type_= util_v4l2::frmtype2s(frmsize_.type);
 47 | 
 48 |             fourcc_format_ = util_v4l2::fcc2s(frmsize_.pixel_format);
 49 |         }
 50 | 
 51 |         // Original frame size enum data
 52 |         v4l2_frmsizeenum frmsize_;
 53 | 
 54 |         std::string type_;
 55 |         std::string fourcc_format_;
 56 |         int frame_size_num;
 57 |         v4l2_frmsize_discrete frmsize_discrete_;
 58 |         v4l2_frmsize_stepwise frmsize_stepwise_;
 59 | 
 60 |         // holds possiable frame intervals
 61 |         struct std::vector<v4l2_frmivalenum> frmival;
 62 |     };
 63 | 
 64 |     struct fmt_ext_t {
 65 | 
 66 |         fmt_ext_t(v4l2_fmtdesc fmt) :
 67 |                 v4l2_fmt_desc_(fmt) {
 68 |             // convert to string repesnation.
 69 |             description = std::string((char *) fmt.description);
 70 |             fourcc_format = util_v4l2::fcc2s(fmt.pixelformat);
 71 |             if (fmt.flags) {
 72 |                 flags = util_v4l2::fmtdesc2s(fmt.flags);
 73 |             }
 74 |             type = util_v4l2::buftype2s(fmt.type);
 75 | 
 76 |             format_index = fmt.index;
 77 |         }
 78 | 
 79 |         // Original v4l2 format description.
 80 |         struct v4l2_fmtdesc v4l2_fmt_desc_;
 81 | 
 82 |         // possiable sizes for format.
 83 |         std::vector<frm_size_t> v4l2_frm_sizes_;
 84 | 
 85 |         int format_index;
 86 |         std::string description;
 87 |         std::string fourcc_format;
 88 |         std::string flags;
 89 |         std::string type;
 90 |     };
 91 | 
 92 |     static void print_fmt_ext(std::vector<fmt_ext_t> vid_formats){
 93 | 
 94 |         // Run on all format descriptions.
 95 |         for(int i = 0; i<vid_formats.size(); ++i){
 96 | 
 97 |             util_v4l2::print_fmt_desc(vid_formats[i].v4l2_fmt_desc_);
 98 | 
 99 |             // Run on all sizes
100 |             for(int j = 0; j<vid_formats[i].v4l2_frm_sizes_.size(); ++j){
101 | 
102 |                 auto e = vid_formats[i].v4l2_frm_sizes_[j].frmsize_;
103 |                 util_v4l2::print_frmsize(e, "\t");
104 | 
105 |                 // Run on all intervals
106 |                 for(int k = 0; k< vid_formats[i].v4l2_frm_sizes_[j].frmival.size();++k){
107 | 
108 |                     auto e = vid_formats[i].v4l2_frm_sizes_[j].frmival[k];
109 |                     util_v4l2::print_frmival(e, "\t\t");
110 |                 }
111 |             }
112 |         }
113 |     }
114 | 
115 | 
116 | 
117 |     static std::vector<fmt_ext_t> get_video_formats_ext(int fd) {
118 |         struct v4l2_fmtdesc fmt;
119 |         struct v4l2_frmsizeenum frmsize;
120 |         struct v4l2_frmivalenum frmival;
121 | 
122 |         std::vector<fmt_ext_t> capture_formats;   // results stored here.
123 | 
124 |         fmt.index = 0;
125 |         fmt.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
126 |         while (util_v4l2::xioctl(fd, VIDIOC_ENUM_FMT, &fmt) >= 0) {
127 | 
128 |             fmt_ext_t current_fmt(fmt);
129 |             // Save format description
130 |             //current_fmt.fmt = fmt;
131 | 
132 |             frmsize.pixel_format = fmt.pixelformat;
133 |             frmsize.index = 0;
134 |             while (util_v4l2::xioctl(fd, VIDIOC_ENUM_FRAMESIZES, &frmsize) >= 0) {
135 | 
136 |                 frm_size_t vid_cap_frm_size(frmsize);
137 | 
138 |                 if (frmsize.type == V4L2_FRMSIZE_TYPE_DISCRETE) {
139 |                     frmival.index = 0;
140 |                     frmival.pixel_format = fmt.pixelformat;
141 |                     frmival.width = frmsize.discrete.width;
142 |                     frmival.height = frmsize.discrete.height;
143 |                     while (util_v4l2::xioctl(fd, VIDIOC_ENUM_FRAMEINTERVALS, &frmival) >= 0) {
144 | 
145 |                         // Save frame interval data
146 |                         vid_cap_frm_size.frmival.push_back(frmival);
147 |                         frmival.index++;
148 |                     }
149 |                 }
150 |                 current_fmt.v4l2_frm_sizes_.push_back(vid_cap_frm_size);
151 |                 frmsize.index++;
152 |             }
153 |             // Save current video format
154 |             capture_formats.push_back(current_fmt);
155 |             fmt.index++;
156 |         }
157 | 
158 |         return capture_formats;
159 |     }
160 | 
161 | }//namespace
162 | 
163 | 
164 | 
165 | 
166 | class capture {
167 | 
168 | public:
169 | 
170 |     ///////////////////////////////////////////////////////////////////////////////
171 |     ///////////////////////////////////////////////////////////////////////////////
172 |     ///////////////////////////////////////////////////////////////////////////////
173 | 
174 |     capture(std::string device, std::function<void(uint8_t *p_data, size_t len)> callback)
175 |             : callback_(callback) {
176 | 
177 |         fd_ = util_v4l2::open_device(device, &err_);
178 |         ASSERT_ERR_CODE(err_);
179 | 
180 |     }
181 | 
182 |     ///////////////////////////////////////////////////////////////////////////////
183 |     ///////////////////////////////////////////////////////////////////////////////
184 |     ///////////////////////////////////////////////////////////////////////////////
185 | 
186 |     capture(std::string device, uint32_t width, uint32_t height, pixel_format format,
187 |             std::function<void(uint8_t *p_data, size_t len)> callback)
188 |             : callback_(callback) {
189 | 
190 | 
191 |         fd_ = util_v4l2::open_device(device, &err_);
192 |         ASSERT_ERR_CODE(err_);
193 | 
194 |         util_v4l2::set_format(fd_, width, height, format, &err_);
195 |         ASSERT_ERR_CODE(err_);
196 | 
197 |         util_v4l2::init_mmap(fd_, buffers, &err_);
198 |         ASSERT_ERR_CODE(err_);
199 | 
200 |         util_v4l2::set_capture_steamon(fd_, &err_);
201 |         ASSERT_ERR_CODE(err_);
202 | 
203 |         auto formats = util_v4l2::query_formats(fd_,nullptr);
204 | 
205 | 
206 | 
207 | 
208 |         v4l2_format format1;
209 |         format1.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
210 | 
211 |         if (-1 == util_v4l2::xioctl(fd_, VIDIOC_G_FMT, &format1)) {
212 | 
213 | 
214 | 
215 |         }
216 |         int x = 5;
217 | 
218 |     }
219 | 
220 |     ///////////////////////////////////////////////////////////////////////////////
221 |     ///////////////////////////////////////////////////////////////////////////////
222 |     ///////////////////////////////////////////////////////////////////////////////
223 | 
224 |     void run() {
225 |         util_v4l2::queue_frames(fd_, NUM_OF_MAP_BUFFER, &err_);
226 |         ASSERT_ERR_CODE(err_);
227 | 
228 |         // blocks indefintly.
229 |         util_v4l2::mainloop(fd_, buffers, callback_, &err_);
230 |         ASSERT_ERR_CODE(err_);
231 |     }
232 | 
233 |     ///////////////////////////////////////////////////////////////////////////////
234 |     ///////////////////////////////////////////////////////////////////////////////
235 |     ///////////////////////////////////////////////////////////////////////////////
236 | 
237 |     void set_format(int width, int height, pixel_format format) {
238 |         util_v4l2::set_format(fd_, width, height, format, &err_);
239 |         ASSERT_ERR_CODE(err_);
240 | 
241 |         util_v4l2::init_mmap(fd_, buffers, &err_);
242 |         ASSERT_ERR_CODE(err_);
243 | 
244 |         util_v4l2::set_capture_steamon(fd_, &err_);
245 |         ASSERT_ERR_CODE(err_);
246 |     }
247 | 
248 |     ///////////////////////////////////////////////////////////////////////////////
249 |     ///////////////////////////////////////////////////////////////////////////////
250 |     ///////////////////////////////////////////////////////////////////////////////
251 | 
252 |     int read() {
253 |         int numOfBytes = util_v4l2::read_one_frame(fd_, buffers, callback_, &err_);
254 |         ASSERT_ERR_CODE(err_);
255 |         return numOfBytes;
256 |     }
257 | 
258 |     ///////////////////////////////////////////////////////////////////////////////
259 |     ///////////////////////////////////////////////////////////////////////////////
260 |     ///////////////////////////////////////////////////////////////////////////////
261 | 
262 | private:
263 | 
264 |     int fd_{};
265 |     constexpr static int NUM_OF_MAP_BUFFER = 4;
266 |     struct util_v4l2::buffer buffers[NUM_OF_MAP_BUFFER];
267 |     error_code err_ = error_code::ERR_NO_ERROR;
268 |     std::function<void(uint8_t *p_data, size_t len)> callback_;
269 | };
270 | 
271 | 
272 | 
273 | 
274 | 
275 | 
276 | 
277 | 
278 | #if 0
279 | void raw_to_rgb(void* inBuff, int inBuffSize, void* outBuff, int outBuffSize, uint32_t numOfPixels, int bitPerPixel)
280 | {
281 |     auto dst = static_cast<uint8_t *>(outBuff);
282 | 
283 |     auto shift = bitPerPixel - 8;  //i.e. 10bit - 8bit(1 byte) = 2, 12bit - 8bit = 4
284 | 
285 |     auto tmp = static_cast<uint16_t *>(inBuff);
286 |     for (auto i = 0u; i < numOfPixels; i++)
287 |     {
288 |         uint16_t temp = (*tmp++) >> shift; //12 bit shift 4, 10bit shift 2
289 |         *dst++ = static_cast<uint8_t>(temp);
290 |         *dst++ = static_cast<uint8_t>(temp);
291 |         *dst++ = static_cast<uint8_t>(temp);
292 |     }
293 | }
294 | 
295 | 
296 | 
297 | namespace util_v4l2_b {
298 | 
299 | 
300 |     static void process_image(const void *p, int size)
301 |     {
302 |         static uint32_t frame_number = 0;
303 |         frame_number++;
304 | 
305 |         char filename[15];
306 | 
307 |         //std::cerr << size << "\n";
308 | //        sprintf(filename, "frame-%d.ppm", frame_number);
309 | //        FILE *fp=fopen(filename,"wb");
310 | 
311 |         uint8_t outBuff[921600];
312 |         raw_to_rgb(const_cast<void *>(p), 0, outBuff, 921600, 640 * 480, 8);
313 | 
314 | //        fprintf(fp, "P6\n%d %d 255\n",
315 | //                640, 480);
316 | 
317 |         bool enable_stdout = true;
318 |         if (enable_stdout){
319 |             //fwrite(outBuff, 921600, 1, fp);
320 |             fwrite(outBuff, 921600, 1, stdout);
321 |         }
322 | 
323 | 
324 | //        fflush(fp);
325 | //        fclose(fp);
326 |     }
327 | 
328 |     static int read_frame(int fd, util_v4l2::buffer *pBuffer) {
329 |         struct v4l2_buffer buf;
330 | 
331 |         CLEAR(buf);
332 | 
333 |         buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
334 |         buf.memory = V4L2_MEMORY_MMAP;
335 | 
336 |         if (-1 == util_v4l2::xioctl(fd, VIDIOC_DQBUF, &buf)) {
337 |             switch (errno) {
338 |                 case EAGAIN:
339 |                     return 0;
340 | 
341 |                 case EIO:
342 |                     /* Could ignore EIO, see spec. */
343 | 
344 |                     /* fall through */
345 | 
346 |                 default:
347 |                     printf("ERROR: read_frame VIDIOC_DQBUF\n");
348 |                     return -1;
349 |                 break;
350 | 
351 |             }
352 |         }
353 | 
354 |         assert(buf.index < 4);
355 | 
356 |         process_image(pBuffer[buf.index].start, buf.bytesused);
357 | 
358 |         if (-1 == util_v4l2::xioctl(fd, VIDIOC_QBUF, &buf))
359 |         {
360 |             printf("ERROR: read_frame VIDIOC_DQBUF\n");
361 |             return -1;
362 |         }
363 | 
364 |         return 1;
365 |     }
366 | 
367 |     static void mainloop(int fd, util_v4l2::buffer *pBuffer) {
368 | 
369 |             while (1){
370 |                 for (;;) {
371 |                 fd_set fds;
372 |                 struct timeval tv;
373 |                 int r;
374 | 
375 |                 FD_ZERO(&fds);
376 |                 FD_SET(fd, &fds);
377 | 
378 |                 /* Timeout. */
379 |                 tv.tv_sec = 5;
380 |                 tv.tv_usec = 0;
381 | 
382 |                 r = select(fd + 1, &fds, NULL, NULL, &tv);
383 | 
384 |                 if (-1 == r) {
385 |                     if (EINTR == errno)
386 |                         continue;
387 | 
388 |                     printf("ERROR: select");
389 |                     return;
390 |                 }
391 | 
392 |                 if (0 == r) {
393 |                     fprintf(stderr, "ERROR: select timeout\n");
394 |                     exit(EXIT_FAILURE);
395 |                 }
396 | 
397 |                 if (util_v4l2_b::read_frame(fd, pBuffer))
398 |                     break;
399 | 
400 |                 /* EAGAIN - continue select loop. */
401 |             }
402 |         }
403 |     }
404 | 
405 | }
406 | 
407 | #endif
408 | 


--------------------------------------------------------------------------------
/src/util_v4l2.h:
--------------------------------------------------------------------------------
   1 | 
   2 | /*
   3 | MIT License
   4 | 
   5 | Copyright (c) 2018 Dan Yerushalmi dan.yerushalmi@gmail.com
   6 | https://github.com/narfster/v4l2cxx/
   7 | 
   8 | Permission is hereby granted, free of charge, to any person obtaining a copy
   9 | of this software and associated documentation files (the "Software"), to deal
  10 | in the Software without restriction, including without limitation the rights
  11 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  12 | copies of the Software, and to permit persons to whom the Software is
  13 | furnished to do so, subject to the following conditions:
  14 | 
  15 | The above copyright notice and this permission notice shall be included in all
  16 | copies or substantial portions of the Software.
  17 | 
  18 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  19 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  20 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  21 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  22 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  23 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  24 | SOFTWARE.
  25 | */
  26 | 
  27 | #pragma once
  28 | 
  29 | 
  30 | #include <linux/videodev2.h>
  31 | #include <fcntl.h>
  32 | #include <sys/ioctl.h>
  33 | #include <cstring>
  34 | #include <vector>
  35 | #include <sys/mman.h>
  36 | #include <sys/mman.h>
  37 | #include <sys/stat.h>
  38 | #include <sys/types.h>
  39 | #include <sys/time.h>
  40 | #include <unistd.h>
  41 | #include <cerrno>
  42 | #include <iostream>
  43 | #include <cassert>
  44 | #include <functional>
  45 | 
  46 | 
  47 | #define UTIL_CLEAR(x) memset(&(x), 0, sizeof(x))
  48 | #define SET_ERR_CODE(err, code) if(err !=nullptr) *err = code
  49 | #define ASSERT_ERR_CODE(x)  if(x != error_code::ERR_NO_ERROR)\
  50 |                                 {\
  51 |                                     print_err_code(x) ;\
  52 |                                     std::cerr << "\n"<< __FILE__ << ":" << __LINE__ << "  ";\
  53 |                                     exit(1);\
  54 |                                 }
  55 | 
  56 | 
  57 | enum class error_code {
  58 |     ERR_NO_ERROR = 0,
  59 |     ERR_CANNOT_OPEN_DEVICE,
  60 |     ERR_CANNOT_SET_FORMAT,
  61 |     ERR_QUERYING_CAP,
  62 |     ERR_QUERYING_FORMAT,
  63 |     ERR_VIDIOC_QBUF,
  64 |     ERR_VIDIOC_STREAMON,
  65 |     ERR_NO_MMAP_SUPPORT,
  66 |     ERR_VIDIO_REQBUFS,
  67 |     ERR_INSUFFICIENT_MEM,
  68 |     ERR_MMAP_INIT,
  69 |     ERR_VIDIO_QUERYBUF,
  70 |     ERR_VIDIOC_S_FMT,
  71 |     ERR_VIDIOC_G_FMT,
  72 |     ERR_READ_FRAME,
  73 |     ERR_SELECT_TIMEOUT,
  74 |     ERR_SELECT,
  75 | };
  76 | 
  77 | void print_err_code(error_code err) {
  78 |     switch (err) {
  79 |         case error_code::ERR_CANNOT_OPEN_DEVICE:
  80 |             std::cerr << "ERR_CANNOT_OPEN_DEVICE" << " " << static_cast<int>(err);
  81 |             break;
  82 |         default:
  83 |             std::cerr << "ERROR # " << static_cast<int>(err);
  84 |             break;
  85 |     }
  86 | 
  87 | }
  88 | 
  89 | std::ostream &operator<<(std::ostream &os, const error_code &obj) {
  90 |     os << static_cast<std::underlying_type<error_code>::type>(obj);
  91 |     return os;
  92 | }
  93 | 
  94 | 
  95 | enum class pixel_format {
  96 |     V4L2CXX_PIX_FMT_RGB332 = V4L2_PIX_FMT_RGB332,
  97 |     V4L2CXX_PIX_FMT_YUYV = V4L2_PIX_FMT_YUYV,
  98 |     V4L2CXX_PIX_FMT_YVYU = V4L2_PIX_FMT_YVYU,
  99 |     V4L2CXX_PIX_FMT_MJPEG = V4L2_PIX_FMT_MJPEG
 100 | 
 101 | };
 102 | 
 103 | class function;
 104 | namespace util_v4l2 {
 105 | 
 106 |     struct buffer {
 107 |         void *start;
 108 |         size_t length;
 109 |     };
 110 | 
 111 | 
 112 |     static int xioctl(int fd, int request, void *arg) {
 113 |         int r;
 114 |         do r = ioctl(fd, request, arg);
 115 |         while (-1 == r && EINTR == errno);
 116 |         return r;
 117 |     }
 118 | 
 119 |     ///////////////////////////////////////////////////////////////////////////////
 120 |     ///////////////////////////////////////////////////////////////////////////////
 121 |     ///////////////////////////////////////////////////////////////////////////////
 122 | 
 123 |     int open_device(std::string device_node, error_code *err) {
 124 | 
 125 |         int fd;
 126 |         SET_ERR_CODE(err, error_code::ERR_NO_ERROR);
 127 |         fd = open(device_node.c_str(), O_RDWR);
 128 |         if (fd == -1) {
 129 |             // couldn't find capture device
 130 |             perror("Opening Video device");
 131 |             SET_ERR_CODE(err, error_code::ERR_CANNOT_OPEN_DEVICE);
 132 |             return -1;
 133 |         }
 134 |         return fd;
 135 |     }
 136 | 
 137 |     ///////////////////////////////////////////////////////////////////////////////
 138 |     ///////////////////////////////////////////////////////////////////////////////
 139 |     ///////////////////////////////////////////////////////////////////////////////
 140 | 
 141 | 
 142 |     void set_format(int fd, uint32_t width, uint32_t height, pixel_format format, error_code *err) {
 143 |         struct v4l2_format fmt;
 144 |         unsigned int min;
 145 |         fmt.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
 146 |         SET_ERR_CODE(err, error_code::ERR_NO_ERROR);
 147 | 
 148 |         //std::cout << "set_format()\n";
 149 |         fmt.fmt.pix.width = width; //replace
 150 |         fmt.fmt.pix.height = height; //replace
 151 |         fmt.fmt.pix.pixelformat = static_cast<__u32>(format); //replace
 152 |         fmt.fmt.pix.field = V4L2_FIELD_ANY;
 153 | 
 154 |         if (-1 == xioctl(fd, VIDIOC_S_FMT, &fmt)) {
 155 |             std::cout << "ERROR set_format\n";
 156 |             SET_ERR_CODE(err, error_code::ERR_VIDIOC_S_FMT);
 157 |         }
 158 |         // Note VIDIOC_S_FMT may change width and height.
 159 | 
 160 |         // Buggy driver paranoia.
 161 |         min = fmt.fmt.pix.width * 2;
 162 |         if (fmt.fmt.pix.bytesperline < min) {
 163 |             fmt.fmt.pix.bytesperline = min;
 164 |         }
 165 | 
 166 |         min = fmt.fmt.pix.bytesperline * fmt.fmt.pix.height;
 167 | 
 168 |         if (fmt.fmt.pix.sizeimage < min) {
 169 |             fmt.fmt.pix.sizeimage = min;
 170 |         }
 171 | 
 172 |         // Test Resolution was set correctly
 173 |         if (width != fmt.fmt.pix.width || height != fmt.fmt.pix.height) {
 174 |             SET_ERR_CODE(err, error_code::ERR_CANNOT_SET_FORMAT);
 175 |         }
 176 | 
 177 |         // Test format was set correctly
 178 |         if (static_cast<__u32>(format) != fmt.fmt.pix.pixelformat) {
 179 |             SET_ERR_CODE(err, error_code::ERR_CANNOT_SET_FORMAT);
 180 |         }
 181 | 
 182 |     }
 183 | 
 184 |     ///////////////////////////////////////////////////////////////////////////////
 185 |     ///////////////////////////////////////////////////////////////////////////////
 186 |     ///////////////////////////////////////////////////////////////////////////////
 187 | 
 188 |     void set_capture_steamon(int fd, error_code *err){
 189 |         SET_ERR_CODE(err,error_code::ERR_NO_ERROR);
 190 |         enum v4l2_buf_type type;
 191 |         type  = V4L2_BUF_TYPE_VIDEO_CAPTURE;
 192 |         if (-1 == util_v4l2::xioctl(fd, VIDIOC_STREAMON, &type)) {
 193 |             std::cerr << "ERROR: queue_frames VIDIOC_STREAMON\n";
 194 |             SET_ERR_CODE(err,error_code::ERR_NO_ERROR);
 195 |         }
 196 |     }
 197 | 
 198 |     ///////////////////////////////////////////////////////////////////////////////
 199 |     ///////////////////////////////////////////////////////////////////////////////
 200 |     ///////////////////////////////////////////////////////////////////////////////
 201 | 
 202 |     void set_capture_steamoff(int fd, error_code *err){
 203 |         SET_ERR_CODE(err,error_code::ERR_NO_ERROR);
 204 |         enum v4l2_buf_type type;
 205 |         type  = V4L2_BUF_TYPE_VIDEO_CAPTURE;
 206 |         if (-1 == util_v4l2::xioctl(fd, VIDIOC_STREAMON, &type)) {
 207 |             std::cerr << "ERROR: queue_frames VIDIOC_STREAMON\n";
 208 |             SET_ERR_CODE(err,error_code::ERR_NO_ERROR);
 209 |         }
 210 |     }
 211 | 
 212 |     ///////////////////////////////////////////////////////////////////////////////
 213 |     ///////////////////////////////////////////////////////////////////////////////
 214 |     ///////////////////////////////////////////////////////////////////////////////
 215 | 
 216 |     v4l2_capability query_capabilites(int fd, error_code *err) {
 217 |         SET_ERR_CODE(err, error_code::ERR_NO_ERROR);
 218 |         struct v4l2_capability caps;
 219 |         if (-1 == util_v4l2::xioctl(fd, VIDIOC_QUERYCAP, &caps)) {
 220 |             SET_ERR_CODE(err, error_code::ERR_QUERYING_CAP);
 221 |         }
 222 |         return caps;
 223 |     }
 224 | 
 225 |     ///////////////////////////////////////////////////////////////////////////////
 226 |     ///////////////////////////////////////////////////////////////////////////////
 227 |     ///////////////////////////////////////////////////////////////////////////////
 228 | 
 229 |     int read_one_frame(int fd, util_v4l2::buffer *pBuffer, std::function<void(uint8_t *p_data, size_t len)> callback, error_code *err){
 230 |         SET_ERR_CODE(err,error_code::ERR_NO_ERROR);
 231 |         struct v4l2_buffer buf;
 232 | 
 233 | 
 234 |         UTIL_CLEAR(buf);
 235 |         buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
 236 |         buf.memory = V4L2_MEMORY_MMAP;
 237 |         buf.index = 0;
 238 | 
 239 |         if (-1 == util_v4l2::xioctl(fd, VIDIOC_QBUF, &buf)) {
 240 |             printf("ERROR: queue_frames VIDIOC_QBUF");
 241 |             SET_ERR_CODE(err,error_code::ERR_READ_FRAME);
 242 |         }
 243 | 
 244 |         UTIL_CLEAR(buf);
 245 |         buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
 246 |         buf.memory = V4L2_MEMORY_MMAP;
 247 | 
 248 |         if (-1 == util_v4l2::xioctl(fd, VIDIOC_DQBUF, &buf)) {
 249 |             SET_ERR_CODE(err,error_code::ERR_READ_FRAME);
 250 |             switch (errno) {
 251 |                 case EAGAIN:
 252 |                     // (try again)
 253 |                     return 0;
 254 | 
 255 |                 case EIO:
 256 |                     // I/O error
 257 |                     /* fall through */
 258 | 
 259 |                 default:
 260 |                     std::cerr << "ERROR: read_frame VIDIOC_DQBUF\n";
 261 |                     return -1;
 262 |                     break;
 263 | 
 264 |             }
 265 |         }
 266 | 
 267 |         assert(buf.index < 4);
 268 |         int numOfBytes = 0;
 269 |         numOfBytes = buf.bytesused;
 270 |         callback((uint8_t *) pBuffer[buf.index].start, buf.bytesused);
 271 | 
 272 |         return numOfBytes;
 273 |     }
 274 |     ///////////////////////////////////////////////////////////////////////////////
 275 |     ///////////////////////////////////////////////////////////////////////////////
 276 |     ///////////////////////////////////////////////////////////////////////////////
 277 | 
 278 | 
 279 |     void printv4l2_capabilites(v4l2_capability cap) {
 280 | 
 281 |         if (cap.device_caps & V4L2_CAP_VIDEO_CAPTURE) {
 282 |             std::cout << "V4L2_CAP_VIDEO_CAPTURE" << std::endl;
 283 |         }
 284 |         if (cap.device_caps & V4L2_CAP_VIDEO_OUTPUT) {
 285 |             std::cout << "V4L2_CAP_VIDEO_OUTPUT" << std::endl;
 286 |         }
 287 |         if (cap.device_caps & V4L2_CAP_STREAMING) {
 288 |             std::cout << "V4L2_CAP_STREAMING" << std::endl;
 289 |         }
 290 |     }
 291 | 
 292 |     ///////////////////////////////////////////////////////////////////////////////
 293 |     ///////////////////////////////////////////////////////////////////////////////
 294 |     ///////////////////////////////////////////////////////////////////////////////
 295 | 
 296 |     v4l2_format get_current_format(int fd, error_code *err) {
 297 |         SET_ERR_CODE(err, error_code::ERR_NO_ERROR);
 298 | 
 299 |         v4l2_format format;
 300 |         format.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
 301 | 
 302 |         if (-1 == util_v4l2::xioctl(fd, VIDIOC_G_FMT, &format)) {
 303 | 
 304 |             SET_ERR_CODE(err, error_code::ERR_VIDIOC_G_FMT);
 305 | 
 306 |         }
 307 |         return format;
 308 |     }
 309 | 
 310 |     ///////////////////////////////////////////////////////////////////////////////
 311 |     ///////////////////////////////////////////////////////////////////////////////
 312 |     ///////////////////////////////////////////////////////////////////////////////
 313 | 
 314 |     std::vector<v4l2_fmtdesc> query_formats(int fd, error_code *err) {
 315 |         SET_ERR_CODE(err, error_code::ERR_NO_ERROR);
 316 | 
 317 |         std::vector<v4l2_fmtdesc> formats;
 318 |         struct v4l2_fmtdesc fmt;
 319 |         fmt.index = 0;
 320 |         fmt.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
 321 | 
 322 |         while (-1 != util_v4l2::xioctl(fd, VIDIOC_ENUM_FMT, &fmt)) {
 323 |             formats.push_back(fmt);
 324 |             fmt.index++;
 325 |         }
 326 |         if (formats.size() == 0) {
 327 |             SET_ERR_CODE(err, error_code::ERR_QUERYING_FORMAT);
 328 |         }
 329 |         return formats;
 330 |     }
 331 | 
 332 |     ///////////////////////////////////////////////////////////////////////////////
 333 |     ///////////////////////////////////////////////////////////////////////////////
 334 |     ///////////////////////////////////////////////////////////////////////////////
 335 | 
 336 |     static void queue_frames(int fd, uint32_t numOfBuffers, error_code *err) {
 337 |         SET_ERR_CODE(err, error_code::ERR_NO_ERROR);
 338 |         unsigned int i;
 339 |         enum v4l2_buf_type type;
 340 | 
 341 |         // Queue into all MMAP buffers from capture device.
 342 |         for (i = 0; i < numOfBuffers; ++i) {
 343 |             struct v4l2_buffer buf;
 344 | 
 345 |             UTIL_CLEAR(buf);
 346 |             buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
 347 |             buf.memory = V4L2_MEMORY_MMAP;
 348 |             buf.index = i;
 349 | 
 350 |             if (-1 == util_v4l2::xioctl(fd, VIDIOC_QBUF, &buf)) {
 351 |                 printf("ERROR: queue_frames VIDIOC_QBUF");
 352 |                 SET_ERR_CODE(err, error_code::ERR_VIDIOC_QBUF);
 353 |             }
 354 |         }
 355 |     }
 356 | 
 357 |     ///////////////////////////////////////////////////////////////////////////////
 358 |     ///////////////////////////////////////////////////////////////////////////////
 359 |     ///////////////////////////////////////////////////////////////////////////////
 360 | 
 361 |     static void stop_capturing(int fd, uint32_t numOfBuffers, error_code *err) {
 362 |         SET_ERR_CODE(err, error_code::ERR_NO_ERROR);
 363 |         unsigned int i;
 364 |         enum v4l2_buf_type type;
 365 | 
 366 |         for (i = 0; i < numOfBuffers; ++i) {
 367 |             struct v4l2_buffer buf;
 368 | 
 369 |             UTIL_CLEAR(buf);
 370 |             buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
 371 |             buf.memory = V4L2_MEMORY_MMAP;
 372 |             buf.index = i;
 373 | 
 374 | //            if (-1 == util_v4l2::xioctl(fd, VIDIOC_DQBUF, &buf)) {
 375 | //                printf("ERROR: queue_frames VIDIOC_DQBUF");
 376 | //                SET_ERR_CODE(err, error_code::ERR_VIDIOC_QBUF);
 377 | //            }
 378 | 
 379 |         }
 380 |         type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
 381 |         if (-1 == util_v4l2::xioctl(fd, VIDIOC_STREAMOFF, &type)) {
 382 |             printf("ERROR: queue_frames VIDIOC_STREAMON");
 383 |             //SET_ERR_CODE(err, error_code::VIDIOC_STREAMOFF);
 384 |         }
 385 |     }
 386 | 
 387 |     ///////////////////////////////////////////////////////////////////////////////
 388 |     ///////////////////////////////////////////////////////////////////////////////
 389 |     ///////////////////////////////////////////////////////////////////////////////
 390 | 
 391 |     static void init_mmap(int fd, buffer buffer[], error_code *err) {
 392 |         SET_ERR_CODE(err, error_code::ERR_NO_ERROR);
 393 |         struct v4l2_requestbuffers req;
 394 | 
 395 |         UTIL_CLEAR(req);
 396 | 
 397 |         req.count = 4;
 398 |         req.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
 399 |         req.memory = V4L2_MEMORY_MMAP;
 400 | 
 401 |         if (-1 == util_v4l2::xioctl(fd, VIDIOC_REQBUFS, &req)) {
 402 |             if (EINVAL == errno) {
 403 |                 printf("ERROR does not support memory mapping\n");
 404 |                 SET_ERR_CODE(err, error_code::ERR_NO_MMAP_SUPPORT);
 405 |             } else {
 406 |                 printf("ERROR: VIDIOC_REQBUFS");
 407 |                 SET_ERR_CODE(err, error_code::ERR_VIDIO_REQBUFS);
 408 |             }
 409 |         }
 410 | 
 411 |         if (req.count < 2) {
 412 |             fprintf(stderr, "Insufficient buffer memory\n");
 413 |             SET_ERR_CODE(err, error_code::ERR_INSUFFICIENT_MEM);
 414 |         }
 415 | 
 416 |         //*ppBuffer = (buffer *) calloc(req.count, sizeof(buffer));
 417 | 
 418 | 
 419 |         if (!buffer) {
 420 |             fprintf(stderr, "Out of memory\n");
 421 |             exit(EXIT_FAILURE);
 422 |         }
 423 | 
 424 |         for (auto i = 0; i < req.count; ++i) {
 425 |             struct v4l2_buffer buf;
 426 | 
 427 |             UTIL_CLEAR(buf);
 428 | 
 429 |             buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
 430 |             buf.memory = V4L2_MEMORY_MMAP;
 431 |             buf.index = i;
 432 | 
 433 |             if (-1 == util_v4l2::xioctl(fd, VIDIOC_QUERYBUF, &buf)) {
 434 |                 printf("ERROR: VIDIOC_QUERYBUF");
 435 |                 SET_ERR_CODE(err, error_code::ERR_VIDIO_QUERYBUF);
 436 |             }
 437 | 
 438 | 
 439 |             (buffer[i]).length = buf.length;
 440 |             (buffer[i]).start =
 441 |                     mmap(NULL /* start anywhere */,
 442 |                          buf.length,
 443 |                          PROT_READ | PROT_WRITE /* required */,
 444 |                          MAP_SHARED /* recommended */,
 445 |                          fd, buf.m.offset);
 446 | 
 447 |             if (MAP_FAILED == (buffer[i]).start) {
 448 |                 printf("ERROR: mmap");
 449 |                 SET_ERR_CODE(err, error_code::ERR_MMAP_INIT);
 450 |             }
 451 |         }
 452 |     }
 453 | 
 454 |     typedef struct {
 455 |         unsigned flag;
 456 |         const char *str;
 457 |     } flag_def;
 458 | 
 459 |     static const flag_def service_def[] = {
 460 |             {V4L2_SLICED_TELETEXT_B, "teletext"},
 461 |             {V4L2_SLICED_WSS_625,    "wss"},
 462 |             {0, NULL}
 463 |     };
 464 | 
 465 |     std::string fcc2s(unsigned int val) {
 466 |         std::string s;
 467 | 
 468 |         s += val & 0x7f;
 469 |         s += (val >> 8) & 0x7f;
 470 |         s += (val >> 16) & 0x7f;
 471 |         s += (val >> 24) & 0x7f;
 472 |         if (val & (1 << 31))
 473 |             s += "-BE";
 474 |         return s;
 475 |     }
 476 | 
 477 |     static std::string num2s(unsigned num) {
 478 |         char buf[10];
 479 | 
 480 |         sprintf(buf, "%08x", num);
 481 |         return buf;
 482 |     }
 483 | 
 484 |     std::string buftype2s(int type) {
 485 |         switch (type) {
 486 |             case 0:
 487 |                 return "Invalid";
 488 |             case V4L2_BUF_TYPE_VIDEO_CAPTURE:
 489 |                 return "Video Capture";
 490 |             case V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE:
 491 |                 return "Video Capture Multiplanar";
 492 |             case V4L2_BUF_TYPE_VIDEO_OUTPUT:
 493 |                 return "Video Output";
 494 |             case V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE:
 495 |                 return "Video Output Multiplanar";
 496 |             case V4L2_BUF_TYPE_VIDEO_OVERLAY:
 497 |                 return "Video Overlay";
 498 |             case V4L2_BUF_TYPE_VBI_CAPTURE:
 499 |                 return "VBI Capture";
 500 |             case V4L2_BUF_TYPE_VBI_OUTPUT:
 501 |                 return "VBI Output";
 502 |             case V4L2_BUF_TYPE_SLICED_VBI_CAPTURE:
 503 |                 return "Sliced VBI Capture";
 504 |             case V4L2_BUF_TYPE_SLICED_VBI_OUTPUT:
 505 |                 return "Sliced VBI Output";
 506 |             case V4L2_BUF_TYPE_VIDEO_OUTPUT_OVERLAY:
 507 |                 return "Video Output Overlay";
 508 |             case V4L2_BUF_TYPE_SDR_CAPTURE:
 509 |                 return "SDR Capture";
 510 |             case V4L2_BUF_TYPE_SDR_OUTPUT:
 511 |                 return "SDR Output";
 512 |             default:
 513 |                 return "Unknown (" + num2s(type) + ")";
 514 |         }
 515 |     }
 516 | 
 517 |     std::string field2s(int val) {
 518 |         switch (val) {
 519 |             case V4L2_FIELD_ANY:
 520 |                 return "Any";
 521 |             case V4L2_FIELD_NONE:
 522 |                 return "None";
 523 |             case V4L2_FIELD_TOP:
 524 |                 return "Top";
 525 |             case V4L2_FIELD_BOTTOM:
 526 |                 return "Bottom";
 527 |             case V4L2_FIELD_INTERLACED:
 528 |                 return "Interlaced";
 529 |             case V4L2_FIELD_SEQ_TB:
 530 |                 return "Sequential Top-Bottom";
 531 |             case V4L2_FIELD_SEQ_BT:
 532 |                 return "Sequential Bottom-Top";
 533 |             case V4L2_FIELD_ALTERNATE:
 534 |                 return "Alternating";
 535 |             case V4L2_FIELD_INTERLACED_TB:
 536 |                 return "Interlaced Top-Bottom";
 537 |             case V4L2_FIELD_INTERLACED_BT:
 538 |                 return "Interlaced Bottom-Top";
 539 |             default:
 540 |                 return "Unknown (" + num2s(val) + ")";
 541 |         }
 542 |     }
 543 | 
 544 |     std::string colorspace2s(int val) {
 545 |         switch (val) {
 546 |             case V4L2_COLORSPACE_DEFAULT:
 547 |                 return "Default";
 548 |             case V4L2_COLORSPACE_SMPTE170M:
 549 |                 return "SMPTE 170M";
 550 |             case V4L2_COLORSPACE_SMPTE240M:
 551 |                 return "SMPTE 240M";
 552 |             case V4L2_COLORSPACE_REC709:
 553 |                 return "Rec. 709";
 554 |             case V4L2_COLORSPACE_BT878:
 555 |                 return "Broken Bt878";
 556 |             case V4L2_COLORSPACE_470_SYSTEM_M:
 557 |                 return "470 System M";
 558 |             case V4L2_COLORSPACE_470_SYSTEM_BG:
 559 |                 return "470 System BG";
 560 |             case V4L2_COLORSPACE_JPEG:
 561 |                 return "JPEG";
 562 |             case V4L2_COLORSPACE_SRGB:
 563 |                 return "sRGB";
 564 |             case V4L2_COLORSPACE_ADOBERGB:
 565 |                 return "AdobeRGB";
 566 |             case V4L2_COLORSPACE_DCI_P3:
 567 |                 return "DCI-P3";
 568 |             case V4L2_COLORSPACE_BT2020:
 569 |                 return "BT.2020";
 570 |             case V4L2_COLORSPACE_RAW:
 571 |                 return "Raw";
 572 |             default:
 573 |                 return "Unknown (" + num2s(val) + ")";
 574 |         }
 575 |     }
 576 | 
 577 |     static std::string xfer_func2s(int val) {
 578 |         switch (val) {
 579 |             case V4L2_XFER_FUNC_DEFAULT:
 580 |                 return "Default";
 581 |             case V4L2_XFER_FUNC_709:
 582 |                 return "Rec. 709";
 583 |             case V4L2_XFER_FUNC_SRGB:
 584 |                 return "sRGB";
 585 |             case V4L2_XFER_FUNC_ADOBERGB:
 586 |                 return "AdobeRGB";
 587 |             case V4L2_XFER_FUNC_DCI_P3:
 588 |                 return "DCI-P3";
 589 |             case V4L2_XFER_FUNC_SMPTE2084:
 590 |                 return "SMPTE 2084";
 591 |             case V4L2_XFER_FUNC_SMPTE240M:
 592 |                 return "SMPTE 240M";
 593 |             case V4L2_XFER_FUNC_NONE:
 594 |                 return "None";
 595 |             default:
 596 |                 return "Unknown (" + num2s(val) + ")";
 597 |         }
 598 |     }
 599 | 
 600 |     static std::string ycbcr_enc2s(int val) {
 601 |         switch (val) {
 602 |             case V4L2_YCBCR_ENC_DEFAULT:
 603 |                 return "Default";
 604 |             case V4L2_YCBCR_ENC_601:
 605 |                 return "ITU-R 601";
 606 |             case V4L2_YCBCR_ENC_709:
 607 |                 return "Rec. 709";
 608 |             case V4L2_YCBCR_ENC_XV601:
 609 |                 return "xvYCC 601";
 610 |             case V4L2_YCBCR_ENC_XV709:
 611 |                 return "xvYCC 709";
 612 |             case V4L2_YCBCR_ENC_SYCC:
 613 |                 return "sYCC";
 614 |             case V4L2_YCBCR_ENC_BT2020:
 615 |                 return "BT.2020";
 616 |             case V4L2_YCBCR_ENC_BT2020_CONST_LUM:
 617 |                 return "BT.2020 Constant Luminance";
 618 |             case V4L2_YCBCR_ENC_SMPTE240M:
 619 |                 return "SMPTE 240M";
 620 |             default:
 621 |                 return "Unknown (" + num2s(val) + ")";
 622 |         }
 623 |     }
 624 | 
 625 |     static std::string quantization2s(int val) {
 626 |         switch (val) {
 627 |             case V4L2_QUANTIZATION_DEFAULT:
 628 |                 return "Default";
 629 |             case V4L2_QUANTIZATION_FULL_RANGE:
 630 |                 return "Full Range";
 631 |             case V4L2_QUANTIZATION_LIM_RANGE:
 632 |                 return "Limited Range";
 633 |             default:
 634 |                 return "Unknown (" + num2s(val) + ")";
 635 |         }
 636 |     }
 637 | 
 638 |     std::string flags2s(unsigned val, const flag_def *def) {
 639 |         std::string s;
 640 | 
 641 |         while (def->flag) {
 642 |             if (val & def->flag) {
 643 |                 if (s.length()) s += ", ";
 644 |                 s += def->str;
 645 |                 val &= ~def->flag;
 646 |             }
 647 |             def++;
 648 |         }
 649 |         if (val) {
 650 |             if (s.length()) s += ", ";
 651 |             s += num2s(val);
 652 |         }
 653 |         return s;
 654 |     }
 655 | 
 656 |     static const flag_def pixflags_def[] = {
 657 |             {V4L2_PIX_FMT_FLAG_PREMUL_ALPHA, "premultiplied-alpha"},
 658 |             {0, NULL}
 659 |     };
 660 | 
 661 |     std::string pixflags2s(unsigned flags) {
 662 |         return flags2s(flags, pixflags_def);
 663 |     }
 664 | 
 665 |     std::string service2s(unsigned service) {
 666 |         return flags2s(service, service_def);
 667 |     }
 668 | 
 669 |     void printv4l2_fmt(const struct v4l2_format &vfmt) {
 670 |         const flag_def vbi_def[] = {
 671 |                 {V4L2_VBI_UNSYNC,     "unsynchronized"},
 672 |                 {V4L2_VBI_INTERLACED, "interlaced"},
 673 |                 {0, NULL}
 674 |         };
 675 |         printf("Format %s:\n", buftype2s(vfmt.type).c_str());
 676 | 
 677 |         switch (vfmt.type) {
 678 |             case V4L2_BUF_TYPE_VIDEO_CAPTURE:
 679 |             case V4L2_BUF_TYPE_VIDEO_OUTPUT:
 680 |                 printf("\tWidth/Height      : %u/%u\n", vfmt.fmt.pix.width, vfmt.fmt.pix.height);
 681 |                 printf("\tPixel Format      : '%s'\n", fcc2s(vfmt.fmt.pix.pixelformat).c_str());
 682 |                 printf("\tField             : %s\n", field2s(vfmt.fmt.pix.field).c_str());
 683 |                 printf("\tBytes per Line    : %u\n", vfmt.fmt.pix.bytesperline);
 684 |                 printf("\tSize Image        : %u\n", vfmt.fmt.pix.sizeimage);
 685 |                 printf("\tColorspace        : %s\n", colorspace2s(vfmt.fmt.pix.colorspace).c_str());
 686 |                 printf("\tTransfer Function : %s\n", xfer_func2s(vfmt.fmt.pix.xfer_func).c_str());
 687 |                 printf("\tYCbCr Encoding    : %s\n", ycbcr_enc2s(vfmt.fmt.pix.ycbcr_enc).c_str());
 688 |                 printf("\tQuantization      : %s\n", quantization2s(vfmt.fmt.pix.quantization).c_str());
 689 |                 if (vfmt.fmt.pix.priv == V4L2_PIX_FMT_PRIV_MAGIC)
 690 |                     printf("\tFlags             : %s\n", pixflags2s(vfmt.fmt.pix.flags).c_str());
 691 |                 break;
 692 |             case V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE:
 693 |             case V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE:
 694 |                 printf("\tWidth/Height      : %u/%u\n", vfmt.fmt.pix_mp.width, vfmt.fmt.pix_mp.height);
 695 |                 printf("\tPixel Format      : '%s'\n", fcc2s(vfmt.fmt.pix_mp.pixelformat).c_str());
 696 |                 printf("\tField             : %s\n", field2s(vfmt.fmt.pix_mp.field).c_str());
 697 |                 printf("\tNumber of planes  : %u\n", vfmt.fmt.pix_mp.num_planes);
 698 |                 printf("\tFlags             : %s\n", pixflags2s(vfmt.fmt.pix_mp.flags).c_str());
 699 |                 printf("\tColorspace        : %s\n", colorspace2s(vfmt.fmt.pix_mp.colorspace).c_str());
 700 |                 printf("\tTransfer Function : %s\n", xfer_func2s(vfmt.fmt.pix_mp.xfer_func).c_str());
 701 |                 printf("\tYCbCr Encoding    : %s\n", ycbcr_enc2s(vfmt.fmt.pix_mp.ycbcr_enc).c_str());
 702 |                 printf("\tQuantization      : %s\n", quantization2s(vfmt.fmt.pix_mp.quantization).c_str());
 703 |                 for (int i = 0; i < vfmt.fmt.pix_mp.num_planes && i < VIDEO_MAX_PLANES; i++) {
 704 |                     printf("\tPlane %d           :\n", i);
 705 |                     printf("\t   Bytes per Line : %u\n", vfmt.fmt.pix_mp.plane_fmt[i].bytesperline);
 706 |                     printf("\t   Size Image     : %u\n", vfmt.fmt.pix_mp.plane_fmt[i].sizeimage);
 707 |                 }
 708 |                 break;
 709 |             case V4L2_BUF_TYPE_VIDEO_OUTPUT_OVERLAY:
 710 |             case V4L2_BUF_TYPE_VIDEO_OVERLAY:
 711 |                 printf("\tLeft/Top    : %d/%d\n",
 712 |                        vfmt.fmt.win.w.left, vfmt.fmt.win.w.top);
 713 |                 printf("\tWidth/Height: %d/%d\n",
 714 |                        vfmt.fmt.win.w.width, vfmt.fmt.win.w.height);
 715 |                 printf("\tField       : %s\n", field2s(vfmt.fmt.win.field).c_str());
 716 |                 printf("\tChroma Key  : 0x%08x\n", vfmt.fmt.win.chromakey);
 717 |                 printf("\tGlobal Alpha: 0x%02x\n", vfmt.fmt.win.global_alpha);
 718 |                 printf("\tClip Count  : %u\n", vfmt.fmt.win.clipcount);
 719 |                 if (vfmt.fmt.win.clips)
 720 |                     for (unsigned i = 0; i < vfmt.fmt.win.clipcount; i++) {
 721 |                         struct v4l2_rect &r = vfmt.fmt.win.clips[i].c;
 722 | 
 723 |                         printf("\t\tClip %2d: %ux%u@%ux%u\n", i,
 724 |                                r.width, r.height, r.left, r.top);
 725 |                     }
 726 |                 printf("\tClip Bitmap : %s", vfmt.fmt.win.bitmap ? "Yes, " : "No\n");
 727 |                 if (vfmt.fmt.win.bitmap) {
 728 |                     unsigned char *bitmap = (unsigned char *) vfmt.fmt.win.bitmap;
 729 |                     unsigned stride = (vfmt.fmt.win.w.width + 7) / 8;
 730 |                     unsigned cnt = 0;
 731 | 
 732 |                     for (unsigned y = 0; y < vfmt.fmt.win.w.height; y++)
 733 |                         for (unsigned x = 0; x < vfmt.fmt.win.w.width; x++)
 734 |                             if (bitmap[y * stride + x / 8] & (1 << (x & 7)))
 735 |                                 cnt++;
 736 |                     printf("%u bits of %u are set\n", cnt,
 737 |                            vfmt.fmt.win.w.width * vfmt.fmt.win.w.height);
 738 |                 }
 739 |                 break;
 740 |             case V4L2_BUF_TYPE_VBI_CAPTURE:
 741 |             case V4L2_BUF_TYPE_VBI_OUTPUT:
 742 |                 printf("\tSampling Rate   : %u Hz\n", vfmt.fmt.vbi.sampling_rate);
 743 |                 printf("\tOffset          : %u samples (%g secs after leading edge)\n",
 744 |                        vfmt.fmt.vbi.offset,
 745 |                        (double) vfmt.fmt.vbi.offset / (double) vfmt.fmt.vbi.sampling_rate);
 746 |                 printf("\tSamples per Line: %u\n", vfmt.fmt.vbi.samples_per_line);
 747 |                 printf("\tSample Format   : %s\n", fcc2s(vfmt.fmt.vbi.sample_format).c_str());
 748 |                 printf("\tStart 1st Field : %u\n", vfmt.fmt.vbi.start[0]);
 749 |                 printf("\tCount 1st Field : %u\n", vfmt.fmt.vbi.count[0]);
 750 |                 printf("\tStart 2nd Field : %u\n", vfmt.fmt.vbi.start[1]);
 751 |                 printf("\tCount 2nd Field : %u\n", vfmt.fmt.vbi.count[1]);
 752 |                 if (vfmt.fmt.vbi.flags)
 753 |                     printf("\tFlags           : %s\n", flags2s(vfmt.fmt.vbi.flags, vbi_def).c_str());
 754 |                 break;
 755 |             case V4L2_BUF_TYPE_SLICED_VBI_CAPTURE:
 756 |             case V4L2_BUF_TYPE_SLICED_VBI_OUTPUT:
 757 |                 printf("\tService Set    : %s\n",
 758 |                        service2s(vfmt.fmt.sliced.service_set).c_str());
 759 |                 for (int i = 0; i < 24; i++) {
 760 |                     printf("\tService Line %2d: %8s / %-8s\n", i,
 761 |                            service2s(vfmt.fmt.sliced.service_lines[0][i]).c_str(),
 762 |                            service2s(vfmt.fmt.sliced.service_lines[1][i]).c_str());
 763 |                 }
 764 |                 printf("\tI/O Size       : %u\n", vfmt.fmt.sliced.io_size);
 765 |                 break;
 766 |             case V4L2_BUF_TYPE_SDR_CAPTURE:
 767 |             case V4L2_BUF_TYPE_SDR_OUTPUT:
 768 |                 printf("\tSample Format   : %s\n", fcc2s(vfmt.fmt.sdr.pixelformat).c_str());
 769 |                 printf("\tBuffer Size     : %u\n", vfmt.fmt.sdr.buffersize);
 770 |                 break;
 771 |         }
 772 |     }
 773 | 
 774 |     ///////////////////////////////////////////////////////////////////////////////
 775 |     ///////////////////////////////////////////////////////////////////////////////
 776 |     ///////////////////////////////////////////////////////////////////////////////
 777 | 
 778 |     static std::string fract2sec(const struct v4l2_fract &f)
 779 |     {
 780 |         char buf[100];
 781 | 
 782 |         sprintf(buf, "%.3f", (1.0 * f.numerator) / f.denominator);
 783 |         return buf;
 784 |     }
 785 | 
 786 |     static std::string fract2fps(const struct v4l2_fract &f)
 787 |     {
 788 |         char buf[100];
 789 | 
 790 |         sprintf(buf, "%.3f", (1.0 * f.denominator) / f.numerator);
 791 |         return buf;
 792 |     }
 793 | 
 794 |     static std::string frmtype2s(unsigned type)
 795 |     {
 796 |         static const char *types[] = {
 797 |                 "Unknown",
 798 |                 "Discrete",
 799 |                 "Continuous",
 800 |                 "Stepwise"
 801 |         };
 802 | 
 803 |         if (type > 3)
 804 |             type = 0;
 805 |         return types[type];
 806 |     }
 807 | 
 808 |     static void print_frmival(const struct v4l2_frmivalenum &frmival, const char *prefix)
 809 |     {
 810 |         printf("%s\tInterval: %s ", prefix, frmtype2s(frmival.type).c_str());
 811 |         if (frmival.type == V4L2_FRMIVAL_TYPE_DISCRETE) {
 812 |             printf("%ss (%s fps)\n", fract2sec(frmival.discrete).c_str(),
 813 |                    fract2fps(frmival.discrete).c_str());
 814 |         } else if (frmival.type == V4L2_FRMIVAL_TYPE_CONTINUOUS) {
 815 |             printf("%ss - %ss (%s-%s fps)\n",
 816 |                    fract2sec(frmival.stepwise.min).c_str(),
 817 |                    fract2sec(frmival.stepwise.max).c_str(),
 818 |                    fract2fps(frmival.stepwise.max).c_str(),
 819 |                    fract2fps(frmival.stepwise.min).c_str());
 820 |         } else if (frmival.type == V4L2_FRMIVAL_TYPE_STEPWISE) {
 821 |             printf("%ss - %ss with step %ss (%s-%s fps)\n",
 822 |                    fract2sec(frmival.stepwise.min).c_str(),
 823 |                    fract2sec(frmival.stepwise.max).c_str(),
 824 |                    fract2sec(frmival.stepwise.step).c_str(),
 825 |                    fract2fps(frmival.stepwise.max).c_str(),
 826 |                    fract2fps(frmival.stepwise.min).c_str());
 827 |         }
 828 |     }
 829 | 
 830 |     static void print_frmsize(const struct v4l2_frmsizeenum &frmsize, const char *prefix)
 831 |     {
 832 |         printf("%s\tSize: %s ", prefix, frmtype2s(frmsize.type).c_str());
 833 |         if (frmsize.type == V4L2_FRMSIZE_TYPE_DISCRETE) {
 834 |             printf("%dx%d", frmsize.discrete.width, frmsize.discrete.height);
 835 |         } else if (frmsize.type == V4L2_FRMSIZE_TYPE_STEPWISE) {
 836 |             printf("%dx%d - %dx%d with step %d/%d",
 837 |                    frmsize.stepwise.min_width,
 838 |                    frmsize.stepwise.min_height,
 839 |                    frmsize.stepwise.max_width,
 840 |                    frmsize.stepwise.max_height,
 841 |                    frmsize.stepwise.step_width,
 842 |                    frmsize.stepwise.step_height);
 843 |         }
 844 |         printf("\n");
 845 |     }
 846 | 
 847 |     static const flag_def fmtdesc_def[] = {
 848 |             { V4L2_FMT_FLAG_COMPRESSED, "compressed" },
 849 |             { V4L2_FMT_FLAG_EMULATED, "emulated" },
 850 |             { 0, NULL }
 851 |     };
 852 | 
 853 |     std::string fmtdesc2s(unsigned flags)
 854 |     {
 855 |         return flags2s(flags, fmtdesc_def);
 856 |     }
 857 | 
 858 |     static void print_video_formats_ext(int fd, __u32 type)
 859 |     {
 860 |         struct v4l2_fmtdesc fmt;
 861 |         struct v4l2_frmsizeenum frmsize;
 862 |         struct v4l2_frmivalenum frmival;
 863 | 
 864 |         fmt.index = 0;
 865 |         fmt.type = type;
 866 |         while (xioctl(fd, VIDIOC_ENUM_FMT, &fmt) >= 0) {
 867 |             printf("\tIndex       : %d\n", fmt.index);
 868 |             printf("\tType        : %s\n", buftype2s(type).c_str());
 869 |             printf("\tPixel Format: '%s'", fcc2s(fmt.pixelformat).c_str());
 870 |             if (fmt.flags)
 871 |                 printf(" (%s)", fmtdesc2s(fmt.flags).c_str());
 872 |             printf("\n");
 873 |             printf("\tName        : %s\n", fmt.description);
 874 |             frmsize.pixel_format = fmt.pixelformat;
 875 |             frmsize.index = 0;
 876 |             while (xioctl(fd, VIDIOC_ENUM_FRAMESIZES, &frmsize) >= 0) {
 877 |                 print_frmsize(frmsize, "\t");
 878 |                 if (frmsize.type == V4L2_FRMSIZE_TYPE_DISCRETE) {
 879 |                     frmival.index = 0;
 880 |                     frmival.pixel_format = fmt.pixelformat;
 881 |                     frmival.width = frmsize.discrete.width;
 882 |                     frmival.height = frmsize.discrete.height;
 883 |                     while (xioctl(fd, VIDIOC_ENUM_FRAMEINTERVALS, &frmival) >= 0) {
 884 |                         print_frmival(frmival, "\t\t");
 885 |                         frmival.index++;
 886 |                     }
 887 |                 }
 888 |                 frmsize.index++;
 889 |             }
 890 |             printf("\n");
 891 |             fmt.index++;
 892 |         }
 893 |     }
 894 | 
 895 |     ///////////////////////////////////////////////////////////////////////////////
 896 |     ///////////////////////////////////////////////////////////////////////////////
 897 |     ///////////////////////////////////////////////////////////////////////////////
 898 | 
 899 | 
 900 |     static void print_fmt_desc(v4l2_fmtdesc fmt){
 901 |         printf("\tIndex       : %d\n", fmt.index);
 902 |         printf("\tType        : %s\n", buftype2s(V4L2_BUF_TYPE_VIDEO_CAPTURE).c_str());
 903 |         printf("\tPixel Format: '%s'", fcc2s(fmt.pixelformat).c_str());
 904 |         if (fmt.flags)
 905 |             printf(" (%s)", fmtdesc2s(fmt.flags).c_str());
 906 |         printf("\n");
 907 |         printf("\tName        : %s\n", fmt.description);
 908 |     }
 909 | 
 910 | 
 911 | 
 912 | 
 913 | 
 914 | 
 915 | 
 916 | 
 917 |     ///////////////////////////////////////////////////////////////////////////////
 918 |     ///////////////////////////////////////////////////////////////////////////////
 919 |     ///////////////////////////////////////////////////////////////////////////////
 920 | 
 921 |     void
 922 |     raw_to_rgb(void *inBuff, int inBuffSize, void *outBuff, int outBuffSize, uint32_t numOfPixels, int bitPerPixel) {
 923 |         auto dst = static_cast<uint8_t *>(outBuff);
 924 | 
 925 |         auto shift = bitPerPixel - 8;  //i.e. 10bit - 8bit(1 byte) = 2, 12bit - 8bit = 4
 926 | 
 927 |         auto tmp = static_cast<uint16_t *>(inBuff);
 928 |         for (auto i = 0u; i < numOfPixels; i++) {
 929 |             uint16_t temp = (*tmp++) >> shift; //12 bit shift 4, 10bit shift 2
 930 |             *dst++ = static_cast<uint8_t>(temp);
 931 |             *dst++ = static_cast<uint8_t>(temp);
 932 |             *dst++ = static_cast<uint8_t>(temp);
 933 |         }
 934 |     }
 935 | 
 936 |     ///////////////////////////////////////////////////////////////////////////////
 937 |     ///////////////////////////////////////////////////////////////////////////////
 938 |     ///////////////////////////////////////////////////////////////////////////////
 939 | 
 940 |     static void process_image(const void *p, int size) {
 941 |         static uint32_t frame_number = 0;
 942 |         frame_number++;
 943 | 
 944 |         char filename[15];
 945 | 
 946 |         //std::cerr << size << "\n";
 947 | //        sprintf(filename, "frame-%d.ppm", frame_number);
 948 | //        FILE *fp=fopen(filename,"wb");
 949 | 
 950 |         uint8_t outBuff[921600];
 951 |         raw_to_rgb(const_cast<void *>(p), 0, outBuff, 921600, 640 * 480, 8);
 952 | 
 953 | //        fprintf(fp, "P6\n%d %d 255\n",
 954 | //                640, 480);
 955 | 
 956 |         bool enable_stdout = true;
 957 |         if (enable_stdout) {
 958 |             //fwrite(outBuff, 921600, 1, fp);
 959 |             fwrite(outBuff, 921600, 1, stdout);
 960 |         }
 961 | 
 962 | 
 963 | //        fflush(fp);
 964 | //        fclose(fp);
 965 |     }
 966 | 
 967 |     ///////////////////////////////////////////////////////////////////////////////
 968 |     ///////////////////////////////////////////////////////////////////////////////
 969 |     ///////////////////////////////////////////////////////////////////////////////
 970 | 
 971 |     static int
 972 |     read_frame(int fd, util_v4l2::buffer *pBuffer, std::function<void(uint8_t *p_data, size_t len)> callback,
 973 |                error_code *err) {
 974 |         SET_ERR_CODE(err, error_code::ERR_NO_ERROR);
 975 |         int numOfBytes = 0;
 976 | 
 977 |         struct v4l2_buffer buf;
 978 |         UTIL_CLEAR(buf);
 979 | 
 980 |         buf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
 981 |         buf.memory = V4L2_MEMORY_MMAP;
 982 | 
 983 |         if (-1 == util_v4l2::xioctl(fd, VIDIOC_DQBUF, &buf)) {
 984 |             SET_ERR_CODE(err, error_code::ERR_READ_FRAME);
 985 |             switch (errno) {
 986 |                 case EAGAIN:
 987 |                     // (try again)
 988 |                     return 0;
 989 | 
 990 |                 case EIO:
 991 |                     // I/O error
 992 |                     /* fall through */
 993 | 
 994 |                 default:
 995 |                     std::cerr << "ERROR: read_frame VIDIOC_DQBUF\n";
 996 |                     return -1;
 997 |                     break;
 998 | 
 999 |             }
1000 |         }
1001 | 
1002 |         assert(buf.index < 4);
1003 | 
1004 |         callback((uint8_t *) pBuffer[buf.index].start, buf.bytesused);
1005 | 
1006 |         if (-1 == util_v4l2::xioctl(fd, VIDIOC_QBUF, &buf)) {
1007 |             std::cerr << "ERROR: read_frame VIDIOC_DQBUF\n";
1008 |             SET_ERR_CODE(err, error_code::ERR_READ_FRAME);
1009 |             return -1;
1010 |         }
1011 | 
1012 |         numOfBytes = buf.bytesused;
1013 |         return numOfBytes;
1014 |     }
1015 | 
1016 |     ///////////////////////////////////////////////////////////////////////////////
1017 |     ///////////////////////////////////////////////////////////////////////////////
1018 |     ///////////////////////////////////////////////////////////////////////////////
1019 | 
1020 |     static void
1021 |     mainloop(int fd, util_v4l2::buffer *pBuffer, std::function<void(uint8_t *p_data, size_t len)> callback,
1022 |              error_code *err) {
1023 | 
1024 | //        int num_of_frames = 200;
1025 | 
1026 |         for (;;) {
1027 | //            if(num_of_frames < 0)
1028 | //                return;
1029 | 
1030 | //            std::cerr << num_of_frames <<"  \n";
1031 | //            num_of_frames--;
1032 | 
1033 |             fd_set fds;
1034 |             struct timeval tv;
1035 |             int r;
1036 | 
1037 |             FD_ZERO(&fds);
1038 |             FD_SET(fd, &fds);
1039 | 
1040 |             /* Timeout. */
1041 |             tv.tv_sec = 5;
1042 |             tv.tv_usec = 0;
1043 | 
1044 | //            On success, select() return the number of file
1045 | //            descriptors contained in the three returned descriptor sets (that is,
1046 | //                    the total number of bits that are set in readfds, writefds,
1047 | //            exceptfds) which may be zero if the timeout expires before anything
1048 | //            interesting happens.  On error, -1 is returned, and errno is set to
1049 | //            indicate the error; the file descriptor sets are unmodified, and
1050 | //            timeout becomes undefined.
1051 |             r = select(fd + 1, &fds, NULL, NULL, &tv);
1052 | 
1053 |             if (-1 == r) {
1054 |                 if (EINTR == errno) {
1055 |                     continue;
1056 |                 }
1057 | 
1058 |                 SET_ERR_CODE(err, error_code::ERR_SELECT);
1059 |                 return;
1060 |             }
1061 | 
1062 |             if (0 == r) {
1063 |                 std::cerr << "ERROR: select timeout\n";
1064 |                 SET_ERR_CODE(err, error_code::ERR_SELECT_TIMEOUT);
1065 |             }
1066 | 
1067 |             if (read_frame(fd, pBuffer, callback,err) == -1) {
1068 |                 SET_ERR_CODE(err, error_code::ERR_READ_FRAME);
1069 |                 // exit loop
1070 |                 return;
1071 |             }
1072 | 
1073 |             /* EAGAIN (try again) - continue select loop. */
1074 |         }
1075 |     }
1076 | 
1077 | }// namespace util_v4l2
1078 | 


--------------------------------------------------------------------------------