summaryrefslogtreecommitdiff
path: root/src/dtvcc.c (plain)
blob: 4a7d9f2b1064890899f335174c8c27b83fd10374
1/*
2 * atsc-cc -- ATSC Closed Caption decoder
3 *
4 * Copyright (C) 2008 Michael H. Schimek <mschimek@users.sf.net>
5 *
6 * Contains code from zvbi-ntsc-cc closed caption decoder written by
7 * <timecop@japan.co.jp>, Mike Baker <mbm@linux.com>,
8 * Mark K. Kim <dev@cbreak.org>.
9 *
10 * Thanks to Karol Zapolski for his support.
11 *
12 * This program is free software; you can redistribute it and/or modify
13 * it under the terms of the GNU General Public License as published by
14 * the Free Software Foundation; either version 2 of the License, or
15 * (at your option) any later version.
16 *
17 * This program is distributed in the hope that it will be useful,
18 * but WITHOUT ANY WARRANTY; without even the implied warranty of
19 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
20 * GNU General Public License for more details.
21 *
22 * You should have received a copy of the GNU General Public License
23 * along with this program; if not, write to the Free Software
24 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
25 * MA 02110-1301, USA.
26 */
27
28#ifdef HAVE_CONFIG_H
29# include "config.h"
30#endif
31
32#define _GNU_SOURCE 1
33
34#include "libzvbi.h"
35#include "dtvcc.h"
36#include "am_debug.h"
37
38#define elements(array) (sizeof(array) / sizeof(array[0]))
39
40#define LOG_TAG "ZVBI"
41#define LOGI(...) __android_log_print(ANDROID_LOG_INFO,LOG_TAG,__VA_ARGS__)
42#define LOGE(...) __android_log_print(ANDROID_LOG_ERROR,LOG_TAG,__VA_ARGS__)
43
44#if __GNUC__ < 3
45# define likely(expr) (expr)
46# define unlikely(expr) (expr)
47#else
48# define likely(expr) __builtin_expect(expr, 1)
49# define unlikely(expr) __builtin_expect(expr, 0)
50#endif
51
52#define N_ELEMENTS(array) (sizeof (array) / sizeof ((array)[0]))
53#define CLEAR(var) memset (&(var), 0, sizeof (var))
54/* FIXME __typeof__ is a GCC extension. */
55#undef SWAP
56#define SWAP(x, y) \
57do { \
58 __typeof__ (x) _x = x; \
59 x = y; \
60 y = _x; \
61} while (0)
62
63#undef MIN
64#define MIN(x, y) ({ \
65 __typeof__ (x) _x = (x); \
66 __typeof__ (y) _y = (y); \
67 (void)(&_x == &_y); /* warn if types do not match */ \
68 /* return */ (_x < _y) ? _x : _y; \
69})
70
71#undef MAX
72#define MAX(x, y) ({ \
73 __typeof__ (x) _x = (x); \
74 __typeof__ (y) _y = (y); \
75 (void)(&_x == &_y); /* warn if types do not match */ \
76 /* return */ (_x > _y) ? _x : _y; \
77})
78
79#undef PARENT
80#define PARENT(_ptr, _type, _member) ({ \
81 __typeof__ (&((_type *) 0)->_member) _p = (_ptr); \
82 (_p != 0) ? (_type *)(((char *) _p) - offsetof (_type, \
83 _member)) : (_type *) 0; \
84})
85
86#define VBI_RGBA(r, g, b) \
87 ((((r) & 0xFF) << 0) | (((g) & 0xFF) << 8) \
88 | (((b) & 0xFF) << 16) | (0xFF << 24))
89
90/* These should be defined in inttypes.h. */
91#ifndef PRId64
92# define PRId64 "lld"
93#endif
94#ifndef PRIu64
95# define PRIu64 "llu"
96#endif
97#ifndef PRIx64
98# define PRIx64 "llx"
99#endif
100
101extern void
102vbi_transp_colormap(vbi_decoder *vbi, vbi_rgba *d, vbi_rgba *s, int entries);
103extern void
104vbi_send_event(vbi_decoder *vbi, vbi_event *ev);
105static void
106dtvcc_get_visible_windows(struct dtvcc_service *ds, int *cnt, struct dtvcc_window **windows);
107
108/* EIA 608-B decoder. */
109
110static int
111printable (int c)
112{
113 if ((c & 0x7F) < 0x20)
114 return '.';
115 else
116 return c & 0x7F;
117}
118
119static void
120dump (FILE * fp,
121 const uint8_t * buf,
122 unsigned int n_bytes)
123 _vbi_unused;
124
125static void
126dump (FILE * fp,
127 const uint8_t * buf,
128 unsigned int n_bytes)
129{
130 const unsigned int width = 16;
131 unsigned int i;
132
133 for (i = 0; i < n_bytes; i += width) {
134 unsigned int end;
135 unsigned int j;
136
137 end = MIN (i + width, n_bytes);
138 for (j = i; j < end; ++j)
139 fprintf (fp, "%02x ", buf[j]);
140 for (; j < i + width; ++j)
141 fputs (" ", fp);
142 fputc (' ', fp);
143 for (j = i; j < end; ++j) {
144 int c = buf[j];
145 fputc (printable (c), fp);
146 }
147 fputc ('\n', fp);
148 }
149}
150
151#define log(verb, templ, args...) \
152 log_message (2, /* print_errno */ FALSE, templ , ##args)
153
154#define log_errno(verb, templ, args...) \
155 log_message (2, /* print_errno */ TRUE, templ , ##args)
156
157#define bug(templ, args...) \
158 log_message (1, /* print_errno */ FALSE, "BUG: " templ , ##args)
159
160static void
161log_message (unsigned int verbosity,
162 vbi_bool print_errno,
163 const char * templ,
164 ...)
165{
166 if (1) {
167 va_list ap;
168
169 va_start (ap, templ);
170
171 fprintf (stderr, "TVCC: ");
172 vfprintf (stderr, templ, ap);
173
174 if (print_errno) {
175 fprintf (stderr, ": %s.\n",
176 strerror (errno));
177 }
178
179 va_end (ap);
180 }
181}
182
183static void *
184xmalloc (size_t size)
185{
186 void *p;
187
188 p = malloc (size);
189 if (NULL == p) {
190 log(2, "no memory");
191 }
192
193 return p;
194}
195
196static char *
197xasprintf (const char * templ,
198 ...)
199{
200 va_list ap;
201 char *s;
202 int r;
203
204 va_start (ap, templ);
205
206 r = vasprintf (&s, templ, ap);
207 if (r < 0 || NULL == s) {
208 return NULL;
209 }
210
211 va_end (ap);
212
213 return s;
214}
215
216_vbi_inline void
217vbi_char_copy_attr (struct vbi_char * cp1,
218 struct vbi_char * cp2,
219 unsigned int attr)
220{
221 if (attr & VBI_UNDERLINE)
222 cp1->underline = cp2->underline;
223 if (attr & VBI_ITALIC)
224 cp1->italic = cp2->italic;
225 if (attr & VBI_FLASH)
226 cp1->flash = cp2->flash;
227}
228
229_vbi_inline void
230vbi_char_clear_attr (struct vbi_char * cp,
231 unsigned int attr)
232{
233 if (attr & VBI_UNDERLINE)
234 cp->underline = 0;
235 if (attr & VBI_ITALIC)
236 cp->italic = 0;
237 if (attr & VBI_FLASH)
238 cp->flash = 0;
239}
240
241_vbi_inline void
242vbi_char_set_attr (struct vbi_char * cp,
243 unsigned int attr)
244{
245 if (attr & VBI_UNDERLINE)
246 cp->underline = 1;
247 if (attr & VBI_ITALIC)
248 cp->italic = 1;
249 if (attr & VBI_FLASH)
250 cp->flash = 1;
251}
252
253_vbi_inline unsigned int
254vbi_char_has_attr (struct vbi_char * cp,
255 unsigned int attr)
256{
257 attr &= (VBI_UNDERLINE | VBI_ITALIC | VBI_FLASH);
258
259 if (0 == cp->underline)
260 attr &= ~VBI_UNDERLINE;
261 if (0 == cp->italic)
262 attr &= ~VBI_ITALIC;
263 if (0 == cp->flash)
264 attr &= ~VBI_FLASH;
265
266 return attr;
267}
268
269_vbi_inline unsigned int
270vbi_char_xor_attr (struct vbi_char * cp1,
271 struct vbi_char * cp2,
272 unsigned int attr)
273{
274 attr &= (VBI_UNDERLINE | VBI_ITALIC | VBI_FLASH);
275
276 if (0 == (cp1->underline ^ cp2->underline))
277 attr &= ~VBI_UNDERLINE;
278 if (0 == (cp1->italic ^ cp2->italic))
279 attr &= ~VBI_ITALIC;
280 if (0 == (cp1->flash ^ cp2->flash))
281 attr &= ~VBI_FLASH;
282
283 return attr;
284}
285
286/* EIA 608-B Closed Caption decoder. */
287
288static void
289cc_timestamp_reset (struct cc_timestamp * ts)
290{
291 CLEAR (ts->sys);
292 ts->pts = -1;
293}
294
295static vbi_bool
296cc_timestamp_isset (struct cc_timestamp * ts)
297{
298 return (ts->pts >= 0 || 0 != (ts->sys.tv_sec | ts->sys.tv_usec));
299}
300
301static const vbi_color
302cc_color_map [8] = {
303 VBI_WHITE, VBI_GREEN, VBI_BLUE, VBI_CYAN,
304 VBI_RED, VBI_YELLOW, VBI_MAGENTA, VBI_BLACK
305};
306
307static const int8_t
308cc_pac_row_map [16] = {
309 /* 0 */ 10, /* 0x1040 */
310 /* 1 */ -1, /* no function */
311 /* 2 */ 0, 1, 2, 3, /* 0x1140 ... 0x1260 */
312 /* 6 */ 11, 12, 13, 14, /* 0x1340 ... 0x1460 */
313 /* 10 */ 4, 5, 6, 7, 8, 9 /* 0x1540 ... 0x1760 */
314};
315
316static vbi_pgno
317cc_channel_num (struct cc_decoder * cd,
318 struct cc_channel * ch)
319{
320 return (ch - cd->channel) + 1;
321}
322
323/* Note 47 CFR 15.119 (h) Character Attributes: "(1) Transmission of
324 Attributes. A character may be transmitted with any or all of four
325 attributes: Color, italics, underline, and flash. All of these
326 attributes are set by control codes included in the received
327 data. An attribute will remain in effect until changed by another
328 control code or until the end of the row is reached. Each row
329 begins with a control code which sets the color and underline
330 attributes. (White non-underlined is the default display attribute
331 if no Preamble Address Code is received before the first character
332 on an empty row.) Attributes are not affected by transparent spaces
333 within a row. (i) All Mid-Row Codes and the Flash On command are
334 spacing attributes which appear in the display just as if a
335 standard space (20h) had been received. Preamble Address Codes are
336 non-spacing and will not alter any attributes when used to position
337 the cursor in the midst of a row of characters. (ii) The color
338 attribute has the highest priority and can only be changed by the
339 Mid-Row Code of another color. Italics has the next highest
340 priority. If characters with both color and italics are desired,
341 the italics Mid-Row Code must follow the color assignment. Any
342 color Mid-Row Code will turn off italics. If the least significant
343 bit of a Preamble Address Code or of a color or italics Mid-Row
344 Code is a 1 (high), underlining is turned on. If that bit is a 0
345 (low), underlining is off. (iii) The flash attribute is transmitted
346 as a Miscellaneous Control Code. The Flash On command will not
347 alter the status of the color, italics, or underline
348 attributes. However, any coloror italics Mid-Row Code will turn off
349 flash. (iv) Thus, for example, if a red, italicized, underlined,
350 flashing character is desired, the attributes must be received in
351 the following order: a red Mid-Row or Preamble Address Code, an
352 italics Mid-Row Code with underline bit, and the Flash On
353 command. The character will then be preceded by three spaces (two
354 if red was assigned via a Preamble Address Code)."
355
356 EIA 608-B Annex C.7 Preamble Address Codes and Tab Offsets
357 (Regulatory/Preferred): "In general, Preamble Address Codes (PACs)
358 have no immediate effect on the display. A major exception is the
359 receipt of a PAC during roll-up captioning. In that case, if the
360 base row designated in the PAC is not the same as the current base
361 row, the display shall be moved immediately to the new base
362 row. [...]
363
364
365cc_channel_num (struct cc_decoder * cd,
366 struct cc_channel * ch)
367indenting PAC carries the attributes of white,
368 non-italicized, and it sets underlining on or off. Tab Offset
369 commands do not change these attributes. If an indenting PAC with
370 underline ON is received followed by a Tab Offset and by text, the
371 text shall be underlined (except as noted below). When a
372 displayable character is received, it is deposited at the current
373 cursor position. If there is already a displayable character in the
374 column immediately to the left, the new character assumes the
375 attributes of that character. The new character may be arriving as
376 the result of an indenting PAC (with or without a Tab Offset), and
377 that PAC may designate other attributes, but the new character is
378 forced to assume the attributes of the character immediately to its
379 left, and the PAC's attributes are ignored. If, when a displayable
380 character is received, it overwrites an existing PAC or mid-row
381 code, and there are already characters to the right of the new
382 character, these existing characters shall assume the same
383 attributes as the new character. This adoption can result in a
384 whole caption row suddenly changing color, underline, italics,
385 and/or flash attributes."
386
387 EIA 608-B Annex C.14 Special Cases Regarding Attributes
388 (Normative): "In most cases, Preamble Address Codes shall set
389 attributes for the caption elements they address. It is
390 theoretically possible for a service provider to use an indenting
391 PAC to start a row at Column 5 or greater, and then to use
392 Backspace to move the cursor to the left of the PAC into an area to
393 which no attributes have been assigned. It is also possible for a
394 roll-up row, having been created by a Carriage Return, to receive
395 characters with no PAC used to set attributes. In these cases, and
396 in any other case where no explicit attributes have been assigned,
397 the display shall be white, non-underlined, non-italicized, and
398 non-flashing. In case new displayable characters are received
399 immediately after a Delete to End of Row (DER), the display
400 attributes of the first deleted character shall remain in effect if
401 there is a displayable character to the left of the cursor;
402 otherwise, the most recently received PAC shall set the display
403 attributes."
404
405 47 CFR 15.119 (n) Glossary of terms: "(6) Displayable character:
406 Any letter, number or symbol which is defined for on-screen
407 display, plus the 20h space. [...] (13) Special characters:
408 Displayable characters (except for "transparent space") [...]" */
409
410static void
411cc_format_row (struct cc_decoder * cd,
412 struct vbi_char * cp,
413 struct cc_channel * ch,
414 unsigned int buffer,
415 unsigned int row,
416 vbi_bool to_upper,
417 vbi_bool padding)
418{
419 struct vbi_char ac;
420 unsigned int i;
421
422 cd = cd; /* unused */
423
424 /* 47 CFR 15.119 (h)(1). EIA 608-B Section 6.4. */
425 CLEAR (ac);
426 ac.foreground = VBI_WHITE;
427 ac.background = VBI_BLACK;
428
429 /* Shortcut. */
430 if (0 == (ch->dirty[buffer] & (1 << row))) {
431 vbi_char *end;
432
433 ac.unicode = 0x20;
434 ac.opacity = VBI_TRANSPARENT_SPACE;
435
436 end = cp + CC_MAX_COLUMNS;
437 if (padding)
438 end += 2;
439
440 while (cp < end)
441 *cp++ = ac;
442
443 return;
444 }
445
446 if (padding) {
447 ac.unicode = 0x20;
448 ac.opacity = VBI_TRANSPARENT_SPACE;
449 *cp++ = ac;
450 }
451
452 /* EIA 608-B Section 6.4. */
453 ac.opacity = VBI_OPAQUE;
454
455 for (i = CC_FIRST_COLUMN - 1; i <= CC_LAST_COLUMN; ++i) {
456 unsigned int color;
457 unsigned int c;
458
459 ac.unicode = 0x20;
460
461 c = ch->buffer[buffer][row][i];
462 if (0 == c) {
463 if (padding
464 && VBI_TRANSPARENT_SPACE != cp[-1].opacity
465 && 0x20 != cp[-1].unicode) {
466 /* Append a space with the same colors
467 and opacity (opaque or
468 transp. backgr.) as the text to the
469 left of it. */
470 *cp++ = ac;
471 /* We don't underline spaces, see
472 below. */
473 vbi_char_clear_attr (cp - 1, -1);
474 } else if (i > 0) {
475 *cp++ = ac;
476 cp[-1].opacity = VBI_TRANSPARENT_SPACE;
477 }
478
479 continue;
480 } else if (c < 0x1040) {
481 if (padding
482 && VBI_TRANSPARENT_SPACE == cp[-1].opacity) {
483 /* Prepend a space with the same
484 colors and opacity (opaque or
485 transp. backgr.) as the text to the
486 right of it. */
487 cp[-1] = ac;
488 /* We don't underline spaces, see
489 below. */
490 vbi_char_clear_attr (cp - 1, -1);
491 }
492
493 if ((c >= 'a' && c <= 'z')
494 || 0x7E == c /* n with tilde */) {
495 /* We do not force these characters to
496 upper case because the standard
497 character set includes upper case
498 versions of these characters and
499 lower case was probably
500 deliberately transmitted. */
501 ac.unicode = vbi_caption_unicode
502 (c, /* to_upper */ FALSE);
503 } else {
504 ac.unicode = vbi_caption_unicode
505 (c, to_upper);
506 }
507 } else if (c < 0x1120) {
508 /* Preamble Address Codes -- 001 crrr 1ri xxxu */
509
510 /* PAC is a non-spacing attribute and only
511 stored in the buffer at the addressed
512 column minus one if it replaces a
513 transparent space (EIA 608-B Annex C.7,
514 C.14). There's always a transparent space
515 to the left of the first column but we show
516 this zeroth column only if padding is
517 enabled. */
518 if (padding
519 && VBI_TRANSPARENT_SPACE != cp[-1].opacity
520 && 0x20 != cp[-1].unicode) {
521 /* See 0 == c. */
522 *cp++ = ac;
523 vbi_char_clear_attr (cp - 1, -1);
524 } else if (i > 0) {
525 *cp++ = ac;
526 cp[-1].opacity = VBI_TRANSPARENT_SPACE;
527 }
528
529 vbi_char_clear_attr (&ac, VBI_UNDERLINE | VBI_ITALIC);
530 if (c & 0x0001)
531 vbi_char_set_attr (&ac, VBI_UNDERLINE);
532 if (c & 0x0010) {
533 ac.foreground = VBI_WHITE;
534 } else {
535 color = (c >> 1) & 7;
536 if (7 == color) {
537 ac.foreground = VBI_WHITE;
538 vbi_char_set_attr (&ac, VBI_ITALIC);
539 } else {
540 ac.foreground = cc_color_map[color];
541 }
542 }
543
544 continue;
545 } else if (c < 0x1130) {
546 /* Mid-Row Codes -- 001 c001 010 xxxu */
547 /* 47 CFR 15.119 Mid-Row Codes table,
548 (h)(1)(ii), (h)(1)(iii). */
549
550 /* 47 CFR 15.119 (h)(1)(i), EIA 608-B Section
551 6.2: Mid-Row codes, FON, BT, FA and FAU are
552 set-at spacing attributes. */
553
554 vbi_char_clear_attr (&ac, -1);
555 if (c & 0x0001)
556 vbi_char_set_attr (&ac, VBI_UNDERLINE);
557 color = (c >> 1) & 7;
558 if (7 == color) {
559 vbi_char_set_attr (&ac, VBI_ITALIC);
560 } else {
561 ac.foreground = cc_color_map[color];
562 }
563 } else if (c < 0x1220) {
564 /* Special Characters -- 001 c001 011 xxxx */
565 /* 47 CFR 15.119 Character Set Table. */
566
567 if (padding
568 && VBI_TRANSPARENT_SPACE == cp[-1].opacity) {
569 cp[-1] = ac;
570 vbi_char_clear_attr (cp - 1, -1);
571 }
572
573 /* Note we already stored 0 instead of 0x1139
574 (transparent space) in the ch->buffer. */
575 ac.unicode = vbi_caption_unicode (c, to_upper);
576 } else if (c < 0x1428) {
577 /* Extended Character Set -- 001 c01x 01x xxxx */
578 /* EIA 608-B Section 6.4.2 */
579
580 if (padding
581 && VBI_TRANSPARENT_SPACE == cp[-1].opacity) {
582 cp[-1] = ac;
583 vbi_char_clear_attr (cp - 1, -1);
584 }
585
586 /* We do not force these characters to upper
587 case because the extended character set
588 includes upper case versions of all letters
589 and lower case was probably deliberately
590 transmitted. */
591 ac.unicode = vbi_caption_unicode
592 (c, /* to_upper */ FALSE);
593 } else if (c < 0x172D) {
594 /* FON Flash On -- 001 c10f 010 1000 */
595 /* 47 CFR 15.119 (h)(1)(iii). */
596
597 vbi_char_set_attr (&ac, VBI_FLASH);
598 } else if (c < 0x172E) {
599 /* BT Background Transparent -- 001 c111 010 1101 */
600 /* EIA 608-B Section 6.4. */
601
602 ac.opacity = VBI_TRANSPARENT_FULL;
603 } else if (c <= 0x172F) {
604 /* FA Foreground Black -- 001 c111 010 111u */
605 /* EIA 608-B Section 6.4. */
606
607 if (c & 0x0001)
608 vbi_char_set_attr (&ac, VBI_UNDERLINE);
609 ac.foreground = VBI_BLACK;
610 }
611
612 *cp++ = ac;
613
614 /* 47 CFR 15.119 and EIA 608-B are silent about
615 underlined spaces, but considering the example in
616 47 CFR (h)(1)(iv) which would produce something
617 ugly like "__text" I suppose we should not
618 underline them. For good measure we also clear the
619 invisible italic and flash attribute. */
620 if (0x20 == ac.unicode)
621 vbi_char_clear_attr (cp - 1, -1);
622 }
623
624 if (padding) {
625 ac.unicode = 0x20;
626 vbi_char_clear_attr (&ac, -1);
627
628 if (VBI_TRANSPARENT_SPACE != cp[-1].opacity
629 && 0x20 != cp[-1].unicode) {
630 *cp = ac;
631 } else {
632 ac.opacity = VBI_TRANSPARENT_SPACE;
633 *cp = ac;
634 }
635 }
636}
637
638typedef enum {
639 /**
640 * 47 CFR Section 15.119 requires caption decoders to roll
641 * caption smoothly: Nominally each character cell has a
642 * height of 13 field lines. When this flag is set the current
643 * caption should be displayed with a vertical offset of 12
644 * field lines, and after every 1001 / 30000 seconds the
645 * caption overlay should move up by one field line until the
646 * offset is zero. The roll rate should be no more than 0.433
647 * seconds/row for other character cell heights.
648 *
649 * The flag may be set again before the offset returned to
650 * zero. The caption overlay should jump to offset 12 in this
651 * case regardless.
652 */
653 VBI_START_ROLLING = (1 << 0)
654} vbi_cc_page_flags;
655
656static void
657cc_display_event (struct cc_decoder * cd,
658 struct cc_channel * ch,
659 vbi_cc_page_flags flags)
660{
661 cd = cd; /* unused */
662 ch = ch;
663 flags = flags;
664}
665
666/* This decoder is mainly designed to overlay caption onto live video,
667 but to create transcripts we also offer an event every time a line
668 of caption is complete. The event occurs when certain control codes
669 are received.
670
671 In POP_ON mode we send the event upon reception of EOC, which swaps
672 the displayed and non-displayed memory.
673
674 In ROLL_UP and TEXT mode captioners are not expected to display new
675 text by erasing and overwriting a row with PAC, TOx, BS and DER so
676 we ignore these codes. In ROLL_UP mode CR, EDM, EOC, RCL and RDC
677 complete a line. CR moves the cursor to a new row, EDM erases the
678 displayed memory. The remaining codes switch to POP_ON or PAINT_ON
679 mode. In TEXT mode CR and TR are our line completion indicators. CR
680 works as above and TR erases the displayed memory. EDM, EOC, RDC,
681 RCL and RUx have no effect on TEXT buffers.
682
683 In PAINT_ON mode RDC never erases the displayed memory and CR has
684 no function. Instead captioners can freely position the cursor and
685 erase or overwrite (parts of) rows with PAC, TOx, BS and DER, or
686 erase all rows with EDM. We send an event on PAC, EDM, EOC, RCL and
687 RUx, provided the characters (including spacing attributes) in the
688 current row changed since the last event. PAC is the only control
689 code which can move the cursor to the left and/or to a new row, and
690 likely to introduce a new line. EOC, RCL and RUx switch to POP_ON
691 or ROLL_UP mode. */
692
693static void
694cc_stream_event (struct cc_decoder * cd,
695 struct cc_channel * ch,
696 unsigned int first_row,
697 unsigned int last_row)
698{
699 vbi_pgno channel;
700 unsigned int row;
701
702 channel = cc_channel_num (cd, ch);
703
704 for (row = first_row; row <= last_row; ++row) {
705 struct vbi_char text[36];
706 unsigned int end;
707
708 cc_format_row (cd, text, ch,
709 ch->displayed_buffer,
710 row, /* to_upper */ FALSE,
711 /* padding */ FALSE);
712
713 for (end = 32; end > 0; --end) {
714 if (VBI_TRANSPARENT_SPACE != text[end - 1].opacity)
715 break;
716 }
717
718 if (0 == end)
719 continue;
720 }
721
722 cc_timestamp_reset (&ch->timestamp_c0);
723}
724
725static void
726cc_put_char (struct cc_decoder * cd,
727 struct cc_channel * ch,
728 int c,
729 vbi_bool displayable,
730 vbi_bool backspace)
731{
732 uint16_t *text;
733 unsigned int curr_buffer;
734 unsigned int row;
735 unsigned int column;
736
737 /* 47 CFR Section 15.119 (f)(1), (f)(2), (f)(3). */
738 curr_buffer = ch->displayed_buffer
739 ^ (CC_MODE_POP_ON == ch->mode);
740
741 row = ch->curr_row;
742 column = ch->curr_column;
743
744 if (unlikely (backspace)) {
745 /* 47 CFR 15.119 (f)(1)(vi), (f)(2)(ii),
746 (f)(3)(i). EIA 608-B Section 6.4.2, 7.4. */
747 if (column > CC_FIRST_COLUMN)
748 --column;
749 } else {
750 /* 47 CFR 15.119 (f)(1)(v), (f)(1)(vi), (f)(2)(ii),
751 (f)(3)(i). EIA 608-B Section 7.4. */
752 if (column < CC_LAST_COLUMN)
753 ch->curr_column = column + 1;
754 }
755
756 text = &ch->buffer[curr_buffer][row][0];
757 text[column] = c;
758
759 /* Send a display update event when the displayed buffer of
760 the current channel changed, but no more than once for each
761 pair of Closed Caption bytes. */
762 /* XXX This may not be a visible change, but such cases are
763 rare and we'd need something close to format_row() to be
764 sure. */
765 if (CC_MODE_POP_ON != ch->mode) {
766 cd->event_pending = ch;
767 }
768
769 if (likely (displayable)) {
770 /* Note EIA 608-B Annex C.7, C.14. */
771 if (CC_FIRST_COLUMN == column
772 || 0 == text[column - 1]) {
773 /* Note last_pac may be 0 as well. */
774 text[column - 1] = ch->last_pac;
775 }
776
777 if (c >= 'a' && c <= 'z') {
778 ch->uppercase_predictor = 0;
779 } else if (c >= 'A' && c <= 'Z') {
780 unsigned int up;
781
782 up = ch->uppercase_predictor + 1;
783 if (up > 0)
784 ch->uppercase_predictor = up;
785 }
786 } else if (unlikely (0 == c)) {
787 unsigned int i;
788
789 /* This is Special Character "Transparent space". */
790
791 for (i = CC_FIRST_COLUMN; i <= CC_LAST_COLUMN; ++i)
792 c |= ch->buffer[curr_buffer][row][i];
793
794 ch->dirty[curr_buffer] &= ~((0 == c) << row);
795
796 return;
797 }
798
799 assert (sizeof (ch->dirty[0]) * 8 - 1 >= CC_MAX_ROWS);
800 ch->dirty[curr_buffer] |= 1 << row;
801
802 if (ch->timestamp_c0.pts < 0
803 && 0 == (ch->timestamp_c0.sys.tv_sec
804 | ch->timestamp_c0.sys.tv_usec)) {
805 ch->timestamp_c0 = cd->timestamp;
806 }
807}
808
809static void
810cc_ext_control_code (struct cc_decoder * cd,
811 struct cc_channel * ch,
812 unsigned int c2)
813{
814 unsigned int column;
815
816 switch (c2) {
817 case 0x21: /* TO1 */
818 case 0x22: /* TO2 */
819 case 0x23: /* TO3 Tab Offset -- 001 c111 010 00xx */
820 /* 47 CFR 15.119 (e)(1)(ii). EIA 608-B Section 7.4,
821 Annex C.7. */
822 column = ch->curr_column + (c2 & 3);
823 ch->curr_column = MIN (column,
824 (unsigned int) CC_LAST_COLUMN);
825 break;
826
827 case 0x24: /* Select standard character set in normal size */
828 case 0x25: /* Select standard character set in double size */
829 case 0x26: /* Select first private character set */
830 case 0x27: /* Select second private character set */
831 case 0x28: /* Select character set GB 2312-80 (Chinese) */
832 case 0x29: /* Select character set KSC 5601-1987 (Korean) */
833 case 0x2A: /* Select first registered character set. */
834 /* EIA 608-B Section 6.3 Closed Group Extensions. */
835 break;
836
837 case 0x2D: /* BT Background Transparent -- 001 c111 010 1101 */
838 case 0x2E: /* FA Foreground Black -- 001 c111 010 1110 */
839 case 0x2F: /* FAU Foregr. Black Underl. -- 001 c111 010 1111 */
840 /* EIA 608-B Section 6.2. */
841 cc_put_char (cd, ch, 0x1700 | c2,
842 /* displayable */ FALSE,
843 /* backspace */ TRUE);
844 break;
845
846 default:
847 /* 47 CFR Section 15.119 (j): Ignore. */
848 break;
849 }
850}
851
852/* Send a stream event if the current row has changed since the last
853 stream event. This is necessary in paint-on mode where CR has no
854 function and captioners can freely position the cursor to erase or
855 overwrite (parts of) rows. */
856static void
857cc_stream_event_if_changed (struct cc_decoder * cd,
858 struct cc_channel * ch)
859{
860 unsigned int curr_buffer;
861 unsigned int row;
862 unsigned int i;
863
864 curr_buffer = ch->displayed_buffer;
865 row = ch->curr_row;
866
867 if (0 == (ch->dirty[curr_buffer] & (1 << row)))
868 return;
869
870 for (i = CC_FIRST_COLUMN; i <= CC_LAST_COLUMN; ++i) {
871 unsigned int c1;
872 unsigned int c2;
873
874 c1 = ch->buffer[curr_buffer][row][i];
875 if (c1 >= 0x1040) {
876 if (c1 < 0x1120) {
877 c1 = 0; /* PAC -- non-spacing */
878 } else if (c1 < 0x1130 || c1 >= 0x1428) {
879 /* MR, FON, BT, FA, FAU -- spacing */
880 c1 = 0x20;
881 }
882 }
883
884 c2 = ch->buffer[2][row][i];
885 if (c2 >= 0x1040) {
886 if (c2 < 0x1120) {
887 c2 = 0;
888 } else if (c2 < 0x1130 || c2 >= 0x1428) {
889 c1 = 0x20;
890 }
891 }
892
893 if (c1 != c2) {
894 cc_stream_event (cd, ch, row, row);
895
896 memcpy (ch->buffer[2][row],
897 ch->buffer[curr_buffer][row],
898 sizeof (ch->buffer[0][0]));
899
900 ch->dirty[2] = ch->dirty[curr_buffer];
901
902 return;
903 }
904 }
905}
906
907static void
908cc_end_of_caption (struct cc_decoder * cd,
909 struct cc_channel * ch)
910{
911 unsigned int curr_buffer;
912 unsigned int row;
913
914 /* EOC End Of Caption -- 001 c10f 010 1111 */
915
916 curr_buffer = ch->displayed_buffer;
917
918 switch (ch->mode) {
919 case CC_MODE_UNKNOWN:
920 case CC_MODE_POP_ON:
921 break;
922
923 case CC_MODE_ROLL_UP:
924 row = ch->curr_row;
925 if (0 != (ch->dirty[curr_buffer] & (1 << row)))
926 cc_stream_event (cd, ch, row, row);
927 break;
928
929 case CC_MODE_PAINT_ON:
930 cc_stream_event_if_changed (cd, ch);
931 break;
932
933 case CC_MODE_TEXT:
934 /* Not reached. (ch is a caption channel.) */
935 return;
936 }
937
938 ch->displayed_buffer = curr_buffer ^= 1;
939
940 /* 47 CFR Section 15.119 (f)(2). */
941 ch->mode = CC_MODE_POP_ON;
942
943 if (0 != ch->dirty[curr_buffer]) {
944 ch->timestamp_c0 = cd->timestamp;
945
946 cc_stream_event (cd, ch,
947 CC_FIRST_ROW,
948 CC_LAST_ROW);
949
950 cc_display_event (cd, ch, 0);
951 }
952}
953
954static void
955cc_carriage_return (struct cc_decoder * cd,
956 struct cc_channel * ch)
957{
958 unsigned int curr_buffer;
959 unsigned int row;
960 unsigned int window_rows;
961 unsigned int first_row;
962
963 /* CR Carriage Return -- 001 c10f 010 1101 */
964
965 curr_buffer = ch->displayed_buffer;
966 row = ch->curr_row;
967
968 switch (ch->mode) {
969 case CC_MODE_UNKNOWN:
970 return;
971
972 case CC_MODE_ROLL_UP:
973 /* 47 CFR Section 15.119 (f)(1)(iii). */
974 ch->curr_column = CC_FIRST_COLUMN;
975
976 /* 47 CFR 15.119 (f)(1): "The cursor always remains on
977 the base row." */
978
979 /* XXX Spec? */
980 ch->last_pac = 0;
981
982 /* No event if the buffer contains only
983 TRANSPARENT_SPACEs. */
984 if (0 == ch->dirty[curr_buffer])
985 return;
986
987 window_rows = MIN (row + 1 - CC_FIRST_ROW,
988 ch->window_rows);
989 break;
990
991 case CC_MODE_POP_ON:
992 case CC_MODE_PAINT_ON:
993 /* 47 CFR 15.119 (f)(2)(i), (f)(3)(i): No effect. */
994 return;
995
996 case CC_MODE_TEXT:
997 /* 47 CFR Section 15.119 (f)(1)(iii). */
998 ch->curr_column = CC_FIRST_COLUMN;
999
1000 /* XXX Spec? */
1001 ch->last_pac = 0;
1002
1003 /* EIA 608-B Section 7.4: "When Text Mode has
1004 initially been selected and the specified Text
1005 memory is empty, the cursor starts at the topmost
1006 row, Column 1, and moves down to Column 1 on the
1007 next row each time a Carriage Return is received
1008 until the last available row is reached. A variety
1009 of methods may be used to accomplish the scrolling,
1010 provided that the text is legible while moving. For
1011 example, as soon as all of the available rows of
1012 text are on the screen, Text Mode switches to the
1013 standard roll-up type of presentation." */
1014
1015 if (CC_LAST_ROW != row) {
1016 if (0 != (ch->dirty[curr_buffer] & (1 << row))) {
1017 cc_stream_event (cd, ch, row, row);
1018 }
1019
1020 ch->curr_row = row + 1;
1021
1022 return;
1023 }
1024
1025 /* No event if the buffer contains all
1026 TRANSPARENT_SPACEs. */
1027 if (0 == ch->dirty[curr_buffer])
1028 return;
1029
1030 window_rows = CC_MAX_ROWS;
1031
1032 break;
1033 }
1034
1035 /* 47 CFR Section 15.119 (f)(1)(iii). In roll-up mode: "Each
1036 time a Carriage Return is received, the text in the top row
1037 of the window is erased from memory and from the display or
1038 scrolled off the top of the window. The remaining rows of
1039 text are each rolled up into the next highest row in the
1040 window, leaving the base row blank and ready to accept new
1041 text." */
1042
1043 if (0 != (ch->dirty[curr_buffer] & (1 << row))) {
1044 cc_stream_event (cd, ch, row, row);
1045 }
1046
1047 first_row = row + 1 - window_rows;
1048 memmove (ch->buffer[curr_buffer][first_row],
1049 ch->buffer[curr_buffer][first_row + 1],
1050 (window_rows - 1) * sizeof (ch->buffer[0][0]));
1051
1052 ch->dirty[curr_buffer] >>= 1;
1053
1054 memset (ch->buffer[curr_buffer][row], 0,
1055 sizeof (ch->buffer[0][0]));
1056
1057 cc_display_event (cd, ch, VBI_START_ROLLING);
1058}
1059
1060static void
1061cc_erase_memory (struct cc_decoder * cd,
1062 struct cc_channel * ch,
1063 unsigned int buffer)
1064{
1065 if (0 != ch->dirty[buffer]) {
1066 CLEAR (ch->buffer[buffer]);
1067
1068 ch->dirty[buffer] = 0;
1069
1070 if (buffer == ch->displayed_buffer)
1071 cc_display_event (cd, ch, 0);
1072 }
1073}
1074
1075static void
1076cc_erase_displayed_memory (struct cc_decoder * cd,
1077 struct cc_channel * ch)
1078{
1079 unsigned int row;
1080
1081 /* EDM Erase Displayed Memory -- 001 c10f 010 1100 */
1082
1083 switch (ch->mode) {
1084 case CC_MODE_UNKNOWN:
1085 /* We have not received EOC, RCL, RDC or RUx yet, but
1086 ch is valid. */
1087 break;
1088
1089 case CC_MODE_ROLL_UP:
1090 row = ch->curr_row;
1091 if (0 != (ch->dirty[ch->displayed_buffer] & (1 << row)))
1092 cc_stream_event (cd, ch, row, row);
1093 break;
1094
1095 case CC_MODE_PAINT_ON:
1096 cc_stream_event_if_changed (cd, ch);
1097 break;
1098
1099 case CC_MODE_POP_ON:
1100 /* Nothing to do. */
1101 break;
1102
1103 case CC_MODE_TEXT:
1104 /* Not reached. (ch is a caption channel.) */
1105 return;
1106 }
1107
1108 /* May send a display event. */
1109 cc_erase_memory (cd, ch, ch->displayed_buffer);
1110}
1111
1112static void
1113cc_text_restart (struct cc_decoder * cd,
1114 struct cc_channel * ch)
1115{
1116 unsigned int curr_buffer;
1117 unsigned int row;
1118
1119 /* TR Text Restart -- 001 c10f 010 1010 */
1120
1121 curr_buffer = ch->displayed_buffer;
1122 row = ch->curr_row;
1123
1124 /* ch->mode is invariably CC_MODE_TEXT. */
1125
1126 if (0 != (ch->dirty[curr_buffer] & (1 << row))) {
1127 cc_stream_event (cd, ch, row, row);
1128 }
1129
1130 /* EIA 608-B Section 7.4. */
1131 /* May send a display event. */
1132 cc_erase_memory (cd, ch, ch->displayed_buffer);
1133
1134 /* EIA 608-B Section 7.4. */
1135 ch->curr_row = CC_FIRST_ROW;
1136 ch->curr_column = CC_FIRST_COLUMN;
1137}
1138
1139static void
1140cc_resume_direct_captioning (struct cc_decoder * cd,
1141 struct cc_channel * ch)
1142{
1143 unsigned int curr_buffer;
1144 unsigned int row;
1145
1146 /* RDC Resume Direct Captioning -- 001 c10f 010 1001 */
1147
1148 /* 47 CFR 15.119 (f)(1)(x), (f)(2)(vi) and EIA 608-B Annex
1149 B.7: Does not erase memory, does not move the cursor when
1150 resuming after a Text transmission.
1151
1152 XXX If ch->mode is unknown, roll-up or pop-on, what shall
1153 we do if no PAC is received between RDC and the text? */
1154
1155 curr_buffer = ch->displayed_buffer;
1156 row = ch->curr_row;
1157
1158 switch (ch->mode) {
1159 case CC_MODE_ROLL_UP:
1160 if (0 != (ch->dirty[curr_buffer] & (1 << row)))
1161 cc_stream_event (cd, ch, row, row);
1162
1163 /* fall through */
1164
1165 case CC_MODE_UNKNOWN:
1166 case CC_MODE_POP_ON:
1167 /* No change since last stream_event(). */
1168 memcpy (ch->buffer[2], ch->buffer[curr_buffer],
1169 sizeof (ch->buffer[2]));
1170 break;
1171
1172 case CC_MODE_PAINT_ON:
1173 /* Mode continues. */
1174 break;
1175
1176 case CC_MODE_TEXT:
1177 /* Not reached. (ch is a caption channel.) */
1178 return;
1179 }
1180
1181 ch->mode = CC_MODE_PAINT_ON;
1182}
1183
1184static void
1185cc_resize_window (struct cc_decoder * cd,
1186 struct cc_channel * ch,
1187 unsigned int new_rows)
1188{
1189 unsigned int curr_buffer;
1190 unsigned int max_rows;
1191 unsigned int old_rows;
1192 unsigned int row1;
1193
1194 curr_buffer = ch->displayed_buffer;
1195
1196 /* No event if the buffer contains all TRANSPARENT_SPACEs. */
1197 if (0 == ch->dirty[curr_buffer])
1198 return;
1199
1200 row1 = ch->curr_row + 1;
1201 max_rows = row1 - CC_FIRST_ROW;
1202 old_rows = MIN (ch->window_rows, max_rows);
1203 new_rows = MIN (new_rows, max_rows);
1204
1205 /* Nothing to do unless the window shrinks. */
1206 if (0 == new_rows || new_rows >= old_rows)
1207 return;
1208
1209 memset (&ch->buffer[curr_buffer][row1 - old_rows][0], 0,
1210 (old_rows - new_rows)
1211 * sizeof (ch->buffer[0][0]));
1212
1213 ch->dirty[curr_buffer] &= -1 << (row1 - new_rows);
1214
1215 cc_display_event (cd, ch, 0);
1216}
1217
1218static void
1219cc_roll_up_caption (struct cc_decoder * cd,
1220 struct cc_channel * ch,
1221 unsigned int c2)
1222{
1223 unsigned int window_rows;
1224
1225 /* Roll-Up Captions -- 001 c10f 010 01xx */
1226
1227 window_rows = (c2 & 7) - 3; /* 2, 3, 4 */
1228
1229 switch (ch->mode) {
1230 case CC_MODE_ROLL_UP:
1231 /* 47 CFR 15.119 (f)(1)(iv). */
1232 /* May send a display event. */
1233 cc_resize_window (cd, ch, window_rows);
1234
1235 /* fall through */
1236
1237 case CC_MODE_UNKNOWN:
1238 ch->mode = CC_MODE_ROLL_UP;
1239 ch->window_rows = window_rows;
1240
1241 /* 47 CFR 15.119 (f)(1)(ix): No cursor movements,
1242 no memory erasing. */
1243
1244 break;
1245
1246 case CC_MODE_PAINT_ON:
1247 cc_stream_event_if_changed (cd, ch);
1248
1249 /* fall through */
1250
1251 case CC_MODE_POP_ON:
1252 ch->mode = CC_MODE_ROLL_UP;
1253 ch->window_rows = window_rows;
1254
1255 /* 47 CFR 15.119 (f)(1)(ii). */
1256 ch->curr_row = CC_LAST_ROW;
1257 ch->curr_column = CC_FIRST_COLUMN;
1258
1259 /* 47 CFR 15.119 (f)(1)(x). */
1260 /* May send a display event. */
1261 cc_erase_memory (cd, ch, ch->displayed_buffer);
1262 cc_erase_memory (cd, ch, ch->displayed_buffer ^ 1);
1263
1264 break;
1265
1266 case CC_MODE_TEXT:
1267 /* Not reached. (ch is a caption channel.) */
1268 return;
1269 }
1270}
1271
1272static void
1273cc_delete_to_end_of_row (struct cc_decoder * cd,
1274 struct cc_channel * ch)
1275{
1276 unsigned int curr_buffer;
1277 unsigned int row;
1278
1279 /* DER Delete To End Of Row -- 001 c10f 010 0100 */
1280
1281 /* 47 CFR 15.119 (f)(1)(vii), (f)(2)(iii), (f)(3)(ii) and EIA
1282 608-B Section 7.4: In all caption modes and Text mode
1283 "[the] Delete to End of Row command will erase from memory
1284 any characters or control codes starting at the current
1285 cursor location and in all columns to its right on the same
1286 row." */
1287
1288 curr_buffer = ch->displayed_buffer
1289 ^ (CC_MODE_POP_ON == ch->mode);
1290
1291 row = ch->curr_row;
1292
1293 /* No event if the row contains only TRANSPARENT_SPACEs. */
1294 if (0 != (ch->dirty[curr_buffer] & (1 << row))) {
1295 unsigned int column;
1296 unsigned int i;
1297 uint16_t c;
1298
1299 column = ch->curr_column;
1300
1301 memset (&ch->buffer[curr_buffer][row][column], 0,
1302 (CC_LAST_COLUMN - column + 1)
1303 * sizeof (ch->buffer[0][0][0]));
1304
1305 c = 0;
1306 for (i = CC_FIRST_COLUMN; i < column; ++i)
1307 c |= ch->buffer[curr_buffer][row][i];
1308
1309 ch->dirty[curr_buffer] &= ~((0 == c) << row);
1310
1311 cc_display_event (cd, ch, 0);
1312 }
1313}
1314
1315static void
1316cc_backspace (struct cc_decoder * cd,
1317 struct cc_channel * ch)
1318{
1319 unsigned int curr_buffer;
1320 unsigned int row;
1321 unsigned int column;
1322
1323 /* BS Backspace -- 001 c10f 010 0001 */
1324
1325 /* 47 CFR Section 15.119 (f)(1)(vi), (f)(2)(ii), (f)(3)(i) and
1326 EIA 608-B Section 7.4. */
1327 column = ch->curr_column;
1328 if (column <= CC_FIRST_COLUMN)
1329 return;
1330
1331 ch->curr_column = --column;
1332
1333 curr_buffer = ch->displayed_buffer
1334 ^ (CC_MODE_POP_ON == ch->mode);
1335
1336 row = ch->curr_row;
1337
1338 /* No event if there's no visible effect. */
1339 if (0 != ch->buffer[curr_buffer][row][column]) {
1340 unsigned int i;
1341 uint16_t c;
1342
1343 /* 47 CFR 15.119 (f), (f)(1)(vi), (f)(2)(ii) and EIA
1344 608-B Section 7.4. */
1345 ch->buffer[curr_buffer][row][column] = 0;
1346
1347 c = 0;
1348 for (i = CC_FIRST_COLUMN; i <= CC_LAST_COLUMN; ++i)
1349 c |= ch->buffer[curr_buffer][row][i];
1350
1351 ch->dirty[curr_buffer] &= ~((0 == c) << row);
1352
1353 cc_display_event (cd, ch, 0);
1354 }
1355}
1356
1357static void
1358cc_resume_caption_loading (struct cc_decoder * cd,
1359 struct cc_channel * ch)
1360{
1361 unsigned int row;
1362
1363 /* RCL Resume Caption Loading -- 001 c10f 010 0000 */
1364
1365 switch (ch->mode) {
1366 case CC_MODE_UNKNOWN:
1367 case CC_MODE_POP_ON:
1368 break;
1369
1370 case CC_MODE_ROLL_UP:
1371 row = ch->curr_row;
1372 if (0 != (ch->dirty[ch->displayed_buffer] & (1 << row)))
1373 cc_stream_event (cd, ch, row, row);
1374 break;
1375
1376 case CC_MODE_PAINT_ON:
1377 cc_stream_event_if_changed (cd, ch);
1378 break;
1379
1380 case CC_MODE_TEXT:
1381 /* Not reached. (ch is a caption channel.) */
1382 return;
1383 }
1384
1385 /* 47 CFR 15.119 (f)(1)(x): Does not erase memory.
1386 (f)(2)(iv): Cursor position remains unchanged. */
1387
1388 ch->mode = CC_MODE_POP_ON;
1389}
1390
1391
1392
1393/* Note curr_ch is invalid if UNKNOWN_CC_CHANNEL == cd->cc.curr_ch_num. */
1394static struct cc_channel *
1395cc_switch_channel (struct cc_decoder * cd,
1396 struct cc_channel * curr_ch,
1397 vbi_pgno new_ch_num,
1398 enum field_num f)
1399{
1400 struct cc_channel *new_ch;
1401
1402 if (UNKNOWN_CC_CHANNEL != cd->curr_ch_num[f]
1403 && CC_MODE_UNKNOWN != curr_ch->mode) {
1404 /* XXX Force a display update if we do not send events
1405 on every display change. */
1406 }
1407
1408 cd->curr_ch_num[f] = new_ch_num;
1409 new_ch = &cd->channel[new_ch_num - VBI_CAPTION_CC1];
1410
1411 return new_ch;
1412}
1413
1414/* Note ch is invalid if UNKNOWN_CC_CHANNEL == cd->cc.curr_ch_num[f]. */
1415static void
1416cc_misc_control_code (struct cc_decoder * cd,
1417 struct cc_channel * ch,
1418 unsigned int c2,
1419 unsigned int ch_num0,
1420 enum field_num f)
1421{
1422 unsigned int new_ch_num;
1423
1424 /* Misc Control Codes -- 001 c10f 010 xxxx */
1425
1426 /* c = channel (0 -> CC1/CC3/T1/T3, 1 -> CC2/CC4/T2/T4)
1427 -- 47 CFR Section 15.119, EIA 608-B Section 7.7.
1428 f = field (0 -> F1, 1 -> F2)
1429 -- EIA 608-B Section 8.4, 8.5. */
1430
1431 /* XXX The f flag is intended to detect accidential field
1432 swapping and we should use it for that purpose. */
1433
1434 switch (c2 & 15) {
1435 case 0: /* RCL Resume Caption Loading -- 001 c10f 010 0000 */
1436 /* 47 CFR 15.119 (f)(2) and EIA 608-B Section 7.7. */
1437 new_ch_num = VBI_CAPTION_CC1 + (ch_num0 & 3);
1438 ch = cc_switch_channel (cd, ch, new_ch_num, f);
1439 cc_resume_caption_loading (cd, ch);
1440 break;
1441
1442 case 1: /* BS Backspace -- 001 c10f 010 0001 */
1443 if (UNKNOWN_CC_CHANNEL == cd->curr_ch_num[f]
1444 || CC_MODE_UNKNOWN == ch->mode)
1445 break;
1446 cc_backspace (cd, ch);
1447 break;
1448
1449 case 2: /* reserved (formerly AOF Alarm Off) */
1450 case 3: /* reserved (formerly AON Alarm On) */
1451 break;
1452
1453 case 4: /* DER Delete To End Of Row -- 001 c10f 010 0100 */
1454 if (UNKNOWN_CC_CHANNEL == cd->curr_ch_num[f]
1455 || CC_MODE_UNKNOWN == ch->mode)
1456 break;
1457 cc_delete_to_end_of_row (cd, ch);
1458 break;
1459
1460 case 5: /* RU2 */
1461 case 6: /* RU3 */
1462 case 7: /* RU4 Roll-Up Captions -- 001 c10f 010 01xx */
1463 /* 47 CFR 15.119 (f)(1) and EIA 608-B Section 7.7. */
1464 new_ch_num = VBI_CAPTION_CC1 + (ch_num0 & 3);
1465 ch = cc_switch_channel (cd, ch, new_ch_num, f);
1466 cc_roll_up_caption (cd, ch, c2);
1467 break;
1468
1469 case 8: /* FON Flash On -- 001 c10f 010 1000 */
1470 if (UNKNOWN_CC_CHANNEL == cd->curr_ch_num[f]
1471 || CC_MODE_UNKNOWN == ch->mode)
1472 break;
1473
1474 /* 47 CFR 15.119 (h)(1)(i): Spacing attribute. */
1475 cc_put_char (cd, ch, 0x1428,
1476 /* displayable */ FALSE,
1477 /* backspace */ FALSE);
1478 break;
1479
1480 case 9: /* RDC Resume Direct Captioning -- 001 c10f 010 1001 */
1481 /* 47 CFR 15.119 (f)(3) and EIA 608-B Section 7.7. */
1482 new_ch_num = VBI_CAPTION_CC1 + (ch_num0 & 3);
1483 ch = cc_switch_channel (cd, ch, new_ch_num, f);
1484 cc_resume_direct_captioning (cd, ch);
1485 break;
1486
1487 case 10: /* TR Text Restart -- 001 c10f 010 1010 */
1488 /* EIA 608-B Section 7.4. */
1489 new_ch_num = VBI_CAPTION_T1 + (ch_num0 & 3);
1490 ch = cc_switch_channel (cd, ch, new_ch_num, f);
1491 cc_text_restart (cd, ch);
1492 break;
1493
1494 case 11: /* RTD Resume Text Display -- 001 c10f 010 1011 */
1495 /* EIA 608-B Section 7.4. */
1496 new_ch_num = VBI_CAPTION_T1 + (ch_num0 & 3);
1497 ch = cc_switch_channel (cd, ch, new_ch_num, f);
1498 /* ch->mode is invariably CC_MODE_TEXT. */
1499 break;
1500
1501 case 12: /* EDM Erase Displayed Memory -- 001 c10f 010 1100 */
1502 /* 47 CFR 15.119 (f). EIA 608-B Section 7.7 and Annex
1503 B.7: "[The] command shall be acted upon as
1504 appropriate for caption processing without
1505 terminating the Text Mode data stream." */
1506
1507 /* We need not check cd->curr_ch_num because bit 2 is
1508 implied, bit 1 is the known field number and bit 0
1509 is coded in the control code. */
1510 ch = &cd->channel[ch_num0 & 3];
1511
1512 cc_erase_displayed_memory (cd, ch);
1513
1514 break;
1515
1516 case 13: /* CR Carriage Return -- 001 c10f 010 1101 */
1517 if (UNKNOWN_CC_CHANNEL == cd->curr_ch_num[f])
1518 break;
1519 cc_carriage_return (cd, ch);
1520 break;
1521
1522 case 14: /* ENM Erase Non-Displayed Memory -- 001 c10f 010 1110 */
1523 /* 47 CFR 15.119 (f)(2)(v). EIA 608-B Section 7.7 and
1524 Annex B.7: "[The] command shall be acted upon as
1525 appropriate for caption processing without
1526 terminating the Text Mode data stream." */
1527
1528 /* See EDM. */
1529 ch = &cd->channel[ch_num0 & 3];
1530
1531 cc_erase_memory (cd, ch, ch->displayed_buffer ^ 1);
1532
1533 break;
1534
1535 case 15: /* EOC End Of Caption -- 001 c10f 010 1111 */
1536 /* 47 CFR 15.119 (f), (f)(2), (f)(3)(iv) and EIA 608-B
1537 Section 7.7, Annex C.11. */
1538 new_ch_num = VBI_CAPTION_CC1 + (ch_num0 & 3);
1539 ch = cc_switch_channel (cd, ch, new_ch_num, f);
1540 cc_end_of_caption (cd, ch);
1541 break;
1542 }
1543}
1544
1545static void
1546cc_move_window (struct cc_decoder * cd,
1547 struct cc_channel * ch,
1548 unsigned int new_base_row)
1549{
1550 uint8_t *base;
1551 unsigned int curr_buffer;
1552 unsigned int bytes_per_row;
1553 unsigned int old_max_rows;
1554 unsigned int new_max_rows;
1555 unsigned int copy_bytes;
1556 unsigned int erase_begin;
1557 unsigned int erase_end;
1558
1559 curr_buffer = ch->displayed_buffer;
1560
1561 /* No event if we do not move the window or the buffer
1562 contains only TRANSPARENT_SPACEs. */
1563 if (new_base_row == ch->curr_row
1564 || 0 == ch->dirty[curr_buffer])
1565 return;
1566
1567 base = (void *) &ch->buffer[curr_buffer][CC_FIRST_ROW][0];
1568 bytes_per_row = sizeof (ch->buffer[0][0]);
1569
1570 old_max_rows = ch->curr_row + 1 - CC_FIRST_ROW;
1571 new_max_rows = new_base_row + 1 - CC_FIRST_ROW;
1572 copy_bytes = MIN (MIN (old_max_rows, new_max_rows),
1573 ch->window_rows) * bytes_per_row;
1574
1575 if (new_base_row < ch->curr_row) {
1576 erase_begin = (new_base_row + 1) * bytes_per_row;
1577 erase_end = (ch->curr_row + 1) * bytes_per_row;
1578
1579 memmove (base + erase_begin - copy_bytes,
1580 base + erase_end - copy_bytes, copy_bytes);
1581
1582 ch->dirty[curr_buffer] >>= ch->curr_row - new_base_row;
1583 } else {
1584 erase_begin = (ch->curr_row + 1) * bytes_per_row
1585 - copy_bytes;
1586 erase_end = (new_base_row + 1) * bytes_per_row
1587 - copy_bytes;
1588
1589 memmove (base + erase_end,
1590 base + erase_begin, copy_bytes);
1591
1592 ch->dirty[curr_buffer] <<= new_base_row - ch->curr_row;
1593 ch->dirty[curr_buffer] &= CC_ALL_ROWS_MASK;
1594 }
1595
1596 memset (base + erase_begin, 0, erase_end - erase_begin);
1597
1598 cc_display_event (cd, ch, 0);
1599}
1600
1601static void
1602cc_preamble_address_code (struct cc_decoder * cd,
1603 struct cc_channel * ch,
1604 unsigned int c1,
1605 unsigned int c2)
1606{
1607 unsigned int row;
1608
1609 /* PAC Preamble Address Codes -- 001 crrr 1ri xxxu */
1610
1611 row = cc_pac_row_map[(c1 & 7) * 2 + ((c2 >> 5) & 1)];
1612 if ((int) row < 0)
1613 return;
1614
1615 switch (ch->mode) {
1616 case CC_MODE_UNKNOWN:
1617 return;
1618
1619 case CC_MODE_ROLL_UP:
1620 /* EIA 608-B Annex C.4. */
1621 if (ch->window_rows > row + 1)
1622 row = ch->window_rows - 1;
1623
1624 /* 47 CFR Section 15.119 (f)(1)(ii). */
1625 /* May send a display event. */
1626 cc_move_window (cd, ch, row);
1627
1628 ch->curr_row = row;
1629
1630 break;
1631
1632 case CC_MODE_PAINT_ON:
1633 cc_stream_event_if_changed (cd, ch);
1634
1635 /* fall through */
1636
1637 case CC_MODE_POP_ON:
1638 /* XXX 47 CFR 15.119 (f)(2)(i), (f)(3)(i): In Pop-on
1639 and paint-on mode "Preamble Address Codes can be
1640 used to move the cursor around the screen in random
1641 order to place captions on Rows 1 to 15." We do not
1642 have a limit on the number of displayable rows, but
1643 as EIA 608-B Annex C.6 points out, if more than
1644 four rows must be displayed they were probably
1645 received in error and we should respond
1646 accordingly. */
1647
1648 /* 47 CFR Section 15.119 (d)(1)(i) and EIA 608-B Annex
1649 C.7. */
1650 ch->curr_row = row;
1651
1652 break;
1653
1654 case CC_MODE_TEXT:
1655 /* 47 CFR 15.119 (e)(1) and EIA 608-B Section 7.4:
1656 Does not change the cursor row. */
1657 break;
1658 }
1659
1660 if (c2 & 0x10) {
1661 /* 47 CFR 15.119 (e)(1)(i) and EIA 608-B Table 71. */
1662 ch->curr_column = CC_FIRST_COLUMN + (c2 & 0x0E) * 2;
1663 }
1664
1665 /* PAC is a non-spacing attribute for the next character, see
1666 cc_put_char(). */
1667 ch->last_pac = 0x1000 | c2;
1668}
1669
1670static void
1671cc_control_code (struct cc_decoder * cd,
1672 unsigned int c1,
1673 unsigned int c2,
1674 enum field_num f)
1675{
1676 struct cc_channel *ch;
1677 unsigned int ch_num0;
1678
1679 /* Caption / text, field 1 / 2, primary / secondary channel. */
1680 ch_num0 = (((cd->curr_ch_num[f] - VBI_CAPTION_CC1) & 4)
1681 + f * 2
1682 + ((c1 >> 3) & 1));
1683
1684 /* Note ch is invalid if UNKNOWN_CC_CHANNEL ==
1685 cd->curr_ch_num[f]. */
1686 ch = &cd->channel[ch_num0];
1687
1688 if (c2 >= 0x40) {
1689 /* Preamble Address Codes -- 001 crrr 1ri xxxu */
1690 if (UNKNOWN_CC_CHANNEL != cd->curr_ch_num[f])
1691 cc_preamble_address_code (cd, ch, c1, c2);
1692 return;
1693 }
1694
1695 switch (c1 & 7) {
1696 case 0:
1697 if (UNKNOWN_CC_CHANNEL == cd->curr_ch_num[f]
1698 || CC_MODE_UNKNOWN == ch->mode)
1699 break;
1700
1701 if (c2 < 0x30) {
1702 /* Backgr. Attr. Codes -- 001 c000 010 xxxt */
1703 /* EIA 608-B Section 6.2. */
1704 cc_put_char (cd, ch, 0x1000 | c2,
1705 /* displayable */ FALSE,
1706 /* backspace */ TRUE);
1707 } else {
1708 /* Undefined. */
1709 }
1710
1711 break;
1712
1713 case 1:
1714 if (UNKNOWN_CC_CHANNEL == cd->curr_ch_num[f]
1715 || CC_MODE_UNKNOWN == ch->mode)
1716 break;
1717
1718 if (c2 < 0x30) {
1719 /* Mid-Row Codes -- 001 c001 010 xxxu */
1720 /* 47 CFR 15.119 (h)(1)(i): Spacing attribute. */
1721 cc_put_char (cd, ch, 0x1100 | c2,
1722 /* displayable */ FALSE,
1723 /* backspace */ FALSE);
1724 } else {
1725 /* Special Characters -- 001 c001 011 xxxx */
1726 if (0x39 == c2) {
1727 /* Transparent space. */
1728 cc_put_char (cd, ch, 0,
1729 /* displayable */ FALSE,
1730 /* backspace */ FALSE);
1731 } else {
1732 cc_put_char (cd, ch, 0x1100 | c2,
1733 /* displayable */ TRUE,
1734 /* backspace */ FALSE);
1735 }
1736 }
1737
1738 break;
1739
1740 case 2:
1741 case 3: /* Extended Character Set -- 001 c01x 01x xxxx */
1742 if (UNKNOWN_CC_CHANNEL == cd->curr_ch_num[f]
1743 || CC_MODE_UNKNOWN == ch->mode)
1744 break;
1745
1746 /* EIA 608-B Section 6.4.2. */
1747 cc_put_char (cd, ch, (c1 * 256 + c2) & 0x777F,
1748 /* displayable */ TRUE,
1749 /* backspace */ TRUE);
1750 break;
1751
1752 case 4:
1753 case 5:
1754 if (c2 < 0x30) {
1755 /* Misc. Control Codes -- 001 c10f 010 xxxx */
1756 cc_misc_control_code (cd, ch, c2, ch_num0, f);
1757 } else {
1758 /* Undefined. */
1759 }
1760
1761 break;
1762
1763 case 6: /* reserved */
1764 break;
1765
1766 case 7: /* Extended control codes -- 001 c111 01x xxxx */
1767 if (UNKNOWN_CC_CHANNEL == cd->curr_ch_num[f]
1768 || CC_MODE_UNKNOWN == ch->mode)
1769 break;
1770
1771 cc_ext_control_code (cd, ch, c2);
1772
1773 break;
1774 }
1775}
1776
1777static vbi_bool
1778cc_characters (struct cc_decoder * cd,
1779 struct cc_channel * ch,
1780 int c)
1781{
1782 if (0 == c) {
1783 if (CC_MODE_UNKNOWN == ch->mode)
1784 return TRUE;
1785
1786 /* XXX After x NUL characters (presumably a caption
1787 pause), force a display update if we do not send
1788 events on every display change. */
1789
1790 return TRUE;
1791 }
1792
1793 if (c < 0x20) {
1794 /* Parity error or invalid data. */
1795
1796 if (c < 0 && CC_MODE_UNKNOWN != ch->mode) {
1797 /* 47 CFR Section 15.119 (j)(1). */
1798 cc_put_char (cd, ch, 0x7F,
1799 /* displayable */ TRUE,
1800 /* backspace */ FALSE);
1801 }
1802
1803 return FALSE;
1804 }
1805
1806 if (CC_MODE_UNKNOWN != ch->mode) {
1807 cc_put_char (cd, ch, c,
1808 /* displayable */ TRUE,
1809 /* backspace */ FALSE);
1810 }
1811
1812 return TRUE;
1813}
1814
1815vbi_bool
1816cc_feed (struct cc_decoder * cd,
1817 const uint8_t buffer[2],
1818 unsigned int line,
1819 const struct timeval * tv,
1820 int64_t pts)
1821{
1822 int c1, c2;
1823 enum field_num f;
1824 vbi_bool all_successful;
1825
1826 assert (NULL != cd);
1827
1828 f = FIELD_1;
1829
1830 switch (line) {
1831 case 21: /* NTSC */
1832 case 22: /* PAL/SECAM */
1833 break;
1834
1835 case 284: /* NTSC */
1836 f = FIELD_2;
1837 break;
1838
1839 default:
1840 return FALSE;
1841 }
1842
1843 cd->timestamp.sys = *tv;
1844 cd->timestamp.pts = pts;
1845
1846 /* FIXME deferred reset here */
1847
1848 c1 = vbi_unpar8 (buffer[0]);
1849 c2 = vbi_unpar8 (buffer[1]);
1850
1851 all_successful = TRUE;
1852
1853 /* 47 CFR 15.119 (2)(i)(4): "If the first transmission of a
1854 control code pair passes parity, it is acted upon within
1855 one video frame. If the next frame contains a perfect
1856 repeat of the same pair, the redundant code is ignored. If,
1857 however, the next frame contains a different but also valid
1858 control code pair, this pair, too, will be acted upon (and
1859 the receiver will expect a repeat of this second pair in
1860 the next frame). If the first byte of the expected
1861 redundant control code pair fails the parity check and the
1862 second byte is identical to the second byte in the
1863 immediately preceding pair, then the expected redundant
1864 code is ignored. If there are printing characters in place
1865 of the redundant code, they will be processed normally."
1866
1867 EIA 608-B Section 8.3: Caption control codes on field 2 may
1868 repeat as on field 1. Section 8.6.2: XDS control codes
1869 shall not repeat. */
1870
1871 if (unlikely (c1 < 0)) {
1872 goto parity_error;
1873 } else if (c1 == cd->expect_ctrl[f][0]
1874 && c2 == cd->expect_ctrl[f][1]) {
1875 /* Already acted upon. */
1876 cd->expect_ctrl[f][0] = -1;
1877 goto finish;
1878 }
1879
1880 if (c1 >= 0x10 && c1 < 0x20) {
1881 /* Caption control code. */
1882
1883 /* There's no XDS on field 1, we just
1884 use an array to save a branch. */
1885 cd->in_xds[f] = FALSE;
1886
1887 /* 47 CFR Section 15.119 (i)(1), (i)(2). */
1888 if (c2 < 0x20) {
1889 /* Parity error or invalid control code.
1890 Let's hope it repeats. */
1891 goto parity_error;
1892 }
1893
1894 cc_control_code (cd, c1, c2, f);
1895
1896 if (cd->event_pending) {
1897 cc_display_event (cd, cd->event_pending, 0);
1898 cd->event_pending = NULL;
1899 }
1900
1901 cd->expect_ctrl[f][0] = c1;
1902 cd->expect_ctrl[f][1] = c2;
1903 } else {
1904 cd->expect_ctrl[f][0] = -1;
1905
1906 if (c1 < 0x10) {
1907 if (FIELD_1 == f) {
1908 /* 47 CFR Section 15.119 (i)(1): "If the
1909 non-printing character in the pair is
1910 in the range 00h to 0Fh, that character
1911 alone will be ignored and the second
1912 character will be treated normally." */
1913 c1 = 0;
1914 } else if (0x0F == c1) {
1915 /* XDS packet terminator. */
1916 cd->in_xds[FIELD_2] = FALSE;
1917 goto finish;
1918 } else if (c1 >= 0x01) {
1919 /* XDS packet start or continuation.
1920 EIA 608-B Section 7.7, 8.5: Also
1921 interrupts a Text mode
1922 transmission. */
1923 cd->in_xds[FIELD_2] = TRUE;
1924 goto finish;
1925 }
1926 }
1927
1928 {
1929 struct cc_channel *ch;
1930 vbi_pgno ch_num;
1931
1932 ch_num = cd->curr_ch_num[f];
1933 if (UNKNOWN_CC_CHANNEL == ch_num)
1934 goto finish;
1935
1936 ch_num = ((ch_num - VBI_CAPTION_CC1) & 5) + f * 2;
1937 ch = &cd->channel[ch_num];
1938
1939 all_successful &= cc_characters (cd, ch, c1);
1940 all_successful &= cc_characters (cd, ch, c2);
1941
1942 if (cd->event_pending) {
1943 cc_display_event (cd, cd->event_pending, 0);
1944 cd->event_pending = NULL;
1945 }
1946 }
1947 }
1948
1949 finish:
1950 cd->error_history = cd->error_history * 2 + all_successful;
1951
1952 return all_successful;
1953
1954 parity_error:
1955 cd->expect_ctrl[f][0] = -1;
1956
1957 /* XXX Some networks stupidly transmit 0x0000 instead of
1958 0x8080 as filler. Perhaps we shouldn't take that as a
1959 serious parity error. */
1960 cd->error_history *= 2;
1961
1962 return FALSE;
1963}
1964
1965void
1966cc_reset (struct cc_decoder * cd)
1967{
1968 unsigned int ch_num;
1969
1970 assert (NULL != cd);
1971
1972 for (ch_num = 0; ch_num < MAX_CC_CHANNELS; ++ch_num) {
1973 struct cc_channel *ch;
1974
1975 ch = &cd->channel[ch_num];
1976
1977 if (ch_num <= 3) {
1978 ch->mode = CC_MODE_UNKNOWN;
1979
1980 /* Something suitable for roll-up mode. */
1981 ch->curr_row = CC_LAST_ROW;
1982 ch->curr_column = CC_FIRST_COLUMN;
1983 ch->window_rows = 4;
1984 } else {
1985 ch->mode = CC_MODE_TEXT; /* invariable */
1986
1987 /* EIA 608-B Section 7.4: "When Text Mode has
1988 initially been selected and the specified
1989 Text memory is empty, the cursor starts at
1990 the topmost row, Column 1." */
1991 ch->curr_row = CC_FIRST_ROW;
1992 ch->curr_column = CC_FIRST_COLUMN;
1993 ch->window_rows = 0; /* n/a */
1994 }
1995
1996 ch->displayed_buffer = 0;
1997
1998 ch->last_pac = 0;
1999
2000 CLEAR (ch->buffer);
2001 CLEAR (ch->dirty);
2002
2003 cc_timestamp_reset (&ch->timestamp);
2004 cc_timestamp_reset (&ch->timestamp_c0);
2005 }
2006
2007 cd->curr_ch_num[0] = UNKNOWN_CC_CHANNEL;
2008 cd->curr_ch_num[1] = UNKNOWN_CC_CHANNEL;
2009
2010 memset (cd->expect_ctrl, -1, sizeof (cd->expect_ctrl));
2011
2012 CLEAR (cd->in_xds);
2013
2014 cd->event_pending = NULL;
2015}
2016
2017void
2018cc_init (struct cc_decoder * cd)
2019{
2020 cc_reset (cd);
2021
2022 cd->error_history = 0;
2023
2024 cc_timestamp_reset (&cd->timestamp);
2025}
2026
2027#if 0 /* to be replaced */
2028
2029static int webtv_check(struct caption_recorder *cr, char * buf,int len)
2030{
2031 unsigned long sum;
2032 unsigned long nwords;
2033 unsigned short csum=0;
2034 char temp[9];
2035 int nbytes=0;
2036
2037 while (buf[0]!='<' && len > 6) //search for the start
2038 {
2039 buf++; len--;
2040 }
2041
2042 if (len == 6) //failure to find start
2043 return 0;
2044
2045
2046 while (nbytes+6 <= len)
2047 {
2048 //look for end of object checksum, it's enclosed in []'s and there shouldn't be any [' after
2049 if (buf[nbytes] == '[' && buf[nbytes+5] == ']' && buf[nbytes+6] != '[')
2050 break;
2051 else
2052 nbytes++;
2053 }
2054 if (nbytes+6>len) //failure to find end
2055 return 0;
2056
2057 nwords = nbytes >> 1; sum = 0;
2058
2059 //add up all two byte words
2060 while (nwords-- > 0) {
2061 sum += *buf++ << 8;
2062 sum += *buf++;
2063 }
2064 if (nbytes & 1) {
2065 sum += *buf << 8;
2066 }
2067 csum = (unsigned short)(sum >> 16);
2068 while(csum !=0) {
2069 sum = csum + (sum & 0xffff);
2070 csum = (unsigned short)(sum >> 16);
2071 }
2072 sprintf(temp,"%04X\n",(int)~sum&0xffff);
2073 buf++;
2074 if (!strncmp(buf,temp,4))
2075 {
2076 buf[5]=0;
2077 if (cr->cur_ch[cr->field] >= 0 && cr->cc_fp[cr->cur_ch[cr->field]]) {
2078 if (!cr->plain)
2079 fprintf(cr->cc_fp[cr->cur_ch[cr->field]], "\33[35mWEBTV: %s\33[0m\n",buf-nbytes-1);
2080 else
2081 fprintf(cr->cc_fp[cr->cur_ch[cr->field]], "WEBTV: %s\n",buf-nbytes-1);
2082 fflush (cr->cc_fp[cr->cur_ch[cr->field]]);
2083 }
2084 }
2085 return 0;
2086}
2087
2088#endif /* 0 */
2089
2090/* CEA 708-C Digital TV Closed Caption decoder. */
2091
2092static const uint8_t
2093dtvcc_c0_length [4] = {
2094 1, 1, 2, 3
2095};
2096
2097static const uint8_t
2098dtvcc_c1_length [32] = {
2099 /* 0x80 CW0 ... CW7 */ 1, 1, 1, 1, 1, 1, 1, 1,
2100 /* 0x88 CLW */ 2,
2101 /* 0x89 DSW */ 2,
2102 /* 0x8A HDW */ 2,
2103 /* 0x8B TGW */ 2,
2104
2105 /* 0x8C DLW */ 2,
2106 /* 0x8D DLY */ 2,
2107 /* 0x8E DLC */ 1,
2108 /* 0x8F RST */ 1,
2109
2110 /* 0x90 SPA */ 3,
2111 /* 0x91 SPC */ 4,
2112 /* 0x92 SPL */ 3,
2113 /* CEA 708-C Section 7.1.5.1: 0x93 ... 0x96 are
2114 reserved one byte codes. */ 1, 1, 1, 1,
2115 /* 0x97 SWA */ 5,
2116 /* 0x98 DF0 ... DF7 */ 7, 7, 7, 7, 7, 7, 7, 7
2117};
2118
2119static const uint16_t
2120dtvcc_g2 [96] = {
2121 /* Note Unicode defines no transparent spaces. */
2122 0x0020, /* 0x1020 Transparent space */
2123 0x00A0, /* 0x1021 Non-breaking transparent space */
2124
2125 0, /* 0x1022 reserved */
2126 0,
2127 0,
2128 0x2026, /* 0x1025 Horizontal ellipsis */
2129 0,
2130 0,
2131 0,
2132 0,
2133 0x0160, /* 0x102A S with caron */
2134 0,
2135 0x0152, /* 0x102C Ligature OE */
2136 0,
2137 0,
2138 0,
2139
2140 /* CEA 708-C Section 7.1.8: "The character (0x30) is a solid
2141 block which fills the entire character position with the
2142 text foreground color." */
2143 0x2588, /* 0x1030 Full block */
2144
2145 0x2018, /* 0x1031 Left single quotation mark */
2146 0x2019, /* 0x1032 Right single quotation mark */
2147 0x201C, /* 0x1033 Left double quotation mark */
2148 0x201D, /* 0x1034 Right double quotation mark */
2149 0x2022,
2150 0,
2151 0,
2152 0,
2153 0x2122, /* 0x1039 Trademark sign */
2154 0x0161, /* 0x103A s with caron */
2155 0,
2156 0x0153, /* 0x103C Ligature oe */
2157 0x2120, /* 0x103D Service mark */
2158 0,
2159 0x0178, /* 0x103F Y with diaeresis */
2160
2161 /* Code points 0x1040 ... 0x106F reserved. */
2162 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2163 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2164 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
2165
2166 0, /* 0x1070 reserved */
2167 0,
2168 0,
2169 0,
2170 0,
2171 0,
2172 0x215B, /* 0x1076 1/8 */
2173 0x215C, /* 0x1077 3/8 */
2174 0x215D, /* 0x1078 5/8 */
2175 0x215E, /* 0x1079 7/8 */
2176 0x2502, /* 0x107A Box drawings vertical */
2177 0x2510, /* 0x107B Box drawings down and left */
2178 0x2514, /* 0x107C Box drawings up and right */
2179 0x2500, /* 0x107D Box drawings horizontal */
2180 0x2518, /* 0x107E Box drawings up and left */
2181 0x250C /* 0x107F Box drawings down and right */
2182};
2183
2184static vbi_rgba
2185dtvcc_color_map[8] = {
2186 VBI_RGBA(0x00, 0x00, 0x00), VBI_RGBA(0xFF, 0x00, 0x00),
2187 VBI_RGBA(0x00, 0xFF, 0x00), VBI_RGBA(0xFF, 0xFF, 0x00),
2188 VBI_RGBA(0x00, 0x00, 0xFF), VBI_RGBA(0xFF, 0x00, 0xFF),
2189 VBI_RGBA(0x00, 0xFF, 0xFF), VBI_RGBA(0xFF, 0xFF, 0xFF)
2190};
2191
2192
2193static void
2194dtvcc_set_page_color_map(vbi_decoder *vbi, vbi_page *pg)
2195{
2196 vbi_transp_colormap(vbi, pg->color_map, dtvcc_color_map, 8);
2197}
2198
2199static vbi_color
2200dtvcc_map_color(dtvcc_color c)
2201{
2202 vbi_color ret = VBI_BLACK;
2203
2204 c &= 0x2A;
2205 switch(c){
2206 case 0:
2207 ret = VBI_BLACK;
2208 break;
2209 case 0x20:
2210 ret = VBI_RED;
2211 break;
2212 case 0x08:
2213 ret = VBI_GREEN;
2214 break;
2215 case 0x28:
2216 ret = VBI_YELLOW;
2217 break;
2218 case 0x02:
2219 ret = VBI_BLUE;
2220 break;
2221 case 0x22:
2222 ret = VBI_MAGENTA;
2223 break;
2224 case 0x0A:
2225 ret = VBI_CYAN;
2226 break;
2227 case 0x2A:
2228 ret = VBI_WHITE;
2229 break;
2230 }
2231
2232 return ret;
2233}
2234
2235unsigned int
2236dtvcc_unicode (unsigned int c)
2237{
2238 if (unlikely (0 == (c & 0x60))) {
2239 /* C0, C1, C2, C3 */
2240 return 0;
2241 } else if (likely (c < 0x100)) {
2242 /* G0, G1 */
2243 if (unlikely (0xAD == c))
2244 return 0x2D;
2245 else if (unlikely (0x7F == c))
2246 return 0x266A; /* music note */
2247 else
2248 return c;
2249 } else if (c < 0x1080) {
2250 if (unlikely (c < 0x1020))
2251 return 0;
2252 else
2253 return dtvcc_g2[c - 0x1020];
2254 } else if (0x10A0 == c) {
2255 /* We map all G2/G3 characters which are not
2256 representable in Unicode to private code U+E900
2257 ... U+E9FF. */
2258 return 0xf101; /* caption icon */
2259 }
2260
2261 return 0;
2262}
2263
2264static void
2265dtvcc_render(struct dtvcc_decoder * dc, struct dtvcc_service * ds)
2266{
2267#if 0
2268 vbi_event event;
2269 struct tvcc_decoder *td = PARENT(dc, struct tvcc_decoder, dtvcc);
2270 struct dtvcc_window *win[8];
2271 int i, cnt;
2272
2273 //printf("render check\n");
2274
2275 cnt = 8;
2276 dtvcc_get_visible_windows(ds, &cnt, win);
2277 //if (!cnt)
2278 // return;
2279
2280 if (cnt != ds->old_win_cnt) {
2281 //printf("cnt changed\n");
2282 goto changed;
2283 }
2284
2285 for (i = 0; i < cnt; i ++) {
2286 struct dtvcc_window *w1 = win[i];
2287 struct dtvcc_window *w2 = &ds->old_window[i];
2288
2289 if (memcmp(w1->buffer, w2->buffer, sizeof(w1->buffer))) {
2290 //printf("text changed\n");
2291 goto changed;
2292 }
2293
2294 if (memcmp(&w1->style, &w2->style, sizeof(w1->style))) {
2295 //printf("style changed\n");
2296 goto changed;
2297 }
2298
2299 if (memcmp(&w1->curr_pen, &w2->curr_pen, sizeof(w1->curr_pen))) {
2300 //printf("pen changed\n");
2301 goto changed;
2302 }
2303
2304 if (w1->row_count != w2->row_count) {
2305 //printf("row changed\n");
2306 goto changed;
2307 }
2308
2309 if (w1->column_count != w2->column_count) {
2310 //printf("col changed\n");
2311 goto changed;
2312 }
2313
2314 if (w1->visible != w2->visible) {
2315 //printf("vis changed\n");
2316 goto changed;
2317 }
2318 }
2319
2320 return;
2321changed:
2322 for (i = 0; i < cnt; i ++) {
2323 ds->old_window[i] = *win[i];
2324 }
2325 ds->old_win_cnt = cnt;
2326#endif
2327 ds->update = 1;
2328#if 0
2329
2330 event.type = VBI_EVENT_CAPTION;
2331 event.ev.caption.pgno = ds - dc->service + 1 + 8/*after 8 cc channels*/;
2332
2333 /* Permits calling tvcc_fetch_page from handler */
2334 pthread_mutex_unlock(&td->mutex);
2335
2336 vbi_send_event(td->vbi, &event);
2337
2338 pthread_mutex_lock(&td->mutex);
2339#endif
2340}
2341
2342static void
2343dtvcc_reset_service (struct dtvcc_service * ds);
2344
2345static unsigned int
2346dtvcc_window_id (struct dtvcc_service * ds,
2347 struct dtvcc_window * dw)
2348{
2349 return dw - ds->window;
2350}
2351
2352static unsigned int
2353dtvcc_service_num (struct dtvcc_decoder * dc,
2354 struct dtvcc_service * ds)
2355{
2356 return ds - dc->service + 1;
2357}
2358
2359/* Up to eight windows can be visible at once, so which one displays
2360 the caption? Let's take a guess. */
2361static struct dtvcc_window *
2362dtvcc_caption_window (struct dtvcc_service * ds)
2363{
2364 struct dtvcc_window *dw;
2365 unsigned int max_priority;
2366 unsigned int window_id;
2367
2368 dw = NULL;
2369 max_priority = 8;
2370
2371 for (window_id = 0; window_id < 8; ++window_id) {
2372 if (0 == (ds->created & (1 << window_id)))
2373 continue;
2374 if (!ds->window[window_id].visible)
2375 continue;
2376 /*if (DIR_BOTTOM_TOP
2377 != ds->window[window_id].style.scroll_direction)
2378 continue; */
2379 if (ds->window[window_id].priority < max_priority) {
2380 dw = &ds->window[window_id];
2381 max_priority = ds->window[window_id].priority;
2382 }
2383 }
2384
2385 return dw;
2386}
2387
2388static void
2389dtvcc_stream_event (struct dtvcc_decoder * dc,
2390 struct dtvcc_service * ds,
2391 struct dtvcc_window * dw,
2392 unsigned int row)
2393{
2394 vbi_char text[48];
2395 vbi_char ac;
2396 unsigned int column;
2397
2398 if (NULL == dw || dw != dtvcc_caption_window (ds))
2399 return;
2400
2401 /* Note we only stream windows with scroll direction
2402 upwards. */
2403 if (0 != (dw->streamed & (1 << row))
2404 /* || !cc_timestamp_isset (&dw->timestamp_c0)*/)
2405 return;
2406
2407 dw->streamed |= 1 << row;
2408
2409 for (column = 0; column < dw->column_count; ++column) {
2410 if (0 != dw->buffer[row][column])
2411 break;
2412 }
2413
2414 /* Row contains only transparent spaces. */
2415 if (column >= dw->column_count)
2416 return;
2417
2418
2419 dtvcc_render(dc, ds);
2420
2421 /* TO DO. */
2422 CLEAR (ac);
2423 ac.foreground = VBI_WHITE;
2424 ac.background = VBI_BLACK;
2425 ac.opacity = VBI_OPAQUE;
2426
2427 for (column = 0; column < dw->column_count; ++column) {
2428 unsigned int c;
2429
2430 c = dw->buffer[row][column];
2431 if (0 == c) {
2432 ac.unicode = 0x20;
2433 } else {
2434 ac.unicode = dtvcc_unicode (c);
2435 if (0 == ac.unicode) {
2436 ac.unicode = 0x20;
2437 }
2438 }
2439 text[column] = ac;
2440 }
2441
2442 cc_timestamp_reset (&dw->timestamp_c0);
2443}
2444
2445static vbi_bool
2446dtvcc_put_char (struct dtvcc_decoder * dc,
2447 struct dtvcc_service * ds,
2448 unsigned int c)
2449{
2450 struct dtvcc_window *dw;
2451 unsigned int row;
2452 unsigned int column,i;
2453
2454 dc = dc; /* unused */
2455
2456 dw = ds->curr_window;
2457
2458 //printf("putchar %c\n", c);
2459
2460 if (NULL == dw) {
2461 ds->error_line = __LINE__;
2462 //AM_DEBUG(1, "================ window null !!!!!");
2463 return FALSE;
2464 }
2465
2466 column = dw->curr_column;
2467 row = dw->curr_row;
2468
2469 /* FIXME how should we handle TEXT_TAG_NOT_DISPLAYABLE? */
2470
2471 /* Add row column lock support */
2472 switch (dw->style.print_direction) {
2473 case DIR_LEFT_RIGHT:
2474 if (column >= dw->column_count)
2475 {
2476 if (dw->column_lock == 1)
2477 {
2478 if (dw->row_lock == 0)
2479 {
2480 column = 0;
2481 row++;
2482 if (row >= dw->row_count)
2483 {
2484 // row moves up
2485 }
2486 }
2487 else
2488 {
2489 return TRUE;
2490 }
2491 }
2492 else
2493 {
2494 if (column < 32)
2495 {
2496 if (dw->column_no_lock_length < column + 1)
2497 dw->column_no_lock_length = column + 1;
2498 }
2499 else
2500 {
2501 if (dw->row_lock == 1)
2502 return TRUE;
2503 else
2504 {
2505 column = 0;
2506 row++;
2507 if (row >= dw->row_count)
2508 {
2509 // row moves up
2510 }
2511 }
2512 }
2513 }
2514 }
2515 break;
2516 case DIR_RIGHT_LEFT:
2517 case DIR_TOP_BOTTOM:
2518 case DIR_BOTTOM_TOP:
2519 break;
2520 }
2521
2522 dw->buffer[row][column] = c;
2523 dw->pen[row][column] = dw->curr_pen.style;
2524 if (c == 0x1020 || c == 0x1021)
2525 {
2526 if (c == 0x1020)
2527 dw->buffer[row][column] = 0x20;
2528 else
2529 dw->buffer[row][column] = 0xA0;
2530 dw->pen[row][column].bg_opacity = OPACITY_TRANSPARENT;
2531 dw->pen[row][column].fg_opacity = OPACITY_TRANSPARENT;
2532 }
2533 //AM_DEBUG(1, "========= putchar %x %c", c, c);
2534 if (dw->visible)
2535 dtvcc_render(dc, ds);
2536
2537 switch (dw->style.print_direction) {
2538 case DIR_LEFT_RIGHT:
2539 dw->streamed &= ~(1 << row);
2540 if (!cc_timestamp_isset (&dw->timestamp_c0))
2541 dw->timestamp_c0 = ds->timestamp;
2542 ++column;
2543 break;
2544
2545 case DIR_RIGHT_LEFT:
2546 dw->streamed &= ~(1 << row);
2547 if (!cc_timestamp_isset (&dw->timestamp_c0))
2548 dw->timestamp_c0 = ds->timestamp;
2549 column--;
2550
2551 case DIR_TOP_BOTTOM:
2552 dw->streamed &= ~(1 << column);
2553 if (!cc_timestamp_isset (&dw->timestamp_c0))
2554 dw->timestamp_c0 = ds->timestamp;
2555 ++row;
2556
2557 case DIR_BOTTOM_TOP:
2558 dw->streamed &= ~(1 << column);
2559 if (!cc_timestamp_isset (&dw->timestamp_c0))
2560 dw->timestamp_c0 = ds->timestamp;
2561 row--;
2562 }
2563
2564 dw->curr_row = row;
2565 dw->curr_column = column;
2566
2567 return TRUE;
2568}
2569
2570static vbi_bool
2571dtvcc_set_pen_location (struct dtvcc_decoder * dc,
2572 struct dtvcc_service * ds,
2573 const uint8_t * buf)
2574{
2575 struct dtvcc_window *dw;
2576 unsigned int row;
2577 unsigned int column;
2578
2579 dw = ds->curr_window;
2580 if (NULL == dw) {
2581 ds->error_line = __LINE__;
2582 return FALSE;
2583 }
2584
2585 row = buf[1];
2586 /* We check the top four zero bits. */
2587 if (row >= 16) {
2588 ds->error_line = __LINE__;
2589 return FALSE;
2590 }
2591
2592 column = buf[2];
2593 /* We also check the top two zero bits. */
2594 if (column >= 42) {
2595 ds->error_line = __LINE__;
2596 return FALSE;
2597 }
2598
2599 if (row > dw->row_count)
2600 row = dw->row_count - 1;
2601 if (column > dw->column_count)
2602 column = dw->column_count - 1;
2603
2604 if (row != dw->curr_row) {
2605 dtvcc_stream_event (dc, ds, dw, dw->curr_row);
2606 }
2607
2608 /* FIXME there's more. */
2609 dw->curr_row = row;
2610 dw->curr_column = column;
2611
2612 return TRUE;
2613}
2614
2615static vbi_bool
2616dtvcc_set_pen_color (struct dtvcc_service * ds,
2617 const uint8_t * buf)
2618{
2619 struct dtvcc_window *dw;
2620 unsigned int c;
2621
2622 dw = ds->curr_window;
2623 if (NULL == dw) {
2624 ds->error_line = __LINE__;
2625 return FALSE;
2626 }
2627
2628 c = buf[3];
2629 if (0 != (c & 0xC0)) {
2630 ds->error_line = __LINE__;
2631 return FALSE;
2632 }
2633
2634 dw->curr_pen.style.edge_color = c;
2635 c = buf[1];
2636 dw->curr_pen.style.fg_opacity = c >> 6;
2637 dw->curr_pen.style.fg_color = c & 0x3F;
2638 dw->curr_pen.style.fg_flash = ((c>>6)==1)?1:0;
2639 c = buf[2];
2640 dw->curr_pen.style.bg_opacity = c >> 6;
2641 dw->curr_pen.style.bg_color = c & 0x3F;
2642 dw->curr_pen.style.bg_flash = ((c>>6)==1)?1:0;
2643
2644 return TRUE;
2645}
2646
2647static vbi_bool
2648dtvcc_set_pen_attributes (struct dtvcc_service * ds,
2649 const uint8_t * buf)
2650{
2651 struct dtvcc_window *dw;
2652 unsigned int c;
2653 enum pen_size pen_size;
2654 enum offset offset;
2655 enum edge edge_type;
2656
2657 dw = ds->curr_window;
2658 if (NULL == dw) {
2659 ds->error_line = __LINE__;
2660 return FALSE;
2661 }
2662
2663 c = buf[1];
2664 offset = (c >> 2) & 3;
2665 pen_size = c & 3;
2666 //TODO: why not larger than 3
2667 /*
2668 if ((offset | pen_size) >= 3) {
2669 ds->error_line = __LINE__;
2670 return FALSE;
2671 } */
2672
2673 c = buf[2];
2674 edge_type = (c >> 3) & 7;
2675 if (edge_type >= 6) {
2676 ds->error_line = __LINE__;
2677 return FALSE;
2678 }
2679
2680 c = buf[1];
2681 dw->curr_pen.text_tag = c >> 4;
2682 dw->curr_pen.style.offset = offset;
2683 dw->curr_pen.style.pen_size = pen_size;
2684 c = buf[2];
2685 dw->curr_pen.style.italics = c >> 7;
2686 dw->curr_pen.style.underline = (c >> 6) & 1;
2687 dw->curr_pen.style.edge_type = edge_type;
2688 dw->curr_pen.style.font_style = c & 7;
2689
2690 return TRUE;
2691}
2692
2693static vbi_bool
2694dtvcc_set_window_attributes (struct dtvcc_service * ds,
2695 const uint8_t * buf)
2696{
2697 struct dtvcc_window *dw;
2698 unsigned int c;
2699 enum edge border_type;
2700 enum display_effect display_effect;
2701
2702 dw = ds->curr_window;
2703 if (NULL == dw)
2704 return FALSE;
2705
2706 c = buf[2];
2707 border_type = ((buf[3] >> 5) & 0x04) | (c >> 6);
2708 if (border_type >= 6)
2709 return FALSE;
2710
2711 c = buf[4];
2712 display_effect = c & 3;
2713 if (display_effect >= 3)
2714 return FALSE;
2715
2716 c = buf[1];
2717 dw->style.fill_opacity = c >> 6;
2718 dw->style.fill_color = c & 0x3F;
2719 dw->style.window_flash = ((c>>6)==1)?1:0;
2720 c = buf[2];
2721 dw->style.border_type = border_type;
2722 dw->style.border_color = c & 0x3F;
2723 c = buf[3];
2724 dw->style.wordwrap = (c >> 6) & 1;
2725 dw->style.print_direction = (c >> 4) & 3;
2726 dw->style.scroll_direction = (c >> 2) & 3;
2727 dw->style.justify = c & 3;
2728 c = buf[4];
2729 dw->style.effect_speed = c >> 4;
2730 dw->style.effect_direction = (c >> 2) & 3;
2731 dw->style.display_effect = display_effect;
2732
2733 return TRUE;
2734}
2735
2736static vbi_bool
2737dtvcc_clear_windows (struct dtvcc_decoder * dc,
2738 struct dtvcc_service * ds,
2739 dtvcc_window_map window_map)
2740{
2741 unsigned int i;
2742
2743 window_map &= ds->created;
2744
2745 for (i = 0; i < 8; ++i) {
2746 struct dtvcc_window *dw;
2747
2748 if (0 == (window_map & (1 << i)))
2749 continue;
2750
2751 dw = &ds->window[i];
2752
2753 dtvcc_stream_event (dc, ds, dw, dw->curr_row);
2754
2755 memset (dw->buffer, 0, sizeof (dw->buffer));
2756 memset (dw->pen, 0, sizeof(dw->pen));
2757
2758 dw->curr_column = 0;
2759 dw->curr_row = 0;
2760
2761 dw->streamed = 0;
2762 dw->style.display_effect = 0;
2763 dw->effect_status = 0;
2764 if (dw->visible)
2765 dtvcc_render(dc, ds);
2766
2767 /* FIXME CEA 708-C Section 7.1.4 (Form Feed)
2768 and 8.10.5.3 confuse me. */
2769 if (0) {
2770 dw->curr_column = 0;
2771 dw->curr_row = 0;
2772 }
2773 }
2774
2775 return TRUE;
2776}
2777
2778static vbi_bool
2779dtvcc_define_window (struct dtvcc_decoder * dc,
2780 struct dtvcc_service * ds,
2781 uint8_t * buf)
2782{
2783 static const struct dtvcc_window_style window_styles [7] = {
2784 {
2785 JUSTIFY_LEFT, DIR_LEFT_RIGHT, DIR_BOTTOM_TOP,
2786 FALSE, DISPLAY_EFFECT_SNAP, 0, 0, 0,
2787 OPACITY_SOLID, EDGE_NONE, 0
2788 }, {
2789 JUSTIFY_LEFT, DIR_LEFT_RIGHT, DIR_BOTTOM_TOP,
2790 FALSE, DISPLAY_EFFECT_SNAP, 0, 0, 0,
2791 OPACITY_TRANSPARENT, EDGE_NONE, 0
2792 }, {
2793 JUSTIFY_CENTER, DIR_LEFT_RIGHT, DIR_BOTTOM_TOP,
2794 FALSE, DISPLAY_EFFECT_SNAP, 0, 0, 0,
2795 OPACITY_SOLID, EDGE_NONE, 0
2796 }, {
2797 JUSTIFY_LEFT, DIR_LEFT_RIGHT, DIR_BOTTOM_TOP,
2798 TRUE, DISPLAY_EFFECT_SNAP, 0, 0, 0,
2799 OPACITY_SOLID, EDGE_NONE, 0
2800 }, {
2801 JUSTIFY_LEFT, DIR_LEFT_RIGHT, DIR_BOTTOM_TOP,
2802 TRUE, DISPLAY_EFFECT_SNAP, 0, 0, 0,
2803 OPACITY_TRANSPARENT, EDGE_NONE, 0
2804 }, {
2805 JUSTIFY_CENTER, DIR_LEFT_RIGHT, DIR_BOTTOM_TOP,
2806 TRUE, DISPLAY_EFFECT_SNAP, 0, 0, 0,
2807 OPACITY_SOLID, EDGE_NONE, 0
2808 }, {
2809 JUSTIFY_LEFT, DIR_TOP_BOTTOM, DIR_RIGHT_LEFT,
2810 FALSE, DISPLAY_EFFECT_SNAP, 0, 0, 0,
2811 OPACITY_SOLID, EDGE_NONE, 0
2812 }
2813 };
2814 static const struct dtvcc_pen_style pen_styles [7] = {
2815 {
2816 PEN_SIZE_STANDARD, 0, OFFSET_NORMAL, FALSE,
2817 FALSE, EDGE_NONE, 0x3F, OPACITY_SOLID,
2818 0x00, OPACITY_SOLID, 0
2819 }, {
2820 PEN_SIZE_STANDARD, 1, OFFSET_NORMAL, FALSE,
2821 FALSE, EDGE_NONE, 0x3F, OPACITY_SOLID,
2822 0x00, OPACITY_SOLID, 0
2823 }, {
2824 PEN_SIZE_STANDARD, 2, OFFSET_NORMAL, FALSE,
2825 FALSE, EDGE_NONE, 0x3F, OPACITY_SOLID,
2826 0x00, OPACITY_SOLID, 0
2827 }, {
2828 PEN_SIZE_STANDARD, 3, OFFSET_NORMAL, FALSE,
2829 FALSE, EDGE_NONE, 0x3F, OPACITY_SOLID,
2830 0x00, OPACITY_SOLID, 0
2831 }, {
2832 PEN_SIZE_STANDARD, 4, OFFSET_NORMAL, FALSE,
2833 FALSE, EDGE_NONE, 0x3F, OPACITY_SOLID,
2834 0x00, OPACITY_SOLID, 0
2835 }, {
2836 PEN_SIZE_STANDARD, 3, OFFSET_NORMAL, FALSE,
2837 FALSE, EDGE_UNIFORM, 0x3F, OPACITY_SOLID,
2838 0, OPACITY_TRANSPARENT, 0x00
2839 }, {
2840 PEN_SIZE_STANDARD, 4, OFFSET_NORMAL, FALSE,
2841 FALSE, EDGE_UNIFORM, 0x3F, OPACITY_SOLID,
2842 0, OPACITY_TRANSPARENT, 0x00
2843 }
2844 };
2845 struct dtvcc_window *dw;
2846 dtvcc_window_map window_map;
2847 vbi_bool anchor_relative;
2848 unsigned int anchor_vertical;
2849 unsigned int anchor_horizontal;
2850 unsigned int anchor_point;
2851 unsigned int column_count_m1;
2852 unsigned int window_id;
2853 unsigned int window_style_id;
2854 unsigned int pen_style_id;
2855 unsigned int c;
2856
2857 //printf("define window\n");
2858
2859 if (0 != ((buf[1] | buf[6]) & 0xC0)) {
2860 ds->error_line = __LINE__;
2861 return FALSE;
2862 }
2863
2864 c = buf[2];
2865 anchor_relative = (c >> 7) & 1;
2866 anchor_vertical = c & 0x7F;
2867 anchor_horizontal = buf[3];
2868 if (0 == anchor_relative) {
2869 if (unlikely (anchor_vertical >= 75
2870 || anchor_horizontal >= 210)) {
2871 ds->error_line = __LINE__;
2872 return FALSE;
2873 }
2874 } else {
2875 if (unlikely (anchor_vertical >= 100
2876 || anchor_horizontal >= 100)) {
2877 ds->error_line = __LINE__;
2878 return FALSE;
2879 }
2880 }
2881
2882 c = buf[4];
2883 anchor_point = c >> 4;
2884 if (unlikely (anchor_point >= 9)) {
2885 ds->error_line = __LINE__;
2886 return FALSE;
2887 }
2888
2889 //printf("define window %d\n", column_count_m1);
2890
2891 column_count_m1 = buf[5];
2892 /* We also check the top two zero bits. */
2893 if (unlikely (column_count_m1 >= 42)) {
2894 ds->error_line = __LINE__;
2895 return FALSE;
2896 }
2897 //printf("define windowa\n");
2898
2899 window_id = buf[0] & 7;
2900 dw = &ds->window[window_id];
2901 window_map = 1 << window_id;
2902
2903 ds->curr_window = dw;
2904
2905 c = buf[1];
2906 dw->visible = (c >> 5) & 1;
2907 dw->row_lock = (c >> 4) & 1;
2908 dw->column_lock = (c >> 3) & 1;
2909 dw->priority = c & 7;
2910
2911 dw->anchor_relative = anchor_relative;
2912 dw->anchor_vertical = anchor_vertical;
2913 dw->anchor_horizontal = anchor_horizontal;
2914 dw->anchor_point = anchor_point;
2915
2916 c = buf[4];
2917 dw->row_count = (c & 15) + 1;
2918 dw->column_count = column_count_m1 + 1;
2919 dw->column_no_lock_length = 0;
2920
2921 c = buf[6];
2922 window_style_id = (c >> 3) & 7;
2923 pen_style_id = c & 7;
2924
2925 if (window_style_id > 0) {
2926 dw->style = window_styles[window_style_id-1];
2927 } else if (0 == (ds->created & window_map)) {
2928 dw->style = window_styles[1];
2929 }
2930
2931 if (pen_style_id > 0) {
2932 dw->curr_pen.style = pen_styles[pen_style_id];
2933 } else if (0 == (ds->created & window_map)) {
2934 dw->curr_pen.style = pen_styles[1];
2935 }
2936
2937 if (0 != (ds->created & window_map))
2938 return TRUE;
2939
2940 /* Has to be something, no? */
2941 dw->curr_pen.text_tag = TEXT_TAG_NOT_DISPLAYABLE;
2942
2943 dw->curr_column = 0;
2944 dw->curr_row = 0;
2945
2946 dw->streamed = 0;
2947
2948 cc_timestamp_reset (&dw->timestamp_c0);
2949
2950 ds->created |= window_map;
2951
2952 //printf("define %x %x\n", ds->curr_window, ds->created);
2953
2954 return dtvcc_clear_windows (dc, ds, window_map);
2955}
2956
2957static vbi_bool
2958dtvcc_display_windows (struct dtvcc_decoder * dc,
2959 struct dtvcc_service * ds,
2960 unsigned int c,
2961 dtvcc_window_map window_map)
2962{
2963 unsigned int i;
2964
2965 window_map &= ds->created;
2966
2967 //printf("display %02x %p %02x\n", c, ds->curr_window, ds->created);
2968 if (ds->curr_window == NULL && ds->created == 0) {
2969 return FALSE;
2970 //return TRUE;
2971 }
2972
2973 for (i = 0; i < 8; ++i) {
2974 struct dtvcc_window *dw;
2975 vbi_bool was_visible;
2976
2977 if (0 == (window_map & (1 << i)))
2978 continue;
2979
2980 dw = &ds->window[i];
2981 was_visible = dw->visible;
2982
2983 switch (c) {
2984 case 0x89: /* DSW DisplayWindows */
2985 dw->visible = TRUE;
2986 dw->effect_status = CC_EFFECT_DISPLAY;
2987 break;
2988
2989 case 0x8A: /* HDW HideWindows */
2990 dw->visible = FALSE;
2991 dw->effect_status = CC_EFFECT_HIDE;
2992 break;
2993
2994 case 0x8B: /* TGW ToggleWindows */
2995 dw->visible = was_visible ^ TRUE;
2996 dw->effect_status =
2997 (dw->visible == TRUE)?CC_EFFECT_DISPLAY:CC_EFFECT_HIDE;
2998 break;
2999 }
3000
3001 clock_gettime(CLOCK_REALTIME, &dw->effect_timer);
3002
3003 if (!was_visible) {
3004 unsigned int row;
3005
3006 dw->timestamp_c0 = ds->timestamp;
3007 for (row = 0; row < dw->row_count; ++row) {
3008 dtvcc_stream_event (dc, ds, dw, row);
3009 }
3010 }
3011 }
3012
3013 dtvcc_render(dc, ds);
3014
3015 return TRUE;
3016}
3017
3018static vbi_bool
3019dtvcc_carriage_return (struct dtvcc_decoder * dc,
3020 struct dtvcc_service * ds)
3021{
3022 struct dtvcc_window *dw;
3023 unsigned int row;
3024 unsigned int column;
3025
3026 dw = ds->curr_window;
3027 if (NULL == dw) {
3028 ds->error_line = __LINE__;
3029 return FALSE;
3030 }
3031
3032 dtvcc_stream_event (dc, ds, dw, dw->curr_row);
3033
3034 row = dw->curr_row;
3035 column = dw->curr_column;
3036
3037 switch (dw->style.scroll_direction) {
3038 case DIR_LEFT_RIGHT:
3039 if (dw->style.print_direction == DIR_BOTTOM_TOP)
3040 {
3041 dw->curr_row = dw->row_count - 1;
3042 if (column > 0) {
3043 dw->curr_column = column - 1;
3044 break;
3045 }
3046 }
3047 else
3048 {
3049 dw->curr_row = 0;
3050 if (column > 0) {
3051 dw->curr_column = column - 1;
3052 break;
3053 }
3054 }
3055 dw->streamed = (dw->streamed << 1)
3056 & ~(1 << dw->column_count);
3057 for (row = 0; row < dw->row_count; ++row) {
3058 for (column = dw->column_count - 1;
3059 column > 0; --column) {
3060 dw->buffer[row][column] =
3061 dw->buffer[row][column - 1];
3062 dw->pen[row][column] =
3063 dw->pen[row][column - 1];
3064 }
3065 dw->buffer[row][column] = 0;
3066 memset(&dw->pen[row][column], 0, sizeof(dw->pen[0][0]));
3067 }
3068 break;
3069
3070 case DIR_RIGHT_LEFT:
3071 if (dw->style.print_direction == DIR_BOTTOM_TOP)
3072 {
3073 dw->curr_row = dw->row_count - 1;
3074 if (column + 1 < dw->row_count) {
3075 dw->curr_column = column + 1;
3076 break;
3077 }
3078 }
3079 else
3080 {
3081 dw->curr_row = 0;
3082 if (column + 1 < dw->row_count) {
3083 dw->curr_column = column + 1;
3084 break;
3085 }
3086 }
3087 dw->streamed >>= 1;
3088 for (row = 0; row < dw->row_count; ++row) {
3089 for (column = 0;
3090 column < dw->column_count - 1; ++column) {
3091 dw->buffer[row][column] =
3092 dw->buffer[row][column + 1];
3093 dw->pen[row][column] =
3094 dw->pen[row][column + 1];
3095 }
3096 dw->buffer[row][column] = 0;
3097 memset(&dw->pen[row][column], 0, sizeof(dw->pen[0][0]));
3098 }
3099 break;
3100
3101 case DIR_TOP_BOTTOM:
3102 if (dw->style.print_direction == DIR_RIGHT_LEFT)
3103 {
3104 AM_DEBUG(0, "CR: print_r_l cur_col %d row %d", dw->curr_column, dw->curr_row);
3105 dw->curr_column = dw->column_count - 1;
3106 if (row > 0) {
3107 dw->curr_row = row - 1;
3108 break;
3109 }
3110 }
3111 else
3112 {
3113 dw->curr_column = 0;
3114 if (row > 0) {
3115 dw->curr_row = row - 1;
3116 break;
3117 }
3118 }
3119 dw->streamed = (dw->streamed << 1)
3120 & ~(1 << dw->row_count);
3121 memmove (&dw->buffer[1], &dw->buffer[0],
3122 sizeof (dw->buffer[0]) * (dw->row_count - 1));
3123 memmove (&dw->pen[1], &dw->pen[0],
3124 sizeof (dw->pen[0]) * (dw->row_count - 1));
3125 memset (&dw->buffer[0], 0, sizeof (dw->buffer[0]));
3126 memset (&dw->pen[0], 0, sizeof(dw->pen[0]));
3127 break;
3128
3129 case DIR_BOTTOM_TOP:
3130 if (dw->style.print_direction == DIR_RIGHT_LEFT)
3131 {
3132 dw->curr_column = dw->column_count - 1;;
3133 if (row + 1 < dw->row_count) {
3134 dw->curr_row = row + 1;
3135 break;
3136 }
3137 }
3138 else
3139 {
3140 dw->curr_column = 0;
3141 if (row + 1 < dw->row_count) {
3142 dw->curr_row = row + 1;
3143 break;
3144 }
3145 }
3146 dw->streamed >>= 1;
3147 memmove (&dw->buffer[0], &dw->buffer[1],
3148 sizeof (dw->buffer[0]) * (dw->row_count - 1));
3149 memmove (&dw->pen[0], &dw->pen[1],
3150 sizeof (dw->pen[0]) * (dw->row_count - 1));
3151 memset (&dw->buffer[row], 0, sizeof (dw->buffer[0]));
3152 memset (&dw->pen[row], 0, sizeof (dw->pen[0]));
3153 break;
3154 }
3155
3156 return TRUE;
3157}
3158
3159static vbi_bool
3160dtvcc_form_feed (struct dtvcc_decoder * dc,
3161 struct dtvcc_service * ds)
3162{
3163 struct dtvcc_window *dw;
3164 dtvcc_window_map window_map;
3165
3166 dw = ds->curr_window;
3167 if (NULL == dw) {
3168 ds->error_line = __LINE__;
3169 return FALSE;
3170 }
3171
3172 window_map = 1 << dtvcc_window_id (ds, dw);
3173
3174 if (!dtvcc_clear_windows (dc, ds, window_map))
3175 return FALSE;
3176
3177 dw->curr_row = 0;
3178 dw->curr_column = 0;
3179
3180 return TRUE;
3181}
3182
3183static vbi_bool
3184dtvcc_backspace (struct dtvcc_decoder * dc,
3185 struct dtvcc_service * ds)
3186{
3187 struct dtvcc_window *dw;
3188 unsigned int row;
3189 unsigned int column;
3190 unsigned int mask;
3191
3192 dc = dc; /* unused */
3193
3194 dw = ds->curr_window;
3195 if (NULL == dw) {
3196 ds->error_line = __LINE__;
3197 return FALSE;
3198 }
3199
3200 row = dw->curr_row;
3201 column = dw->curr_column;
3202
3203 switch (dw->style.print_direction) {
3204 case DIR_LEFT_RIGHT:
3205 mask = 1 << row;
3206 if (column-- <= 0)
3207 return TRUE;
3208 break;
3209
3210 case DIR_RIGHT_LEFT:
3211 mask = 1 << row;
3212 if (++column >= dw->column_count)
3213 return TRUE;
3214 break;
3215
3216 case DIR_TOP_BOTTOM:
3217 mask = 1 << column;
3218 if (row-- <= 0)
3219 return TRUE;
3220 break;
3221
3222 case DIR_BOTTOM_TOP:
3223 mask = 1 << column;
3224 if (++row >= dw->row_count)
3225 return TRUE;
3226 break;
3227 }
3228
3229 if (0 != dw->buffer[row][column]) {
3230 dw->streamed &= ~mask;
3231 dw->buffer[row][column] = 0;
3232 memset(&dw->pen[row][column], 0, sizeof(dw->pen[0][0]));
3233 }
3234
3235 dw->curr_row = row;
3236 dw->curr_column = column;
3237
3238 return TRUE;
3239}
3240
3241static vbi_bool
3242dtvcc_hor_carriage_return (struct dtvcc_decoder * dc,
3243 struct dtvcc_service * ds)
3244{
3245 struct dtvcc_window *dw;
3246 unsigned int row;
3247 unsigned int column;
3248 unsigned int mask;
3249
3250 dc = dc; /* unused */
3251
3252 dw = ds->curr_window;
3253 if (NULL == dw) {
3254 ds->error_line = __LINE__;
3255 return FALSE;
3256 }
3257
3258 row = dw->curr_row;
3259 column = dw->curr_column;
3260
3261 switch (dw->style.print_direction) {
3262 case DIR_LEFT_RIGHT:
3263 case DIR_RIGHT_LEFT:
3264 mask = 1 << row;
3265 memset (&dw->buffer[row][0], 0,
3266 sizeof (dw->buffer[0]));
3267 memset (&dw->pen[row][0], 0,
3268 sizeof (dw->pen[0]));
3269 if (DIR_LEFT_RIGHT == dw->style.print_direction)
3270 dw->curr_column = 0;
3271 else
3272 dw->curr_column = dw->column_count - 1;
3273 break;
3274
3275 case DIR_TOP_BOTTOM:
3276 case DIR_BOTTOM_TOP:
3277 mask = 1 << column;
3278 for (row = 0; row < dw->column_count; ++row) {
3279 dw->buffer[row][column] = 0;
3280 memset(&dw->pen[row][column], 0, sizeof(dw->pen[0][0]));
3281 }
3282 if (DIR_TOP_BOTTOM == dw->style.print_direction)
3283 dw->curr_row = 0;
3284 else
3285 dw->curr_row = dw->row_count - 1;
3286 break;
3287 }
3288
3289 dw->streamed &= ~mask;
3290
3291 return TRUE;
3292}
3293
3294static vbi_bool
3295dtvcc_delete_windows (struct dtvcc_decoder * dc,
3296 struct dtvcc_service * ds,
3297 dtvcc_window_map window_map)
3298{
3299 struct dtvcc_window *dw;
3300 int i;
3301 int changed = 0;
3302
3303 for (i = 0; i < N_ELEMENTS(ds->window); i ++) {
3304 dw = &ds->window[i];
3305
3306 if (NULL != dw) {
3307 unsigned int window_id;
3308 window_id = dtvcc_window_id (ds, dw);
3309 if (ds->created & (1 << window_id)) {
3310 if (window_map & (1 << window_id)) {
3311 //printf("delete window %d\n", window_id);
3312 dtvcc_stream_event (dc, ds, dw, dw->curr_row);
3313
3314 if (dw == ds->curr_window)
3315 ds->curr_window = NULL;
3316
3317 if (dw->visible)
3318 dtvcc_render(dc, ds);
3319
3320 memset (dw->buffer, 0, sizeof (dw->buffer));
3321 memset (dw->pen, 0, sizeof(dw->pen));
3322 dw->visible = 0;
3323 dw->effect_status = 0;
3324 dw->effect_percent = 0;
3325 dw->style.display_effect = 0;
3326
3327 changed = 1;
3328 }
3329 }
3330 }
3331 }
3332
3333 ds->created &= ~window_map;
3334
3335 return TRUE;
3336}
3337
3338static vbi_bool
3339dtvcc_delay_cmd (struct dtvcc_decoder * dc,
3340 struct dtvcc_service * ds,
3341 uint8_t delay_cmd,
3342 uint8_t delay_time)
3343{
3344 struct timespec now_ts;
3345 int plus_one_second = 0;
3346 clock_gettime(CLOCK_REALTIME, &now_ts);
3347 if (delay_cmd == 0x8D)
3348 {
3349 /* Set trigger time
3350 Until that time, sevice stop decoding.
3351 */
3352 /* Delay time is tenths of second */
3353 /* We set the timer a little faster to avoid double delay conflict */
3354 if ((1000000000 - (delay_time%10) * 100000000) > now_ts.tv_nsec)
3355 {
3356 ds->delay_timer.tv_nsec = ((delay_time % 10) * 100000000 + now_ts.tv_nsec) % 1000000000;
3357 ds->delay_timer.tv_sec = (1 + now_ts.tv_sec + delay_time/10) -1;
3358 }
3359 else
3360 {
3361 ds->delay_timer.tv_nsec = (delay_time % 10) * 100000000 + now_ts.tv_nsec;
3362 ds->delay_timer.tv_sec = (now_ts.tv_sec + delay_time / 10) -1;
3363 }
3364 ds->delay_timer.tv_sec = now_ts.tv_sec + 1;
3365 ds->delay = 1;
3366 ds->delay_cancel = 0;
3367 //AM_DEBUG(1, "Enter delay cmd, now %d until %d", now_ts.tv_sec, ds->delay_timer.tv_sec);
3368 }
3369 else if (delay_cmd == 0x8E)
3370 {
3371 ds->delay = 0;
3372 ds->delay_cancel = 1;
3373 }
3374 return TRUE;
3375}
3376
3377static vbi_bool
3378dtvcc_command (struct dtvcc_decoder * dc,
3379 struct dtvcc_service * ds,
3380 unsigned int * se_length,
3381 uint8_t * buf,
3382 unsigned int n_bytes)
3383{
3384 unsigned int c;
3385 unsigned int window_id;
3386
3387 c = buf[0];
3388 if ((int8_t) c < 0) {
3389 *se_length = dtvcc_c1_length[c - 0x80];
3390 } else {
3391 *se_length = dtvcc_c0_length[c >> 3];
3392 }
3393
3394 if (*se_length > n_bytes) {
3395 ds->error_line = __LINE__;
3396 return TRUE;
3397 }
3398 switch (c) {
3399 case 0x08: /* BS Backspace */
3400 return dtvcc_backspace (dc, ds);
3401
3402 case 0x0C: /* FF Form Feed */
3403 return dtvcc_form_feed (dc, ds);
3404
3405 case 0x0D: /* CR Carriage Return */
3406 return dtvcc_carriage_return (dc, ds);
3407
3408 case 0x0E: /* HCR Horizontal Carriage Return */
3409 return dtvcc_hor_carriage_return (dc, ds);
3410
3411 case 0x80 ... 0x87: /* CWx SetCurrentWindow */
3412 window_id = c & 7;
3413 if (0 == (ds->created & (1 << window_id))) {
3414 ds->error_line = __LINE__;
3415 return FALSE;
3416 }
3417 ds->curr_window = &ds->window[window_id];
3418 return TRUE;
3419
3420 case 0x88: /* CLW ClearWindows */
3421 return dtvcc_clear_windows (dc, ds, buf[1]);
3422
3423 case 0x89: /* DSW DisplayWindows */
3424 return dtvcc_display_windows (dc, ds, c, buf[1]);
3425
3426 case 0x8D:
3427 dtvcc_delay_cmd(dc, ds, 0x8d, buf[1]);
3428 return 0;
3429
3430 case 0x8E:
3431 dtvcc_delay_cmd(dc, ds, 0x8e, buf[1]);
3432 return 0;
3433
3434 case 0x8A: /* HDW HideWindows */
3435 return dtvcc_display_windows (dc, ds, c, buf[1]);
3436
3437 case 0x8B: /* TGW ToggleWindows */
3438 return dtvcc_display_windows (dc, ds, c, buf[1]);
3439
3440 case 0x8C: /* DLW DeleteWindows */
3441 return dtvcc_delete_windows (dc, ds, buf[1]);
3442
3443 case 0x8F: /* RST Reset */
3444 dtvcc_reset_service (ds);
3445 return TRUE;
3446
3447 case 0x90: /* SPA SetPenAttributes */
3448 return dtvcc_set_pen_attributes (ds, buf);
3449
3450 case 0x91: /* SPC SetPenColor */
3451 return dtvcc_set_pen_color (ds, buf);
3452
3453 case 0x92: /* SPL SetPenLocation */
3454 return dtvcc_set_pen_location (dc, ds, buf);
3455
3456 case 0x97: /* SWA SetWindowAttributes */
3457 return dtvcc_set_window_attributes (ds, buf);
3458
3459 case 0x98 ... 0x9F: /* DFx DefineWindow */
3460 return dtvcc_define_window (dc, ds, buf);
3461
3462 default:
3463 return TRUE;
3464 }
3465}
3466
3467static vbi_bool
3468dtvcc_decode_se (struct dtvcc_decoder * dc,
3469 struct dtvcc_service * ds,
3470 unsigned int * se_length,
3471 uint8_t * buf,
3472 unsigned int n_bytes)
3473{
3474 unsigned int c;
3475
3476 c = buf[0];
3477 if (likely (0 != (c & 0x60))) {
3478 /* G0/G1 character. */
3479 *se_length = 1;
3480 return dtvcc_put_char (dc, ds, c);
3481 }
3482
3483 if (0x10 != c) {
3484 /* C0/C1 control code. */
3485 return dtvcc_command (dc, ds, se_length,
3486 buf, n_bytes);
3487 }
3488
3489 if (unlikely (n_bytes < 2)) {
3490 ds->error_line = __LINE__;
3491 return FALSE;
3492 }
3493
3494 c = buf[1];
3495 if (likely (0 != (c & 0x60))) {
3496 /* G2/G3 character. */
3497 *se_length = 2;
3498 return dtvcc_put_char (dc, ds, 0x1000 | c);
3499 }
3500
3501 /* CEA 708-C defines no C2 or C3 commands. */
3502
3503 if ((int8_t) c >= 0) {
3504 /* C2 code. */
3505 *se_length = (c >> 3) + 2;
3506 } else if (c < 0x90) {
3507 /* C3 Fixed Length Commands. */
3508 *se_length = (c >> 3) - 10;
3509 } else {
3510 /* C3 Variable Length Commands. */
3511
3512 if (unlikely (n_bytes < 3)) {
3513 ds->error_line = __LINE__;
3514 return FALSE;
3515 }
3516
3517 /* type [2], zero_bit [1],
3518 length [5] */
3519 *se_length = (buf[2] & 0x1F) + 3;
3520 }
3521
3522 if (unlikely (n_bytes < *se_length)) {
3523 ds->error_line = __LINE__;
3524 return FALSE;
3525 }
3526
3527 return TRUE;
3528}
3529
3530static vbi_bool
3531dtvcc_decode_syntactic_elements (struct dtvcc_decoder * dc,
3532 struct dtvcc_service * ds,
3533 uint8_t * buf,
3534 unsigned int n_bytes)
3535{
3536 ds->timestamp = dc->timestamp;
3537 struct timespec ts_now;
3538
3539#if 0
3540 AM_DEBUG(1, "+++++++++++++++++++++ servie %d\n", n_bytes);
3541 {
3542 int i;
3543
3544 for (i = 0; i < n_bytes; i ++)
3545 AM_DEBUG(1, "++++++++++++++ %02x ", buf[i]);
3546 }
3547#endif
3548 while (n_bytes > 0) {
3549 unsigned int se_length;
3550
3551 //printf("dec se %02x\n", buf[0]);
3552
3553 if (!dtvcc_decode_se (dc, ds,
3554 &se_length,
3555 buf, n_bytes)) {
3556 return FALSE;
3557 }
3558
3559 buf += se_length;
3560 n_bytes -= se_length;
3561 }
3562
3563 return TRUE;
3564}
3565
3566static void
3567dtvcc_try_decode_channels (struct dtvcc_decoder *dc)
3568{
3569 int i;
3570
3571 for (i = 0; i < 6; ++i) {
3572 struct dtvcc_service *ds;
3573 struct program *pr;
3574 vbi_bool success;
3575
3576 ds = &dc->service[i];
3577 if (0 == ds->service_data_in)
3578 continue;
3579 if (!ds->delay ||
3580 (ds->delay && ds->service_data_in>=128))
3581 {
3582 //AM_DEBUG(1, "service datain %d", ds->service_data_in);
3583 success = dtvcc_decode_syntactic_elements
3584 (dc, ds, ds->service_data, ds->service_data_in);
3585 if (ds->service_data_in >= 128)
3586 {
3587 ds->delay = 0;
3588 ds->delay_cancel = 0;
3589 }
3590 ds->service_data_in = 0;
3591
3592 if (success)
3593 continue;
3594 }
3595 //dtvcc_reset_service (ds);
3596 //dc->next_sequence_number = -1;
3597 }
3598}
3599
3600void
3601dtvcc_decode_packet (struct dtvcc_decoder * dc,
3602 const struct timeval * tv,
3603 int64_t pts)
3604{
3605 unsigned int packet_size_code;
3606 unsigned int packet_size;
3607 unsigned int i;
3608
3609#if 0
3610 printf("%d dtvcc decode packet %d: ", get_input_offset(), dc->packet_size);
3611
3612 for (i = 0; i < dc->packet_size; i ++) {
3613 printf("%02x ", dc->packet[i]);
3614 }
3615 printf("\n");
3616#endif
3617 dc->timestamp.sys = *tv;
3618 dc->timestamp.pts = pts;
3619
3620 /* Packet Layer. */
3621
3622 /* sequence_number [2], packet_size_code [6],
3623 packet_data [n * 8] */
3624#if 0
3625 if (dc->next_sequence_number >= 0
3626 && 0 != ((dc->packet[0] ^ dc->next_sequence_number) & 0xC0)) {
3627 dtvcc_reset (dc);
3628 return;
3629 }
3630#endif
3631 dc->next_sequence_number = dc->packet[0] + 0x40;
3632
3633 packet_size_code = dc->packet[0] & 0x3F;
3634 packet_size = 128;
3635 if (packet_size_code > 0)
3636 packet_size = packet_size_code * 2;
3637
3638 /* CEA 708-C Section 5: Apparently packet_size need not be
3639 equal to the actually transmitted amount of data. */
3640 if (packet_size > dc->packet_size) {
3641 /*
3642 dtvcc_reset (dc);
3643 return;*/
3644 packet_size = dc->packet_size;
3645 }
3646
3647 /* Service Layer. */
3648
3649 /* CEA 708-C Section 6.2.5, 6.3: Service Blocks and syntactic
3650 elements must not cross Caption Channel Packet
3651 boundaries. */
3652
3653 for (i = 1; i < packet_size;) {
3654 unsigned int service_number;
3655 unsigned int block_size;
3656 unsigned int header_size;
3657 unsigned int c;
3658
3659 header_size = 1;
3660
3661 /* service_number [3], block_size [5],
3662 (null_fill [2], extended_service_number [6]),
3663 (Block_data [n * 8]) */
3664
3665 c = dc->packet[i];
3666 service_number = (c & 0xE0) >> 5;
3667
3668 //printf("srv %d\n", service_number);
3669
3670 /* CEA 708-C Section 6.3: Ignore block_size if
3671 service_number is zero. */
3672 if (0 == service_number) {
3673 /* NULL Service Block Header, no more data in
3674 this Caption Channel Packet. */
3675 break;
3676 }
3677
3678 /* CEA 708-C Section 6.2.1: Apparently block_size zero
3679 is valid, although properly it should only occur in
3680 NULL Service Block Headers. */
3681 block_size = c & 0x1F;
3682
3683 if (7 == service_number) {
3684 if (i + 1 > packet_size)
3685 break;
3686
3687 header_size = 2;
3688 c = dc->packet[i + 1];
3689
3690 /* We also check the null_fill bits. */
3691 if (c < 7 || c > 63)
3692 break;
3693
3694 service_number = c;
3695 }
3696
3697 //printf("srv %d %d %d %d\n", service_number, header_size, block_size, packet_size);
3698
3699 if (i + header_size + block_size > packet_size)
3700 {
3701 break;
3702 }
3703
3704 if (service_number <= 6) {
3705 struct dtvcc_service *ds;
3706 unsigned int in;
3707
3708 ds = &dc->service[service_number - 1];
3709 in = ds->service_data_in;
3710 memcpy (ds->service_data + in,
3711 dc->packet + i + header_size,
3712 block_size);
3713 ds->service_data_in = in + block_size;
3714 }
3715
3716 i += header_size + block_size;
3717 }
3718
3719 dtvcc_try_decode_channels(dc);
3720 return;
3721}
3722
3723static int
3724dtvcc_get_se_len (unsigned char *p, int left)
3725{
3726 unsigned char c;
3727 int se_length;
3728
3729 if (left < 1)
3730 return 0;
3731
3732 c = p[0];
3733
3734 if ((c == 0x8d) && (c == 0x8e))
3735 return 1;
3736
3737 if (0 != (c & 0x60))
3738 return 1;
3739
3740 if (0x10 != c) {
3741 if ((int8_t) c < 0) {
3742 se_length = dtvcc_c1_length[c - 0x80];
3743 } else {
3744 se_length = dtvcc_c0_length[c >> 3];
3745 }
3746
3747 if (left < se_length)
3748 return 0;
3749
3750 return se_length;
3751 }
3752
3753 if (left < 2)
3754 return 0;
3755
3756 c = p[1];
3757 if (0 != (c & 0x60))
3758 return 2;
3759
3760 if ((int8_t) c >= 0) {
3761 se_length = (c >> 3) + 2;
3762 } else if (c < 0x90) {
3763 se_length = (c >> 3) - 10;
3764 } else {
3765 if (left < 3)
3766 return 0;
3767
3768 se_length = (p[2] & 0x1F) + 3;
3769 }
3770
3771 if (left < se_length)
3772 return 0;
3773
3774 return se_length;
3775}
3776
3777void
3778dtvcc_try_decode_packet (struct dtvcc_decoder * dc,
3779 const struct timeval * tv,
3780 int64_t pts)
3781{
3782 unsigned int packet_size_code;
3783 unsigned int packet_size;
3784 unsigned char *p;
3785 int left;
3786
3787 if (dc->packet_size < 1)
3788 return;
3789
3790 packet_size_code = dc->packet[0] & 0x3F;
3791
3792 packet_size = 128;
3793 if (packet_size_code > 0)
3794 packet_size = packet_size_code * 2;
3795
3796 if (packet_size <= dc->packet_size) {
3797 dtvcc_decode_packet(dc, tv, pts);
3798 dc->packet_size = 0;
3799 return;
3800 }
3801
3802 p = dc->packet + 1;
3803 left = dc->packet_size - 1;
3804 while (left > 0) {
3805 unsigned int service_number;
3806 unsigned int block_size;
3807 unsigned int header_size;
3808 unsigned int c;
3809
3810 header_size = 1;
3811
3812 c = p[0];
3813 service_number = (c & 0xE0) >> 5;
3814 if (0 == service_number)
3815 break;
3816
3817 block_size = c & 0x1F;
3818
3819 if (7 == service_number) {
3820 if (left < 2)
3821 break;
3822
3823 header_size = 2;
3824 c = p[1];
3825
3826 if (c < 7 || c > 63)
3827 break;
3828
3829 service_number = c;
3830 }
3831
3832 if (left >= header_size + block_size) {
3833 if (service_number <= 6) {
3834 struct dtvcc_service *ds;
3835 unsigned int in;
3836
3837 ds = &dc->service[service_number - 1];
3838 in = ds->service_data_in;
3839 memcpy (ds->service_data + in,
3840 p + header_size,
3841 block_size);
3842
3843 ds->service_data_in = in + block_size;
3844 }
3845 } else {
3846 unsigned char *s = p + header_size;
3847 int sleft = left - header_size;
3848
3849 while (sleft > 0) {
3850 int se_len;
3851
3852 se_len = dtvcc_get_se_len(s, sleft);
3853 if (se_len <= 0)
3854 break;
3855
3856 s += se_len;
3857 sleft -= se_len;
3858 }
3859
3860 if (sleft != left - header_size) {
3861 int parsed = left - header_size - sleft;
3862
3863 if (service_number <= 6) {
3864 struct dtvcc_service *ds;
3865 unsigned int in;
3866
3867 ds = &dc->service[service_number - 1];
3868 in = ds->service_data_in;
3869 memcpy (ds->service_data + in,
3870 p + header_size,
3871 parsed);
3872
3873 ds->service_data_in = in + parsed;
3874 }
3875
3876 memmove(p + header_size, s, sleft);
3877 block_size -= parsed;
3878 left -= parsed;
3879
3880 p[0] &= ~0x1f;
3881 p[0] |= block_size;
3882 }
3883 break;
3884 }
3885
3886 p += header_size + block_size;
3887 left -= header_size + block_size;
3888 }
3889
3890 if (left != dc->packet_size - 1) {
3891 int parsed = dc->packet_size - 1 - left;
3892
3893 memmove(dc->packet + 1, p, left);
3894
3895 packet_size_code = ((dc->packet[0] & 0x3f) << 1) - parsed;
3896 if (packet_size_code & 1)
3897 packet_size_code ++;
3898 packet_size_code >>= 1;
3899
3900 dc->packet[0] &= ~0x3f;
3901 dc->packet[0] |= packet_size_code;
3902 dc->packet_size = left + 1;
3903
3904 dtvcc_try_decode_channels(dc);
3905 }
3906}
3907
3908static void
3909dtvcc_reset_service (struct dtvcc_service * ds)
3910{
3911 int i;
3912 ds->curr_window = NULL;
3913 ds->created = 0;
3914 ds->delay = 0;
3915 ds->delay_cancel = 0;
3916
3917 struct dtvcc_window *dw;
3918 for (i=0;i<8;i++)
3919 {
3920 dw = &ds->window[i];
3921 ds->window[i].visible = 0;
3922 memset (dw->buffer, 0, sizeof (dw->buffer));
3923 memset (dw->pen, 0, sizeof(dw->pen));
3924 dw->effect_status = 0;
3925 dw->streamed = 0;
3926 }
3927 ds->update = 1;
3928 cc_timestamp_reset (&ds->timestamp);
3929}
3930
3931void
3932dtvcc_reset (struct dtvcc_decoder * dc)
3933{
3934 dtvcc_reset_service (&dc->service[0]);
3935 dtvcc_reset_service (&dc->service[1]);
3936 dc->packet_size = 0;
3937 dc->next_sequence_number = -1;
3938}
3939
3940void
3941dtvcc_init (struct dtvcc_decoder * dc)
3942{
3943 int i;
3944 memset(dc, 0, sizeof(struct dtvcc_decoder));
3945 dtvcc_reset (dc);
3946 cc_timestamp_reset (&dc->timestamp);
3947 for (i=0;i<6;i++)
3948 dc->service[i].id = i;
3949}
3950
3951static void dtvcc_window_to_page(vbi_decoder *vbi, struct dtvcc_window *dw, struct vbi_page *pg)
3952{
3953 int i, j, c;
3954 vbi_char ac;
3955 vbi_opacity fg_opacity, bg_opacity;
3956
3957 static const vbi_opacity vbi_opacity_map[]={
3958 VBI_OPAQUE,
3959 VBI_OPAQUE,
3960 VBI_SEMI_TRANSPARENT,
3961 VBI_TRANSPARENT_SPACE
3962 };
3963
3964 memset(pg, 0, sizeof(struct vbi_page));
3965#if 1
3966 pg->rows = dw->row_count;
3967 pg->columns = dw->column_count;
3968
3969 dtvcc_set_page_color_map(vbi, pg);
3970 memset(dw->row_start, 0, sizeof(dw->row_start));
3971
3972 for (i=0; i<pg->rows; i++)
3973 {
3974 for (j=0; j<pg->columns; j++)
3975 {
3976 memset(&ac, 0, sizeof(ac));
3977 /*use the curr_pen to draw all the text, actually this isn't reasonable*/
3978 if (dw->curr_pen.style.fg_opacity >= N_ELEMENTS(vbi_opacity_map)){
3979 fg_opacity = VBI_OPAQUE;
3980 }else{
3981 fg_opacity = vbi_opacity_map[dw->curr_pen.style.fg_opacity];
3982 }
3983
3984 if (dw->curr_pen.style.bg_opacity >= N_ELEMENTS(vbi_opacity_map)){
3985 bg_opacity = VBI_OPAQUE;
3986 }else{
3987 bg_opacity = vbi_opacity_map[dw->curr_pen.style.bg_opacity];
3988 }
3989
3990 ac.opacity = (fg_opacity<<4) | bg_opacity;
3991 ac.foreground = dtvcc_map_color(dw->curr_pen.style.fg_color);
3992 ac.background = dtvcc_map_color(dw->curr_pen.style.bg_color);
3993
3994 c = dw->buffer[i][j];
3995 if (0 == c) {
3996 ac.unicode = 0x20;
3997 ac.opacity = VBI_TRANSPARENT_SPACE;
3998 dw->row_start[i] ++;
3999 } else {
4000 ac.unicode = dtvcc_unicode (c);
4001 if (0 == ac.unicode) {
4002 ac.unicode = 0x20;
4003 dw->row_start[i] ++;
4004 }
4005 }
4006 pg->text[i*pg->columns + j] = ac;
4007 }
4008 }
4009#else
4010 pg->rows = 15;
4011 pg->columns = 42;
4012 dtvcc_set_page_color_map(vbi, pg);
4013 for (i=0; i<pg->rows; i++)
4014 {
4015 for (j=0; j<pg->columns; j++)
4016 {
4017 memset(&ac, 0, sizeof(ac));
4018 ac.opacity = VBI_OPAQUE;
4019 ac.foreground = VBI_WHITE;
4020 ac.background = VBI_BLACK;
4021 if (j == 0)
4022 c = '0' + (i%10);
4023 else
4024 c = '0' + (j%10);
4025 ac.unicode = dtvcc_unicode (c);
4026 LOGI("TEXT(%x): %c", ac.unicode, ac.unicode);
4027 pg->text[i*pg->columns + j] = ac;
4028 }
4029 }
4030#endif
4031 pg->screen_color = 0;
4032 pg->screen_opacity = VBI_OPAQUE;
4033 //pg->font[0] = vbi_font_descriptors; /* English */
4034 //pg->font[1] = vbi_font_descriptors;
4035}
4036
4037static int dtvcc_compare_window_priority(const void *window1, const void *window2)
4038{
4039 struct dtvcc_window *w1 = (struct dtvcc_window*)window1;
4040 struct dtvcc_window *w2 = (struct dtvcc_window*)window2;
4041
4042 return (w1->priority - w2->priority);
4043}
4044
4045static void dtvcc_get_visible_windows(struct dtvcc_service *ds, int *cnt, struct dtvcc_window **windows)
4046{
4047 int i, j = 0;
4048
4049 for (i=0; i<N_ELEMENTS(ds->window); i++){
4050 if (ds->window[i].visible && j < *cnt){
4051 windows[j++] = &ds->window[i];
4052 }
4053 }
4054
4055 qsort(windows, j, sizeof(windows[0]), dtvcc_compare_window_priority);
4056
4057 *cnt = j;
4058}
4059
4060void tvcc_fetch_page(struct tvcc_decoder *td, int pgno, int *sub_cnt, struct vbi_page *sub_pages)
4061{
4062 int sub_pg = 0;
4063
4064 if (pgno < 1 || pgno > 14 || *sub_cnt <= 0)
4065 goto fetch_done;
4066
4067 if (pgno <= 8){
4068 if (vbi_fetch_cc_page(td->vbi, &sub_pages[0], pgno, 1)){
4069 sub_pg = 1;
4070 sub_pages[0].pgno = pgno;
4071 }
4072 }else{
4073 int i;
4074 struct dtvcc_service *ds = &td->dtvcc.service[pgno - 1 - 8];
4075 struct dtvcc_window *dw;
4076 struct dtvcc_window *visible_windows[8];
4077
4078 sub_pg = *sub_cnt;
4079 if (sub_pg > 8)
4080 sub_pg = 8;
4081
4082 dtvcc_get_visible_windows(ds, &sub_pg, visible_windows);
4083
4084 for (i=0; i<sub_pg; i++){
4085 dw = visible_windows[i];
4086
4087 dtvcc_window_to_page(td->vbi, dw, &sub_pages[i]);
4088 sub_pages[i].vbi = td->vbi;
4089 sub_pages[i].pgno = pgno;
4090 sub_pages[i].subno = dw - ds->window;
4091 }
4092 }
4093
4094fetch_done:
4095 *sub_cnt = sub_pg;
4096}
4097
4098/* ATSC A/53 Part 4:2007 Closed Caption Data decoder */
4099
4100/* Only handle effect */
4101static void update_service_status_internal (struct tvcc_decoder *td)
4102{
4103 int i, j, k, l;
4104 struct timespec ts_now;
4105 struct dtvcc_decoder *decoder;
4106 struct dtvcc_pen_style *target_pen;
4107 int flash;
4108
4109 decoder = &td->dtvcc;
4110 clock_gettime(CLOCK_REALTIME, &ts_now);
4111
4112 flash = (ts_now.tv_nsec / 250000000) & 1;
4113
4114 /* CS1 - CS6 */
4115 for (i = 0; i < 6; ++i)
4116 {
4117 struct dtvcc_service *ds;
4118 struct program *pr;
4119 vbi_bool success;
4120 ds = &decoder->service[i];
4121 /* Check every effect */
4122 if (ds->delay)
4123 {
4124 struct vbi_event event;
4125 /* time is up */
4126 if ((ts_now.tv_sec > ds->delay_timer.tv_sec) ||
4127 ((ts_now.tv_sec == ds->delay_timer.tv_sec) &&(ts_now.tv_nsec > ds->delay_timer.tv_nsec)) ||
4128 ds->delay_cancel)
4129 {
4130 //AM_DEBUG(1, "delay timeup");
4131 ds->delay = 0;
4132 ds->delay_cancel = 0;
4133 dtvcc_decode_syntactic_elements
4134 (decoder, ds, ds->service_data, ds->service_data_in);
4135
4136 ds->service_data_in = 0;
4137 }
4138 }
4139
4140 if (flash == decoder->flash_state)
4141 continue;
4142
4143 for (j = 0; j < 8; j++)
4144 {
4145 struct dtvcc_window *target_window;
4146 target_window = &ds->window[j];
4147 /*window flash treatment */
4148 if (target_window->style.window_flash)
4149 {
4150 target_window->style.fill_opacity = flash?0:3;
4151 ds->update = 1;
4152 }
4153
4154 /* Wipe and fade treatment */
4155 if (target_window->style.display_effect != 0 &&
4156 target_window->effect_status != 0)
4157 {
4158 target_window->effect_percent =
4159 ((ts_now.tv_sec - target_window->effect_timer.tv_sec) * 1000 +
4160 (ts_now.tv_nsec - target_window->effect_timer.tv_nsec) / 1000000) *100/
4161 (target_window->style.effect_speed * 500);
4162 if (target_window->effect_percent > 100)
4163 target_window->effect_percent = 100;
4164 ds->update = 1;
4165 }
4166
4167 /* Pen flash treatment */
4168 for (k = 0; k < 16; k++)
4169 {
4170 for (l =0; l<42; l++)
4171 {
4172 target_pen = &target_window->pen[k][l];
4173 if (target_pen->bg_flash)
4174 {
4175 target_pen->bg_opacity = flash?0:3;
4176 ds->update = 1;
4177 }
4178 if (target_pen->fg_flash)
4179 {
4180 target_pen->fg_opacity = flash?0:3;
4181 ds->update = 1;
4182 }
4183 }
4184 }
4185 }
4186 }
4187
4188 decoder->flash_state = flash;
4189}
4190
4191static void
4192update_display (struct tvcc_decoder *td)
4193{
4194 int i;
4195
4196 for (i = 0; i < N_ELEMENTS(td->dtvcc.service); i ++) {
4197 struct dtvcc_service *ds = &td->dtvcc.service[i];
4198
4199 if (ds->update) {
4200 struct vbi_event event;
4201
4202 event.type = VBI_EVENT_CAPTION;
4203 event.ev.caption.pgno = i + 1 + 8/*after 8 cc channels*/;
4204
4205 /* Permits calling tvcc_fetch_page from handler */
4206 pthread_mutex_unlock(&td->mutex);
4207
4208 vbi_send_event(td->vbi, &event);
4209 pthread_mutex_lock(&td->mutex);
4210
4211 ds->update = 0;
4212 }
4213 }
4214}
4215
4216
4217/* Note pts may be < 0 if no PTS was received. */
4218void
4219tvcc_decode_data (struct tvcc_decoder *td,
4220 int64_t pts,
4221 const uint8_t * buf,
4222 unsigned int n_bytes)
4223{
4224 unsigned int process_cc_data_flag;
4225 unsigned int cc_count;
4226 unsigned int i;
4227 vbi_bool dtvcc;
4228 struct timeval now;
4229
4230 if (buf[0] != 0x03)
4231 return;
4232 process_cc_data_flag = buf[1] & 0x40;
4233 if (!process_cc_data_flag)
4234 {
4235 return;
4236 }
4237
4238 cc_count = buf[1] & 0x1F;
4239 dtvcc = FALSE;
4240
4241#if 0
4242 printf("tvcc decode %d:\n", n_bytes);
4243 {
4244 int i;
4245
4246 for (i = 0; i < n_bytes; i ++) {
4247 printf("%02x ", buf[i]);
4248 if ((i + 1) % 16 == 0)
4249 printf("\n");
4250 }
4251 printf("\n");
4252 }
4253#endif
4254 pthread_mutex_lock(&td->mutex);
4255
4256 //printf("cc count %d\n", cc_count);
4257
4258 for (i = 0; i < cc_count; ++i) {
4259 unsigned int b0;
4260 unsigned int cc_valid;
4261 enum cc_type cc_type;
4262 unsigned int cc_data_1;
4263 unsigned int cc_data_2;
4264 unsigned int j;
4265
4266 b0 = buf[3 + i * 3];
4267 cc_valid = b0 & 4;
4268 cc_type = (enum cc_type)(b0 & 3);
4269 cc_data_1 = buf[4 + i * 3];
4270 cc_data_2 = buf[5 + i * 3];
4271
4272 //printf("cc type %02x %02x %02x %02x\n", cc_type, cc_valid, cc_data_1, cc_data_2);
4273
4274 switch (cc_type) {
4275 case NTSC_F1:
4276 case NTSC_F2:
4277 //printf("ntsc cc\n");
4278 /* Note CEA 708-C Table 4: Only one NTSC pair
4279 will be present in field picture user_data
4280 or in progressive video pictures, and up to
4281 three can occur if the frame rate < 30 Hz
4282 or repeat_first_field = 1. */
4283 if (!cc_valid || i >= 3 || dtvcc) {
4284 /* Illegal, invalid or filler. */
4285 break;
4286 }
4287#if 0
4288 cc_feed (&td->cc, &buf[12 + i * 3],
4289 /* line */ (NTSC_F1 == cc_type) ? 21 : 284,
4290 &now, pts);
4291#endif
4292 vbi_decode_caption(td->vbi, (NTSC_F1 == cc_type) ? 21 : 284, &buf[4 + i * 3]);
4293 break;
4294
4295 case DTVCC_DATA:
4296 j = td->dtvcc.packet_size;
4297 if (j <= 0) {
4298 /* Missed packet start. */
4299 break;
4300 } else if (!cc_valid) {
4301 /* End of DTVCC packet. */
4302 } else if (j + 2 > 128) {
4303 /* Packet buffer overflow. */
4304 dtvcc_reset (&td->dtvcc);
4305 td->dtvcc.packet_size = 0;
4306 } else {
4307 td->dtvcc.packet[j] = cc_data_1;
4308 td->dtvcc.packet[j + 1] = cc_data_2;
4309 td->dtvcc.packet_size = j + 2;
4310
4311 dtvcc_try_decode_packet (&td->dtvcc, &now, pts);
4312 }
4313 break;
4314
4315 case DTVCC_START:
4316 dtvcc = TRUE;
4317 j = td->dtvcc.packet_size;
4318 if (j > 0) {
4319 /* End of DTVCC packet. */
4320 dtvcc_decode_packet (&td->dtvcc,
4321 &now, pts);
4322 }
4323 if (!cc_valid) {
4324 /* No new data. */
4325 td->dtvcc.packet_size = 0;
4326 } else {
4327 td->dtvcc.packet[0] = cc_data_1;
4328 td->dtvcc.packet[1] = cc_data_2;
4329 td->dtvcc.packet_size = 2;
4330 dtvcc_try_decode_packet(&td->dtvcc, &now, pts);
4331 }
4332 break;
4333 }
4334 }
4335
4336 update_service_status_internal(td);
4337 update_display(td);
4338
4339 pthread_mutex_unlock(&td->mutex);
4340}
4341
4342/* Only handle effect */
4343void update_service_status(struct tvcc_decoder *td)
4344{
4345 pthread_mutex_lock(&td->mutex);
4346
4347 update_service_status_internal(td);
4348 update_display(td);
4349
4350 pthread_mutex_unlock(&td->mutex);
4351}
4352
4353void tvcc_init(struct tvcc_decoder *td)
4354{
4355 pthread_mutex_init(&td->mutex, NULL);
4356 dtvcc_init(&td->dtvcc);
4357 cc_init(&td->cc);
4358 td->vbi = vbi_decoder_new();
4359}
4360
4361void tvcc_destroy(struct tvcc_decoder *td)
4362{
4363 if (td){
4364 vbi_decoder_delete(td->vbi);
4365 td->vbi = NULL;
4366 pthread_mutex_destroy(&td->mutex);
4367 }
4368}
4369
4370void tvcc_reset(struct tvcc_decoder *td)
4371{
4372 dtvcc_reset(&td->dtvcc);
4373 cc_reset(&td->cc);
4374}
4375
4376