mirror of
https://gitlab.freedesktop.org/gstreamer/gstreamer.git
synced 2024-11-27 20:21:24 +00:00
1198 lines
29 KiB
C
1198 lines
29 KiB
C
/**
|
|
* Copyright (c) 2002 Billy Biggs <vektor@dumbterm.net>.
|
|
* Copyright (c) 2002 Doug Bell <drbell@users.sourceforge.net>
|
|
*
|
|
* CC code from Nathan Laredo's ccdecode, used under the GPL.
|
|
* Lots of 'hey what does this mean?' code from
|
|
* Billy Biggs and Doug Bell, like all the crap with
|
|
* XDS and stuff. Some help from Zapping's vbi library by
|
|
* Michael H. Schimek and others, released under the GPL.
|
|
*
|
|
* Modified and adapted to GStreamer by
|
|
* David I. Lehn <dlehn@users.sourceforge.net>
|
|
*
|
|
* 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., 675 Mass Ave, Cambridge, MA 02139, USA.
|
|
*/
|
|
|
|
#ifdef HAVE_CONFIG_H
|
|
#include "config.h"
|
|
#endif
|
|
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <sys/types.h>
|
|
#include <sys/stat.h>
|
|
#include <string.h>
|
|
#include <fcntl.h>
|
|
#include <ctype.h>
|
|
#include <unistd.h>
|
|
#include <errno.h>
|
|
#include "vbidata.h"
|
|
#include "vbiscreen.h"
|
|
/*#include "tvtimeosd.h"*/
|
|
|
|
#define DO_LINE 11
|
|
static int pll = 0;
|
|
|
|
struct vbidata_s
|
|
{
|
|
int fd;
|
|
vbiscreen_t *vs;
|
|
/*tvtime_osd_t *osd; */
|
|
char buf[65536];
|
|
int wanttop;
|
|
int wanttext;
|
|
|
|
unsigned int colour;
|
|
int row, ital;
|
|
int indent, ul;
|
|
int chan;
|
|
|
|
unsigned int current_colour;
|
|
int current_row, current_ital;
|
|
int current_indent, current_ul;
|
|
int current_chan;
|
|
int current_istext;
|
|
|
|
int initialised;
|
|
int enabled;
|
|
int lastcode;
|
|
int lastcount;
|
|
int verbose;
|
|
|
|
/* XDS data */
|
|
char xds_packet[2048];
|
|
int xds_cursor;
|
|
|
|
char *program_name;
|
|
char *network_name;
|
|
char *call_letters;
|
|
const char *rating;
|
|
const char *program_type;
|
|
int start_day;
|
|
int start_month;
|
|
int start_min;
|
|
int start_hour;
|
|
int length_hour;
|
|
int length_min;
|
|
int length_elapsed_hour;
|
|
int length_elapsed_min;
|
|
int length_elapsed_sec;
|
|
char *program_desc[8];
|
|
};
|
|
|
|
|
|
/* this is NOT exactly right */
|
|
//static char *ccode = " !\"#$%&'()\0341+,-./0123456789:;<=>?@"
|
|
static char *ccode = " !\"#$%&'()a+,-./0123456789:;<=>?@"
|
|
"ABCDEFGHIJKLMNOPQRSTUVWXYZ"
|
|
// "abcdefghijklmnopqrstuvwxyz"
|
|
// "[\0351]\0355\0363\0372abcdefghijklmnopqr"
|
|
"[e]iouabcdefghijklmnopqr"
|
|
// "stuvwxyz\0347\0367\0245\0244\0240";
|
|
"stuvwxyzcoNn ";
|
|
static char *wccode = "\0256\0260\0275\0277T\0242\0243#\0340 "
|
|
"\0350\0354\0362\0371";
|
|
|
|
static char *extcode1 = "\0301\0311\0323\0332\0334\0374"
|
|
"`\0241*'-\0251S*\"\"\0300\0302"
|
|
"\0307\0310\0312\0313\0353\0316\0317\0357" "\0324\0331\0371\0333\0253\0273";
|
|
|
|
static char *extcode2 = "\0303\0343\0315\0314\0354\0322\0362\0325"
|
|
"{}\\^_|~\0304\0344\0326\0366\0337\0245\0244|" "\0305\0345\0330\0370++++";
|
|
|
|
int
|
|
parityok (int n)
|
|
{ /* check parity for 2 bytes packed in n */
|
|
int j, k;
|
|
|
|
for (k = 0, j = 0; j < 7; j++)
|
|
if (n & (1 << j))
|
|
k++;
|
|
if ((k & 1) && (n & 0x80))
|
|
return 0;
|
|
for (k = 0, j = 8; j < 15; j++)
|
|
if (n & (1 << j))
|
|
k++;
|
|
if ((k & 1) && (n & 0x8000))
|
|
return 0;
|
|
return 1;
|
|
}
|
|
|
|
int
|
|
decodebit (unsigned char *data, int threshold)
|
|
{
|
|
return ((data[0] + data[1] + data[2] + data[3] + data[4] + data[5] +
|
|
data[6] + data[7] + data[8] + data[9] + data[10] + data[11] +
|
|
data[12] + data[13] + data[14] + data[15] + data[16] + data[17] +
|
|
data[18] + data[19] + data[20] + data[21] + data[22] + data[23] +
|
|
data[24] + data[25] + data[26] + data[27] + data[28] + data[29] +
|
|
data[30] + data[31]) >> 5 > threshold);
|
|
}
|
|
|
|
|
|
int
|
|
ccdecode (unsigned char *vbiline)
|
|
{
|
|
int max = 0, maxval = 0, minval = 255, i = 0, clk = 0, tmp = 0;
|
|
int sample, packedbits = 0;
|
|
|
|
for (i = 0; i < 250; i++) {
|
|
sample = vbiline[i];
|
|
if (sample - maxval > 10)
|
|
(maxval = sample, max = i);
|
|
if (sample < minval)
|
|
minval = sample;
|
|
if (maxval - sample > 40)
|
|
break;
|
|
}
|
|
sample = ((maxval + minval) >> 1);
|
|
pll = max;
|
|
|
|
/* found clock lead-in, double-check start */
|
|
#ifndef PAL_DECODE
|
|
i = max + 478;
|
|
#else
|
|
i = max + 538;
|
|
#endif
|
|
if (!decodebit (&vbiline[i], sample))
|
|
return 0;
|
|
#ifndef PAL_DECODE
|
|
tmp = i + 57; /* tmp = data bit zero */
|
|
#else
|
|
tmp = i + 71;
|
|
#endif
|
|
for (i = 0; i < 16; i++) {
|
|
#ifndef PAL_DECODE
|
|
clk = tmp + i * 57;
|
|
#else
|
|
clk = tmp + i * 71;
|
|
#endif
|
|
if (decodebit (&vbiline[clk], sample)) {
|
|
packedbits |= 1 << i;
|
|
}
|
|
}
|
|
if (parityok (packedbits))
|
|
return packedbits;
|
|
return 0;
|
|
} /* ccdecode */
|
|
|
|
const char *movies[] = { "N/A", "G", "PG", "PG-13", "R",
|
|
"NC-17", "X", "Not Rated"
|
|
};
|
|
const char *usa_tv[] = { "Not Rated", "TV-Y", "TV-Y7", "TV-G",
|
|
"TV-PG", "TV-14", "TV-MA", "Not Rated"
|
|
};
|
|
const char *cane_tv[] = { "Exempt", "C", "C8+", "G", "PG",
|
|
"14+", "18+", "Reserved"
|
|
};
|
|
const char *canf_tv[] = { "Exempt", "G", "8 ans +", "13 ans +",
|
|
"16 ans +", "18 ans +", "Reserved",
|
|
"Reserved"
|
|
};
|
|
|
|
const char *months[] = { 0, "Jan", "Feb", "Mar", "Apr", "May",
|
|
"Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"
|
|
};
|
|
|
|
static const char *eia608_program_type[96] = {
|
|
"education", "entertainment", "movie", "news", "religious", "sports",
|
|
"other", "action", "advertisement", "animated", "anthology",
|
|
"automobile", "awards", "baseball", "basketball", "bulletin", "business",
|
|
"classical", "college", "combat", "comedy", "commentary", "concert",
|
|
"consumer", "contemporary", "crime", "dance", "documentary", "drama",
|
|
"elementary", "erotica", "exercise", "fantasy", "farm", "fashion",
|
|
"fiction", "food", "football", "foreign", "fund raiser", "game/quiz",
|
|
"garden", "golf", "government", "health", "high school", "history",
|
|
"hobby", "hockey", "home", "horror", "information", "instruction",
|
|
"international", "interview", "language", "legal", "live", "local",
|
|
"math", "medical", "meeting", "military", "miniseries", "music", "mystery",
|
|
"national", "nature", "police", "politics", "premiere", "prerecorded",
|
|
"product", "professional", "public", "racing", "reading", "repair", "repeat",
|
|
"review", "romance", "science", "series", "service", "shopping",
|
|
"soap opera", "special", "suspense", "talk", "technical", "tennis",
|
|
"travel", "variety", "video", "weather", "western"
|
|
};
|
|
|
|
|
|
static void
|
|
parse_xds_packet (vbidata_t * vbi, char *packet, int length)
|
|
{
|
|
int sum = 0;
|
|
int i;
|
|
|
|
if (!vbi)
|
|
return;
|
|
|
|
/* Check the checksum for validity of the packet. */
|
|
for (i = 0; i < length - 1; i++) {
|
|
sum += packet[i];
|
|
}
|
|
if ((((~sum) & 0x7f) + 1) != packet[length - 1]) {
|
|
return;
|
|
}
|
|
|
|
/* Stick a null at the end, and cut off the last two characters. */
|
|
packet[length - 2] = '\0';
|
|
length -= 2;
|
|
|
|
if (packet[0] == 0x01 && packet[1] == 0x03) {
|
|
if (vbi->program_name && !strcmp (vbi->program_name, packet + 2)) {
|
|
return;
|
|
}
|
|
if (vbi->verbose)
|
|
fprintf (stderr, "Current program name: '%s'\n", packet + 2);
|
|
if (vbi->program_name)
|
|
free (vbi->program_name);
|
|
vbi->program_name = strdup (packet + 2);
|
|
/*tvtime_osd_set_show_name( vbi->osd, vbi->program_name ); */
|
|
} else if (packet[0] == 0x03 && packet[1] == 0x03) {
|
|
if (vbi->verbose)
|
|
fprintf (stderr, "Future program name: '%s'\n", packet + 2);
|
|
} else if (packet[0] == 0x05 && packet[1] == 0x01) {
|
|
if (vbi->network_name && !strcmp (vbi->network_name, packet + 2)) {
|
|
return;
|
|
}
|
|
|
|
if (vbi->verbose)
|
|
fprintf (stderr, "Network name: '%s'\n", packet + 2);
|
|
if (vbi->network_name)
|
|
free (vbi->network_name);
|
|
vbi->network_name = strdup (packet + 2);
|
|
/*tvtime_osd_set_network_name( vbi->osd, vbi->network_name ); */
|
|
} else if (packet[0] == 0x01 && packet[1] == 0x05) {
|
|
int movie_rating = packet[2] & 7;
|
|
int scheme = (packet[2] & 56) >> 3;
|
|
int tv_rating = packet[3] & 7;
|
|
int VSL = packet[3] & 56;
|
|
const char *str;
|
|
|
|
switch (VSL | scheme) {
|
|
case 3: /* Canadian English TV */
|
|
str = cane_tv[tv_rating];
|
|
break;
|
|
case 7: /* Canadian French TV */
|
|
str = canf_tv[tv_rating];
|
|
break;
|
|
case 19: /* Reserved */
|
|
case 31:
|
|
str = "";
|
|
break;
|
|
default:
|
|
if (((VSL | scheme) & 3) == 1) {
|
|
/* USA TV */
|
|
str = usa_tv[tv_rating];
|
|
} else {
|
|
/* MPAA Movie Rating */
|
|
str = movies[movie_rating];
|
|
}
|
|
break;
|
|
}
|
|
|
|
if (vbi->rating && !strcmp (vbi->rating, str)) {
|
|
return;
|
|
}
|
|
|
|
if (vbi->verbose)
|
|
fprintf (stderr, "Show rating: %s", str);
|
|
if (((VSL | scheme) & 3) == 1 || ((VSL | scheme) & 3) == 0) {
|
|
/* show VSLD for the americans */
|
|
if ((VSL | scheme) & 32) {
|
|
if (vbi->verbose)
|
|
fprintf (stderr, " V");
|
|
}
|
|
if ((VSL | scheme) & 16) {
|
|
if (vbi->verbose)
|
|
fprintf (stderr, " S");
|
|
}
|
|
if ((VSL | scheme) & 8) {
|
|
if (vbi->verbose)
|
|
fprintf (stderr, " L");
|
|
}
|
|
if ((VSL | scheme) & 4) {
|
|
if (vbi->verbose)
|
|
fprintf (stderr, " D");
|
|
}
|
|
}
|
|
if (vbi->verbose)
|
|
fprintf (stderr, "\n");
|
|
vbi->rating = str;
|
|
/*tvtime_osd_set_show_rating( vbi->osd, vbi->rating ); */
|
|
} else if (packet[0] == 0x05 && packet[1] == 0x02) {
|
|
if (vbi->call_letters && !strcmp (vbi->call_letters, packet + 2)) {
|
|
return;
|
|
}
|
|
|
|
if (vbi->verbose)
|
|
fprintf (stderr, "Network call letters: '%s'\n", packet + 2);
|
|
if (vbi->call_letters)
|
|
free (vbi->call_letters);
|
|
vbi->call_letters = strdup (packet + 2);
|
|
/*tvtime_osd_set_network_call( vbi->osd, vbi->call_letters ); */
|
|
} else if (packet[0] == 0x01 && packet[1] == 0x01) {
|
|
int month = packet[5]; // & 15;
|
|
int day = packet[4]; // & 31;
|
|
int hour = packet[3]; // & 31;
|
|
int min = packet[2]; // & 63;
|
|
char str[33];
|
|
|
|
if (vbi->verbose)
|
|
fprintf (stderr, "Program Start: %02d %s, %02d:%02d\n",
|
|
day & 31, months[month & 15], hour & 31, min & 63);
|
|
// packet[ 3 ], packet[ 4 ], packet[ 5 ], packet[ 6 ] );
|
|
//packet[ 5 ] & 31, packet[ 6 ], packet[ 4 ] & 31, packet[ 3 ] & 63 );
|
|
vbi->start_month = month & 15;
|
|
vbi->start_day = day & 31;
|
|
vbi->start_hour = hour & 31;
|
|
vbi->start_min = hour & 63;
|
|
snprintf (str, 32, "%02d %s, %02d:%02d",
|
|
day & 31, months[month & 15], hour & 31, min & 63);
|
|
/*tvtime_osd_set_show_start( vbi->osd, str ); */
|
|
} else if (packet[0] == 0x01 && packet[1] == 0x04) {
|
|
if (vbi->verbose)
|
|
fprintf (stderr, "Program type: ");
|
|
for (i = 0; i < length - 2; i++) {
|
|
int cur = packet[2 + i] - 0x20;
|
|
|
|
if (cur >= 0 && cur < 96) {
|
|
if (vbi->verbose)
|
|
fprintf (stderr, "%s%s", i ? ", " : "", eia608_program_type[cur]);
|
|
/* this will cause us to keep only the last type we check */
|
|
vbi->program_type = eia608_program_type[cur];
|
|
}
|
|
}
|
|
if (vbi->verbose)
|
|
fprintf (stderr, "\n");
|
|
} else if (packet[0] < 0x03 && packet[1] >= 0x10 && packet[1] <= 0x17) {
|
|
|
|
if (vbi->program_desc[packet[1] & 0xf] &&
|
|
!strcmp (vbi->program_desc[packet[1] & 0xf], packet + 2)) {
|
|
return;
|
|
}
|
|
|
|
if (vbi->verbose)
|
|
fprintf (stderr, "Program Description: Line %d", packet[1] & 0xf);
|
|
if (vbi->verbose)
|
|
fprintf (stderr, "%s\n", packet + 2);
|
|
if (vbi->program_desc[packet[1] & 0xf])
|
|
free (vbi->program_desc[packet[1] & 0xf]);
|
|
vbi->program_desc[packet[1] & 0xf] = strdup (packet + 2);
|
|
} else if (packet[0] == 0x01 && packet[1] == 0x02) {
|
|
char str[33];
|
|
|
|
str[0] = 0;
|
|
if (vbi->verbose)
|
|
fprintf (stderr, "Program Length: %02d:%02d",
|
|
packet[3] & 63, packet[2] & 63);
|
|
vbi->length_hour = packet[3] & 63;
|
|
vbi->length_min = packet[2] & 63;
|
|
snprintf (str, 32, "%02d:%02d", packet[3] & 63, packet[2] & 63);
|
|
if (length > 4) {
|
|
if (vbi->verbose)
|
|
fprintf (stderr, " Elapsed: %02d:%02d", packet[5] & 63, packet[4] & 63);
|
|
vbi->length_elapsed_hour = packet[5] & 63;
|
|
vbi->length_elapsed_min = packet[4] & 63;
|
|
snprintf (str, 32, "%02d:%02d/%02d:%02d",
|
|
packet[5] & 63, packet[4] & 63, packet[3] & 63, packet[2] & 63);
|
|
} else {
|
|
vbi->length_elapsed_hour = 0;
|
|
vbi->length_elapsed_min = 0;
|
|
}
|
|
|
|
if (length > 6) {
|
|
if (vbi->verbose)
|
|
fprintf (stderr, ".%02d", packet[6] & 63);
|
|
vbi->length_elapsed_hour = packet[6] & 63;
|
|
snprintf (str, 32, "%02d:%02d.%02d/%02d:%02d",
|
|
packet[5] & 63, packet[4] & 63, packet[6] & 63,
|
|
packet[3] & 63, packet[2] & 63);
|
|
} else {
|
|
vbi->length_elapsed_hour = 0;
|
|
}
|
|
/*tvtime_osd_set_show_length( vbi->osd, str ); */
|
|
if (vbi->verbose)
|
|
fprintf (stderr, "\n");
|
|
} else if (packet[0] == 0x05 && packet[1] == 0x04) {
|
|
if (vbi->verbose)
|
|
fprintf (stderr, "Transmission Signal Identifier (TSID): 0x%04x\n",
|
|
packet[2] << 24 | packet[3] << 16 | packet[4] << 8 | packet[5]);
|
|
} else {
|
|
/* unknown */
|
|
|
|
if (vbi->verbose)
|
|
fprintf (stderr, "Unknown XDS packet, class ");
|
|
switch (packet[0]) {
|
|
case 0x1:
|
|
if (vbi->verbose)
|
|
fprintf (stderr, "CURRENT start\n");
|
|
break;
|
|
case 0x2:
|
|
if (vbi->verbose)
|
|
fprintf (stderr, "CURRENT continue\n");
|
|
break;
|
|
|
|
case 0x3:
|
|
if (vbi->verbose)
|
|
fprintf (stderr, "FUTURE start\n");
|
|
break;
|
|
case 0x4:
|
|
if (vbi->verbose)
|
|
fprintf (stderr, "FUTURE continue\n");
|
|
break;
|
|
|
|
case 0x5:
|
|
if (vbi->verbose)
|
|
fprintf (stderr, "CHANNEL start\n");
|
|
break;
|
|
case 0x6:
|
|
if (vbi->verbose)
|
|
fprintf (stderr, "CHANNEL continue\n");
|
|
break;
|
|
|
|
case 0x7:
|
|
if (vbi->verbose)
|
|
fprintf (stderr, "MISC start\n");
|
|
break;
|
|
case 0x8:
|
|
if (vbi->verbose)
|
|
fprintf (stderr, "MISC continue\n");
|
|
break;
|
|
|
|
case 0x9:
|
|
if (vbi->verbose)
|
|
fprintf (stderr, "PUB start\n");
|
|
break;
|
|
case 0xa:
|
|
if (vbi->verbose)
|
|
fprintf (stderr, "PUB continue\n");
|
|
break;
|
|
|
|
case 0xb:
|
|
if (vbi->verbose)
|
|
fprintf (stderr, "RES start\n");
|
|
break;
|
|
case 0xc:
|
|
if (vbi->verbose)
|
|
fprintf (stderr, "RES continue\n");
|
|
break;
|
|
|
|
case 0xd:
|
|
if (vbi->verbose)
|
|
fprintf (stderr, "UNDEF start\n");
|
|
break;
|
|
case 0xe:
|
|
if (vbi->verbose)
|
|
fprintf (stderr, "UNDEF continue\n");
|
|
break;
|
|
}
|
|
for (i = 0; i < length; i++) {
|
|
if (vbi->verbose)
|
|
fprintf (stderr, "0x%02x ", packet[i]);
|
|
}
|
|
if (vbi->verbose)
|
|
fprintf (stderr, "\n");
|
|
}
|
|
}
|
|
|
|
static int
|
|
xds_decode (vbidata_t * vbi, int b1, int b2)
|
|
{
|
|
if (!vbi)
|
|
return 0;
|
|
if (vbi->xds_cursor > 2046) {
|
|
vbi->xds_cursor = 0;
|
|
}
|
|
|
|
if (!vbi->xds_cursor && b1 > 0xf) {
|
|
return 0;
|
|
}
|
|
|
|
|
|
if (b1 < 0xf && (b1 & 0x2)) {
|
|
/* ignore the continue and thus 'support' continuation of
|
|
a single packet */
|
|
return 1;
|
|
} else if (b1 < 0xf) {
|
|
/* kill old packet cause we got a new one */
|
|
vbi->xds_cursor = 0;
|
|
}
|
|
|
|
vbi->xds_packet[vbi->xds_cursor] = b1;
|
|
vbi->xds_packet[vbi->xds_cursor + 1] = b2;
|
|
vbi->xds_cursor += 2;
|
|
|
|
if (b1 == 0xf) {
|
|
parse_xds_packet (vbi, vbi->xds_packet, vbi->xds_cursor);
|
|
vbi->xds_cursor = 0;
|
|
}
|
|
|
|
return 1;
|
|
}
|
|
|
|
#define NOMODE 0
|
|
|
|
#define CC1 1
|
|
#define CC2 2
|
|
#define T1 3
|
|
#define T2 4
|
|
|
|
#define CC3 1
|
|
#define CC4 2
|
|
#define T3 3
|
|
#define T4 4
|
|
|
|
const unsigned int colours[] = {
|
|
0xFFFFFFFFU, /* white */
|
|
0xFF00FF00U, /* green */
|
|
0xFF0000FFU, /* blue */
|
|
0xFF00C7C7U, /* cyan */
|
|
0xFFFF0000U, /* red */
|
|
0xFFFFFF00U, /* yellow */
|
|
0xFFC700C7U /* magenta */
|
|
};
|
|
|
|
const int rows[] = {
|
|
11,
|
|
0, /* unused */
|
|
1,
|
|
2,
|
|
3,
|
|
4,
|
|
12,
|
|
13,
|
|
14,
|
|
15,
|
|
5,
|
|
6,
|
|
7,
|
|
8,
|
|
9,
|
|
10
|
|
};
|
|
|
|
#define ROLL_2 6
|
|
#define ROLL_3 7
|
|
#define ROLL_4 8
|
|
#define POP_UP 9
|
|
#define PAINT_ON 10
|
|
|
|
|
|
static int
|
|
Process16b (vbidata_t * vbi, int bottom, int w1)
|
|
{
|
|
int b1, b2;
|
|
|
|
b1 = w1 & 0x7f;
|
|
b2 = (w1 >> 8) & 0x7f;
|
|
|
|
if (!b1 && !b2) {
|
|
return 0;
|
|
}
|
|
|
|
if (vbi->enabled && b1 >= 0x10 && b1 <= 0x1F && b2 >= 0x20 && b2 <= 0x7F) {
|
|
int code;
|
|
|
|
if ((b2 & 64)) {
|
|
/* Preamble Code */
|
|
/* This sets up colors and indenting */
|
|
|
|
if (!bottom && vbi->lastcode == ((b1 << 8) | b2)) {
|
|
vbi->lastcount = (vbi->lastcount + 1) % 2;
|
|
return 1;
|
|
}
|
|
|
|
vbi->current_chan = (b1 & 8) >> 3;
|
|
if (!bottom == vbi->wanttop) {
|
|
if (vbi->chan != vbi->current_chan)
|
|
return 0;
|
|
} else
|
|
return 0;
|
|
|
|
vbi->current_ital = (b2 & 1);
|
|
if (!(b2 & 16)) {
|
|
vbi->current_colour = colours[(b2 & 30) >> 1];
|
|
vbi->current_indent = 0;
|
|
} else {
|
|
vbi->current_colour = 0xFFFFFFFFU; /* white */
|
|
vbi->current_indent = 4 * ((b2 & 14) >> 1);
|
|
}
|
|
vbi->current_row = rows[((b1 & 7) << 1) | ((b2 & 32) >> 5)];
|
|
vbi->current_ul = b2 & 1;
|
|
|
|
if (vbi->verbose)
|
|
fprintf (stderr, "field: %d chan %d, ital %d, ul %d, colour 0x%x, "
|
|
"indent %d, row %d\n", bottom, vbi->current_chan,
|
|
vbi->current_ital, vbi->current_ul, vbi->current_colour,
|
|
vbi->current_indent, vbi->current_row);
|
|
|
|
if (!bottom == vbi->wanttop &&
|
|
vbi->current_chan == vbi->chan &&
|
|
vbi->current_istext == vbi->wanttext) {
|
|
|
|
vbi->indent = vbi->current_indent;
|
|
vbi->ital = vbi->current_ital;
|
|
vbi->colour = vbi->current_colour;
|
|
vbi->row = vbi->current_row;
|
|
vbi->current_istext = 0;
|
|
|
|
vbiscreen_new_caption (vbi->vs, vbi->indent, vbi->ital,
|
|
vbi->colour, vbi->row);
|
|
|
|
}
|
|
|
|
vbi->lastcode = (b1 << 8) | b2;
|
|
vbi->lastcount = 0;
|
|
return 1;
|
|
}
|
|
|
|
if ((b1 & 8) == 1) {
|
|
/* Midrow code */
|
|
if (!vbi->initialised)
|
|
return 0;
|
|
|
|
if (!bottom && vbi->lastcode == ((b1 << 8) | b2)) {
|
|
vbi->lastcount = (vbi->lastcount + 1) % 2;
|
|
return 1;
|
|
}
|
|
|
|
if (vbi->verbose)
|
|
fprintf (stderr, "Midrow TODO: Add me.\n");
|
|
|
|
vbi->lastcode = (b1 << 8) | b2;
|
|
return 1;
|
|
}
|
|
|
|
if ((b1 & 2) && !(b2 & 64)) {
|
|
if (!vbi->initialised)
|
|
return 0;
|
|
|
|
if (!bottom && vbi->lastcode == ((b1 << 8) | b2)) {
|
|
vbi->lastcount = (vbi->lastcount + 1) % 2;
|
|
return 1;
|
|
}
|
|
|
|
if (vbi->verbose)
|
|
fprintf (stderr, "Tab Offset: %d columns\n", b2 & 3);
|
|
if (vbi->wanttext && vbi->current_istext &&
|
|
vbi->current_chan == vbi->chan && !bottom == vbi->wanttop) {
|
|
vbiscreen_tab (vbi->vs, b2 & 3);
|
|
}
|
|
vbi->lastcode = (b1 << 8) | b2;
|
|
return 1;
|
|
}
|
|
|
|
switch ((code = b2 & 15)) {
|
|
case 0: /* POP-UP */
|
|
case 5: /* ROLL UP 2 */
|
|
case 6: /* ROLL UP 3 */
|
|
case 7: /* ROLL UP 4 */
|
|
case 9: /* PAINT-ON */
|
|
case 10: /* TEXT */
|
|
case 11: /* TEXT */
|
|
vbi->initialised = 1;
|
|
if (!bottom && vbi->lastcode == ((b1 << 8) | b2)) {
|
|
/* This is the repeated Control Code */
|
|
vbi->lastcount = (vbi->lastcount + 1) % 2;
|
|
return 1;
|
|
}
|
|
switch (code) {
|
|
case 0: /* POP-UP */
|
|
if (!vbi->wanttext && vbi->current_chan == vbi->chan &&
|
|
!bottom == vbi->wanttop) {
|
|
if (vbi->verbose)
|
|
fprintf (stderr, "Pop-Up\n");
|
|
vbi->indent = vbi->current_indent;
|
|
vbi->ital = vbi->current_ital;
|
|
vbi->colour = vbi->current_colour;
|
|
vbi->row = vbi->current_row;
|
|
vbi->current_istext = 0;
|
|
vbiscreen_set_mode (vbi->vs, 1, POP_UP);
|
|
}
|
|
break;
|
|
case 5: /* ROLL UP 2 */
|
|
if (!vbi->wanttext && vbi->current_chan == vbi->chan &&
|
|
!bottom == vbi->wanttop) {
|
|
if (vbi->verbose)
|
|
fprintf (stderr, "Roll-Up 2 (RU2)\n");
|
|
vbi->indent = vbi->current_indent;
|
|
vbi->ital = vbi->current_ital;
|
|
vbi->colour = vbi->current_colour;
|
|
vbi->row = vbi->current_row;
|
|
vbi->current_istext = 0;
|
|
vbiscreen_set_mode (vbi->vs, 1, ROLL_2);
|
|
}
|
|
break;
|
|
case 6: /* ROLL UP 3 */
|
|
if (!vbi->wanttext && vbi->current_chan == vbi->chan &&
|
|
!bottom == vbi->wanttop) {
|
|
if (vbi->verbose)
|
|
fprintf (stderr, "Roll-Up 3 (RU3)\n");
|
|
vbi->indent = vbi->current_indent;
|
|
vbi->ital = vbi->current_ital;
|
|
vbi->colour = vbi->current_colour;
|
|
vbi->row = vbi->current_row;
|
|
vbi->current_istext = 0;
|
|
vbiscreen_set_mode (vbi->vs, 1, ROLL_3);
|
|
}
|
|
break;
|
|
case 7: /* ROLL UP 4 */
|
|
if (!vbi->wanttext && vbi->current_chan == vbi->chan &&
|
|
!bottom == vbi->wanttop) {
|
|
if (vbi->verbose)
|
|
fprintf (stderr, "Roll-Up 4 (RU4)\n");
|
|
vbi->indent = vbi->current_indent;
|
|
vbi->ital = vbi->current_ital;
|
|
vbi->colour = vbi->current_colour;
|
|
vbi->row = vbi->current_row;
|
|
vbi->current_istext = 0;
|
|
vbiscreen_set_mode (vbi->vs, 1, ROLL_4);
|
|
}
|
|
break;
|
|
case 9: /* PAINT-ON */
|
|
if (!vbi->wanttext && vbi->current_chan == vbi->chan &&
|
|
!bottom == vbi->wanttop) {
|
|
if (vbi->verbose)
|
|
fprintf (stderr, "Paint-On\n");
|
|
vbi->indent = vbi->current_indent;
|
|
vbi->ital = vbi->current_ital;
|
|
vbi->colour = vbi->current_colour;
|
|
vbi->row = vbi->current_row;
|
|
vbi->current_istext = 0;
|
|
vbiscreen_set_mode (vbi->vs, 1, PAINT_ON);
|
|
}
|
|
break;
|
|
case 10: /* TEXT */
|
|
if (vbi->wanttext && vbi->current_chan == vbi->chan &&
|
|
!bottom == vbi->wanttop) {
|
|
if (vbi->verbose)
|
|
fprintf (stderr, "Text Restart\n");
|
|
vbi->indent = vbi->current_indent;
|
|
vbi->ital = vbi->current_ital;
|
|
vbi->colour = vbi->current_colour;
|
|
vbi->row = vbi->current_row;
|
|
vbi->current_istext = 1;
|
|
vbiscreen_set_mode (vbi->vs, 0, 0);
|
|
}
|
|
break;
|
|
case 11: /* TEXT */
|
|
if (vbi->wanttext && vbi->current_chan == vbi->chan &&
|
|
!bottom == vbi->wanttop) {
|
|
if (vbi->verbose)
|
|
fprintf (stderr, "Resume Text Display\n");
|
|
vbi->indent = vbi->current_indent;
|
|
vbi->ital = vbi->current_ital;
|
|
vbi->colour = vbi->current_colour;
|
|
vbi->row = vbi->current_row;
|
|
vbi->current_istext = 1;
|
|
vbiscreen_set_mode (vbi->vs, 0, 0);
|
|
}
|
|
break;
|
|
default: /* impossible */
|
|
break;
|
|
}
|
|
break;
|
|
case 1:
|
|
if (!vbi->initialised)
|
|
return 0;
|
|
if (!bottom && vbi->lastcode == ((b1 << 8) | b2)) {
|
|
vbi->lastcount = (vbi->lastcount + 1) % 2;
|
|
}
|
|
if (!bottom == vbi->wanttop && vbi->current_chan == vbi->chan &&
|
|
vbi->current_istext == vbi->wanttext) {
|
|
if (vbi->verbose)
|
|
fprintf (stderr, "Backspace\n");
|
|
vbiscreen_backspace (vbi->vs);
|
|
}
|
|
break;
|
|
case 2:
|
|
case 3:
|
|
if (!vbi->initialised)
|
|
return 0;
|
|
fprintf (stderr, "Reserved\n");
|
|
break;
|
|
case 4:
|
|
if (!vbi->initialised)
|
|
return 0;
|
|
if (!bottom && vbi->lastcode == ((b1 << 8) | b2)) {
|
|
vbi->lastcount = (vbi->lastcount + 1) % 2;
|
|
}
|
|
if (!bottom == vbi->wanttop && vbi->current_chan == vbi->chan &&
|
|
vbi->current_istext == vbi->wanttext) {
|
|
if (vbi->verbose)
|
|
fprintf (stderr, "Delete to End of Row\n");
|
|
vbiscreen_delete_to_end (vbi->vs);
|
|
}
|
|
break;
|
|
case 8:
|
|
if (!vbi->initialised)
|
|
return 0;
|
|
if (vbi->verbose)
|
|
fprintf (stderr, "Flash On\n");
|
|
break;
|
|
case 12:
|
|
case 13:
|
|
case 14:
|
|
case 15:
|
|
if (!vbi->initialised)
|
|
return 0;
|
|
if (!bottom && vbi->lastcode == ((b1 << 8) | b2)) {
|
|
vbi->lastcount = (vbi->lastcount + 1) % 2;
|
|
return 1;
|
|
}
|
|
|
|
switch (code) {
|
|
case 12:
|
|
/* Show buffer 1, Fill buffer 2 */
|
|
if (!bottom == vbi->wanttop &&
|
|
vbi->current_chan == vbi->chan &&
|
|
vbi->current_istext == vbi->wanttext) {
|
|
if (vbi->verbose)
|
|
fprintf (stderr, "Erase Displayed Memory\n");
|
|
vbiscreen_erase_displayed (vbi->vs);
|
|
}
|
|
break;
|
|
case 13:
|
|
if (!bottom == vbi->wanttop &&
|
|
vbi->current_chan == vbi->chan &&
|
|
vbi->current_istext == vbi->wanttext) {
|
|
if (vbi->verbose)
|
|
fprintf (stderr, "Carriage Return\n");
|
|
vbiscreen_carriage_return (vbi->vs);
|
|
}
|
|
break;
|
|
case 14:
|
|
if (!bottom == vbi->wanttop &&
|
|
vbi->current_chan == vbi->chan &&
|
|
vbi->current_istext == vbi->wanttext) {
|
|
if (vbi->verbose)
|
|
fprintf (stderr, "Erase Non-Displayed\n");
|
|
vbiscreen_erase_non_displayed (vbi->vs);
|
|
}
|
|
break;
|
|
case 15:
|
|
/* Show buffer 2, Fill Buffer 1 */
|
|
if (!bottom == vbi->wanttop &&
|
|
vbi->current_chan == vbi->chan &&
|
|
vbi->current_istext == vbi->wanttext) {
|
|
if (vbi->verbose)
|
|
fprintf (stderr, "End Of Caption\n");
|
|
vbiscreen_end_of_caption (vbi->vs);
|
|
}
|
|
break;
|
|
default: /* impossible */
|
|
return 0;
|
|
break;
|
|
}
|
|
break;
|
|
default: /* Impossible */
|
|
return 0;
|
|
break;
|
|
}
|
|
|
|
if (vbi->lastcode != ((b1 << 8) | b2)) {
|
|
vbi->lastcount = 0;
|
|
}
|
|
|
|
vbi->lastcode = (b1 << 8) | b2;
|
|
return 1;
|
|
}
|
|
|
|
if (bottom && xds_decode (vbi, b1, b2)) {
|
|
return 1;
|
|
}
|
|
|
|
if (!vbi->enabled)
|
|
return 0;
|
|
|
|
vbi->lastcode = 0;
|
|
vbi->lastcount = 0;
|
|
|
|
if (!vbi->initialised)
|
|
return 0;
|
|
|
|
if (!bottom != vbi->wanttop || vbi->current_chan != vbi->chan ||
|
|
vbi->current_istext != vbi->wanttext) {
|
|
return 0;
|
|
}
|
|
|
|
if (b1 == 0x11 || b1 == 0x19 ||
|
|
b1 == 0x12 || b1 == 0x13 || b1 == 0x1A || b1 == 0x1B) {
|
|
switch (b1) {
|
|
case 0x1A:
|
|
case 0x12:
|
|
/* use extcode1 */
|
|
if (b1 > 31 && b2 > 31 && b1 <= 0x3F && b2 <= 0x3F)
|
|
if (vbi->verbose)
|
|
fprintf (stderr, "char %d (%c), char %d (%c)\n", b1,
|
|
extcode1[b1 - 32], b2, extcode1[b2 - 32]);
|
|
|
|
break;
|
|
case 0x13:
|
|
case 0x1B:
|
|
/* use extcode2 */
|
|
if (b1 > 31 && b2 > 31 && b1 <= 0x3F && b2 <= 0x3F)
|
|
if (vbi->verbose)
|
|
fprintf (stderr, "char %d (%c), char %d (%c)\n", b1,
|
|
extcode2[b1 - 32], b2, extcode2[b2 - 32]);
|
|
|
|
break;
|
|
case 0x11:
|
|
case 0x19:
|
|
/* use wcode */
|
|
if (b1 > 31 && b2 > 31 && b1 <= 0x3F && b2 <= 0x3F)
|
|
if (vbi->verbose)
|
|
fprintf (stderr, "char %d (%c), char %d (%c)\n", b1,
|
|
wccode[b1 - 32], b2, wccode[b2 - 32]);
|
|
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
} else if (b1) {
|
|
/* use ccode */
|
|
if (b1 < 32)
|
|
b1 = 32;
|
|
if (b2 < 32)
|
|
b2 = 32;
|
|
if (vbi->verbose)
|
|
fprintf (stderr, "vbidata: data: %c %c\n", ccode[b1 - 32],
|
|
ccode[b2 - 32]);
|
|
vbiscreen_print (vbi->vs, ccode[b1 - 32], ccode[b2 - 32]);
|
|
}
|
|
|
|
|
|
return 1;
|
|
} /* Process16b */
|
|
|
|
int
|
|
ProcessLine (vbidata_t * vbi, unsigned char *s, int bottom)
|
|
{
|
|
int w1;
|
|
|
|
/*char *outbuf = NULL; */
|
|
|
|
if (!vbi)
|
|
return 0;
|
|
|
|
w1 = ccdecode (s);
|
|
|
|
return Process16b (vbi, bottom, w1);
|
|
} /* ProcessLine */
|
|
|
|
|
|
|
|
vbidata_t *
|
|
vbidata_new_file (const char *filename, vbiscreen_t * vs,
|
|
/*tvtime_osd_t* osd, */ int verbose)
|
|
{
|
|
vbidata_t *vbi = (vbidata_t *) malloc (sizeof (vbidata_t));
|
|
|
|
if (!vbi) {
|
|
return 0;
|
|
}
|
|
|
|
vbi->fd = open (filename, O_RDONLY);
|
|
if (vbi->fd < 0) {
|
|
fprintf (stderr, "vbidata: Can't open %s: %s\n",
|
|
filename, strerror (errno));
|
|
free (vbi);
|
|
return 0;
|
|
}
|
|
|
|
vbi->vs = vs;
|
|
/*vbi->osd = osd; */
|
|
vbi->verbose = verbose;
|
|
|
|
vbidata_reset (vbi);
|
|
|
|
return vbi;
|
|
}
|
|
|
|
vbidata_t *
|
|
vbidata_new_line (vbiscreen_t * vs, int verbose)
|
|
{
|
|
vbidata_t *vbi = (vbidata_t *) malloc (sizeof (vbidata_t));
|
|
|
|
if (!vbi) {
|
|
return 0;
|
|
}
|
|
|
|
vbi->vs = vs;
|
|
/*vbi->osd = osd; */
|
|
vbi->verbose = verbose;
|
|
|
|
vbidata_reset (vbi);
|
|
|
|
return vbi;
|
|
}
|
|
|
|
void
|
|
vbidata_delete (vbidata_t * vbi)
|
|
{
|
|
if (!vbi)
|
|
return;
|
|
if (vbi->fd != 0) {
|
|
close (vbi->fd);
|
|
}
|
|
free (vbi);
|
|
}
|
|
|
|
void
|
|
vbidata_reset (vbidata_t * vbi)
|
|
{
|
|
if (!vbi)
|
|
return;
|
|
|
|
vbi->wanttop = 0;
|
|
vbi->wanttext = 0;
|
|
vbi->colour = 0xFFFFFFFFU;
|
|
vbi->row = 0;
|
|
|
|
vbi->ital = 0;
|
|
vbi->indent = 0;
|
|
vbi->ul = 0;
|
|
|
|
vbi->chan = 0;
|
|
|
|
vbi->initialised = 0;
|
|
vbi->enabled = 0;
|
|
|
|
memset (vbi->program_desc, 0, 8 * sizeof (char *));
|
|
vbi->program_name = NULL;
|
|
vbi->network_name = NULL;
|
|
vbi->call_letters = NULL;
|
|
vbi->rating = NULL;
|
|
vbi->program_type = NULL;
|
|
|
|
vbi->start_day = 0;
|
|
vbi->start_month = 0;
|
|
vbi->start_min = 0;
|
|
vbi->start_hour = 0;
|
|
vbi->length_hour = 0;
|
|
vbi->length_min = 0;
|
|
vbi->length_elapsed_hour = 0;
|
|
vbi->length_elapsed_min = 0;
|
|
vbi->length_elapsed_sec = 0;
|
|
|
|
/*
|
|
tvtime_osd_set_network_call( vbi->osd, "" );
|
|
tvtime_osd_set_network_name( vbi->osd, "" );
|
|
tvtime_osd_set_show_name( vbi->osd, "" );
|
|
tvtime_osd_set_show_rating( vbi->osd, "" );
|
|
tvtime_osd_set_show_start( vbi->osd, "" );
|
|
tvtime_osd_set_show_length( vbi->osd, "" );
|
|
*/
|
|
|
|
|
|
|
|
vbi->lastcode = 0;
|
|
vbi->lastcount = 0;
|
|
vbi->xds_packet[0] = 0;
|
|
vbi->xds_cursor = 0;
|
|
vbiscreen_reset (vbi->vs);
|
|
}
|
|
|
|
void
|
|
vbidata_set_verbose (vbidata_t * vbi, int verbose)
|
|
{
|
|
vbi->verbose = verbose;
|
|
}
|
|
|
|
void
|
|
vbidata_capture_mode (vbidata_t * vbi, int mode)
|
|
{
|
|
if (!vbi)
|
|
return;
|
|
switch (mode) {
|
|
case CAPTURE_OFF:
|
|
vbi->enabled = 0;
|
|
break;
|
|
case CAPTURE_CC1:
|
|
vbi->wanttop = 1;
|
|
vbi->wanttext = 0;
|
|
vbi->chan = 0;
|
|
vbi->enabled = 1;
|
|
break;
|
|
case CAPTURE_CC2:
|
|
vbi->wanttop = 1;
|
|
vbi->wanttext = 0;
|
|
vbi->chan = 1;
|
|
vbi->enabled = 1;
|
|
break;
|
|
case CAPTURE_CC3:
|
|
vbi->wanttop = 0;
|
|
vbi->wanttext = 0;
|
|
vbi->chan = 0;
|
|
vbi->enabled = 1;
|
|
break;
|
|
case CAPTURE_CC4:
|
|
vbi->wanttop = 0;
|
|
vbi->wanttext = 0;
|
|
vbi->chan = 1;
|
|
vbi->enabled = 1;
|
|
break;
|
|
case CAPTURE_T1:
|
|
vbi->wanttop = 1;
|
|
vbi->wanttext = 1;
|
|
vbi->chan = 0;
|
|
vbi->enabled = 1;
|
|
break;
|
|
case CAPTURE_T2:
|
|
vbi->wanttop = 1;
|
|
vbi->wanttext = 1;
|
|
vbi->chan = 1;
|
|
vbi->enabled = 1;
|
|
break;
|
|
case CAPTURE_T3:
|
|
vbi->wanttop = 0;
|
|
vbi->wanttext = 1;
|
|
vbi->chan = 0;
|
|
vbi->enabled = 1;
|
|
break;
|
|
case CAPTURE_T4:
|
|
vbi->wanttop = 0;
|
|
vbi->wanttext = 1;
|
|
vbi->chan = 1;
|
|
vbi->enabled = 1;
|
|
break;
|
|
default:
|
|
vbi->enabled = 0;
|
|
break;
|
|
}
|
|
}
|
|
|
|
void
|
|
vbidata_process_frame (vbidata_t * vbi, int printdebug)
|
|
{
|
|
if (read (vbi->fd, vbi->buf, 65536) < 65536) {
|
|
fprintf (stderr, "error, can't read vbi data.\n");
|
|
return;
|
|
}
|
|
|
|
ProcessLine (vbi, &vbi->buf[DO_LINE * 2048], 0);
|
|
ProcessLine (vbi, &vbi->buf[(16 + DO_LINE) * 2048], 1);
|
|
}
|
|
|
|
void
|
|
vbidata_process_line (vbidata_t * vbi, unsigned char *s, int bottom)
|
|
{
|
|
ProcessLine (vbi, s, bottom);
|
|
}
|
|
|
|
void
|
|
vbidata_process_16b (vbidata_t * vbi, int bottom, int w)
|
|
{
|
|
Process16b (vbi, bottom, w);
|
|
}
|