Move test to v4l2-apps/test.

From: Hans Verkuil <hverkuil@xs4all.nl>



Signed-off-by: Hans Verkuil <hverkuil@xs4all.nl>

6 files changed, 0 insertions, 2602 deletions

diff --git a/test/qv4l2/fileopen.xpm b/test/qv4l2/fileopen.xpm
deleted file mode 100644
index 880417eee..000000000
--- a/test/qv4l2/fileopen.xpm
+++ /dev/null
@@ -1,22 +0,0 @@
-/* XPM */
-static const char *fileopen[] = {
-"    16    13        5            1",
-". c #040404",
-"# c #808304",
-"a c None",
-"b c #f3f704",
-"c c #f3f7f3",
-"aaaaaaaaa...aaaa",
-"aaaaaaaa.aaa.a.a",
-"aaaaaaaaaaaaa..a",
-"a...aaaaaaaa...a",
-".bcb.......aaaaa",
-".cbcbcbcbc.aaaaa",
-".bcbcbcbcb.aaaaa",
-".cbcb...........",
-".bcb.#########.a",
-".cb.#########.aa",
-".b.#########.aaa",
-"..#########.aaaa",
-"...........aaaaa"
-};
diff --git a/test/qv4l2/frequencies.c b/test/qv4l2/frequencies.c
deleted file mode 100644
index e30c55303..000000000
--- a/test/qv4l2/frequencies.c
+++ /dev/null
@@ -1,1300 +0,0 @@
-#include <stdlib.h>
-#include <sys/time.h>
-#include <pthread.h>
-
-#include "frequencies.h"
-
-/* --------------------------------------------------------------------- */
-
-/* US broadcast */
-static struct CHANLIST ntsc_bcast[] = {
-    { "2",	 55250 },
-    { "3",	 61250 },
-    { "4",	 67250 },
-    { "5",	 77250 },
-    { "6",	 83250 },
-    { "7",	175250 },
-    { "8",	181250 },
-    { "9",	187250 },
-    { "10",	193250 },
-    { "11",	199250 },
-    { "12",	205250 },
-    { "13",	211250 },
-    { "14",	471250 },
-    { "15",	477250 },
-    { "16",	483250 },
-    { "17",	489250 },
-    { "18",	495250 },
-    { "19",	501250 },
-    { "20",	507250 },
-    { "21",	513250 },
-    { "22",	519250 },
-    { "23",	525250 },
-    { "24",	531250 },
-    { "25",	537250 },
-    { "26",	543250 },
-    { "27",	549250 },
-    { "28",	555250 },
-    { "29",	561250 },
-    { "30",	567250 },
-    { "31",	573250 },
-    { "32",	579250 },
-    { "33",	585250 },
-    { "34",	591250 },
-    { "35",	597250 },
-    { "36",	603250 },
-    { "37",	609250 },
-    { "38",	615250 },
-    { "39",	621250 },
-    { "40",	627250 },
-    { "41",	633250 },
-    { "42",	639250 },
-    { "43",	645250 },
-    { "44",	651250 },
-    { "45",	657250 },
-    { "46",	663250 },
-    { "47",	669250 },
-    { "48",	675250 },
-    { "49",	681250 },
-    { "50",	687250 },
-    { "51",	693250 },
-    { "52",	699250 },
-    { "53",	705250 },
-    { "54",	711250 },
-    { "55",	717250 },
-    { "56",	723250 },
-    { "57",	729250 },
-    { "58",	735250 },
-    { "59",	741250 },
-    { "60",	747250 },
-    { "61",	753250 },
-    { "62",	759250 },
-    { "63",	765250 },
-    { "64",	771250 },
-    { "65",	777250 },
-    { "66",	783250 },
-    { "67",	789250 },
-    { "68",	795250 },
-    { "69",	801250 },
-
-    { "70",	807250 },
-    { "71",	813250 },
-    { "72",	819250 },
-    { "73",	825250 },
-    { "74",	831250 },
-    { "75",	837250 },
-    { "76",	843250 },
-    { "77",	849250 },
-    { "78",	855250 },
-    { "79",	861250 },
-    { "80",	867250 },
-    { "81",	873250 },
-    { "82",	879250 },
-    { "83",	885250 },
-};
-
-/* US cable */
-static struct CHANLIST ntsc_cable[] = {
-    { "1",	 73250 },
-    { "2",	 55250 },
-    { "3",	 61250 },
-    { "4",	 67250 },
-    { "5",	 77250 },
-    { "6",	 83250 },
-    { "7",	175250 },
-    { "8",	181250 },
-    { "9",	187250 },
-    { "10",	193250 },
-    { "11",	199250 },
-    { "12",	205250 },
-
-    { "13",	211250 },
-    { "14",	121250 },
-    { "15",	127250 },
-    { "16",	133250 },
-    { "17",	139250 },
-    { "18",	145250 },
-    { "19",	151250 },
-    { "20",	157250 },
-
-    { "21",	163250 },
-    { "22",	169250 },
-    { "23",	217250 },
-    { "24",	223250 },
-    { "25",	229250 },
-    { "26",	235250 },
-    { "27",	241250 },
-    { "28",	247250 },
-    { "29",	253250 },
-    { "30",	259250 },
-    { "31",	265250 },
-    { "32",	271250 },
-    { "33",	277250 },
-    { "34",	283250 },
-    { "35",	289250 },
-    { "36",	295250 },
-    { "37",	301250 },
-    { "38",	307250 },
-    { "39",	313250 },
-    { "40",	319250 },
-    { "41",	325250 },
-    { "42",	331250 },
-    { "43",	337250 },
-    { "44",	343250 },
-    { "45",	349250 },
-    { "46",	355250 },
-    { "47",	361250 },
-    { "48",	367250 },
-    { "49",	373250 },
-    { "50",	379250 },
-    { "51",	385250 },
-    { "52",	391250 },
-    { "53",	397250 },
-    { "54",	403250 },
-    { "55",	409250 },
-    { "56",	415250 },
-    { "57",	421250 },
-    { "58",	427250 },
-    { "59",	433250 },
-    { "60",	439250 },
-    { "61",	445250 },
-    { "62",	451250 },
-    { "63",	457250 },
-    { "64",	463250 },
-    { "65",	469250 },
-    { "66",	475250 },
-    { "67",	481250 },
-    { "68",	487250 },
-    { "69",	493250 },
-
-    { "70",	499250 },
-    { "71",	505250 },
-    { "72",	511250 },
-    { "73",	517250 },
-    { "74",	523250 },
-    { "75",	529250 },
-    { "76",	535250 },
-    { "77",	541250 },
-    { "78",	547250 },
-    { "79",	553250 },
-    { "80",	559250 },
-    { "81",	565250 },
-    { "82",	571250 },
-    { "83",	577250 },
-    { "84",	583250 },
-    { "85",	589250 },
-    { "86",	595250 },
-    { "87",	601250 },
-    { "88",	607250 },
-    { "89",	613250 },
-    { "90",	619250 },
-    { "91",	625250 },
-    { "92",	631250 },
-    { "93",	637250 },
-    { "94",	643250 },
-    { "95",	 91250 },
-    { "96",	 97250 },
-    { "97",	103250 },
-    { "98",	109250 },
-    { "99",	115250 },
-    { "100",	649250 },
-    { "101",	655250 },
-    { "102",	661250 },
-    { "103",	667250 },
-    { "104",	673250 },
-    { "105",	679250 },
-    { "106",	685250 },
-    { "107",	691250 },
-    { "108",	697250 },
-    { "109",	703250 },
-    { "110",	709250 },
-    { "111",	715250 },
-    { "112",	721250 },
-    { "113",	727250 },
-    { "114",	733250 },
-    { "115",	739250 },
-    { "116",	745250 },
-    { "117",	751250 },
-    { "118",	757250 },
-    { "119",	763250 },
-    { "120",	769250 },
-    { "121",	775250 },
-    { "122",	781250 },
-    { "123",	787250 },
-    { "124",	793250 },
-    { "125",	799250 },
-
-    { "T7", 	  8250 },
-    { "T8",	 14250 },
-    { "T9",	 20250 },
-    { "T10",	 26250 },
-    { "T11",	 32250 },
-    { "T12",	 38250 },
-    { "T13",	 44250 },
-    { "T14",	 50250 }
-};
-
-/* US HRC */
-static struct CHANLIST ntsc_hrc[] = {
-    { "1",	  72000 },
-
-    { "2",	  54000 },
-    { "3",	  60000 },
-    { "4",	  66000 },
-
-    { "5",	  78000 },
-    { "6",	  84000 },
-
-    { "7",	 174000 },
-    { "8",	 180000 },
-    { "9",	 186000 },
-    { "10",	 192000 },
-    { "11",	 198000 },
-    { "12",	 204000 },
-    { "13",	 210000 },
-    { "14",	 120000 },
-    { "15",	 126000 },
-    { "16",	 132000 },
-    { "17",	 138000 },
-    { "18",	 144000 },
-    { "19",	 150000 },
-    { "20",	 156000 },
-    { "21",	 162000 },
-    { "22",	 168000 },
-    { "23",	 216000 },
-    { "24",	 222000 },
-    { "25",	 228000 },
-    { "26",	 234000 },
-    { "27",	 240000 },
-    { "28",	 246000 },
-    { "29",	 252000 },
-    { "30",	 258000 },
-    { "31",	 264000 },
-    { "32",	 270000 },
-    { "33",	 276000 },
-    { "34",	 282000 },
-    { "35",	 288000 },
-    { "36",	 294000 },
-    { "37",	 300000 },
-    { "38",	 306000 },
-    { "39",	 312000 },
-    { "40",	 318000 },
-    { "41",	 324000 },
-    { "42",	 330000 },
-    { "43",	 336000 },
-    { "44",	 342000 },
-    { "45",	 348000 },
-    { "46",	 354000 },
-    { "47",	 360000 },
-    { "48",	 366000 },
-    { "49",	 372000 },
-    { "50",	 378000 },
-    { "51",	 384000 },
-    { "52",	 390000 },
-    { "53",	 396000 },
-    { "54",	 402000 },
-    { "55",	 408000 },
-    { "56",	 414000 },
-    { "57",	 420000 },
-    { "58",	 426000 },
-    { "59",	 432000 },
-    { "60",	 438000 },
-    { "61",	 444000 },
-    { "62",	 450000 },
-    { "63",	 456000 },
-    { "64",	 462000 },
-    { "65",	 468000 },
-    { "66",	 474000 },
-    { "67",	 480000 },
-    { "68",	 486000 },
-    { "69",	 492000 },
-    { "70",	 498000 },
-    { "71",	 504000 },
-    { "72",	 510000 },
-    { "73",	 516000 },
-    { "74",	 522000 },
-    { "75",	 528000 },
-    { "76",	 534000 },
-    { "77",	 540000 },
-    { "78",	 546000 },
-    { "79",	 552000 },
-    { "80",	 558000 },
-    { "81",	 564000 },
-    { "82",	 570000 },
-    { "83",	 576000 },
-    { "84",	 582000 },
-    { "85",	 588000 },
-    { "86",	 594000 },
-    { "87",	 600000 },
-    { "88",	 606000 },
-    { "89",	 612000 },
-    { "90",	 618000 },
-    { "91",	 624000 },
-    { "92",	 630000 },
-    { "93",	 636000 },
-    { "94",	 642000 },
-
-    { "95",	  90000 },
-    { "96",	  96000 },
-    { "97",	 102000 },
-    { "98",	 108000 },
-    { "99",	 114000 },
-
-    { "100",	 648000 },
-    { "101",	 654000 },
-    { "102",	 660000 },
-    { "103",	 666000 },
-    { "104",	 672000 },
-    { "105",	 678000 },
-    { "106",	 684000 },
-    { "107",	 690000 },
-    { "108",	 696000 },
-    { "109",	 702000 },
-    { "110",	 708000 },
-    { "111",	 714000 },
-    { "112",	 720000 },
-    { "113",	 726000 },
-    { "114",	 732000 },
-    { "115",	 738000 },
-    { "116",	 744000 },
-    { "117",	 750000 },
-    { "118",	 756000 },
-    { "119",	 762000 },
-    { "120",	 768000 },
-    { "121",	 774000 },
-    { "122",	 780000 },
-    { "123",	 786000 },
-    { "124",	 792000 },
-    { "125",	 798000 },
-
-    { "T7",	   7000 },
-    { "T8",	  13000 },
-    { "T9",	  19000 },
-    { "T10",	  25000 },
-    { "T11",	  31000 },
-    { "T12",	  37000 },
-    { "T13",	  43000 },
-    { "T14",	  49000 },
-};
-
-/* US IRC */
-static struct CHANLIST ntsc_irc[] = {
-    { "1",      73250 },
-    { "2",      55250 },
-    { "3",      61250 },
-    { "4",      67250 },
-    { "5",      79250 },
-    { "6",      85250 },
-    { "7",     175250 },
-    { "8",     181250 },
-    { "9",     187250 },
-    { "10",    193250 },
-    { "11",    199250 },
-    { "12",    205250 },
-    { "13",    211250 },
-
-    { "14",    121150 },
-    { "15",    127150 },
-    { "16",    133150 },
-    { "17",    139150 },
-    { "18",    145150 },
-    { "19",    151150 },
-    { "20",    157150 },
-    { "21",    163150 },
-    { "22",    169150 },
-
-    { "23",    217250 },
-    { "24",    223250 },
-    { "25",    229250 },
-    { "26",    235250 },
-    { "27",    241250 },
-    { "28",    247250 },
-    { "29",    253250 },
-    { "30",    259250 },
-    { "31",    265250 },
-    { "32",    271250 },
-    { "33",    277250 },
-    { "34",    283250 },
-    { "35",    289250 },
-    { "36",    295250 },
-    { "37",    301250 },
-    { "38",    307250 },
-    { "39",    313250 },
-    { "40",    319250 },
-    { "41",    325250 },
-    { "42",    331250 },
-    { "43",    337250 },
-    { "44",    343250 },
-    { "45",    349250 },
-    { "46",    355250 },
-    { "47",    361250 },
-    { "48",    367250 },
-    { "49",    373250 },
-    { "50",    379250 },
-    { "51",    385250 },
-    { "52",    391250 },
-    { "53",    397250 },
-    { "54",    403250 },
-    { "55",    409250 },
-    { "56",    415250 },
-    { "57",    421250 },
-    { "58",    427250 },
-    { "59",    433250 },
-    { "60",    439250 },
-    { "61",    445250 },
-    { "62",    451250 },
-    { "63",    457250 },
-    { "64",    463250 },
-    { "65",    469250 },
-    { "66",    475250 },
-    { "67",    481250 },
-    { "68",    487250 },
-    { "69",    493250 },
-    { "70",    499250 },
-    { "71",    505250 },
-    { "72",    511250 },
-    { "73",    517250 },
-    { "74",    523250 },
-    { "75",    529250 },
-    { "76",    535250 },
-    { "77",    541250 },
-    { "78",    547250 },
-    { "79",    553250 },
-    { "80",    559250 },
-    { "81",    565250 },
-    { "82",    571250 },
-    { "83",    577250 },
-    { "84",    583250 },
-    { "85",    589250 },
-    { "86",    595250 },
-    { "87",    601250 },
-    { "88",    607250 },
-    { "89",    613250 },
-    { "90",    619250 },
-    { "91",    625250 },
-    { "92",    631250 },
-    { "93",    637250 },
-    { "94",    643250 },
-
-    { "95",     91250 },
-    { "96",     97250 },
-    { "97",    103250 },
-    { "98",    109250 },
-    { "99",    115250 },
-    { "100",   649250 },
-    { "101",   655250 },
-    { "102",   661250 },
-    { "103",   667250 },
-    { "104",   673250 },
-    { "105",   679250 },
-    { "106",   685250 },
-    { "107",   691250 },
-    { "108",   697250 },
-    { "109",   703250 },
-    { "110",   709250 },
-    { "111",   715250 },
-    { "112",   721250 },
-    { "113",   727250 },
-    { "114",   733250 },
-    { "115",   739250 },
-    { "116",   745250 },
-    { "117",   751250 },
-    { "118",   757250 },
-    { "119",   763250 },
-    { "120",   769250 },
-    { "121",   775250 },
-    { "122",   781250 },
-    { "123",   787250 },
-    { "124",   793250 },
-    { "125",   799250 },
-
-    { "T7",      8250 },
-    { "T8",     14250 },
-    { "T9",     20250 },
-    { "T10",    26250 },
-    { "T11",    32250 },
-    { "T12",    38250 },
-    { "T13",    44250 },
-    { "T14",    50250 }
-};
-
-
-/* --------------------------------------------------------------------- */
-
-/* JP broadcast */
-static struct CHANLIST ntsc_bcast_jp[] = {
-    { "1",   91250 },
-    { "2",   97250 },
-    { "3",  103250 },
-    { "4",  171250 },
-    { "5",  177250 },
-    { "6",  183250 },
-    { "7",  189250 },
-    { "8",  193250 },
-    { "9",  199250 },
-    { "10", 205250 },
-    { "11", 211250 },
-    { "12", 217250 },
-
-    { "13", 471250 },
-    { "14", 477250 },
-    { "15", 483250 },
-    { "16", 489250 },
-    { "17", 495250 },
-    { "18", 501250 },
-    { "19", 507250 },
-    { "20", 513250 },
-    { "21", 519250 },
-    { "22", 525250 },
-    { "23", 531250 },
-    { "24", 537250 },
-    { "25", 543250 },
-    { "26", 549250 },
-    { "27", 555250 },
-    { "28", 561250 },
-    { "29", 567250 },
-    { "30", 573250 },
-    { "31", 579250 },
-    { "32", 585250 },
-    { "33", 591250 },
-    { "34", 597250 },
-    { "35", 603250 },
-    { "36", 609250 },
-    { "37", 615250 },
-    { "38", 621250 },
-    { "39", 627250 },
-    { "40", 633250 },
-    { "41", 639250 },
-    { "42", 645250 },
-    { "43", 651250 },
-    { "44", 657250 },
-
-    { "45", 663250 },
-    { "46", 669250 },
-    { "47", 675250 },
-    { "48", 681250 },
-    { "49", 687250 },
-    { "50", 693250 },
-    { "51", 699250 },
-    { "52", 705250 },
-    { "53", 711250 },
-    { "54", 717250 },
-    { "55", 723250 },
-    { "56", 729250 },
-    { "57", 735250 },
-    { "58", 741250 },
-    { "59", 747250 },
-    { "60", 753250 },
-    { "61", 759250 },
-    { "62", 765250 },
-};
-
-/* JP cable */
-static struct CHANLIST ntsc_cable_jp[] = {
-    { "13",	109250 },
-    { "14",	115250 },
-    { "15",	121250 },
-    { "16",	127250 },
-    { "17",	133250 },
-    { "18",	139250 },
-    { "19",	145250 },
-    { "20",	151250 },
-
-    { "21",	157250 },
-    { "22",	165250 },
-    { "23",	223250 },
-    { "24",	231250 },
-    { "25",	237250 },
-    { "26",	243250 },
-    { "27",	249250 },
-    { "28",	253250 },
-    { "29",	259250 },
-    { "30",	265250 },
-    { "31",	271250 },
-    { "32",	277250 },
-    { "33",	283250 },
-    { "34",	289250 },
-    { "35",	295250 },
-    { "36",	301250 },
-    { "37",	307250 },
-    { "38",	313250 },
-    { "39",	319250 },
-    { "40",	325250 },
-    { "41",	331250 },
-    { "42",	337250 },
-    { "43",	343250 },
-    { "44",	349250 },
-    { "45", 	355250 },
-    { "46", 	361250 },
-    { "47", 	367250 },
-    { "48", 	373250 },
-    { "49", 	379250 },
-    { "50", 	385250 },
-    { "51", 	391250 },
-    { "52", 	397250 },
-    { "53", 	403250 },
-    { "54", 	409250 },
-    { "55", 	415250 },
-    { "56", 	421250 },
-    { "57", 	427250 },
-    { "58", 	433250 },
-    { "59", 	439250 },
-    { "60", 	445250 },
-    { "61", 	451250 },
-    { "62", 	457250 },
-    { "63",	463250 },
-};
-
-/* --------------------------------------------------------------------- */
-
-/* australia */
-static struct CHANLIST pal_australia[] = {
-    { "0",	 46250 },
-    { "1",	 57250 },
-    { "2",	 64250 },
-    { "3",	 86250 },
-    { "4",  	 95250 },
-    { "5",  	102250 },
-    { "5A",  	138250 },
-    { "6",  	175250 },
-    { "7",  	182250 },
-    { "8",  	189250 },
-    { "9",  	196250 },
-    { "10", 	209250 },
-    { "11",	216250 },
-    { "28",	527250 },
-    { "29",	534250 },
-    { "30",	541250 },
-    { "31",	548250 },
-    { "32",	555250 },
-    { "33",	562250 },
-    { "34",	569250 },
-    { "35",	576250 },
-    { "36",     591250 },
-    { "39",	604250 },
-    { "40",	611250 },
-    { "41",	618250 },
-    { "42",	625250 },
-    { "43",	632250 },
-    { "44",	639250 },
-    { "45",	646250 },
-    { "46",	653250 },
-    { "47",	660250 },
-    { "48",	667250 },
-    { "49",	674250 },
-    { "50",	681250 },
-    { "51",	688250 },
-    { "52",	695250 },
-    { "53",	702250 },
-    { "54",	709250 },
-    { "55",	716250 },
-    { "56",	723250 },
-    { "57",	730250 },
-    { "58",	737250 },
-    { "59",	744250 },
-    { "60",	751250 },
-    { "61",	758250 },
-    { "62",	765250 },
-    { "63",	772250 },
-    { "64",	779250 },
-    { "65",	786250 },
-    { "66",	793250 },
-    { "67",	800250 },
-    { "68",	807250 },
-    { "69",	814250 },
-};
-
-static struct CHANLIST pal_australia_optus[] = {
-   { "1",  138250 },
-   { "2",  147250 },
-   { "3",  154250 },
-   { "4",  161250 },
-   { "5",  168250 },
-   { "6",  175250 },
-   { "7",  182250 },
-   { "8",  189250 },
-   { "9",  196250 },
-   { "10", 209250 },
-   { "11", 216250 },
-   { "12", 224250 },
-   { "13", 231250 },
-   { "14", 238250 },
-   { "15", 245250 },
-   { "16", 252250 },
-   { "17", 259250 },
-   { "18", 266250 },
-   { "19", 273250 },
-   { "20", 280250 },
-   { "21", 287250 },
-   { "22", 294250 },
-   { "23", 303250 },
-   { "24", 310250 },
-   { "25", 317250 },
-   { "26", 324250 },
-   { "27", 338250 },
-   { "28", 345250 },
-   { "29", 352250 },
-   { "30", 359250 },
-   { "31", 366250 },
-   { "32", 373250 },
-   { "33", 380250 },
-   { "34", 387250 },
-   { "35", 394250 },
-   { "36", 401250 },
-   { "37", 408250 },
-   { "38", 415250 },
-   { "39", 422250 },
-   { "40", 429250 },
-   { "41", 436250 },
-   { "42", 443250 },
-   { "43", 450250 },
-   { "44", 457250 },
-   { "45", 464250 },
-   { "46", 471250 },
-   { "47", 478250 },
-   { "48", 485250 },
-   { "49", 492250 },
-   { "50", 499250 },
-   { "51", 506250 },
-   { "52", 513250 },
-   { "53", 520250 },
-   { "54", 527250 },
-   { "55", 534250 },
-};
-
-
-/* --------------------------------------------------------------------- */
-/* europe                                                                */
-
-/* CCIR frequencies */
-
-#define FREQ_CCIR_I_III		\
-    { "E2",	  48250 },	\
-    { "E3",	  55250 },	\
-    { "E4",	  62250 },	\
-				\
-    { "S01",	  69250 },	\
-    { "S02",	  76250 },	\
-    { "S03",	  83250 },	\
-				\
-    { "E5",	 175250 },	\
-    { "E6",	 182250 },	\
-    { "E7",	 189250 },	\
-    { "E8",	 196250 },	\
-    { "E9",	 203250 },	\
-    { "E10",	 210250 },	\
-    { "E11",	 217250 },	\
-    { "E12",	 224250 }
-
-#define FREQ_CCIR_SL_SH		\
-    { "SE1",	 105250 },	\
-    { "SE2",	 112250 },	\
-    { "SE3",	 119250 },	\
-    { "SE4",	 126250 },	\
-    { "SE5",	 133250 },	\
-    { "SE6",	 140250 },	\
-    { "SE7",	 147250 },	\
-    { "SE8",	 154250 },	\
-    { "SE9",	 161250 },	\
-    { "SE10",    168250 },	\
-				\
-    { "SE11",    231250 },	\
-    { "SE12",    238250 },	\
-    { "SE13",    245250 },	\
-    { "SE14",    252250 },	\
-    { "SE15",    259250 },	\
-    { "SE16",    266250 },	\
-    { "SE17",    273250 },	\
-    { "SE18",    280250 },	\
-    { "SE19",    287250 },	\
-    { "SE20",    294250 }
-
-#define FREQ_CCIR_H	\
-    { "S21", 303250 },	\
-    { "S22", 311250 },	\
-    { "S23", 319250 },	\
-    { "S24", 327250 },	\
-    { "S25", 335250 },	\
-    { "S26", 343250 },	\
-    { "S27", 351250 },	\
-    { "S28", 359250 },	\
-    { "S29", 367250 },	\
-    { "S30", 375250 },	\
-    { "S31", 383250 },	\
-    { "S32", 391250 },	\
-    { "S33", 399250 },	\
-    { "S34", 407250 },	\
-    { "S35", 415250 },	\
-    { "S36", 423250 },	\
-    { "S37", 431250 },	\
-    { "S38", 439250 },	\
-    { "S39", 447250 },	\
-    { "S40", 455250 },	\
-    { "S41", 463250 }
-
-/* OIRT frequencies */
-
-#define FREQ_OIRT_I_III		\
-    { "R1",       49750 },	\
-    { "R2",       59250 },	\
-				\
-    { "R3",       77250 },	\
-    { "R4",       85250 },	\
-    { "R5",       93250 },	\
-				\
-    { "R6",	 175250 },	\
-    { "R7",	 183250 },	\
-    { "R8",	 191250 },	\
-    { "R9",	 199250 },	\
-    { "R10",	 207250 },	\
-    { "R11",	 215250 },	\
-    { "R12",	 223250 }
-
-#define FREQ_OIRT_SL_SH		\
-    { "SR1",	 111250 },	\
-    { "SR2",	 119250 },	\
-    { "SR3",	 127250 },	\
-    { "SR4",	 135250 },	\
-    { "SR5",	 143250 },	\
-    { "SR6",	 151250 },	\
-    { "SR7",	 159250 },	\
-    { "SR8",	 167250 },	\
-				\
-    { "SR11",    231250 },	\
-    { "SR12",    239250 },	\
-    { "SR13",    247250 },	\
-    { "SR14",    255250 },	\
-    { "SR15",    263250 },	\
-    { "SR16",    271250 },	\
-    { "SR17",    279250 },	\
-    { "SR18",    287250 },	\
-    { "SR19",    295250 }
-
-#define FREQ_UHF	\
-    { "21",  471250 },	\
-    { "22",  479250 },	\
-    { "23",  487250 },	\
-    { "24",  495250 },	\
-    { "25",  503250 },	\
-    { "26",  511250 },	\
-    { "27",  519250 },	\
-    { "28",  527250 },	\
-    { "29",  535250 },	\
-    { "30",  543250 },	\
-    { "31",  551250 },	\
-    { "32",  559250 },	\
-    { "33",  567250 },	\
-    { "34",  575250 },	\
-    { "35",  583250 },	\
-    { "36",  591250 },	\
-    { "37",  599250 },	\
-    { "38",  607250 },	\
-    { "39",  615250 },	\
-    { "40",  623250 },	\
-    { "41",  631250 },	\
-    { "42",  639250 },	\
-    { "43",  647250 },	\
-    { "44",  655250 },	\
-    { "45",  663250 },	\
-    { "46",  671250 },	\
-    { "47",  679250 },	\
-    { "48",  687250 },	\
-    { "49",  695250 },	\
-    { "50",  703250 },	\
-    { "51",  711250 },	\
-    { "52",  719250 },	\
-    { "53",  727250 },	\
-    { "54",  735250 },	\
-    { "55",  743250 },	\
-    { "56",  751250 },	\
-    { "57",  759250 },	\
-    { "58",  767250 },	\
-    { "59",  775250 },	\
-    { "60",  783250 },	\
-    { "61",  791250 },	\
-    { "62",  799250 },	\
-    { "63",  807250 },	\
-    { "64",  815250 },	\
-    { "65",  823250 },	\
-    { "66",  831250 },	\
-    { "67",  839250 },	\
-    { "68",  847250 },	\
-    { "69",  855250 }
-
-static struct CHANLIST europe_west[] = {
-    FREQ_CCIR_I_III,
-    FREQ_CCIR_SL_SH,
-    FREQ_CCIR_H,
-    FREQ_UHF
-};
-
-static struct CHANLIST europe_east[] = {
-    FREQ_OIRT_I_III,
-    FREQ_OIRT_SL_SH,
-    FREQ_CCIR_I_III,
-    FREQ_CCIR_SL_SH,
-    FREQ_CCIR_H,
-    FREQ_UHF
-};
-
-static struct CHANLIST pal_italy[] = {
-    { "A",	 53750 },
-    { "B",	 62250 },
-    { "C",	 82250 },
-    { "D",	175250 },
-    { "E",	183750 },
-    { "F",	192250 },
-    { "G",	201250 },
-    { "H",	210250 },
-    { "H1",	217250 },
-    { "H2",	224250 },
-    FREQ_UHF
-};
-
-static struct CHANLIST pal_ireland[] = {
-    { "A0",    45750 },
-    { "A1",    48000 },
-    { "A2",    53750 },
-    { "A3",    56000 },
-    { "A4",    61750 },
-    { "A5",    64000 },
-    { "A6",   175250 },
-    { "A7",   176000 },
-    { "A8",   183250 },
-    { "A9",   184000 },
-    { "A10",   191250 },
-    { "A11",   192000 },
-    { "A12",   199250 },
-    { "A13",   200000 },
-    { "A14",   207250 },
-    { "A15",   208000 },
-    { "A16",   215250 },
-    { "A17",   216000 },
-    { "A18",   224000 },
-    { "A19",   232000 },
-    { "A20",   248000 },
-    { "A21",   256000 },
-    { "A22",   264000 },
-    { "A23",   272000 },
-    { "A24",   280000 },
-    { "A25",   288000 },
-    { "A26",   296000 },
-    { "A27",   304000 },
-    { "A28",   312000 },
-    { "A29",   320000 },
-    { "A30",   344000 },
-    { "A31",   352000 },
-    { "A32",   408000 },
-    { "A33",   416000 },
-    { "A34",   448000 },
-    { "A35",   480000 },
-    { "A36",   520000 },
-    FREQ_UHF,
-};
-
-static struct CHANLIST secam_france[] = {
-    { "K01",    47750 },
-    { "K02",    55750 },
-    { "K03",    60500 },
-    { "K04",    63750 },
-    { "K05",   176000 },
-    { "K06",   184000 },
-    { "K07",   192000 },
-    { "K08",   200000 },
-    { "K09",   208000 },
-    { "K10",   216000 },
-    { "KB",    116750 },
-    { "KC",    128750 },
-    { "KD",    140750 },
-    { "KE",    159750 },
-    { "KF",    164750 },
-    { "KG",    176750 },
-    { "KH",    188750 },
-    { "KI",    200750 },
-    { "KJ",    212750 },
-    { "KK",    224750 },
-    { "KL",    236750 },
-    { "KM",    248750 },
-    { "KN",    260750 },
-    { "KO",    272750 },
-    { "KP",    284750 },
-    { "KQ",    296750 },
-    { "H01",   303250 },
-    { "H02",   311250 },
-    { "H03",   319250 },
-    { "H04",   327250 },
-    { "H05",   335250 },
-    { "H06",   343250 },
-    { "H07",   351250 },
-    { "H08",   359250 },
-    { "H09",   367250 },
-    { "H10",   375250 },
-    { "H11",   383250 },
-    { "H12",   391250 },
-    { "H13",   399250 },
-    { "H14",   407250 },
-    { "H15",   415250 },
-    { "H16",   423250 },
-    { "H17",   431250 },
-    { "H18",   439250 },
-    { "H19",   447250 },
-    FREQ_UHF,
-};
-
-/* --------------------------------------------------------------------- */
-
-static struct CHANLIST pal_newzealand[] = {
-    { "1", 	  45250 },
-    { "2",	  55250 },
-    { "3",	  62250 },
-    { "4",	 175250 },
-    { "5",	 182250 },
-    { "6",	 189250 },
-    { "7",	 196250 },
-    { "8",	 203250 },
-    { "9",	 210250 },
-    { "10",	 217250 },
-    { "11",	 224250 },
-    FREQ_UHF,
-};
-
-/* --------------------------------------------------------------------- */
-
-/* China broadcast */
-static struct CHANLIST pal_bcast_cn[] = {
-    { "1",	49750 },
-    { "2",	57750 },
-    { "3",	65750 },
-    { "4",	77250 },
-    { "5",	85250 },
-    { "6",	112250 },
-    { "7",	120250 },
-    { "8",	128250 },
-    { "9",	136250 },
-    { "10",	144250 },
-    { "11",	152250 },
-    { "12",	160250 },
-    { "13",	168250 },
-    { "14",	176250 },
-    { "15",	184250 },
-    { "16",	192250 },
-    { "17",	200250 },
-    { "18",	208250 },
-    { "19",	216250 },
-    { "20",	224250 },
-    { "21",	232250 },
-    { "22",	240250 },
-    { "23",	248250 },
-    { "24",	256250 },
-    { "25",	264250 },
-    { "26",	272250 },
-    { "27",	280250 },
-    { "28",	288250 },
-    { "29",	296250 },
-    { "30",	304250 },
-    { "31",	312250 },
-    { "32",	320250 },
-    { "33",	328250 },
-    { "34",	336250 },
-    { "35",	344250 },
-    { "36",	352250 },
-    { "37",	360250 },
-    { "38",	368250 },
-    { "39",	376250 },
-    { "40",	384250 },
-    { "41",	392250 },
-    { "42",	400250 },
-    { "43",	408250 },
-    { "44",	416250 },
-    { "45",	424250 },
-    { "46",	432250 },
-    { "47",	440250 },
-    { "48",	448250 },
-    { "49",	456250 },
-    { "50",	463250 },
-    { "51",	471250 },
-    { "52",	479250 },
-    { "53",	487250 },
-    { "54",	495250 },
-    { "55",	503250 },
-    { "56",	511250 },
-    { "57",	519250 },
-    { "58",	527250 },
-    { "59",	535250 },
-    { "60",	543250 },
-    { "61",	551250 },
-    { "62",	559250 },
-    { "63",	607250 },
-    { "64",	615250 },
-    { "65",	623250 },
-    { "66",	631250 },
-    { "67",	639250 },
-    { "68",	647250 },
-    { "69",	655250 },
-    { "70",	663250 },
-    { "71",	671250 },
-    { "72",	679250 },
-    { "73",	687250 },
-    { "74",	695250 },
-    { "75",	703250 },
-    { "76",	711250 },
-    { "77",	719250 },
-    { "78",	727250 },
-    { "79",	735250 },
-    { "80",	743250 },
-    { "81",	751250 },
-    { "82",	759250 },
-    { "83",	767250 },
-    { "84",	775250 },
-    { "85",	783250 },
-    { "86",	791250 },
-    { "87",	799250 },
-    { "88",	807250 },
-    { "89",	815250 },
-    { "90",	823250 },
-    { "91",	831250 },
-    { "92",	839250 },
-    { "93",	847250 },
-    { "94",	855250 },
-};
-
-/* --------------------------------------------------------------------- */
-/* South Africa Broadcast */
-
-static struct CHANLIST pal_bcast_za[] ={
-    { "1", 175250 },
-    { "2", 183250 },
-    { "3", 191250 },
-    { "4", 199250 },
-    { "5", 207250 },
-    { "6", 215250 },
-    { "7", 223250 },
-    { "8", 231250 },
-    { "9", 239250 },
-    { "10", 247250 },
-    { "11", 255250 },
-    { "12", 263250 },
-    { "13", 271250 },
-    FREQ_UHF
-};
-
-/* --------------------------------------------------------------------- */
-
-static struct CHANLIST argentina[] = {
-    { "001",   56250 },
-    { "002",   62250 },
-    { "003",   68250 },
-    { "004",   78250 },
-    { "005",   84250 },
-    { "006",  176250 },
-    { "007",  182250 },
-    { "008",  188250 },
-    { "009",  194250 },
-    { "010",  200250 },
-    { "011",  206250 },
-    { "012",  212250 },
-    { "013",  122250 },
-    { "014",  128250 },
-    { "015",  134250 },
-    { "016",  140250 },
-    { "017",  146250 },
-    { "018",  152250 },
-    { "019",  158250 },
-    { "020",  164250 },
-    { "021",  170250 },
-    { "022",  218250 },
-    { "023",  224250 },
-    { "024",  230250 },
-    { "025",  236250 },
-    { "026",  242250 },
-    { "027",  248250 },
-    { "028",  254250 },
-    { "029",  260250 },
-    { "030",  266250 },
-    { "031",  272250 },
-    { "032",  278250 },
-    { "033",  284250 },
-    { "034",  290250 },
-    { "035",  296250 },
-    { "036",  302250 },
-    { "037",  308250 },
-    { "038",  314250 },
-    { "039",  320250 },
-    { "040",  326250 },
-    { "041",  332250 },
-    { "042",  338250 },
-    { "043",  344250 },
-    { "044",  350250 },
-    { "045",  356250 },
-    { "046",  362250 },
-    { "047",  368250 },
-    { "048",  374250 },
-    { "049",  380250 },
-    { "050",  386250 },
-    { "051",  392250 },
-    { "052",  398250 },
-    { "053",  404250 },
-    { "054",  410250 },
-    { "055",  416250 },
-    { "056",  422250 },
-    { "057",  428250 },
-    { "058",  434250 },
-    { "059",  440250 },
-    { "060",  446250 },
-    { "061",  452250 },
-    { "062",  458250 },
-    { "063",  464250 },
-    { "064",  470250 },
-    { "065",  476250 },
-    { "066",  482250 },
-    { "067",  488250 },
-    { "068",  494250 },
-    { "069",  500250 },
-    { "070",  506250 },
-    { "071",  512250 },
-    { "072",  518250 },
-    { "073",  524250 },
-    { "074",  530250 },
-    { "075",  536250 },
-    { "076",  542250 },
-    { "077",  548250 },
-    { "078",  554250 },
-    { "079",  560250 },
-    { "080",  566250 },
-    { "081",  572250 },
-    { "082",  578250 },
-    { "083",  584250 },
-    { "084",  590250 },
-    { "085",  596250 },
-    { "086",  602250 },
-    { "087",  608250 },
-    { "088",  614250 },
-    { "089",  620250 },
-    { "090",  626250 },
-    { "091",  632250 },
-    { "092",  638250 },
-    { "093",  644250 },
-};
-
-/* --------------------------------------------------------------------- */
-
-struct CHANLISTS chanlists[] = {
-    { "us-bcast",         ntsc_bcast,        CHAN_COUNT(ntsc_bcast)        },
-    { "us-cable",         ntsc_cable,        CHAN_COUNT(ntsc_cable)        },
-    { "us-cable-hrc",     ntsc_hrc,          CHAN_COUNT(ntsc_hrc)          },
-    { "us-cable-irc",     ntsc_irc,          CHAN_COUNT(ntsc_irc)          },
-    { "japan-bcast",      ntsc_bcast_jp,     CHAN_COUNT(ntsc_bcast_jp)     },
-    { "japan-cable",      ntsc_cable_jp,     CHAN_COUNT(ntsc_cable_jp)     },
-    { "europe-west",      europe_west,       CHAN_COUNT(europe_west)       },
-    { "europe-east",      europe_east,       CHAN_COUNT(europe_east)       },
-    { "italy",		  pal_italy,         CHAN_COUNT(pal_italy)         },
-    { "newzealand",       pal_newzealand,    CHAN_COUNT(pal_newzealand)    },
-    { "australia",        pal_australia,     CHAN_COUNT(pal_australia)     },
-    { "ireland",          pal_ireland,       CHAN_COUNT(pal_ireland)       },
-    { "france",           secam_france,      CHAN_COUNT(secam_france)      },
-    { "china-bcast",      pal_bcast_cn,      CHAN_COUNT(pal_bcast_cn)      },
-    { "southafrica",      pal_bcast_za,      CHAN_COUNT(pal_bcast_za)      },
-    { "argentina",        argentina,         CHAN_COUNT(argentina)         },
-    { "australia-optus",  pal_australia_optus, CHAN_COUNT(pal_australia_optus) },
-    { NULL, NULL, 0 } /* EOF */
-};
diff --git a/test/qv4l2/frequencies.h b/test/qv4l2/frequencies.h
deleted file mode 100644
index e6044e5e1..000000000
--- a/test/qv4l2/frequencies.h
+++ /dev/null
@@ -1,111 +0,0 @@
-#ifndef FREQUENCIES_H
-#define FREQUENCIES_H
-
-/*
- * Worldwide channel/frequency list
- *
- * Nathan Laredo (laredo@broked.net)
- *
- * Frequencies are given in kHz
- */
-#define NTSC_AUDIO_CARRIER	4500
-#define PAL_AUDIO_CARRIER_I	6000
-#define PAL_AUDIO_CARRIER_BGHN	5500
-#define PAL_AUDIO_CARRIER_MN	4500
-#define PAL_AUDIO_CARRIER_D	6500
-#define SEACAM_AUDIO_DKK1L	6500
-#define SEACAM_AUDIO_BG		5500
-/* NICAM 728 32-kHz, 14-bit digital stereo audio is transmitted in 1ms frames
-   containing 8 bits frame sync, 5 bits control, 11 bits additional data, and
-   704 bits audio data.  The bit rate is reduced by transmitting only 10 bits
-   plus parity of each 14 bit sample, the largest sample in a frame determines
-   which 10 bits are transmitted.  The parity bits for audio samples also
-   specify the scaling factor used for that channel during that frame.  The
-   companeded audio data is interleaved to reduce the influence of dropouts
-   and the whole frame except for sync bits is scrambled for spectrum shaping.
-   Data is modulated using QPSK, at below following subcarrier freqs */
-#define NICAM728_PAL_BGH	5850
-#define NICAM728_PAL_I		6552
-
-/* COMPREHENSIVE LIST OF FORMAT BY COUNTRY
-   (M) NTSC used in:
-	Antigua, Aruba, Bahamas, Barbados, Belize, Bermuda, Bolivia, Burma,
-	Canada, Chile, Colombia, Costa Rica, Cuba, Curacao, Dominican Republic,
-	Ecuador, El Salvador, Guam Guatemala, Honduras, Jamaica, Japan,
-	South Korea, Mexico, Montserrat, Myanmar, Nicaragua, Panama, Peru,
-	Philippines, Puerto Rico, St Christopher and Nevis, Samoa, Suriname,
-	Taiwan, Trinidad/Tobago, United States, Venezuela, Virgin Islands
-   (B) PAL used in:
-	Albania, Algeria, Australia, Austria, Bahrain, Bangladesh, Belgium,
-	Bosnia-Herzegovinia, Brunei Darussalam, Cambodia, Cameroon, Croatia,
-	Cyprus, Denmark, Egypt, Ethiopia, Equatorial Guinea, Finland, Germany,
-	Ghana, Gibraltar, Greenland, Iceland, India, Indonesia, Israel, Italy,
-	Jordan, Kenya, Kuwait, Liberia, Libya, Luxembourg, Malaysa, Maldives,
-	Malta, Nepal, Netherlands, New Zeland, Nigeria, Norway, Oman, Pakistan,
-	Papua New Guinea, Portugal, Qatar, Sao Tome and Principe, Saudi Arabia,
-	Seychelles, Sierra Leone, Singapore, Slovenia, Somali, Spain,
-	Sri Lanka, Sudan, Swaziland, Sweden, Switzeland, Syria, Thailand,
-	Tunisia, Turkey, Uganda, United Arab Emirates, Yemen
-   (N) PAL used in: (Combination N = 4.5MHz audio carrier, 3.58MHz burst)
-	Argentina (Combination N), Paraguay, Uruguay
-   (M) PAL (525/60, 3.57MHz burst) used in:
-	Brazil
-   (G) PAL used in:
-	Albania, Algeria, Austria, Bahrain, Bosnia/Herzegovinia, Cambodia,
-	Cameroon, Croatia, Cyprus, Denmark, Egypt, Ethiopia, Equatorial Guinea,
-	Finland, Germany, Gibraltar, Greenland, Iceland, Israel, Italy, Jordan,
-	Kenya, Kuwait, Liberia, Libya, Luxembourg, Malaysia, Monaco,
-	Mozambique, Netherlands, New Zealand, Norway, Oman, Pakistan,
-	Papa New Guinea, Portugal, Qatar, Romania, Sierra Leone, Singapore,
-	Slovenia, Somalia, Spain, Sri Lanka, Sudan, Swaziland, Sweeden,
-	Switzerland, Syria, Thailand, Tunisia, Turkey, United Arab Emirates,
-	Yemen, Zambia, Zimbabwe
-   (D) PAL used in:
-	China, North Korea, Romania, Czech Republic
-   (H) PAL used in:
-	Belgium
-   (I) PAL used in:
-	Angola, Botswana, Gambia, Guinea-Bissau, Hong Kong, Ireland, Lesotho,
-	Malawi, Nambia, Nigeria, South Africa, Tanzania, United Kingdom,
-	Zanzibar
-   (B) SECAM used in:
-	Djibouti, Greece, Iran, Iraq, Lebanon, Mali, Mauritania, Mauritus,
-	Morocco
-   (D) SECAM used in:
-	Afghanistan, Armenia, Azerbaijan, Belarus, Bulgaria,
-	Estonia, Georgia, Hungary, Zazakhstan, Lithuania, Mongolia, Moldova,
-	Russia, Slovak Republic, Ukraine, Vietnam
-   (G) SECAM used in:
-	Greecem Iran, Iraq, Mali, Mauritus, Morocco, Saudi Arabia
-   (K) SECAM used in:
-	Armenia, Azerbaijan, Bulgaria, Estonia, Georgia,
-	Hungary, Kazakhstan, Lithuania, Madagascar, Moldova, Poland, Russia,
-	Slovak Republic, Ukraine, Vietnam
-   (K1) SECAM used in:
-	Benin, Burkina Faso, Burundi, Chad, Cape Verde, Central African
-	Republic, Comoros, Congo, Gabon, Madagascar, Niger, Rwanda, Senegal,
-	Togo, Zaire
-   (L) SECAM used in:
-	France
-*/
-
-/* --------------------------------------------------------------------- */
-
-typedef struct CHANLIST {
-    const char *name;
-    int   freq;
-} _chanlist;
-
-typedef struct CHANLISTS {
-    const char       *name;
-    struct CHANLIST  *list;
-    int               count;
-} _chanlists;
-
-#define CHAN_COUNT(x) (sizeof(x)/sizeof(struct CHANLIST))
-
-/* --------------------------------------------------------------------- */
-
-extern struct CHANLISTS   chanlists[];
-
-#endif
diff --git a/test/qv4l2/qv4l2.cpp b/test/qv4l2/qv4l2.cpp
deleted file mode 100644
index a4c675d48..000000000
--- a/test/qv4l2/qv4l2.cpp
+++ /dev/null
@@ -1,1049 +0,0 @@
-
-#include "qv4l2.h"
-#include "frequencies.h"
-
-#include <qimage.h>
-#include <qpixmap.h>
-#include <qtoolbar.h>
-#include <qtoolbutton.h>
-#include <qpopupmenu.h>
-#include <qmenubar.h>
-#include <qfile.h>
-#include <qfiledialog.h>
-#include <qstatusbar.h>
-#include <qmessagebox.h>
-#include <qapplication.h>
-#include <qaccel.h>
-#include <qlineedit.h>
-#include <qvalidator.h>
-#include <qlayout.h>
-#include <qvbox.h>
-#include <qhbox.h>
-#include <qlabel.h>
-#include <qslider.h>
-#include <qspinbox.h>
-#include <qcombobox.h>
-#include <qcheckbox.h>
-#include <qpushbutton.h>
-#include <qtooltip.h>
-#include <qpainter.h>
-#include <qpaintdevicemetrics.h>
-#include <qwhatsthis.h>
-
-#include <fcntl.h>
-#include <sys/ioctl.h>
-#include <errno.h>
-
-#include "fileopen.xpm"
-
-ApplicationWindow::ApplicationWindow()
-    : QMainWindow( 0, "V4L2 main window", WDestructiveClose | WGroupLeader )
-{
-    QPixmap openIcon, saveIcon;
-
-    fd = -1;
-
-    sigMapper = NULL;
-    QToolBar * fileTools = new QToolBar( this, "file operations" );
-    fileTools->setLabel( "File Operations" );
-
-    openIcon = QPixmap( fileopen );
-    QToolButton * fileOpen
-	= new QToolButton( openIcon, "Open File", QString::null,
-			   this, SLOT(choose()), fileTools, "open file" );
-
-    (void)QWhatsThis::whatsThisButton( fileTools );
-
-    const char * fileOpenText = "<p><img source=\"fileopen\"> "
-		 "Click this button to open a <em>new v4l device</em>.<br>"
-		 "You can also select the <b>Open</b> command "
-		 "from the <b>File</b> menu.</p>";
-
-    QWhatsThis::add( fileOpen, fileOpenText );
-
-    QMimeSourceFactory::defaultFactory()->setPixmap( "fileopen", openIcon );
-
-    QPopupMenu * file = new QPopupMenu( this );
-    menuBar()->insertItem( "&File", file );
-
-
-    int id;
-    id = file->insertItem( openIcon, "&Open...",
-			   this, SLOT(choose()), CTRL+Key_O );
-    file->setWhatsThis( id, fileOpenText );
-
-    file->insertSeparator();
-
-    file->insertItem( "&Close", this, SLOT(close()), CTRL+Key_W );
-
-    file->insertItem( "&Quit", qApp, SLOT( closeAllWindows() ), CTRL+Key_Q );
-
-    menuBar()->insertSeparator();
-
-    QPopupMenu * help = new QPopupMenu( this );
-    menuBar()->insertItem( "&Help", help );
-
-    help->insertItem( "&About", this, SLOT(about()), Key_F1 );
-    help->insertItem( "What's &This", this, SLOT(whatsThis()), SHIFT+Key_F1 );
-
-    statusBar()->message( "Ready", 2000 );
-
-    tabs = new QTabWidget(this);
-    tabs->setMargin(3);
-
-    //resize( 450, 600 );
-}
-
-
-ApplicationWindow::~ApplicationWindow()
-{
-	if (fd >= 0) ::close(fd);
-}
-
-
-void ApplicationWindow::setDevice(const QString &device)
-{
-	if (fd >= 0) ::close(fd);
-	while (QWidget *page = tabs->page(0)) {
-		tabs->removePage(page);
-		delete page;
-	}
-	delete tabs;
-	delete sigMapper;
-	tabs = new QTabWidget(this);
-	tabs->setMargin(3);
-	sigMapper = new QSignalMapper(this);
-	connect(sigMapper, SIGNAL(mapped(int)), this, SLOT(ctrlAction(int)));
-	ctrlMap.clear();
-	widgetMap.clear();
-	classMap.clear();
-	videoInput = NULL;
-	videoOutput = NULL;
-	audioInput = NULL;
-	audioOutput = NULL;
-	tvStandard = NULL;
-	freq = NULL;
-	freqChannel = NULL;
-	freqTable = NULL;
-
-	fd = ::open(device, O_RDONLY);
-	if (fd >= 0) {
-		addGeneralTab();
-		addTabs();
-	}
-	if (QWidget *current = tabs->currentPage()) {
-		current->show();
-	}
-	tabs->show();
-	tabs->setFocus();
-	setCentralWidget(tabs);
-}
-
-void ApplicationWindow::addGeneralTab()
-{
-	int cnt = 0;
-	QVBox *vbox = new QVBox(tabs);
-	QGrid *grid = new QGrid(4, vbox);
-	grid->setSpacing(3);
-	tabs->addTab(vbox, "General");
-
-	memset(&tuner, 0, sizeof(tuner));
-	ioctl(fd, VIDIOC_G_TUNER, &tuner);
-
-	struct v4l2_input vin;
-	memset(&vin, 0, sizeof(vin));
-	if (ioctl(fd, VIDIOC_ENUMINPUT, &vin) >= 0) {
-		QLabel *label = new QLabel("Input", grid);
-		label->setAlignment(Qt::AlignRight);
-		videoInput = new QComboBox(grid);
-		while (ioctl(fd, VIDIOC_ENUMINPUT, &vin) >= 0) {
-			videoInput->insertItem((char *)vin.name);
-			vin.index++;
-		}
-		connect(videoInput, SIGNAL(activated(int)), SLOT(inputChanged(int)));
-		updateVideoInput();
-		cnt++;
-	}
-
-	struct v4l2_output vout;
-	memset(&vout, 0, sizeof(vout));
-	if (ioctl(fd, VIDIOC_ENUMOUTPUT, &vout) >= 0) {
-		QLabel *label = new QLabel("Output", grid);
-		label->setAlignment(Qt::AlignRight);
-		videoOutput = new QComboBox(grid);
-		while (ioctl(fd, VIDIOC_ENUMOUTPUT, &vout) >= 0) {
-			videoOutput->insertItem((char *)vout.name);
-			vout.index++;
-		}
-		connect(videoOutput, SIGNAL(activated(int)), SLOT(outputChanged(int)));
-		updateVideoOutput();
-		cnt++;
-	}
-
-	struct v4l2_audio vaudio;
-	memset(&vaudio, 0, sizeof(vaudio));
-	if (ioctl(fd, VIDIOC_ENUMAUDIO, &vaudio) >= 0) {
-		QLabel *label = new QLabel("Input Audio", grid);
-		label->setAlignment(Qt::AlignRight);
-		audioInput = new QComboBox(grid);
-		vaudio.index = 0;
-		while (ioctl(fd, VIDIOC_ENUMAUDIO, &vaudio) >= 0) {
-			audioInput->insertItem((char *)vaudio.name);
-			vaudio.index++;
-		}
-		connect(audioInput, SIGNAL(activated(int)), SLOT(inputAudioChanged(int)));
-		updateAudioInput();
-		cnt++;
-	}
-
-	struct v4l2_audioout vaudioout;
-	memset(&vaudioout, 0, sizeof(vaudioout));
-	if (ioctl(fd, VIDIOC_ENUMAUDOUT, &vaudioout) >= 0) {
-		QLabel *label = new QLabel("Output Audio", grid);
-		label->setAlignment(Qt::AlignRight);
-		audioOutput = new QComboBox(grid);
-		while (ioctl(fd, VIDIOC_ENUMAUDOUT, &vaudioout) >= 0) {
-			audioOutput->insertItem((char *)vaudioout.name);
-			vaudioout.index++;
-		}
-		connect(audioOutput, SIGNAL(activated(int)), SLOT(outputAudioChanged(int)));
-		updateAudioOutput();
-		cnt++;
-	}
-
-	struct v4l2_standard vs;
-	memset(&vs, 0, sizeof(vs));
-	if (ioctl(fd, VIDIOC_ENUMSTD, &vs) >= 0) {
-		QLabel *label = new QLabel("TV Standard", grid);
-		label->setAlignment(Qt::AlignRight);
-		tvStandard = new QComboBox(grid);
-		while (ioctl(fd, VIDIOC_ENUMSTD, &vs) >= 0) {
-			tvStandard->insertItem((char *)vs.name);
-			vs.index++;
-		}
-		connect(tvStandard, SIGNAL(activated(int)), SLOT(standardChanged(int)));
-		updateStandard();
-		cnt++;
-	}
-
-	bool first = cnt & 1;
-
-	if (first) {
-		QString what;
-		QLabel *label = new QLabel("Frequency", grid);
-		label->setAlignment(Qt::AlignRight);
-		freq = new QSpinBox(tuner.rangelow, tuner.rangehigh, 1, grid);
-		QWhatsThis::add(freq, what.sprintf("Frequency\n"
-					"Low: %d\n"
-					"High: %d\n",
-					tuner.rangelow, tuner.rangehigh));
-		connect(freq, SIGNAL(valueChanged(int)), SLOT(freqChanged(int)));
-		updateFreq();
-		cnt++;
-	}
-
-	{
-		QLabel *label = new QLabel("Frequency Tables", grid);
-		label->setAlignment(Qt::AlignRight);
-		freqTable = new QComboBox(grid);
-		for (int i = 0; chanlists[i].name; i++) {
-			freqTable->insertItem(chanlists[i].name);
-		}
-		connect(freqTable, SIGNAL(activated(int)), SLOT(freqTableChanged(int)));
-
-		label = new QLabel("Channels", grid);
-		label->setAlignment(Qt::AlignRight);
-		freqChannel = new QComboBox(grid);
-		connect(freqChannel, SIGNAL(activated(int)), SLOT(freqChannelChanged(int)));
-		updateFreqChannel();
-	}
-
-	if (!first) {
-		QString what;
-		QLabel *label = new QLabel("Frequency", grid);
-		label->setAlignment(Qt::AlignRight);
-		freq = new QSpinBox(tuner.rangelow, tuner.rangehigh, 1, grid);
-		QWhatsThis::add(freq, what.sprintf("Frequency\n"
-					"Low: %d\n"
-					"High: %d\n",
-					tuner.rangelow, tuner.rangehigh));
-		connect(freq, SIGNAL(valueChanged(int)), SLOT(freqChanged(int)));
-		updateFreq();
-		cnt++;
-	}
-
-	if (cnt & 1) {
-		new QWidget(grid);
-		new QWidget(grid);
-	}
-	QWidget *stretch = new QWidget(grid);
-	stretch->setSizePolicy(QSizePolicy::Fixed, QSizePolicy::Ignored);
-}
-
-void ApplicationWindow::addTabs()
-{
-	struct v4l2_queryctrl qctrl;
-	unsigned ctrl_class;
-	unsigned i;
-	int id;
-
-	memset(&qctrl, 0, sizeof(qctrl));
-	qctrl.id = V4L2_CTRL_FLAG_NEXT_CTRL;
-	while (::ioctl(fd, VIDIOC_QUERYCTRL, &qctrl) == 0) {
-		if ((qctrl.flags & V4L2_CTRL_FLAG_DISABLED) == 0) {
-			ctrlMap[qctrl.id] = qctrl;
-			if (qctrl.type != V4L2_CTRL_TYPE_CTRL_CLASS)
-				classMap[V4L2_CTRL_ID2CLASS(qctrl.id)].push_back(qctrl.id);
-		}
-		qctrl.id |= V4L2_CTRL_FLAG_NEXT_CTRL;
-	}
-	if (qctrl.id == V4L2_CTRL_FLAG_NEXT_CTRL) {
-		strcpy((char *)qctrl.name, "User Controls");
-		qctrl.id = V4L2_CTRL_CLASS_USER | 1;
-		qctrl.type = V4L2_CTRL_TYPE_CTRL_CLASS;
-		ctrlMap[qctrl.id] = qctrl;
-		for (id = V4L2_CID_USER_BASE; id < V4L2_CID_LASTP1; id++) {
-			qctrl.id = id;
-			if (::ioctl(fd, VIDIOC_QUERYCTRL, &qctrl))
-				continue;
-			if (qctrl.flags & V4L2_CTRL_FLAG_DISABLED)
-				continue;
-			ctrlMap[qctrl.id] = qctrl;
-			classMap[V4L2_CTRL_CLASS_USER].push_back(qctrl.id);
-		}
-		for (qctrl.id = V4L2_CID_PRIVATE_BASE;
-				::ioctl(fd, VIDIOC_QUERYCTRL, &qctrl) == 0; qctrl.id++) {
-			if (qctrl.flags & V4L2_CTRL_FLAG_DISABLED)
-				continue;
-			ctrlMap[qctrl.id] = qctrl;
-			classMap[V4L2_CTRL_CLASS_USER].push_back(qctrl.id);
-		}
-	}
-
-	for (ClassMap::iterator iter = classMap.begin(); iter != classMap.end(); ++iter) {
-		ctrl_class = V4L2_CTRL_ID2CLASS(iter->second[0]);
-		id = ctrl_class | 1;
-		const struct v4l2_queryctrl &qctrl = ctrlMap[id];
-		QVBox *vbox = new QVBox(tabs);
-		QGrid *grid = new QGrid(4, vbox);
-		grid->setSpacing(3);
-		tabs->addTab(vbox, (char *)qctrl.name);
-		for (i = 0; i < iter->second.size(); i++) {
-			if (i & 1)
-				id = iter->second[(1+iter->second.size()) / 2 + i / 2];
-			else
-				id = iter->second[i / 2];
-			addCtrl(grid, ctrlMap[id]);
-		}
-		finishGrid(vbox, grid, ctrl_class, i & 1);
-	}
-}
-
-void ApplicationWindow::finishGrid(QWidget *vbox, QGrid *grid, unsigned ctrl_class, bool odd)
-{
-	if (odd) {
-		new QWidget(grid);
-		new QWidget(grid);
-	}
-	QWidget *stretch = new QWidget(grid);
-	stretch->setSizePolicy(QSizePolicy::Fixed, QSizePolicy::Ignored);
-
-	QFrame *frame = new QFrame(vbox);
-	frame->setFrameShape(QFrame::HLine);
-	frame->setFrameShadow(QFrame::Sunken);
-	frame->setMargin(3);
-
-	QHBox *hbox = new QHBox(vbox);
-	hbox->setSpacing(3);
-
-	QCheckBox *cbox = new QCheckBox("Update on change", hbox);
-	widgetMap[ctrl_class | CTRL_UPDATE_ON_CHANGE] = cbox;
-	connect(cbox, SIGNAL(clicked()), sigMapper, SLOT(map()));
-	sigMapper->setMapping(cbox, ctrl_class | CTRL_UPDATE_ON_CHANGE);
-
-	stretch = new QWidget(hbox);
-	stretch->setSizePolicy(QSizePolicy::Ignored, QSizePolicy::Fixed);
-
-	QPushButton *defBut = new QPushButton("Set Defaults", hbox);
-	widgetMap[ctrl_class | CTRL_DEFAULTS] = defBut;
-	connect(defBut, SIGNAL(clicked()), sigMapper, SLOT(map()));
-	sigMapper->setMapping(defBut, ctrl_class | CTRL_DEFAULTS);
-
-	QPushButton *refreshBut = new QPushButton("Refresh", hbox);
-	widgetMap[ctrl_class | CTRL_REFRESH] = refreshBut;
-	connect(refreshBut, SIGNAL(clicked()), sigMapper, SLOT(map()));
-	sigMapper->setMapping(refreshBut, ctrl_class | CTRL_REFRESH);
-
-	QPushButton *button = new QPushButton("Update", hbox);
-	widgetMap[ctrl_class | CTRL_UPDATE] = button;
-	connect(button, SIGNAL(clicked()), sigMapper, SLOT(map()));
-	sigMapper->setMapping(button, ctrl_class | CTRL_UPDATE);
-	connect(cbox, SIGNAL(toggled(bool)), button, SLOT(setDisabled(bool)));
-
-	cbox->setChecked(ctrl_class == V4L2_CTRL_CLASS_USER);
-
-	refresh(ctrl_class);
-}
-
-void ApplicationWindow::addCtrl(QGrid *grid, const struct v4l2_queryctrl &qctrl)
-{
-	QIntValidator *val;
-	QLineEdit *edit;
-	QString name((char *)qctrl.name);
-	QComboBox *combo;
-	struct v4l2_querymenu qmenu;
-
-	QLabel *label = new QLabel(name, grid);
-	label->setAlignment(Qt::AlignRight);
-
-	switch (qctrl.type) {
-	case V4L2_CTRL_TYPE_INTEGER:
-		if (qctrl.flags & V4L2_CTRL_FLAG_SLIDER) {
-			widgetMap[qctrl.id] =
-				new QSlider(qctrl.minimum, qctrl.maximum,
-					qctrl.step, qctrl.default_value,
-					Horizontal, grid);
-			connect(widgetMap[qctrl.id], SIGNAL(valueChanged(int)),
-				sigMapper, SLOT(map()));
-			break;
-		}
-
-		if (qctrl.maximum - qctrl.minimum <= 255) {
-			widgetMap[qctrl.id] =
-				new QSpinBox(qctrl.minimum, qctrl.maximum, 1, grid);
-			connect(widgetMap[qctrl.id], SIGNAL(valueChanged(int)),
-				sigMapper, SLOT(map()));
-			break;
-		}
-
-		val = new QIntValidator(qctrl.minimum, qctrl.maximum, grid);
-		edit = new QLineEdit(grid);
-		edit->setValidator(val);
-		widgetMap[qctrl.id] = edit;
-		connect(widgetMap[qctrl.id], SIGNAL(lostFocus()),
-				sigMapper, SLOT(map()));
-		connect(widgetMap[qctrl.id], SIGNAL(returnPressed()),
-				sigMapper, SLOT(map()));
-		break;
-
-	case V4L2_CTRL_TYPE_INTEGER64:
-		widgetMap[qctrl.id] = new QLineEdit(grid);
-		connect(widgetMap[qctrl.id], SIGNAL(lostFocus()),
-				sigMapper, SLOT(map()));
-		connect(widgetMap[qctrl.id], SIGNAL(returnPressed()),
-				sigMapper, SLOT(map()));
-		break;
-
-	case V4L2_CTRL_TYPE_BOOLEAN:
-		label->setText("");
-		widgetMap[qctrl.id] = new QCheckBox(name, grid);
-		connect(widgetMap[qctrl.id], SIGNAL(clicked()),
-				sigMapper, SLOT(map()));
-		break;
-
-	case V4L2_CTRL_TYPE_BUTTON:
-		label->setText("");
-		widgetMap[qctrl.id] = new QPushButton((char *)qctrl.name, grid);
-		connect(widgetMap[qctrl.id], SIGNAL(clicked()),
-				sigMapper, SLOT(map()));
-		break;
-
-	case V4L2_CTRL_TYPE_MENU:
-		combo = new QComboBox(grid);
-		widgetMap[qctrl.id] = combo;
-		for (int i = qctrl.minimum; i <= qctrl.maximum; i++) {
-			qmenu.id = qctrl.id;
-			qmenu.index = i;
-			if (::ioctl(fd, VIDIOC_QUERYMENU, &qmenu))
-				continue;
-			combo->insertItem((char *)qmenu.name);
-		}
-		connect(widgetMap[qctrl.id], SIGNAL(activated(int)),
-				sigMapper, SLOT(map()));
-		break;
-
-	default:
-		return;
-	}
-	sigMapper->setMapping(widgetMap[qctrl.id], qctrl.id);
-	if (qctrl.flags & (V4L2_CTRL_FLAG_READ_ONLY | V4L2_CTRL_FLAG_INACTIVE))
-		widgetMap[qctrl.id]->setDisabled(true);
-}
-
-void ApplicationWindow::ctrlAction(int id)
-{
-	unsigned ctrl_class = V4L2_CTRL_ID2CLASS(id);
-	if (ctrl_class == V4L2_CID_PRIVATE_BASE)
-		ctrl_class = V4L2_CTRL_CLASS_USER;
-	unsigned ctrl = id & 0xffff;
-	QCheckBox *cbox = static_cast<QCheckBox *>(widgetMap[ctrl_class | CTRL_UPDATE_ON_CHANGE]);
-	bool update = cbox->isChecked();
-	bool all = (ctrl == CTRL_UPDATE || (update && ctrl == CTRL_UPDATE_ON_CHANGE));
-
-	if (ctrl == CTRL_DEFAULTS) {
-		setDefaults(ctrl_class);
-		return;
-	}
-	if (ctrl == CTRL_REFRESH) {
-		refresh(ctrl_class);
-		return;
-	}
-	if (!update && !all && ctrlMap[id].type != V4L2_CTRL_TYPE_BUTTON)
-		return;
-	if (ctrl_class == V4L2_CTRL_CLASS_USER) {
-		if (!all) {
-			updateCtrl(id);
-			return;
-		}
-		for (unsigned i = 0; i < classMap[ctrl_class].size(); i++) {
-			updateCtrl(classMap[ctrl_class][i]);
-		}
-		return;
-	}
-	if (!all) {
-		updateCtrl(id);
-		return;
-	}
-	unsigned count = classMap[ctrl_class].size();
-	struct v4l2_ext_control *c = new v4l2_ext_control[count];
-	struct v4l2_ext_controls ctrls;
-	int idx = 0;
-
-	for (unsigned i = 0; i < count; i++) {
-		unsigned id = classMap[ctrl_class][i];
-
-		if (ctrlMap[id].flags & (V4L2_CTRL_FLAG_READ_ONLY | V4L2_CTRL_FLAG_INACTIVE))
-			continue;
-		c[idx].id = id;
-		if (ctrlMap[id].type == V4L2_CTRL_TYPE_INTEGER64)
-			c[idx].value64 = getVal64(id);
-		else
-			c[idx].value = getVal(id);
-		idx++;
-	}
-	memset(&ctrls, 0, sizeof(ctrls));
-	ctrls.count = idx;
-	ctrls.ctrl_class = ctrl_class;
-	ctrls.controls = c;
-	if (::ioctl(fd, VIDIOC_S_EXT_CTRLS, &ctrls)) {
-		int err = errno;
-
-		if (ctrls.error_idx >= ctrls.count) {
-			printf("error: %s\n", strerror(err));
-		}
-		else {
-			id = c[ctrls.error_idx].id;
-			printf("error %08x (%s): %s\n", id,
-					ctrlMap[id].name, strerror(err));
-		}
-	}
-	delete [] c;
-	refresh(ctrl_class);
-}
-
-long long ApplicationWindow::getVal64(unsigned id)
-{
-	const v4l2_queryctrl &qctrl = ctrlMap[id];
-	QWidget *w = widgetMap[qctrl.id];
-	long long v = 0;
-
-	switch (qctrl.type) {
-	case V4L2_CTRL_TYPE_INTEGER64:
-		v = static_cast<QLineEdit *>(w)->text().toLongLong();
-		break;
-	default:
-		break;
-	}
-	setWhat(w, id, v);
-	return v;
-}
-
-int ApplicationWindow::getVal(unsigned id)
-{
-	const v4l2_queryctrl &qctrl = ctrlMap[id];
-	QWidget *w = widgetMap[qctrl.id];
-	v4l2_querymenu qmenu;
-	int i, idx;
-	int v = 0;
-
-	switch (qctrl.type) {
-	case V4L2_CTRL_TYPE_INTEGER:
-		if (qctrl.flags & V4L2_CTRL_FLAG_SLIDER) {
-			v = static_cast<QSlider *>(w)->value();
-			break;
-		}
-
-		if (qctrl.maximum - qctrl.minimum <= 255) {
-			v = static_cast<QSpinBox *>(w)->value();
-			break;
-		}
-		v = static_cast<QLineEdit *>(w)->text().toInt();
-		break;
-
-	case V4L2_CTRL_TYPE_BOOLEAN:
-		v = static_cast<QCheckBox *>(w)->isChecked();
-		break;
-
-	case V4L2_CTRL_TYPE_MENU:
-		idx = static_cast<QComboBox *>(w)->currentItem();
-		for (i = qctrl.minimum; i <= qctrl.maximum; i++) {
-			qmenu.id = qctrl.id;
-			qmenu.index = i;
-			if (::ioctl(fd, VIDIOC_QUERYMENU, &qmenu))
-				continue;
-			if (idx-- == 0)
-				break;
-		}
-		v = i;
-		break;
-
-	default:
-		break;
-	}
-	setWhat(w, id, v);
-	return v;
-}
-
-void ApplicationWindow::updateCtrl(unsigned id)
-{
-	unsigned ctrl_class = V4L2_CTRL_ID2CLASS(id);
-	if (ctrl_class == V4L2_CID_PRIVATE_BASE)
-		ctrl_class = V4L2_CTRL_CLASS_USER;
-
-	if (ctrlMap[id].flags & (V4L2_CTRL_FLAG_READ_ONLY | V4L2_CTRL_FLAG_INACTIVE))
-		return;
-
-	if (ctrl_class == V4L2_CTRL_CLASS_USER) {
-		struct v4l2_control c;
-
-		c.id = id;
-		c.value = getVal(id);
-		if (::ioctl(fd, VIDIOC_S_CTRL, &c)) {
-			int err = errno;
-			char buf[200];
-
-			sprintf(buf, "Error %08x (%s): %s", id,
-				ctrlMap[id].name, strerror(err));
-			statusBar()->message(buf, 10000);
-		}
-		return;
-	}
-	struct v4l2_ext_control c;
-	struct v4l2_ext_controls ctrls;
-
-	memset(&c, 0, sizeof(c));
-	memset(&ctrls, 0, sizeof(ctrls));
-	c.id = id;
-	if (ctrlMap[id].type == V4L2_CTRL_TYPE_INTEGER64)
-		c.value64 = getVal64(id);
-	else
-		c.value = getVal(id);
-	ctrls.count = 1;
-	ctrls.ctrl_class = ctrl_class;
-	ctrls.controls = &c;
-	if (::ioctl(fd, VIDIOC_S_EXT_CTRLS, &ctrls)) {
-		int err = errno;
-		char buf[200];
-
-		sprintf(buf, "Error %08x (%s): %s", id,
-				ctrlMap[id].name, strerror(err));
-		statusBar()->message(buf, 10000);
-	}
-	else if (ctrlMap[id].flags & V4L2_CTRL_FLAG_UPDATE)
-		refresh(ctrl_class);
-	else {
-		if (ctrlMap[id].type == V4L2_CTRL_TYPE_INTEGER64)
-			setVal64(id, c.value64);
-		else
-			setVal(id, c.value);
-	}
-}
-
-void ApplicationWindow::refresh(unsigned ctrl_class)
-{
-	if (ctrl_class == V4L2_CTRL_CLASS_USER) {
-		for (unsigned i = 0; i < classMap[ctrl_class].size(); i++) {
-			unsigned id = classMap[ctrl_class][i];
-
-			v4l2_control c;
-
-			c.id = id;
-			if (::ioctl(fd, VIDIOC_G_CTRL, &c)) {
-				int err = errno;
-				char buf[200];
-
-				sprintf(buf, "Error %08x (%s): %s", id,
-						ctrlMap[id].name, strerror(err));
-				statusBar()->message(buf, 10000);
-			}
-			setVal(id, c.value);
-		}
-		return;
-	}
-	unsigned count = classMap[ctrl_class].size();
-	struct v4l2_ext_control *c = new v4l2_ext_control[count];
-	struct v4l2_ext_controls ctrls;
-
-	for (unsigned i = 0; i < count; i++) {
-		c[i].id = classMap[ctrl_class][i];
-	}
-	memset(&ctrls, 0, sizeof(ctrls));
-	ctrls.count = count;
-	ctrls.ctrl_class = ctrl_class;
-	ctrls.controls = c;
-	if (::ioctl(fd, VIDIOC_G_EXT_CTRLS, &ctrls)) {
-		int err = errno;
-
-		if (ctrls.error_idx >= ctrls.count) {
-			statusBar()->message(strerror(err), 10000);
-		}
-		else {
-			unsigned id = c[ctrls.error_idx].id;
-			char buf[200];
-
-			sprintf(buf, "Error %08x (%s): %s", id,
-					ctrlMap[id].name, strerror(err));
-			statusBar()->message(buf, 10000);
-		}
-	}
-	else {
-		for (unsigned i = 0; i < ctrls.count; i++) {
-			unsigned id = c[i].id;
-			if (ctrlMap[id].type == V4L2_CTRL_TYPE_INTEGER64)
-				setVal64(id, c[i].value64);
-			else
-				setVal(id, c[i].value);
-			::ioctl(fd, VIDIOC_QUERYCTRL, &ctrlMap[id]);
-			widgetMap[id]->setDisabled(ctrlMap[id].flags &
-				(V4L2_CTRL_FLAG_READ_ONLY | V4L2_CTRL_FLAG_INACTIVE));
-		}
-	}
-	delete [] c;
-}
-
-void ApplicationWindow::setWhat(QWidget *w, unsigned id, long long v)
-{
-	const v4l2_queryctrl &qctrl = ctrlMap[id];
-	QString what;
-	QString flags = getCtrlFlags(qctrl.flags);
-
-	switch (qctrl.type) {
-	case V4L2_CTRL_TYPE_INTEGER:
-		QWhatsThis::add(w, what.sprintf("Integer type control\n"
-					"Minimum: %d\n"
-					"Maximum: %d\n"
-					"Current: %d\n"
-					"Default: %d\n",
-			qctrl.minimum, qctrl.maximum, (int)v, qctrl.default_value) + flags);
-		break;
-
-	case V4L2_CTRL_TYPE_INTEGER64:
-		QWhatsThis::add(w, what.sprintf("64-bit Integer type control\n"
-					"Current: %lld\n", v) + flags);
-		break;
-
-	case V4L2_CTRL_TYPE_BUTTON:
-		QWhatsThis::add(w, what.sprintf("Button type control\n") + flags);
-		break;
-
-	case V4L2_CTRL_TYPE_BOOLEAN:
-		QWhatsThis::add(w, what.sprintf("Boolean type control\n"
-					"Current: %d\n"
-					"Default: %d\n",
-			(int)v, qctrl.default_value) + flags);
-		break;
-
-	case V4L2_CTRL_TYPE_MENU:
-		QWhatsThis::add(w, what.sprintf("Menu type control\n"
-					"Minimum: %d\n"
-					"Maximum: %d\n"
-					"Current: %d\n"
-					"Default: %d\n",
-			qctrl.minimum, qctrl.maximum, (int)v, qctrl.default_value) + flags);
-		break;
-	default:
-		break;
-	}
-}
-
-void ApplicationWindow::setVal(unsigned id, int v)
-{
-	const v4l2_queryctrl &qctrl = ctrlMap[id];
-	v4l2_querymenu qmenu;
-	QWidget *w = widgetMap[qctrl.id];
-	int i, idx;
-
-	switch (qctrl.type) {
-	case V4L2_CTRL_TYPE_INTEGER:
-		if (qctrl.flags & V4L2_CTRL_FLAG_SLIDER)
-			static_cast<QSlider *>(w)->setValue(v);
-		else if (qctrl.maximum - qctrl.minimum <= 255)
-			static_cast<QSpinBox *>(w)->setValue(v);
-		else
-			static_cast<QLineEdit *>(w)->setText(QString::number(v));
-		break;
-
-	case V4L2_CTRL_TYPE_BOOLEAN:
-		static_cast<QCheckBox *>(w)->setChecked(v);
-		break;
-
-	case V4L2_CTRL_TYPE_MENU:
-		idx = 0;
-		for (i = qctrl.minimum; i <= v; i++) {
-			qmenu.id = id;
-			qmenu.index = i;
-			if (::ioctl(fd, VIDIOC_QUERYMENU, &qmenu))
-				continue;
-			idx++;
-		}
-		static_cast<QComboBox *>(w)->setCurrentItem(idx - 1);
-		break;
-	default:
-		break;
-	}
-	setWhat(w, id, v);
-}
-
-void ApplicationWindow::setVal64(unsigned id, long long v)
-{
-	const v4l2_queryctrl &qctrl = ctrlMap[id];
-	QWidget *w = widgetMap[qctrl.id];
-
-	switch (qctrl.type) {
-	case V4L2_CTRL_TYPE_INTEGER64:
-		static_cast<QLineEdit *>(w)->setText(QString::number(v));
-		break;
-	default:
-		break;
-	}
-	setWhat(w, id, v);
-}
-
-void ApplicationWindow::setDefaults(unsigned ctrl_class)
-{
-	for (unsigned i = 0; i < classMap[ctrl_class].size(); i++) {
-		unsigned id = classMap[ctrl_class][i];
-
-		if (ctrlMap[id].type != V4L2_CTRL_TYPE_INTEGER64 &&
-		    ctrlMap[id].type != V4L2_CTRL_TYPE_BUTTON)
-			setVal(id, ctrlMap[id].default_value);
-	}
-	ctrlAction(ctrl_class | CTRL_UPDATE);
-}
-
-QString ApplicationWindow::getCtrlFlags(unsigned flags)
-{
-	QString s;
-
-	if (flags & V4L2_CTRL_FLAG_GRABBED)
-		s += "grabbed ";
-	if (flags & V4L2_CTRL_FLAG_READ_ONLY)
-		s += "readonly ";
-	if (flags & V4L2_CTRL_FLAG_UPDATE)
-		s += "update ";
-	if (flags & V4L2_CTRL_FLAG_INACTIVE)
-		s += "inactive ";
-	if (flags & V4L2_CTRL_FLAG_SLIDER)
-		s += "slider ";
-	if (s.length()) s = QString("Flags: ") + s;
-	return s;
-}
-
-void ApplicationWindow::choose()
-{
-    QString fn = QFileDialog::getOpenFileName( "/dev/v4l", QString::null,
-					       this);
-    if ( !fn.isEmpty() ) {
-	    setDevice(fn);
-    }
-    else
-	statusBar()->message( "Loading aborted", 2000 );
-}
-
-
-void ApplicationWindow::closeEvent( QCloseEvent* ce )
-{
-	ce->accept();
-}
-
-void ApplicationWindow::inputChanged(int input)
-{
-	doIoctl("Set Input", VIDIOC_S_INPUT, &input);
-	struct v4l2_audio vaudio;
-	memset(&vaudio, 0, sizeof(vaudio));
-	if (audioInput && ioctl(fd, VIDIOC_G_AUDIO, &vaudio) >= 0) {
-		audioInput->setCurrentItem(vaudio.index);
-		updateAudioInput();
-	}
-	updateVideoInput();
-}
-
-void ApplicationWindow::outputChanged(int output)
-{
-	doIoctl("Set Output", VIDIOC_S_OUTPUT, &output);
-	updateVideoOutput();
-}
-
-void ApplicationWindow::inputAudioChanged(int input)
-{
-	struct v4l2_audio vaudio;
-	memset(&vaudio, 0, sizeof(vaudio));
-	vaudio.index = input;
-	doIoctl("Set Audio Input", VIDIOC_S_AUDIO, &vaudio);
-	updateAudioInput();
-}
-
-void ApplicationWindow::outputAudioChanged(int output)
-{
-	struct v4l2_audioout vaudioout;
-	memset(&vaudioout, 0, sizeof(vaudioout));
-	vaudioout.index = output;
-	doIoctl("Set Audio Output", VIDIOC_S_AUDOUT, &vaudioout);
-	updateAudioOutput();
-}
-
-void ApplicationWindow::standardChanged(int std)
-{
-	struct v4l2_standard vs;
-	memset(&vs, 0, sizeof(vs));
-	vs.index = std;
-	ioctl(fd, VIDIOC_ENUMSTD, &vs);
-	doIoctl("Set TV Standard", VIDIOC_S_STD, &vs.id);
-	updateStandard();
-}
-
-void ApplicationWindow::freqTableChanged(int)
-{
-	updateFreqChannel();
-	freqChannelChanged(0);
-}
-
-void ApplicationWindow::freqChannelChanged(int idx)
-{
-	freq->setValue((int)(chanlists[freqTable->currentItem()].list[idx].freq / 62.5));
-}
-
-void ApplicationWindow::freqChanged(int val)
-{
-	struct v4l2_frequency f;
-
-	memset(&f, 0, sizeof(f));
-	f.type = V4L2_TUNER_ANALOG_TV;
-	f.frequency = val;
-	doIoctl("Set frequency", VIDIOC_S_FREQUENCY, &f);
-}
-
-void ApplicationWindow::updateVideoInput()
-{
-	int input;
-
-	ioctl(fd, VIDIOC_G_INPUT, &input);
-	videoInput->setCurrentItem(input);
-}
-
-void ApplicationWindow::updateVideoOutput()
-{
-	int output;
-
-	ioctl(fd, VIDIOC_G_OUTPUT, &output);
-	videoOutput->setCurrentItem(output);
-}
-
-void ApplicationWindow::updateAudioInput()
-{
-	struct v4l2_audio audio;
-	QString what;
-
-	memset(&audio, 0, sizeof(audio));
-	ioctl(fd, VIDIOC_G_AUDIO, &audio);
-	audioInput->setCurrentItem(audio.index);
-	if (audio.capability & V4L2_AUDCAP_STEREO)
-		what = "stereo input";
-	else
-		what = "mono input";
-	if (audio.capability & V4L2_AUDCAP_AVL)
-		what += ", has AVL";
-	if (audio.mode & V4L2_AUDMODE_AVL)
-		what += ", AVL is on";
-	QWhatsThis::add(audioInput, what);
-}
-
-void ApplicationWindow::updateAudioOutput()
-{
-	struct v4l2_audioout audio;
-
-	memset(&audio, 0, sizeof(audio));
-	ioctl(fd, VIDIOC_G_AUDOUT, &audio);
-	audioOutput->setCurrentItem(audio.index);
-}
-
-void ApplicationWindow::updateStandard()
-{
-	v4l2_std_id std;
-	struct v4l2_standard vs;
-	QString what;
-	ioctl(fd, VIDIOC_G_STD, &std);
-	memset(&vs, 0, sizeof(vs));
-	while (ioctl(fd, VIDIOC_ENUMSTD, &vs) != -1) {
-		if (vs.id & std) {
-			tvStandard->setCurrentItem(vs.index);
-			what.sprintf("TV Standard (0x%llX)\n"
-				"Frame period: %f (%d/%d)\n"
-				"Frame lines: %d\n", std,
-				(double)vs.frameperiod.numerator / vs.frameperiod.denominator,
-				vs.frameperiod.numerator, vs.frameperiod.denominator,
-				vs.framelines);
-			QWhatsThis::add(tvStandard, what);
-			return;
-		}
-		vs.index++;
-	}
-}
-
-void ApplicationWindow::updateFreq()
-{
-	struct v4l2_frequency f;
-
-	memset(&f, 0, sizeof(f));
-	ioctl(fd, VIDIOC_G_FREQUENCY, &f);
-	freq->setValue(f.frequency);
-}
-
-void ApplicationWindow::updateFreqChannel()
-{
-	freqChannel->clear();
-	int tbl = freqTable->currentItem();
-	struct CHANLIST *list = chanlists[tbl].list;
-	for (int i = 0; i < chanlists[tbl].count; i++)
-		freqChannel->insertItem(list[i].name);
-}
-
-bool ApplicationWindow::doIoctl(QString descr, unsigned cmd, void *arg)
-{
-	statusBar()->clear();
-	int err = ioctl(fd, cmd, arg);
-
-	if (err == -1) {
-		QString s = strerror(errno);
-		statusBar()->message(descr + ": " + s, 10000);
-	}
-	return err != -1;
-}
-
-void ApplicationWindow::about()
-{
-    QMessageBox::about( this, "V4L2 Control Panel",
-			"This program allows easy experimenting with video4linux devices.");
-}
-
-
-int main(int argc, char **argv)
-{
-    QApplication a(argc, argv);
-    ApplicationWindow *mw = new ApplicationWindow();
-    mw->setCaption( "V4L2 Control Panel" );
-    mw->setDevice("/dev/video0");
-    mw->show();
-    a.connect( &a, SIGNAL(lastWindowClosed()), &a, SLOT(quit()) );
-    return a.exec();
-}
diff --git a/test/qv4l2/qv4l2.h b/test/qv4l2/qv4l2.h
deleted file mode 100644
index 1145af417..000000000
--- a/test/qv4l2/qv4l2.h
+++ /dev/null
@@ -1,110 +0,0 @@
-/****************************************************************************
-** $Id: qt/application.h   3.3.6   edited Aug 31 2005 $
-**
-** Copyright (C) 1992-2005 Trolltech AS.  All rights reserved.
-**
-** This file is part of an example program for Qt.  This example
-** program may be used, distributed and modified without limitation.
-**
-*****************************************************************************/
-
-#ifndef APPLICATION_H
-#define APPLICATION_H
-
-#include <qmainwindow.h>
-#include <qtabwidget.h>
-#include <qsignalmapper.h>
-#include <qgrid.h>
-#include <map>
-#include <vector>
-
-#define __user
-#include <linux/videodev2.h>
-
-class QComboBox;
-class QSpinBox;
-
-typedef std::vector<unsigned> ClassIDVec;
-typedef std::map<unsigned, ClassIDVec> ClassMap;
-typedef std::map<unsigned, struct v4l2_queryctrl> CtrlMap;
-typedef std::map<unsigned, QWidget *> WidgetMap;
-
-enum {
-	CTRL_UPDATE_ON_CHANGE = 0x10,
-	CTRL_DEFAULTS,
-	CTRL_REFRESH,
-	CTRL_UPDATE
-};
-
-class ApplicationWindow: public QMainWindow
-{
-    Q_OBJECT
-
-public:
-    ApplicationWindow();
-    ~ApplicationWindow();
-
-    void setDevice(const QString &device);
-
-protected:
-    void closeEvent( QCloseEvent* );
-
-private slots:
-    void choose();
-    void ctrlAction(int);
-    void inputChanged(int);
-    void outputChanged(int);
-    void inputAudioChanged(int);
-    void outputAudioChanged(int);
-    void standardChanged(int);
-    void freqTableChanged(int);
-    void freqChannelChanged(int);
-    void freqChanged(int);
-
-    void about();
-
-private:
-    void addTabs();
-    void addGeneralTab();
-    void finishGrid(QWidget *vbox, QGrid *grid, unsigned ctrl_class, bool odd);
-    void addCtrl(QGrid *grid, const struct v4l2_queryctrl &qctrl);
-    void updateCtrl(unsigned id);
-    void refresh(unsigned ctrl_class);
-    void setDefaults(unsigned ctrl_class);
-    int getVal(unsigned id);
-    long long getVal64(unsigned id);
-    void setVal(unsigned id, int v);
-    void setVal64(unsigned id, long long v);
-    QString getCtrlFlags(unsigned flags);
-    void setWhat(QWidget *w, unsigned id, long long v);
-    bool doIoctl(QString descr, unsigned cmd, void *arg);
-    void updateVideoInput();
-    void updateVideoOutput();
-    void updateAudioInput();
-    void updateAudioOutput();
-    void updateStandard();
-    void updateFreq();
-    void updateFreqChannel();
-
-    QString filename;
-    QSignalMapper *sigMapper;
-    QTabWidget *tabs;
-    int fd;
-    CtrlMap ctrlMap;
-    WidgetMap widgetMap;
-    ClassMap classMap;
-    struct v4l2_tuner tuner;
-
-    // General tab
-    QComboBox *videoInput;
-    QComboBox *videoOutput;
-    QComboBox *audioInput;
-    QComboBox *audioOutput;
-    QComboBox *tvStandard;
-    QSpinBox  *freq;
-    QComboBox *freqTable;
-    QComboBox *freqChannel;
-};
-
-
-#endif
diff --git a/test/qv4l2/qv4l2.pro b/test/qv4l2/qv4l2.pro
deleted file mode 100644
index cfa608ca2..000000000
--- a/test/qv4l2/qv4l2.pro
+++ /dev/null
@@ -1,10 +0,0 @@
-######################################################################
-# Automatically generated by qmake (1.07a) Sat Jun 17 12:35:16 2006
-######################################################################
-
-TEMPLATE = app
-INCLUDEPATH += . ../../linux/include
-
-# Input
-HEADERS += qv4l2.h
-SOURCES += qv4l2.cpp frequencies.c