| /** |
| * 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); |
| } |
