summaryrefslogtreecommitdiff
path: root/src/dtvcc.c (plain)
blob: e0ec6055e1f3dd89967ddcdd2395114dde1153ed
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 row = dw->curr_row;
2467 column = dw->curr_column;
2468
2469 /* FIXME how should we handle TEXT_TAG_NOT_DISPLAYABLE? */
2470
2471 dw->buffer[row][column] = c;
2472 dw->pen[row][column] = dw->curr_pen.style;
2473 if (c == 0x1020 || c == 0x1021)
2474 {
2475 if (c == 0x1020)
2476 dw->buffer[row][column] = 0x20;
2477 else
2478 dw->buffer[row][column] = 0xA0;
2479 dw->pen[row][column].bg_opacity = OPACITY_TRANSPARENT;
2480 dw->pen[row][column].fg_opacity = OPACITY_TRANSPARENT;
2481 }
2482 //AM_DEBUG(1, "========= putchar %x %c", c, c);
2483 if (dw->visible)
2484 dtvcc_render(dc, ds);
2485
2486 switch (dw->style.print_direction) {
2487 case DIR_LEFT_RIGHT:
2488 dw->streamed &= ~(1 << row);
2489 if (!cc_timestamp_isset (&dw->timestamp_c0))
2490 dw->timestamp_c0 = ds->timestamp;
2491 if (++column >= dw->column_count)
2492 return TRUE;
2493 break;
2494
2495 case DIR_RIGHT_LEFT:
2496 dw->streamed &= ~(1 << row);
2497 if (!cc_timestamp_isset (&dw->timestamp_c0))
2498 dw->timestamp_c0 = ds->timestamp;
2499 if (column-- <= 0)
2500 return TRUE;
2501 break;
2502
2503 case DIR_TOP_BOTTOM:
2504 dw->streamed &= ~(1 << column);
2505 if (!cc_timestamp_isset (&dw->timestamp_c0))
2506 dw->timestamp_c0 = ds->timestamp;
2507 if (++row >= dw->row_count)
2508 return TRUE;
2509 break;
2510
2511 case DIR_BOTTOM_TOP:
2512 dw->streamed &= ~(1 << column);
2513 if (!cc_timestamp_isset (&dw->timestamp_c0))
2514 dw->timestamp_c0 = ds->timestamp;
2515 if (row-- <= 0)
2516 return TRUE;
2517 break;
2518 }
2519
2520 dw->curr_row = row;
2521 dw->curr_column = column;
2522
2523
2524 return TRUE;
2525}
2526
2527static vbi_bool
2528dtvcc_set_pen_location (struct dtvcc_decoder * dc,
2529 struct dtvcc_service * ds,
2530 const uint8_t * buf)
2531{
2532 struct dtvcc_window *dw;
2533 unsigned int row;
2534 unsigned int column;
2535
2536 dw = ds->curr_window;
2537 if (NULL == dw) {
2538 ds->error_line = __LINE__;
2539 return FALSE;
2540 }
2541
2542 row = buf[1];
2543 /* We check the top four zero bits. */
2544 if (row >= 16) {
2545 ds->error_line = __LINE__;
2546 return FALSE;
2547 }
2548
2549 column = buf[2];
2550 /* We also check the top two zero bits. */
2551 if (column >= 42) {
2552 ds->error_line = __LINE__;
2553 return FALSE;
2554 }
2555
2556 if (row > dw->row_count)
2557 row = dw->row_count - 1;
2558 if (column > dw->column_count)
2559 column = dw->column_count - 1;
2560
2561 if (row != dw->curr_row) {
2562 dtvcc_stream_event (dc, ds, dw, dw->curr_row);
2563 }
2564
2565 /* FIXME there's more. */
2566 dw->curr_row = row;
2567 dw->curr_column = column;
2568
2569 return TRUE;
2570}
2571
2572static vbi_bool
2573dtvcc_set_pen_color (struct dtvcc_service * ds,
2574 const uint8_t * buf)
2575{
2576 struct dtvcc_window *dw;
2577 unsigned int c;
2578
2579 dw = ds->curr_window;
2580 if (NULL == dw) {
2581 ds->error_line = __LINE__;
2582 return FALSE;
2583 }
2584
2585 c = buf[3];
2586 if (0 != (c & 0xC0)) {
2587 ds->error_line = __LINE__;
2588 return FALSE;
2589 }
2590
2591 dw->curr_pen.style.edge_color = c;
2592 c = buf[1];
2593 dw->curr_pen.style.fg_opacity = c >> 6;
2594 dw->curr_pen.style.fg_color = c & 0x3F;
2595 dw->curr_pen.style.fg_flash = ((c>>6)==1)?1:0;
2596 c = buf[2];
2597 dw->curr_pen.style.bg_opacity = c >> 6;
2598 dw->curr_pen.style.bg_color = c & 0x3F;
2599 dw->curr_pen.style.bg_flash = ((c>>6)==1)?1:0;
2600
2601 return TRUE;
2602}
2603
2604static vbi_bool
2605dtvcc_set_pen_attributes (struct dtvcc_service * ds,
2606 const uint8_t * buf)
2607{
2608 struct dtvcc_window *dw;
2609 unsigned int c;
2610 enum pen_size pen_size;
2611 enum offset offset;
2612 enum edge edge_type;
2613
2614 dw = ds->curr_window;
2615 if (NULL == dw) {
2616 ds->error_line = __LINE__;
2617 return FALSE;
2618 }
2619
2620 c = buf[1];
2621 offset = (c >> 2) & 3;
2622 pen_size = c & 3;
2623 //TODO: why not larger than 3
2624 /*
2625 if ((offset | pen_size) >= 3) {
2626 ds->error_line = __LINE__;
2627 return FALSE;
2628 } */
2629
2630 c = buf[2];
2631 edge_type = (c >> 3) & 7;
2632 if (edge_type >= 6) {
2633 ds->error_line = __LINE__;
2634 return FALSE;
2635 }
2636
2637 c = buf[1];
2638 dw->curr_pen.text_tag = c >> 4;
2639 dw->curr_pen.style.offset = offset;
2640 dw->curr_pen.style.pen_size = pen_size;
2641 c = buf[2];
2642 dw->curr_pen.style.italics = c >> 7;
2643 dw->curr_pen.style.underline = (c >> 6) & 1;
2644 dw->curr_pen.style.edge_type = edge_type;
2645 dw->curr_pen.style.font_style = c & 7;
2646
2647 return TRUE;
2648}
2649
2650static vbi_bool
2651dtvcc_set_window_attributes (struct dtvcc_service * ds,
2652 const uint8_t * buf)
2653{
2654 struct dtvcc_window *dw;
2655 unsigned int c;
2656 enum edge border_type;
2657 enum display_effect display_effect;
2658
2659 dw = ds->curr_window;
2660 if (NULL == dw)
2661 return FALSE;
2662
2663 c = buf[2];
2664 border_type = ((buf[3] >> 5) & 0x04) | (c >> 6);
2665 if (border_type >= 6)
2666 return FALSE;
2667
2668 c = buf[4];
2669 display_effect = c & 3;
2670 if (display_effect >= 3)
2671 return FALSE;
2672
2673 c = buf[1];
2674 dw->style.fill_opacity = c >> 6;
2675 dw->style.fill_color = c & 0x3F;
2676 dw->style.window_flash = ((c>>6)==1)?1:0;
2677 c = buf[2];
2678 dw->style.border_type = border_type;
2679 dw->style.border_color = c & 0x3F;
2680 c = buf[3];
2681 dw->style.wordwrap = (c >> 6) & 1;
2682 dw->style.print_direction = (c >> 4) & 3;
2683 dw->style.scroll_direction = (c >> 2) & 3;
2684 dw->style.justify = c & 3;
2685 c = buf[4];
2686 dw->style.effect_speed = c >> 4;
2687 dw->style.effect_direction = (c >> 2) & 3;
2688 dw->style.display_effect = display_effect;
2689
2690 return TRUE;
2691}
2692
2693static vbi_bool
2694dtvcc_clear_windows (struct dtvcc_decoder * dc,
2695 struct dtvcc_service * ds,
2696 dtvcc_window_map window_map)
2697{
2698 unsigned int i;
2699
2700 window_map &= ds->created;
2701
2702 for (i = 0; i < 8; ++i) {
2703 struct dtvcc_window *dw;
2704
2705 if (0 == (window_map & (1 << i)))
2706 continue;
2707
2708 dw = &ds->window[i];
2709
2710 dtvcc_stream_event (dc, ds, dw, dw->curr_row);
2711
2712 memset (dw->buffer, 0, sizeof (dw->buffer));
2713 memset (dw->pen, 0, sizeof(dw->pen));
2714
2715 dw->streamed = 0;
2716
2717 if (dw->visible)
2718 dtvcc_render(dc, ds);
2719
2720 /* FIXME CEA 708-C Section 7.1.4 (Form Feed)
2721 and 8.10.5.3 confuse me. */
2722 if (0) {
2723 dw->curr_column = 0;
2724 dw->curr_row = 0;
2725 }
2726 }
2727
2728 return TRUE;
2729}
2730
2731static vbi_bool
2732dtvcc_define_window (struct dtvcc_decoder * dc,
2733 struct dtvcc_service * ds,
2734 uint8_t * buf)
2735{
2736 static const struct dtvcc_window_style window_styles [7] = {
2737 {
2738 JUSTIFY_LEFT, DIR_LEFT_RIGHT, DIR_BOTTOM_TOP,
2739 FALSE, DISPLAY_EFFECT_SNAP, 0, 0, 0,
2740 OPACITY_SOLID, EDGE_NONE, 0
2741 }, {
2742 JUSTIFY_LEFT, DIR_LEFT_RIGHT, DIR_BOTTOM_TOP,
2743 FALSE, DISPLAY_EFFECT_SNAP, 0, 0, 0,
2744 OPACITY_TRANSPARENT, EDGE_NONE, 0
2745 }, {
2746 JUSTIFY_CENTER, DIR_LEFT_RIGHT, DIR_BOTTOM_TOP,
2747 FALSE, DISPLAY_EFFECT_SNAP, 0, 0, 0,
2748 OPACITY_SOLID, EDGE_NONE, 0
2749 }, {
2750 JUSTIFY_LEFT, DIR_LEFT_RIGHT, DIR_BOTTOM_TOP,
2751 TRUE, DISPLAY_EFFECT_SNAP, 0, 0, 0,
2752 OPACITY_SOLID, EDGE_NONE, 0
2753 }, {
2754 JUSTIFY_LEFT, DIR_LEFT_RIGHT, DIR_BOTTOM_TOP,
2755 TRUE, DISPLAY_EFFECT_SNAP, 0, 0, 0,
2756 OPACITY_TRANSPARENT, EDGE_NONE, 0
2757 }, {
2758 JUSTIFY_CENTER, DIR_LEFT_RIGHT, DIR_BOTTOM_TOP,
2759 TRUE, DISPLAY_EFFECT_SNAP, 0, 0, 0,
2760 OPACITY_SOLID, EDGE_NONE, 0
2761 }, {
2762 JUSTIFY_LEFT, DIR_TOP_BOTTOM, DIR_RIGHT_LEFT,
2763 FALSE, DISPLAY_EFFECT_SNAP, 0, 0, 0,
2764 OPACITY_SOLID, EDGE_NONE, 0
2765 }
2766 };
2767 static const struct dtvcc_pen_style pen_styles [7] = {
2768 {
2769 PEN_SIZE_STANDARD, 0, OFFSET_NORMAL, FALSE,
2770 FALSE, EDGE_NONE, 0x3F, OPACITY_SOLID,
2771 0x00, OPACITY_SOLID, 0
2772 }, {
2773 PEN_SIZE_STANDARD, 1, OFFSET_NORMAL, FALSE,
2774 FALSE, EDGE_NONE, 0x3F, OPACITY_SOLID,
2775 0x00, OPACITY_SOLID, 0
2776 }, {
2777 PEN_SIZE_STANDARD, 2, OFFSET_NORMAL, FALSE,
2778 FALSE, EDGE_NONE, 0x3F, OPACITY_SOLID,
2779 0x00, OPACITY_SOLID, 0
2780 }, {
2781 PEN_SIZE_STANDARD, 3, OFFSET_NORMAL, FALSE,
2782 FALSE, EDGE_NONE, 0x3F, OPACITY_SOLID,
2783 0x00, OPACITY_SOLID, 0
2784 }, {
2785 PEN_SIZE_STANDARD, 4, OFFSET_NORMAL, FALSE,
2786 FALSE, EDGE_NONE, 0x3F, OPACITY_SOLID,
2787 0x00, OPACITY_SOLID, 0
2788 }, {
2789 PEN_SIZE_STANDARD, 3, OFFSET_NORMAL, FALSE,
2790 FALSE, EDGE_UNIFORM, 0x3F, OPACITY_SOLID,
2791 0, OPACITY_TRANSPARENT, 0x00
2792 }, {
2793 PEN_SIZE_STANDARD, 4, OFFSET_NORMAL, FALSE,
2794 FALSE, EDGE_UNIFORM, 0x3F, OPACITY_SOLID,
2795 0, OPACITY_TRANSPARENT, 0x00
2796 }
2797 };
2798 struct dtvcc_window *dw;
2799 dtvcc_window_map window_map;
2800 vbi_bool anchor_relative;
2801 unsigned int anchor_vertical;
2802 unsigned int anchor_horizontal;
2803 unsigned int anchor_point;
2804 unsigned int column_count_m1;
2805 unsigned int window_id;
2806 unsigned int window_style_id;
2807 unsigned int pen_style_id;
2808 unsigned int c;
2809
2810 //printf("define window\n");
2811
2812 if (0 != ((buf[1] | buf[6]) & 0xC0)) {
2813 ds->error_line = __LINE__;
2814 return FALSE;
2815 }
2816
2817 c = buf[2];
2818 anchor_relative = (c >> 7) & 1;
2819 anchor_vertical = c & 0x7F;
2820 anchor_horizontal = buf[3];
2821 if (0 == anchor_relative) {
2822 if (unlikely (anchor_vertical >= 75
2823 || anchor_horizontal >= 210)) {
2824 ds->error_line = __LINE__;
2825 return FALSE;
2826 }
2827 } else {
2828 if (unlikely (anchor_vertical >= 100
2829 || anchor_horizontal >= 100)) {
2830 ds->error_line = __LINE__;
2831 return FALSE;
2832 }
2833 }
2834
2835 c = buf[4];
2836 anchor_point = c >> 4;
2837 if (unlikely (anchor_point >= 9)) {
2838 ds->error_line = __LINE__;
2839 return FALSE;
2840 }
2841
2842 //printf("define window %d\n", column_count_m1);
2843
2844 column_count_m1 = buf[5];
2845 /* We also check the top two zero bits. */
2846 if (unlikely (column_count_m1 >= 42)) {
2847 ds->error_line = __LINE__;
2848 return FALSE;
2849 }
2850 //printf("define windowa\n");
2851
2852 window_id = buf[0] & 7;
2853 dw = &ds->window[window_id];
2854 window_map = 1 << window_id;
2855
2856 ds->curr_window = dw;
2857
2858 c = buf[1];
2859 dw->visible = (c >> 5) & 1;
2860 dw->row_lock = (c >> 4) & 1;
2861 dw->column_lock = (c >> 4) & 1;
2862 dw->priority = c & 7;
2863
2864 dw->anchor_relative = anchor_relative;
2865 dw->anchor_vertical = anchor_vertical;
2866 dw->anchor_horizontal = anchor_horizontal;
2867 dw->anchor_point = anchor_point;
2868
2869 c = buf[4];
2870 dw->row_count = (c & 15) + 1;
2871 dw->column_count = column_count_m1 + 1;
2872
2873 c = buf[6];
2874 window_style_id = (c >> 3) & 7;
2875 pen_style_id = c & 7;
2876
2877 if (window_style_id > 0) {
2878 dw->style = window_styles[window_style_id-1];
2879 } else if (0 == (ds->created & window_map)) {
2880 dw->style = window_styles[1];
2881 }
2882
2883 if (pen_style_id > 0) {
2884 dw->curr_pen.style = pen_styles[pen_style_id];
2885 } else if (0 == (ds->created & window_map)) {
2886 dw->curr_pen.style = pen_styles[1];
2887 }
2888
2889 if (0 != (ds->created & window_map))
2890 return TRUE;
2891
2892 /* Has to be something, no? */
2893 dw->curr_pen.text_tag = TEXT_TAG_NOT_DISPLAYABLE;
2894
2895 dw->curr_column = 0;
2896 dw->curr_row = 0;
2897
2898 dw->streamed = 0;
2899
2900 cc_timestamp_reset (&dw->timestamp_c0);
2901
2902 ds->created |= window_map;
2903
2904 //printf("define %x %x\n", ds->curr_window, ds->created);
2905
2906 return dtvcc_clear_windows (dc, ds, window_map);
2907}
2908
2909static vbi_bool
2910dtvcc_display_windows (struct dtvcc_decoder * dc,
2911 struct dtvcc_service * ds,
2912 unsigned int c,
2913 dtvcc_window_map window_map)
2914{
2915 unsigned int i;
2916
2917 window_map &= ds->created;
2918
2919 //printf("display %02x %p %02x\n", c, ds->curr_window, ds->created);
2920 if (ds->curr_window == NULL && ds->created == 0) {
2921 return FALSE;
2922 //return TRUE;
2923 }
2924
2925 for (i = 0; i < 8; ++i) {
2926 struct dtvcc_window *dw;
2927 vbi_bool was_visible;
2928
2929 if (0 == (window_map & (1 << i)))
2930 continue;
2931
2932 dw = &ds->window[i];
2933 was_visible = dw->visible;
2934
2935 switch (c) {
2936 case 0x89: /* DSW DisplayWindows */
2937 dw->visible = TRUE;
2938 break;
2939
2940 case 0x8A: /* HDW HideWindows */
2941 dw->visible = FALSE;
2942 break;
2943
2944 case 0x8B: /* TGW ToggleWindows */
2945 dw->visible = was_visible ^ TRUE;
2946 break;
2947 }
2948
2949 if (!was_visible) {
2950 unsigned int row;
2951
2952 dw->timestamp_c0 = ds->timestamp;
2953 for (row = 0; row < dw->row_count; ++row) {
2954 dtvcc_stream_event (dc, ds, dw, row);
2955 }
2956 }
2957 }
2958
2959 dtvcc_render(dc, ds);
2960
2961 return TRUE;
2962}
2963
2964static vbi_bool
2965dtvcc_carriage_return (struct dtvcc_decoder * dc,
2966 struct dtvcc_service * ds)
2967{
2968 struct dtvcc_window *dw;
2969 unsigned int row;
2970 unsigned int column;
2971
2972 dw = ds->curr_window;
2973 if (NULL == dw) {
2974 ds->error_line = __LINE__;
2975 return FALSE;
2976 }
2977
2978 dtvcc_stream_event (dc, ds, dw, dw->curr_row);
2979
2980 row = dw->curr_row;
2981 column = dw->curr_column;
2982
2983 switch (dw->style.scroll_direction) {
2984 case DIR_LEFT_RIGHT:
2985 dw->curr_row = 0;
2986 if (column > 0) {
2987 dw->curr_column = column - 1;
2988 break;
2989 }
2990 dw->streamed = (dw->streamed << 1)
2991 & ~(1 << dw->column_count);
2992 for (row = 0; row < dw->row_count; ++row) {
2993 for (column = dw->column_count - 1;
2994 column > 0; --column) {
2995 dw->buffer[row][column] =
2996 dw->buffer[row][column - 1];
2997 dw->pen[row][column] =
2998 dw->pen[row][column - 1];
2999 }
3000 dw->buffer[row][column] = 0;
3001 memset(&dw->pen[row][column], 0, sizeof(dw->pen[0][0]));
3002 }
3003 break;
3004
3005 case DIR_RIGHT_LEFT:
3006 dw->curr_row = 0;
3007 if (column + 1 < dw->row_count) {
3008 dw->curr_column = column + 1;
3009 break;
3010 }
3011 dw->streamed >>= 1;
3012 for (row = 0; row < dw->row_count; ++row) {
3013 for (column = 0;
3014 column < dw->column_count - 1; ++column) {
3015 dw->buffer[row][column] =
3016 dw->buffer[row][column + 1];
3017 dw->pen[row][column] =
3018 dw->pen[row][column + 1];
3019 }
3020 dw->buffer[row][column] = 0;
3021 memset(&dw->pen[row][column], 0, sizeof(dw->pen[0][0]));
3022 }
3023 break;
3024
3025 case DIR_TOP_BOTTOM:
3026 dw->curr_column = 0;
3027 if (row > 0) {
3028 dw->curr_row = row - 1;
3029 break;
3030 }
3031 dw->streamed = (dw->streamed << 1)
3032 & ~(1 << dw->row_count);
3033 memmove (&dw->buffer[1], &dw->buffer[0],
3034 sizeof (dw->buffer[0]) * (dw->row_count - 1));
3035 memmove (&dw->pen[1], &dw->pen[0],
3036 sizeof (dw->pen[0]) * (dw->row_count - 1));
3037 memset (&dw->buffer[0], 0, sizeof (dw->buffer[0]));
3038 memset (&dw->pen[0], 0, sizeof(dw->pen[0]));
3039 break;
3040
3041 case DIR_BOTTOM_TOP:
3042 dw->curr_column = 0;
3043 if (row + 1 < dw->row_count) {
3044 dw->curr_row = row + 1;
3045 break;
3046 }
3047 dw->streamed >>= 1;
3048 memmove (&dw->buffer[0], &dw->buffer[1],
3049 sizeof (dw->buffer[0]) * (dw->row_count - 1));
3050 memmove (&dw->pen[0], &dw->pen[1],
3051 sizeof (dw->pen[0]) * (dw->row_count - 1));
3052 memset (&dw->buffer[row], 0, sizeof (dw->buffer[0]));
3053 memset (&dw->pen[row], 0, sizeof (dw->pen[0]));
3054 break;
3055 }
3056
3057 return TRUE;
3058}
3059
3060static vbi_bool
3061dtvcc_form_feed (struct dtvcc_decoder * dc,
3062 struct dtvcc_service * ds)
3063{
3064 struct dtvcc_window *dw;
3065 dtvcc_window_map window_map;
3066
3067 dw = ds->curr_window;
3068 if (NULL == dw) {
3069 ds->error_line = __LINE__;
3070 return FALSE;
3071 }
3072
3073 window_map = 1 << dtvcc_window_id (ds, dw);
3074
3075 if (!dtvcc_clear_windows (dc, ds, window_map))
3076 return FALSE;
3077
3078 dw->curr_row = 0;
3079 dw->curr_column = 0;
3080
3081 return TRUE;
3082}
3083
3084static vbi_bool
3085dtvcc_backspace (struct dtvcc_decoder * dc,
3086 struct dtvcc_service * ds)
3087{
3088 struct dtvcc_window *dw;
3089 unsigned int row;
3090 unsigned int column;
3091 unsigned int mask;
3092
3093 dc = dc; /* unused */
3094
3095 dw = ds->curr_window;
3096 if (NULL == dw) {
3097 ds->error_line = __LINE__;
3098 return FALSE;
3099 }
3100
3101 row = dw->curr_row;
3102 column = dw->curr_column;
3103
3104 switch (dw->style.print_direction) {
3105 case DIR_LEFT_RIGHT:
3106 mask = 1 << row;
3107 if (column-- <= 0)
3108 return TRUE;
3109 break;
3110
3111 case DIR_RIGHT_LEFT:
3112 mask = 1 << row;
3113 if (++column >= dw->column_count)
3114 return TRUE;
3115 break;
3116
3117 case DIR_TOP_BOTTOM:
3118 mask = 1 << column;
3119 if (row-- <= 0)
3120 return TRUE;
3121 break;
3122
3123 case DIR_BOTTOM_TOP:
3124 mask = 1 << column;
3125 if (++row >= dw->row_count)
3126 return TRUE;
3127 break;
3128 }
3129
3130 if (0 != dw->buffer[row][column]) {
3131 dw->streamed &= ~mask;
3132 dw->buffer[row][column] = 0;
3133 memset(&dw->pen[row][column], 0, sizeof(dw->pen[0][0]));
3134 }
3135
3136 dw->curr_row = row;
3137 dw->curr_column = column;
3138
3139 return TRUE;
3140}
3141
3142static vbi_bool
3143dtvcc_hor_carriage_return (struct dtvcc_decoder * dc,
3144 struct dtvcc_service * ds)
3145{
3146 struct dtvcc_window *dw;
3147 unsigned int row;
3148 unsigned int column;
3149 unsigned int mask;
3150
3151 dc = dc; /* unused */
3152
3153 dw = ds->curr_window;
3154 if (NULL == dw) {
3155 ds->error_line = __LINE__;
3156 return FALSE;
3157 }
3158
3159 row = dw->curr_row;
3160 column = dw->curr_column;
3161
3162 switch (dw->style.print_direction) {
3163 case DIR_LEFT_RIGHT:
3164 case DIR_RIGHT_LEFT:
3165 mask = 1 << row;
3166 memset (&dw->buffer[row][0], 0,
3167 sizeof (dw->buffer[0]));
3168 memset (&dw->pen[row][0], 0,
3169 sizeof (dw->pen[0]));
3170 if (DIR_LEFT_RIGHT == dw->style.print_direction)
3171 dw->curr_column = 0;
3172 else
3173 dw->curr_column = dw->column_count - 1;
3174 break;
3175
3176 case DIR_TOP_BOTTOM:
3177 case DIR_BOTTOM_TOP:
3178 mask = 1 << column;
3179 for (row = 0; row < dw->column_count; ++row) {
3180 dw->buffer[row][column] = 0;
3181 memset(&dw->pen[row][column], 0, sizeof(dw->pen[0][0]));
3182 }
3183 if (DIR_TOP_BOTTOM == dw->style.print_direction)
3184 dw->curr_row = 0;
3185 else
3186 dw->curr_row = dw->row_count - 1;
3187 break;
3188 }
3189
3190 dw->streamed &= ~mask;
3191
3192 return TRUE;
3193}
3194
3195static vbi_bool
3196dtvcc_delete_windows (struct dtvcc_decoder * dc,
3197 struct dtvcc_service * ds,
3198 dtvcc_window_map window_map)
3199{
3200 struct dtvcc_window *dw;
3201 int i;
3202 int changed = 0;
3203
3204 for (i = 0; i < N_ELEMENTS(ds->window); i ++) {
3205 dw = &ds->window[i];
3206
3207 if (NULL != dw) {
3208 unsigned int window_id;
3209 window_id = dtvcc_window_id (ds, dw);
3210 if (ds->created & (1 << window_id)) {
3211 if (window_map & (1 << window_id)) {
3212 //printf("delete window %d\n", window_id);
3213 dtvcc_stream_event (dc, ds, dw, dw->curr_row);
3214
3215 if (dw == ds->curr_window)
3216 ds->curr_window = NULL;
3217
3218 if (dw->visible)
3219 dtvcc_render(dc, ds);
3220
3221 memset (dw->buffer, 0, sizeof (dw->buffer));
3222 memset (dw->pen, 0, sizeof(dw->pen));
3223 dw->visible = 0;
3224
3225 changed = 1;
3226 }
3227 }
3228 }
3229 }
3230
3231 ds->created &= ~window_map;
3232
3233 return TRUE;
3234}
3235
3236static vbi_bool
3237dtvcc_delay_cmd (struct dtvcc_decoder * dc,
3238 struct dtvcc_service * ds,
3239 uint8_t delay_cmd,
3240 uint8_t delay_time)
3241{
3242 struct timespec now_ts;
3243 int plus_one_second = 0;
3244 clock_gettime(CLOCK_REALTIME, &now_ts);
3245 if (delay_cmd == 0x8D)
3246 {
3247 /* Set trigger time
3248 Until that time, sevice stop decoding.
3249 */
3250 /* Delay time is tenths of second */
3251 /* We set the timer a little faster to avoid double delay conflict */
3252 if ((1000000000 - (delay_time%10) * 100000000) > now_ts.tv_nsec)
3253 {
3254 ds->delay_timer.tv_nsec = ((delay_time % 10) * 100000000 + now_ts.tv_nsec) % 1000000000;
3255 ds->delay_timer.tv_sec = (1 + now_ts.tv_sec + delay_time/10) -1;
3256 }
3257 else
3258 {
3259 ds->delay_timer.tv_nsec = (delay_time % 10) * 100000000 + now_ts.tv_nsec;
3260 ds->delay_timer.tv_sec = (now_ts.tv_sec + delay_time / 10) -1;
3261 }
3262 ds->delay_timer.tv_sec = now_ts.tv_sec + 1;
3263 ds->delay = 1;
3264 ds->delay_cancel = 0;
3265 //AM_DEBUG(1, "Enter delay cmd, now %d until %d", now_ts.tv_sec, ds->delay_timer.tv_sec);
3266 }
3267 else if (delay_cmd == 0x8E)
3268 {
3269 ds->delay = 0;
3270 ds->delay_cancel = 1;
3271 }
3272 return TRUE;
3273}
3274
3275static vbi_bool
3276dtvcc_command (struct dtvcc_decoder * dc,
3277 struct dtvcc_service * ds,
3278 unsigned int * se_length,
3279 uint8_t * buf,
3280 unsigned int n_bytes)
3281{
3282 unsigned int c;
3283 unsigned int window_id;
3284
3285 c = buf[0];
3286 if ((int8_t) c < 0) {
3287 *se_length = dtvcc_c1_length[c - 0x80];
3288 } else {
3289 *se_length = dtvcc_c0_length[c >> 3];
3290 }
3291
3292 if (*se_length > n_bytes) {
3293 ds->error_line = __LINE__;
3294 return TRUE;
3295 }
3296 switch (c) {
3297 case 0x08: /* BS Backspace */
3298 return dtvcc_backspace (dc, ds);
3299
3300 case 0x0C: /* FF Form Feed */
3301 return dtvcc_form_feed (dc, ds);
3302
3303 case 0x0D: /* CR Carriage Return */
3304 return dtvcc_carriage_return (dc, ds);
3305
3306 case 0x0E: /* HCR Horizontal Carriage Return */
3307 return dtvcc_hor_carriage_return (dc, ds);
3308
3309 case 0x80 ... 0x87: /* CWx SetCurrentWindow */
3310 window_id = c & 7;
3311 if (0 == (ds->created & (1 << window_id))) {
3312 ds->error_line = __LINE__;
3313 return FALSE;
3314 }
3315 ds->curr_window = &ds->window[window_id];
3316 return TRUE;
3317
3318 case 0x88: /* CLW ClearWindows */
3319 return dtvcc_clear_windows (dc, ds, buf[1]);
3320
3321 case 0x89: /* DSW DisplayWindows */
3322 return dtvcc_display_windows (dc, ds, c, buf[1]);
3323
3324 case 0x8D:
3325 dtvcc_delay_cmd(dc, ds, 0x8d, buf[1]);
3326 return 0;
3327
3328 case 0x8E:
3329 dtvcc_delay_cmd(dc, ds, 0x8e, buf[1]);
3330 return 0;
3331
3332 case 0x8A: /* HDW HideWindows */
3333 return dtvcc_display_windows (dc, ds, c, buf[1]);
3334
3335 case 0x8B: /* TGW ToggleWindows */
3336 return dtvcc_display_windows (dc, ds, c, buf[1]);
3337
3338 case 0x8C: /* DLW DeleteWindows */
3339 return dtvcc_delete_windows (dc, ds, buf[1]);
3340
3341 case 0x8F: /* RST Reset */
3342 dtvcc_reset_service (ds);
3343 return TRUE;
3344
3345 case 0x90: /* SPA SetPenAttributes */
3346 return dtvcc_set_pen_attributes (ds, buf);
3347
3348 case 0x91: /* SPC SetPenColor */
3349 return dtvcc_set_pen_color (ds, buf);
3350
3351 case 0x92: /* SPL SetPenLocation */
3352 return dtvcc_set_pen_location (dc, ds, buf);
3353
3354 case 0x97: /* SWA SetWindowAttributes */
3355 return dtvcc_set_window_attributes (ds, buf);
3356
3357 case 0x98 ... 0x9F: /* DFx DefineWindow */
3358 return dtvcc_define_window (dc, ds, buf);
3359
3360 default:
3361 return TRUE;
3362 }
3363}
3364
3365static vbi_bool
3366dtvcc_decode_se (struct dtvcc_decoder * dc,
3367 struct dtvcc_service * ds,
3368 unsigned int * se_length,
3369 uint8_t * buf,
3370 unsigned int n_bytes)
3371{
3372 unsigned int c;
3373
3374 c = buf[0];
3375 if (likely (0 != (c & 0x60))) {
3376 /* G0/G1 character. */
3377 *se_length = 1;
3378 return dtvcc_put_char (dc, ds, c);
3379 }
3380
3381 if (0x10 != c) {
3382 /* C0/C1 control code. */
3383 return dtvcc_command (dc, ds, se_length,
3384 buf, n_bytes);
3385 }
3386
3387 if (unlikely (n_bytes < 2)) {
3388 ds->error_line = __LINE__;
3389 return FALSE;
3390 }
3391
3392 c = buf[1];
3393 if (likely (0 != (c & 0x60))) {
3394 /* G2/G3 character. */
3395 *se_length = 2;
3396 return dtvcc_put_char (dc, ds, 0x1000 | c);
3397 }
3398
3399 /* CEA 708-C defines no C2 or C3 commands. */
3400
3401 if ((int8_t) c >= 0) {
3402 /* C2 code. */
3403 *se_length = (c >> 3) + 2;
3404 } else if (c < 0x90) {
3405 /* C3 Fixed Length Commands. */
3406 *se_length = (c >> 3) - 10;
3407 } else {
3408 /* C3 Variable Length Commands. */
3409
3410 if (unlikely (n_bytes < 3)) {
3411 ds->error_line = __LINE__;
3412 return FALSE;
3413 }
3414
3415 /* type [2], zero_bit [1],
3416 length [5] */
3417 *se_length = (buf[2] & 0x1F) + 3;
3418 }
3419
3420 if (unlikely (n_bytes < *se_length)) {
3421 ds->error_line = __LINE__;
3422 return FALSE;
3423 }
3424
3425 return TRUE;
3426}
3427
3428static vbi_bool
3429dtvcc_decode_syntactic_elements (struct dtvcc_decoder * dc,
3430 struct dtvcc_service * ds,
3431 uint8_t * buf,
3432 unsigned int n_bytes)
3433{
3434 ds->timestamp = dc->timestamp;
3435 struct timespec ts_now;
3436
3437#if 0
3438 AM_DEBUG(1, "+++++++++++++++++++++ servie %d\n", n_bytes);
3439 {
3440 int i;
3441
3442 for (i = 0; i < n_bytes; i ++)
3443 AM_DEBUG(1, "++++++++++++++ %02x ", buf[i]);
3444 }
3445#endif
3446 while (n_bytes > 0) {
3447 unsigned int se_length;
3448
3449 //printf("dec se %02x\n", buf[0]);
3450
3451 if (!dtvcc_decode_se (dc, ds,
3452 &se_length,
3453 buf, n_bytes)) {
3454 return FALSE;
3455 }
3456
3457 buf += se_length;
3458 n_bytes -= se_length;
3459 }
3460
3461 return TRUE;
3462}
3463
3464static void
3465dtvcc_try_decode_channels (struct dtvcc_decoder *dc)
3466{
3467 int i;
3468
3469 for (i = 0; i < 6; ++i) {
3470 struct dtvcc_service *ds;
3471 struct program *pr;
3472 vbi_bool success;
3473
3474 ds = &dc->service[i];
3475 if (0 == ds->service_data_in)
3476 continue;
3477 if (!ds->delay ||
3478 (ds->delay && ds->service_data_in>=128))
3479 {
3480 //AM_DEBUG(1, "service datain %d", ds->service_data_in);
3481 success = dtvcc_decode_syntactic_elements
3482 (dc, ds, ds->service_data, ds->service_data_in);
3483 if (ds->service_data_in >= 128)
3484 {
3485 ds->delay = 0;
3486 ds->delay_cancel = 0;
3487 }
3488 ds->service_data_in = 0;
3489
3490 if (success)
3491 continue;
3492 }
3493 //dtvcc_reset_service (ds);
3494 //dc->next_sequence_number = -1;
3495 }
3496}
3497
3498void
3499dtvcc_decode_packet (struct dtvcc_decoder * dc,
3500 const struct timeval * tv,
3501 int64_t pts)
3502{
3503 unsigned int packet_size_code;
3504 unsigned int packet_size;
3505 unsigned int i;
3506
3507#if 0
3508 printf("%d dtvcc decode packet %d: ", get_input_offset(), dc->packet_size);
3509
3510 for (i = 0; i < dc->packet_size; i ++) {
3511 printf("%02x ", dc->packet[i]);
3512 }
3513 printf("\n");
3514#endif
3515 dc->timestamp.sys = *tv;
3516 dc->timestamp.pts = pts;
3517
3518 /* Packet Layer. */
3519
3520 /* sequence_number [2], packet_size_code [6],
3521 packet_data [n * 8] */
3522#if 0
3523 if (dc->next_sequence_number >= 0
3524 && 0 != ((dc->packet[0] ^ dc->next_sequence_number) & 0xC0)) {
3525 dtvcc_reset (dc);
3526 return;
3527 }
3528#endif
3529 dc->next_sequence_number = dc->packet[0] + 0x40;
3530
3531 packet_size_code = dc->packet[0] & 0x3F;
3532 packet_size = 128;
3533 if (packet_size_code > 0)
3534 packet_size = packet_size_code * 2;
3535
3536 /* CEA 708-C Section 5: Apparently packet_size need not be
3537 equal to the actually transmitted amount of data. */
3538 if (packet_size > dc->packet_size) {
3539 /*
3540 dtvcc_reset (dc);
3541 return;*/
3542 packet_size = dc->packet_size;
3543 }
3544
3545 /* Service Layer. */
3546
3547 /* CEA 708-C Section 6.2.5, 6.3: Service Blocks and syntactic
3548 elements must not cross Caption Channel Packet
3549 boundaries. */
3550
3551 for (i = 1; i < packet_size;) {
3552 unsigned int service_number;
3553 unsigned int block_size;
3554 unsigned int header_size;
3555 unsigned int c;
3556
3557 header_size = 1;
3558
3559 /* service_number [3], block_size [5],
3560 (null_fill [2], extended_service_number [6]),
3561 (Block_data [n * 8]) */
3562
3563 c = dc->packet[i];
3564 service_number = (c & 0xE0) >> 5;
3565
3566 //printf("srv %d\n", service_number);
3567
3568 /* CEA 708-C Section 6.3: Ignore block_size if
3569 service_number is zero. */
3570 if (0 == service_number) {
3571 /* NULL Service Block Header, no more data in
3572 this Caption Channel Packet. */
3573 break;
3574 }
3575
3576 /* CEA 708-C Section 6.2.1: Apparently block_size zero
3577 is valid, although properly it should only occur in
3578 NULL Service Block Headers. */
3579 block_size = c & 0x1F;
3580
3581 if (7 == service_number) {
3582 if (i + 1 > packet_size)
3583 break;
3584
3585 header_size = 2;
3586 c = dc->packet[i + 1];
3587
3588 /* We also check the null_fill bits. */
3589 if (c < 7 || c > 63)
3590 break;
3591
3592 service_number = c;
3593 }
3594
3595 //printf("srv %d %d %d %d\n", service_number, header_size, block_size, packet_size);
3596
3597 if (i + header_size + block_size > packet_size)
3598 {
3599 break;
3600 }
3601
3602 if (service_number <= 6) {
3603 struct dtvcc_service *ds;
3604 unsigned int in;
3605
3606 ds = &dc->service[service_number - 1];
3607 in = ds->service_data_in;
3608 memcpy (ds->service_data + in,
3609 dc->packet + i + header_size,
3610 block_size);
3611 ds->service_data_in = in + block_size;
3612 }
3613
3614 i += header_size + block_size;
3615 }
3616
3617 dtvcc_try_decode_channels(dc);
3618 return;
3619}
3620
3621static int
3622dtvcc_get_se_len (unsigned char *p, int left)
3623{
3624 unsigned char c;
3625 int se_length;
3626
3627 if (left < 1)
3628 return 0;
3629
3630 c = p[0];
3631
3632 if ((c == 0x8d) && (c == 0x8e))
3633 return 1;
3634
3635 if (0 != (c & 0x60))
3636 return 1;
3637
3638 if (0x10 != c) {
3639 if ((int8_t) c < 0) {
3640 se_length = dtvcc_c1_length[c - 0x80];
3641 } else {
3642 se_length = dtvcc_c0_length[c >> 3];
3643 }
3644
3645 if (left < se_length)
3646 return 0;
3647
3648 return se_length;
3649 }
3650
3651 if (left < 2)
3652 return 0;
3653
3654 c = p[1];
3655 if (0 != (c & 0x60))
3656 return 2;
3657
3658 if ((int8_t) c >= 0) {
3659 se_length = (c >> 3) + 2;
3660 } else if (c < 0x90) {
3661 se_length = (c >> 3) - 10;
3662 } else {
3663 if (left < 3)
3664 return 0;
3665
3666 se_length = (p[2] & 0x1F) + 3;
3667 }
3668
3669 if (left < se_length)
3670 return 0;
3671
3672 return se_length;
3673}
3674
3675void
3676dtvcc_try_decode_packet (struct dtvcc_decoder * dc,
3677 const struct timeval * tv,
3678 int64_t pts)
3679{
3680 unsigned int packet_size_code;
3681 unsigned int packet_size;
3682 unsigned char *p;
3683 int left;
3684
3685 if (dc->packet_size < 1)
3686 return;
3687
3688 packet_size_code = dc->packet[0] & 0x3F;
3689
3690 packet_size = 128;
3691 if (packet_size_code > 0)
3692 packet_size = packet_size_code * 2;
3693
3694 if (packet_size <= dc->packet_size) {
3695 dtvcc_decode_packet(dc, tv, pts);
3696 dc->packet_size = 0;
3697 return;
3698 }
3699
3700 p = dc->packet + 1;
3701 left = dc->packet_size - 1;
3702 while (left > 0) {
3703 unsigned int service_number;
3704 unsigned int block_size;
3705 unsigned int header_size;
3706 unsigned int c;
3707
3708 header_size = 1;
3709
3710 c = p[0];
3711 service_number = (c & 0xE0) >> 5;
3712 if (0 == service_number)
3713 break;
3714
3715 block_size = c & 0x1F;
3716
3717 if (7 == service_number) {
3718 if (left < 2)
3719 break;
3720
3721 header_size = 2;
3722 c = p[1];
3723
3724 if (c < 7 || c > 63)
3725 break;
3726
3727 service_number = c;
3728 }
3729
3730 if (left >= header_size + block_size) {
3731 if (service_number <= 6) {
3732 struct dtvcc_service *ds;
3733 unsigned int in;
3734
3735 ds = &dc->service[service_number - 1];
3736 in = ds->service_data_in;
3737 memcpy (ds->service_data + in,
3738 p + header_size,
3739 block_size);
3740
3741 ds->service_data_in = in + block_size;
3742 }
3743 } else {
3744 unsigned char *s = p + header_size;
3745 int sleft = left - header_size;
3746
3747 while (sleft > 0) {
3748 int se_len;
3749
3750 se_len = dtvcc_get_se_len(s, sleft);
3751 if (se_len <= 0)
3752 break;
3753
3754 s += se_len;
3755 sleft -= se_len;
3756 }
3757
3758 if (sleft != left - header_size) {
3759 int parsed = left - header_size - sleft;
3760
3761 if (service_number <= 6) {
3762 struct dtvcc_service *ds;
3763 unsigned int in;
3764
3765 ds = &dc->service[service_number - 1];
3766 in = ds->service_data_in;
3767 memcpy (ds->service_data + in,
3768 p + header_size,
3769 parsed);
3770
3771 ds->service_data_in = in + parsed;
3772 }
3773
3774 memmove(p + header_size, s, sleft);
3775 block_size -= parsed;
3776 left -= parsed;
3777
3778 p[0] &= ~0x1f;
3779 p[0] |= block_size;
3780 }
3781 break;
3782 }
3783
3784 p += header_size + block_size;
3785 left -= header_size + block_size;
3786 }
3787
3788 if (left != dc->packet_size - 1) {
3789 int parsed = dc->packet_size - 1 - left;
3790
3791 memmove(dc->packet + 1, p, left);
3792
3793 packet_size_code = ((dc->packet[0] & 0x3f) << 1) - parsed;
3794 if (packet_size_code & 1)
3795 packet_size_code ++;
3796 packet_size_code >>= 1;
3797
3798 dc->packet[0] &= ~0x3f;
3799 dc->packet[0] |= packet_size_code;
3800 dc->packet_size = left + 1;
3801
3802 dtvcc_try_decode_channels(dc);
3803 }
3804}
3805
3806static void
3807dtvcc_reset_service (struct dtvcc_service * ds)
3808{
3809 int i;
3810 ds->curr_window = NULL;
3811 ds->created = 0;
3812 ds->delay = 0;
3813 ds->delay_cancel = 0;
3814 struct dtvcc_window *dw;
3815 for (i=0;i<8;i++)
3816 {
3817 dw = &ds->window[i];
3818 ds->window[i].visible = 0;
3819 memset (dw->buffer, 0, sizeof (dw->buffer));
3820 memset (dw->pen, 0, sizeof(dw->pen));
3821
3822 dw->streamed = 0;
3823 }
3824 ds->update = 1;
3825 cc_timestamp_reset (&ds->timestamp);
3826}
3827
3828void
3829dtvcc_reset (struct dtvcc_decoder * dc)
3830{
3831 dtvcc_reset_service (&dc->service[0]);
3832 dtvcc_reset_service (&dc->service[1]);
3833 dc->packet_size = 0;
3834 dc->next_sequence_number = -1;
3835}
3836
3837void
3838dtvcc_init (struct dtvcc_decoder * dc)
3839{
3840 memset(dc, 0, sizeof(struct dtvcc_decoder));
3841 dtvcc_reset (dc);
3842 cc_timestamp_reset (&dc->timestamp);
3843}
3844
3845static void dtvcc_window_to_page(vbi_decoder *vbi, struct dtvcc_window *dw, struct vbi_page *pg)
3846{
3847 int i, j, c;
3848 vbi_char ac;
3849 vbi_opacity fg_opacity, bg_opacity;
3850
3851 static const vbi_opacity vbi_opacity_map[]={
3852 VBI_OPAQUE,
3853 VBI_OPAQUE,
3854 VBI_SEMI_TRANSPARENT,
3855 VBI_TRANSPARENT_SPACE
3856 };
3857
3858 memset(pg, 0, sizeof(struct vbi_page));
3859#if 1
3860 pg->rows = dw->row_count;
3861 pg->columns = dw->column_count;
3862
3863 dtvcc_set_page_color_map(vbi, pg);
3864 memset(dw->row_start, 0, sizeof(dw->row_start));
3865
3866 for (i=0; i<pg->rows; i++)
3867 {
3868 for (j=0; j<pg->columns; j++)
3869 {
3870 memset(&ac, 0, sizeof(ac));
3871 /*use the curr_pen to draw all the text, actually this isn't reasonable*/
3872 if (dw->curr_pen.style.fg_opacity >= N_ELEMENTS(vbi_opacity_map)){
3873 fg_opacity = VBI_OPAQUE;
3874 }else{
3875 fg_opacity = vbi_opacity_map[dw->curr_pen.style.fg_opacity];
3876 }
3877
3878 if (dw->curr_pen.style.bg_opacity >= N_ELEMENTS(vbi_opacity_map)){
3879 bg_opacity = VBI_OPAQUE;
3880 }else{
3881 bg_opacity = vbi_opacity_map[dw->curr_pen.style.bg_opacity];
3882 }
3883
3884 ac.opacity = (fg_opacity<<4) | bg_opacity;
3885 ac.foreground = dtvcc_map_color(dw->curr_pen.style.fg_color);
3886 ac.background = dtvcc_map_color(dw->curr_pen.style.bg_color);
3887
3888 c = dw->buffer[i][j];
3889 if (0 == c) {
3890 ac.unicode = 0x20;
3891 ac.opacity = VBI_TRANSPARENT_SPACE;
3892 dw->row_start[i] ++;
3893 } else {
3894 ac.unicode = dtvcc_unicode (c);
3895 if (0 == ac.unicode) {
3896 ac.unicode = 0x20;
3897 dw->row_start[i] ++;
3898 }
3899 }
3900 pg->text[i*pg->columns + j] = ac;
3901 }
3902 }
3903#else
3904 pg->rows = 15;
3905 pg->columns = 42;
3906 dtvcc_set_page_color_map(vbi, pg);
3907 for (i=0; i<pg->rows; i++)
3908 {
3909 for (j=0; j<pg->columns; j++)
3910 {
3911 memset(&ac, 0, sizeof(ac));
3912 ac.opacity = VBI_OPAQUE;
3913 ac.foreground = VBI_WHITE;
3914 ac.background = VBI_BLACK;
3915 if (j == 0)
3916 c = '0' + (i%10);
3917 else
3918 c = '0' + (j%10);
3919 ac.unicode = dtvcc_unicode (c);
3920 LOGI("TEXT(%x): %c", ac.unicode, ac.unicode);
3921 pg->text[i*pg->columns + j] = ac;
3922 }
3923 }
3924#endif
3925 pg->screen_color = 0;
3926 pg->screen_opacity = VBI_OPAQUE;
3927 //pg->font[0] = vbi_font_descriptors; /* English */
3928 //pg->font[1] = vbi_font_descriptors;
3929}
3930
3931static int dtvcc_compare_window_priority(const void *window1, const void *window2)
3932{
3933 struct dtvcc_window *w1 = (struct dtvcc_window*)window1;
3934 struct dtvcc_window *w2 = (struct dtvcc_window*)window2;
3935
3936 return (w1->priority - w2->priority);
3937}
3938
3939static void dtvcc_get_visible_windows(struct dtvcc_service *ds, int *cnt, struct dtvcc_window **windows)
3940{
3941 int i, j = 0;
3942
3943 for (i=0; i<N_ELEMENTS(ds->window); i++){
3944 if (ds->window[i].visible && j < *cnt){
3945 windows[j++] = &ds->window[i];
3946 }
3947 }
3948
3949 qsort(windows, j, sizeof(windows[0]), dtvcc_compare_window_priority);
3950
3951 *cnt = j;
3952}
3953
3954void tvcc_fetch_page(struct tvcc_decoder *td, int pgno, int *sub_cnt, struct vbi_page *sub_pages)
3955{
3956 int sub_pg = 0;
3957
3958 if (pgno < 1 || pgno > 14 || *sub_cnt <= 0)
3959 goto fetch_done;
3960
3961 if (pgno <= 8){
3962 if (vbi_fetch_cc_page(td->vbi, &sub_pages[0], pgno, 1)){
3963 sub_pg = 1;
3964 sub_pages[0].pgno = pgno;
3965 }
3966 }else{
3967 int i;
3968 struct dtvcc_service *ds = &td->dtvcc.service[pgno - 1 - 8];
3969 struct dtvcc_window *dw;
3970 struct dtvcc_window *visible_windows[8];
3971
3972 sub_pg = *sub_cnt;
3973 if (sub_pg > 8)
3974 sub_pg = 8;
3975
3976 dtvcc_get_visible_windows(ds, &sub_pg, visible_windows);
3977
3978 for (i=0; i<sub_pg; i++){
3979 dw = visible_windows[i];
3980
3981 dtvcc_window_to_page(td->vbi, dw, &sub_pages[i]);
3982 sub_pages[i].vbi = td->vbi;
3983 sub_pages[i].pgno = pgno;
3984 sub_pages[i].subno = dw - ds->window;
3985 }
3986 }
3987
3988fetch_done:
3989 *sub_cnt = sub_pg;
3990}
3991
3992/* ATSC A/53 Part 4:2007 Closed Caption Data decoder */
3993
3994/* Only handle effect */
3995static void update_service_status_internal (struct tvcc_decoder *td)
3996{
3997 int i, j, k, l;
3998 struct timespec ts_now;
3999 struct dtvcc_decoder *decoder;
4000 struct dtvcc_pen_style *target_pen;
4001 int flash;
4002
4003 decoder = &td->dtvcc;
4004 clock_gettime(CLOCK_REALTIME, &ts_now);
4005
4006 flash = (ts_now.tv_nsec / 250000000) & 1;
4007
4008 /* CS1 - CS6 */
4009 for (i = 0; i < 6; ++i)
4010 {
4011 struct dtvcc_service *ds;
4012 struct program *pr;
4013 vbi_bool success;
4014 ds = &decoder->service[i];
4015 /* Check every effect */
4016 if (ds->delay)
4017 {
4018 struct vbi_event event;
4019 /* time is up */
4020 if ((ts_now.tv_sec > ds->delay_timer.tv_sec) ||
4021 ((ts_now.tv_sec == ds->delay_timer.tv_sec) &&(ts_now.tv_nsec > ds->delay_timer.tv_nsec)) ||
4022 ds->delay_cancel)
4023 {
4024 //AM_DEBUG(1, "delay timeup");
4025 ds->delay = 0;
4026 ds->delay_cancel = 0;
4027 dtvcc_decode_syntactic_elements
4028 (decoder, ds, ds->service_data, ds->service_data_in);
4029
4030 ds->service_data_in = 0;
4031 }
4032 }
4033
4034 if (flash == decoder->flash_state)
4035 continue;
4036
4037 for (j = 0; j < 8; j++)
4038 {
4039 /*window flash treatment */
4040 if (ds->window[j].style.window_flash)
4041 {
4042 ds->window[j].style.fill_opacity = flash?0:3;
4043 ds->update = 1;
4044 }
4045
4046 /* Pen flash treatment */
4047 for (k = 0; k < 16; k++)
4048 {
4049 for (l =0; l<42; l++)
4050 {
4051 target_pen = &ds->window[j].pen[k][l];
4052 if (target_pen->bg_flash)
4053 {
4054 target_pen->bg_opacity = flash?0:3;
4055 ds->update = 1;
4056 }
4057 if (target_pen->fg_flash)
4058 {
4059 target_pen->fg_opacity = flash?0:3;
4060 ds->update = 1;
4061 }
4062 }
4063 }
4064 }
4065 }
4066
4067 decoder->flash_state = flash;
4068}
4069
4070static void
4071update_display (struct tvcc_decoder *td)
4072{
4073 int i;
4074
4075 for (i = 0; i < N_ELEMENTS(td->dtvcc.service); i ++) {
4076 struct dtvcc_service *ds = &td->dtvcc.service[i];
4077
4078 if (ds->update) {
4079 struct vbi_event event;
4080
4081 event.type = VBI_EVENT_CAPTION;
4082 event.ev.caption.pgno = i + 1 + 8/*after 8 cc channels*/;
4083
4084 /* Permits calling tvcc_fetch_page from handler */
4085 pthread_mutex_unlock(&td->mutex);
4086
4087 vbi_send_event(td->vbi, &event);
4088 pthread_mutex_lock(&td->mutex);
4089
4090 ds->update = 0;
4091 }
4092 }
4093}
4094
4095
4096/* Note pts may be < 0 if no PTS was received. */
4097void
4098tvcc_decode_data (struct tvcc_decoder *td,
4099 int64_t pts,
4100 const uint8_t * buf,
4101 unsigned int n_bytes)
4102{
4103 unsigned int process_cc_data_flag;
4104 unsigned int cc_count;
4105 unsigned int i;
4106 vbi_bool dtvcc;
4107 struct timeval now;
4108
4109 if (buf[0] != 0x03)
4110 return;
4111 process_cc_data_flag = buf[1] & 0x40;
4112 if (!process_cc_data_flag)
4113 {
4114 return;
4115 }
4116
4117 cc_count = buf[1] & 0x1F;
4118 dtvcc = FALSE;
4119
4120#if 0
4121 printf("tvcc decode %d:\n", n_bytes);
4122 {
4123 int i;
4124
4125 for (i = 0; i < n_bytes; i ++) {
4126 printf("%02x ", buf[i]);
4127 if ((i + 1) % 16 == 0)
4128 printf("\n");
4129 }
4130 printf("\n");
4131 }
4132#endif
4133 pthread_mutex_lock(&td->mutex);
4134
4135 //printf("cc count %d\n", cc_count);
4136
4137 for (i = 0; i < cc_count; ++i) {
4138 unsigned int b0;
4139 unsigned int cc_valid;
4140 enum cc_type cc_type;
4141 unsigned int cc_data_1;
4142 unsigned int cc_data_2;
4143 unsigned int j;
4144
4145 b0 = buf[3 + i * 3];
4146 cc_valid = b0 & 4;
4147 cc_type = (enum cc_type)(b0 & 3);
4148 cc_data_1 = buf[4 + i * 3];
4149 cc_data_2 = buf[5 + i * 3];
4150
4151 //printf("cc type %02x %02x %02x %02x\n", cc_type, cc_valid, cc_data_1, cc_data_2);
4152
4153 switch (cc_type) {
4154 case NTSC_F1:
4155 case NTSC_F2:
4156 //printf("ntsc cc\n");
4157 /* Note CEA 708-C Table 4: Only one NTSC pair
4158 will be present in field picture user_data
4159 or in progressive video pictures, and up to
4160 three can occur if the frame rate < 30 Hz
4161 or repeat_first_field = 1. */
4162 if (!cc_valid || i >= 3 || dtvcc) {
4163 /* Illegal, invalid or filler. */
4164 break;
4165 }
4166#if 0
4167 cc_feed (&td->cc, &buf[12 + i * 3],
4168 /* line */ (NTSC_F1 == cc_type) ? 21 : 284,
4169 &now, pts);
4170#endif
4171 vbi_decode_caption(td->vbi, (NTSC_F1 == cc_type) ? 21 : 284, &buf[4 + i * 3]);
4172 break;
4173
4174 case DTVCC_DATA:
4175 j = td->dtvcc.packet_size;
4176 if (j <= 0) {
4177 /* Missed packet start. */
4178 break;
4179 } else if (!cc_valid) {
4180 /* End of DTVCC packet. */
4181 } else if (j + 2 > 128) {
4182 /* Packet buffer overflow. */
4183 dtvcc_reset (&td->dtvcc);
4184 td->dtvcc.packet_size = 0;
4185 } else {
4186 td->dtvcc.packet[j] = cc_data_1;
4187 td->dtvcc.packet[j + 1] = cc_data_2;
4188 td->dtvcc.packet_size = j + 2;
4189
4190 dtvcc_try_decode_packet (&td->dtvcc, &now, pts);
4191 }
4192 break;
4193
4194 case DTVCC_START:
4195 dtvcc = TRUE;
4196 j = td->dtvcc.packet_size;
4197 if (j > 0) {
4198 /* End of DTVCC packet. */
4199 dtvcc_decode_packet (&td->dtvcc,
4200 &now, pts);
4201 }
4202 if (!cc_valid) {
4203 /* No new data. */
4204 td->dtvcc.packet_size = 0;
4205 } else {
4206 td->dtvcc.packet[0] = cc_data_1;
4207 td->dtvcc.packet[1] = cc_data_2;
4208 td->dtvcc.packet_size = 2;
4209 dtvcc_try_decode_packet(&td->dtvcc, &now, pts);
4210 }
4211 break;
4212 }
4213 }
4214
4215 update_service_status_internal(td);
4216 update_display(td);
4217
4218 pthread_mutex_unlock(&td->mutex);
4219}
4220
4221/* Only handle effect */
4222void update_service_status(struct tvcc_decoder *td)
4223{
4224 pthread_mutex_lock(&td->mutex);
4225
4226 update_service_status_internal(td);
4227 update_display(td);
4228
4229 pthread_mutex_unlock(&td->mutex);
4230}
4231
4232void tvcc_init(struct tvcc_decoder *td)
4233{
4234 pthread_mutex_init(&td->mutex, NULL);
4235 dtvcc_init(&td->dtvcc);
4236 cc_init(&td->cc);
4237 td->vbi = vbi_decoder_new();
4238}
4239
4240void tvcc_destroy(struct tvcc_decoder *td)
4241{
4242 if (td){
4243 vbi_decoder_delete(td->vbi);
4244 td->vbi = NULL;
4245 pthread_mutex_destroy(&td->mutex);
4246 }
4247}
4248
4249void tvcc_reset(struct tvcc_decoder *td)
4250{
4251 dtvcc_reset(&td->dtvcc);
4252 cc_reset(&td->cc);
4253}
4254
4255
generated by cgit at 2024-05-17 01:47:28 (GMT)