|
Lines 117-146
void VideoDevice::setupControls()
Link Here
|
| 117 |
} |
117 |
} |
| 118 |
break; |
118 |
break; |
| 119 |
#endif |
119 |
#endif |
| 120 |
case VIDEODEV_DRIVER_V4L: |
|
|
| 121 |
{ |
| 122 |
NumericVideoControl numCtrl; |
| 123 |
numCtrl.value_min = 0; |
| 124 |
numCtrl.value_max = 65535; |
| 125 |
numCtrl.value_step = 1; |
| 126 |
numCtrl.value_default = 32767; |
| 127 |
numCtrl.id = IMGCTRL_ID_V4L1_BRIGHTNESS; |
| 128 |
numCtrl.name = i18n("Brightness"); |
| 129 |
m_numericCtrls.push_back( numCtrl ); |
| 130 |
numCtrl.id = IMGCTRL_ID_V4L1_HUE; |
| 131 |
numCtrl.name = i18n("Hue"); |
| 132 |
m_numericCtrls.push_back( numCtrl ); |
| 133 |
numCtrl.id = IMGCTRL_ID_V4L1_COLOR; |
| 134 |
numCtrl.name = i18n("Color"); |
| 135 |
m_numericCtrls.push_back( numCtrl ); |
| 136 |
numCtrl.id = IMGCTRL_ID_V4L1_CONTRAST; |
| 137 |
numCtrl.name = i18n("Contrast"); |
| 138 |
m_numericCtrls.push_back( numCtrl ); |
| 139 |
numCtrl.id = IMGCTRL_ID_V4L1_WHITENESS; |
| 140 |
numCtrl.name = i18n("Whiteness"); |
| 141 |
m_numericCtrls.push_back( numCtrl ); |
| 142 |
} |
| 143 |
break; |
| 144 |
#endif |
120 |
#endif |
| 145 |
case VIDEODEV_DRIVER_NONE: |
121 |
case VIDEODEV_DRIVER_NONE: |
| 146 |
default: |
122 |
default: |
|
Lines 486-554
detectSignalStandards();
Link Here
|
| 486 |
|
462 |
|
| 487 |
#endif |
463 |
#endif |
| 488 |
|
464 |
|
| 489 |
CLEAR(V4L_capabilities); |
|
|
| 490 |
|
| 491 |
if(m_driver==VIDEODEV_DRIVER_NONE) |
| 492 |
{ |
| 493 |
kDebug() << "checkDevice(): " << full_filename << " Trying V4L API."; |
| 494 |
if (-1 == xioctl (VIDIOCGCAP, &V4L_capabilities)) |
| 495 |
{ |
| 496 |
perror ("ioctl (VIDIOCGCAP)"); |
| 497 |
m_driver = VIDEODEV_DRIVER_NONE; |
| 498 |
return EXIT_FAILURE; |
| 499 |
} |
| 500 |
else |
| 501 |
{ |
| 502 |
kDebug() << full_filename << " is a V4L device."; |
| 503 |
m_driver = VIDEODEV_DRIVER_V4L; |
| 504 |
m_model=QString::fromLocal8Bit((const char*)V4L_capabilities.name); |
| 505 |
if(V4L_capabilities.type & VID_TYPE_CAPTURE) |
| 506 |
m_videocapture=true; |
| 507 |
if(V4L_capabilities.type & VID_TYPE_CHROMAKEY) |
| 508 |
m_videochromakey=true; |
| 509 |
if(V4L_capabilities.type & VID_TYPE_SCALES) |
| 510 |
m_videoscale=true; |
| 511 |
if(V4L_capabilities.type & VID_TYPE_OVERLAY) |
| 512 |
m_videooverlay=true; |
| 513 |
// kDebug() << "libkopete (avdevice): Inputs : " << V4L_capabilities.channels; |
| 514 |
// kDebug() << "libkopete (avdevice): Audios : " << V4L_capabilities.audios; |
| 515 |
minwidth = V4L_capabilities.minwidth; |
| 516 |
maxwidth = V4L_capabilities.maxwidth; |
| 517 |
minheight = V4L_capabilities.minheight; |
| 518 |
maxheight = V4L_capabilities.maxheight; |
| 519 |
|
| 520 |
|
| 521 |
int inputisok=EXIT_SUCCESS; |
| 522 |
m_input.clear(); |
| 523 |
for(int loop=0; loop < V4L_capabilities.channels; loop++) |
| 524 |
{ |
| 525 |
struct video_channel videoinput; |
| 526 |
CLEAR(videoinput); |
| 527 |
videoinput.channel = loop; |
| 528 |
videoinput.norm = 1; |
| 529 |
inputisok=xioctl(VIDIOCGCHAN, &videoinput); |
| 530 |
if(inputisok==EXIT_SUCCESS) |
| 531 |
{ |
| 532 |
VideoInput tempinput; |
| 533 |
tempinput.name = QString::fromLocal8Bit((const char*)videoinput.name); |
| 534 |
tempinput.hastuner=videoinput.flags & VIDEO_VC_TUNER; |
| 535 |
// TODO: The routine to detect the appropriate video standards for V4L must be placed here |
| 536 |
m_input.push_back(tempinput); |
| 537 |
// kDebug() << "libkopete (avdevice): Input " << loop << ": " << tempinput.name << " (tuner: " << ((videoinput.flags & VIDEO_VC_TUNER) != 0) << ")"; |
| 538 |
/* if((input.type & V4L2_INPUT_TYPE_TUNER) != 0) |
| 539 |
{ |
| 540 |
// _tunerForInput[name] = desc.tuner; |
| 541 |
// _isTuner = true; |
| 542 |
} |
| 543 |
else |
| 544 |
{ |
| 545 |
// _tunerForInput[name] = -1; |
| 546 |
} |
| 547 |
*/ } |
| 548 |
} |
| 549 |
|
| 550 |
} |
| 551 |
} |
| 552 |
#endif |
465 |
#endif |
| 553 |
m_name=m_model; // Take care about changing the name to be different from the model itself... |
466 |
m_name=m_model; // Take care about changing the name to be different from the model itself... |
| 554 |
|
467 |
|
|
Lines 678-693
int VideoDevice::initDevice()
Link Here
|
| 678 |
} |
591 |
} |
| 679 |
break; |
592 |
break; |
| 680 |
#endif |
593 |
#endif |
| 681 |
case VIDEODEV_DRIVER_V4L: |
|
|
| 682 |
m_videoread=true; |
| 683 |
m_io_method=IO_METHOD_READ; |
| 684 |
if(-1 != xioctl(VIDIOCGFBUF,&V4L_videobuffer)) |
| 685 |
{ |
| 686 |
// m_videostream=true; |
| 687 |
// m_io_method = IO_METHOD_MMAP; |
| 688 |
kDebug() << " Streaming interface"; |
| 689 |
} |
| 690 |
break; |
| 691 |
#endif |
594 |
#endif |
| 692 |
case VIDEODEV_DRIVER_NONE: |
595 |
case VIDEODEV_DRIVER_NONE: |
| 693 |
default: |
596 |
default: |
|
Lines 863-897
kDebug() << "VIDIOC_S_FMT worked (" << e
Link Here
|
| 863 |
} |
766 |
} |
| 864 |
break; |
767 |
break; |
| 865 |
#endif |
768 |
#endif |
| 866 |
case VIDEODEV_DRIVER_V4L: |
|
|
| 867 |
{ |
| 868 |
struct video_window V4L_videowindow; |
| 869 |
|
| 870 |
if (xioctl (VIDIOCGWIN, &V4L_videowindow)== -1) |
| 871 |
{ |
| 872 |
perror ("ioctl VIDIOCGWIN"); |
| 873 |
// return (NULL); |
| 874 |
} |
| 875 |
V4L_videowindow.width = newwidth; |
| 876 |
V4L_videowindow.height = newheight; |
| 877 |
V4L_videowindow.clipcount=0; |
| 878 |
if (xioctl (VIDIOCSWIN, &V4L_videowindow)== -1) |
| 879 |
{ |
| 880 |
perror ("ioctl VIDIOCSWIN"); |
| 881 |
return EXIT_FAILURE; |
| 882 |
} |
| 883 |
kDebug() << "------------- width: " << V4L_videowindow.width << " Height: " << V4L_videowindow.height << " Clipcount: " << V4L_videowindow.clipcount << " -----------------"; |
| 884 |
|
| 885 |
currentwidth = V4L_videowindow.width; |
| 886 |
currentheight = V4L_videowindow.height; |
| 887 |
|
| 888 |
// kDebug() << "libkopete (avdevice): V4L_picture.palette: " << V4L_picture.palette << " Depth: " << V4L_picture.depth; |
| 889 |
|
| 890 |
/* if(-1 == xioctl(VIDIOCGFBUF,&V4L_videobuffer)) |
| 891 |
kDebug() << "libkopete (avdevice): VIDIOCGFBUF failed (" << errno << "): Device cannot stream";*/ |
| 892 |
|
| 893 |
} |
| 894 |
break; |
| 895 |
#endif |
769 |
#endif |
| 896 |
case VIDEODEV_DRIVER_NONE: |
770 |
case VIDEODEV_DRIVER_NONE: |
| 897 |
default: |
771 |
default: |
|
Lines 966-998
pixel_format VideoDevice::setPixelFormat
Link Here
|
| 966 |
} |
840 |
} |
| 967 |
break; |
841 |
break; |
| 968 |
#endif |
842 |
#endif |
| 969 |
case VIDEODEV_DRIVER_V4L: |
|
|
| 970 |
{ |
| 971 |
struct video_picture V4L_picture; |
| 972 |
if(-1 == xioctl(VIDIOCGPICT, &V4L_picture)) |
| 973 |
{ |
| 974 |
kDebug() << "VIDIOCGPICT failed (" << errno << ")."; |
| 975 |
} |
| 976 |
// kDebug() << "V4L_picture.palette: " << V4L_picture.palette << " Depth: " << V4L_picture.depth; |
| 977 |
V4L_picture.palette = pixelFormatCode(newformat); |
| 978 |
V4L_picture.depth = pixelFormatDepth(newformat); |
| 979 |
if(-1 == xioctl(VIDIOCSPICT,&V4L_picture)) |
| 980 |
{ |
| 981 |
// kDebug() << "Device seems to not support " << pixelFormatName(newformat) << " format. Fallback to it is not yet implemented."; |
| 982 |
} |
| 983 |
|
| 984 |
if(-1 == xioctl(VIDIOCGPICT, &V4L_picture)) |
| 985 |
{ |
| 986 |
kDebug() << "VIDIOCGPICT failed (" << errno << ")."; |
| 987 |
} |
| 988 |
|
| 989 |
// kDebug() << "V4L_picture.palette: " << V4L_picture.palette << " Depth: " << V4L_picture.depth; |
| 990 |
m_pixelformat=pixelFormatForPalette(V4L_picture.palette); |
| 991 |
if (m_pixelformat == newformat) |
| 992 |
ret = newformat; |
| 993 |
|
| 994 |
} |
| 995 |
break; |
| 996 |
#endif |
843 |
#endif |
| 997 |
case VIDEODEV_DRIVER_NONE: |
844 |
case VIDEODEV_DRIVER_NONE: |
| 998 |
default: |
845 |
default: |
|
Lines 1043-1059
int VideoDevice::selectInput(int newinpu
Link Here
|
| 1043 |
setupControls(); |
890 |
setupControls(); |
| 1044 |
break; |
891 |
break; |
| 1045 |
#endif |
892 |
#endif |
| 1046 |
case VIDEODEV_DRIVER_V4L: |
|
|
| 1047 |
struct video_channel V4L_input; |
| 1048 |
V4L_input.channel=newinput; |
| 1049 |
V4L_input.norm=4; // Hey, it's plain wrong! It should be input's signal standard! |
| 1050 |
if (-1 == ioctl (descriptor, VIDIOCSCHAN, &V4L_input)) |
| 1051 |
{ |
| 1052 |
perror ("ioctl (VIDIOCSCHAN)"); |
| 1053 |
return EXIT_FAILURE; |
| 1054 |
} |
| 1055 |
setupControls(); |
| 1056 |
break; |
| 1057 |
#endif |
893 |
#endif |
| 1058 |
case VIDEODEV_DRIVER_NONE: |
894 |
case VIDEODEV_DRIVER_NONE: |
| 1059 |
default: |
895 |
default: |
|
Lines 1817-1851
int VideoDevice::getControlValue(quint32
Link Here
|
| 1817 |
} |
1653 |
} |
| 1818 |
break; |
1654 |
break; |
| 1819 |
#endif |
1655 |
#endif |
| 1820 |
case VIDEODEV_DRIVER_V4L: |
|
|
| 1821 |
struct video_picture V4L_picture; |
| 1822 |
if(-1 == xioctl(VIDIOCGPICT, &V4L_picture)) |
| 1823 |
{ |
| 1824 |
kDebug() << "VIDIOCGPICT failed (" << errno << ")."; |
| 1825 |
return EXIT_FAILURE; |
| 1826 |
} |
| 1827 |
switch (ctrl_id) |
| 1828 |
{ |
| 1829 |
case IMGCTRL_ID_V4L1_BRIGHTNESS: |
| 1830 |
*value = V4L_picture.brightness; |
| 1831 |
break; |
| 1832 |
case IMGCTRL_ID_V4L1_HUE: |
| 1833 |
*value = V4L_picture.hue; |
| 1834 |
break; |
| 1835 |
case IMGCTRL_ID_V4L1_COLOR: |
| 1836 |
*value = V4L_picture.colour; |
| 1837 |
break; |
| 1838 |
case IMGCTRL_ID_V4L1_CONTRAST: |
| 1839 |
*value = V4L_picture.contrast; |
| 1840 |
break; |
| 1841 |
case IMGCTRL_ID_V4L1_WHITENESS: |
| 1842 |
*value = V4L_picture.whiteness; |
| 1843 |
break; |
| 1844 |
default: |
| 1845 |
return EXIT_FAILURE; |
| 1846 |
} |
| 1847 |
kDebug() << "Reported current value is" << *value << "."; |
| 1848 |
return EXIT_SUCCESS; |
| 1849 |
#endif |
1656 |
#endif |
| 1850 |
case VIDEODEV_DRIVER_NONE: |
1657 |
case VIDEODEV_DRIVER_NONE: |
| 1851 |
default: |
1658 |
default: |
|
Lines 1963-2012
int VideoDevice::setControlValue(quint32
Link Here
|
| 1963 |
} |
1770 |
} |
| 1964 |
break; |
1771 |
break; |
| 1965 |
#endif |
1772 |
#endif |
| 1966 |
case VIDEODEV_DRIVER_V4L: |
|
|
| 1967 |
struct video_picture V4L_picture; |
| 1968 |
if(-1 == xioctl(VIDIOCGPICT, &V4L_picture)) |
| 1969 |
{ |
| 1970 |
kDebug() << "VIDIOCGPICT failed (" << errno << ")."; |
| 1971 |
return EXIT_FAILURE; |
| 1972 |
} |
| 1973 |
if (value < 0) |
| 1974 |
{ |
| 1975 |
value = 0; |
| 1976 |
kDebug() << "Value exceeds lower limit ! Setting to minimum: 0"; |
| 1977 |
} |
| 1978 |
else if (value > 65535) |
| 1979 |
{ |
| 1980 |
value = 65535; |
| 1981 |
kDebug() << "Value exceeds upper limit ! Setting to maximum: 65535"; |
| 1982 |
} |
| 1983 |
// TODO: consider step, too ? |
| 1984 |
switch (ctrl_id) |
| 1985 |
{ |
| 1986 |
case IMGCTRL_ID_V4L1_BRIGHTNESS: |
| 1987 |
V4L_picture.brightness = value; |
| 1988 |
break; |
| 1989 |
case IMGCTRL_ID_V4L1_HUE: |
| 1990 |
V4L_picture.hue = value; |
| 1991 |
break; |
| 1992 |
case IMGCTRL_ID_V4L1_COLOR: |
| 1993 |
V4L_picture.colour = value; |
| 1994 |
break; |
| 1995 |
case IMGCTRL_ID_V4L1_CONTRAST: |
| 1996 |
V4L_picture.contrast = value; |
| 1997 |
break; |
| 1998 |
case IMGCTRL_ID_V4L1_WHITENESS: |
| 1999 |
V4L_picture.whiteness = value; |
| 2000 |
break; |
| 2001 |
default: |
| 2002 |
return EXIT_FAILURE; |
| 2003 |
} |
| 2004 |
if(-1 == xioctl(VIDIOCSPICT,&V4L_picture)) |
| 2005 |
{ |
| 2006 |
kDebug() << "Device seems to not support adjusting image brightness. Fallback to it is not yet implemented."; |
| 2007 |
return EXIT_FAILURE; |
| 2008 |
} |
| 2009 |
return EXIT_SUCCESS; |
| 2010 |
#endif |
1773 |
#endif |
| 2011 |
case VIDEODEV_DRIVER_NONE: |
1774 |
case VIDEODEV_DRIVER_NONE: |
| 2012 |
default: |
1775 |
default: |
|
Lines 2070-2092
pixel_format VideoDevice::pixelFormatFor
Link Here
|
| 2070 |
} |
1833 |
} |
| 2071 |
break; |
1834 |
break; |
| 2072 |
#endif |
1835 |
#endif |
| 2073 |
case VIDEODEV_DRIVER_V4L: |
|
|
| 2074 |
switch(palette) |
| 2075 |
{ |
| 2076 |
case 0 : return PIXELFORMAT_NONE; break; |
| 2077 |
case VIDEO_PALETTE_GREY : return PIXELFORMAT_GREY; break; |
| 2078 |
case VIDEO_PALETTE_HI240 : return PIXELFORMAT_RGB332; break; |
| 2079 |
case VIDEO_PALETTE_RGB555 : return PIXELFORMAT_RGB555; break; |
| 2080 |
case VIDEO_PALETTE_RGB565 : return PIXELFORMAT_RGB565; break; |
| 2081 |
case VIDEO_PALETTE_RGB24 : return PIXELFORMAT_RGB24; break; |
| 2082 |
case VIDEO_PALETTE_RGB32 : return PIXELFORMAT_RGB32; break; |
| 2083 |
case VIDEO_PALETTE_YUYV : return PIXELFORMAT_YUYV; break; |
| 2084 |
case VIDEO_PALETTE_UYVY : return PIXELFORMAT_UYVY; break; |
| 2085 |
case VIDEO_PALETTE_YUV420 : |
| 2086 |
case VIDEO_PALETTE_YUV420P : return PIXELFORMAT_YUV420P; break; |
| 2087 |
case VIDEO_PALETTE_YUV422P : return PIXELFORMAT_YUV422P; break; |
| 2088 |
} |
| 2089 |
break; |
| 2090 |
#endif |
1836 |
#endif |
| 2091 |
case VIDEODEV_DRIVER_NONE: |
1837 |
case VIDEODEV_DRIVER_NONE: |
| 2092 |
default: |
1838 |
default: |
|
Lines 2150-2199
int VideoDevice::pixelFormatCode(pixel_f
Link Here
|
| 2150 |
} |
1896 |
} |
| 2151 |
break; |
1897 |
break; |
| 2152 |
#endif |
1898 |
#endif |
| 2153 |
case VIDEODEV_DRIVER_V4L: |
|
|
| 2154 |
switch(pixelformat) |
| 2155 |
{ |
| 2156 |
case PIXELFORMAT_NONE : return 0; break; |
| 2157 |
|
| 2158 |
// Packed RGB formats |
| 2159 |
case PIXELFORMAT_RGB332 : return VIDEO_PALETTE_HI240; break; |
| 2160 |
case PIXELFORMAT_RGB444 : return 0; break; |
| 2161 |
case PIXELFORMAT_RGB555 : return VIDEO_PALETTE_RGB555; break; |
| 2162 |
case PIXELFORMAT_RGB565 : return VIDEO_PALETTE_RGB565; break; |
| 2163 |
case PIXELFORMAT_RGB555X: return 0; break; |
| 2164 |
case PIXELFORMAT_RGB565X: return 0; break; |
| 2165 |
case PIXELFORMAT_BGR24 : return 0; break; |
| 2166 |
case PIXELFORMAT_RGB24 : return VIDEO_PALETTE_RGB24; break; |
| 2167 |
case PIXELFORMAT_BGR32 : return 0; break; |
| 2168 |
case PIXELFORMAT_RGB32 : return VIDEO_PALETTE_RGB32; break; |
| 2169 |
|
| 2170 |
// Bayer RGB format |
| 2171 |
case PIXELFORMAT_SBGGR8 : return 0; break; |
| 2172 |
|
| 2173 |
// YUV formats |
| 2174 |
case PIXELFORMAT_GREY : return VIDEO_PALETTE_GREY; break; |
| 2175 |
case PIXELFORMAT_YUYV : return VIDEO_PALETTE_YUYV; break; |
| 2176 |
case PIXELFORMAT_UYVY : return VIDEO_PALETTE_UYVY; break; |
| 2177 |
case PIXELFORMAT_YUV420P: return VIDEO_PALETTE_YUV420; break; |
| 2178 |
case PIXELFORMAT_YUV422P: return VIDEO_PALETTE_YUV422P; break; |
| 2179 |
|
| 2180 |
// Compressed formats |
| 2181 |
case PIXELFORMAT_JPEG : return 0; break; |
| 2182 |
case PIXELFORMAT_MPEG : return 0; break; |
| 2183 |
|
| 2184 |
// Reserved formats |
| 2185 |
case PIXELFORMAT_DV : return 0; break; |
| 2186 |
case PIXELFORMAT_ET61X251:return 0; break; |
| 2187 |
case PIXELFORMAT_HI240 : return VIDEO_PALETTE_HI240; break; |
| 2188 |
case PIXELFORMAT_HM12 : return 0; break; |
| 2189 |
case PIXELFORMAT_MJPEG : return 0; break; |
| 2190 |
case PIXELFORMAT_PWC1 : return 0; break; |
| 2191 |
case PIXELFORMAT_PWC2 : return 0; break; |
| 2192 |
case PIXELFORMAT_SN9C10X: return 0; break; |
| 2193 |
case PIXELFORMAT_WNVA : return 0; break; |
| 2194 |
case PIXELFORMAT_YYUV : return 0; break; |
| 2195 |
} |
| 2196 |
break; |
| 2197 |
#endif |
1899 |
#endif |
| 2198 |
case VIDEODEV_DRIVER_NONE: |
1900 |
case VIDEODEV_DRIVER_NONE: |
| 2199 |
default: |
1901 |
default: |
|
Lines 2356-2377
QString VideoDevice::pixelFormatName(int
Link Here
|
| 2356 |
} |
2058 |
} |
| 2357 |
break; |
2059 |
break; |
| 2358 |
#endif |
2060 |
#endif |
| 2359 |
case VIDEODEV_DRIVER_V4L: |
|
|
| 2360 |
switch(pixelformat) |
| 2361 |
{ |
| 2362 |
case VIDEO_PALETTE_GREY : returnvalue = pixelFormatName(PIXELFORMAT_GREY); break; |
| 2363 |
case VIDEO_PALETTE_HI240 : returnvalue = pixelFormatName(PIXELFORMAT_RGB332); break; |
| 2364 |
case VIDEO_PALETTE_RGB555 : returnvalue = pixelFormatName(PIXELFORMAT_RGB555); break; |
| 2365 |
case VIDEO_PALETTE_RGB565 : returnvalue = pixelFormatName(PIXELFORMAT_RGB565); break; |
| 2366 |
case VIDEO_PALETTE_RGB24 : returnvalue = pixelFormatName(PIXELFORMAT_RGB24); break; |
| 2367 |
case VIDEO_PALETTE_RGB32 : returnvalue = pixelFormatName(PIXELFORMAT_RGB32); break; |
| 2368 |
case VIDEO_PALETTE_YUYV : returnvalue = pixelFormatName(PIXELFORMAT_YUYV); break; |
| 2369 |
case VIDEO_PALETTE_UYVY : returnvalue = pixelFormatName(PIXELFORMAT_UYVY); break; |
| 2370 |
case VIDEO_PALETTE_YUV420 : |
| 2371 |
case VIDEO_PALETTE_YUV420P : returnvalue = pixelFormatName(PIXELFORMAT_YUV420P); break; |
| 2372 |
case VIDEO_PALETTE_YUV422P : returnvalue = pixelFormatName(PIXELFORMAT_YUV422P); break; |
| 2373 |
} |
| 2374 |
break; |
| 2375 |
#endif |
2061 |
#endif |
| 2376 |
case VIDEODEV_DRIVER_NONE: |
2062 |
case VIDEODEV_DRIVER_NONE: |
| 2377 |
default: |
2063 |
default: |
|
Lines 2408-2456
int VideoDevice::detectPixelFormats()
Link Here
|
| 2408 |
} |
2094 |
} |
| 2409 |
// break; |
2095 |
// break; |
| 2410 |
#endif |
2096 |
#endif |
| 2411 |
case VIDEODEV_DRIVER_V4L: |
|
|
| 2412 |
// TODO: THis thing can be used to detec what pixel formats are supported in a API-independent way, but V4L2 has VIDIOC_ENUM_PIXFMT. |
| 2413 |
// The correct thing to do is to isolate these calls and do a proper implementation for V4L and another for V4L2 when this thing will be migrated to a plugin architecture. |
| 2414 |
|
| 2415 |
// Packed RGB formats |
| 2416 |
kDebug() << "Supported pixel formats:"; |
| 2417 |
if(PIXELFORMAT_NONE != setPixelFormat(PIXELFORMAT_RGB332)) { kDebug() << pixelFormatName(PIXELFORMAT_RGB332); } |
| 2418 |
if(PIXELFORMAT_NONE != setPixelFormat(PIXELFORMAT_RGB444)) { kDebug() << pixelFormatName(PIXELFORMAT_RGB444); } |
| 2419 |
if(PIXELFORMAT_NONE != setPixelFormat(PIXELFORMAT_RGB555)) { kDebug() << pixelFormatName(PIXELFORMAT_RGB555); } |
| 2420 |
if(PIXELFORMAT_NONE != setPixelFormat(PIXELFORMAT_RGB565)) { kDebug() << pixelFormatName(PIXELFORMAT_RGB565); } |
| 2421 |
if(PIXELFORMAT_NONE != setPixelFormat(PIXELFORMAT_RGB555X)) { kDebug() << pixelFormatName(PIXELFORMAT_RGB555X); } |
| 2422 |
if(PIXELFORMAT_NONE != setPixelFormat(PIXELFORMAT_RGB565X)) { kDebug() << pixelFormatName(PIXELFORMAT_RGB565X); } |
| 2423 |
if(PIXELFORMAT_NONE != setPixelFormat(PIXELFORMAT_BGR24)) { kDebug() << pixelFormatName(PIXELFORMAT_BGR24); } |
| 2424 |
if(PIXELFORMAT_NONE != setPixelFormat(PIXELFORMAT_RGB24)) { kDebug() << pixelFormatName(PIXELFORMAT_RGB24); } |
| 2425 |
if(PIXELFORMAT_NONE != setPixelFormat(PIXELFORMAT_BGR32)) { kDebug() << pixelFormatName(PIXELFORMAT_BGR32); } |
| 2426 |
if(PIXELFORMAT_NONE != setPixelFormat(PIXELFORMAT_RGB32)) { kDebug() << pixelFormatName(PIXELFORMAT_RGB32); } |
| 2427 |
|
| 2428 |
// Bayer RGB format |
| 2429 |
if(PIXELFORMAT_NONE != setPixelFormat(PIXELFORMAT_SBGGR8)) { kDebug() << pixelFormatName(PIXELFORMAT_SBGGR8); } |
| 2430 |
|
| 2431 |
// YUV formats |
| 2432 |
if(PIXELFORMAT_NONE != setPixelFormat(PIXELFORMAT_GREY)) { kDebug() << pixelFormatName(PIXELFORMAT_GREY); } |
| 2433 |
if(PIXELFORMAT_NONE != setPixelFormat(PIXELFORMAT_YUYV)) { kDebug() << pixelFormatName(PIXELFORMAT_YUYV); } |
| 2434 |
if(PIXELFORMAT_NONE != setPixelFormat(PIXELFORMAT_UYVY)) { kDebug() << pixelFormatName(PIXELFORMAT_UYVY); } |
| 2435 |
if(PIXELFORMAT_NONE != setPixelFormat(PIXELFORMAT_YUV420P)) { kDebug() << pixelFormatName(PIXELFORMAT_YUV420P); } |
| 2436 |
if(PIXELFORMAT_NONE != setPixelFormat(PIXELFORMAT_YUV422P)) { kDebug() << pixelFormatName(PIXELFORMAT_YUV422P); } |
| 2437 |
|
| 2438 |
// Compressed formats |
| 2439 |
if(PIXELFORMAT_NONE != setPixelFormat(PIXELFORMAT_JPEG)) { kDebug() << pixelFormatName(PIXELFORMAT_JPEG); } |
| 2440 |
if(PIXELFORMAT_NONE != setPixelFormat(PIXELFORMAT_MPEG)) { kDebug() << pixelFormatName(PIXELFORMAT_MPEG); } |
| 2441 |
|
| 2442 |
// Reserved formats |
| 2443 |
if(PIXELFORMAT_NONE != setPixelFormat(PIXELFORMAT_DV)) { kDebug() << pixelFormatName(PIXELFORMAT_DV); } |
| 2444 |
if(PIXELFORMAT_NONE != setPixelFormat(PIXELFORMAT_ET61X251)) { kDebug() << pixelFormatName(PIXELFORMAT_ET61X251); } |
| 2445 |
if(PIXELFORMAT_NONE != setPixelFormat(PIXELFORMAT_HI240)) { kDebug() << pixelFormatName(PIXELFORMAT_HI240); } |
| 2446 |
if(PIXELFORMAT_NONE != setPixelFormat(PIXELFORMAT_HM12)) { kDebug() << pixelFormatName(PIXELFORMAT_HM12); } |
| 2447 |
if(PIXELFORMAT_NONE != setPixelFormat(PIXELFORMAT_MJPEG)) { kDebug() << pixelFormatName(PIXELFORMAT_MJPEG); } |
| 2448 |
if(PIXELFORMAT_NONE != setPixelFormat(PIXELFORMAT_PWC1)) { kDebug() << pixelFormatName(PIXELFORMAT_PWC1); } |
| 2449 |
if(PIXELFORMAT_NONE != setPixelFormat(PIXELFORMAT_PWC2)) { kDebug() << pixelFormatName(PIXELFORMAT_PWC2); } |
| 2450 |
if(PIXELFORMAT_NONE != setPixelFormat(PIXELFORMAT_SN9C10X)) { kDebug() << pixelFormatName(PIXELFORMAT_SN9C10X); } |
| 2451 |
if(PIXELFORMAT_NONE != setPixelFormat(PIXELFORMAT_WNVA)) { kDebug() << pixelFormatName(PIXELFORMAT_WNVA); } |
| 2452 |
if(PIXELFORMAT_NONE != setPixelFormat(PIXELFORMAT_YYUV)) { kDebug() << pixelFormatName(PIXELFORMAT_YYUV); } |
| 2453 |
break; |
| 2454 |
#endif |
2097 |
#endif |
| 2455 |
case VIDEODEV_DRIVER_NONE: |
2098 |
case VIDEODEV_DRIVER_NONE: |
| 2456 |
default: |
2099 |
default: |
|
Lines 2520-2579
__u64 VideoDevice::signalStandardCode(si
Link Here
|
| 2520 |
} |
2163 |
} |
| 2521 |
break; |
2164 |
break; |
| 2522 |
#endif |
2165 |
#endif |
| 2523 |
case VIDEODEV_DRIVER_V4L: |
|
|
| 2524 |
switch(standard) |
| 2525 |
{ |
| 2526 |
case STANDARD_PAL_B : return VIDEO_MODE_PAL; break; |
| 2527 |
case STANDARD_PAL_B1 : return VIDEO_MODE_PAL; break; |
| 2528 |
case STANDARD_PAL_G : return VIDEO_MODE_PAL; break; |
| 2529 |
case STANDARD_PAL_H : return VIDEO_MODE_PAL; break; |
| 2530 |
case STANDARD_PAL_I : return VIDEO_MODE_PAL; break; |
| 2531 |
case STANDARD_PAL_D : return VIDEO_MODE_PAL; break; |
| 2532 |
case STANDARD_PAL_D1 : return VIDEO_MODE_PAL; break; |
| 2533 |
case STANDARD_PAL_K : return VIDEO_MODE_PAL; break; |
| 2534 |
|
| 2535 |
case STANDARD_PAL_M : return 5; break; // Undocumented value found to be compatible with V4L bttv driver |
| 2536 |
case STANDARD_PAL_N : return 6; break; // Undocumented value found to be compatible with V4L bttv driver |
| 2537 |
case STANDARD_PAL_Nc : return 4; break; // Undocumented value found to be compatible with V4L bttv driver |
| 2538 |
case STANDARD_PAL_60 : return VIDEO_MODE_PAL; break; |
| 2539 |
|
| 2540 |
case STANDARD_NTSC_M : return VIDEO_MODE_NTSC; break; |
| 2541 |
case STANDARD_NTSC_M_JP : return 7; break; // Undocumented value found to be compatible with V4L bttv driver |
| 2542 |
case STANDARD_NTSC_443 : return VIDEO_MODE_NTSC; break; |
| 2543 |
case STANDARD_NTSC_M_KR : return VIDEO_MODE_NTSC; break; |
| 2544 |
|
| 2545 |
case STANDARD_SECAM_B : return VIDEO_MODE_SECAM; break; |
| 2546 |
case STANDARD_SECAM_D : return VIDEO_MODE_SECAM; break; |
| 2547 |
case STANDARD_SECAM_G : return VIDEO_MODE_SECAM; break; |
| 2548 |
case STANDARD_SECAM_H : return VIDEO_MODE_SECAM; break; |
| 2549 |
case STANDARD_SECAM_K : return VIDEO_MODE_SECAM; break; |
| 2550 |
case STANDARD_SECAM_K1 : return VIDEO_MODE_SECAM; break; |
| 2551 |
case STANDARD_SECAM_L : return VIDEO_MODE_SECAM; break; |
| 2552 |
case STANDARD_SECAM_LC : return VIDEO_MODE_SECAM; break; |
| 2553 |
|
| 2554 |
case STANDARD_ATSC_8_VSB: return VIDEO_MODE_AUTO; break; |
| 2555 |
case STANDARD_ATSC_16_VSB:return VIDEO_MODE_AUTO; break; |
| 2556 |
|
| 2557 |
case STANDARD_PAL_BG : return VIDEO_MODE_PAL; break; |
| 2558 |
case STANDARD_PAL_DK : return VIDEO_MODE_PAL; break; |
| 2559 |
case STANDARD_PAL : return VIDEO_MODE_PAL; break; |
| 2560 |
case STANDARD_NTSC : return VIDEO_MODE_NTSC; break; |
| 2561 |
case STANDARD_SECAM_DK : return VIDEO_MODE_SECAM; break; |
| 2562 |
case STANDARD_SECAM : return VIDEO_MODE_SECAM; break; |
| 2563 |
|
| 2564 |
case STANDARD_MN : return VIDEO_MODE_AUTO; break; |
| 2565 |
case STANDARD_B : return VIDEO_MODE_AUTO; break; |
| 2566 |
case STANDARD_GH : return VIDEO_MODE_AUTO; break; |
| 2567 |
case STANDARD_DK : return VIDEO_MODE_AUTO; break; |
| 2568 |
|
| 2569 |
case STANDARD_525_60 : return VIDEO_MODE_PAL; break; |
| 2570 |
case STANDARD_625_50 : return VIDEO_MODE_SECAM; break; |
| 2571 |
case STANDARD_ATSC : return VIDEO_MODE_AUTO; break; |
| 2572 |
|
| 2573 |
case STANDARD_UNKNOWN : return VIDEO_MODE_AUTO; break; |
| 2574 |
case STANDARD_ALL : return VIDEO_MODE_AUTO; break; |
| 2575 |
} |
| 2576 |
break; |
| 2577 |
#endif |
2166 |
#endif |
| 2578 |
case VIDEODEV_DRIVER_NONE: |
2167 |
case VIDEODEV_DRIVER_NONE: |
| 2579 |
default: |
2168 |
default: |
|
Lines 2701-2719
QString VideoDevice::signalStandardName(
Link Here
|
| 2701 |
} |
2290 |
} |
| 2702 |
break; |
2291 |
break; |
| 2703 |
#endif |
2292 |
#endif |
| 2704 |
case VIDEODEV_DRIVER_V4L: |
|
|
| 2705 |
switch(standard) |
| 2706 |
{ |
| 2707 |
case VIDEO_MODE_PAL : returnvalue = signalStandardName(STANDARD_PAL); break; |
| 2708 |
case VIDEO_MODE_NTSC : returnvalue = signalStandardName(STANDARD_NTSC); break; |
| 2709 |
case VIDEO_MODE_SECAM : returnvalue = signalStandardName(STANDARD_SECAM); break; |
| 2710 |
case VIDEO_MODE_AUTO : returnvalue = signalStandardName(STANDARD_ALL); break; // It must be disabled until I find a correct way to handle those non-standard bttv modes |
| 2711 |
// case VIDEO_MODE_PAL_Nc : returnvalue = signalStandardName(STANDARD_PAL_Nc); break; // Undocumented value found to be compatible with V4L bttv driver |
| 2712 |
case VIDEO_MODE_PAL_M : returnvalue = signalStandardName(STANDARD_PAL_M); break; // Undocumented value found to be compatible with V4L bttv driver |
| 2713 |
case VIDEO_MODE_PAL_N : returnvalue = signalStandardName(STANDARD_PAL_N); break; // Undocumented value found to be compatible with V4L bttv driver |
| 2714 |
case VIDEO_MODE_NTSC_JP : returnvalue = signalStandardName(STANDARD_NTSC_M_JP); break; // Undocumented value found to be compatible with V4L bttv driver |
| 2715 |
} |
| 2716 |
break; |
| 2717 |
#endif |
2293 |
#endif |
| 2718 |
case VIDEODEV_DRIVER_NONE: |
2294 |
case VIDEODEV_DRIVER_NONE: |
| 2719 |
default: |
2295 |
default: |
|
Lines 2779-2786
int VideoDevice::detectSignalStandards()
Link Here
|
| 2779 |
|
2355 |
|
| 2780 |
break; |
2356 |
break; |
| 2781 |
#endif |
2357 |
#endif |
| 2782 |
case VIDEODEV_DRIVER_V4L: |
|
|
| 2783 |
break; |
| 2784 |
#endif |
2358 |
#endif |
| 2785 |
case VIDEODEV_DRIVER_NONE: |
2359 |
case VIDEODEV_DRIVER_NONE: |
| 2786 |
default: |
2360 |
default: |
