sub_cc.c

   1 /*
   2  * decoder for Closed Captions
   3  *
   4  * This decoder relies on MPlayer's OSD to display subtitles.
   5  * Be warned that decoding is somewhat preliminary, though it basically works.
   6  *
   7  * Most notably, only the text information is decoded as of now, discarding
   8  * color, background and position info (see source below).
   9  *
  10  * by Matteo Giani
  11  *
  12  * uses source from the xine closed captions decoder
  13  */
  14
  15
  16 #include <stdio.h>
  17 #include <stdlib.h>
  18 #include <string.h>
  19
  20 #include "config.h"
  21 #include "sub_cc.h"
  22
  23 #include "subreader.h"
  24
  25 #include "libvo/video_out.h"
  26 #include "libvo/sub.h"
  27
  28
  29 #define CC_MAX_LINE_LENGTH 64
  30
  31 static char chartbl[128];
  32
  33 static subtitle buf1,buf2;
  34 static subtitle *fb,*bb;
  35
  36 static unsigned int cursor_pos=0;
  37
  38 static int initialized=0;
  39
  40 #define CC_ROLLON 1
  41 #define CC_ROLLUP 2
  42
  43 static int cc_mode=CC_ROLLON;
  44 static int cc_lines=4; ///< number of visible rows in CC roll-up mode, not used in CC roll-on mode
  45
  46 static void display_buffer(subtitle * buf);
  47
  48 static void build_char_table(void)
  49 {
  50   int i;
  51   /* first the normal ASCII codes */
  52   for (i = 0; i < 128; i++)
  53     chartbl[i] = (char) i;
  54   /* now the special codes */
  55   chartbl[0x2a] = 'á';
  56   chartbl[0x5c] = 'é';
  57   chartbl[0x5e] = 'í';
  58   chartbl[0x5f] = 'ó';
  59   chartbl[0x60] = 'ú';
  60   chartbl[0x7b] = 'ç';
  61   chartbl[0x7c] = '÷';
  62   chartbl[0x7d] = 'Ñ';
  63   chartbl[0x7e] = 'ñ';
  64   chartbl[0x7f] = '¤';    /* FIXME: this should be a solid block */
  65 }
  66
  67 static void clear_buffer(subtitle *buf)
  68 {
  69         int i;
  70         buf->lines=0;
  71         for(i=0;i<SUB_MAX_TEXT;i++) if(buf->text[i]) {free(buf->text[i]);buf->text[i]=NULL;}
  72 }
  73
  74
  75 /**
  76  \brief scroll buffer one line up
  77  \param buf buffer to scroll
  78 */
  79 static void scroll_buffer(subtitle* buf)
  80 {
  81         int i;
  82
  83         while(buf->lines > cc_lines)
  84         {
  85                 if(buf->text[0]) free(buf->text[0]);
  86
  87                 for(i = 0; i < (buf->lines - 1); i++) buf->text[i] = buf->text[i+1];
  88
  89                 buf->text[buf->lines-1] = NULL;
  90                 buf->lines--;
  91         }
  92 }
  93
  94
  95 void subcc_init(void)
  96 {
  97         int i;
  98         //printf("subcc_init(): initing...\n");
  99         build_char_table();
 100         for(i=0;i<SUB_MAX_TEXT;i++) {buf1.text[i]=buf2.text[i]=NULL;}
 101         buf1.lines=buf2.lines=0;
 102         fb=&buf1;
 103         bb=&buf2;
 104
 105         initialized=1;
 106 }
 107
 108 static void append_char(char c)
 109 {
 110         if(!bb->lines) {bb->lines++; cursor_pos=0;}
 111         if(bb->text[bb->lines - 1]==NULL)
 112         {
 113                 bb->text[bb->lines - 1]=malloc(CC_MAX_LINE_LENGTH);
 114                 memset(bb->text[bb->lines - 1],0,CC_MAX_LINE_LENGTH);
 115                 cursor_pos=0;
 116         }
 117
 118         if(c=='\n')
 119         {
 120                 if(cursor_pos>0 && bb->lines < SUB_MAX_TEXT)
 121                 {
 122                         bb->lines++;cursor_pos=0;
 123                         if(cc_mode==CC_ROLLUP){ //Carriage return - scroll buffer one line up
 124                                 bb->text[bb->lines - 1]=calloc(1, CC_MAX_LINE_LENGTH);
 125                                 scroll_buffer(bb);
 126                         }
 127                 }
 128         }
 129         else
 130         {
 131                 if(cursor_pos==CC_MAX_LINE_LENGTH-1)
 132                 {
 133                         fprintf(stderr,"CC: append_char() reached CC_MAX_LINE_LENGTH!\n");
 134                         return;
 135                 }
 136                 bb->text[bb->lines - 1][cursor_pos++]=c;
 137         }
 138         //In CC roll-up mode data should be shown immediately
 139         if(cc_mode==CC_ROLLUP) display_buffer(bb);
 140 }
 141
 142
 143 static void swap_buffers(void)
 144 {
 145         subtitle *foo;
 146         foo=fb;
 147         fb=bb;
 148         bb=foo;
 149 }
 150
 151 static void display_buffer(subtitle * buf)
 152 {
 153         vo_sub=buf;
 154         vo_osd_changed(OSDTYPE_SUBTITLE);
 155 }
 156
 157
 158 static void cc_decode_EIA608(unsigned short int data)
 159 {
 160
 161   static unsigned short int lastcode=0x0000;
 162   unsigned char c1 = data & 0x7f;
 163   unsigned char c2 = (data >> 8) & 0x7f;
 164
 165   if (c1 & 0x60) {              /* normal character, 0x20 <= c1 <= 0x7f */
 166            append_char(chartbl[c1]);
 167            if(c2 & 0x60)        /*c2 might not be a normal char even if c1 is*/
 168                    append_char(chartbl[c2]);
 169   }
 170   else if (c1 & 0x10)           // control code / special char
 171   {
 172 //        int channel= (c1 & 0x08) >> 3;
 173           c1&=~0x08;
 174           if(data!=lastcode)
 175           {
 176                 if(c2 & 0x40) { /*PAC, Preamble Address Code */
 177                         append_char('\n'); /*FIXME properly interpret PACs*/
 178                 }
 179                 else
 180                         switch(c1)
 181                         {
 182                                 case 0x10:      break; // ext attribute
 183                                 case 0x11:
 184                                         if((c2 & 0x30)==0x30)
 185                                         {
 186                                                 //printf("[debug]:Special char (ignored)\n");
 187                                                 /*cc_decode_special_char()*/;
 188                                         }
 189                                         else if (c2 & 0x20)
 190                                         {
 191                                                 //printf("[debug]: midrow_attr (ignored)\n");
 192                                                 /*cc_decode_midrow_attr()*/;
 193                                         }
 194                                         break;
 195                                 case 0x14:
 196                                         switch(c2)
 197                                         {
 198                                                 case 0x00: //CC roll-on mode
 199                                                            cc_mode=CC_ROLLON;
 200                                                            break;
 201                                                 case 0x25: //CC roll-up, 2 rows
 202                                                 case 0x26: //CC roll-up, 3 rows
 203                                                 case 0x27: //CC roll-up, 4 rows
 204                                                            cc_lines=c2-0x23;
 205                                                            cc_mode=CC_ROLLUP;
 206                                                            break;
 207                                                 case 0x2C: display_buffer(NULL); //EDM
 208                                                            clear_buffer(fb); break;
 209                                                 case 0x2d: append_char('\n');   //carriage return
 210                                                            break;
 211                                                 case 0x2e: clear_buffer(bb);    //ENM
 212                                                            break;
 213                                                 case 0x2f: swap_buffers();      //Swap buffers
 214                                                            display_buffer(fb);
 215                                                            clear_buffer(bb);
 216                                                            break;
 217                                         }
 218                                         break;
 219                                 case 0x17:
 220                                         if( c2>=0x21 && c2<=0x23) //TAB
 221                                         {
 222                                                 break;
 223                                         }
 224                         }
 225           }
 226   }
 227   lastcode=data;
 228 }
 229
 230 static void subcc_decode(unsigned char *inputbuffer, unsigned int inputlength)
 231 {
 232   /* The first number may denote a channel number. I don't have the
 233    * EIA-708 standard, so it is hard to say.
 234    * From what I could figure out so far, the general format seems to be:
 235    *
 236    * repeat
 237    *
 238    *   0xfe starts 2 byte sequence of unknown purpose. It might denote
 239    *        field #2 in line 21 of the VBI. We'll ignore it for the
 240    *        time being.
 241    *
 242    *   0xff starts 2 byte EIA-608 sequence, field #1 in line 21 of the VBI.
 243    *        Followed by a 3-code triplet that starts either with 0xff or
 244    *        0xfe. In either case, the following triplet needs to be ignored
 245    *        for line 21, field 1.
 246    *
 247    *   0x00 is padding, followed by 2 more 0x00.
 248    *
 249    *   0x01 always seems to appear at the beginning, always seems to
 250    *        be followed by 0xf8, 8-bit number.
 251    *        The lower 7 bits of this 8-bit number seem to denote the
 252    *        number of code triplets that follow.
 253    *        The most significant bit denotes whether the Line 21 field 1
 254    *        captioning information is at odd or even triplet offsets from this
 255    *        beginning triplet. 1 denotes odd offsets, 0 denotes even offsets.
 256    *
 257    *        Most captions are encoded with odd offsets, so this is what we
 258    *        will assume.
 259    *
 260    * until end of packet
 261    */
 262   unsigned char *current = inputbuffer;
 263   unsigned int curbytes = 0;
 264   unsigned char data1, data2;
 265   unsigned char cc_code;
 266   int odd_offset = 1;
 267
 268   while (curbytes < inputlength) {
 269     int skip = 2;
 270
 271     cc_code = *(current);
 272
 273     if (inputlength - curbytes < 2) {
 274 #ifdef LOG_DEBUG
 275       fprintf(stderr, "Not enough data for 2-byte CC encoding\n");
 276 #endif
 277       break;
 278     }
 279
 280     data1 = *(current+1);
 281     data2 = *(current + 2);
 282     current++; curbytes++;
 283
 284     switch (cc_code) {
 285     case 0xfe:
 286       /* expect 2 byte encoding (perhaps CC3, CC4?) */
 287       /* ignore for time being */
 288       skip = 2;
 289       break;
 290
 291     case 0xff:
 292       /* expect EIA-608 CC1/CC2 encoding */
 293       // FIXME check parity!
 294       // Parity check omitted assuming we are reading from a DVD and therefore
 295       // we should encounter no "transmission errors".
 296       cc_decode_EIA608(data1 | (data2 << 8));
 297       skip = 5;
 298       break;
 299
 300     case 0x00:
 301       /* This seems to be just padding */
 302       skip = 2;
 303       break;
 304
 305     case 0x01:
 306       odd_offset = data2 & 0x80;
 307       if (odd_offset)
 308         skip = 2;
 309       else
 310         skip = 5;
 311       break;
 312
 313     default:
 314 //#ifdef LOG_DEBUG
 315       fprintf(stderr, "Unknown CC encoding: %x\n", cc_code);
 316 //#endif
 317       skip = 2;
 318       break;
 319     }
 320     current += skip;
 321     curbytes += skip;
 322   }
 323 }
 324
 325
 326 void subcc_process_data(unsigned char *inputdata,unsigned int len)
 327 {
 328         if(!subcc_enabled) return;
 329         if(!initialized) subcc_init();
 330
 331         subcc_decode(inputdata, len);
 332 }