← Back to branch summary

~ubuntu-branches/ubuntu/oneiric/v4l-utils/oneiric

« back to all changes in this revision

Viewing changes to utils/v4l2-compliance/v4l2-compliance.cpp

  • Committer: Bazaar Package Importer
  • Author(s): Martin Pitt
  • Date: 2011-07-22 13:58:48 UTC
  • mfrom: (11.1.2 sid)
  • Revision ID: james.westby@ubuntu.com-20110722135848-tju3x5jlpa4e9by5
Tags: 0.8.5-1ubuntu1
debian/control: Drop ia32-libs-dev build dependency; we don't have this in
Ubuntu, and ia32-libs is in universe.

Show diffs side-by-side

added added

removed removed

Lines of Context:
utils/v4l2-compliance/v4l2-compliance.cpp
159
159
        return s;
160
160
}
161
161
 
 
162
std::string buftype2s(int type)
 
163
{
 
164
        switch (type) {
 
165
        case V4L2_BUF_TYPE_VIDEO_CAPTURE:
 
166
                return "Video Capture";
 
167
        case V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE:
 
168
                return "Video Capture Multiplanar";
 
169
        case V4L2_BUF_TYPE_VIDEO_OUTPUT:
 
170
                return "Video Output";
 
171
        case V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE:
 
172
                return "Video Output Multiplanar";
 
173
        case V4L2_BUF_TYPE_VIDEO_OVERLAY:
 
174
                return "Video Overlay";
 
175
        case V4L2_BUF_TYPE_VBI_CAPTURE:
 
176
                return "VBI Capture";
 
177
        case V4L2_BUF_TYPE_VBI_OUTPUT:
 
178
                return "VBI Output";
 
179
        case V4L2_BUF_TYPE_SLICED_VBI_CAPTURE:
 
180
                return "Sliced VBI Capture";
 
181
        case V4L2_BUF_TYPE_SLICED_VBI_OUTPUT:
 
182
                return "Sliced VBI Output";
 
183
        case V4L2_BUF_TYPE_VIDEO_OUTPUT_OVERLAY:
 
184
                return "Video Output Overlay";
 
185
        case V4L2_BUF_TYPE_PRIVATE:
 
186
                return "Private";
 
187
        default:
 
188
                return std::string("Unknown");
 
189
        }
 
190
}
 
191
 
