The Video for Linux project develops drivers for analogue video capture hardware like TV-cards. Using these drivers you can watch and record TV programs and VHS tapes on your computer. Most capture cards have multiple inputs leaving you the choise which one to use. Most common video inputs are TV/FM in (RF), composite and s-video. Audio inputs should be 2 RCA ports for stereo sound.

Video for Linux has 2 main versions: v4l and v4l2. In this text we will be using v4l2 since it’s the latest and superior version. However when reffering to v4l2 we will use the abbreviation v4l.

In order to control the v4l driver we will use the v4l2-ctrl utility (/usr/bin/v4l2-ctrl). The v4l2-ctrl options will be discused along the article. The first options we will use are the ‘–*-video-input’ options. These options list, set and get the input port. Listing 1 shows the 3 options (the output for –list-video-inputs is wrapped with tree dots.

$ v4l2-ctrl --list-video-inputs
ioctl: VIDIOC_ENUMINPUT
Input   : 0
Name    : Tuner 1
...
Input   : 1
Name    : S-Video 1
...
Input   : 2
Name    : Composite 1
...
Input   : 3
Name    : S-Video 2
...
Input   : 4
Name    : Composite 2
...

$ v4l2-ctrl --set-video-input=2
Video input set to 2 (Composite 1)

$ v4l2-ctrl --get-video-input
Video input : 2 (Composite 1)

Tuner (TV and Radio).
In this article we will not use the TV/Radio port, nor the posibilities when watching TV.

Composite video.
Composite video is most commonly distributed over RCA ports and cables and therefore of lesser quality the newer connectors like s-video and scart. Composite video has tree components: 1 for luminance (brightness) and 2 for color information. The 2 color components are mixed together to create the chrominance (color) component. The first component by itself would output a monochrome picture. All components are transmitted on one wire.

S-Video.
The s-video standard is an extension of composite video. It separates the chrominance from the luminance by using different wires and thus leaving more bandwidth, hence more picture quality.

Note on s-video:
Most TV/VCR devices do not handle s-video correctly because the SCART specification (EURO-AV) does not implements ports for the s-video components, instead s-video over scart uses the RGB ports resulting that with some devices the image will be monochrome as only the luminance component is transmitted. If you need the quality of s-video, you will probably need to aquire an s-video device. JVC’s website is a good start.

In order to view the signal passed trough v4l we can use a commandline media player like mplayer. We just need to play the contents that v4l gets from the capture card, which usualy is mpeg-2 encoded. The content is a constant video stream, with, depending on the hardware, just a few seconds of delay because it is encoded on the fly.

The v4l devices are located in /dev/v4l but there should also be links inside the /dev directory. In the /dev/ directory there is also a direct link to the common video device named ‘video’. We will use this device to access the video stream.

$ ls /dev/v4l
radio0 vbi0 video0 video24 video32

$ ls -al /dev |grep v4l
lrwxrwxrwx  1 root root          10 Apr 17 13:10 radio -> v4l/radio0
lrwxrwxrwx  1 root root          10 Apr 17 13:10 radio0 -> v4l/radio0
drwxr-xr-x  2 root root           0 Apr 17 13:10 v4l
lrwxrwxrwx  1 root root           8 Apr 17 13:10 vbi -> v4l/vbi0
lrwxrwxrwx  1 root root           8 Apr 17 13:10 vbi0 -> v4l/vbi0
lrwxrwxrwx  1 root root          10 Apr 17 13:10 video -> v4l/video0
lrwxrwxrwx  1 root root          10 Apr 17 13:10 video0 -> v4l/video0
lrwxrwxrwx  1 root root          11 Apr 17 13:10 video24 -> v4l/video24
lrwxrwxrwx  1 root root          11 Apr 17 13:10 video32 -> v4l/video32

$ mplayer -cache 8192 -ni /dev/video

This last command should play the video stream from the selected source in listing 1. Remember that there is a short delay (a few seconds). The video source should be started first. The v4l device will return a black (or blue, if the device is in standby position) screen until the picture is send trough. Making mplayer cache before it plays the stream is recommended, otherwise it might complain. The -ni option makes mplayer parse the stream as non-interleaved, which also clears some errors.

Now that we have selected the right video source we can start setting up the v4l sound and picture options.

CAPTURING WITH THE IEEE1394 ( FIREWIRE / ILink ) DRIVERS.

The ieee1394 project develops kernel modules (drivers) for firewire or i.Link harware (firewire and i.Link are the commercial names given to the ieee1394 protocol by Apple and Sony). There are no v4l devices for ieee1394, one can however use the v4l vloopback device but that is not within the scope of this text. In this text the video1394 module will be used instead.

The video1394 module uses a device named /dev/video1394, or /dev/video1394-0 where 0 indicates the current controller in use. (the module supports up to 4 different controllers or cards). The module may not be loaded by default, to check if it is loaded run ‘lsmod |grep video’ This should return (depending on which modules are loaded) something like:

$ lsmod |grep video
video1394              18448  0
ohci1394               33608  2 video1394,dv1394
ieee1394               93144  4 video1394,dv1394,raw1394,ohci1394
videodev               27904  1 ivtv
v4l2_common            18688  6 wm8775,cx25840,tuner,ivtv,cx2341x,videodev
v4l1_compat            13956  2 ivtv,videodev

If the video1394 module is not listed, load it with modprobe, then run ‘lsmod |grep video’ again.

$ modprobe video1394
$ lsmod |grep video

Now check if the video1394 device is created properly with ‘ls /dev/*1394*’. This should return a list of ieee1394 devices similar to the next example depending on the ieee1394 modules that are loaded.

$ ls /dev/*1394*
/dev/raw1394
/dev/dv1394
/dev/video1394-0

These devices are created following the conventions given in the udev ruleset (when running udev) or the devfs config file (when using devfs).

Further reading (and searching):
ENCODING MPEG-2 (DVD) WITH MENCODER.
DVD AUTHORING WITH DVDAUTHOR AND SPUMUX.

De GNU Toolset.

De GNU toolset is een verzameling van vele kleinere programma’s die allemaal een specifieke rol spelen binnen een besturingssysteem. Het anagram GNU staat voor GNU is Not Unix, waarmee men doelt op het feit dat, ondanks het GNU systeem en dus ook het GNU/Linux besturingssysteem gebaseerd is op het Unix besturingssysteem, het een vrij systeem is. Werken met Unix is enorm beperkt door patenten en licentievoorwaarden maar door zijn modulaire aard kan men de onderdelen ‘vervangen’ door vrije GNU varianten. Andere besturingssystemen die op Unix gebaseerd zijn, zijn ondermeer OS X, Solaris en (Free)BSD.

Waarom Unix?

Waarom baseert men zich op een systeem van eind jaren ‘70? Het Unix bestandssysteem dat de dragende kracht is van het platform, bepaalt dat zo goed als alles een onderdeel is in een grote boomstructuur (vanuit het perspectief van het systeem). Of het nu om een tekst gaat of een toetsenbord of printer, in principe is alles een bestand. Op die manier is het systeem modulair en dus beter te beheren. Unix bestaat ook uit vele kleine (niet-interactieve) programma’s die samenwerken om taken uit te voeren. De combinatie van deze kleine programma’s bepaalt dus de functionaliteit. Dus opnieuw modulariteit. Het systeem laat ook meerdere gebruikers toe en heeft dus een zeer uitgebreid gebruikersrechtensysteem, wat van uiterst belang is voor de veiligheid bij het werken binnen een netwerkomgeving zoals bijvoorbeeld het internet.

Distributies.

Door uiteenlopende meningen en dankzij de open aard van GPL (General Public License) gelicenseerde software zijn er verschillende versies ontstaan van het GNU/Linux besturingssysteem. Zulke versies worden distributies genoemd. Eigenlijk wordt een GNU/Linux systeem getypeerd door de manier van configuratie en de meegeleverde software. Er zijn bijvoorbeeld distributies die zich specialiseren in bepaalde systeemvereisten zoals die van laptops, GPS systemen, game consoles, servers of desktop computers. Andere distributies leggen zich dan weer toe op specifieke gebruikersnoden zoals multimedia, geluidssynthesis, geografische doeleinden, forensisch onderzoek, specifieke taalondersteuning enzovoort.

Distributies worden zowel door privé-personen als door communities (mensen die via het internet met elkaar samenwerken) ontwikkeld, maar evengoed door universiteiten, overheidsinstellingen en -diensten. De meeste grote - en dus succesvolle - distributies staan echter op naam van bedrijven of zijn door bedrijven opgekocht. Bekende distributies zijn ondermeer IBM’s Redhat Linux, Novell Suse Linux, Mandriva, Debian GNU/Linux en (k)Ubuntu Linux. De meeste linux distributies stammen af, of zijn bewerkingen van deze grote distributies en delen dan ook heel wat eigenschappen met deze distributies. Er is echter een nieuwe generatie distributies die ontwikkeld wordt aan de hand van LFS (Linux From Scratch): een distributie die aan de hand van een uitvoerige handleiding van nul af aan stap voor stap een puur GNU/Linux systeem opbouwt. Deze worden dan stelselmatig aangepast aan de eisen van een modern linux systeem. Een voorbeeld van een moderne distributie is Archlinux.

Wat is de beste distributie?

Hierop is geen eenduidig antwoord te geven: de ene distributie is beter voor de ene taak, een andere is dan weer geschikter voor een andere. Ook mensen verschillen in hun voorkeur voor een bepaalde distributie. De hoofdregel is: elke distributie is in principe compatibel. Men kan dus meerdere systemen binnen dezelfde werkomgeving gebruiken zonder al te veel aanpassingen en complicaties. Het komt er dus op neer om te bepalen wat de eisen zijn die de gebruiker(s) en de omgeving stellen. Enkele belangrijke elementen in deze bepaling kunnen zijn: de middelen (De eisen die oudere computers stellen zijn anders dan de eisen van laptops, die dan weer anders zijn dan die van servers…), de gebruikers (ervaren of niet-ervaren gebruikers) en het beheer (onderschat nooit de tijd die noodzakelijk is om een systeem degelijk te beheren; kies een systeem dat voldoende door zijn gebruikers kan beheerd worden).

Wat kan ik wel / niet doen op een GNU/Linux systeem?

De mogelijkheden van het systeem zijn in zekere mate bepaald door de distributie enerzijds en het bestaan van de gewenste functionaliteit voor het GNU/Linux systeem anderzijds. Bepaalde programma’s stellen eisen aan het besturingssysteem waardoor het voor andere programma’s moeilijker wordt om te functioneren. Zoals bijvoorbeeld de specifieke aanpassingen die noodzakelijk zijn om betere beeld- of geluidsbewerking te doen. Over het algemeen is er een goede basisconfiguratie die het de meeste programma’s mogelijk maakt te werken. De vraag blijft natuurlijk of er een bepaalde functionaliteit voorhande is voor het GNU/Linux systeem. Maar dan nog blijft de vraag: is het programma dat deze functionaliteit implementeert voldoende stabiel en voldoet deze aan de eisen van de gebruiker. De meeste geavanceerde programma’s die vrij (en dus gratis) beschikbaar zijn voor GNU/Linux zijn in constante ontwikkeling en kunnen dus kinderziekten vertonen. Voor de meest voor de hand liggende noden echter, zijn er voldoende programma’s die goed functioneren. Bij programma’s voor bureautica- en multimediatoepassingen komt het er dus meestal op neer te kiezen, eerder dan te vinden. Op het internet kan men via zoekrobots zoals Google meestal snel een GNU/Linux variant vinden op een programma door te zoeken naar “programmanaam+linux”.

De General Public Licence of GPL.

GNU/Linux en de meeste programma’s (software) die beschikbaar zijn voor GNU/Linux, maar ook veel programma’s die beschikbaar zijn voor andere besturingssystemen vallen onder het GPL. Het GPL is een software licentie die ontwikkeld is vanuit het oorspronkelijke principe die gehanteerd werd bij het ontwikkelen van software: de code is vrij en beschikbaar voor iedereen. Dat wil zeggen dat iedereen de achterliggende broncode (de logische stappen die een software programma maakt) kan bekijken en, desgewenst, kan aanpassen of gebruiken in eigen software. Vanaf het moment dat computers, en dus ook besturingssystemen, buiten universiteiten gebruikt werden, kwam er al snel commerciële software op de markt waarvan de broncode niet meer beschikbaar werd gesteld aan het publiek. Dit kan aangezien broncode steeds ‘gecompileerd’ wordt - het wordt omgezet naar een taal die de computer kan verstaan. Volgens de beweging achter de GPL, de Free Software Foundation, beperkt dit de innovatie en de kennis van software. De GPL is een licentie die stelt dat niet alleen de broncode van het programma beschikbaar moet zijn, maar ook deze van elke aanpassing of derivaat. De GPL is de meest voorkomende opensource (openbron) licentie, andere licenties zijn meestal beperkingen op de GPL zoals de Lesser GPL of LGPL. Het model van openbron (opensource) ontwikkeling, waarbij een (vaak grote) groep mensen via interactieve middelen zoals het internet en speciale ontwikkelprogramma’s aan één project werkt, zoals een software programma of GNU/Linux distributie, heeft in ieder geval al verschillende vruchten geworpen. Het GNU/Linux besturingssysteem is daarvan het voornaamste voorbeeld.

Hoe ziet GNU/Linux er uit?

De grafische omgeving waarin men werkt, speelt voor veel mensen een belangrijke rol. Vaak worden de systemen OS X en Windows op het grafische vlak vergeleken. Het is nu eenmaal zo, dat de meeste gebruikers veel eisen stellen aan het gebruiksgemak dat met de grafische interface gepaard gaat. Aangezien GNU/Linux een open systeem is, zijn er dan ook verschillende grafische systemen beschikbaar. Opnieuw is de keuze aan de gebruiker en kunnen meerdere grafische systemen apart of samen gebruikt worden. Deze grafische omgevingen variëren van zeer simpele tot zeer complexe systemen, er zijn zelf mogelijkheden die ver voorbij deze van de laatste OS X gaan. Natuurlijk vragen meer mogelijkheden ook betere en dus ook duurdere hardware. Toch is het mogelijk om de meeste grafische omgevingen voor GNU/Linux zo in te stellen dat ze zelfs op oudere computers naar behoren kunnen werken.

Er zijn enkele populaire systemen die een volledige oplossing aanbieden: ze bieden een hele reeks hulpprogramma’s aan, zoals ondermeer een browser voor zowel bestanden als het internet, een tekstverwerker en allerlei programma’s voor het bekijken van foto’s, videos, teksten en het beluisteren van muziek. Deze programma’s zijn telkens ingewerkt in het systeem zodat ze herkenbaar zijn en een lagere leercurve hebben. Voorbeelden zijn KDE, GNOME en XFCE.

“XML Schema: Datatypes is part 2 of the specification of the XML Schema language. It defines facilities for defining datatypes to be used in XML Schema s as well as other XML specifications. The datatype language, which is itself represented in XML 1.0, provides a superset of the capabilities found in XML 1.0 document type definitions (DTDs) for specifying datatypes on elements and attributes.”

The XML Schema datatypes definition language is, as it’s parental language XML, an extensible language. It is implemented in many xml languages or dialects as a way to distinct and validate values. Examples are RDF and Xforms. The following code example uses an XML Schema (xs) datatype to distinct a value used in RDF. The code is taken from the RDF recommendation

Example 1. RDF’s use of xs datatypes.

Line 5 states that the datatype of the value given for the ex:size of http://example.org/item01 (123) is int

Example 2. XForms use of xs datatypes.

This XForms model uses XML Schema datatypes twice: First while using the buil-in datatype gYearMonth to type the node /my:payment/my:expiry and then by deriving a new datatype called ccnumber from the buil-in string datatype. This example is taken from the XForms recommendation

Type System

A datatype is (in this recommendation) a 3-tuple consisting of value space, lexical space and a set of characterizing facets.

Figure 1. The 3-tuple : value space, lexical space and facets

The value space holds the possible values and the lexical space holds the possible lexical representations of those values. If a datatype has more possible lexical representations - eg. like time or dates – the lexical space is referred to as ‘canonical’.

Facets define or restrict the value space of the datatype. The fundamental facets (equal, ordered, bounded, cardinality and numeric) semantically characterize while constraining facets (length, minLength, maxLength, pattern, enumeration, whiteSpace, maxInclusive, maxExclusive, minExclusive, minInclusive, totalDigits, fractionDigits) constrain the value space.

Datatypes can also be categorized by specific dimensions (Characterization dichotomies). The recommendation comes with a list of build-in datatypes, all other datatypes are user-derived (eg. written by you). Some build-in datatypes are primitive; They form the basis from which other datatypes are derived. Eg. A token is derived from normalizedString, which is derived from string. String is a primitive datatype.

Figure 2. Datatype Dichotomies

The most remarkable dichotomy is atomic versus list versus union. Datatypes can be either atomic (they hold only one indivisible value), lists (they hold a – possible empty - list of indivisible values) or unions (they combine the value and lexical space of one or several datatypes).

Figure 3. The build-in datatypes

The recommendation decribes all these datatypes into detail.

^[2] RDF/XML Syntax Specification (Revised) [http://www.w3.org/TR/rdf-syntax-grammar/]

^[3] XForms 1.0 (Second Edition) [http://www.w3.org/TR/xforms/]

This short example shows how one can download a file from an FTP server using mozilla’s Necko networking library(s). It is done by constructing the neccesary XPCOM Components and interfaces. First we need to get the FTP Component:

Then we QueryInterface() the nsIProtocolHandler. This interface provides protocol specific enhangements to the basic network functions newURI() and newChannel(). The nsIURI and nsIChannel interfaces returned by these functions are not very different. An nsIURI interface is an very descriptive platform independent way to determine a uniform resource identificator - a comprehensive descriptor for a resource. An nsIChannel interface uses the information of an nsIURI and constructs a connection (= channel) between the client and the remote resource.

Streams are low-level data containers. They can be used to transport, distribute, convert etc… the data they contain. The nsIChannel open() method creates a synchronised connection to the data and returns an nsIInputStream. If the action should be done asynchronously, use the AsyncOpen() method instead.

nsIInputStreams are not entirely scriptable, so we need to initialise the stream into a scriptable stream. XPCOM provides an interface called nsIScriptableInputStream which is implemented by the @mozilla.org/scriptableinputstream;1 component. The returned stream ‘aStream’ is the one we will be using.

Now we have to read the contents of the stream into a buffer (eg: a javascript String object).

Note
An nsIInputStream has a method called read() which is not scriptable. Therefore we have the use the method read() from the nsIScriptableInputStream. Although these methods look the same there is an important differance. They have a different construction. The nsIInputStream method:

PRUint32 read( charPtr* bufPRUint32 count);
charPtr* buf PRUint32 count ;

The nsIScriptableInputStream method:
char* read( PRUint32 count);
PRUint32 count ;

Where the first one takes the buffer as a parameter the second simply returns it.

Now we close the stream and return the buffer.

Full code listing:

Each value in the powers of 2 sequence is unique in that it can not be formed by any combination of the others. For example: There is no way to get 8 using more then one of these numbers because the addition of all numbers lower than 8 (1, 2, 4) is 7.

It is possible to form any number by combining these numbers. But any number can be formed with only one unique combination. For example: the number 7 is formed out of 1, 2 and 4. The number 9 out of 8 and 1.

If we make a sequence of 8 powers of 2 and represent them either as zeros or ones, a zero if we don’t use the power of 2 in our combination, a one if we do.

The representation of the number 9 would then look like this:

This program takes a decimal d and keeps dividing it by two ( d=(d/2) ) while the resulting number is higher or equal to one ( while(d>=1) ). It determines the remainder of each division and accordingly prepends a zero or one to the return value b ( b=((d%2>=1)?’1′:’0′)+b ).

Basic Usage of base 2 sequences.

Anne eats one icecream every day. For the sake of historic recollection she wants to store the flavors used. There are 4 flavors: vanilla, chocolate, strawberry and pistache. How should she store it so she can easily determine which flavor is used in a certain icecream?

The answer is simple:

Let’s give each flavor a unique power of 2 value:

	vanilla		= 8	(1000)
	chocolate	= 4	(0100)
	strawberry	= 2	(0010)
	pistache	= 1	(0001)

If Anne’s icecream has vanilla and strawberry that would make

	8 + 2 = 10

In base 2 notation that is:

	1010

If we would like to know if the flavor vanilla is used in a particular icecream we need to perform a little math; If a 1 occurs at both the icecream and vanilla sequences at the same spot (eg. first from the left) we place a 1 in a result sequence at the same spot. Any other combination (0 and 1, 0 and 0 or 1 and 0) returns 0. Our resulting line now shows:

	vanilla		= 1000
	icecream	= 1010
	======================
	result		= 1000

This result sequence is the same as the vanilla sequence; so vanilla is used in the icecream.

In scripting/programming languages this operation (bitwise AND) is mostly represented with the & (ampersant) symbol.

Example 2.

In order to count how many flavors are used in an icecream we just test for all the flavors.

Example 3.

Using base2 notation we can store information about the kind and number of flavors used in an icecream using a combination of only 4 one’s and/or zero’s. Comparing this to storing the actual names of the flavors you have to know that every character uses at least 8 zero’s or one’s in base2 notation. For the word vanilla that would add up to 7*8 = 56.