libmpdemux/demux_ty_osd.c

   1 // Most of this was written by mbm@linux.com and released on the GPL2 License.
   2 //
   3 // Modifications and SEVERE cleanup of the code was done by
   4 // Christopher Wingert
   5 // Copyright 2003
   6 //
   7 // Released under GPL2 License.
   8
   9 #include <stdio.h>
  10 #include <stdlib.h>
  11 #include <unistd.h>
  12 #include <time.h>
  13 #include <stdarg.h>
  14 #include <string.h>
  15
  16 #include "config.h"
  17 #include "mp_msg.h"
  18 #include "help_mp.h"
  19
  20 //#include "stream/stream.h"
  21 //#include "demuxer.h"
  22 //#include "parse_es.h"
  23 //#include "stheader.h"
  24 //#include "mp3_hdr.h"
  25 //#include "subreader.h"
  26 #include "sub_cc.h"
  27 #include "libvo/sub.h"
  28
  29 //#include "dvdauth.h"
  30
  31 extern int sub_justify;
  32
  33 #define TY_TEXT_MODE        ( 1 << 0 )
  34 #define TY_OSD_MODE         ( 1 << 1 )
  35
  36 static int TY_OSD_flags = TY_TEXT_MODE | TY_OSD_MODE;
  37 static int TY_OSD_debug = 0;
  38
  39 // ===========================================================================
  40 // Closed Caption Decoding and OSD Presentation
  41 // ===========================================================================
  42 #define TY_CCNONE     ( -3 )
  43 #define TY_CCTEXTMODE ( -2 )
  44 #define TY_CCPOPUPNB  ( -1 )
  45 #define TY_CCPOPUP    (  0 )
  46 #define TY_CCPAINTON  (  1 )
  47
  48 #define TY_CC_MAX_X   ( 45 )
  49
  50 static int      TY_CC_CUR_X;
  51 static int      TY_CC_CUR_Y;
  52 static int      TY_CC_stat = TY_CCNONE;
  53 static char     TY_CC_buf[ 255 ];
  54 static char     *TY_CC_ptr = TY_CC_buf;
  55 static unsigned TY_CC_lastcap = 0;
  56 static int      TY_CC_TextItalic;
  57 static int      TY_CC_Y_Offset;
  58
  59 static subtitle ty_OSD1;
  60 static subtitle ty_OSD2;
  61 static subtitle *ty_pOSD1;
  62 static subtitle *ty_pOSD2;
  63 static int             tyOSDInited = 0;
  64 static int             tyOSDUpdate = 0;
  65
  66 static void ty_DrawOSD(void)
  67 {
  68         // printf( "Calling ty_DrawOSD()\n" );
  69         tyOSDUpdate = 1;
  70 }
  71
  72 void ty_ClearOSD( int start )
  73 {
  74         int index;
  75         // printf( "Calling ty_ClearOSD()\n" );
  76    for ( index = start ; index < SUB_MAX_TEXT ; index++ )
  77         {
  78                 memset( ty_OSD1.text[ index ], ' ', TY_CC_MAX_X - 1 );
  79                 ty_OSD1.text[ index ][ TY_CC_MAX_X - 1 ] = 0;
  80                 memset( ty_OSD2.text[ index ], ' ', TY_CC_MAX_X - 1 );
  81                 ty_OSD2.text[ index ][ TY_CC_MAX_X - 1 ] = 0;
  82         }
  83 }
  84
  85 static void ty_DrawChar( int *x, int *y, char disChar, int fgColor, int bgColor )
  86 {
  87    int cx;
  88    int cy;
  89
  90    cx = *x;
  91    cy = *y;
  92
  93         if ( *x >= ( TY_CC_MAX_X - 1 ) )
  94         {
  95       cx = 0;
  96         }
  97         if ( ( *y + TY_CC_Y_Offset ) > SUB_MAX_TEXT )
  98         {
  99            cy = SUB_MAX_TEXT - TY_CC_Y_Offset - 1;
 100    }
 101
 102         // printf( "Calling ty_DrawChar() x:%d y:%d %c fg:%d bg:%d\n",
 103         //      cx, cy, disChar, fgColor, bgColor );
 104
 105    ty_OSD1.text[ TY_CC_Y_Offset + cy ][ cx ] = disChar;
 106    memset( &( ty_OSD1.text[ TY_CC_Y_Offset + cy ][ cx + 1 ] ), ' ',
 107       TY_CC_MAX_X - cx - 2 );
 108         ( *x )++;
 109 }
 110
 111 static void ty_RollupBuf( int dest, int source, int numLines )
 112 {
 113         int index;
 114
 115         // printf( "Calling ty_RollupBuf() dest:%d source %d, numLines %d\n",
 116         //    dest, source, numLines );
 117         //
 118         if ( ( source + TY_CC_Y_Offset + numLines ) > SUB_MAX_TEXT )
 119         {
 120       ty_ClearOSD( 1 );
 121                 return;
 122         }
 123
 124         if ( ( source + TY_CC_Y_Offset + numLines ) < 0 )
 125         {
 126       ty_ClearOSD( 1 );
 127                 return;
 128         }
 129
 130         if ( numLines > SUB_MAX_TEXT )
 131         {
 132       ty_ClearOSD( 1 );
 133                 return;
 134         }
 135
 136         for ( index = 0 ; index < numLines ; index++ )
 137         {
 138                 strcpy( ty_OSD1.text[ TY_CC_Y_Offset + dest ],
 139                         ty_OSD1.text[ TY_CC_Y_Offset + source ] );
 140            dest++;
 141                 source++;
 142         }
 143         memset( ty_OSD1.text[ TY_CC_Y_Offset + source - 1 ], ' ', TY_CC_MAX_X - 1 );
 144         ty_OSD1.text[ TY_CC_Y_Offset + source - 1 ][ TY_CC_MAX_X - 1 ] = 0;
 145 }
 146
 147 static void ty_drawchar( char c )
 148 {
 149    if ( c < 2 ) return;
 150
 151    if ( TY_OSD_flags & TY_OSD_MODE && TY_CC_stat != TY_CCNONE &&
 152       TY_CC_CUR_Y != -1 )
 153       ty_DrawChar( &TY_CC_CUR_X, &TY_CC_CUR_Y, c, 4, 13 );
 154
 155    if ( TY_CC_ptr - TY_CC_buf > sizeof( TY_CC_buf ) - 1 )
 156    {        // buffer overflow
 157       TY_CC_ptr = TY_CC_buf;
 158       memset( TY_CC_buf, 0, sizeof( TY_CC_buf ) );
 159    }
 160    *( TY_CC_ptr++ ) = ( c == 14 ) ? '/' : c; // swap a '/' for musical note
 161 }
 162
 163 static void ty_draw(void)
 164 {
 165    if ( TY_CC_ptr != TY_CC_buf && TY_OSD_flags & TY_TEXT_MODE )
 166    {
 167       if ( *( TY_CC_ptr - 1 ) == '\n' ) *( TY_CC_ptr - 1 ) = 0;
 168
 169       mp_msg( MSGT_DEMUX, MSGL_V, "CC: %s\n", TY_CC_buf );
 170   }
 171   TY_CC_lastcap = time( NULL );
 172
 173   TY_CC_ptr = TY_CC_buf;
 174   memset( TY_CC_buf, 0, sizeof( TY_CC_buf) );
 175
 176   if ( TY_OSD_flags & TY_OSD_MODE ) ty_DrawOSD();
 177   if ( TY_CC_TextItalic ) TY_CC_TextItalic = 0;
 178 }
 179
 180
 181 static int CC_last = 0;
 182 static char CC_mode = 0;
 183 static int CC_row[] =
 184 {
 185    11, -1, 1, 2, 3, 4, 12, 13, 14, 15, 5, 6, 7, 8, 9, 10
 186 };
 187
 188 // char specialchar[] = { '®', '°', '½', '¿', '*', '¢', '£', 14, 'à', ' ', 'è', 'â', 'ê', 'î', 'ô', 'û' };
 189
 190 static int ty_CCdecode( char b1, char b2 )
 191 {
 192    int x;
 193    int data = ( b2 << 8 ) + b1;
 194
 195    if ( b1 & 0x60 )                // text
 196    {
 197        if ( !TY_OSD_debug && TY_CC_stat == TY_CCNONE ) return 0;
 198        if ( TY_OSD_debug > 3 )
 199        {
 200           mp_msg( MSGT_DEMUX, MSGL_DBG3, "%c %c", b1, b2 );
 201        }
 202        ty_drawchar( b1 );
 203        ty_drawchar( b2 );
 204
 205        if ( TY_CC_stat > 0 && TY_OSD_flags & TY_OSD_MODE ) ty_DrawOSD();
 206    }
 207    else if ( ( b1 & 0x10 ) && ( b2 > 0x1F ) && ( data != CC_last ) )
 208    {
 209       #define CURRENT ( ( b1 & 0x08 ) >> 3 )
 210
 211       if ( CC_mode != CURRENT && TY_CC_stat != TY_CCNONE )
 212       {
 213          if ( TY_OSD_debug && TY_CC_ptr != TY_CC_buf ) ty_draw();
 214          TY_CC_stat = TY_CCNONE;
 215          return 0;
 216       }
 217
 218       if ( TY_CC_stat == TY_CCNONE || TY_CC_CUR_Y == -1 )
 219       {
 220          if ( TY_CC_ptr != TY_CC_buf )
 221          {
 222             if ( TY_OSD_debug )
 223                mp_msg( MSGT_DEMUX, MSGL_DBG3, "(TY_OSD_debug) %s\n",
 224                   TY_CC_buf );
 225             TY_CC_ptr = TY_CC_buf;
 226             memset(TY_CC_buf, 0, sizeof(TY_CC_buf));
 227          }
 228
 229          if ( CC_mode != CURRENT ) return 0;
 230       }
 231
 232       // preamble address code (row & indent)
 233       if ( b2 & 0x40 )
 234       {
 235          TY_CC_CUR_Y = CC_row[ ( ( b1 << 1 ) & 14 ) | ( ( b2 >> 5 ) & 1 ) ];
 236
 237                         // Offset into MPlayer's Buffer
 238                         if ( ( TY_CC_CUR_Y >= 1 ) && ( TY_CC_CUR_Y <= 4 ) )
 239                         {
 240                                 TY_CC_Y_Offset = SUB_MAX_TEXT - 5 - 1;
 241                         }
 242                         if ( ( TY_CC_CUR_Y >= 5 ) && ( TY_CC_CUR_Y <= 10 ) )
 243                         {
 244                                 TY_CC_Y_Offset = SUB_MAX_TEXT - 5 - 5;
 245                         }
 246                         if ( ( TY_CC_CUR_Y >= 12 ) && ( TY_CC_CUR_Y <= 15 ) )
 247                         {
 248                                 TY_CC_Y_Offset = SUB_MAX_TEXT - 5 - 12;
 249                         }
 250
 251          if ( TY_OSD_debug > 3 )
 252             mp_msg( MSGT_DEMUX, MSGL_DBG3, "<< preamble %d >>\n", TY_CC_CUR_Y );
 253
 254          // we still have something in the text buffer
 255          if (TY_CC_ptr != TY_CC_buf)
 256          {
 257             *(TY_CC_ptr++) = '\n';
 258             if ( TY_CC_TextItalic )
 259             {
 260                TY_CC_TextItalic = 0;
 261             }
 262          }
 263
 264          TY_CC_CUR_X = 1;
 265          // row contains indent flag
 266          if ( b2 & 0x10 )
 267          {
 268             for ( x = 0 ; x < ( ( b2 & 0x0F ) << 1 ) ; x++ )
 269             {
 270                TY_CC_CUR_X++;
 271                *(TY_CC_ptr++) = ' ';
 272             }
 273          }
 274       }
 275       else
 276       // !(b2 & 0x40)
 277       {
 278          if ( TY_OSD_debug > 3 )
 279             mp_msg( MSGT_DEMUX, MSGL_DBG3, "<< %02x >>\n", b1 & 0x7 );
 280          switch (b1 & 0x07)
 281          {
 282             case 0x00:                      // attribute
 283                                 {
 284                if ( TY_OSD_debug > 1 )
 285                   mp_msg( MSGT_DEMUX, MSGL_DBG3, "<<A: %d>>\n", b2 );
 286                break;
 287                                 }
 288             case 0x01:                      // midrow or char
 289                                 {
 290                switch (b2 & 0x70)
 291                {
 292                   case 0x20:                // midrow attribute change
 293                   {
 294                      switch (b2 & 0x0e)
 295                      {
 296                         case 0x00:          // italics off
 297                         {
 298                            TY_CC_TextItalic = 0;
 299                            *(TY_CC_ptr++) = ' ';
 300                            break;
 301                         }
 302                         case 0x0e:          // italics on
 303                         {
 304                            ty_drawchar(' ');
 305                            TY_CC_TextItalic = 1;
 306                            break;
 307                         }
 308                         default:
 309                         {
 310                            if ( TY_OSD_debug > 1 )
 311                               mp_msg( MSGT_DEMUX, MSGL_DBG3, "<<D: %d>>\n",
 312                                  b2 & 0x0e );
 313                         }
 314                      }
 315                      if ( b2 & 0x01 )
 316                      {
 317                         // TextUnderline = 1;
 318                      }
 319                      else
 320                      {
 321                         // TextUnderline = 0;
 322                      }
 323                      break;
 324                   }
 325                   case 0x30:                // special character..
 326                   {
 327                      // transparent space
 328                      if ( ( b2 & 0x0f ) == 9 )
 329                      {
 330                         TY_CC_CUR_X++;
 331                         *(TY_CC_ptr++) = ' ';
 332                      }
 333                      else
 334                      {
 335                         // ty_drawchar(specialchar[ b2 & 0x0f ] );
 336                         ty_drawchar( ' ' );
 337                      }
 338                      break;
 339                   }
 340                }
 341                break;
 342                                 }
 343
 344             case 0x04:                      // misc
 345             case 0x05:                      // misc + F
 346                                 {
 347                if ( TY_OSD_debug > 3 )
 348                   mp_msg( MSGT_DEMUX, MSGL_DBG3, "<< misc %02x >>\n", b2 );
 349                switch ( b2 )
 350                {
 351                   case 0x20:                // resume caption (new caption)
 352                   {
 353                      if ( TY_OSD_flags & TY_OSD_MODE &&
 354                         TY_CC_stat != TY_CCPOPUP )
 355                                                                 ty_ClearOSD( 1 );
 356                      TY_CC_stat = TY_CCPOPUP;
 357                      break;
 358                   }
 359
 360                   case 0x21:                // backspace
 361                   {
 362                      TY_CC_CUR_X--;
 363                      break;
 364                   }
 365
 366                   case 0x25:       // 2-4 row captions
 367                   case 0x26:
 368                   case 0x27:
 369                   {
 370                      if ( TY_CC_stat == TY_CCPOPUP ) ty_ClearOSD( 1 );
 371                      TY_CC_stat = b2 - 0x23;
 372                      if ( TY_CC_CUR_Y < TY_CC_stat ) TY_CC_CUR_Y = TY_CC_stat;
 373                      break;
 374                   }
 375
 376                   case 0x29:                // resume direct caption
 377                   {
 378                      TY_CC_stat = TY_CCPAINTON;
 379                      break;
 380                   }
 381
 382                   case 0x2A:                // text restart
 383                   {
 384                      ty_draw();
 385                      /* FALL */
 386                   }
 387
 388                   case 0x2B:                // resume text display
 389                   {
 390                      TY_CC_stat = TY_CCTEXTMODE;
 391                      break;
 392                   }
 393
 394                   case 0x2C:                // erase displayed memory
 395                   {
 396                      TY_CC_lastcap = 0;
 397                      if ( TY_OSD_flags & TY_OSD_MODE )
 398                      {
 399                         if ( TY_CC_stat > TY_CCPOPUP || TY_CC_ptr == TY_CC_buf )
 400                         {
 401                            ty_ClearOSD( 1 );
 402                            ty_draw();
 403                         }
 404                         else
 405                         {
 406                            ty_ClearOSD( 1 );
 407
 408                            // CRW -
 409                            // new buffer
 410                            // Used to be a buffer swap here, dunno why
 411                         }
 412                      }
 413                      break;
 414                   }
 415
 416                   case 0x2D:                // carriage return
 417                   {
 418                      ty_draw();
 419                      TY_CC_CUR_X = 1;
 420                      if ( TY_OSD_flags & TY_OSD_MODE )
 421                      {
 422                         if ( TY_CC_stat > TY_CCPAINTON )
 423                            ty_RollupBuf
 424                            (
 425                               TY_CC_CUR_Y - TY_CC_stat + 1 ,
 426                               TY_CC_CUR_Y - TY_CC_stat + 2,
 427                               TY_CC_stat - 1
 428                             );
 429                         else
 430                            TY_CC_CUR_Y++;
 431                       }
 432                       break;
 433                   }
 434
 435                   case 0x2F:                // end caption + swap memory
 436                   {
 437                      ty_draw();
 438                      /* FALL THROUGH TO 0x2E */
 439                   }
 440
 441                   case 0x2E:                // erase non-displayed memory
 442                   {
 443                      if ( TY_OSD_debug && TY_CC_ptr != TY_CC_buf )
 444                         mp_msg( MSGT_DEMUX, MSGL_DBG3, "(TY_OSD_debug) %s\n",
 445                            TY_CC_buf );
 446                      if ( TY_OSD_flags & TY_OSD_MODE ) ty_ClearOSD( 1 );
 447
 448                      TY_CC_CUR_X = 1;
 449                      TY_CC_CUR_Y = -1;
 450
 451                      TY_CC_ptr = TY_CC_buf;
 452                      memset( TY_CC_buf, 0, sizeof( TY_CC_buf ) );
 453                   }
 454                }
 455                break;
 456                                 }
 457             case 0x07:                      // misc (TAB)
 458             {
 459                for ( x = 0 ; x < ( b2 - 0x20 ) ; x++ )
 460                   TY_CC_CUR_X++;
 461                break;
 462             }
 463          }
 464       }
 465    }
 466    CC_last = data;
 467    return 0;
 468 }
 469
 470 // ===========================================================================
 471 // Extended Data Service Decoding and OSD Presentation
 472 // ===========================================================================
 473 #define XDS_BUFFER_LENGTH     ( 16 )
 474 #define XDS_DISPLAY_FRAMES    ( 120 )
 475 static char *ty_XDS_Display[ XDS_BUFFER_LENGTH ];
 476 static int ty_XDSAddLine = -1;
 477 static int ty_XDSDisplayCount = -1;
 478
 479
 480 static void ty_AddXDSToDisplay( const char *format, ... )
 481 {
 482    char line[ 80 ];
 483    int  index;
 484    va_list ap;
 485
 486    if ( ty_XDSAddLine == -1 )
 487    {
 488       for( index = 0 ; index < XDS_BUFFER_LENGTH ; index++ )
 489       {
 490          ty_XDS_Display[ index ] = 0;
 491       }
 492       ty_XDSAddLine = 0;
 493    }
 494
 495    va_start( ap, format );
 496    vsnprintf( line, 80, format, ap );
 497    va_end( ap );
 498    mp_msg( MSGT_DEMUX, MSGL_V, "XDS: %s\n", line );
 499
 500    if ( ty_XDSAddLine == XDS_BUFFER_LENGTH )
 501    {
 502       mp_msg( MSGT_DEMUX, MSGL_ERR, "XDS Buffer would have been blown\n" );
 503    }
 504
 505    if ( ty_XDS_Display[ ty_XDSAddLine ] != 0 )
 506    {
 507       free( ty_XDS_Display[ ty_XDSAddLine ] );
 508       ty_XDS_Display[ ty_XDSAddLine ] = 0;
 509    }
 510
 511    ty_XDS_Display[ ty_XDSAddLine ] = malloc( strlen( line ) + 1 );
 512    strcpy( ty_XDS_Display[ ty_XDSAddLine ], line );
 513    ty_XDSAddLine++;
 514 }
 515
 516
 517 static void ty_DisplayXDSInfo(void)
 518 {
 519    int index;
 520    int size;
 521
 522    if ( ty_XDSDisplayCount == -1 )
 523    {
 524       for( index = 0 ; index < XDS_BUFFER_LENGTH ; index++ )
 525       {
 526          if ( ty_XDS_Display[ index ] != 0 )
 527          {
 528             break;
 529          }
 530       }
 531       if ( index != XDS_BUFFER_LENGTH )
 532       {
 533          size =  strlen( ty_XDS_Display[ index ] );
 534
 535          // Right Justify the XDS Stuff
 536          memcpy( &( ty_OSD1.text[ 0 ][ TY_CC_MAX_X - size - 1 ] ),
 537             ty_XDS_Display[ index ], size );
 538          free( ty_XDS_Display[ index ] );
 539          ty_XDS_Display[ index ] = 0;
 540          ty_XDSDisplayCount = 0;
 541          tyOSDUpdate = 1;
 542
 543       }
 544       else
 545       {
 546          // We cleaned out all the XDS stuff to be displayed
 547          ty_XDSAddLine = 0;
 548       }
 549    }
 550    else
 551    {
 552       // We displayed that piece of XDS information long enough
 553       // Let's move on
 554       ty_XDSDisplayCount++;
 555       if ( ty_XDSDisplayCount >= XDS_DISPLAY_FRAMES )
 556       {
 557                    memset( ty_OSD1.text[ 0 ], ' ', TY_CC_MAX_X - 1 );
 558                       ty_OSD1.text[ 0 ][ TY_CC_MAX_X - 1 ] = 0;
 559          ty_XDSDisplayCount = -1;
 560          tyOSDUpdate = 1;
 561       }
 562    }
 563 }
 564
 565
 566 static int  TY_XDS_mode = 0;
 567 static int  TY_XDS_type = 0;
 568 static int  TY_XDS_length = 0;
 569 static char TY_XDS_checksum = 0;
 570
 571 // Array of [ Mode ][ Type ][ Length ]
 572 static char TY_XDS    [ 8 ][ 25 ][ 34 ];
 573 static char TY_XDS_new[ 8 ][ 25 ][ 34 ];
 574
 575 // Array of [ MPAARating|TVRating ][ NumberRatings ]
 576 static const char const *TY_XDS_CHIP[ 2 ][ 8 ] =
 577 {
 578    { "(NOT APPLICABLE)", "G", "PG", "PG-13", "R", "NC-17", "X", "(NOT RATED)" },
 579    { "(NOT RATED)", "TV-Y", "TV-Y7", "TV-G", "TV-PG", "TV-14", "TV-MA",
 580       "(NOT RATED)" }
 581 };
 582
 583 static const char const *TY_XDS_modes[] =
 584 {
 585   "CURRENT",                        // 01h-02h current program
 586   "FUTURE ",                        // 03h-04h future program
 587   "CHANNEL",                        // 05h-06h channel
 588   "MISC.  ",                        // 07h-08h miscellaneous
 589   "PUBLIC ",                        // 09h-0Ah public service
 590   "RESERV.",                        // 0Bh-0Ch reserved
 591   "UNDEF. ",
 592   "INVALID",
 593   "INVALID",
 594   "INVALID"
 595 };
 596
 597 static int ty_XDSdecode( char b1, char b2 )
 598 {
 599    char line[ 80 ];
 600
 601    if ( b1 < 0x0F )
 602    {                                        // start packet
 603       TY_XDS_length = 0;
 604       TY_XDS_mode = b1 >> 1;                // every other mode is a resume
 605       TY_XDS_type = b2;
 606       TY_XDS_checksum = b1 + b2;
 607       return 0;
 608    }
 609
 610    TY_XDS_checksum += b1 + b2;
 611
 612    // eof (next byte is checksum)
 613    if ( b1 == 0x0F )
 614    {
 615       // validity check
 616       if ( !TY_XDS_length || TY_XDS_checksum & 0x7F )
 617       {
 618          if ( TY_OSD_debug > 3 && !TY_XDS_length )
 619          {
 620             mp_msg( MSGT_DEMUX, MSGL_DBG3,
 621                "%% TY_XDS CHECKSUM ERROR (ignoring)\n" );
 622          }
 623          else
 624          {
 625             TY_XDS_mode = 0;
 626             TY_XDS_type = 0;
 627             return 1;
 628          }
 629       }
 630
 631       // check to see if the data has changed.
 632       if ( strncmp( TY_XDS[ TY_XDS_mode ][ TY_XDS_type ],
 633          TY_XDS_new[ TY_XDS_mode ][ TY_XDS_type ], TY_XDS_length - 1 ) )
 634       {
 635          char *TY_XDS_ptr = TY_XDS[ TY_XDS_mode ][ TY_XDS_type ];
 636
 637          TY_XDS_ptr[ TY_XDS_length ] = 0;
 638          memcpy( TY_XDS[ TY_XDS_mode ][ TY_XDS_type ],
 639             TY_XDS_new[ TY_XDS_mode ][ TY_XDS_type ], TY_XDS_length );
 640
 641          // nasty hack: only print time codes if seconds are 0
 642          if ( TY_XDS_mode == 3 && TY_XDS_type == 1 &&
 643             !( TY_XDS_new[ 3 ][ 1 ][ 3 ] & 0x20 ) )
 644                         {
 645             return 0;
 646                         }
 647          if ( TY_XDS_mode == 0 && TY_XDS_type == 2 &&
 648             ( TY_XDS_new[ 0 ][ 2 ][ 4 ] & 0x3f ) > 1 )
 649                         {
 650             return 0;
 651                         }
 652
 653          mp_msg( MSGT_DEMUX, MSGL_DBG3, "%% %s ", TY_XDS_modes[ TY_XDS_mode ] );
 654
 655          line[ 0 ] = 0;
 656          // printf( "XDS Code %x\n",
 657                         //    ( TY_XDS_mode << 9 ) + TY_XDS_type + 0x100 );
 658          switch ( ( TY_XDS_mode << 9 ) + TY_XDS_type + 0x100 )
 659          {
 660             // cases are specified in 2 bytes hex representing mode, type.
 661             // TY_XDS_ptr will point to the current class buffer
 662             case 0x0101:                    // current
 663             case 0x0301:                    // future
 664             {
 665                char *mon[] =
 666                {
 667                   "0", "Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul",
 668                   "Aug", "Sep", "Oct", "Nov", "Dec", "13", "14", "15"
 669                };
 670                ty_AddXDSToDisplay( "AIR DATE: %s %2d %d:%02d:00",
 671                  mon[ TY_XDS_ptr[ 3 ] & 0x0f ],
 672                  TY_XDS_ptr[ 2 ] & 0x1f,
 673                  TY_XDS_ptr[ 1 ] & 0x1f,
 674                  TY_XDS_ptr[ 0 ] & 0x3f
 675                  );
 676
 677                // Program is tape delayed
 678                if ( TY_XDS_ptr[ 3 ] & 0x10 ) ty_AddXDSToDisplay( " TAPE" );
 679             }
 680             break;
 681
 682             case 0x0102:                    // current program length
 683             case 0x0302:                    // future
 684             {
 685                ty_AddXDSToDisplay(
 686                   "DURATION: %d:%02d:%02d of %d:%02d:%02d",
 687                   TY_XDS_ptr[ 3 ] & 0x3f,
 688                   TY_XDS_ptr[ 2 ] & 0x3f,
 689                   TY_XDS_ptr[ 4 ] & 0x3f,
 690                   TY_XDS_ptr[ 1 ] & 0x3f,
 691                   TY_XDS_ptr[ 0 ] & 0x3f, 0);
 692                break;
 693             }
 694
 695             case 0x0103:                    // current program name
 696             case 0x0303:                    // future
 697             {
 698                ty_AddXDSToDisplay( "TITLE: %s", TY_XDS_ptr );
 699                break;
 700             }
 701
 702             case 0x0104:                    // current program type
 703             case 0x0304:                    // future
 704             {
 705                // for now just print out the raw data
 706                // requires a 127 string array to parse
 707                // properly and isn't worth it.
 708                sprintf ( line, "%sGENRE:", line );
 709                {
 710                   int x;
 711                   for ( x = 0 ; x < TY_XDS_length ; x++ )
 712                      sprintf( line, "%s %02x", line, TY_XDS_ptr[ x ] );
 713                }
 714                ty_AddXDSToDisplay( line );
 715                break;
 716             }
 717
 718             case 0x0105:                    // current program rating
 719             case 0x0305:                    // future
 720             {
 721                sprintf( line, "%sRATING: %s", line,
 722                   TY_XDS_CHIP[ ( TY_XDS_ptr[ 0 ] & 0x08 ) >> 3 ]
 723                   [ TY_XDS_ptr[ 1 ] & 0x07 ] );
 724                if ( TY_XDS_ptr[ 0 ] & 0x20 )
 725                   sprintf( line, "%s DIALOGUE", line );
 726                if ( TY_XDS_ptr[ 1 ] & 0x08 )
 727                   sprintf( line, "%s LANGUAGE", line );
 728                if ( TY_XDS_ptr[ 1 ] & 0x10 )
 729                   sprintf( line, "%s SEXUAL", line );
 730                if ( TY_XDS_ptr[ 1 ] & 0x20 )
 731                   sprintf( line, "%s VIOLENCE", line );
 732                ty_AddXDSToDisplay( line );
 733
 734                // raw output for verification.
 735                if ( TY_OSD_debug > 1 )
 736                   mp_msg( MSGT_DEMUX, MSGL_DBG3, " (%02x %02x)",
 737                      TY_XDS_ptr[ 0 ], TY_XDS_ptr[ 1 ] );
 738                break;
 739             }
 740
 741             case 0x0106:                    // current program audio services
 742             case 0x0306:                    // future
 743             {
 744                // requires table, never actually seen it used either
 745                ty_AddXDSToDisplay( "AUDIO: %02x %02x", TY_XDS_ptr[ 0 ],
 746                   TY_XDS_ptr[ 1 ] );
 747                break;
 748             }
 749
 750             case 0x0109:                    // current program aspect ratio
 751             case 0x0309:                    // future
 752             {
 753                // requires table, rare
 754                ty_AddXDSToDisplay( "ASPECT: %02x %02x",
 755                   TY_XDS_ptr[ 0 ], TY_XDS_ptr[ 1 ] );
 756                break;
 757             }
 758
 759             case 0x0110:         // program description
 760             case 0x0111:
 761             case 0x0112:
 762             case 0x0113:
 763             case 0x0114:
 764             case 0x0115:
 765             case 0x0116:
 766             case 0x0117:
 767             {
 768                ty_AddXDSToDisplay( "DESCRIP: %s", TY_XDS_ptr );
 769                break;
 770             }
 771
 772             case 0x0501:                    // channel network name
 773             {
 774                ty_AddXDSToDisplay( "NETWORK: %s", TY_XDS_ptr );
 775                break;
 776             }
 777
 778             case 0x0502:                    // channel network call letters
 779             {
 780                ty_AddXDSToDisplay( "CALLSIGN: %s", TY_XDS_ptr );
 781                break;
 782             }
 783
 784             case 0x0701:                    // misc. time of day
 785             {
 786 #define TIMEZONE          ( TY_XDS[ 3 ][ 4 ][ 0 ] & 0x1f )
 787 #define DST               ( ( TY_XDS[ 3 ][ 4 ][ 0 ] & 0x20 ) >> 5 )
 788                struct tm tm =
 789                {
 790                   .tm_sec = 0,                                // sec
 791                   .tm_min = ( TY_XDS_ptr[ 0 ] & 0x3F ),       // min
 792                   .tm_hour = ( TY_XDS_ptr[ 1 ] & 0x1F ),      // hour
 793                   .tm_mday = ( TY_XDS_ptr[ 2 ] & 0x1F ),      // day
 794                   .tm_mon = ( TY_XDS_ptr[ 3 ] & 0x1f ) - 1,   // month
 795                   .tm_year = ( TY_XDS_ptr[ 5 ] & 0x3f ) + 90, // year
 796                   .tm_wday = 0,                               // day of week
 797                   .tm_yday = 0,                               // day of year
 798                   .tm_isdst = 0,                              // DST
 799                };
 800
 801                time_t time_t = mktime( &tm );
 802                char *timestr;
 803
 804                time_t -= ( ( TIMEZONE - DST ) * 60 * 60 );
 805                timestr = ctime( &time_t );
 806                timestr[ strlen( timestr ) - 1 ] = 0;
 807
 808                sprintf( line, "%sCUR.TIME: %s ", line, timestr );
 809                if ( TY_XDS[ 3 ][ 4 ][ 0 ] )
 810                {
 811                   sprintf( line, "%sUTC-%d", line, TIMEZONE );
 812                   if (DST) sprintf( line, "%s DST", line );
 813                }
 814                else
 815                   sprintf( line, "%sUTC", line );
 816
 817                ty_AddXDSToDisplay( line );
 818
 819                break;
 820             }
 821
 822             case 0x0704:                    //misc. local time zone
 823             {
 824                sprintf( line, "%sTIMEZONE: UTC-%d",
 825                   line, TY_XDS_ptr[ 0 ] & 0x1f );
 826                if ( TY_XDS_ptr[ 0 ] & 0x20 ) sprintf( line, "%s DST", line );
 827                ty_AddXDSToDisplay( line );
 828                break;
 829             }
 830
 831             default:
 832             {
 833                mp_msg( MSGT_DEMUX, MSGL_DBG3, "UNKNOWN CLASS %d TYPE %d",
 834                   ( TY_XDS_mode << 1 ) + 1, TY_XDS_type );
 835               if ( TY_OSD_debug > 1 )
 836               {
 837                   int x;
 838                   mp_msg( MSGT_DEMUX, MSGL_DBG3, "\nDUMP:\n" );
 839                   for ( x = 0 ; x < TY_XDS_length ; x++ )
 840                     mp_msg( MSGT_DEMUX, MSGL_DBG3, " %02x %c",
 841                        TY_XDS_ptr[ x ], TY_XDS_ptr[ x ] );
 842                   mp_msg( MSGT_DEMUX, MSGL_DBG3, "\n" );
 843                }
 844             }
 845          }
 846          if ( TY_OSD_debug > 1 )
 847             mp_msg( MSGT_DEMUX, MSGL_DBG3, " (%d)", TY_XDS_length );
 848       }
 849       TY_XDS_mode = 0;
 850       TY_XDS_type = 0;
 851    }
 852    else if ( TY_XDS_length < 34 )
 853    {
 854       TY_XDS_new[ TY_XDS_mode ][ TY_XDS_type ][ TY_XDS_length++ ] = b1;
 855       TY_XDS_new[ TY_XDS_mode ][ TY_XDS_type ][ TY_XDS_length++ ] = b2;
 856    }
 857    return 0;
 858 }
 859
 860
 861 // ===========================================================================
 862 // Callback from Video Display Processing to put up the OSD
 863 // ===========================================================================
 864 void ty_processuserdata( unsigned char* buf, int len )
 865 {
 866         int index;
 867
 868         sub_justify = 1;
 869
 870         if ( subcc_enabled )
 871         {
 872                 if ( tyOSDInited == 0 )
 873                 {
 874                         for ( index = 0; index < SUB_MAX_TEXT ; index++ )
 875                         {
 876                                 ty_OSD1.text[ index ] = malloc( TY_CC_MAX_X );
 877                                 ty_OSD2.text[ index ] = malloc( TY_CC_MAX_X );
 878                         }
 879                         ty_ClearOSD( 0 );
 880                         ty_OSD1.lines = SUB_MAX_TEXT;
 881                         ty_OSD2.lines = SUB_MAX_TEXT;
 882                         ty_pOSD1 = &ty_OSD1;
 883                         ty_pOSD2 = &ty_OSD2;
 884                         tyOSDUpdate = 0;
 885                         tyOSDInited = 1;
 886                 }
 887
 888                 if ( buf[ 0 ] == 0x01 )
 889                 {
 890                         ty_CCdecode( buf[ 1 ], buf[ 2 ] );
 891                 }
 892                 if ( buf[ 0 ] == 0x02 )
 893                 {
 894                         ty_XDSdecode( buf[ 1 ], buf[ 2 ] );
 895                 }
 896
 897       ty_DisplayXDSInfo();
 898
 899                 if ( tyOSDUpdate )
 900                 {
 901                         // for ( index = 0; index < SUB_MAX_TEXT ; index++ )
 902                         // {
 903          //    printf( "OSD:%d:%s\n", index, ty_OSD1.text[ index ] );
 904          // }
 905                    vo_sub = &ty_OSD1;
 906                 vo_osd_changed( OSDTYPE_SUBTITLE );
 907                         tyOSDUpdate = 0;
 908                 }
 909         }
 910 }
 911
 912
 913