162
192
const char *ok(int res)
163
193
{
164
194
        static char buf[100];
210
240
        struct v4l2_capability vcap;
211
241
        __u32 caps;
212
242
 
213
 
        if (doioctl(node, VIDIOC_QUERYCAP, &vcap))
214
 
                return fail("VIDIOC_QUERYCAP not implemented\n");
215
 
        if (check_ustring(vcap.driver, sizeof(vcap.driver)))
216
 
                return fail("invalid driver name\n");
217
 
        if (check_ustring(vcap.card, sizeof(vcap.card)))
218
 
                return fail("invalid card name\n");
 
243
        // Must always be there
 
244
        fail_on_test(doioctl(node, VIDIOC_QUERYCAP, &vcap));
 
245
        fail_on_test(check_ustring(vcap.driver, sizeof(vcap.driver)));
 
246
        fail_on_test(check_ustring(vcap.card, sizeof(vcap.card)));
219
247
        if (check_ustring(vcap.bus_info, sizeof(vcap.bus_info))) {
220
 
                if (vcap.bus_info[0])
221
 
                        return fail("invalid bus_info\n");
222
 
                else
223
 
                        warn("VIDIOC_QUERYCAP: empty bus_info\n");
 
248
                fail_on_test(vcap.bus_info[0]);
 
249
                warn("VIDIOC_QUERYCAP: empty bus_info\n");
224
250
        }
225
 
        if (check_0(vcap.reserved, sizeof(vcap.reserved)))
226
 
                return fail("non-zero reserved fields\n");
 
251
        fail_on_test(check_0(vcap.reserved, sizeof(vcap.reserved)));
227
252
        caps = vcap.capabilities;
228
 
        if (caps == 0)
229
 
                return fail("no capabilities set\n");
230
 
        if (node->is_video && !(caps & (V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_VIDEO_OUTPUT |
231
 
                                        V4L2_CAP_VIDEO_OVERLAY | V4L2_CAP_VIDEO_OUTPUT_OVERLAY)))
232
 
                return fail("video node without the relevant capabilities\n");
233
 
        if (node->is_radio && !(caps & (V4L2_CAP_RADIO | V4L2_CAP_MODULATOR)))
234
 
                return fail("radio node without the relevant capabilities\n");
235
 
        if (node->is_radio && (caps & V4L2_CAP_AUDIO))
236
 
                return fail("radio node cannot have CAP_AUDIO set\n");
237
 
        if (node->is_vbi && !(caps & (V4L2_CAP_VBI_CAPTURE | V4L2_CAP_SLICED_VBI_CAPTURE |
238
 
                                      V4L2_CAP_VBI_OUTPUT | V4L2_CAP_SLICED_VBI_OUTPUT)))
239
 
                return fail("vbi node without the relevant capabilities\n");
 
253
        fail_on_test(vcap.capabilities == 0);
 
254
        fail_on_test(node->is_video && !(caps & (V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_VIDEO_OUTPUT |
 
255
                                        V4L2_CAP_VIDEO_OVERLAY | V4L2_CAP_VIDEO_OUTPUT_OVERLAY)));
 
256
        fail_on_test(node->is_radio && !(caps & (V4L2_CAP_RADIO | V4L2_CAP_MODULATOR)));
 
257
        // V4L2_CAP_AUDIO is invalid for radio
 
258
        fail_on_test(node->is_radio && (caps & V4L2_CAP_AUDIO));
 
259
        fail_on_test(node->is_vbi && !(caps & (V4L2_CAP_VBI_CAPTURE | V4L2_CAP_SLICED_VBI_CAPTURE |
 
260
                                      V4L2_CAP_VBI_OUTPUT | V4L2_CAP_SLICED_VBI_OUTPUT)));
 
261
        // You can't have both set due to missing buffer type in VIDIOC_G/S_FBUF
 
262
        fail_on_test((caps & (V4L2_CAP_VIDEO_OVERLAY | V4L2_CAP_VIDEO_OUTPUT_OVERLAY)) ==
 
263
                        (V4L2_CAP_VIDEO_OVERLAY | V4L2_CAP_VIDEO_OUTPUT_OVERLAY));
 
264
 
240
265
        return 0;
241
266
}
242
267
 
243
268
static int check_prio(struct node *node, struct node *node2, enum v4l2_priority match)
244
269
{
245
270
        enum v4l2_priority prio;
246
 
        int err;
247
271
 
248
 
        err = doioctl(node, VIDIOC_G_PRIORITY, &prio);
249
 
        if (err)
250
 
                return fail("VIDIOC_G_PRIORITY failed\n");
251
 
        if (prio != match)
252
 
                return fail("wrong priority returned (%d, expected %d)\n", prio, match);
253
 
        if (doioctl(node2, VIDIOC_G_PRIORITY, &prio))
254
 
                return fail("second VIDIOC_G_PRIORITY failed\n");
255
 
        if (prio != match)
256
 
                return fail("wrong priority returned on second fh (%d, expected %d)\n", prio, match);
 
272
        // Must be able to get priority
 
273
        fail_on_test(doioctl(node, VIDIOC_G_PRIORITY, &prio));
 
274
        // Must match the expected prio
 
275
        fail_on_test(prio != match);
 
276
        fail_on_test(doioctl(node2, VIDIOC_G_PRIORITY, &prio));
 
277
        fail_on_test(prio != match);
257
278
        return 0;
258
279
}
259
280
 
