Context Navigation

MVideo.cc

Visit:

Last change on this file was 18618, checked in by tbretz, 8 years ago
Copied files from Mars and Cosy to compile toold which fit our current drivectrl.
File size: 31.7 KB

Line
1	/* ======================================================================== *\
2	!
3	! *
4	! * This file is part of MARS, the MAGIC Analysis and Reconstruction
5	! * Software. It is distributed to you in the hope that it can be a useful
6	! * and timesaving tool in analysing Data of imaging Cerenkov telescopes.
7	! * It is distributed WITHOUT ANY WARRANTY.
8	! *
9	! * Permission to use, copy, modify and distribute this software and its
10	! * documentation for any purpose is hereby granted without fee,
11	! * provided that the above copyright notice appear in all copies and
12	! * that both that copyright notice and this permission notice appear
13	! * in supporting documentation. It is provided "as is" without express
14	! * or implied warranty.
15	! *
16	!
17	!
18	! Author(s): Thomas Bretz 1/2008 <mailto:thomas.bretz@epfl.ch>
19	!
20	! Copyright: MAGIC Software Development, 2000-2011
21	!
22	!
23	\* ======================================================================== */
24
25	/////////////////////////////////////////////////////////////////////////////
26	//
27	// MVideo
28	//
29	// Interface to Video4Linux at a simple level
30	//
31	// V4L2 spcifications from http://v4l2spec.bytesex.org/spec/
32	//
33	/////////////////////////////////////////////////////////////////////////////
34	#include "MVideo.h"
35
36	// iostream
37	#include <iostream>
38
39	// open
40	#include <sys/types.h>
41	#include <sys/stat.h>
42	#include <fcntl.h>
43
44	#include <unistd.h> // usleep
45	#include <errno.h> // errno
46	#include <sys/mman.h> // mmap
47	#include <sys/ioctl.h> // ioctl
48
49	#include <TEnv.h>
50	#include <TString.h>
51
52	#include "MLog.h"
53	#include "MLogManip.h"
54
55	#undef DEBUG
56
57	using namespace std;
58
59	//ClassImp(MVideo);
60
61	MVideoCtrl::MVideoCtrl(const v4l2_queryctrl &ctrl)
62	{
63	fId = ctrl.id;
64	fName = (const char*)ctrl.name;
65	fMinimum = ctrl.minimum;
66	fMaximum = ctrl.maximum;
67	fStep = ctrl.step;
68	fDefault = ctrl.default_value;
69	}
70
71	// -------------------------------------------------------------
72	//
73	// Constructor. Specify the device (e.g. "/dev/video") to be used
74	//
75	MVideo::MVideo(const char *path) : fPath(path), fFileDesc(-1), fMapBuffer(0)
76	{
77	Reset();
78
79	fControls.SetOwner();
80	}
81
82	// -------------------------------------------------------------
83	//
84	// Internal function to reset the descriptors of the device
85	//
86	void MVideo::Reset()
87	{
88	fInputs.clear();
89	fStandards.clear();
90
91	memset(&fCaps, 0, sizeof(fCaps));
92	memset(&fChannel, 0, sizeof(fChannel));
93	// memset(&fBuffer, 0, sizeof(fBuffer));
94	memset(&fAbil, 0, sizeof(fAbil));
95
96	fFileDesc = -1;
97	fMapBuffer = 0;
98	fChannel.channel = -1;
99	fAbil.tuner = -1;
100
101	fControls.Delete();
102	}
103
104	// -------------------------------------------------------------
105	//
106	// Mapper around ioctl for easier access to the device
107	//
108	int MVideo::Ioctl(int req, void *opt, bool allowirq, bool force) const
109	{
110	if (fFileDesc<0)
111	{
112	gLog << err << "ERROR - Ioctl: Device " << fPath << " not open." << endl;
113	return -1;
114	}
115
116	while (1)
117	{
118	// FIXME: This call is a possible source for a hangup
119	const int rc = ioctl(fFileDesc, req, opt);
120	if (rc==0)
121	return 0;
122
123	if (errno==EINVAL)
124	return 1;
125
126	if (!allowirq && errno==EAGAIN)
127	return -4;
128
129	cout <<"errno="<< errno << endl;
130
131	// errno== 4: Interrupted system call (e.g. by alarm())
132	// errno==16: Device or resource busy
133	if (errno==4 \|\| errno==16)
134	{
135	if (!allowirq && errno==4)
136	return -4;
137
138	gLog << err << "ERROR - MVideo::Ioctl 0x" << hex << req << ": errno=" << dec << errno << " - ";
139	gLog << strerror(errno) << " (rc=" << rc << ")" << endl;
140	usleep(10);
141	continue;
142	}
143
144	if (!force)
145	{
146	gLog << err << "ERROR - MVideo::Ioctl 0x" << hex << req << ": errno=" << dec << errno << " - ";
147	gLog << strerror(errno) << " (rc=" << rc << ")" << endl;
148	}
149	return rc;
150	}
151	return -1;
152	}
153
154	// -------------------------------------------------------------
155	//
156	// Read the capabilities of the device
157	//
158	Bool_t MVideo::GetCapabilities()
159	{
160	return Ioctl(VIDIOCGCAP, &fCaps)!=-1;
161	}
162
163	// -------------------------------------------------------------
164	//
165	// Read the properties of the device
166	//
167	Bool_t MVideo::GetProperties()
168	{
169	return Ioctl(VIDIOCGPICT, &fProp)!=-1;
170	}
171
172	// -------------------------------------------------------------
173	//
174	// Read the video standard
175	//
176	Bool_t MVideo::GetVideoStandard()
177	{
178	return Ioctl(VIDIOC_G_STD, &fVideoStandard)==-1;
179	}
180
181	// -------------------------------------------------------------
182	//
183	// Read the abilities of the tuner
184	//
185	Bool_t MVideo::GetTunerAbilities()
186	{
187	fAbil.tuner = 0; // FIXME?
188	return Ioctl(VIDIOCGTUNER, &fAbil)!=-1;
189	}
190
191	// -------------------------------------------------------------
192	//
193	// Enumerate (get) all controls from the device and store them
194	// as MVideoCtrl in fControls, starting with the id given as
195	// argument.
196	//
197	Bool_t MVideo::EnumerateControls(UInt_t id)
198	{
199	struct v4l2_queryctrl qctrl;
200	memset(&qctrl, 0, sizeof(qctrl));
201	qctrl.id = id;
202
203	while (1)
204	{
205	if (Ioctl(VIDIOC_QUERYCTRL, &qctrl, true, true)==-1)
206	break;
207
208	if (qctrl.maximum<=qctrl.minimum)
209	continue;
210
211	fControls.Add(new MVideoCtrl(qctrl));
212
213	qctrl.id++;
214	}
215
216	return kTRUE;
217	}
218
219	// -------------------------------------------------------------
220	//
221	// Enumerate (get) all basic and private controls from the
222	// device and store them as MVideoCtrl in fControls.
223	//
224	Bool_t MVideo::EnumerateControls()
225	{
226	if (!EnumerateControls(V4L2_CID_BASE))
227	return kFALSE;
228	if (!EnumerateControls(V4L2_CID_PRIVATE_BASE))
229	return kFALSE;
230
231	return kTRUE;
232	}
233
234	// -------------------------------------------------------------
235	//
236	// Reset a given control to it's default value as defined
237	// by the device.
238	//
239	Bool_t MVideo::ResetControl(MVideoCtrl &vctrl) const
240	{
241	return WriteControl(vctrl, vctrl.fDefault);
242	}
243
244	// -------------------------------------------------------------
245	//
246	// Reset all enumereated device controls to their default.
247	// The default is defined by the device iteself.
248	//
249	Bool_t MVideo::ResetControls() const
250	{
251	Bool_t rc = kTRUE;
252
253	TIter Next(&fControls);
254	MVideoCtrl *ctrl = 0;
255	while ((ctrl=((MVideoCtrl*)Next())))
256	if (!ResetControl(*ctrl))
257	{
258	gLog << err << "ERROR - Could not reset " << ctrl->fName << "." << endl;
259	rc = kFALSE;
260	}
261
262	return rc;
263	}
264
265	// -------------------------------------------------------------
266	//
267	// Read the value of the given control from the device
268	// and store it back into the given MVideoCtrl.
269	//
270	Bool_t MVideo::ReadControl(MVideoCtrl &vctrl) const
271	{
272	struct v4l2_control ctrl = { vctrl.fId, 0 };
273	if (Ioctl(VIDIOC_G_CTRL, &ctrl)==-1)
274	return kFALSE;
275
276	vctrl.fValue = ctrl.value;
277
278	return kTRUE;
279	}
280
281	// -------------------------------------------------------------
282	//
283	// Write the given value into the given control of the device.
284	// On success the value is stored in the given MVideoCtrl.
285	//
286	Bool_t MVideo::WriteControl(MVideoCtrl &vctrl, Int_t val) const
287	{
288	if (val<vctrl.fMinimum)
289	{
290	gLog << err << "ERROR - Value of " << val << " below minimum of " << vctrl.fMinimum << " for " << vctrl.fName << endl;
291	return kFALSE;
292	}
293
294	if (val>vctrl.fMaximum)
295	{
296	gLog << err << "ERROR - Value of " << val << " above maximum of " << vctrl.fMaximum << " for " << vctrl.fName << endl;
297	return kFALSE;
298	}
299
300	struct v4l2_control ctrl = { vctrl.fId, val };
301	if (Ioctl(VIDIOC_S_CTRL, &ctrl)==-1)
302	return kFALSE;
303
304	vctrl.fValue = val;
305
306	return kTRUE;
307	}
308
309	// -------------------------------------------------------------
310	//
311	// Set all controls from a TEnv. Note that all whitespaces
312	// and colons in the control names (as defined by the name of
313	// the MVideoCtrls stored in fControls) are replaced by
314	// underscores.
315	//
316	Bool_t MVideo::SetControls(TEnv &env) const
317	{
318	Bool_t rc = kTRUE;
319
320	TIter Next(&fControls);
321	TObject *o = 0;
322	while ((o=Next()))
323	{
324	if (!env.Defined(o->GetName()))
325	continue;
326
327	TString str = env.GetValue(o->GetName(), "");
328	str = str.Strip(TString::kBoth);
329	str.ReplaceAll(" ", "_");
330	str.ReplaceAll(":", "_");
331	if (str.IsNull())
332	continue;
333
334	MVideoCtrl &ctrl = static_cast<MVideoCtrl>(o);
335
336	const Int_t val = str=="default" \|\| str=="def" ?
337	ctrl.fDefault : env.GetValue(o->GetName(), 0);
338
339	if (!WriteControl(ctrl, val))
340	rc = kFALSE;
341	}
342
343	return rc;
344	}
345
346	template<class S>
347	Bool_t MVideo::Enumerate(vector<S> &vec, int request)
348	{
349	for (int i=0; ; i++)
350	{
351	S input;
352	input.index = i;
353
354	const int rc = Ioctl(request, &input);
355	if (rc<0)
356	return kFALSE;
357	if (rc==1)
358	return kTRUE;
359
360	vec.push_back(input);
361	}
362
363	return kFALSE;
364	}
365
366	void MVideo::PrintInputs() const
367	{
368	gLog << all;
369	for (vector<v4l2_input>::const_iterator it=fInputs.begin(); it!=fInputs.end(); it++)
370	{
371	gLog << "Input #" << it->index << endl;
372	gLog << " - " << it->name << endl;
373	gLog << " - " << (it->type==V4L2_INPUT_TYPE_CAMERA?"Camera":"Tuner") << endl;
374	gLog << " - TV Standard: " << hex << it->std << dec << endl;
375
376	gLog << " - Status: 0x" << hex << it->status;
377	if (it->status&V4L2_IN_ST_NO_POWER)
378	gLog << " NoPower";
379	if (it->status&V4L2_IN_ST_NO_SIGNAL)
380	gLog << " NoSignal";
381	if (it->status&V4L2_IN_ST_NO_COLOR)
382	gLog << " NoColor";
383	if (it->status&V4L2_IN_ST_NO_H_LOCK)
384	gLog << " NoHLock";
385	if (it->status&V4L2_IN_ST_COLOR_KILL)
386	gLog << " ColorKill";
387	gLog << endl;
388
389	/*
390	TV Standard
391	===========
392	#define V4L2_STD_PAL_B ((v4l2_std_id)0x00000001)
393	#define V4L2_STD_PAL_B1 ((v4l2_std_id)0x00000002)
394	#define V4L2_STD_PAL_G ((v4l2_std_id)0x00000004)
395	#define V4L2_STD_PAL_H ((v4l2_std_id)0x00000008)
396	#define V4L2_STD_PAL_I ((v4l2_std_id)0x00000010)
397	#define V4L2_STD_PAL_D ((v4l2_std_id)0x00000020)
398	#define V4L2_STD_PAL_D1 ((v4l2_std_id)0x00000040)
399	#define V4L2_STD_PAL_K ((v4l2_std_id)0x00000080)
400
401	#define V4L2_STD_PAL_M ((v4l2_std_id)0x00000100)
402	#define V4L2_STD_PAL_N ((v4l2_std_id)0x00000200)
403	#define V4L2_STD_PAL_Nc ((v4l2_std_id)0x00000400)
404	#define V4L2_STD_PAL_60 ((v4l2_std_id)0x00000800)
405	V4L2_STD_PAL_60 is a hybrid standard with 525 lines, 60 Hz refresh rate, and PAL color modulation with a 4.43 MHz color subcarrier. Some PAL video recorders can play back NTSC tapes in this mode for display on a 50/60 Hz agnostic PAL TV.
406
407	#define V4L2_STD_NTSC_M ((v4l2_std_id)0x00001000)
408	#define V4L2_STD_NTSC_M_JP ((v4l2_std_id)0x00002000)
409	#define V4L2_STD_NTSC_443 ((v4l2_std_id)0x00004000)
410	V4L2_STD_NTSC_443 is a hybrid standard with 525 lines, 60 Hz refresh rate, and NTSC color modulation with a 4.43 MHz color subcarrier.
411
412	#define V4L2_STD_NTSC_M_KR ((v4l2_std_id)0x00008000)
413
414	#define V4L2_STD_SECAM_B ((v4l2_std_id)0x00010000)
415	#define V4L2_STD_SECAM_D ((v4l2_std_id)0x00020000)
416	#define V4L2_STD_SECAM_G ((v4l2_std_id)0x00040000)
417	#define V4L2_STD_SECAM_H ((v4l2_std_id)0x00080000)
418	#define V4L2_STD_SECAM_K ((v4l2_std_id)0x00100000)
419	#define V4L2_STD_SECAM_K1 ((v4l2_std_id)0x00200000)
420	#define V4L2_STD_SECAM_L ((v4l2_std_id)0x00400000)
421	#define V4L2_STD_SECAM_LC ((v4l2_std_id)0x00800000)
422
423
424	// ATSC/HDTV
425	#define V4L2_STD_ATSC_8_VSB ((v4l2_std_id)0x01000000)
426	#define V4L2_STD_ATSC_16_VSB ((v4l2_std_id)0x02000000)
427	V4L2_STD_ATSC_8_VSB and V4L2_STD_ATSC_16_VSB are U.S. terrestrial digital TV standards. Presently the V4L2 API does not support digital TV. See also the Linux DVB API at http://linuxtv.org.
428
429	#define V4L2_STD_PAL_BG (V4L2_STD_PAL_B \| V4L2_STD_PAL_B1 \| V4L2_STD_PAL_G)
430	#define V4L2_STD_B (V4L2_STD_PAL_B \| V4L2_STD_PAL_B1 \| V4L2_STD_SECAM_B)
431	#define V4L2_STD_GH (V4L2_STD_PAL_G \| V4L2_STD_PAL_H \| V4L2_STD_SECAM_G \| V4L2_STD_SECAM_H)
432	#define V4L2_STD_PAL_DK (V4L2_STD_PAL_D \| V4L2_STD_PAL_D1 \| V4L2_STD_PAL_K)
433	#define V4L2_STD_PAL (V4L2_STD_PAL_BG \| V4L2_STD_PAL_DK \| V4L2_STD_PAL_H \| V4L2_STD_PAL_I)
434	#define V4L2_STD_NTSC (V4L2_STD_NTSC_M \| V4L2_STD_NTSC_M_JP \| V4L2_STD_NTSC_M_KR)
435	#define V4L2_STD_MN (V4L2_STD_PAL_M \| V4L2_STD_PAL_N \| V4L2_STD_PAL_Nc \| V4L2_STD_NTSC)
436	#define V4L2_STD_SECAM_DK (V4L2_STD_SECAM_D \| V4L2_STD_SECAM_K \| V4L2_STD_SECAM_K1)
437	#define V4L2_STD_DK (V4L2_STD_PAL_DK \| V4L2_STD_SECAM_DK)
438	#define V4L2_STD_SECAM (V4L2_STD_SECAM_B \| V4L2_STD_SECAM_G \| V4L2_STD_SECAM_H \| V4L2_STD_SECAM_DK \| V4L2_STD_SECAM_L \| V4L2_STD_SECAM_LC)
439	#define V4L2_STD_525_60 (V4L2_STD_PAL_M \| V4L2_STD_PAL_60 \| V4L2_STD_NTSC \| V4L2_STD_NTSC_443)
440	#define V4L2_STD_625_50 (V4L2_STD_PAL \| V4L2_STD_PAL_N \| V4L2_STD_PAL_Nc \| V4L2_STD_SECAM)
441	#define V4L2_STD_UNKNOWN 0
442	#define V4L2_STD_ALL (V4L2_STD_525_60 \| V4L2_STD_625_50)
443	*/
444
445	/*
446	Status:
447	=======
448	General
449	V4L2_IN_ST_NO_POWER 0x00000001 Attached device is off.
450	V4L2_IN_ST_NO_SIGNAL 0x00000002
451	V4L2_IN_ST_NO_COLOR 0x00000004 The hardware supports color decoding, but does not detect color modulation in the signal.
452
453	Analog Video
454	V4L2_IN_ST_NO_H_LOCK 0x00000100 No horizontal sync lock.
455	V4L2_IN_ST_COLOR_KILL 0x00000200 A color killer circuit automatically disables color decoding when it detects no color modulation. When this flag is set the color killer is enabled and has shut off color decoding.
456
457	Digital Video
458	V4L2_IN_ST_NO_SYNC 0x00010000 No synchronization lock.
459	V4L2_IN_ST_NO_EQU 0x00020000 No equalizer lock.
460	V4L2_IN_ST_NO_CARRIER 0x00040000 Carrier recovery failed.
461
462	VCR and Set-Top Box
463	V4L2_IN_ST_MACROVISION 0x01000000 Macrovision is an analog copy prevention system mangling the video signal to confuse video recorders. When this flag is set Macrovision has been detected.
464	V4L2_IN_ST_NO_ACCESS 0x02000000 Conditional access denied.
465	V4L2_IN_ST_VTR 0x04000000 VTR time constant. [?]
466	*/
467	}
468	}
469
470	void MVideo::PrintStandards() const
471	{
472	gLog << all;
473	for (vector<v4l2_standard>::const_iterator it=fStandards.begin(); it!=fStandards.end(); it++)
474	{
475	gLog << "Index #" << it->index << endl;
476	gLog << " - TV Standard: " << it->name << hex << "(" << it->id << ")" << dec << endl;
477	gLog << " - FPS: " << it->frameperiod.numerator << "/" << it->frameperiod.denominator << endl;
478	gLog << " - Lines: " << it->framelines << endl;
479	}
480	}
481
482	// -------------------------------------------------------------
483	//
484	// Open channel ch of the device
485	//
486	Bool_t MVideo::Open(Int_t ch)
487	{
488	const Bool_t rc = Init(ch);
489	if (!rc)
490	Close();
491	return rc;
492	}
493
494	// -------------------------------------------------------------
495	//
496	// Open a channel of the device and retriev all necessary
497	// informations from the driver. Initialize the shared
498	// memory. Other access methods are not supported yet.
499	//
500	Bool_t MVideo::Init(Int_t channel)
501	{
502	if (IsOpen())
503	{
504	gLog << warn << "WARNING - Device " << fPath << " already open." << endl;
505	return kTRUE;
506	}
507
508	gLog << all << "Opening " << fPath << "... " << flush;
509	do
510	{
511	fFileDesc = open(fPath, O_RDWR\|O_NONBLOCK, 0);
512	usleep(1);
513	}
514	while (errno==19 && fFileDesc==-1);
515
516	if (fFileDesc == -1)
517	{
518	gLog << err << "ERROR: " << strerror(errno) << endl;
519	return kFALSE;
520	}
521
522	gLog << "done (" << fFileDesc << ")." << endl;
523
524	// Close device on exit
525	if (fcntl(fFileDesc, F_SETFD, FD_CLOEXEC)<0)
526	{
527	gLog << err << "ERROR - Call to fnctl (F_SETFD, FD_CLOEXEC) failed." << endl;
528	return kFALSE;
529	}
530
531
532
533	/*
534	if (!Enumerate(fInputs, VIDIOC_ENUMINPUT))
535	{
536	gLog << err << "ERROR - Could not enumerate inputs." << endl;
537	return kFALSE;
538	}
539	PrintInputs();
540
541	if (!Enumerate(fStandards, VIDIOC_ENUMSTD))
542	{
543	gLog << err << "ERROR - Could not enumerate inputs." << endl;
544	return kFALSE;
545	}
546	PrintStandards();
547	*/
548
549	int index = 3;
550	if (Ioctl(VIDIOC_S_INPUT, &index)==-1)
551	{
552	gLog << err << "ERROR - Could not set input." << endl;
553	return kFALSE;
554	}
555
556	//check the input
557	if (Ioctl(VIDIOC_G_INPUT, &index))
558	{
559	gLog << err << "ERROR - Could not get input." << endl;
560	return kFALSE;
561	}
562
563	v4l2_input input;
564	memset(&input, 0, sizeof (input));
565	input.index = index;
566	if (Ioctl(VIDIOC_ENUMINPUT, &input))
567	{
568	gLog << err << "ERROR - Could enum input." << endl;
569	return kFALSE;
570	}
571	gLog << "*** Input: " << input.name << " (" << input.index << ")" << endl;
572
573	v4l2_std_id st = 4;//standard.id;
574	if (Ioctl (VIDIOC_S_STD, &st))
575	{
576	gLog << err << "ERROR - Could not set standard." << endl;
577	return kFALSE;
578	}
579
580	v4l2_capability cap;
581	if (Ioctl(VIDIOC_QUERYCAP, &cap))
582	{
583	gLog << err << "ERROR - Could not get capabilities." << endl;
584	return kFALSE;
585	}
586
587	if (!(cap.capabilities & V4L2_CAP_VIDEO_CAPTURE))
588	{
589	gLog << err << "ERROR - No capture capabaility." << endl;
590	return kFALSE;
591	}
592
593	v4l2_cropcap cropcap;
594	cropcap.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
595
596	if (Ioctl(VIDIOC_CROPCAP, &cropcap)==-1)
597	{
598	}
599
600	v4l2_crop crop;
601	crop.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
602	crop.c = cropcap.defrect; /* reset to default */
603
604	if (Ioctl(VIDIOC_S_CROP, &crop))
605	{
606	gLog << err << "Could not reset cropping." << endl;
607	return kFALSE;
608	}
609
610	v4l2_format fmt;
611	fmt.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
612	fmt.fmt.pix.width = 768;
613	fmt.fmt.pix.height = 576;
614	fmt.fmt.pix.pixelformat = V4L2_PIX_FMT_RGB32;
615
616	if (Ioctl(VIDIOC_S_FMT, &fmt)==-1)
617	{
618	gLog << err << "ERROR - Could not set format." << endl;
619	return kFALSE;
620	}
621	// The image format must be selected before buffers are allocated,
622	// with the VIDIOC_S_FMT ioctl. When no format is selected the driver
623	// may use the last, possibly by another application requested format.
624
625	v4l2_requestbuffers reqbuf;
626	memset (&reqbuf, 0, sizeof (reqbuf));
627
628	reqbuf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
629	reqbuf.memory = V4L2_MEMORY_MMAP;
630	reqbuf.count = 4;//125;
631
632	if (Ioctl(VIDIOC_REQBUFS, &reqbuf)==-1)
633	{
634	gLog << err << "ERROR - Couldn't setup frame buffers." << endl;
635	return kFALSE;
636	}
637
638	gLog << all << "Allocated " << reqbuf.count << " frame buffers." << endl;
639
640	for (unsigned int i=0; i<reqbuf.count; i++)
641	{
642	v4l2_buffer buffer;
643	memset (&buffer, 0, sizeof (buffer));
644
645	buffer.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
646	buffer.memory = V4L2_MEMORY_MMAP;
647	buffer.index = i;
648
649	if (Ioctl(VIDIOC_QUERYBUF, &buffer))
650	{
651	gLog << err << "ERROR - Request of frame buffer " << i << " failed." << endl;
652	return kFALSE;
653	}
654
655	void *ptr = mmap(NULL, buffer.length,
656	PROT_READ \| PROT_WRITE,
657	MAP_SHARED,
658	fFileDesc, buffer.m.offset);
659
660	if (MAP_FAILED == ptr)
661	{
662
663	gLog << err << "ERROR - Could not allocate shared memory." << endl;
664	return kFALSE;
665	// If you do not exit here you should unmap() and free()
666	// the buffers mapped so far.
667	//perror ("mmap");
668	//exit (EXIT_FAILURE);
669	}
670
671	fBuffers.push_back(make_pair(buffer, ptr));
672	}
673
674	return kTRUE;
675	}
676
677	Bool_t MVideo::Start()
678	{
679	v4l2_buf_type type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
680	if (Ioctl(VIDIOC_STREAMON, &type)==-1)
681	{
682	gLog << err << "ERROR - Couldn't start capturing." << endl;
683	return kFALSE;
684	}
685
686	cout << "*** Stream on" << endl;
687
688	return kTRUE;
689	}
690
691	// -------------------------------------------------------------
692	//
693	// Close device. Free the shared memory
694	//
695	Int_t MVideo::Close()
696	{
697	// if (!IsOpen())
698	// return kTRUE;
699	/*
700	if (Ioctl(VIDIOC_STREAMON, &fBuffers[0])==-1)
701	{
702	gLog << err << "ERROR - Couldn't start capturing." << endl;
703	return kFALSE;
704	}
705	*/
706	Bool_t rc = kTRUE;
707
708	gLog << all << "Closing " << fPath << " (" << fFileDesc << ")... " << flush;
709	if (fFileDesc != -1)
710	{
711	if (close(fFileDesc)<0)
712	{
713	gLog << err << "ERROR!" << endl;
714	rc = kFALSE;
715	}
716	fFileDesc = -1;
717	}
718	gLog << "done." << endl;
719
720	// unmap device memory
721	for (vector<pair<v4l2_buffer,void*> >::iterator it=fBuffers.begin(); it!=fBuffers.end(); it++)
722	{
723	munmap(it->second, it->first.length);
724	fBuffers.erase(it);
725	}
726
727	Reset();
728
729	return rc;
730	}
731
732	// -------------------------------------------------------------
733	//
734	// Instruct hardware to start capture into framebuffer frame
735	//
736	Bool_t MVideo::CaptureStart(unsigned int frame) const
737	{
738	frame %= fBuffers.size();
739
740	// cout << "*** CaptureStart " << frame << endl;
741
742	if (Ioctl(VIDIOC_QBUF, const_cast<v4l2_buffer*>(&fBuffers[frame].first))==-1)
743	{
744	gLog << err << "ERROR - Couldn't buffer " << frame << "." << endl;
745	return kFALSE;
746	}
747
748	// cout << "*** " << errno << endl;
749
750	return kTRUE;
751
752	/*
753	struct video_mmap gb =
754	{
755	frame, // frame
756	fCaps.maxheight, fCaps.maxwidth, // height, width
757	VIDEO_PALETTE_RGB24 // palette
758	};
759
760	#ifdef DEBUG
761	gLog << dbg << "CapturStart(" << frame << ")" << endl;
762	#endif
763
764	//
765	// capture frame
766	//
767	if (Ioctl(VIDIOCMCAPTURE, &gb) != -1)
768	return kTRUE;
769
770	// if (errno == EAGAIN)
771	gLog << err;
772	gLog << "ERROR - Couldn't start capturing frame " << frame << "." << endl;
773	gLog << " Maybe your card doesn't support VIDEO_PALETTE_RGB24." << endl;
774	return kFALSE;
775	*/
776	}
777
778	// -------------------------------------------------------------
779	//
780	// Wait until hardware has finished capture into framebuffer frame
781	//
782	Int_t MVideo::CaptureWait(unsigned int frame, unsigned char **ptr) const
783	{
784	frame %= fBuffers.size();
785
786	if (ptr)
787	*ptr = NULL;
788
789	// const int SYNC_TIMEOUT = 1;
790
791	//#ifdef DEBUG
792	// cout << "*** CaptureWait " << frame << endl;
793	//#endif
794
795	//alarm(SYNC_TIMEOUT);
796	const Int_t rc = Ioctl(VIDIOC_DQBUF, const_cast<v4l2_buffer*>(&fBuffers[frame].first), false);
797	if (rc==-4)
798	{
799	//cout << "ERROR - Waiting for frame " << frame << " timed out." << endl;
800	return kSKIP;
801	}
802	//alarm(0);
803
804	if (rc==-1)
805	{
806	gLog << err << "ERROR - Waiting for " << frame << " frame failed." << endl;
807	return kFALSE;
808	}
809
810	if (ptr)
811	ptr = static_cast<unsigned char>(fBuffers[frame].second);
812
813	return kTRUE;
814	}
815
816	// -------------------------------------------------------------
817	//
818	// Change the channel of a priviously opened device
819	//
820	Int_t MVideo::SetChannel(Int_t chan)
821	{
822	return kSKIP;
823
824	if (fChannel.channel==chan)
825	return kSKIP;
826
827	if (chan<0 \|\| chan>=fCaps.channels)
828	{
829	gLog << err << "ERROR - Set channel " << chan << " out of range." << endl;
830	return kFALSE;
831	}
832
833	// Switch to channel
834	struct video_channel ch = { chan, "", 0, 0, 0, 0 };
835	if (Ioctl(VIDIOCSCHAN, &ch)==-1)
836	{
837	gLog << err << "ERROR - Couldn't switch to channel " << chan << "." << endl;
838	gLog << " You might need a bttv version > 0.5.13" << endl;
839	return kFALSE;
840	}
841
842	// Get information about channel
843	if (Ioctl(VIDIOCGCHAN, &ch)==-1)
844	{
845	gLog << err << "ERROR - Getting information for channel " << chan << " failed." << endl;
846	return kFALSE;
847	}
848
849	memcpy(&fChannel, &ch, sizeof(fChannel));
850
851	gLog << all << "Switched to channel " << chan << endl;
852
853	return kTRUE;
854	}
855
856	// -------------------------------------------------------------
857	//
858	// Has the device capture capabilities?
859	//
860	Bool_t MVideo::CanCapture() const
861	{
862	return fCaps.type&VID_TYPE_CAPTURE;
863	}
864
865	// -------------------------------------------------------------
866	//
867	// Has a tuner
868	//
869	Bool_t MVideo::HasTuner() const
870	{
871	return fCaps.type&VID_TYPE_TUNER;
872	}
873
874	// -------------------------------------------------------------
875	//
876	// Returns the number of frame buffers which can be used
877	//
878	Int_t MVideo::GetNumBuffers() const
879	{
880	return fBuffers.size();
881	}
882
883	// -------------------------------------------------------------
884	//
885	// Maximum width of the frame which can be captured
886	//
887	Int_t MVideo::GetWidth() const
888	{
889	return 768;//fCaps.maxwidth;
890	}
891
892	// -------------------------------------------------------------
893	//
894	// Maximum height of the frame which can be captured
895	//
896	Int_t MVideo::GetHeight() const
897	{
898	return 576;//fCaps.maxheight;
899	}
900
901	// -------------------------------------------------------------
902	//
903	// Return the device type as string
904	//
905	TString MVideo::GetDevType(int type) const
906	{
907	TString rc;
908	if (CanCapture())
909	rc += " capture";
910	if (HasTuner())
911	rc += " tuner";
912	if (type&VID_TYPE_TELETEXT)
913	rc += " teletext";
914	if (type&VID_TYPE_OVERLAY)
915	rc += " overlay";
916	if (type&VID_TYPE_CHROMAKEY)
917	rc += " chromakey";
918	if (type&VID_TYPE_CLIPPING)
919	rc += " clipping";
920	if (type&VID_TYPE_FRAMERAM)
921	rc += " frameram";
922	if (type&VID_TYPE_SCALES)
923	rc += " scales";
924	if (type&VID_TYPE_MONOCHROME)
925	rc += " monochrom";
926	if (type&VID_TYPE_SUBCAPTURE)
927	rc += " subcapature";
928	return rc;
929	}
930
931	TString MVideo::GetTunerFlags(Int_t flags) const
932	{
933	TString rc;
934	if (flags&VIDEO_TUNER_PAL)
935	rc += " PAL";
936	if (flags&VIDEO_TUNER_NTSC)
937	rc += " NTSC";
938	if (flags&VIDEO_TUNER_SECAM)
939	rc += " SECAM";
940	if (flags&VIDEO_TUNER_LOW)
941	rc += " kHz";
942	if (flags&VIDEO_TUNER_NORM)
943	rc += " CanSetNorm";
944	if (flags&VIDEO_TUNER_STEREO_ON)
945	rc += " StereoOn";
946	return rc;
947	}
948
949	TString MVideo::GetTunerMode(Int_t mode) const
950	{
951	switch (mode)
952	{
953	case VIDEO_MODE_PAL:
954	return "PAL";
955	case VIDEO_MODE_NTSC:
956	return "NTSC";
957	case VIDEO_MODE_SECAM:
958	return "SECAM";
959	case VIDEO_MODE_AUTO:
960	return "AUTO";
961	}
962	return "undefined";
963	}
964
965	// -------------------------------------------------------------
966	//
967	// Return the channel flags as string
968	//
969	TString MVideo::GetChannelFlags(Int_t flags) const
970	{
971	TString rc = "video";
972	if (flags&VIDEO_VC_TUNER)
973	rc += " tuner";
974	if (flags&VIDEO_VC_AUDIO)
975	rc += " audio";
976	// if (flags&VIDEO_VC_NORM)
977	// rc += " normsetting";
978	return rc;
979	}
980
981	// -------------------------------------------------------------
982	//
983	// Return the channel type as string
984	//
985	TString MVideo::GetChannelType(Int_t type) const
986	{
987	if (type&VIDEO_TYPE_TV)
988	return "TV";
989	if (type&VIDEO_TYPE_CAMERA)
990	return "Camera";
991	return "unknown";
992	}
993
994	// -------------------------------------------------------------
995	//
996	// Return the palette pal as string
997	//
998	TString MVideo::GetPalette(Int_t pal) const
999	{
1000	switch (pal)
1001	{
1002	case VIDEO_PALETTE_GREY:
1003	return "VIDEO_PALETTE_GREY: Linear intensity grey scale";
1004	case VIDEO_PALETTE_HI240:
1005	return "VIDEO_PALETTE_HI240: BT848 8-bit color cube";
1006	case VIDEO_PALETTE_RGB565:
1007	return "VIDEO_PALETTE_RGB565: RGB565 packed into 16-bit words";
1008	case VIDEO_PALETTE_RGB555:
1009	return "VIDEO_PALETTE_RGB555: RGB555 packed into 16-bit words, top bit undefined";
1010	case VIDEO_PALETTE_RGB24:
1011	return "VIDEO_PALETTE_RGB24: RGB888 packed into 24-bit words";
1012	case VIDEO_PALETTE_RGB32:
1013	return "VIDEO_PALETTE_RGB32: RGB888 packed into the low three bytes of 32-bit words. Top bits undefined.";
1014	case VIDEO_PALETTE_YUV422:
1015	return "VIDEO_PALETTE_YUV422: Video style YUV422 - 8-bit packed, 4-bit Y, 2-bits U, 2-bits V";
1016	case VIDEO_PALETTE_YUYV:
1017	return "VIDEO_PALETTE_YUYV: YUYV";
1018	case VIDEO_PALETTE_UYVY:
1019	return "VIDEO_PALETTE_UYVY: UYVY";
1020	case VIDEO_PALETTE_YUV420:
1021	return "VIDEO_PALETTE_YUV420: YUV420";
1022	case VIDEO_PALETTE_YUV411:
1023	return "VIDEO_PALETTE_YUV411: YUV411";
1024	case VIDEO_PALETTE_RAW:
1025	return "VIDEO_PALETTE_RAW: Raw capture (Bt848)";
1026	case VIDEO_PALETTE_YUV422P:
1027	return "VIDEO_PALETTE_YUV422P: YUV 4:2:2 planar";
1028	case VIDEO_PALETTE_YUV411P:
1029	return "VIDEO_PALETTE_YUV411P: YUV 4:1:1 planar";
1030	}
1031	return "unknown";
1032	}
1033
1034	// -------------------------------------------------------------
1035	//
1036	// Print informations about the device, the capabilities, the
1037	// channel and all available information
1038	//
1039	void MVideo::Print() const
1040	{
1041	gLog << all << dec;
1042
1043	gLog << "Device " << fPath << " " << (fFileDesc>0?"open":"closed") << "." << endl;
1044
1045	if (fFileDesc<=0)
1046	return;
1047
1048	gLog << " - Name: " << fCaps.name << endl;
1049	gLog << " - DevType: " << GetDevType(fCaps.type) << endl;
1050	gLog << " - Channels: " << fCaps.channels << endl;
1051	gLog << " - Audios: " << fCaps.audios << endl;
1052	gLog << " - Size: ";
1053	gLog << fCaps.minwidth << "x" << fCaps.minheight << " to ";
1054	gLog << fCaps.maxwidth << "x" << fCaps.maxheight << endl;
1055	gLog << endl;
1056	if (fChannel.channel>=0)
1057	{
1058	gLog << " - Channel: " << fChannel.channel << " (" << fChannel.name << ")" << endl;
1059	gLog << " - IsA: " << GetChannelType(fChannel.type) << " with " << GetChannelFlags(fChannel.flags) << " (" << fChannel.flags << ")" << endl;
1060	//if (fChannel.flags&VIDEO_VC_NORM)
1061	gLog << " - Norm: " << fChannel.norm << endl;
1062	gLog << endl;
1063	}
1064
1065	if (fAbil.tuner>=0)
1066	{
1067	gLog << " - Tuner: " << fAbil.tuner << endl;
1068	gLog << " - Name: " << fAbil.name << endl;
1069	// gLog << " - Tuner Range: " << fAbil.rangelow << " - " << fAbil.rangehigh << endl;
1070	gLog << " - Tuner flags: " << GetTunerFlags(fAbil.flags) << " (" << fAbil.flags << ")" << endl;
1071	gLog << " - Tuner mode: " << GetTunerMode(fAbil.mode) << " (" << fAbil.mode << ")" <<endl;
1072	gLog << " - Signal Strength: " << fAbil.signal << endl;
1073	}
1074
1075	gLog << " - Brightness: " << fProp.brightness << endl;
1076	gLog << " - Hue: " << fProp.hue << endl;
1077	gLog << " - Color: " << fProp.colour << endl;
1078	gLog << " - Contrast: " << fProp.contrast << endl;
1079	gLog << " - Whiteness: " << fProp.whiteness << endl;
1080	gLog << " - Depth: " << fProp.depth << endl;
1081	gLog << " - Palette: " << GetPalette(fProp.palette) << " (" << fProp.palette << ")" << endl;
1082	gLog << endl;
1083
1084	// gLog << " - BufferSize: 0x" << hex << fBuffer.size << " (" << dec << fBuffer.frames << " frames)" << endl;
1085	// gLog << " - Offsets: " << hex;
1086	// for (int i=0; i<fBuffer.frames; i++)
1087	// gLog << " 0x" << fBuffer.offsets[i];
1088	// gLog << dec << endl;
1089
1090	gLog << inf2 << "Controls:" << endl;
1091	fControls.Print();
1092	}
1093
1094	/*
1095	void MVideo::SetPicPar(int bright, int hue, int contrast)
1096	{
1097	struct video_picture pict;
1098
1099	Ioctl(VIDIOCGPICT, &pict); // get
1100
1101	if (contrast != -1)
1102	pict.contrast = contrast;
1103
1104	if (bright != -1)
1105	pict.brightness = bright;
1106
1107	if (hue != -1)
1108	pict.hue = hue;
1109
1110	Ioctl(VIDIOCSPICT, &pict); //set
1111	}
1112
1113	void MVideo::GetPicPar(int bright, int hue, int *contrast)
1114	{
1115	struct video_picture pict;
1116
1117	Ioctl(VIDIOCGPICT, &pict); // get
1118
1119	*contrast = pict.contrast;
1120	*bright = pict.brightness;
1121	*hue = pict.hue;
1122	}
1123	*/

Note: See TracBrowser for help on using the repository browser.

Context Navigation

source: branches/FACT++_lidctrl_usb/drive/MVideo.cc

Download in other formats: