?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
codec: cc: rework demux loop to remove local storage
[vlc.git] / modules / codec / cc.c
blobae1ed13997a437259a7836e5f22b989ef2fcbbc0
1 /*****************************************************************************
2 * cc.c : CC 608/708 subtitles decoder
3 *****************************************************************************
4 * Copyright © 2007-2010 Laurent Aimar, 2011 VLC authors and VideoLAN
5 *
6 * Authors: Laurent Aimar < fenrir # via.ecp.fr>
7 *
8 * This program is free software; you can redistribute it and/or modify it
9 * under the terms of the GNU Lesser General Public License as published by
10 * the Free Software Foundation; either version 2.1 of the License, or
11 * (at your option) any later version.
12 *
13 * This program is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU Lesser General Public License for more details.
17 *
18 * You should have received a copy of the GNU Lesser General Public License
19 * along with this program; if not, write to the Free Software Foundation,
20 * Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
21 *****************************************************************************/
22
23 /*****************************************************************************
24 * Preamble
25 *****************************************************************************/
26 /* The EIA 608 decoder part has been initialy based on ccextractor (GPL)
27 * and rewritten */
28
29 /* TODO:
30 * Check parity
31 * 708 decoding
32 */
33
34 #ifdef HAVE_CONFIG_H
35 # include "config.h"
36 #endif
37
38 #include <assert.h>
39
40 #include <vlc_common.h>
41 #include <vlc_plugin.h>
42 #include <vlc_codec.h>
43 #include <vlc_charset.h>
44
45 #include "substext.h"
46
47 /*****************************************************************************
48 * Module descriptor.
49 *****************************************************************************/
50 static int Open ( vlc_object_t * );
51 static void Close( vlc_object_t * );
52
53 #define OPAQUE_TEXT N_("Opacity")
54 #define OPAQUE_LONGTEXT N_("Setting to true " \
55 "makes the text to be boxed and maybe easier to read." )
56
57 vlc_module_begin ()
58 set_shortname( N_("CC 608/708"))
59 set_description( N_("Closed Captions decoder") )
60 set_capability( "spu decoder", 50 )
61 set_category( CAT_INPUT )
62 set_subcategory( SUBCAT_INPUT_SCODEC )
63 set_callbacks( Open, Close )
64
65 add_bool( "cc-opaque", true,
66 OPAQUE_TEXT, OPAQUE_LONGTEXT, false )
67 vlc_module_end ()
68
69 /*****************************************************************************
70 * Local prototypes
71 *****************************************************************************/
72 typedef enum
73 {
74 EIA608_MODE_POPUP = 0,
75 EIA608_MODE_ROLLUP_2 = 1,
76 EIA608_MODE_ROLLUP_3 = 2,
77 EIA608_MODE_ROLLUP_4 = 3,
78 EIA608_MODE_PAINTON = 4,
79 EIA608_MODE_TEXT = 5
80 } eia608_mode_t;
81
82 typedef enum
83 {
84 EIA608_COLOR_WHITE = 0,
85 EIA608_COLOR_GREEN = 1,
86 EIA608_COLOR_BLUE = 2,
87 EIA608_COLOR_CYAN = 3,
88 EIA608_COLOR_RED = 4,
89 EIA608_COLOR_YELLOW = 5,
90 EIA608_COLOR_MAGENTA = 6,
91 EIA608_COLOR_USERDEFINED = 7
92 } eia608_color_t;
93
94 typedef enum
95 {
96 EIA608_FONT_REGULAR = 0x00,
97 EIA608_FONT_ITALICS = 0x01,
98 EIA608_FONT_UNDERLINE = 0x02,
99 EIA608_FONT_UNDERLINE_ITALICS = EIA608_FONT_UNDERLINE | EIA608_FONT_ITALICS
100 } eia608_font_t;
101
102 #define EIA608_SCREEN_ROWS 15
103 #define EIA608_SCREEN_COLUMNS 32
104
105 struct eia608_screen // A CC buffer
106 {
107 uint8_t characters[EIA608_SCREEN_ROWS][EIA608_SCREEN_COLUMNS+1];
108 eia608_color_t colors[EIA608_SCREEN_ROWS][EIA608_SCREEN_COLUMNS+1];
109 eia608_font_t fonts[EIA608_SCREEN_ROWS][EIA608_SCREEN_COLUMNS+1]; // Extra char at the end for a 0
110 int row_used[EIA608_SCREEN_ROWS]; // Any data in row?
111 };
112 typedef struct eia608_screen eia608_screen;
113
114 typedef enum
115 {
116 EIA608_STATUS_DEFAULT = 0x00,
117 EIA608_STATUS_CHANGED = 0x01, /* current screen has been altered */
118 EIA608_STATUS_CAPTION_ENDED = 0x02, /* screen flip */
119 EIA608_STATUS_CAPTION_CLEARED = 0x04, /* active screen erased */
120 EIA608_STATUS_DISPLAY = EIA608_STATUS_CAPTION_CLEARED | EIA608_STATUS_CAPTION_ENDED,
121 } eia608_status_t;
122
123 static const struct {
124 eia608_color_t i_color;
125 eia608_font_t i_font;
126 int i_column;
127 } pac2_attribs[]= {
128 { EIA608_COLOR_WHITE, EIA608_FONT_REGULAR, 0 },
129 { EIA608_COLOR_WHITE, EIA608_FONT_UNDERLINE, 0 },
130 { EIA608_COLOR_GREEN, EIA608_FONT_REGULAR, 0 },
131 { EIA608_COLOR_GREEN, EIA608_FONT_UNDERLINE, 0 },
132 { EIA608_COLOR_BLUE, EIA608_FONT_REGULAR, 0 },
133 { EIA608_COLOR_BLUE, EIA608_FONT_UNDERLINE, 0 },
134 { EIA608_COLOR_CYAN, EIA608_FONT_REGULAR, 0 },
135 { EIA608_COLOR_CYAN, EIA608_FONT_UNDERLINE, 0 },
136 { EIA608_COLOR_RED, EIA608_FONT_REGULAR, 0 },
137 { EIA608_COLOR_RED, EIA608_FONT_UNDERLINE, 0 },
138 { EIA608_COLOR_YELLOW, EIA608_FONT_REGULAR, 0 },
139 { EIA608_COLOR_YELLOW, EIA608_FONT_UNDERLINE, 0 },
140 { EIA608_COLOR_MAGENTA, EIA608_FONT_REGULAR, 0 },
141 { EIA608_COLOR_MAGENTA, EIA608_FONT_UNDERLINE, 0 },
142 { EIA608_COLOR_WHITE, EIA608_FONT_ITALICS, 0 },
143 { EIA608_COLOR_WHITE, EIA608_FONT_UNDERLINE_ITALICS, 0 },
144
145 { EIA608_COLOR_WHITE, EIA608_FONT_REGULAR, 0 },
146 { EIA608_COLOR_WHITE, EIA608_FONT_UNDERLINE, 0 },
147 { EIA608_COLOR_WHITE, EIA608_FONT_REGULAR, 4 },
148 { EIA608_COLOR_WHITE, EIA608_FONT_UNDERLINE, 4 },
149 { EIA608_COLOR_WHITE, EIA608_FONT_REGULAR, 8 },
150 { EIA608_COLOR_WHITE, EIA608_FONT_UNDERLINE, 8 },
151 { EIA608_COLOR_WHITE, EIA608_FONT_REGULAR, 12 },
152 { EIA608_COLOR_WHITE, EIA608_FONT_UNDERLINE, 12 },
153 { EIA608_COLOR_WHITE, EIA608_FONT_REGULAR, 16 },
154 { EIA608_COLOR_WHITE, EIA608_FONT_UNDERLINE, 16 },
155 { EIA608_COLOR_WHITE, EIA608_FONT_REGULAR, 20 },
156 { EIA608_COLOR_WHITE, EIA608_FONT_UNDERLINE, 20 },
157 { EIA608_COLOR_WHITE, EIA608_FONT_REGULAR, 24 },
158 { EIA608_COLOR_WHITE, EIA608_FONT_UNDERLINE, 24 },
159 { EIA608_COLOR_WHITE, EIA608_FONT_REGULAR, 28 },
160 { EIA608_COLOR_WHITE, EIA608_FONT_UNDERLINE, 28 } ,
161 };
162
163 #define EIA608_COLOR_DEFAULT EIA608_COLOR_WHITE
164
165 static const int rgi_eia608_colors[] = {
166 0xffffff, // white
167 0x00ff00, // green
168 0x0000ff, // blue
169 0x00ffff, // cyan
170 0xff0000, // red
171 0xffff00, // yellow
172 0xff00ff, // magenta
173 0xffffff, // user defined XXX we use white
174 };
175
176 typedef struct
177 {
178 /* Current channel (used to reject packet without channel information) */
179 int i_channel;
180
181 /* */
182 int i_screen; /* Displayed screen */
183 eia608_screen screen[2];
184
185 struct
186 {
187 int i_row;
188 int i_column;
189 } cursor;
190
191 /* */
192 eia608_mode_t mode;
193 eia608_color_t color;
194 eia608_font_t font;
195 int i_row_rollup;
196
197 /* Last command pair (used to reject duplicated command) */
198 struct
199 {
200 uint8_t d1;
201 uint8_t d2;
202 } last;
203 } eia608_t;
204
205 static void Eia608Init( eia608_t * );
206 static eia608_status_t Eia608Parse( eia608_t *h, int i_channel_selected, const uint8_t data[2] );
207 static void Eia608FillUpdaterRegions( subpicture_updater_sys_t *p_updater, eia608_t *h );
208
209 /* It will be enough up to 63 B frames, which is far too high for
210 * broadcast environment */
211 #define CC_MAX_REORDER_SIZE (64)
212 struct decoder_sys_t
213 {
214 int i_queue;
215 block_t *p_queue;
216
217 int i_field;
218 int i_channel;
219
220 int i_reorder_depth;
221
222 eia608_t eia608;
223 bool b_opaque;
224 };
225
226 static int Decode( decoder_t *, block_t * );
227 static void Flush( decoder_t * );
228
229 /*****************************************************************************
230 * Open: probe the decoder and return score
231 *****************************************************************************
232 * Tries to launch a decoder and return score so that the interface is able
233 * to chose.
234 *****************************************************************************/
235 static int Open( vlc_object_t *p_this )
236 {
237 decoder_t *p_dec = (decoder_t*)p_this;
238 decoder_sys_t *p_sys;
239 int i_field;
240 int i_channel;
241
242 switch( p_dec->fmt_in.i_codec )
243 {
244 case VLC_CODEC_EIA608_1:
245 i_field = 0; i_channel = 1;
246 break;
247 case VLC_CODEC_EIA608_2:
248 i_field = 0; i_channel = 2;
249 break;
250 case VLC_CODEC_EIA608_3:
251 i_field = 1; i_channel = 1;
252 break;
253 case VLC_CODEC_EIA608_4:
254 i_field = 1; i_channel = 2;
255 break;
256
257 default:
258 return VLC_EGENERIC;
259 }
260
261 p_dec->pf_decode = Decode;
262 p_dec->pf_flush = Flush;
263
264 /* Allocate the memory needed to store the decoder's structure */
265 p_dec->p_sys = p_sys = calloc( 1, sizeof( *p_sys ) );
266 if( p_sys == NULL )
267 return VLC_ENOMEM;
268
269 /* init of p_sys */
270 p_sys->i_field = i_field;
271 p_sys->i_channel = i_channel;
272
273 Eia608Init( &p_sys->eia608 );
274 p_sys->b_opaque = var_InheritBool( p_dec, "cc-opaque" );
275 p_sys->i_reorder_depth = p_dec->fmt_in.subs.cc.i_reorder_depth;
276
277 p_dec->fmt_out.i_codec = VLC_CODEC_TEXT;
278
279 return VLC_SUCCESS;
280 }
281
282 /*****************************************************************************
283 * Flush:
284 *****************************************************************************/
285 static void Flush( decoder_t *p_dec )
286 {
287 decoder_sys_t *p_sys = p_dec->p_sys;
288
289 Eia608Init( &p_sys->eia608 );
290
291 block_ChainRelease( p_sys->p_queue );
292 p_sys->p_queue = NULL;
293 p_sys->i_queue = 0;
294 }
295
296 /****************************************************************************
297 * Decode: the whole thing
298 ****************************************************************************
299 *
300 ****************************************************************************/
301 static void Push( decoder_t *, block_t * );
302 static block_t *Pop( decoder_t *, bool );
303 static void Convert( decoder_t *, mtime_t, const uint8_t *, size_t );
304
305 static bool DoDecode( decoder_t *p_dec, bool b_drain )
306 {
307 block_t *p_block = Pop( p_dec, b_drain );
308 if( !p_block )
309 return false;
310
311 Convert( p_dec, p_block->i_pts, p_block->p_buffer, p_block->i_buffer );
312 block_Release( p_block );
313
314 return true;
315 }
316
317 static int Decode( decoder_t *p_dec, block_t *p_block )
318 {
319 decoder_sys_t *p_sys = p_dec->p_sys;
320
321 if( p_block )
322 {
323 /* Reset decoder if needed */
324 if( p_block->i_flags & (BLOCK_FLAG_DISCONTINUITY | BLOCK_FLAG_CORRUPTED) )
325 {
326 /* Drain */
327 for( ; DoDecode( p_dec, true ) ; );
328 Eia608Init( &p_sys->eia608 );
329
330 if( (p_block->i_flags & BLOCK_FLAG_CORRUPTED) || p_block->i_buffer < 1 )
331 {
332 block_Release( p_block );
333 return VLCDEC_SUCCESS;
334 }
335 }
336
337 /* XXX Cc captions data are OUT OF ORDER (because we receive them in the bitstream
338 * order (ie ordered by video picture dts) instead of the display order.
339 * We will simulate a simple IPB buffer scheme
340 * and reorder with pts.
341 * XXX it won't work with H264 which use non out of order B picture or MMCO */
342 if( p_sys->i_reorder_depth == 0 )
343 {
344 /* Wait for a P and output all *previous* picture by pts order (for
345 * hierarchical B frames) */
346 if( (p_block->i_flags & BLOCK_FLAG_TYPE_B) == 0 )
347 for( ; DoDecode( p_dec, true ); );
348 }
349
350 Push( p_dec, p_block );
351 }
352
353 for( ; DoDecode( p_dec, (p_block == NULL) ); );
354
355 return VLCDEC_SUCCESS;
356 }
357
358 /*****************************************************************************
359 * CloseDecoder: clean up the decoder
360 *****************************************************************************/
361 static void Close( vlc_object_t *p_this )
362 {
363 decoder_t *p_dec = (decoder_t *)p_this;
364 decoder_sys_t *p_sys = p_dec->p_sys;
365
366 block_ChainRelease( p_sys->p_queue );
367 free( p_sys );
368 }
369
370 /*****************************************************************************
371 *
372 *****************************************************************************/
373 static void Push( decoder_t *p_dec, block_t *p_block )
374 {
375 decoder_sys_t *p_sys = p_dec->p_sys;
376
377 if( p_sys->i_queue >= CC_MAX_REORDER_SIZE )
378 {
379 block_Release( Pop( p_dec, true ) );
380 msg_Warn( p_dec, "Trashing a CC entry" );
381 }
382
383 block_t **pp_block;
384 /* find insertion point */
385 for( pp_block = &p_sys->p_queue; *pp_block ; pp_block = &((*pp_block)->p_next) )
386 {
387 if( p_block->i_pts == VLC_TS_INVALID || (*pp_block)->i_pts == VLC_TS_INVALID )
388 continue;
389 if( p_block->i_pts < (*pp_block)->i_pts )
390 {
391 if( p_sys->i_reorder_depth > 0 &&
392 p_sys->i_queue < p_sys->i_reorder_depth &&
393 pp_block == &p_sys->p_queue )
394 {
395 msg_Info( p_dec, "Increasing reorder depth to %d", ++p_sys->i_reorder_depth );
396 }
397 break;
398 }
399 }
400 /* Insert, keeping a pts and/or fifo ordered list */
401 p_block->p_next = *pp_block ? *pp_block : NULL;
402 *pp_block = p_block;
403 p_sys->i_queue++;
404 }
405
406 static block_t *Pop( decoder_t *p_dec, bool b_forced )
407 {
408 decoder_sys_t *p_sys = p_dec->p_sys;
409 block_t *p_block;
410
411 if( p_sys->i_queue == 0 )
412 return NULL;
413
414 if( !b_forced && p_sys->i_queue < CC_MAX_REORDER_SIZE )
415 {
416 if( p_sys->i_queue < p_sys->i_reorder_depth || p_sys->i_reorder_depth == 0 )
417 return NULL;
418 }
419
420 /* dequeue head */
421 p_block = p_sys->p_queue;
422 p_sys->p_queue = p_block->p_next;
423 p_block->p_next = NULL;
424 p_sys->i_queue--;
425
426 return p_block;
427 }
428
429 static subpicture_t *Subtitle( decoder_t *p_dec, eia608_t *h, mtime_t i_pts )
430 {
431 //decoder_sys_t *p_sys = p_dec->p_sys;
432 subpicture_t *p_spu = NULL;
433
434 /* We cannot display a subpicture with no date */
435 if( i_pts <= VLC_TS_INVALID )
436 return NULL;
437
438 /* Create the subpicture unit */
439 p_spu = decoder_NewSubpictureText( p_dec );
440 if( !p_spu )
441 return NULL;
442
443 p_spu->i_start = i_pts;
444 p_spu->i_stop = i_pts + 10000000; /* 10s max */
445 p_spu->b_ephemer = true;
446 p_spu->b_absolute = false;
447
448 subpicture_updater_sys_t *p_spu_sys = p_spu->updater.p_sys;
449
450 /* The "leavetext" alignment is a special mode where the subpicture
451 region itself gets aligned, but the text inside it does not */
452 p_spu_sys->region.align = SUBPICTURE_ALIGN_TOP;
453 p_spu_sys->region.inner_align = SUBPICTURE_ALIGN_LEAVETEXT;
454 p_spu_sys->region.flags = UPDT_REGION_IGNORE_BACKGROUND | UPDT_REGION_USES_GRID_COORDINATES;
455 /* Set style defaults (will be added to segments if none set) */
456 p_spu_sys->p_default_style->i_style_flags |= STYLE_MONOSPACED;
457 if( p_dec->p_sys->b_opaque )
458 {
459 p_spu_sys->p_default_style->i_background_alpha = STYLE_ALPHA_OPAQUE;
460 p_spu_sys->p_default_style->i_features |= STYLE_HAS_BACKGROUND_ALPHA;
461 p_spu_sys->p_default_style->i_style_flags |= STYLE_BACKGROUND;
462 }
463 p_spu_sys->p_default_style->i_font_color = rgi_eia608_colors[EIA608_COLOR_DEFAULT];
464 /* FCC defined "safe area" for EIA-608 captions is 80% of the height of the display */
465 p_spu_sys->p_default_style->f_font_relsize = 100 * 8 / 10 / EIA608_SCREEN_ROWS;
466 p_spu_sys->p_default_style->i_features |= (STYLE_HAS_FONT_COLOR | STYLE_HAS_FLAGS);
467
468 Eia608FillUpdaterRegions( p_spu_sys, h );
469
470 return p_spu;
471 }
472
473 static void Convert( decoder_t *p_dec, mtime_t i_pts,
474 const uint8_t *p_buffer, size_t i_buffer )
475 {
476 decoder_sys_t *p_sys = p_dec->p_sys;
477
478 size_t i_ticks = 0;
479 while( i_buffer >= 3 )
480 {
481 /* Mask off the specific i_field bit, else some sequences can be lost. */
482 if ( (p_buffer[0] & 0x03) == p_sys->i_field &&
483 (p_buffer[0] & 0x04) /* Valid bit */ )
484 {
485 eia608_status_t i_status =
486 Eia608Parse( &p_sys->eia608, p_sys->i_channel, &p_buffer[1] );
487
488 /* a caption is ready or removed, process its screen */
489 /*
490 * In case of rollup/painton with 1 packet/frame, we need to update on Changed status.
491 * Batch decoding might be incorrect if those in large number of commands (mp4, ...) then.
492 * see CEAv1.2zero.trp tests
493 */
494 if( i_status & (EIA608_STATUS_DISPLAY | EIA608_STATUS_CHANGED) )
495 {
496 subpicture_t *p_spu = Subtitle( p_dec, &p_sys->eia608, i_pts + i_ticks * CLOCK_FREQ / 30 );
497 if( p_spu )
498 decoder_QueueSub( p_dec, p_spu );
499 }
500 }
501 i_ticks++;
502
503 i_buffer -= 3;
504 p_buffer += 3;
505 }
506 }
507
508
509 /*****************************************************************************
510 *
511 *****************************************************************************/
512 static void Eia608Cursor( eia608_t *h, int dx )
513 {
514 h->cursor.i_column += dx;
515 if( h->cursor.i_column < 0 )
516 h->cursor.i_column = 0;
517 else if( h->cursor.i_column > EIA608_SCREEN_COLUMNS-1 )
518 h->cursor.i_column = EIA608_SCREEN_COLUMNS-1;
519 }
520 static void Eia608ClearScreenRowX( eia608_t *h, int i_screen, int i_row, int x )
521 {
522 eia608_screen *screen = &h->screen[i_screen];
523
524 if( x == 0 )
525 {
526 screen->row_used[i_row] = false;
527 }
528 else
529 {
530 screen->row_used[i_row] = false;
531 for( int i = 0; i < x; i++ )
532 {
533 if( screen->characters[i_row][i] != ' ' ||
534 screen->colors[i_row][i] != EIA608_COLOR_DEFAULT ||
535 screen->fonts[i_row][i] != EIA608_FONT_REGULAR )
536 {
537 screen->row_used[i_row] = true;
538 break;
539 }
540 }
541 }
542
543 for( ; x < EIA608_SCREEN_COLUMNS+1; x++ )
544 {
545 screen->characters[i_row][x] = x < EIA608_SCREEN_COLUMNS ? ' ' : '\0';
546 screen->colors[i_row][x] = EIA608_COLOR_DEFAULT;
547 screen->fonts[i_row][x] = EIA608_FONT_REGULAR;
548 }
549 }
550
551 static void Eia608ClearScreenRow( eia608_t *h, int i_screen, int i_row )
552 {
553 Eia608ClearScreenRowX( h, i_screen, i_row, 0 );
554 }
555
556 static void Eia608ClearScreen( eia608_t *h, int i_screen )
557 {
558 for( int i = 0; i < EIA608_SCREEN_ROWS; i++ )
559 Eia608ClearScreenRow( h, i_screen, i );
560 }
561
562 static int Eia608GetWritingScreenIndex( eia608_t *h )
563 {
564 switch( h->mode )
565 {
566 case EIA608_MODE_POPUP: // Non displayed screen
567 return 1 - h->i_screen;
568
569 case EIA608_MODE_ROLLUP_2: // Displayed screen
570 case EIA608_MODE_ROLLUP_3:
571 case EIA608_MODE_ROLLUP_4:
572 case EIA608_MODE_PAINTON:
573 return h->i_screen;
574 default:
575 /* It cannot happen, else it is a bug */
576 vlc_assert_unreachable();
577 return 0;
578 }
579 }
580
581 static void Eia608EraseScreen( eia608_t *h, bool b_displayed )
582 {
583 Eia608ClearScreen( h, b_displayed ? h->i_screen : (1-h->i_screen) );
584 }
585
586 static void Eia608Write( eia608_t *h, const uint8_t c )
587 {
588 const int i_row = h->cursor.i_row;
589 const int i_column = h->cursor.i_column;
590 eia608_screen *screen;
591
592 if( h->mode == EIA608_MODE_TEXT )
593 return;
594
595 screen = &h->screen[Eia608GetWritingScreenIndex( h )];
596
597 screen->characters[i_row][i_column] = c;
598 screen->colors[i_row][i_column] = h->color;
599 screen->fonts[i_row][i_column] = h->font;
600 screen->row_used[i_row] = true;
601 Eia608Cursor( h, 1 );
602 }
603 static void Eia608Erase( eia608_t *h )
604 {
605 const int i_row = h->cursor.i_row;
606 const int i_column = h->cursor.i_column - 1;
607 eia608_screen *screen;
608
609 if( h->mode == EIA608_MODE_TEXT )
610 return;
611 if( i_column < 0 )
612 return;
613
614 screen = &h->screen[Eia608GetWritingScreenIndex( h )];
615
616 /* FIXME do we need to reset row_used/colors/font ? */
617 screen->characters[i_row][i_column] = ' ';
618 Eia608Cursor( h, -1 );
619 }
620 static void Eia608EraseToEndOfRow( eia608_t *h )
621 {
622 if( h->mode == EIA608_MODE_TEXT )
623 return;
624
625 Eia608ClearScreenRowX( h, Eia608GetWritingScreenIndex( h ), h->cursor.i_row, h->cursor.i_column );
626 }
627
628 static void Eia608RollUp( eia608_t *h )
629 {
630 if( h->mode == EIA608_MODE_TEXT )
631 return;
632
633 const int i_screen = Eia608GetWritingScreenIndex( h );
634 eia608_screen *screen = &h->screen[i_screen];
635
636 int keep_lines;
637
638 /* Window size */
639 if( h->mode == EIA608_MODE_ROLLUP_2 )
640 keep_lines = 2;
641 else if( h->mode == EIA608_MODE_ROLLUP_3 )
642 keep_lines = 3;
643 else if( h->mode == EIA608_MODE_ROLLUP_4 )
644 keep_lines = 4;
645 else
646 return;
647
648 /* Reset the cursor */
649 h->cursor.i_column = 0;
650
651 /* Erase lines above our window */
652 for( int i = 0; i < h->cursor.i_row - keep_lines; i++ )
653 Eia608ClearScreenRow( h, i_screen, i );
654
655 /* Move up */
656 for( int i = 0; i < keep_lines-1; i++ )
657 {
658 const int i_row = h->cursor.i_row - keep_lines + i + 1;
659 if( i_row < 0 )
660 continue;
661 assert( i_row+1 < EIA608_SCREEN_ROWS );
662 memcpy( screen->characters[i_row], screen->characters[i_row+1], sizeof(*screen->characters) );
663 memcpy( screen->colors[i_row], screen->colors[i_row+1], sizeof(*screen->colors) );
664 memcpy( screen->fonts[i_row], screen->fonts[i_row+1], sizeof(*screen->fonts) );
665 screen->row_used[i_row] = screen->row_used[i_row+1];
666 }
667 /* Reset current row */
668 Eia608ClearScreenRow( h, i_screen, h->cursor.i_row );
669 }
670 static void Eia608ParseChannel( eia608_t *h, const uint8_t d[2] )
671 {
672 /* Check odd parity */
673 static const int p4[16] = {
674 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0, 1, 0, 1, 1, 0
675 };
676 if( p4[d[0] & 0xf] == p4[d[0] >> 4] ||
677 p4[d[1] & 0xf] == p4[ d[1] >> 4] )
678 {
679 h->i_channel = -1;
680 return;
681 }
682
683 /* */
684 const int d1 = d[0] & 0x7f;
685 if( d1 >= 0x10 && d1 <= 0x1f )
686 h->i_channel = 1 + ((d1 & 0x08) != 0);
687 else if( d1 < 0x10 )
688 h->i_channel = 3;
689 }
690 static eia608_status_t Eia608ParseTextAttribute( eia608_t *h, uint8_t d2 )
691 {
692 const int i_index = d2 - 0x20;
693 assert( d2 >= 0x20 && d2 <= 0x2f );
694
695 h->color = pac2_attribs[i_index].i_color;
696 h->font = pac2_attribs[i_index].i_font;
697 Eia608Cursor( h, 1 );
698
699 return EIA608_STATUS_DEFAULT;
700 }
701 static eia608_status_t Eia608ParseSingle( eia608_t *h, const uint8_t dx )
702 {
703 assert( dx >= 0x20 );
704 Eia608Write( h, dx );
705 return EIA608_STATUS_CHANGED;
706 }
707 static eia608_status_t Eia608ParseDouble( eia608_t *h, uint8_t d2 )
708 {
709 assert( d2 >= 0x30 && d2 <= 0x3f );
710 Eia608Write( h, d2 + 0x50 ); /* We use charaters 0x80...0x8f */
711 return EIA608_STATUS_CHANGED;
712 }
713 static eia608_status_t Eia608ParseExtended( eia608_t *h, uint8_t d1, uint8_t d2 )
714 {
715 assert( d2 >= 0x20 && d2 <= 0x3f );
716 assert( d1 == 0x12 || d1 == 0x13 );
717 if( d1 == 0x12 )
718 d2 += 0x70; /* We use charaters 0x90-0xaf */
719 else
720 d2 += 0x90; /* We use charaters 0xb0-0xcf */
721
722 /* The extended characters replace the previous one with a more
723 * advanced one */
724 Eia608Cursor( h, -1 );
725 Eia608Write( h, d2 );
726 return EIA608_STATUS_CHANGED;
727 }
728 static eia608_status_t Eia608ParseCommand0x14( eia608_t *h, uint8_t d2 )
729 {
730 eia608_status_t i_status = EIA608_STATUS_DEFAULT;
731
732 switch( d2 )
733 {
734 case 0x20: /* Resume caption loading */
735 h->mode = EIA608_MODE_POPUP;
736 break;
737 case 0x21: /* Backspace */
738 Eia608Erase( h );
739 i_status = EIA608_STATUS_CHANGED;
740 break;
741 case 0x22: /* Reserved */
742 case 0x23:
743 break;
744 case 0x24: /* Delete to end of row */
745 Eia608EraseToEndOfRow( h );
746 break;
747 case 0x25: /* Rollup 2 */
748 case 0x26: /* Rollup 3 */
749 case 0x27: /* Rollup 4 */
750 if( h->mode == EIA608_MODE_POPUP || h->mode == EIA608_MODE_PAINTON )
751 {
752 Eia608EraseScreen( h, true );
753 Eia608EraseScreen( h, false );
754 i_status = EIA608_STATUS_CHANGED | EIA608_STATUS_CAPTION_CLEARED;
755 }
756
757 if( d2 == 0x25 )
758 h->mode = EIA608_MODE_ROLLUP_2;
759 else if( d2 == 0x26 )
760 h->mode = EIA608_MODE_ROLLUP_3;
761 else
762 h->mode = EIA608_MODE_ROLLUP_4;
763
764 h->cursor.i_column = 0;
765 h->cursor.i_row = h->i_row_rollup;
766 break;
767 case 0x28: /* Flash on */
768 /* TODO */
769 break;
770 case 0x29: /* Resume direct captionning */
771 h->mode = EIA608_MODE_PAINTON;
772 break;
773 case 0x2a: /* Text restart */
774 /* TODO */
775 break;
776
777 case 0x2b: /* Resume text display */
778 h->mode = EIA608_MODE_TEXT;
779 break;
780
781 case 0x2c: /* Erase displayed memory */
782 Eia608EraseScreen( h, true );
783 i_status = EIA608_STATUS_CHANGED | EIA608_STATUS_CAPTION_CLEARED;
784 break;
785 case 0x2d: /* Carriage return */
786 Eia608RollUp(h);
787 i_status = EIA608_STATUS_CHANGED;
788 break;
789 case 0x2e: /* Erase non displayed memory */
790 Eia608EraseScreen( h, false );
791 break;
792 case 0x2f: /* End of caption (flip screen if not paint on) */
793 if( h->mode != EIA608_MODE_PAINTON )
794 h->i_screen = 1 - h->i_screen;
795 h->mode = EIA608_MODE_POPUP;
796 h->cursor.i_column = 0;
797 h->cursor.i_row = 0;
798 h->color = EIA608_COLOR_DEFAULT;
799 h->font = EIA608_FONT_REGULAR;
800 i_status = EIA608_STATUS_CHANGED | EIA608_STATUS_CAPTION_ENDED;
801 break;
802 }
803 return i_status;
804 }
805 static bool Eia608ParseCommand0x17( eia608_t *h, uint8_t d2 )
806 {
807 switch( d2 )
808 {
809 case 0x21: /* Tab offset 1 */
810 Eia608Cursor( h, 1 );
811 break;
812 case 0x22: /* Tab offset 2 */
813 Eia608Cursor( h, 2 );
814 break;
815 case 0x23: /* Tab offset 3 */
816 Eia608Cursor( h, 3 );
817 break;
818 }
819 return false;
820 }
821 static bool Eia608ParsePac( eia608_t *h, uint8_t d1, uint8_t d2 )
822 {
823 static const int pi_row[] = {
824 11, -1, 1, 2, 3, 4, 12, 13, 14, 15, 5, 6, 7, 8, 9, 10
825 };
826 const int i_row_index = ( (d1<<1) & 0x0e) | ( (d2>>5) & 0x01 );
827
828 assert( d2 >= 0x40 && d2 <= 0x7f );
829
830 if( pi_row[i_row_index] <= 0 )
831 return false;
832
833 /* Row */
834 if( h->mode != EIA608_MODE_TEXT )
835 h->cursor.i_row = pi_row[i_row_index] - 1;
836 h->i_row_rollup = pi_row[i_row_index] - 1;
837 /* Column */
838 if( d2 >= 0x60 )
839 d2 -= 0x60;
840 else if( d2 >= 0x40 )
841 d2 -= 0x40;
842 h->cursor.i_column = pac2_attribs[d2].i_column;
843 h->color = pac2_attribs[d2].i_color;
844 h->font = pac2_attribs[d2].i_font;
845
846 return false;
847 }
848
849 static eia608_status_t Eia608ParseData( eia608_t *h, uint8_t d1, uint8_t d2 )
850 {
851 eia608_status_t i_status = EIA608_STATUS_DEFAULT;
852
853 if( d1 >= 0x18 && d1 <= 0x1f )
854 d1 -= 8;
855
856 #define ON( d2min, d2max, cmd ) do { if( d2 >= d2min && d2 <= d2max ) i_status = cmd; } while(0)
857 switch( d1 )
858 {
859 case 0x11:
860 ON( 0x20, 0x2f, Eia608ParseTextAttribute( h, d2 ) );
861 ON( 0x30, 0x3f, Eia608ParseDouble( h, d2 ) );
862 break;
863 case 0x12: case 0x13:
864 ON( 0x20, 0x3f, Eia608ParseExtended( h, d1, d2 ) );
865 break;
866 case 0x14: case 0x15:
867 ON( 0x20, 0x2f, Eia608ParseCommand0x14( h, d2 ) );
868 break;
869 case 0x17:
870 ON( 0x21, 0x23, Eia608ParseCommand0x17( h, d2 ) );
871 ON( 0x2e, 0x2f, Eia608ParseTextAttribute( h, d2 ) );
872 break;
873 }
874 if( d1 == 0x10 )
875 ON( 0x40, 0x5f, Eia608ParsePac( h, d1, d2 ) );
876 else if( d1 >= 0x11 && d1 <= 0x17 )
877 ON( 0x40, 0x7f, Eia608ParsePac( h, d1, d2 ) );
878 #undef ON
879 if( d1 >= 0x20 )
880 {
881 i_status = Eia608ParseSingle( h, d1 );
882 if( d2 >= 0x20 )
883 i_status |= Eia608ParseSingle( h, d2 );
884 }
885
886 /* Ignore changes occuring to doublebuffer */
887 if( h->mode == EIA608_MODE_POPUP && i_status == EIA608_STATUS_CHANGED )
888 i_status = EIA608_STATUS_DEFAULT;
889
890 return i_status;
891 }
892
893 static void Eia608TextUtf8( char *psz_utf8, uint8_t c ) // Returns number of bytes used
894 {
895 #define E1(c,u) { c, { u, '\0' } }
896 #define E2(c,u1,u2) { c, { u1, u2, '\0' } }
897 #define E3(c,u1,u2,u3) { c, { u1, u2, u3, '\0' } }
898 static const struct {
899 uint8_t c;
900 char utf8[3+1];
901 } c2utf8[] = {
902 // Regular line-21 character set, mostly ASCII except these exceptions
903 E2( 0x2a, 0xc3,0xa1), // lowercase a, acute accent
904 E2( 0x5c, 0xc3,0xa9), // lowercase e, acute accent
905 E2( 0x5e, 0xc3,0xad), // lowercase i, acute accent
906 E2( 0x5f, 0xc3,0xb3), // lowercase o, acute accent
907 E2( 0x60, 0xc3,0xba), // lowercase u, acute accent
908 E2( 0x7b, 0xc3,0xa7), // lowercase c with cedilla
909 E2( 0x7c, 0xc3,0xb7), // division symbol
910 E2( 0x7d, 0xc3,0x91), // uppercase N tilde
911 E2( 0x7e, 0xc3,0xb1), // lowercase n tilde
912 // THIS BLOCK INCLUDES THE 16 EXTENDED (TWO-BYTE) LINE 21 CHARACTERS
913 // THAT COME FROM HI BYTE=0x11 AND LOW BETWEEN 0x30 AND 0x3F
914 E2( 0x80, 0xc2,0xae), // Registered symbol (R)
915 E2( 0x81, 0xc2,0xb0), // degree sign
916 E2( 0x82, 0xc2,0xbd), // 1/2 symbol
917 E2( 0x83, 0xc2,0xbf), // Inverted (open) question mark
918 E3( 0x84, 0xe2,0x84,0xa2), // Trademark symbol (TM)
919 E2( 0x85, 0xc2,0xa2), // Cents symbol
920 E2( 0x86, 0xc2,0xa3), // Pounds sterling
921 E3( 0x87, 0xe2,0x99,0xaa), // Music note
922 E2( 0x88, 0xc3,0xa0), // lowercase a, grave accent
923 E2( 0x89, 0xc2,0xa0), // transparent space
924 E2( 0x8a, 0xc3,0xa8), // lowercase e, grave accent
925 E2( 0x8b, 0xc3,0xa2), // lowercase a, circumflex accent
926 E2( 0x8c, 0xc3,0xaa), // lowercase e, circumflex accent
927 E2( 0x8d, 0xc3,0xae), // lowercase i, circumflex accent
928 E2( 0x8e, 0xc3,0xb4), // lowercase o, circumflex accent
929 E2( 0x8f, 0xc3,0xbb), // lowercase u, circumflex accent
930 // THIS BLOCK INCLUDES THE 32 EXTENDED (TWO-BYTE) LINE 21 CHARACTERS
931 // THAT COME FROM HI BYTE=0x12 AND LOW BETWEEN 0x20 AND 0x3F
932 E2( 0x90, 0xc3,0x81), // capital letter A with acute
933 E2( 0x91, 0xc3,0x89), // capital letter E with acute
934 E2( 0x92, 0xc3,0x93), // capital letter O with acute
935 E2( 0x93, 0xc3,0x9a), // capital letter U with acute
936 E2( 0x94, 0xc3,0x9c), // capital letter U with diaresis
937 E2( 0x95, 0xc3,0xbc), // lowercase letter U with diaeresis
938 E1( 0x96, 0x27), // apostrophe
939 E2( 0x97, 0xc2,0xa1), // inverted exclamation mark
940 E1( 0x98, 0x2a), // asterisk
941 E1( 0x99, 0x27), // apostrophe (yes, duped). See CCADI source code.
942 E1( 0x9a, 0x2d), // hyphen-minus
943 E2( 0x9b, 0xc2,0xa9), // copyright sign
944 E3( 0x9c, 0xe2,0x84,0xa0), // Service mark
945 E1( 0x9d, 0x2e), // Full stop (.)
946 E3( 0x9e, 0xe2,0x80,0x9c), // Quotation mark
947 E3( 0x9f, 0xe2,0x80,0x9d), // Quotation mark
948 E2( 0xa0, 0xc3,0x80), // uppercase A, grave accent
949 E2( 0xa1, 0xc3,0x82), // uppercase A, circumflex
950 E2( 0xa2, 0xc3,0x87), // uppercase C with cedilla
951 E2( 0xa3, 0xc3,0x88), // uppercase E, grave accent
952 E2( 0xa4, 0xc3,0x8a), // uppercase E, circumflex
953 E2( 0xa5, 0xc3,0x8b), // capital letter E with diaresis
954 E2( 0xa6, 0xc3,0xab), // lowercase letter e with diaresis
955 E2( 0xa7, 0xc3,0x8e), // uppercase I, circumflex
956 E2( 0xa8, 0xc3,0x8f), // uppercase I, with diaresis
957 E2( 0xa9, 0xc3,0xaf), // lowercase i, with diaresis
958 E2( 0xaa, 0xc3,0x94), // uppercase O, circumflex
959 E2( 0xab, 0xc3,0x99), // uppercase U, grave accent
960 E2( 0xac, 0xc3,0xb9), // lowercase u, grave accent
961 E2( 0xad, 0xc3,0x9b), // uppercase U, circumflex
962 E2( 0xae, 0xc2,0xab), // LEFT-POINTING DOUBLE ANGLE QUOTATION MARK
963 E2( 0xaf, 0xc2,0xbb), // RIGHT-POINTING DOUBLE ANGLE QUOTATION MARK
964 // THIS BLOCK INCLUDES THE 32 EXTENDED (TWO-BYTE) LINE 21 CHARACTERS
965 // THAT COME FROM HI BYTE=0x13 AND LOW BETWEEN 0x20 AND 0x3F
966 E2( 0xb0, 0xc3,0x83), // Uppercase A, tilde
967 E2( 0xb1, 0xc3,0xa3), // Lowercase a, tilde
968 E2( 0xb2, 0xc3,0x8d), // Uppercase I, acute accent
969 E2( 0xb3, 0xc3,0x8c), // Uppercase I, grave accent
970 E2( 0xb4, 0xc3,0xac), // Lowercase i, grave accent
971 E2( 0xb5, 0xc3,0x92), // Uppercase O, grave accent
972 E2( 0xb6, 0xc3,0xb2), // Lowercase o, grave accent
973 E2( 0xb7, 0xc3,0x95), // Uppercase O, tilde
974 E2( 0xb8, 0xc3,0xb5), // Lowercase o, tilde
975 E1( 0xb9, 0x7b), // Open curly brace
976 E1( 0xba, 0x7d), // Closing curly brace
977 E1( 0xbb, 0x5c), // Backslash
978 E1( 0xbc, 0x5e), // Caret
979 E1( 0xbd, 0x5f), // Underscore
980 E2( 0xbe, 0xc2,0xa6), // Pipe (broken bar)
981 E1( 0xbf, 0x7e), // Tilde (utf8 code unsure)
982 E2( 0xc0, 0xc3,0x84), // Uppercase A, umlaut
983 E2( 0xc1, 0xc3,0xa4), // Lowercase A, umlaut
984 E2( 0xc2, 0xc3,0x96), // Uppercase O, umlaut
985 E2( 0xc3, 0xc3,0xb6), // Lowercase o, umlaut
986 E2( 0xc4, 0xc3,0x9f), // Esszett (sharp S)
987 E2( 0xc5, 0xc2,0xa5), // Yen symbol
988 E2( 0xc6, 0xc2,0xa4), // Currency symbol
989 E1( 0xc7, 0x7c), // Vertical bar
990 E2( 0xc8, 0xc3,0x85), // Uppercase A, ring
991 E2( 0xc9, 0xc3,0xa5), // Lowercase A, ring
992 E2( 0xca, 0xc3,0x98), // Uppercase O, slash
993 E2( 0xcb, 0xc3,0xb8), // Lowercase o, slash
994 E3( 0xcc, 0xe2,0x8c,0x9c), // Upper left corner
995 E3( 0xcd, 0xe2,0x8c,0x9d), // Upper right corner
996 E3( 0xce, 0xe2,0x8c,0x9e), // Lower left corner
997 E3( 0xcf, 0xe2,0x8c,0x9f), // Lower right corner
998
999 E1(0,0)
1000 };
1001 #undef E3
1002 #undef E2
1003 #undef E1
1004
1005 for( size_t i = 0; i < ARRAY_SIZE(c2utf8) ; i++ )
1006 if( c2utf8[i].c == c ) {
1007 strcpy( psz_utf8, c2utf8[i].utf8 );
1008 return;
1009 }
1010
1011 psz_utf8[0] = c < 0x80 ? c : '?'; /* Normal : Unsupported */
1012 psz_utf8[1] = '\0';
1013 }
1014
1015 static void Eia608Strlcat( char *d, const char *s, int i_max )
1016 {
1017 if( i_max > 1 )
1018 strncat( d, s, i_max-1 - strnlen(d, i_max-1));
1019 if( i_max > 0 )
1020 d[i_max-1] = '\0';
1021 }
1022
1023 #define CAT(t) Eia608Strlcat( psz_text, t, i_text_max )
1024
1025 static text_segment_t * Eia608TextLine( struct eia608_screen *screen, int i_row )
1026 {
1027 const uint8_t *p_char = screen->characters[i_row];
1028 const eia608_color_t *p_color = screen->colors[i_row];
1029 const eia608_font_t *p_font = screen->fonts[i_row];
1030 int i_start;
1031 int i_end;
1032 int x;
1033 eia608_color_t prev_color = EIA608_COLOR_DEFAULT;
1034 eia608_font_t prev_font = EIA608_FONT_REGULAR;
1035
1036 char utf8[4];
1037 const unsigned i_text_max = 4 * EIA608_SCREEN_COLUMNS + 1;
1038 char psz_text[i_text_max + 1];
1039 psz_text[0] = '\0';
1040
1041 /* Search the start */
1042 i_start = 0;
1043
1044 /* Convert leading spaces to non-breaking so that they don't get
1045 stripped by the RenderHtml routine as regular whitespace */
1046 while( i_start < EIA608_SCREEN_COLUMNS && p_char[i_start] == ' ' ) {
1047 Eia608TextUtf8( utf8, 0x89 );
1048 CAT( utf8 );
1049 i_start++;
1050 }
1051
1052 /* Search the end */
1053 i_end = EIA608_SCREEN_COLUMNS-1;
1054 while( i_end > i_start && p_char[i_end] == ' ' )
1055 i_end--;
1056
1057 /* */
1058 if( i_start > i_end ) /* Nothing to render */
1059 return NULL;
1060
1061 text_segment_t *p_segment, *p_segments_head = p_segment = text_segment_New( NULL );
1062 if(!p_segment)
1063 return NULL;
1064
1065 p_segment->style = text_style_Create( STYLE_NO_DEFAULTS );
1066 if(!p_segment->style)
1067 {
1068 text_segment_Delete(p_segment);
1069 return NULL;
1070 }
1071 /* Ensure we get a monospaced font (required for accurate positioning */
1072 p_segment->style->i_style_flags |= STYLE_MONOSPACED;
1073
1074 for( x = i_start; x <= i_end; x++ )
1075 {
1076 eia608_color_t color = p_color[x];
1077 eia608_font_t font = p_font[x];
1078
1079 if(font != prev_font || color != prev_color)
1080 {
1081 EnsureUTF8(psz_text);
1082 p_segment->psz_text = strdup(psz_text);
1083 psz_text[0] = '\0';
1084 p_segment->p_next = text_segment_New( NULL );
1085 p_segment = p_segment->p_next;
1086 if(!p_segment)
1087 return p_segments_head;
1088
1089 p_segment->style = text_style_Create( STYLE_NO_DEFAULTS );
1090 if(!p_segment->style)
1091 {
1092 text_segment_Delete(p_segment);
1093 return p_segments_head;
1094 }
1095 p_segment->style->i_style_flags |= STYLE_MONOSPACED;
1096
1097 /* start segment with new style */
1098 if(font & EIA608_FONT_ITALICS)
1099 {
1100 p_segment->style->i_style_flags |= STYLE_ITALIC;
1101 p_segment->style->i_features |= STYLE_HAS_FLAGS;
1102 }
1103 if(font & EIA608_FONT_UNDERLINE)
1104 {
1105 p_segment->style->i_style_flags |= STYLE_UNDERLINE;
1106 p_segment->style->i_features |= STYLE_HAS_FLAGS;
1107 }
1108
1109 if(color != EIA608_COLOR_DEFAULT)
1110 {
1111 p_segment->style->i_font_color = rgi_eia608_colors[color];
1112 p_segment->style->i_features |= STYLE_HAS_FONT_COLOR;
1113 }
1114 }
1115
1116 Eia608TextUtf8( utf8, p_char[x] );
1117 CAT( utf8 );
1118
1119 /* */
1120 prev_font = font;
1121 prev_color = color;
1122 }
1123
1124 #undef CAT
1125
1126 if( p_segment )
1127 {
1128 assert(!p_segment->psz_text); // shouldn't happen
1129 EnsureUTF8(psz_text);
1130 p_segment->psz_text = strdup(psz_text);
1131 }
1132
1133 return p_segments_head;
1134 }
1135
1136 static void Eia608FillUpdaterRegions( subpicture_updater_sys_t *p_updater, eia608_t *h )
1137 {
1138 struct eia608_screen *screen = &h->screen[h->i_screen];
1139 subpicture_updater_sys_region_t *p_region = &p_updater->region;
1140 text_segment_t **pp_last = &p_region->p_segments;
1141 bool b_newregion = false;
1142
1143 for( int i = 0; i < EIA608_SCREEN_ROWS; i++ )
1144 {
1145 if( !screen->row_used[i] )
1146 continue;
1147
1148 text_segment_t *p_segments = Eia608TextLine( screen, i );
1149 if( p_segments )
1150 {
1151 if( b_newregion )
1152 {
1153 subpicture_updater_sys_region_t *p_newregion;
1154 p_newregion = SubpictureUpdaterSysRegionNew();
1155 if( !p_newregion )
1156 {
1157 text_segment_ChainDelete( p_segments );
1158 return;
1159 }
1160 SubpictureUpdaterSysRegionAdd( p_region, p_newregion );
1161 p_region = p_newregion;
1162 pp_last = &p_region->p_segments;
1163 b_newregion = false;
1164 }
1165
1166 if( p_region->p_segments == NULL ) /* First segment in the [new] region */
1167 {
1168 p_region->origin.y = i; /* set start line number */
1169 }
1170 else /* Insert line break between region lines */
1171 {
1172 *pp_last = text_segment_New( "\n" );
1173 if( *pp_last )
1174 pp_last = &((*pp_last)->p_next);
1175 }
1176
1177 *pp_last = p_segments;
1178 do { pp_last = &((*pp_last)->p_next); } while ( *pp_last != NULL );
1179 }
1180 else
1181 {
1182 b_newregion = !!p_region->p_segments;
1183 }
1184 }
1185 }
1186
1187 /* */
1188 static void Eia608Init( eia608_t *h )
1189 {
1190 memset( h, 0, sizeof(*h) );
1191
1192 /* */
1193 h->i_channel = -1;
1194
1195 h->i_screen = 0;
1196 Eia608ClearScreen( h, 0 );
1197 Eia608ClearScreen( h, 1 );
1198
1199 /* Cursor for writing text */
1200 h->cursor.i_column = 0;
1201 h->cursor.i_row = 0;
1202
1203 h->last.d1 = 0x00;
1204 h->last.d2 = 0x00;
1205 h->mode = EIA608_MODE_POPUP;
1206 h->color = EIA608_COLOR_DEFAULT;
1207 h->font = EIA608_FONT_REGULAR;
1208 h->i_row_rollup = EIA608_SCREEN_ROWS-1;
1209 }
1210 static eia608_status_t Eia608Parse( eia608_t *h, int i_channel_selected, const uint8_t data[2] )
1211 {
1212 const uint8_t d1 = data[0] & 0x7f; /* Removed parity bit */
1213 const uint8_t d2 = data[1] & 0x7f;
1214 eia608_status_t i_screen_status = EIA608_STATUS_DEFAULT;
1215
1216 if( d1 == 0 && d2 == 0 )
1217 return EIA608_STATUS_DEFAULT; /* Ignore padding (parity check are sometimes invalid on them) */
1218
1219 Eia608ParseChannel( h, data );
1220 if( h->i_channel != i_channel_selected )
1221 return false;
1222 //fprintf( stderr, "CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC %x %x\n", data[0], data[1] );
1223
1224 if( d1 >= 0x10 )
1225 {
1226 if( d1 >= 0x20 ||
1227 d1 != h->last.d1 || d2 != h->last.d2 ) /* Command codes can be repeated */
1228 i_screen_status = Eia608ParseData( h, d1,d2 );
1229
1230 h->last.d1 = d1;
1231 h->last.d2 = d2;
1232 }
1233 else if( ( d1 >= 0x01 && d1 <= 0x0E ) || d1 == 0x0F )
1234 {
1235 /* XDS block / End of XDS block */
1236 }
1237 return i_screen_status;
1238 }
VLC Development tree mirror