267
288
                return err;
268
289
 
269
290
        prio = V4L2_PRIORITY_RECORD;
270
 
        if (doioctl(node, VIDIOC_S_PRIORITY, &prio))
271
 
                return fail("VIDIOC_S_PRIORITY RECORD failed\n");
272
 
        if (check_prio(node, node2, V4L2_PRIORITY_RECORD))
273
 
                return fail("expected priority RECORD");
 
291
        // Must be able to change priority
 
292
        fail_on_test(doioctl(node, VIDIOC_S_PRIORITY, &prio));
 
293
        // Must match the new prio
 
294
        fail_on_test(check_prio(node, node2, V4L2_PRIORITY_RECORD));
274
295
 
275
296
        prio = V4L2_PRIORITY_INTERACTIVE;
276
 
        if (!doioctl(node2, VIDIOC_S_PRIORITY, &prio))
277
 
                return fail("Can lower prio on second filehandle\n");
 
297
        // Going back to interactive on the other node must fail
 
298
        fail_on_test(!doioctl(node2, VIDIOC_S_PRIORITY, &prio));
278
299
        prio = V4L2_PRIORITY_INTERACTIVE;
279
 
        if (doioctl(node, VIDIOC_S_PRIORITY, &prio))
280
 
                return fail("Could not lower prio\n");
281
 
        if (check_prio(node, node2, V4L2_PRIORITY_INTERACTIVE))
282
 
                return fail("expected priority INTERACTIVE");
 
300
        // Changing it on the first node must work.
 
301
        fail_on_test(doioctl(node, VIDIOC_S_PRIORITY, &prio));
 
302
        fail_on_test(check_prio(node, node2, V4L2_PRIORITY_INTERACTIVE));
283
303
        return 0;
284
304
}
285
305
 
417
437
                node.fd = radio_node.fd;
418
438
                device = radio_device;
419
439
                node.is_radio = true;
 
440
                printf("is radio\n");
420
441
        } else if (vbi_node.fd >= 0) {
421
442
                node.fd = vbi_node.fd;
422
443
                device = vbi_device;
547
568
        printf("\ttest VIDIOC_G/S_DV_TIMINGS: %s\n", ok(testCustomTimings(&node)));
548
569
        printf("\n");
549
570
 
 
571
        /* Format ioctls */
 
572
 
 
573
        printf("Format ioctls:\n");
 
574
        printf("\ttest VIDIOC_ENUM_FMT/FRAMESIZES/FRAMEINTERVALS: %s\n", ok(testEnumFormats(&node)));
 
575
        printf("\ttest VIDIOC_G_FBUF: %s\n", ok(testFBuf(&node)));
 
576
        printf("\ttest VIDIOC_G_FMT: %s\n", ok(testFormats(&node)));
 
577
        printf("\ttest VIDIOC_G_SLICED_VBI_CAP: %s\n", ok(testSlicedVBICap(&node)));
 
578
 
550
579
        /* TODO:
551
580
 
552
581
           VIDIOC_CROPCAP, VIDIOC_G/S_CROP
553
 
           VIDIOC_ENUM_FMT/FRAMESIZES/FRAMEINTERVALS
554
 
           VIDIOC_G/S_FBUF/OVERLAY
555
 
           VIDIOC_G/S/TRY_FMT
 
582
           VIDIOC_S_FBUF/OVERLAY
 
583
           VIDIOC_S/TRY_FMT
556
584
           VIDIOC_G/S_PARM
557
585
           VIDIOC_G/S_JPEGCOMP
558
 
           VIDIOC_SLICED_VBI_CAP
559
586
           VIDIOC_S_HW_FREQ_SEEK
560
587
           VIDIOC_SUBSCRIBE_EVENT/UNSUBSCRIBE_EVENT/DQEVENT
561
588
           VIDIOC_(TRY_)ENCODER_CMD