Video-ivtv-0.13/0000755000076400003530000000000010134550135012670 5ustar james00000000000000Video-ivtv-0.13/ivtv.pm0000644000076400003530000001255010063116512014217 0ustar james00000000000000package Video::ivtv; use 5.006; use strict; use warnings; require Exporter; require DynaLoader; use vars qw($VERSION @ISA @EXPORT); @ISA = qw(Exporter DynaLoader); # Items to export into callers namespace by default. Note: do not export # names by default without a very good reason. Use EXPORT_OK instead. # Do not simply export all your public functions/methods/constants. @EXPORT = qw( ); $VERSION = '0.13'; bootstrap Video::ivtv $VERSION; sub new { my $that = shift; my $class = ref($that) || $that; my $self = bless {}, $class; $self->{codecIndexes} = { aspect => 0, audio_bitmask => 1, # audio renamed to audio_bitmask bframes => 2, bitrate_mode => 3, bitrate => 4, bitrate_peak => 5, dnr_mode => 6, dnr_spatial => 7, dnr_temporal => 8, dnr_type => 9, framerate => 10, framespergop => 11, gop_closure => 12, pulldown => 13, stream_type => 14, }; $self->{capIndexes} = { driver => 0, card => 1, bus_info => 2, version => 3, capabilities => 4, }; return $self; } # Preloaded methods go here. 1; __END__ # Below is stub documentation for your module. You better edit it! =head1 NAME Video::ivtv - Perl extension for using V4l2 in the ivtv perl scripts =head1 SYNOPSIS use Video::ivtv; open(my $tuner, "new(); # get the current resolution my ($width, $height) = $ivtvObj->getResolution($tunerFD); # set the new resolution $ivtvObj->setResolution($tunerFD, 640, 480); close($tuner); =head1 DESCRIPTION The Video::ivtv module will provide helper methods for working with videodev2.h structures and making ioctl calls that have proven to be too difficult to create pack strings for in perl itself. This is not supposed to be an equivalent of the Video::Capture::V4l module which was created for videodev.h. =head2 EXPORT All functions and the variables section. =head1 VARIABLES =over 4 =item %codecIndexes This contains the index names and their position in the ivtv_ioctl_codec structure as returned by getCodecInfo() and as expected by setCodecInfo(). =item %capIndexes This contains the index names and their position in the v4l2_capability structure as returned by getCapabilities(). =back =head1 FUNCTIONS =over 4 =item @(driver, card, bus_info, version, capabilities) getCapabilities(fd) Returns the contents of the v4l2_capability structure. If the ioctl fails, then an empty list is returned. =item @(width,height) getResolution(fd) Pass in the file handle number using fileno($fd) and the width and height are returned in an array ref. If an error is encountered in the ioctl call, then width and height will = -1. =item int setResolution(fd, width, height) Specify the new width, height to set the capture to. Returns undef if invalid resolution is specified. Returns a 1 if sucess, 0 if error from the actual code. =item int getStandard(fd) Returns the current video standard the card is using. =item int setStandard(fd, standard) Sets the video standard to what is specified (hex value). Returns 1 on success, 0 on error. =item @(index, id, name, frameperiod_numerator, frameperiod_denominator, framelines) enumerateStandard(fd, index) Returns the contents of the v4l2_standard structure for the specified index. If the ioctl fails then index = -1. =item int getFrequency(fd, tuner) Returns the current frequency for the specified tuner or -1 if an ioctl error occured. Returns undef on invalid parameters. =item int setFrequency(fd, tuner, freq) Sets the specified frequency on the specified tuner. Returns 1 on success, 0 on error. =item int getInput(fd) Returns the current input number starting from 0. Returns -1 if an error occured. =item int setInput(fd, input) Sets the input to the specified value. input is a 0 indexed value. Returns 1 on success, 0 on error. =item @(index, name, type, audioset, tuner, std, status) enumerateInput(fd, index) Returns the contents of the v4l2_input structure for the specified index. If the ioctl fails then index = -1. =item @(aspect, audio_bitmask, bframes, bitrate, bitrate_peak, dnr_mode, dnr_spatial, dnr_temporal, dnr_type, framerate, framespergop, gop_closure, pulldown, stream_type) getCodecInfo(fd) Returns the contents of the ivtv_ioctl_codec structure. If the ioctl fails then an empty list is returned. audio_bitmask is what audio used to be. =item int setCodecInfo(fd, aspect, audio_bitmask, bframes, bitrate, bitrate_peak, dnr_mode, dnr_spatial, dnr_temporal, dnr_type, framerate, framespergop, gop_closure, pulldown, stream_type) Sets the card to the specified codec related stuff. Returns 1 on success, 0 on error. audio_bitmask is what audio used to be. =item int setEndGOP(fd, end_gop) Sets the GOP_END flag to the specified value (1 or 0) to instruct the driver to finish a recording with a closed GOP. Returns undef if end_gop < 0 or > 1. Returns 1 on success, 0 on error. =item int stopEncoding(fd) Calls the VIDIOC_STREAMOFF ioctl to signal we want to stop encoding (reading from the driver). Returns 1 on success, 0 on error. =back =head1 AUTHOR James A. Pattie =head1 SEE ALSO L. =cut Video-ivtv-0.13/ivtv.xs0000644000076400003530000001622010063141034014230 0ustar james00000000000000#include "EXTERN.h" #include "perl.h" #include "XSUB.h" #include /* we don't want linux/time.h */ #define _LINUX_TIME_H 1 #include "videodev2.h" #include #include "ivtv.h" MODULE = Video::ivtv PACKAGE = Video::ivtv void getResolution(SV * self, IN int fd, OUTLIST int width, OUTLIST int height) INIT: struct v4l2_format vfmt; CODE: vfmt.type = V4L2_BUF_TYPE_VIDEO_CAPTURE; if (ioctl(fd, VIDIOC_G_FMT, &vfmt) < 0) { /* return an invalid case to signal an error occured */ width = height = -1; } else { width = vfmt.fmt.pix.width; height = vfmt.fmt.pix.height; } int setResolution(SV * self, int fd, int width, int height) INIT: struct v4l2_format vfmt; /* make sure we have valid input values. */ if (width < 0 || width > 720) { XSRETURN_UNDEF; } if (height < 0 || height > 576) { XSRETURN_UNDEF; } CODE: vfmt.type = V4L2_BUF_TYPE_VIDEO_CAPTURE; /* make sure the buf type is set for Video Capture! */ vfmt.fmt.pix.width = width; vfmt.fmt.pix.height = height; if (ioctl(fd, VIDIOC_S_FMT, &vfmt) < 0) { /* return an invalid case to signal an error occured */ RETVAL = 0; } else { RETVAL = 1; } OUTPUT: RETVAL int getStandard(SV * self, int fd) INIT: v4l2_std_id n; CODE: if (ioctl(fd, VIDIOC_G_STD, &n) < 0) { RETVAL = 0; } else { RETVAL = n; } OUTPUT: RETVAL int setStandard(SV * self, int fd, int standard) CODE: if (ioctl(fd, VIDIOC_S_STD, &standard) < 0) { RETVAL = 0; } else { RETVAL = 1; } OUTPUT: RETVAL void enumerateStandard(SV * self, IN int fd, IN_OUTLIST int index, OUTLIST int std_id, OUTLIST char *name, OUTLIST int numerator, OUTLIST int denominator, OUTLIST int framelines) INIT: struct v4l2_standard vs; if (index < 0) { XSRETURN_UNDEF; } CODE: vs.index = index; if (ioctl(fd, VIDIOC_ENUMSTD, &vs) < 0) { /* return an invalid case to signal an error occured */ index = -1; name = ""; numerator = 0; denominator = 0; framelines = 0; } else { std_id = vs.id; name = vs.name; numerator = vs.frameperiod.numerator; denominator = vs.frameperiod.denominator; framelines = vs.framelines; } int getFrequency(SV * self, int fd, int tuner) INIT: struct v4l2_frequency vf; if (tuner < 0) { XSRETURN_UNDEF; } CODE: vf.tuner = tuner; if (ioctl(fd, VIDIOC_G_FREQUENCY, &vf) < 0) { RETVAL = -1; } else { RETVAL = vf.frequency; } OUTPUT: RETVAL int setFrequency(SV * self, int fd, int tuner, int freq) INIT: struct v4l2_frequency vf; if (tuner < 0) { XSRETURN_UNDEF; } if (freq < 0) { XSRETURN_UNDEF; } CODE: vf.tuner = tuner; vf.frequency = freq; if (ioctl(fd, VIDIOC_S_FREQUENCY, &vf) < 0) { RETVAL = 0; } else { RETVAL = 1; } OUTPUT: RETVAL int getInput(SV * self, int fd) INIT: int input; CODE: if (ioctl(fd, VIDIOC_G_INPUT, &input) < 0) { RETVAL = -1; } else { RETVAL = input; } OUTPUT: RETVAL int setInput(SV * self, int fd, int input) INIT: if (input < 0) { XSRETURN_UNDEF; } CODE: if (ioctl(fd, VIDIOC_S_INPUT, &input) < 0) { RETVAL = 0; } else { RETVAL = 1; } OUTPUT: RETVAL void enumerateInput(SV * self, IN int fd, IN_OUTLIST int index, OUTLIST char *name, OUTLIST int type, OUTLIST int audioset, OUTLIST int tuner, OUTLIST int std, OUTLIST int status) INIT: struct v4l2_input vi; if (index < 0) { XSRETURN_UNDEF; } CODE: vi.index = index; if (ioctl(fd, VIDIOC_ENUMINPUT, &vi) < 0) { /* return an invalid case to signal an error occured */ index = -1; name = ""; type = 0; audioset = 0; tuner = 0; std = 0; status = 0; } else { name = vi.name; type = vi.type; audioset = vi.audioset; tuner = vi.tuner; std = vi.std; status = vi.status; } void getCodecInfo(SV * self, IN int fd, OUTLIST int aspect, OUTLIST int audio_bitmask, OUTLIST int bframes, OUTLIST int bitrate_mode, OUTLIST int bitrate, OUTLIST int bitrate_peak, OUTLIST int dnr_mode, OUTLIST int dnr_spatial, OUTLIST int dnr_temporal, OUTLIST int dnr_type, OUTLIST int framerate, OUTLIST int framespergop, OUTLIST int gop_closure, OUTLIST int pulldown, OUTLIST int stream_type) INIT: struct ivtv_ioctl_codec codec; CODE: if (ioctl(fd, IVTV_IOC_G_CODEC, &codec) < 0) { /* an error occured, hopefully this is returning an empty array. */ } else { aspect = codec.aspect; audio_bitmask = codec.audio_bitmask; bframes = codec.bframes; bitrate_mode = codec.bitrate_mode; bitrate = codec.bitrate; bitrate_peak = codec.bitrate_peak; dnr_mode = codec.dnr_mode; dnr_spatial = codec.dnr_spatial; dnr_temporal = codec.dnr_temporal; dnr_type = codec.dnr_type; framerate = codec.framerate; framespergop = codec.framespergop; gop_closure = codec.gop_closure; pulldown = codec.pulldown; stream_type = codec.stream_type; } int setCodecInfo(SV * self, int fd, int aspect, int audio_bitmask, int bframes, int bitrate_mode, int bitrate, int bitrate_peak, int dnr_mode, int dnr_spatial, int dnr_temporal, int dnr_type, int framerate, int framespergop, int gop_closure, int pulldown, int stream_type) INIT: struct ivtv_ioctl_codec codec; /* make sure we have valid input values. */ CODE: codec.aspect = aspect; codec.audio_bitmask = audio_bitmask; codec.bframes = bframes; codec.bitrate_mode = bitrate_mode; codec.bitrate = bitrate; codec.bitrate_peak = bitrate_peak; codec.dnr_mode = dnr_mode; codec.dnr_spatial = dnr_spatial; codec.dnr_temporal = dnr_temporal; codec.dnr_type = dnr_type; codec.framerate = framerate; codec.framespergop = framespergop; codec.gop_closure = gop_closure; codec.pulldown = pulldown; codec.stream_type = stream_type; if (ioctl(fd, IVTV_IOC_S_CODEC, &codec) < 0) { /* return an invalid case to signal an error occured */ RETVAL = 0; } else { RETVAL = 1; } OUTPUT: RETVAL void getCapabilities(SV * self, IN int fd, OUTLIST char *driver, OUTLIST char *card, OUTLIST char *bus_info, OUTLIST int version, OUTLIST int capabilities) INIT: struct v4l2_capability vcap; CODE: if (ioctl(fd, VIDIOC_QUERYCAP, &vcap) < 0) { /* an error occured, hopefully this is returning an empty array. */ } else { driver = vcap.driver; card = vcap.card; bus_info = vcap.bus_info; version = vcap.version; capabilities = vcap.capabilities; } int setEndGOP(SV * self, int fd, int end_gop) INIT: if (end_gop < 0 || end_gop > 1) { XSRETURN_UNDEF; } CODE: if (ioctl(fd, IVTV_IOC_S_GOP_END, &end_gop) < 0) { RETVAL = 0; } else { RETVAL = 1; } OUTPUT: RETVAL int stopEncoding(SV * self, int fd) CODE: if (ioctl(fd, VIDIOC_STREAMOFF) < 0) { RETVAL = 0; } else { RETVAL = 1; } OUTPUT: RETVAL Video-ivtv-0.13/README0000644000076400003530000000253610134547672013572 0ustar james00000000000000Video/ivtv version 0.13 ======================= Video::ivtv is designed to be a quick hack at making the record-v4l2.pl script not have to depend on the test_ioctl program included with the ivtv utils. By moving to have the things that have proven difficult to do purely in perl to C where they currently are being done, I can concentrate on improving the code rather than hitting my head against the wall trying to do code cleanups. ;) INSTALLATION To install this module type the following: perl Makefile.PL make make test make install DEPENDENCIES This module requires these other modules and libraries: v4l2: videodev2.h - included ivtv: ivtv.h - Codec interface definitions (included) COPYRIGHT AND LICENCE Copyright (C) 2003-2004 James A. Pattie NOTES 0.10 relies on the bitrate_mode patch being applied in CVS. This was added June 19, 2003. 0.11 relies on the audio -> audio_bitmask patch being applied in CVS. This was added June 25, 2003 and fixed June 26, 2003. 0.13 is against the ivtv-0.2.0rc1g driver which should be pretty much what the 0.2.0 driver will be (feature wise). CAUTION: The setMSPMatrix support is now removed as that feature is no longer publicaly available from the driver and is supposedly no longer required to make the audio work after channel changes. Video-ivtv-0.13/Changes0000644000076400003530000000532610134547640014200 0ustar james00000000000000Revision history for Perl extension Video::ivtv. 0.01 Sat May 3 22:32:47 2003 - original version; created by h2xs 1.21 with options -Afn Video::ivtv - implemented the getResolution() method. - implemented the setResolution() method. 0.02 Sun May 4 20:17:57 2003 - implemented the getStandard() / setStandard() methods. 0.03 Wed May 7 21:15:45 2003 - modified getResolution() to return an array! - improved the test file to reset the previous resolution. - implemented the getFrequency() / setFrequency() methods. 0.04 Sat May 10 12:10:09 2003 - Exporting all methods so you don't have to do Video::ivtv::method(). - Making getFrequency return -1 if an ioctl error since it could be returning frequency = 0. - implemented the getInput() / setInput() methods. - implemented enumerateStandard(), enumerateInput() methods. 0.05 Mon May 12 20:00:00 2003 - Added initial support for the Codec hack that is currently in the ivtv cvs code. Had to create ivtv.h to define the needed structures. - implemented the getCodecInfo() / setCodecInfo() methods. 0.06 Fri May 16 20:30:00 2003 - Moved to an Object Oriented interface and removed all exporting of methods and variables into the callers namespace. 0.07 Mon May 19 19:30:30 2003 - Updated POD documentation to reflect the new OO changes in 0.06. 0.08 Sat May 24 16:17:20 2003 - Added getCapabilities() method to help determine the driver in use. 0.09 Sat Jun 14 13:30:30 2003 - Fixing the segfault issues with using int's instead of the variables that are in the v4l2 structures. - Updating the test code to hopefully more correctly use the ok() method so that ok/fail is properly handled. Fixed the last $self errors. - Added the default values in those cases that Arthur Britto thinks were causing him to have segfault issues. 0.10 Sat Jun 21 09:00:00 2003 - Updating the ivtv_ioctl_codec structure and the get/setCodecInfo() methods in regards to the new bitrate_mode variable. 0.11 Wed Jun 25 22:00:00 2003 - Updating the ivtv_ioctl_codec structure and the get/setCodecInfo() methods in regards to the audio -> audio_bitmask variable. 0.12 Sun Jul 13 20:15:00 2003 - Added mspMatrixSet to allow setting the msp matrix to make sure that audio always works after the user switches Video Standards. - Updated the ivtv.h file to contain the ivtv-ext-api.h from the utils dir. 0.13 Sun Jun 13 13:11:00 2004 - Updated ivtv.h and videodev2.h from ivtv-0.1.10-pre2-ck90k. - Removed the mspMatrixSet support. - Added setGopEnd() and stopEncoding() methods to allow the programmer to take advantage of the new, capture a complete GOP, feature that Chris Kennedy implemented. - Updated ivtv.h from ivtv-0.2.0rc1g. Video-ivtv-0.13/test.pl0000644000076400003530000001546710063116306014220 0ustar james00000000000000# Before `make install' is performed this script should be runnable with # `make test'. After `make install' it should work as `perl test.pl' ######################### # change 'tests => 1' to 'tests => last_test_to_print'; use Test; BEGIN { plan tests => 16 }; use Video::ivtv; my $ivtvObj = Video::ivtv->new(); ok (defined $ivtvObj); my $dev = "/dev/video0"; open (my $tuner, "<$dev") or die "Error opening $dev! $!\n"; my $tunerFD = fileno($tuner); my ($oldwidth, $oldheight) = $ivtvObj->getResolution($tunerFD); print "Width = $oldwidth, Height = $oldheight\n"; ok ($oldwidth != -1 && $oldheight != -1); my $result = $ivtvObj->setResolution($tunerFD, 640, 480); if (defined $result) { if ($result) { my ($width, $height) = $ivtvObj->getResolution($tunerFD); if ($width == 640 && $height == 480) { ok(3); # restore the previous setting. $result = $ivtvObj->setResolution($tunerFD, $oldwidth, $oldheight); } else { print "Error: width='$width', height='$height'\n"; ok ($width ==640 && $height == 480); } } else { ok ($result); } } else { ok (defined $result); } my $standard = $ivtvObj->getStandard($tunerFD); ok ($standard == 0x00003000 || $standard == 0x000000FF || $standard == 0x007F0000); # set the Video Standard to NTSC (0x3000) $result = $ivtvObj->setStandard($tunerFD, 0x00003000); if ($result) { my $newStandard = $ivtvObj->getStandard($tunerFD); ok ($newStandard == $standard); # restore the previous standard. $ivtvObj->setStandard($tunerFD, $standard); } else { ok ($result); } my $freq = $ivtvObj->getFrequency($tunerFD, 0); ok ($freq != 0); # set the Video Frequency to 8276 (SCiFI) $result = $ivtvObj->setFrequency($tunerFD, 0, 8276); if ($result) { # verify the frequency got set to what we want. my $newfreq = $ivtvObj->getFrequency($tunerFD, 0); ok ($newfreq == 8276); # restore the previous frequency value $result = $ivtvObj->setFrequency($tunerFD, 0, $freq); } else { ok ($result); } # get the Video Input my $input = $ivtvObj->getInput($tunerFD); ok ($input >= 0); print "input = '$input'\n"; # set the Video Input $result = $ivtvObj->setInput($tunerFD, 4); # Tuner on my card. if ($result) { # verify the input got set to what I wanted. my $newInput = $ivtvObj->getInput($tunerFD); ok ($newInput, 4, "Input = '$newInput' instead of 4!"); # reset the input back to what it was originally. $ivtvObj->setInput($tunerFD, $input); } else { ok ($result); } # enumerate the available Standards my $done = 0; my $index; for ($index=0; !$done; ++$index) { my ($i, $id, $name, $numerator, $denominator, $framelines) = $ivtvObj->enumerateStandard($tunerFD, $index); if ($i == -1) { $done = 1; # this index is invalid. } else { printf("%d 0x%08x %s %d/%d %d\n", $i, $id, $name, $numerator, $denominator, $framelines); } } ok ($index > 0); # enumerate the available Inputs $done = 0; $index; for ($index=0; !$done; ++$index) { my ($i, $name, $type, $audioset, $tuner, $std, $status) = $ivtvObj->enumerateInput($tunerFD, $index); if ($i == -1) { $done = 1; # this index is invalid. } else { printf("%d %s 0x%08x 0x%08x 0x%08x 0x%08x %d\n", $i, $name, $type, $audioset, $tuner, $std, $status); } } ok ($index > 0); # get the capabilities and make sure we are working with the ivtv driver before doing the next tests. my @capabilities = $ivtvObj->getCapabilities($tunerFD); if (scalar @capabilities != scalar(keys %{$ivtvObj->{capIndexes}})) { ok (12, 0, "getCapabilities() returned " . int(@capabilities) . " values!\n"); } else { if ($capabilities[$ivtvObj->{capIndexes}{driver}] ne "ivtv") { print "I cannot test the ivtv codec options as your v4l2 driver = '$capabilities[$ivtvObj->{capIndexes}{driver}]' instead of 'ivtv'.\n"; ok(12); } else { print "driver = $capabilities[$ivtvObj->{capIndexes}{driver}]\n"; print "card = $capabilities[$ivtvObj->{capIndexes}{card}]\n"; print "bus_info = $capabilities[$ivtvObj->{capIndexes}{bus_info}]\n"; print "version = $capabilities[$ivtvObj->{capIndexes}{version}]\n"; print "capabilities = $capabilities[$ivtvObj->{capIndexes}{capabilities}]\n"; ok(12); # get the current codec settings my @codec = $ivtvObj->getCodecInfo($tunerFD); if (scalar @codec == scalar(keys %{$ivtvObj->{codecIndexes}})) { print "Current codec info:\n"; print "aspect: $codec[$ivtvObj->{codecIndexes}{aspect}]\naudio_bitmask: $codec[$ivtvObj->{codecIndexes}{audio_bitmask}]\nbframes: $codec[$ivtvObj->{codecIndexes}{bframes}]\n"; print "bitrate_mode: $codec[$ivtvObj->{codecIndexes}{bitrate_mode}]\nbitrate: $codec[$ivtvObj->{codecIndexes}{bitrate}]\nbitrate_peak: $codec[$ivtvObj->{codecIndexes}{bitrate_peak}]\ndnr_mode: $codec[$ivtvObj->{codecIndexes}{dnr_mode}]\n"; print "dnr_spatial: $codec[$ivtvObj->{codecIndexes}{dnr_spatial}]\ndnr_temporal: $codec[$ivtvObj->{codecIndexes}{dnr_temporal}]\ndnr_type: $codec[$ivtvObj->{codecIndexes}{dnr_type}]\n"; print "framerate: $codec[$ivtvObj->{codecIndexes}{framerate}]\nframespergop: $codec[$ivtvObj->{codecIndexes}{framespergop}]\ngop_closure: $codec[$ivtvObj->{codecIndexes}{gop_closure}]\n"; print "pulldown: $codec[$ivtvObj->{codecIndexes}{pulldown}]\nstream_type: $codec[$ivtvObj->{codecIndexes}{stream_type}]\n"; ok(13); } else { ok (13, 0, "getCodecInfo() returned " . int(@codec) . " values!\n"); } # test setting them, then restore my @newCodec = $ivtvObj->getCodecInfo($tunerFD); $newCodec[$codecIndexes{bitrate}] = 6500000; # change the bitrate value $newCodec[$codecIndexes{bitrate_peak}] = 9000000; # change the bitrate_peak value $result = $ivtvObj->setCodecInfo($tunerFD, @newCodec); if ($result) { # verify that the values are what I set. my @testCodec = $ivtvObj->getCodecInfo($tunerFD); if ($testCodec[$ivtvObj->{codecIndexes}{bitrate}] == $newCodec[$ivtvObj->{codecIndexes}{bitrate}] && $testCodec[$ivtvObj->{codecIndexes}{bitrate_peak}] == $newCodec[$ivtvObj->{codecIndexes}{bitrate_peak}]) { # restore the original values. $result = $ivtvObj->setCodecInfo($tunerFD, @codec); ok(14); } else { ok (14, 0, "getCodecInfo() returned bitrate = '$testCodec[$ivtvObj->{codecIndexes}{bitrate}]', bitrate_peak = '$testCodec[$ivtvObj->{codecIndexes}{bitrate_peak}]'\n"); } } else { ok (0); } # verify the setEndGOP method is correctly bombing out if given invalid parameters. $result = $ivtvObj->setEndGOP($tunerFD, -1); ok (undef, $result, "setEndGOP(-1) returned '$result'\n"); $result = $ivtvObj->setEndGOP($tunerFD, 2); ok (undef, $result, "setEndGOP(2) returned '$result'\n"); } } ######################### # Insert your test code below, the Test module is use()ed here so read # its man page ( perldoc Test ) for help writing this test script. Video-ivtv-0.13/debian/0000755000076400003530000000000010134550135014112 5ustar james00000000000000Video-ivtv-0.13/debian/control0000644000076400003530000000125010063117474015521 0ustar james00000000000000Source: libvideo-ivtv-perl Section: perl Priority: optional Build-Depends: debhelper (>= 3.0.5), perl (>= 5.8.0-7) Maintainer: James A. Pattie Standards-Version: 3.6.1 Package: libvideo-ivtv-perl Architecture: any Depends: perl (>= 5.8.0), ${shlibs:Depends}, ${misc:Depends} Description: Perl extension for using V4l2 in the ivtv perl scripts The Video::ivtv module will provide helper methods for working with videodev2.h structures and making ioctl calls that have proven to be too difficult to create pack strings for in perl itself. . This is not supposed to be an equivalent of the Video::Capture::V4l module which was created for videodev.h. Video-ivtv-0.13/debian/rules0000755000076400003530000000343510063117373015203 0ustar james00000000000000#!/usr/bin/make -f #-*- makefile -*- # Made with the aid of dh_make, by Craig Small # Sample debian/rules that uses debhelper. GNU copyright 1997 by Joey Hess. # Some lines taken from debmake, by Christoph Lameter. # Uncomment this to turn on verbose mode. #export DH_VERBOSE=1 PACKAGE=$(shell dh_listpackages) ifndef PERL PERL = /usr/bin/perl endif ifndef DESTDIR DESTDIR=.. endif TMP =`pwd`/debian/$(PACKAGE) OPTIMIZE = -O2 -Wall ifneq (,$(findstring debug,$(DEB_BUILD_OPTIONS))) OPTIMIZE += -g endif build: build-stamp build-stamp: dh_testdir # Add here commands to compile the package. $(PERL) Makefile.PL INSTALLDIRS=vendor $(MAKE) OPTIMIZE="$(OPTIMIZE)" LD_RUN_PATH="" touch build-stamp clean: dh_testdir dh_testroot rm -f build-stamp # Add here commands to clean up after the build process. -$(MAKE) realclean dh_clean install: dh_testdir dh_testroot dh_clean -k dh_installdirs # Add here commands to install the package into debian/tmp. #$(MAKE) install DESTDIR=`pwd`/debian/tmp $(MAKE) install PREFIX=$(TMP)/usr # Build architecture-independent files here. binary-indep: build install # We have nothing to do by default. # Build architecture-dependent files here. binary-arch: build install dh_testdir dh_testroot dh_installdocs README dh_installexamples dh_installmenu # dh_installemacsen # dh_installinit dh_installcron dh_installman dh_installchangelogs Changes dh_link dh_strip dh_compress dh_fixperms # dh_makeshlibs dh_installdeb dh_perl dh_shlibdeps dh_gencontrol dh_md5sums dh_builddeb --destdir=$(DESTDIR) source diff: @echo >&2 'source and diff are obsolete - use dpkg-source -b'; false binary: binary-indep binary-arch .PHONY: build clean binary-indep binary-arch binary Video-ivtv-0.13/debian/changelog0000644000076400003530000000101110134550021015747 0ustar james00000000000000libvideo-ivtv-perl (0.13-2) unstable; urgency=low * Updated to cover the 0.2.0rc1g driver version. -- James A. Pattie Sun, 17 Oct 2004 15:03:00 -0500 libvideo-ivtv-perl (0.13-1) unstable; urgency=low * Updated to cover the 0.1.10-pre2-ck90k driver version. -- James A. Pattie Sun, 13 Jun 2004 13:38:42 -0500 libvideo-ivtv-perl (0.12-1) unstable; urgency=low * Initial Release. -- James A. Pattie Sat, 23 Aug 2003 16:06:42 -0500 Video-ivtv-0.13/debian/compat0000644000076400003530000000000210063117373015314 0ustar james000000000000004 Video-ivtv-0.13/debian/copyright0000644000076400003530000000072010063117373016050 0ustar james00000000000000This is the debian package for the Video::ivtv module. It was created by James A. Pattie using dh-make-perl. The upstream author is: James A. Pattie . This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License. On Debian GNU/Linux systems, the complete text of the GNU General Public License can be found in `/usr/share/common-licenses/GPL'. Video-ivtv-0.13/Makefile.PL0000644000076400003530000000143507655276140014664 0ustar james00000000000000use ExtUtils::MakeMaker; # See lib/ExtUtils/MakeMaker.pm for details of how to influence # the contents of the Makefile that is written. WriteMakefile( 'NAME' => 'Video::ivtv', 'VERSION_FROM' => 'ivtv.pm', # finds $VERSION 'PREREQ_PM' => {}, # e.g., Module::Name => 1.1 ($] >= 5.005 ? ## Add these new keywords supported since 5.005 (ABSTRACT_FROM => 'ivtv.pm', # retrieve abstract from module AUTHOR => 'James A. Pattie ') : ()), 'LIBS' => [''], # e.g., '-lm' 'DEFINE' => '', # e.g., '-DHAVE_SOMETHING' # Insert -I. if you add *.h files later: 'INC' => '-I.', # e.g., '-I/usr/include/other' # Un-comment this if you add C files to link with later: # 'OBJECT' => '$(O_FILES)', # link all the C files too ); Video-ivtv-0.13/ivtv.h0000644000076400003530000002660010132077133014035 0ustar james00000000000000/* Public ivtv API header Copyright (C) 2003-2004 Kevin Thayer VBI portions: Copyright (C) 2004 Hans Verkuil This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ #ifndef _LINUX_IVTV_H #define _LINUX_IVTV_H /* Stream types */ #define IVTV_STREAM_PS 0 #define IVTV_STREAM_TS 1 #define IVTV_STREAM_MPEG1 2 #define IVTV_STREAM_PES_AV 3 #define IVTV_STREAM_PES_V 5 #define IVTV_STREAM_PES_A 7 #define IVTV_STREAM_DVD 10 #define IVTV_STREAM_VCD 11 #define IVTV_STREAM_SVCD 12 #define IVTV_STREAM_DVD_S1 13 #define IVTV_STREAM_DVD_S2 14 #define IVTV_SLICED_TELETEXT_B (1 << 0) #define IVTV_SLICED_CAPTION_625 (1 << 1) #define IVTV_SLICED_CAPTION_525 (1 << 2) #define IVTV_SLICED_WSS_625 (1 << 3) #define IVTV_SLICED_VPS (1 << 4) struct ivtv_sliced_vbi_format { unsigned long service_set; /* one or more of the IVTV_SLICED_ defines */ unsigned long packet_size; /* the size in bytes of the ivtv_sliced_data packet */ unsigned long io_size; /* maximum number of bytes passed by one read() call */ unsigned long reserved; }; /* This structure is the same as the proposed v4l2_sliced_data structure */ /* id is one of the VBI_SLICED_ flags. */ struct ivtv_sliced_data { unsigned long id; unsigned long line; unsigned char data[]; }; /* The four bit VBI data type found in the embedded VBI data of an MPEG stream has one of the following values: */ #define VBI_TYPE_TELETEXT 0x1 // Teletext (uses lines 6-22 for PAL, 10-21 for NTSC) #define VBI_TYPE_CC 0x4 // Closed Captions (line 21 NTSC, line 22 PAL) #define VBI_TYPE_WSS 0x5 // Wide Screen Signal (line 20 NTSC, line 23 PAL) #define VBI_TYPE_VPS 0x7 // Video Programming System (PAL) (line 16) /* These data types are not (yet?) used but are already reserved for future use. */ #ifdef IVTV_INTERNAL #define VBI_TYPE_NABST 0x2 // NABST (NTSC) #define VBI_TYPE_MOJI 0x3 // MOJI (NTSC) #define VBI_TYPE_VITC 0x6 // Vertical Interval Time Code #define VBI_TYPE_GEMSTAR2X 0x7 // Gemstar TV Guide (NTSC) #define VBI_TYPE_GEMSTAR1X 0x8 // Gemstar TV Guide (NTSC) #endif /* device ioctls should use the range 29-199 */ #define IVTV_IOC_START_DECODE _IOW ('@', 29, struct ivtv_cfg_start_decode) #define IVTV_IOC_STOP_DECODE _IOW ('@', 30, struct ivtv_cfg_stop_decode) #define IVTV_IOC_G_SPEED _IOR ('@', 31, struct ivtv_speed) #define IVTV_IOC_S_SPEED _IOW ('@', 32, struct ivtv_speed) #define IVTV_IOC_DEC_STEP _IOW ('@', 33, int) #define IVTV_IOC_DEC_FLUSH _IOW ('@', 34, int) #define IVTV_IOC_S_VBI_MODE _IOWR('@', 35, struct ivtv_sliced_vbi_format) #define IVTV_IOC_G_VBI_MODE _IOR ('@', 36, struct ivtv_sliced_vbi_format) #define IVTV_IOC_PLAY _IO ('@', 37) #define IVTV_IOC_PAUSE _IO ('@', 38) #define IVTV_IOC_FRAMESYNC _IOR ('@', 39, struct ivtv_ioctl_framesync) #define IVTV_IOC_GET_TIMING _IOR ('@', 40, struct ivtv_ioctl_framesync) #define IVTV_IOC_S_SLOW_FAST _IOW ('@', 41, struct ivtv_slow_fast) #define IVTV_IOC_S_START_DECODE _IOW ('@', 42, struct ivtv_cfg_start_decode) #define IVTV_IOC_S_STOP_DECODE _IOW ('@', 43, struct ivtv_cfg_stop_decode) #define IVTV_IOC_GET_FB _IOR ('@', 44, int) #define IVTV_IOC_G_CODEC _IOR ('@', 48, struct ivtv_ioctl_codec) #define IVTV_IOC_S_CODEC _IOW ('@', 49, struct ivtv_ioctl_codec) #define IVTV_IOC_S_GOP_END _IOWR('@', 50, int) #define IVTV_IOC_S_VBI_PASSTHROUGH _IOW ('@', 51, int) #define IVTV_IOC_G_VBI_PASSTHROUGH _IOR ('@', 52, int) #define IVTV_IOC_PASSTHROUGH _IOW ('@', 53, int) #define IVTV_IOC_S_VBI_EMBED _IOW ('@', 54, int) #define IVTV_IOC_G_VBI_EMBED _IOR ('@', 55, int) #define IVTV_IOC_PAUSE_ENCODE _IO ('@', 56) #define IVTV_IOC_RESUME_ENCODE _IO ('@', 57) /* Custom v4l controls */ #ifndef V4L2_CID_PRIVATE_BASE #define V4L2_CID_PRIVATE_BASE 0x08000000 #endif #define V4L2_CID_IVTV_FREQ (V4L2_CID_PRIVATE_BASE) #define V4L2_CID_IVTV_ENC (V4L2_CID_PRIVATE_BASE + 1) #define V4L2_CID_IVTV_BITRATE (V4L2_CID_PRIVATE_BASE + 2) #define V4L2_CID_IVTV_MONO (V4L2_CID_PRIVATE_BASE + 3) #define V4L2_CID_IVTV_JOINT (V4L2_CID_PRIVATE_BASE + 4) #define V4L2_CID_IVTV_EMPHASIS (V4L2_CID_PRIVATE_BASE + 5) #define V4L2_CID_IVTV_CRC (V4L2_CID_PRIVATE_BASE + 6) #define V4L2_CID_IVTV_COPYRIGHT (V4L2_CID_PRIVATE_BASE + 7) #define V4L2_CID_IVTV_GEN (V4L2_CID_PRIVATE_BASE + 8) #define V4L2_CID_IVTV_DEC_SMOOTH_FF (V4L2_CID_PRIVATE_BASE + 9) #define V4L2_CID_IVTV_DEC_FR_MASK (V4L2_CID_PRIVATE_BASE + 10) #define V4L2_CID_IVTV_DEC_SP_MUTE (V4L2_CID_PRIVATE_BASE + 11) #define V4L2_CID_IVTV_DEC_FR_FIELD (V4L2_CID_PRIVATE_BASE + 12) #define V4L2_CID_IVTV_DEC_AUD_SKIP (V4L2_CID_PRIVATE_BASE + 13) #define V4L2_CID_IVTV_DEC_NUM_BUFFERS (V4L2_CID_PRIVATE_BASE + 14) #define V4L2_CID_IVTV_DEC_PREBUFFER (V4L2_CID_PRIVATE_BASE + 15) struct ivtv_ioctl_framesync { uint32_t frame; uint64_t pts; uint64_t scr; }; struct ivtv_speed { int scale; /* 1-?? (50 for now) */ int smooth; /* Smooth mode when in slow/fast mode */ int speed; /* 0 = slow, 1 = fast */ int direction; /* 0 = forward, 1 = reverse (not supportd */ int fr_mask; /* 0 = I, 1 = I,P, 2 = I,P,B 2 = default!*/ int b_per_gop; /* frames per GOP (reverse only) */ int aud_mute; /* Mute audio while in slow/fast mode */ int fr_field; /* 1 = show every field, 0 = show every frame */ int mute; /* # of audio frames to mute on playback resume */ }; struct ivtv_slow_fast { int speed; /* 0 = slow, 1 = fast */ int scale; /* 1-?? (50 for now) */ }; struct ivtv_cfg_start_decode { uint32_t gop_offset; /*Frames in GOP to skip before starting */ uint32_t muted_audio_frames;/* #of audio frames to mute */ }; struct ivtv_cfg_stop_decode { int hide_last; /* 1 = show black after stop, 0 = show last frame */ uint64_t pts_stop; /* PTS to stop at */ }; /* For use with IVTV_IOC_G_CODEC and IVTV_IOC_S_CODEC */ struct ivtv_ioctl_codec { uint32_t aspect; uint32_t audio_bitmask; uint32_t bframes; uint32_t bitrate_mode; uint32_t bitrate; uint32_t bitrate_peak; uint32_t dnr_mode; uint32_t dnr_spatial; uint32_t dnr_temporal; uint32_t dnr_type; uint32_t framerate; /* read only, ignored on write */ uint32_t framespergop; /* read only, ignored on write */ uint32_t gop_closure; uint32_t pulldown; uint32_t stream_type; }; /* Framebuffer external API */ struct ivtvfb_ioctl_state_info { unsigned long status; unsigned long alpha; }; struct ivtvfb_ioctl_blt_copy_args { int x, y, width, height, source_offset, source_stride; }; struct ivtvfb_ioctl_blt_fill_args { int rasterop, alpha_mode, alpha_mask, width, height, x, y; unsigned int destPixelMask, colour; }; struct ivtvfb_ioctl_dma_host_to_ivtv_args { void* source; unsigned long dest_offset; int count; }; struct ivtvfb_ioctl_get_frame_buffer { void* mem; int size; int sizex; int sizey; }; struct ivtv_osd_coords { unsigned long offset; unsigned long max_offset; int pixel_stride; int lines; int x; int y; }; struct rectangle { int x0; int y0; int x1; int y1; }; /* Framebuffer ioctls should use the range 1 - 28 */ #define IVTVFB_IOCTL_GET_STATE _IOR('@', 1, struct ivtvfb_ioctl_state_info) #define IVTVFB_IOCTL_SET_STATE _IOW('@', 2, struct ivtvfb_ioctl_state_info) #define IVTVFB_IOCTL_PREP_FRAME _IOW('@', 3, struct ivtvfb_ioctl_dma_host_to_ivtv_args) #define IVTVFB_IOCTL_BLT_COPY _IOW('@', 4, struct ivtvfb_ioctl_blt_copy_args) #define IVTVFB_IOCTL_GET_ACTIVE_BUFFER _IOR('@', 5, struct ivtv_osd_coords) #define IVTVFB_IOCTL_SET_ACTIVE_BUFFER _IOW('@', 6, struct ivtv_osd_coords) #define IVTVFB_IOCTL_GET_FRAME_BUFFER _IOR('@', 7, struct ivtvfb_ioctl_get_frame_buffer) #define IVTVFB_IOCTL_BLT_FILL _IOW('@', 8, struct ivtvfb_ioctl_blt_fill_args) #define IVTVFB_STATUS_ENABLED (1 << 0) #define IVTVFB_STATUS_GLOBAL_ALPHA (1 << 1) #define IVTVFB_STATUS_LOCAL_ALPHA (1 << 2) #define IVTVFB_STATUS_FLICKER_REDUCTION (1 << 3) #ifdef IVTV_INTERNAL /* Do not use these structures and ioctls in code that you want to release. Only to be used for testing and by the utilities ivtvctl, ivtvfbctl and fwapi. */ #define IVTV_MBOX_MAX_DATA 16 struct ivtv_ioctl_fwapi { uint32_t cmd; uint32_t result; int32_t args; uint32_t data[IVTV_MBOX_MAX_DATA]; }; struct ivtv_ioctl_event { uint32_t type; uint32_t mbox; struct ivtv_ioctl_fwapi api; }; struct ivtv_saa71xx_reg { unsigned char reg; unsigned char val; }; struct ivtv_itvc_reg { uint32_t reg; uint32_t val; }; struct ivtv_msp_matrix { int input; int output; }; /* Debug flags */ #define IVTV_DEBUG_ERR (1 << 0) #define IVTV_DEBUG_INFO (1 << 1) #define IVTV_DEBUG_API (1 << 2) #define IVTV_DEBUG_DMA (1 << 3) #define IVTV_DEBUG_IOCTL (1 << 4) #define IVTV_DEBUG_I2C (1 << 5) #define IVTV_DEBUG_IRQ (1 << 6) #define IVTV_DEBUG_DEC (1 << 7) /* BLT RasterOps */ #define IVTV_BLT_RASTER_ZERO 0 #define IVTV_BLT_RASTER_NOTDEST_AND_NOTSRC 1 #define IVTV_BLT_RASTER_NOTDEST_AND_SRC 2 #define IVTV_BLT_RASTER_NOTDEST 3 #define IVTV_BLT_RASTER_DEST_AND_NOTSRC 4 #define IVTV_BLT_RASTER_NOTSRC 5 #define IVTV_BLT_RASTER_DEST_XOR_SRC 6 #define IVTV_BLT_RASTER_NOTDEST_OR_NOTSRC 7 /* #define IVTV_BLT_RASTER_NOTDEST_AND_NOTSRC 8 */ /* Same as 1 */ #define IVTV_BLT_RASTER_DEST_XNOR_SRC 9 #define IVTV_BLT_RASTER_SRC 10 #define IVTV_BLT_RASTER_NOTDEST_OR_SRC 11 #define IVTV_BLT_RASTER_DEST 12 #define IVTV_BLT_RASTER_DEST_OR_NOTSRC 13 #define IVTV_BLT_RASTER_DEST_OR_SRC 14 #define IVTV_BLT_RASTER_ONE 15 /* BLT Alpha blending */ #define IVTV_BLT_ALPHABLEND_SRC 0x01 #define IVTV_BLT_ALPHABLEND_DEST 0x10 #define IVTV_BLT_ALPHABLEND_DEST_X_SRC 0x11 /* dest x src +1 , = zero if both zero */ /* Internal ioctls should use the range 200-255 */ #define IVTV_IOC_S_DEBUG_LEVEL _IOWR('@', 200, int) #define IVTV_IOC_G_DEBUG_LEVEL _IOR ('@', 201, int) #define IVTV_IOC_RELOAD_FW _IO ('@', 202) #define IVTV_IOC_ZCOUNT _IO ('@', 203) #define IVTV_IOC_FWAPI _IOWR('@', 204, struct ivtv_ioctl_fwapi) #define IVTV_IOC_EVENT_SETUP _IOWR('@', 205, struct ivtv_ioctl_event) #define IVTV_IOC_G_SAA7115_REG _IOWR('@', 206, struct ivtv_saa71xx_reg) #define IVTV_IOC_S_SAA7115_REG _IOW ('@', 207, struct ivtv_saa71xx_reg) #define IVTV_IOC_G_SAA7127_REG _IOWR('@', 208, struct ivtv_saa71xx_reg) #define IVTV_IOC_S_SAA7127_REG _IOW ('@', 209, struct ivtv_saa71xx_reg) #define IVTV_IOC_S_MSP_MATRIX _IOW ('@', 210, struct ivtv_msp_matrix) #define IVTV_IOC_G_ITVC_REG _IOWR('@', 211, struct ivtv_itvc_reg) #define IVTV_IOC_S_ITVC_REG _IOW ('@', 212, struct ivtv_itvc_reg) #endif #endif Video-ivtv-0.13/videodev2.h0000644000076400003530000007133107755522367014762 0ustar james00000000000000#ifndef __LINUX_VIDEODEV2_H #define __LINUX_VIDEODEV2_H /* * Video for Linux Two * * Header file for v4l or V4L2 drivers and applications, for * Linux kernels 2.2.x or 2.4.x. * * See http://bytesex.org/v4l/ for API specs and other * v4l2 documentation. * * Author: Bill Dirks * Justin Schoeman * et al. */ #ifdef __KERNEL__ #include /* need struct timeval */ #endif /* * M I S C E L L A N E O U S */ /* Four-character-code (FOURCC) */ #define v4l2_fourcc(a,b,c,d)\ (((__u32)(a)<<0)|((__u32)(b)<<8)|((__u32)(c)<<16)|((__u32)(d)<<24)) /* * E N U M S */ enum v4l2_field { V4L2_FIELD_ANY = 0, /* driver can choose from none, top, bottom, interlaced depending on whatever it thinks is approximate ... */ V4L2_FIELD_NONE = 1, /* this device has no fields ... */ V4L2_FIELD_TOP = 2, /* top field only */ V4L2_FIELD_BOTTOM = 3, /* bottom field only */ V4L2_FIELD_INTERLACED = 4, /* both fields interlaced */ V4L2_FIELD_SEQ_TB = 5, /* both fields sequential into one buffer, top-bottom order */ V4L2_FIELD_SEQ_BT = 6, /* same as above + bottom-top order */ V4L2_FIELD_ALTERNATE = 7, /* both fields alternating into separate buffers */ }; #define V4L2_FIELD_HAS_TOP(field) \ ((field) == V4L2_FIELD_TOP ||\ (field) == V4L2_FIELD_INTERLACED ||\ (field) == V4L2_FIELD_SEQ_TB ||\ (field) == V4L2_FIELD_SEQ_BT) #define V4L2_FIELD_HAS_BOTTOM(field) \ ((field) == V4L2_FIELD_BOTTOM ||\ (field) == V4L2_FIELD_INTERLACED ||\ (field) == V4L2_FIELD_SEQ_TB ||\ (field) == V4L2_FIELD_SEQ_BT) #define V4L2_FIELD_HAS_BOTH(field) \ ((field) == V4L2_FIELD_INTERLACED ||\ (field) == V4L2_FIELD_SEQ_TB ||\ (field) == V4L2_FIELD_SEQ_BT) enum v4l2_buf_type { V4L2_BUF_TYPE_VIDEO_CAPTURE = 1, V4L2_BUF_TYPE_VIDEO_OUTPUT = 2, V4L2_BUF_TYPE_VIDEO_OVERLAY = 3, V4L2_BUF_TYPE_VBI_CAPTURE = 4, V4L2_BUF_TYPE_VBI_OUTPUT = 5, V4L2_BUF_TYPE_PRIVATE = 0x80, }; enum v4l2_ctrl_type { V4L2_CTRL_TYPE_INTEGER = 1, V4L2_CTRL_TYPE_BOOLEAN = 2, V4L2_CTRL_TYPE_MENU = 3, V4L2_CTRL_TYPE_BUTTON = 4, }; enum v4l2_tuner_type { V4L2_TUNER_RADIO = 1, V4L2_TUNER_ANALOG_TV = 2, }; enum v4l2_memory { V4L2_MEMORY_MMAP = 1, V4L2_MEMORY_USERPTR = 2, V4L2_MEMORY_OVERLAY = 3, }; /* see also http://vektor.theorem.ca/graphics/ycbcr/ */ enum v4l2_colorspace { /* ITU-R 601 -- broadcast NTSC/PAL */ V4L2_COLORSPACE_SMPTE170M = 1, /* 1125-Line (US) HDTV */ V4L2_COLORSPACE_SMPTE240M = 2, /* HD and modern captures. */ V4L2_COLORSPACE_REC709 = 3, /* broken BT878 extents (601, luma range 16-253 instead of 16-235) */ V4L2_COLORSPACE_BT878 = 4, /* These should be useful. Assume 601 extents. */ V4L2_COLORSPACE_470_SYSTEM_M = 5, V4L2_COLORSPACE_470_SYSTEM_BG = 6, /* I know there will be cameras that send this. So, this is * unspecified chromaticities and full 0-255 on each of the * Y'CbCr components */ V4L2_COLORSPACE_JPEG = 7, /* For RGB colourspaces, this is probably a good start. */ V4L2_COLORSPACE_SRGB = 8, }; enum v4l2_priority { V4L2_PRIORITY_UNSET = 0, /* not initialized */ V4L2_PRIORITY_BACKGROUND = 1, V4L2_PRIORITY_INTERACTIVE = 2, V4L2_PRIORITY_RECORD = 3, V4L2_PRIORITY_DEFAULT = V4L2_PRIORITY_INTERACTIVE, }; struct v4l2_rect { __s32 left; __s32 top; __s32 width; __s32 height; }; struct v4l2_fract { __u32 numerator; __u32 denominator; }; /* * D R I V E R C A P A B I L I T I E S */ struct v4l2_capability { __u8 driver[16]; /* i.e. "bttv" */ __u8 card[32]; /* i.e. "Hauppauge WinTV" */ __u8 bus_info[32]; /* "PCI:" + pci_name(pci_dev) */ __u32 version; /* should use KERNEL_VERSION() */ __u32 capabilities; /* Device capabilities */ __u32 reserved[4]; }; /* Values for 'capabilities' field */ #define V4L2_CAP_VIDEO_CAPTURE 0x00000001 /* Is a video capture device */ #define V4L2_CAP_VIDEO_OUTPUT 0x00000002 /* Is a video output device */ #define V4L2_CAP_VIDEO_OVERLAY 0x00000004 /* Can do video overlay */ #define V4L2_CAP_VBI_CAPTURE 0x00000010 /* Is a VBI capture device */ #define V4L2_CAP_VBI_OUTPUT 0x00000020 /* Is a VBI output device */ #define V4L2_CAP_RDS_CAPTURE 0x00000100 /* RDS data capture */ #define V4L2_CAP_TUNER 0x00010000 /* has a tuner */ #define V4L2_CAP_AUDIO 0x00020000 /* has audio support */ #define V4L2_CAP_RADIO 0x00040000 /* is a radio device */ #define V4L2_CAP_READWRITE 0x01000000 /* read/write systemcalls */ #define V4L2_CAP_ASYNCIO 0x02000000 /* async I/O */ #define V4L2_CAP_STREAMING 0x04000000 /* streaming I/O ioctls */ /* * V I D E O I M A G E F O R M A T */ struct v4l2_pix_format { __u32 width; __u32 height; __u32 pixelformat; enum v4l2_field field; __u32 bytesperline; /* for padding, zero if unused */ __u32 sizeimage; enum v4l2_colorspace colorspace; __u32 priv; /* private data, depends on pixelformat */ }; /* Pixel format FOURCC depth Description */ #define V4L2_PIX_FMT_RGB332 v4l2_fourcc('R','G','B','1') /* 8 RGB-3-3-2 */ #define V4L2_PIX_FMT_RGB555 v4l2_fourcc('R','G','B','O') /* 16 RGB-5-5-5 */ #define V4L2_PIX_FMT_RGB565 v4l2_fourcc('R','G','B','P') /* 16 RGB-5-6-5 */ #define V4L2_PIX_FMT_RGB555X v4l2_fourcc('R','G','B','Q') /* 16 RGB-5-5-5 BE */ #define V4L2_PIX_FMT_RGB565X v4l2_fourcc('R','G','B','R') /* 16 RGB-5-6-5 BE */ #define V4L2_PIX_FMT_BGR24 v4l2_fourcc('B','G','R','3') /* 24 BGR-8-8-8 */ #define V4L2_PIX_FMT_RGB24 v4l2_fourcc('R','G','B','3') /* 24 RGB-8-8-8 */ #define V4L2_PIX_FMT_BGR32 v4l2_fourcc('B','G','R','4') /* 32 BGR-8-8-8-8 */ #define V4L2_PIX_FMT_RGB32 v4l2_fourcc('R','G','B','4') /* 32 RGB-8-8-8-8 */ #define V4L2_PIX_FMT_GREY v4l2_fourcc('G','R','E','Y') /* 8 Greyscale */ #define V4L2_PIX_FMT_YVU410 v4l2_fourcc('Y','V','U','9') /* 9 YVU 4:1:0 */ #define V4L2_PIX_FMT_YVU420 v4l2_fourcc('Y','V','1','2') /* 12 YVU 4:2:0 */ #define V4L2_PIX_FMT_YUYV v4l2_fourcc('Y','U','Y','V') /* 16 YUV 4:2:2 */ #define V4L2_PIX_FMT_UYVY v4l2_fourcc('U','Y','V','Y') /* 16 YUV 4:2:2 */ #define V4L2_PIX_FMT_YUV422P v4l2_fourcc('4','2','2','P') /* 16 YVU422 planar */ #define V4L2_PIX_FMT_YUV411P v4l2_fourcc('4','1','1','P') /* 16 YVU411 planar */ #define V4L2_PIX_FMT_Y41P v4l2_fourcc('Y','4','1','P') /* 12 YUV 4:1:1 */ /* two planes -- one Y, one Cr + Cb interleaved */ #define V4L2_PIX_FMT_NV12 v4l2_fourcc('N','V','1','2') /* 12 Y/CbCr 4:2:0 */ #define V4L2_PIX_FMT_NV21 v4l2_fourcc('N','V','2','1') /* 12 Y/CrCb 4:2:0 */ /* The following formats are not defined in the V4L2 specification */ #define V4L2_PIX_FMT_YUV410 v4l2_fourcc('Y','U','V','9') /* 9 YUV 4:1:0 */ #define V4L2_PIX_FMT_YUV420 v4l2_fourcc('Y','U','1','2') /* 12 YUV 4:2:0 */ #define V4L2_PIX_FMT_YYUV v4l2_fourcc('Y','Y','U','V') /* 16 YUV 4:2:2 */ #define V4L2_PIX_FMT_HI240 v4l2_fourcc('H','I','2','4') /* 8 8-bit color */ /* compressed formats */ #define V4L2_PIX_FMT_MJPEG v4l2_fourcc('M','J','P','G') /* Motion-JPEG */ #define V4L2_PIX_FMT_JPEG v4l2_fourcc('J','P','E','G') /* JFIF JPEG */ #define V4L2_PIX_FMT_DV v4l2_fourcc('d','v','s','d') /* 1394 */ #define V4L2_PIX_FMT_MPEG v4l2_fourcc('M','P','E','G') /* MPEG */ /* Vendor-specific formats */ #define V4L2_PIX_FMT_WNVA v4l2_fourcc('W','N','V','A') /* Winnov hw compress */ /* * F O R M A T E N U M E R A T I O N */ struct v4l2_fmtdesc { __u32 index; /* Format number */ enum v4l2_buf_type type; /* buffer type */ __u32 flags; __u8 description[32]; /* Description string */ __u32 pixelformat; /* Format fourcc */ __u32 reserved[4]; }; #define V4L2_FMT_FLAG_COMPRESSED 0x0001 /* * T I M E C O D E */ struct v4l2_timecode { __u32 type; __u32 flags; __u8 frames; __u8 seconds; __u8 minutes; __u8 hours; __u8 userbits[4]; }; /* Type */ #define V4L2_TC_TYPE_24FPS 1 #define V4L2_TC_TYPE_25FPS 2 #define V4L2_TC_TYPE_30FPS 3 #define V4L2_TC_TYPE_50FPS 4 #define V4L2_TC_TYPE_60FPS 5 /* Flags */ #define V4L2_TC_FLAG_DROPFRAME 0x0001 /* "drop-frame" mode */ #define V4L2_TC_FLAG_COLORFRAME 0x0002 #define V4L2_TC_USERBITS_field 0x000C #define V4L2_TC_USERBITS_USERDEFINED 0x0000 #define V4L2_TC_USERBITS_8BITCHARS 0x0008 /* The above is based on SMPTE timecodes */ /* * C O M P R E S S I O N P A R A M E T E R S */ #if 0 /* ### generic compression settings don't work, there is too much * ### codec-specific stuff. Maybe reuse that for MPEG codec settings * ### later ... */ struct v4l2_compression { __u32 quality; __u32 keyframerate; __u32 pframerate; __u32 reserved[5]; /* what we'll need for MPEG, extracted from some postings on the v4l list (Gert Vervoort, PlasmaJohn). system stream: - type: elementary stream(ES), packatised elementary stream(s) (PES) program stream(PS), transport stream(TS) - system bitrate - PS packet size (DVD: 2048 bytes, VCD: 2324 bytes) - TS video PID - TS audio PID - TS PCR PID - TS system information tables (PAT, PMT, CAT, NIT and SIT) - (MPEG-1 systems stream vs. MPEG-2 program stream (TS not supported by MPEG-1 systems) audio: - type: MPEG (+Layer I,II,III), AC-3, LPCM - bitrate - sampling frequency (DVD: 48 Khz, VCD: 44.1 KHz, 32 kHz) - Trick Modes? (ff, rew) - Copyright - Inverse Telecine video: - picturesize (SIF, 1/2 D1, 2/3 D1, D1) and PAL/NTSC norm can be set through excisting V4L2 controls - noise reduction, parameters encoder specific? - MPEG video version: MPEG-1, MPEG-2 - GOP (Group Of Pictures) definition: - N: number of frames per GOP - M: distance between reference (I,P) frames - open/closed GOP - quantiser matrix: inter Q matrix (64 bytes) and intra Q matrix (64 bytes) - quantiser scale: linear or logarithmic - scanning: alternate or zigzag - bitrate mode: CBR (constant bitrate) or VBR (variable bitrate). - target video bitrate for CBR - target video bitrate for VBR - maximum video bitrate for VBR - min. quantiser value for VBR - max. quantiser value for VBR - adaptive quantisation value - return the number of bytes per GOP or bitrate for bitrate monitoring */ }; #endif struct v4l2_jpegcompression { int quality; int APPn; /* Number of APP segment to be written, * must be 0..15 */ int APP_len; /* Length of data in JPEG APPn segment */ char APP_data[60]; /* Data in the JPEG APPn segment. */ int COM_len; /* Length of data in JPEG COM segment */ char COM_data[60]; /* Data in JPEG COM segment */ __u32 jpeg_markers; /* Which markers should go into the JPEG * output. Unless you exactly know what * you do, leave them untouched. * Inluding less markers will make the * resulting code smaller, but there will * be fewer aplications which can read it. * The presence of the APP and COM marker * is influenced by APP_len and COM_len * ONLY, not by this property! */ #define V4L2_JPEG_MARKER_DHT (1<<3) /* Define Huffman Tables */ #define V4L2_JPEG_MARKER_DQT (1<<4) /* Define Quantization Tables */ #define V4L2_JPEG_MARKER_DRI (1<<5) /* Define Restart Interval */ #define V4L2_JPEG_MARKER_COM (1<<6) /* Comment segment */ #define V4L2_JPEG_MARKER_APP (1<<7) /* App segment, driver will * allways use APP0 */ }; /* * M E M O R Y - M A P P I N G B U F F E R S */ struct v4l2_requestbuffers { __u32 count; enum v4l2_buf_type type; enum v4l2_memory memory; __u32 reserved[2]; }; struct v4l2_buffer { __u32 index; enum v4l2_buf_type type; __u32 bytesused; __u32 flags; enum v4l2_field field; struct timeval timestamp; struct v4l2_timecode timecode; __u32 sequence; /* memory location */ enum v4l2_memory memory; union { __u32 offset; unsigned long userptr; } m; __u32 length; __u32 reserved[2]; }; /* Flags for 'flags' field */ #define V4L2_BUF_FLAG_MAPPED 0x0001 /* Buffer is mapped (flag) */ #define V4L2_BUF_FLAG_QUEUED 0x0002 /* Buffer is queued for processing */ #define V4L2_BUF_FLAG_DONE 0x0004 /* Buffer is ready */ #define V4L2_BUF_FLAG_KEYFRAME 0x0008 /* Image is a keyframe (I-frame) */ #define V4L2_BUF_FLAG_PFRAME 0x0010 /* Image is a P-frame */ #define V4L2_BUF_FLAG_BFRAME 0x0020 /* Image is a B-frame */ #define V4L2_BUF_FLAG_TIMECODE 0x0100 /* timecode field is valid */ /* * O V E R L A Y P R E V I E W */ struct v4l2_framebuffer { __u32 capability; __u32 flags; /* FIXME: in theory we should pass something like PCI device + memory * region + offset instead of some physical address */ void* base; struct v4l2_pix_format fmt; }; /* Flags for the 'capability' field. Read only */ #define V4L2_FBUF_CAP_EXTERNOVERLAY 0x0001 #define V4L2_FBUF_CAP_CHROMAKEY 0x0002 #define V4L2_FBUF_CAP_LIST_CLIPPING 0x0004 #define V4L2_FBUF_CAP_BITMAP_CLIPPING 0x0008 /* Flags for the 'flags' field. */ #define V4L2_FBUF_FLAG_PRIMARY 0x0001 #define V4L2_FBUF_FLAG_OVERLAY 0x0002 #define V4L2_FBUF_FLAG_CHROMAKEY 0x0004 struct v4l2_clip { struct v4l2_rect c; struct v4l2_clip *next; }; struct v4l2_window { struct v4l2_rect w; enum v4l2_field field; __u32 chromakey; struct v4l2_clip *clips; __u32 clipcount; void *bitmap; }; /* * C A P T U R E P A R A M E T E R S */ struct v4l2_captureparm { __u32 capability; /* Supported modes */ __u32 capturemode; /* Current mode */ struct v4l2_fract timeperframe; /* Time per frame in .1us units */ __u32 extendedmode; /* Driver-specific extensions */ __u32 readbuffers; /* # of buffers for read */ __u32 reserved[4]; }; /* Flags for 'capability' and 'capturemode' fields */ #define V4L2_MODE_HIGHQUALITY 0x0001 /* High quality imaging mode */ #define V4L2_CAP_TIMEPERFRAME 0x1000 /* timeperframe field is supported */ struct v4l2_outputparm { __u32 capability; /* Supported modes */ __u32 outputmode; /* Current mode */ struct v4l2_fract timeperframe; /* Time per frame in seconds */ __u32 extendedmode; /* Driver-specific extensions */ __u32 writebuffers; /* # of buffers for write */ __u32 reserved[4]; }; /* * I N P U T I M A G E C R O P P I N G */ struct v4l2_cropcap { enum v4l2_buf_type type; struct v4l2_rect bounds; struct v4l2_rect defrect; struct v4l2_fract pixelaspect; }; struct v4l2_crop { enum v4l2_buf_type type; struct v4l2_rect c; }; /* * A N A L O G V I D E O S T A N D A R D */ typedef __u64 v4l2_std_id; /* one bit for each */ #define V4L2_STD_PAL_B ((v4l2_std_id)0x00000001) #define V4L2_STD_PAL_B1 ((v4l2_std_id)0x00000002) #define V4L2_STD_PAL_G ((v4l2_std_id)0x00000004) #define V4L2_STD_PAL_H ((v4l2_std_id)0x00000008) #define V4L2_STD_PAL_I ((v4l2_std_id)0x00000010) #define V4L2_STD_PAL_D ((v4l2_std_id)0x00000020) #define V4L2_STD_PAL_D1 ((v4l2_std_id)0x00000040) #define V4L2_STD_PAL_K ((v4l2_std_id)0x00000080) #define V4L2_STD_PAL_M ((v4l2_std_id)0x00000100) #define V4L2_STD_PAL_N ((v4l2_std_id)0x00000200) #define V4L2_STD_PAL_Nc ((v4l2_std_id)0x00000400) #define V4L2_STD_PAL_60 ((v4l2_std_id)0x00000800) #define V4L2_STD_NTSC_M ((v4l2_std_id)0x00001000) #define V4L2_STD_NTSC_M_JP ((v4l2_std_id)0x00002000) #define V4L2_STD_SECAM_B ((v4l2_std_id)0x00010000) #define V4L2_STD_SECAM_D ((v4l2_std_id)0x00020000) #define V4L2_STD_SECAM_G ((v4l2_std_id)0x00040000) #define V4L2_STD_SECAM_H ((v4l2_std_id)0x00080000) #define V4L2_STD_SECAM_K ((v4l2_std_id)0x00100000) #define V4L2_STD_SECAM_K1 ((v4l2_std_id)0x00200000) #define V4L2_STD_SECAM_L ((v4l2_std_id)0x00400000) /* ATSC/HDTV */ #define V4L2_STD_ATSC_8_VSB ((v4l2_std_id)0x01000000) #define V4L2_STD_ATSC_16_VSB ((v4l2_std_id)0x02000000) /* some common needed stuff */ #define V4L2_STD_PAL_BG (V4L2_STD_PAL_B |\ V4L2_STD_PAL_B1 |\ V4L2_STD_PAL_G) #define V4L2_STD_PAL_DK (V4L2_STD_PAL_D |\ V4L2_STD_PAL_D1 |\ V4L2_STD_PAL_K) #define V4L2_STD_PAL (V4L2_STD_PAL_BG |\ V4L2_STD_PAL_DK |\ V4L2_STD_PAL_H |\ V4L2_STD_PAL_I) #define V4L2_STD_NTSC (V4L2_STD_NTSC_M |\ V4L2_STD_NTSC_M_JP) #define V4L2_STD_SECAM (V4L2_STD_SECAM_B |\ V4L2_STD_SECAM_D |\ V4L2_STD_SECAM_G |\ V4L2_STD_SECAM_H |\ V4L2_STD_SECAM_K |\ V4L2_STD_SECAM_K1 |\ V4L2_STD_SECAM_L) #define V4L2_STD_525_60 (V4L2_STD_PAL_M |\ V4L2_STD_PAL_60 |\ V4L2_STD_NTSC) #define V4L2_STD_625_50 (V4L2_STD_PAL |\ V4L2_STD_PAL_N |\ V4L2_STD_PAL_Nc |\ V4L2_STD_SECAM) #define V4L2_STD_UNKNOWN 0 #define V4L2_STD_ALL (V4L2_STD_525_60 |\ V4L2_STD_625_50) struct v4l2_standard { __u32 index; v4l2_std_id id; __u8 name[24]; struct v4l2_fract frameperiod; /* Frames, not fields */ __u32 framelines; __u32 reserved[4]; }; /* * V I D E O I N P U T S */ struct v4l2_input { __u32 index; /* Which input */ __u8 name[32]; /* Label */ __u32 type; /* Type of input */ __u32 audioset; /* Associated audios (bitfield) */ __u32 tuner; /* Associated tuner */ v4l2_std_id std; __u32 status; __u32 reserved[4]; }; /* Values for the 'type' field */ #define V4L2_INPUT_TYPE_TUNER 1 #define V4L2_INPUT_TYPE_CAMERA 2 /* field 'status' - general */ #define V4L2_IN_ST_NO_POWER 0x00000001 /* Attached device is off */ #define V4L2_IN_ST_NO_SIGNAL 0x00000002 #define V4L2_IN_ST_NO_COLOR 0x00000004 /* field 'status' - analog */ #define V4L2_IN_ST_NO_H_LOCK 0x00000100 /* No horizontal sync lock */ #define V4L2_IN_ST_COLOR_KILL 0x00000200 /* Color killer is active */ /* field 'status' - digital */ #define V4L2_IN_ST_NO_SYNC 0x00010000 /* No synchronization lock */ #define V4L2_IN_ST_NO_EQU 0x00020000 /* No equalizer lock */ #define V4L2_IN_ST_NO_CARRIER 0x00040000 /* Carrier recovery failed */ /* field 'status' - VCR and set-top box */ #define V4L2_IN_ST_MACROVISION 0x01000000 /* Macrovision detected */ #define V4L2_IN_ST_NO_ACCESS 0x02000000 /* Conditional access denied */ #define V4L2_IN_ST_VTR 0x04000000 /* VTR time constant */ /* * V I D E O O U T P U T S */ struct v4l2_output { __u32 index; /* Which output */ __u8 name[32]; /* Label */ __u32 type; /* Type of output */ __u32 audioset; /* Associated audios (bitfield) */ __u32 modulator; /* Associated modulator */ v4l2_std_id std; __u32 reserved[4]; }; /* Values for the 'type' field */ #define V4L2_OUTPUT_TYPE_MODULATOR 1 #define V4L2_OUTPUT_TYPE_ANALOG 2 #define V4L2_OUTPUT_TYPE_ANALOGVGAOVERLAY 3 /* * C O N T R O L S */ struct v4l2_control { __u32 id; __s32 value; }; /* Used in the VIDIOC_QUERYCTRL ioctl for querying controls */ struct v4l2_queryctrl { __u32 id; enum v4l2_ctrl_type type; __u8 name[32]; /* Whatever */ __s32 minimum; /* Note signedness */ __s32 maximum; __s32 step; __s32 default_value; __u32 flags; __u32 reserved[2]; }; /* Used in the VIDIOC_QUERYMENU ioctl for querying menu items */ struct v4l2_querymenu { __u32 id; __u32 index; __u8 name[32]; /* Whatever */ __u32 reserved; }; /* Control flags */ #define V4L2_CTRL_FLAG_DISABLED 0x0001 #define V4L2_CTRL_FLAG_GRABBED 0x0002 /* Control IDs defined by V4L2 */ #define V4L2_CID_BASE 0x00980900 /* IDs reserved for driver specific controls */ #define V4L2_CID_PRIVATE_BASE 0x08000000 #define V4L2_CID_BRIGHTNESS (V4L2_CID_BASE+0) #define V4L2_CID_CONTRAST (V4L2_CID_BASE+1) #define V4L2_CID_SATURATION (V4L2_CID_BASE+2) #define V4L2_CID_HUE (V4L2_CID_BASE+3) #define V4L2_CID_AUDIO_VOLUME (V4L2_CID_BASE+5) #define V4L2_CID_AUDIO_BALANCE (V4L2_CID_BASE+6) #define V4L2_CID_AUDIO_BASS (V4L2_CID_BASE+7) #define V4L2_CID_AUDIO_TREBLE (V4L2_CID_BASE+8) #define V4L2_CID_AUDIO_MUTE (V4L2_CID_BASE+9) #define V4L2_CID_AUDIO_LOUDNESS (V4L2_CID_BASE+10) #define V4L2_CID_BLACK_LEVEL (V4L2_CID_BASE+11) #define V4L2_CID_AUTO_WHITE_BALANCE (V4L2_CID_BASE+12) #define V4L2_CID_DO_WHITE_BALANCE (V4L2_CID_BASE+13) #define V4L2_CID_RED_BALANCE (V4L2_CID_BASE+14) #define V4L2_CID_BLUE_BALANCE (V4L2_CID_BASE+15) #define V4L2_CID_GAMMA (V4L2_CID_BASE+16) #define V4L2_CID_WHITENESS (V4L2_CID_GAMMA) /* ? Not sure */ #define V4L2_CID_EXPOSURE (V4L2_CID_BASE+17) #define V4L2_CID_AUTOGAIN (V4L2_CID_BASE+18) #define V4L2_CID_GAIN (V4L2_CID_BASE+19) #define V4L2_CID_HFLIP (V4L2_CID_BASE+20) #define V4L2_CID_VFLIP (V4L2_CID_BASE+21) #define V4L2_CID_HCENTER (V4L2_CID_BASE+22) #define V4L2_CID_VCENTER (V4L2_CID_BASE+23) #define V4L2_CID_LASTP1 (V4L2_CID_BASE+24) /* last CID + 1 */ /* * T U N I N G */ struct v4l2_tuner { __u32 index; __u8 name[32]; enum v4l2_tuner_type type; __u32 capability; __u32 rangelow; __u32 rangehigh; __u32 rxsubchans; __u32 audmode; __s32 signal; __s32 afc; __u32 reserved[4]; }; struct v4l2_modulator { __u32 index; __u8 name[32]; __u32 capability; __u32 rangelow; __u32 rangehigh; __u32 txsubchans; __u32 reserved[4]; }; /* Flags for the 'capability' field */ #define V4L2_TUNER_CAP_LOW 0x0001 #define V4L2_TUNER_CAP_NORM 0x0002 #define V4L2_TUNER_CAP_STEREO 0x0010 #define V4L2_TUNER_CAP_LANG2 0x0020 #define V4L2_TUNER_CAP_SAP 0x0020 #define V4L2_TUNER_CAP_LANG1 0x0040 /* Flags for the 'rxsubchans' field */ #define V4L2_TUNER_SUB_MONO 0x0001 #define V4L2_TUNER_SUB_STEREO 0x0002 #define V4L2_TUNER_SUB_LANG2 0x0004 #define V4L2_TUNER_SUB_SAP 0x0004 #define V4L2_TUNER_SUB_LANG1 0x0008 /* Values for the 'audmode' field */ #define V4L2_TUNER_MODE_MONO 0x0000 #define V4L2_TUNER_MODE_STEREO 0x0001 #define V4L2_TUNER_MODE_LANG2 0x0002 #define V4L2_TUNER_MODE_SAP 0x0002 #define V4L2_TUNER_MODE_LANG1 0x0003 struct v4l2_frequency { __u32 tuner; enum v4l2_tuner_type type; __u32 frequency; __u32 reserved[8]; }; /* * A U D I O */ struct v4l2_audio { __u32 index; __u8 name[32]; __u32 capability; __u32 mode; __u32 reserved[2]; }; /* Flags for the 'capability' field */ #define V4L2_AUDCAP_STEREO 0x00001 #define V4L2_AUDCAP_AVL 0x00002 /* Flags for the 'mode' field */ #define V4L2_AUDMODE_AVL 0x00001 struct v4l2_audioout { __u32 index; __u8 name[32]; __u32 capability; __u32 mode; __u32 reserved[2]; }; /* * D A T A S E R V I C E S ( V B I ) * * Data services API by Michael Schimek */ struct v4l2_vbi_format { __u32 sampling_rate; /* in 1 Hz */ __u32 offset; __u32 samples_per_line; __u32 sample_format; /* V4L2_PIX_FMT_* */ __s32 start[2]; __u32 count[2]; __u32 flags; /* V4L2_VBI_* */ __u32 reserved[2]; /* must be zero */ }; /* VBI flags */ #define V4L2_VBI_UNSYNC (1<< 0) #define V4L2_VBI_INTERLACED (1<< 1) /* * A G G R E G A T E S T R U C T U R E S */ /* Stream data format */ struct v4l2_format { enum v4l2_buf_type type; union { struct v4l2_pix_format pix; // V4L2_BUF_TYPE_VIDEO_CAPTURE struct v4l2_window win; // V4L2_BUF_TYPE_VIDEO_OVERLAY struct v4l2_vbi_format vbi; // V4L2_BUF_TYPE_VBI_CAPTURE __u8 raw_data[200]; // user-defined } fmt; }; /* Stream type-dependent parameters */ struct v4l2_streamparm { enum v4l2_buf_type type; union { struct v4l2_captureparm capture; struct v4l2_outputparm output; __u8 raw_data[200]; /* user-defined */ } parm; }; /* * I O C T L C O D E S F O R V I D E O D E V I C E S * */ #define VIDIOC_QUERYCAP _IOR ('V', 0, struct v4l2_capability) #define VIDIOC_RESERVED _IO ('V', 1) #define VIDIOC_ENUM_FMT _IOWR ('V', 2, struct v4l2_fmtdesc) #define VIDIOC_G_FMT _IOWR ('V', 4, struct v4l2_format) #define VIDIOC_S_FMT _IOWR ('V', 5, struct v4l2_format) #if 0 #define VIDIOC_G_COMP _IOR ('V', 6, struct v4l2_compression) #define VIDIOC_S_COMP _IOW ('V', 7, struct v4l2_compression) #endif #define VIDIOC_REQBUFS _IOWR ('V', 8, struct v4l2_requestbuffers) #define VIDIOC_QUERYBUF _IOWR ('V', 9, struct v4l2_buffer) #define VIDIOC_G_FBUF _IOR ('V', 10, struct v4l2_framebuffer) #define VIDIOC_S_FBUF _IOW ('V', 11, struct v4l2_framebuffer) #define VIDIOC_OVERLAY _IOW ('V', 14, int) #define VIDIOC_QBUF _IOWR ('V', 15, struct v4l2_buffer) #define VIDIOC_DQBUF _IOWR ('V', 17, struct v4l2_buffer) #define VIDIOC_STREAMON _IOW ('V', 18, int) #define VIDIOC_STREAMOFF _IOW ('V', 19, int) #define VIDIOC_G_PARM _IOWR ('V', 21, struct v4l2_streamparm) #define VIDIOC_S_PARM _IOWR ('V', 22, struct v4l2_streamparm) #define VIDIOC_G_STD _IOR ('V', 23, v4l2_std_id) #define VIDIOC_S_STD _IOW ('V', 24, v4l2_std_id) #define VIDIOC_ENUMSTD _IOWR ('V', 25, struct v4l2_standard) #define VIDIOC_ENUMINPUT _IOWR ('V', 26, struct v4l2_input) #define VIDIOC_G_CTRL _IOWR ('V', 27, struct v4l2_control) #define VIDIOC_S_CTRL _IOWR ('V', 28, struct v4l2_control) #define VIDIOC_G_TUNER _IOWR ('V', 29, struct v4l2_tuner) #define VIDIOC_S_TUNER _IOW ('V', 30, struct v4l2_tuner) #define VIDIOC_G_AUDIO _IOR ('V', 33, struct v4l2_audio) #define VIDIOC_S_AUDIO _IOW ('V', 34, struct v4l2_audio) #define VIDIOC_QUERYCTRL _IOWR ('V', 36, struct v4l2_queryctrl) #define VIDIOC_QUERYMENU _IOWR ('V', 37, struct v4l2_querymenu) #define VIDIOC_G_INPUT _IOR ('V', 38, int) #define VIDIOC_S_INPUT _IOWR ('V', 39, int) #define VIDIOC_G_OUTPUT _IOR ('V', 46, int) #define VIDIOC_S_OUTPUT _IOWR ('V', 47, int) #define VIDIOC_ENUMOUTPUT _IOWR ('V', 48, struct v4l2_output) #define VIDIOC_G_AUDOUT _IOR ('V', 49, struct v4l2_audioout) #define VIDIOC_S_AUDOUT _IOW ('V', 50, struct v4l2_audioout) #define VIDIOC_G_MODULATOR _IOWR ('V', 54, struct v4l2_modulator) #define VIDIOC_S_MODULATOR _IOW ('V', 55, struct v4l2_modulator) #define VIDIOC_G_FREQUENCY _IOWR ('V', 56, struct v4l2_frequency) #define VIDIOC_S_FREQUENCY _IOW ('V', 57, struct v4l2_frequency) #define VIDIOC_CROPCAP _IOR ('V', 58, struct v4l2_cropcap) #define VIDIOC_G_CROP _IOWR ('V', 59, struct v4l2_crop) #define VIDIOC_S_CROP _IOW ('V', 60, struct v4l2_crop) #define VIDIOC_G_JPEGCOMP _IOR ('V', 61, struct v4l2_jpegcompression) #define VIDIOC_S_JPEGCOMP _IOW ('V', 62, struct v4l2_jpegcompression) #define VIDIOC_QUERYSTD _IOR ('V', 63, v4l2_std_id) #define VIDIOC_TRY_FMT _IOWR ('V', 64, struct v4l2_format) #define VIDIOC_ENUMAUDIO _IOWR ('V', 65, struct v4l2_audio) #define VIDIOC_ENUMAUDOUT _IOWR ('V', 66, struct v4l2_audioout) #define VIDIOC_G_PRIORITY _IOR ('V', 67, enum v4l2_priority) #define VIDIOC_S_PRIORITY _IOW ('V', 68, enum v4l2_priority) /* for compatibility, will go away some day */ #define VIDIOC_OVERLAY_OLD _IOWR ('V', 14, int) #define VIDIOC_S_PARM_OLD _IOW ('V', 22, struct v4l2_streamparm) #define VIDIOC_S_CTRL_OLD _IOW ('V', 28, struct v4l2_control) #define VIDIOC_G_AUDIO_OLD _IOWR ('V', 33, struct v4l2_audio) #define VIDIOC_G_AUDOUT_OLD _IOWR ('V', 49, struct v4l2_audioout) #define BASE_VIDIOC_PRIVATE 192 /* 192-255 are private */ #ifdef __KERNEL__ /* * * V 4 L 2 D R I V E R H E L P E R A P I * * Some commonly needed functions for drivers (v4l2-common.o module) */ #include /* Video standard functions */ extern unsigned int v4l2_video_std_fps(struct v4l2_standard *vs); extern int v4l2_video_std_construct(struct v4l2_standard *vs, int id, char *name); /* prority handling */ struct v4l2_prio_state { atomic_t prios[4]; }; int v4l2_prio_init(struct v4l2_prio_state *global); int v4l2_prio_change(struct v4l2_prio_state *global, enum v4l2_priority *local, enum v4l2_priority new); int v4l2_prio_open(struct v4l2_prio_state *global, enum v4l2_priority *local); int v4l2_prio_close(struct v4l2_prio_state *global, enum v4l2_priority *local); enum v4l2_priority v4l2_prio_max(struct v4l2_prio_state *global); int v4l2_prio_check(struct v4l2_prio_state *global, enum v4l2_priority *local); /* names for fancy debug output */ extern char *v4l2_field_names[]; extern char *v4l2_type_names[]; extern char *v4l2_ioctl_names[]; /* Compatibility layer interface -- v4l1-compat module */ typedef int (*v4l2_kioctl)(struct inode *inode, struct file *file, unsigned int cmd, void *arg); int v4l_compat_translate_ioctl(struct inode *inode, struct file *file, int cmd, void *arg, v4l2_kioctl driver_ioctl); #endif /* __KERNEL__ */ #endif /* __LINUX_VIDEODEV2_H */ /* * Local variables: * c-basic-offset: 8 * End: */ Video-ivtv-0.13/META.yml0000644000076400003530000000044610134550135014145 0ustar james00000000000000# http://module-build.sourceforge.net/META-spec.html #XXXXXXX This is a prototype!!! It will change in the future!!! XXXXX# name: Video-ivtv version: 0.13 version_from: ivtv.pm installdirs: site requires: distribution_type: module generated_by: ExtUtils::MakeMaker version 6.17 Video-ivtv-0.13/MANIFEST0000644000076400003530000000035310063131737014026 0ustar james00000000000000Changes ivtv.pm ivtv.xs ivtv.h videodev2.h Makefile.PL MANIFEST README test.pl debian/changelog debian/compat debian/control debian/copyright debian/rules META.yml Module meta-data (added by MakeMaker)