git.sesse.net Git - vlc/blob - modules/codec/zvbi.c

   1 /*****************************************************************************
   2  * zvbi.c : VBI and Teletext PES demux and decoder using libzvbi
   3  *****************************************************************************
   4  * Copyright (C) 2007, M2X
   5  * $Id$
   6  *
   7  * Authors: Derk-Jan Hartman <djhartman at m2x dot nl>
   8  *          Jean-Paul Saman <jpsaman at m2x dot nl>
   9  *
  10  * This program is free software; you can redistribute it and/or modify it
  11  * under the terms of the GNU Lesser General Public License as published by
  12  * the Free Software Foundation; either version 2.1 of the License, or
  13  * (at your option) any later version.
  14  *
  15  * This program is distributed in the hope that it will be useful,
  16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  18  * GNU Lesser General Public License for more details.
  19  *
  20  * You should have received a copy of the GNU Lesser General Public License
  21  * along with this program; if not, write to the Free Software Foundation,
  22  * Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
  23  *****************************************************************************/
  24
  25 /*****************************************************************************
  26  *
  27  * information on teletext format can be found here :
  28  * http://pdc.ro.nu/teletext.html
  29  *
  30  *****************************************************************************/
  31
  32 /* This module implements:
  33  * ETSI EN 301 775: VBI data in PES
  34  * ETSI EN 300 472: EBU Teletext data in PES
  35  * ETSI EN 300 706: Enhanced Teletext (libzvbi)
  36  * ETSI EN 300 231: Video Programme System [VPS] (libzvbi)
  37  * ETSI EN 300 294: 625-line Wide Screen Signaling [WSS] (libzvbi)
  38  * EIA-608 Revision A: Closed Captioning [CC] (libzvbi)
  39  */
  40
  41 #ifdef HAVE_CONFIG_H
  42 # include "config.h"
  43 #endif
  44
  45 #include <vlc_common.h>
  46 #include <vlc_plugin.h>
  47 #include <assert.h>
  48 #include <libzvbi.h>
  49
  50 #include <vlc_codec.h>
  51
  52 /*****************************************************************************
  53  * Module descriptor.
  54  *****************************************************************************/
  55 static int  Open ( vlc_object_t * );
  56 static void Close( vlc_object_t * );
  57
  58 #define PAGE_TEXT N_("Teletext page")
  59 #define PAGE_LONGTEXT N_("Open the indicated Teletext page." \
  60         "Default page is index 100")
  61
  62 #define OPAQUE_TEXT N_("Teletext transparency")
  63 #define OPAQUE_LONGTEXT N_("Setting vbi-opaque to false " \
  64         "makes the boxed text transparent." )
  65
  66 #define POS_TEXT N_("Teletext alignment")
  67 #define POS_LONGTEXT N_( \
  68   "You can enforce the teletext position on the video " \
  69   "(0=center, 1=left, 2=right, 4=top, 8=bottom, you can " \
  70   "also use combinations of these values, eg. 6 = top-right).")
  71
  72 #define TELX_TEXT N_("Teletext text subtitles")
  73 #define TELX_LONGTEXT N_( "Output teletext subtitles as text " \
  74   "instead of as RGBA" )
  75
  76 static const int pi_pos_values[] = { 0, 1, 2, 4, 8, 5, 6, 9, 10 };
  77 static const char *const ppsz_pos_descriptions[] =
  78 { N_("Center"), N_("Left"), N_("Right"), N_("Top"), N_("Bottom"),
  79   N_("Top-Left"), N_("Top-Right"), N_("Bottom-Left"), N_("Bottom-Right") };
  80
  81 vlc_module_begin ()
  82     set_description( N_("VBI and Teletext decoder") )
  83     set_shortname( N_("VBI & Teletext") )
  84     set_capability( "decoder", 51 )
  85     set_category( CAT_INPUT )
  86     set_subcategory( SUBCAT_INPUT_SCODEC )
  87     set_callbacks( Open, Close )
  88
  89     add_integer( "vbi-page", 100,
  90                  PAGE_TEXT, PAGE_LONGTEXT, false )
  91     add_bool( "vbi-opaque", true,
  92                  OPAQUE_TEXT, OPAQUE_LONGTEXT, false )
  93     add_integer( "vbi-position", 4, POS_TEXT, POS_LONGTEXT, false )
  94         change_integer_list( pi_pos_values, ppsz_pos_descriptions );
  95     add_bool( "vbi-text", false,
  96               TELX_TEXT, TELX_LONGTEXT, false )
  97 vlc_module_end ()
  98
  99 /****************************************************************************
 100  * Local structures
 101  ****************************************************************************/
 102
 103 // #define ZVBI_DEBUG
 104
 105 //Guessing table for missing "default region triplet"
 106 static const int pi_default_triplet[] = {
 107  0, 0, 0, 0,     // slo slk cze ces
 108  8,              // pol
 109  24,24,24,24,    //scc scr slv rum
 110  32,32,32,32,32, //est lit rus bul ukr
 111  48,48,          //gre ell
 112  64,             //ara
 113  88,             //heb
 114  16 };           //default
 115 static const char *const ppsz_default_triplet[] = {
 116  "slo", "slk", "cze", "ces",
 117  "pol",
 118  "scc", "scr", "slv", "rum",
 119  "est", "lit", "rus", "bul", "ukr",
 120  "gre", "ell",
 121  "ara",
 122  "heb",
 123  NULL
 124 };
 125
 126 typedef enum {
 127     ZVBI_KEY_RED    = 'r' << 16,
 128     ZVBI_KEY_GREEN  = 'g' << 16,
 129     ZVBI_KEY_YELLOW = 'y' << 16,
 130     ZVBI_KEY_BLUE   = 'b' << 16,
 131     ZVBI_KEY_INDEX  = 'i' << 16,
 132 } ttxt_key_id;
 133
 134 typedef enum {
 135     DATA_UNIT_EBU_TELETEXT_NON_SUBTITLE     = 0x02,
 136     DATA_UNIT_EBU_TELETEXT_SUBTITLE         = 0x03,
 137     DATA_UNIT_EBU_TELETEXT_INVERTED         = 0x0C,
 138
 139     DATA_UNIT_ZVBI_WSS_CPR1204              = 0xB4,
 140     DATA_UNIT_ZVBI_CLOSED_CAPTION_525       = 0xB5,
 141     DATA_UNIT_ZVBI_MONOCHROME_SAMPLES_525   = 0xB6,
 142
 143     DATA_UNIT_VPS                           = 0xC3,
 144     DATA_UNIT_WSS                           = 0xC4,
 145     DATA_UNIT_CLOSED_CAPTION                = 0xC5,
 146     DATA_UNIT_MONOCHROME_SAMPLES            = 0xC6,
 147
 148     DATA_UNIT_STUFFING                      = 0xFF,
 149 } data_unit_id;
 150
 151 #define MAX_SLICES 32
 152
 153 struct decoder_sys_t
 154 {
 155     vbi_decoder *     p_vbi_dec;
 156     vbi_sliced        p_vbi_sliced[MAX_SLICES];
 157     unsigned int      i_last_page;
 158     bool              b_update;
 159     bool              b_text;   /* Subtitles as text */
 160
 161     vlc_mutex_t       lock; /* Lock to protect the following variables */
 162     /* Positioning of Teletext images */
 163     int               i_align;
 164     /* */
 165     unsigned int      i_wanted_page;
 166     unsigned int      i_wanted_subpage;
 167     /* */
 168     bool              b_opaque;
 169     struct {
 170         int pgno, subno;
 171     }                 nav_link[6];
 172     int               i_key[3];
 173 };
 174
 175 static subpicture_t *Decode( decoder_t *, block_t ** );
 176
 177 static subpicture_t *Subpicture( decoder_t *p_dec, video_format_t *p_fmt,
 178                                  bool b_text,
 179                                  int i_columns, int i_rows,
 180                                  int i_align, mtime_t i_pts );
 181
 182 static void EventHandler( vbi_event *ev, void *user_data );
 183 static int OpaquePage( picture_t *p_src, const vbi_page p_page,
 184                        const video_format_t fmt, bool b_opaque );
 185
 186 /* Properties callbacks */
 187 static int RequestPage( vlc_object_t *p_this, char const *psz_cmd,
 188                         vlc_value_t oldval, vlc_value_t newval, void *p_data );
 189 static int Opaque( vlc_object_t *p_this, char const *psz_cmd,
 190                    vlc_value_t oldval, vlc_value_t newval, void *p_data );
 191 static int Position( vlc_object_t *p_this, char const *psz_cmd,
 192                      vlc_value_t oldval, vlc_value_t newval, void *p_data );
 193 static int EventKey( vlc_object_t *p_this, char const *psz_cmd,
 194                      vlc_value_t oldval, vlc_value_t newval, void *p_data );
 195
 196 /*****************************************************************************
 197  * Open: probe the decoder and return score
 198  *****************************************************************************
 199  * Tries to launch a decoder and return score so that the interface is able
 200  * to chose.
 201  *****************************************************************************/
 202 static int Open( vlc_object_t *p_this )
 203 {
 204     decoder_t     *p_dec = (decoder_t *) p_this;
 205     decoder_sys_t *p_sys = NULL;
 206
 207     if( p_dec->fmt_in.i_codec != VLC_CODEC_TELETEXT )
 208         return VLC_EGENERIC;
 209
 210     p_dec->pf_decode_sub = Decode;
 211     p_sys = p_dec->p_sys = calloc( 1, sizeof(decoder_sys_t) );
 212     if( p_sys == NULL )
 213         return VLC_ENOMEM;
 214
 215     p_sys->i_key[0] = p_sys->i_key[1] = p_sys->i_key[2] = '*' - '0';
 216     p_sys->b_update = false;
 217     p_sys->p_vbi_dec = vbi_decoder_new();
 218     vlc_mutex_init( &p_sys->lock );
 219
 220     if( p_sys->p_vbi_dec == NULL )
 221     {
 222         msg_Err( p_dec, "VBI decoder could not be created." );
 223         Close( p_this );
 224         return VLC_ENOMEM;
 225     }
 226
 227     /* Some broadcasters in countries with level 1 and level 1.5 still not send a G0 to do
 228      * matches against table 32 of ETSI 300 706. We try to do some best effort guessing
 229      * This is not perfect, but might handle some cases where we know the vbi language
 230      * is known. It would be better if people started sending G0 */
 231     for( int i = 0; ppsz_default_triplet[i] != NULL; i++ )
 232     {
 233         if( p_dec->fmt_in.psz_language && !strcasecmp( p_dec->fmt_in.psz_language, ppsz_default_triplet[i] ) )
 234         {
 235             vbi_teletext_set_default_region( p_sys->p_vbi_dec, pi_default_triplet[i]);
 236             msg_Dbg( p_dec, "overwriting default zvbi region: %d", pi_default_triplet[i] );
 237         }
 238     }
 239
 240     vbi_event_handler_register( p_sys->p_vbi_dec, VBI_EVENT_TTX_PAGE | VBI_EVENT_NETWORK |
 241 #ifdef ZVBI_DEBUG
 242                                 VBI_EVENT_CAPTION | VBI_EVENT_TRIGGER |
 243                                 VBI_EVENT_ASPECT | VBI_EVENT_PROG_INFO | VBI_EVENT_NETWORK_ID |
 244 #endif
 245                                 0 , EventHandler, p_dec );
 246
 247     /* Create the var on vlc_global. */
 248     p_sys->i_wanted_page = var_CreateGetInteger( p_dec, "vbi-page" );
 249     var_AddCallback( p_dec, "vbi-page", RequestPage, p_sys );
 250
 251     /* Check if the Teletext track has a known "initial page". */
 252     if( p_sys->i_wanted_page == 100 && p_dec->fmt_in.subs.teletext.i_magazine != -1 )
 253     {
 254         p_sys->i_wanted_page = 100 * p_dec->fmt_in.subs.teletext.i_magazine +
 255                                vbi_bcd2dec( p_dec->fmt_in.subs.teletext.i_page );
 256         var_SetInteger( p_dec, "vbi-page", p_sys->i_wanted_page );
 257     }
 258     p_sys->i_wanted_subpage = VBI_ANY_SUBNO;
 259
 260     p_sys->b_opaque = var_CreateGetBool( p_dec, "vbi-opaque" );
 261     var_AddCallback( p_dec, "vbi-opaque", Opaque, p_sys );
 262
 263     p_sys->i_align = var_CreateGetInteger( p_dec, "vbi-position" );
 264     var_AddCallback( p_dec, "vbi-position", Position, p_sys );
 265
 266     p_sys->b_text = var_CreateGetBool( p_dec, "vbi-text" );
 267 //    var_AddCallback( p_dec, "vbi-text", Text, p_sys );
 268
 269     /* Listen for keys */
 270     var_AddCallback( p_dec->p_libvlc, "key-pressed", EventKey, p_dec );
 271
 272     es_format_Init( &p_dec->fmt_out, SPU_ES, VLC_CODEC_SPU );
 273     if( p_sys->b_text )
 274         p_dec->fmt_out.video.i_chroma = VLC_CODEC_TEXT;
 275     else
 276         p_dec->fmt_out.video.i_chroma = VLC_CODEC_RGBA;
 277     return VLC_SUCCESS;
 278 }
 279
 280 /*****************************************************************************
 281  * Close:
 282  *****************************************************************************/
 283 static void Close( vlc_object_t *p_this )
 284 {
 285     decoder_t     *p_dec = (decoder_t*) p_this;
 286     decoder_sys_t *p_sys = p_dec->p_sys;
 287
 288     var_DelCallback( p_dec, "vbi-position", Position, p_sys );
 289     var_DelCallback( p_dec, "vbi-opaque", Opaque, p_sys );
 290     var_DelCallback( p_dec, "vbi-page", RequestPage, p_sys );
 291     var_DelCallback( p_dec->p_libvlc, "key-pressed", EventKey, p_dec );
 292
 293     vlc_mutex_destroy( &p_sys->lock );
 294
 295     if( p_sys->p_vbi_dec )
 296         vbi_decoder_delete( p_sys->p_vbi_dec );
 297     free( p_sys );
 298 }
 299
 300 #ifdef WORDS_BIGENDIAN
 301 # define ZVBI_PIXFMT_RGBA32 VBI_PIXFMT_RGBA32_BE
 302 #else
 303 # define ZVBI_PIXFMT_RGBA32 VBI_PIXFMT_RGBA32_LE
 304 #endif
 305
 306 /*****************************************************************************
 307  * Decode:
 308  *****************************************************************************/
 309 static subpicture_t *Decode( decoder_t *p_dec, block_t **pp_block )
 310 {
 311     decoder_sys_t   *p_sys = p_dec->p_sys;
 312     block_t         *p_block;
 313     subpicture_t    *p_spu = NULL;
 314     video_format_t  fmt;
 315     bool            b_cached = false;
 316     vbi_page        p_page;
 317
 318     if( (pp_block == NULL) || (*pp_block == NULL) )
 319         return NULL;
 320
 321     p_block = *pp_block;
 322     *pp_block = NULL;
 323
 324     if( p_block->i_buffer > 0 &&
 325         ( ( p_block->p_buffer[0] >= 0x10 && p_block->p_buffer[0] <= 0x1f ) ||
 326           ( p_block->p_buffer[0] >= 0x99 && p_block->p_buffer[0] <= 0x9b ) ) )
 327     {
 328         vbi_sliced   *p_sliced = p_sys->p_vbi_sliced;
 329         unsigned int i_lines = 0;
 330
 331         p_block->i_buffer--;
 332         p_block->p_buffer++;
 333         while( p_block->i_buffer >= 2 )
 334         {
 335             int      i_id   = p_block->p_buffer[0];
 336             unsigned i_size = p_block->p_buffer[1];
 337
 338             if( 2 + i_size > p_block->i_buffer )
 339                 break;
 340
 341             if( ( i_id == 0x02 || i_id == 0x03 ) && i_size >= 44 && i_lines < MAX_SLICES )
 342             {
 343                 unsigned line_offset  = p_block->p_buffer[2] & 0x1f;
 344                 unsigned field_parity = p_block->p_buffer[2] & 0x20;
 345
 346                 p_sliced[i_lines].id = VBI_SLICED_TELETEXT_B;
 347                 if( line_offset > 0 )
 348                     p_sliced[i_lines].line = line_offset + (field_parity ? 0 : 313);
 349                 else
 350                     p_sliced[i_lines].line = 0;
 351                 for( int i = 0; i < 42; i++ )
 352                     p_sliced[i_lines].data[i] = vbi_rev8( p_block->p_buffer[4 + i] );
 353                 i_lines++;
 354             }
 355
 356             p_block->i_buffer -= 2 + i_size;
 357             p_block->p_buffer += 2 + i_size;
 358         }
 359
 360         if( i_lines > 0 )
 361             vbi_decode( p_sys->p_vbi_dec, p_sliced, i_lines, (double)p_block->i_pts / 1000000 );
 362     }
 363
 364     /* */
 365     vlc_mutex_lock( &p_sys->lock );
 366     const int i_align = p_sys->i_align;
 367     const unsigned int i_wanted_page = p_sys->i_wanted_page;
 368     const unsigned int i_wanted_subpage = p_sys->i_wanted_subpage;
 369     const bool b_opaque = p_sys->b_opaque;
 370     vlc_mutex_unlock( &p_sys->lock );
 371
 372     /* Try to see if the page we want is in the cache yet */
 373     memset( &p_page, 0, sizeof(vbi_page) );
 374     b_cached = vbi_fetch_vt_page( p_sys->p_vbi_dec, &p_page,
 375                                   vbi_dec2bcd( i_wanted_page ),
 376                                   i_wanted_subpage, VBI_WST_LEVEL_3p5,
 377                                   25, true );
 378
 379     if( i_wanted_page == p_sys->i_last_page && !p_sys->b_update )
 380         goto error;
 381
 382     if( !b_cached )
 383     {
 384         if( p_sys->i_last_page != i_wanted_page )
 385         {
 386             /* We need to reset the subtitle */
 387             p_spu = Subpicture( p_dec, &fmt, true,
 388                                 p_page.columns, p_page.rows,
 389                                 i_align, p_block->i_pts );
 390             if( !p_spu )
 391                 goto error;
 392             p_spu->p_region->psz_text = strdup("");
 393
 394             p_sys->b_update = true;
 395             p_sys->i_last_page = i_wanted_page;
 396             goto exit;
 397         }
 398         goto error;
 399     }
 400
 401     p_sys->b_update = false;
 402     p_sys->i_last_page = i_wanted_page;
 403 #ifdef ZVBI_DEBUG
 404     msg_Dbg( p_dec, "we now have page: %d ready for display",
 405              i_wanted_page );
 406 #endif
 407     /* If there is a page or sub to render, then we do that here */
 408     /* Create the subpicture unit */
 409     p_spu = Subpicture( p_dec, &fmt, p_sys->b_text,
 410                         p_page.columns, p_page.rows,
 411                         i_align, p_block->i_pts );
 412     if( !p_spu )
 413         goto error;
 414
 415     if( p_sys->b_text )
 416     {
 417         unsigned int i_textsize = 7000;
 418         int i_total;
 419         char p_text[i_textsize+1];
 420
 421         i_total = vbi_print_page_region( &p_page, p_text, i_textsize,
 422                         "UTF-8", 0, 0, 0, 0, p_page.columns, p_page.rows );
 423         p_text[i_total] = '\0';
 424         /* Strip off the pagenumber */
 425         if( i_total <= 40 )
 426             goto error;
 427         p_spu->p_region->psz_text = strdup( &p_text[8] );
 428
 429 #ifdef ZVBI_DEBUG
 430         msg_Info( p_dec, "page %x-%x(%d)\n%s", p_page.pgno, p_page.subno, i_total, p_text );
 431 #endif
 432     }
 433     else
 434     {
 435         picture_t *p_pic = p_spu->p_region->p_picture;
 436
 437         /* ZVBI is stupid enough to assume pitch == width */
 438         p_pic->p->i_pitch = 4 * fmt.i_width;
 439         vbi_draw_vt_page( &p_page, ZVBI_PIXFMT_RGBA32,
 440                           p_spu->p_region->p_picture->p->p_pixels, 1, 1 );
 441
 442         vlc_mutex_lock( &p_sys->lock );
 443         memcpy( p_sys->nav_link, &p_page.nav_link, sizeof( p_sys->nav_link )) ;
 444         vlc_mutex_unlock( &p_sys->lock );
 445
 446         OpaquePage( p_pic, p_page, fmt, b_opaque );
 447     }
 448
 449 exit:
 450     vbi_unref_page( &p_page );
 451     block_Release( p_block );
 452     return p_spu;
 453
 454 error:
 455     vbi_unref_page( &p_page );
 456     if( p_spu != NULL )
 457     {
 458         decoder_DeleteSubpicture( p_dec, p_spu );
 459         p_spu = NULL;
 460     }
 461
 462     block_Release( p_block );
 463     return NULL;
 464 }
 465
 466 static subpicture_t *Subpicture( decoder_t *p_dec, video_format_t *p_fmt,
 467                                  bool b_text,
 468                                  int i_columns, int i_rows, int i_align,
 469                                  mtime_t i_pts )
 470 {
 471     video_format_t fmt;
 472     subpicture_t *p_spu;
 473
 474     /* If there is a page or sub to render, then we do that here */
 475     /* Create the subpicture unit */
 476     p_spu = decoder_NewSubpicture( p_dec, NULL );
 477     if( !p_spu )
 478     {
 479         msg_Warn( p_dec, "can't get spu buffer" );
 480         return NULL;
 481     }
 482
 483     memset( &fmt, 0, sizeof(video_format_t) );
 484     fmt.i_chroma = b_text ? VLC_CODEC_TEXT : VLC_CODEC_RGBA;
 485     fmt.i_sar_num = 0;
 486     fmt.i_sar_den = 1;
 487     if( b_text )
 488     {
 489         fmt.i_bits_per_pixel = 0;
 490     }
 491     else
 492     {
 493         fmt.i_width = fmt.i_visible_width = i_columns * 12;
 494         fmt.i_height = fmt.i_visible_height = i_rows * 10;
 495         fmt.i_bits_per_pixel = 32;
 496     }
 497     fmt.i_x_offset = fmt.i_y_offset = 0;
 498
 499     p_spu->p_region = subpicture_region_New( &fmt );
 500     if( p_spu->p_region == NULL )
 501     {
 502         msg_Err( p_dec, "cannot allocate SPU region" );
 503         decoder_DeleteSubpicture( p_dec, p_spu );
 504         return NULL;
 505     }
 506
 507     p_spu->p_region->i_x = 0;
 508     p_spu->p_region->i_y = 0;
 509     p_spu->p_region->i_align = i_align;
 510
 511     p_spu->i_start = i_pts;
 512     p_spu->i_stop = 0;
 513     p_spu->b_ephemer = true;
 514     p_spu->b_absolute = false;
 515
 516     if( !b_text )
 517     {
 518         p_spu->i_original_picture_width = fmt.i_width;
 519         p_spu->i_original_picture_height = fmt.i_height;
 520     }
 521
 522     /* */
 523     *p_fmt = fmt;
 524     return p_spu;
 525 }
 526
 527 static void EventHandler( vbi_event *ev, void *user_data )
 528 {
 529     decoder_t *p_dec        = (decoder_t *)user_data;
 530     decoder_sys_t *p_sys    = p_dec->p_sys;
 531
 532     if( ev->type == VBI_EVENT_TTX_PAGE )
 533     {
 534 #ifdef ZVBI_DEBUG
 535         msg_Info( p_dec, "Page %03x.%02x ",
 536                     ev->ev.ttx_page.pgno,
 537                     ev->ev.ttx_page.subno & 0xFF);
 538 #endif
 539         if( p_sys->i_last_page == vbi_bcd2dec( ev->ev.ttx_page.pgno ) )
 540             p_sys->b_update = true;
 541 #ifdef ZVBI_DEBUG
 542         if( ev->ev.ttx_page.clock_update )
 543             msg_Dbg( p_dec, "clock" );
 544         if( ev->ev.ttx_page.header_update )
 545             msg_Dbg( p_dec, "header" );
 546 #endif
 547     }
 548     else if( ev->type == VBI_EVENT_CLOSE )
 549         msg_Dbg( p_dec, "Close event" );
 550     else if( ev->type == VBI_EVENT_CAPTION )
 551         msg_Dbg( p_dec, "Caption line: %x", ev->ev.caption.pgno );
 552     else if( ev->type == VBI_EVENT_NETWORK )
 553     {
 554         msg_Dbg( p_dec, "Network change");
 555         vbi_network n = ev->ev.network;
 556         msg_Dbg( p_dec, "Network id:%d name: %s, call: %s ", n.nuid, n.name, n.call );
 557     }
 558     else if( ev->type == VBI_EVENT_TRIGGER )
 559         msg_Dbg( p_dec, "Trigger event" );
 560     else if( ev->type == VBI_EVENT_ASPECT )
 561         msg_Dbg( p_dec, "Aspect update" );
 562     else if( ev->type == VBI_EVENT_PROG_INFO )
 563         msg_Dbg( p_dec, "Program info received" );
 564     else if( ev->type == VBI_EVENT_NETWORK_ID )
 565         msg_Dbg( p_dec, "Network ID changed" );
 566 }
 567
 568 static int OpaquePage( picture_t *p_src, const vbi_page p_page,
 569                        const video_format_t fmt, bool b_opaque )
 570 {
 571     unsigned int    x, y;
 572
 573     assert( fmt.i_chroma == VLC_CODEC_RGBA );
 574
 575     /* Kludge since zvbi doesn't provide an option to specify opacity. */
 576     for( y = 0; y < fmt.i_height; y++ )
 577     {
 578         for( x = 0; x < fmt.i_width; x++ )
 579         {
 580             const vbi_opacity opacity = p_page.text[ y/10 * p_page.columns + x/12 ].opacity;
 581             const int background = p_page.text[ y/10 * p_page.columns + x/12 ].background;
 582             uint32_t *p_pixel = (uint32_t*)&p_src->p->p_pixels[y * p_src->p->i_pitch + 4*x];
 583
 584             switch( opacity )
 585             {
 586             /* Show video instead of this character */
 587             case VBI_TRANSPARENT_SPACE:
 588                 *p_pixel = 0;
 589                 break;
 590             /* Display foreground and background color */
 591             /* To make the boxed text "closed captioning" transparent
 592              * change true to false.
 593              */
 594             case VBI_OPAQUE:
 595             /* alpha blend video into background color */
 596             case VBI_SEMI_TRANSPARENT:
 597                 if( b_opaque )
 598                     break;
 599             /* Full text transparency. only foreground color is show */
 600             case VBI_TRANSPARENT_FULL:
 601                 if( (*p_pixel) == (0xff000000 | p_page.color_map[background] ) )
 602                     *p_pixel = 0;
 603                 break;
 604             }
 605         }
 606     }
 607     /* end of kludge */
 608     return VLC_SUCCESS;
 609 }
 610
 611 /* Callbacks */
 612 static int RequestPage( vlc_object_t *p_this, char const *psz_cmd,
 613                         vlc_value_t oldval, vlc_value_t newval, void *p_data )
 614 {
 615     decoder_sys_t *p_sys = p_data;
 616     VLC_UNUSED(p_this); VLC_UNUSED(psz_cmd); VLC_UNUSED(oldval);
 617
 618     vlc_mutex_lock( &p_sys->lock );
 619     switch( newval.i_int )
 620     {
 621         case ZVBI_KEY_RED:
 622             p_sys->i_wanted_page = vbi_bcd2dec( p_sys->nav_link[0].pgno );
 623             p_sys->i_wanted_subpage = p_sys->nav_link[0].subno;
 624             break;
 625         case ZVBI_KEY_GREEN:
 626             p_sys->i_wanted_page = vbi_bcd2dec( p_sys->nav_link[1].pgno );
 627             p_sys->i_wanted_subpage = p_sys->nav_link[1].subno;
 628             break;
 629         case ZVBI_KEY_YELLOW:
 630             p_sys->i_wanted_page = vbi_bcd2dec( p_sys->nav_link[2].pgno );
 631             p_sys->i_wanted_subpage = p_sys->nav_link[2].subno;
 632             break;
 633         case ZVBI_KEY_BLUE:
 634             p_sys->i_wanted_page = vbi_bcd2dec( p_sys->nav_link[3].pgno );
 635             p_sys->i_wanted_subpage = p_sys->nav_link[3].subno;
 636             break;
 637         case ZVBI_KEY_INDEX:
 638             p_sys->i_wanted_page = vbi_bcd2dec( p_sys->nav_link[5].pgno ); /* #4 is SKIPPED */
 639             p_sys->i_wanted_subpage = p_sys->nav_link[5].subno;
 640             break;
 641     }
 642     if( newval.i_int > 0 && newval.i_int < 999 )
 643     {
 644         p_sys->i_wanted_page = newval.i_int;
 645         p_sys->i_wanted_subpage = VBI_ANY_SUBNO;
 646     }
 647     vlc_mutex_unlock( &p_sys->lock );
 648
 649     return VLC_SUCCESS;
 650 }
 651
 652 static int Opaque( vlc_object_t *p_this, char const *psz_cmd,
 653                    vlc_value_t oldval, vlc_value_t newval, void *p_data )
 654 {
 655     decoder_sys_t *p_sys = p_data;
 656     VLC_UNUSED(p_this); VLC_UNUSED(psz_cmd); VLC_UNUSED(oldval);
 657
 658     vlc_mutex_lock( &p_sys->lock );
 659     p_sys->b_opaque = newval.b_bool;
 660     p_sys->b_update = true;
 661     vlc_mutex_unlock( &p_sys->lock );
 662
 663     return VLC_SUCCESS;
 664 }
 665
 666 static int Position( vlc_object_t *p_this, char const *psz_cmd,
 667                      vlc_value_t oldval, vlc_value_t newval, void *p_data )
 668 {
 669     decoder_sys_t *p_sys = p_data;
 670     VLC_UNUSED(p_this); VLC_UNUSED(psz_cmd); VLC_UNUSED(oldval);
 671
 672     vlc_mutex_lock( &p_sys->lock );
 673     p_sys->i_align = newval.i_int;
 674     vlc_mutex_unlock( &p_sys->lock );
 675
 676     return VLC_SUCCESS;
 677 }
 678
 679 static int EventKey( vlc_object_t *p_this, char const *psz_cmd,
 680                         vlc_value_t oldval, vlc_value_t newval, void *p_data )
 681 {
 682     decoder_t *p_dec = p_data;
 683     decoder_sys_t *p_sys = p_dec->p_sys;
 684
 685     VLC_UNUSED(psz_cmd); VLC_UNUSED(oldval); VLC_UNUSED( p_this );
 686
 687     /* FIXME: Capture + and - key for subpage browsing */
 688     if( newval.i_int == '-' || newval.i_int == '+' )
 689     {
 690         vlc_mutex_lock( &p_sys->lock );
 691         if( p_sys->i_wanted_subpage == VBI_ANY_SUBNO && newval.i_int == '+' )
 692             p_sys->i_wanted_subpage = vbi_dec2bcd(1);
 693         else if ( newval.i_int == '+' )
 694             p_sys->i_wanted_subpage = vbi_add_bcd( p_sys->i_wanted_subpage, 1);
 695         else if( newval.i_int == '-')
 696             p_sys->i_wanted_subpage = vbi_add_bcd( p_sys->i_wanted_subpage, 0xF9999999); /* BCD complement - 1 */
 697
 698         if ( !vbi_bcd_digits_greater( p_sys->i_wanted_subpage, 0x00 ) || vbi_bcd_digits_greater( p_sys->i_wanted_subpage, 0x99 ) )
 699                 p_sys->i_wanted_subpage = VBI_ANY_SUBNO;
 700         else
 701             msg_Info( p_dec, "subpage: %d",
 702                       vbi_bcd2dec( p_sys->i_wanted_subpage) );
 703
 704         p_sys->b_update = true;
 705         vlc_mutex_unlock( &p_sys->lock );
 706     }
 707
 708     /* Capture 0-9 for page selection */
 709     if( newval.i_int < '0' || newval.i_int > '9' )
 710         return VLC_SUCCESS;
 711
 712     vlc_mutex_lock( &p_sys->lock );
 713     p_sys->i_key[0] = p_sys->i_key[1];
 714     p_sys->i_key[1] = p_sys->i_key[2];
 715     p_sys->i_key[2] = (int)(newval.i_int - '0');
 716     msg_Info( p_dec, "page: %c%c%c", (char)(p_sys->i_key[0]+'0'),
 717               (char)(p_sys->i_key[1]+'0'), (char)(p_sys->i_key[2]+'0') );
 718
 719     int i_new_page = 0;
 720
 721     if( p_sys->i_key[0] > 0 && p_sys->i_key[0] <= 8 &&
 722         p_sys->i_key[1] >= 0 && p_sys->i_key[1] <= 9 &&
 723         p_sys->i_key[2] >= 0 && p_sys->i_key[2] <= 9 )
 724     {
 725         i_new_page = p_sys->i_key[0]*100 + p_sys->i_key[1]*10 + p_sys->i_key[2];
 726         p_sys->i_key[0] = p_sys->i_key[1] = p_sys->i_key[2] = '*' - '0';
 727     }
 728     vlc_mutex_unlock( &p_sys->lock );
 729
 730     if( i_new_page > 0 )
 731         var_SetInteger( p_dec, "vbi-page", i_new_page );
 732
 733     return VLC_SUCCESS;
 734 }