libmpcodecs/dec_teletext.c

   1 /*
   2  * Teletext support
   3  *
   4  * Copyright (C) 2007 Vladimir Voroshilov <voroshil@gmail.com>
   5  *
   6  * This file is part of MPlayer.
   7  *
   8  * MPlayer is free software; you can redistribute it and/or modify
   9  * it under the terms of the GNU General Public License as published by
  10  * the Free Software Foundation; either version 2 of the License, or
  11  * (at your option) any later version.
  12  *
  13  * MPlayer 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 General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU General Public License along
  19  * with MPlayer; if not, write to the Free Software Foundation, Inc.,
  20  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  21  *
  22  *
  23  * Based on Attila Otvos' teletext patch, Michael Niedermayer's
  24  * proof-of-concept teletext capture utility and some parts
  25  * (decode_raw_line_runin,pll_add,pll_reset) of MythTV project.
  26  * Code for calculating [soc:eoc] is based on aletv of Edgar Toernig.
  27  *
  28  * Teletext system is described in
  29  * ETS 300 706 "Enhanced Teletext specification" : May 1997
  30  * http://www.themm.net/~mihu/linux/saa7146/specs/ets_300706e01p.pdf
  31  *
  32  * Some implementation details:
  33  * How to port teletext to another tvi_* driver (see tvi_v4l2.c for example):
  34  *
  35  * 1. Implement TVI_CONTROL_VBI_INIT (initialize driver-related vbi subsystem,
  36  *    start grabbing thread)
  37  *    input data: vbi device name.
  38  *    (driver should also call TV_VBI_CONTROL_START for common vbi subsystem initialization
  39  *    with pointer to initialized tt_stream_properties structure.
  40  *    After ioctl call variable will contain pointer to initialized priv_vbi_t structure.
  41  *
  42  * 2. After receiving next chunk of raw vbi data call TV_VBI_CONTROL_DECODE_PAGE
  43  *    ioctl with pointer to data buffer
  44  * 3. pass all other VBI related ioctl cmds to teletext_control routine
  45  *
  46  * Page displaying process consist of following stages:
  47  *
  48  * ---grabbing stage---
  49  * 0. stream/tvi_*.c: vbi_grabber(...)
  50  *      getting vbi data from video device
  51  * ---decoding stage---
  52  * 1. libmpcodecs/dec_teletext.c: decode_raw_line_runin(...) or decode_raw_line_sine(...)
  53  *      decode raw vbi data into sliced 45(?) bytes long packets
  54  * 2. libmpcodecs/dec_teletext.c: decode_pkt0(...), decode_pkt_page(...)
  55  *      packets processing (header analyzing, storing complete page in cache,
  56  *      only raw member of tt_char is filled at this stage)
  57  * 3. libmpcodecs/dec_teletext.c: decode_page(...)
  58  *      page decoding. filling unicode,gfx,ctl,etc members of tt_char structure
  59  *      with appropriate values according to teletext control chars, converting
  60  *      text to utf8.
  61  * ---rendering stage---
  62  * 4. libmpcodecs/dec_teletext.c: prepare_visible_page(...)
  63  *      processing page. adding number of just received by background process
  64  *      teletext page, adding current time,etc.
  65  * 5. libvo/sub.c: vo_update_text_teletext(...)
  66  *      rendering displayable osd with text and graphics
  67  *
  68  * TODO:
  69  *  v4lv1,bktr support
  70  *  spu rendering
  71  *  is better quality on poor signal possible ?
  72  *  link support
  73  *  greyscale osd
  74  *  slave command for dumping pages
  75  *  fix bcd<->dec as suggested my Michael
  76  *
  77  *  BUGS:
  78  *  wrong colors in debug dump
  79  *  blinking when visible page was just updated
  80  */
  81
  82 #include "config.h"
  83
  84 #include <stdlib.h>
  85 #include <string.h>
  86 #include <unistd.h>
  87 #include <errno.h>
  88 #include <math.h>
  89 #include <stdio.h>
  90
  91 #ifdef HAVE_PTHREADS
  92 // pthreads are needed for async updates from v4l(2)
  93 // FIXME: try to avoid using pthread calls when running only a single
  94 // thread as e.g. with DVB teletext
  95 #include <pthread.h>
  96 #else
  97 #define pthread_mutex_init(m, p)
  98 #define pthread_mutex_destroy(m)
  99 #define pthread_mutex_lock(m)
 100 #define pthread_mutex_unlock(m)
 101 #endif
 102
 103 #include "dec_teletext.h"
 104 #include "mp_msg.h"
 105 #include "help_mp.h"
 106 #include "libmpcodecs/img_format.h"
 107 #include "libavutil/common.h"
 108 #include "input/input.h"
 109 #include "osdep/timer.h"
 110
 111 //#define DEBUG_DUMP 1
 112
 113 /// page magazine entry structure
 114 typedef struct mag_s{
 115     tt_page* pt;
 116     int      order;
 117 } mag_t;
 118
 119 typedef struct {
 120     int             on;            ///< teletext on/off
 121     int             pagenum;       ///< seek page number
 122     int             subpagenum;    ///< seek subpage
 123     int             curr_pagenum;  ///< current page number
 124     int             pagenumdec;    ///< set page num with dec
 125
 126     teletext_format tformat;       ///< see teletext_format enum
 127     teletext_zoom   zoom;          ///< see teletext_zoom enum
 128     mag_t*          mag;           ///< pages magazine (has 8 entities)
 129     int             primary_language;      ///< primary character set
 130     int             secondary_language;    ///< secondary character set
 131     /// Currently displayed page (with additional info, e.g current time)
 132     tt_char         display_page[VBI_ROWS*VBI_COLUMNS];
 133     /// number of raw bytes between two subsequent encoded bits
 134     int bpb;
 135     /// clock run-in sequence will be searched in buffer in [soc:eoc] bytes range
 136     int soc;
 137     int eoc;
 138     /// minimum number of raw vbi bytes wich can be decoded into 8 data bits
 139     int bp8bl;
 140     /// maximum number of raw vbi bytes wich can be decoded into 8 data bits
 141     int bp8bh;
 142
 143     int pll_adj;
 144     int pll_dir;
 145     int pll_cnt;
 146     int pll_err;
 147     int pll_lerr;
 148     int pll_fixed;
 149     /// vbi stream properties (buffer size,bytes per line, etc)
 150     tt_stream_props* ptsp;
 151 #ifdef HAVE_PTHREADS
 152     pthread_mutex_t buffer_mutex;
 153 #endif
 154
 155     tt_page** ptt_cache;
 156     unsigned char* ptt_cache_first_subpage;
 157     /// network info
 158     unsigned char initialpage;
 159     unsigned int  initialsubpage;
 160     unsigned int  networkid;
 161     int           timeoffset; // timeoffset=realoffset*2
 162     unsigned int  juliandate;
 163     unsigned int  universaltime;
 164     unsigned char networkname[21];
 165     int           cache_reset;
 166     /// "page changed" flag: 0-unchanged, 1-entire page, 3-only header
 167     int           page_changed;
 168     int           last_rendered;
 169 } priv_vbi_t;
 170
 171 static unsigned char fixParity[256];
 172
 173 static const tt_char tt_space={0x20,7,0,0,0,0,0,0,0x20};
 174 static const tt_char tt_error={'?',1,0,0,0,0,0,0,'?'}; // Red '?' on black background
 175 static double si[12];
 176 static double co[12];
 177
 178 #define VBI_FORMAT(priv) (*(priv->ptsp))
 179
 180 #define FIXP_SH 16
 181 #define ONE_FIXP (1<<FIXP_SH)
 182 #define FIXP2INT(a) ((a)>>FIXP_SH)
 183 #define ANY2FIXP(a) ((int)((a)*ONE_FIXP))
 184
 185 static const unsigned char corrHamm48[256]={
 186   0x01, 0xff, 0x01, 0x01, 0xff, 0x00, 0x01, 0xff,
 187   0xff, 0x02, 0x01, 0xff, 0x0a, 0xff, 0xff, 0x07,
 188   0xff, 0x00, 0x01, 0xff, 0x00, 0x00, 0xff, 0x00,
 189   0x06, 0xff, 0xff, 0x0b, 0xff, 0x00, 0x03, 0xff,
 190   0xff, 0x0c, 0x01, 0xff, 0x04, 0xff, 0xff, 0x07,
 191   0x06, 0xff, 0xff, 0x07, 0xff, 0x07, 0x07, 0x07,
 192   0x06, 0xff, 0xff, 0x05, 0xff, 0x00, 0x0d, 0xff,
 193   0x06, 0x06, 0x06, 0xff, 0x06, 0xff, 0xff, 0x07,
 194   0xff, 0x02, 0x01, 0xff, 0x04, 0xff, 0xff, 0x09,
 195   0x02, 0x02, 0xff, 0x02, 0xff, 0x02, 0x03, 0xff,
 196   0x08, 0xff, 0xff, 0x05, 0xff, 0x00, 0x03, 0xff,
 197   0xff, 0x02, 0x03, 0xff, 0x03, 0xff, 0x03, 0x03,
 198   0x04, 0xff, 0xff, 0x05, 0x04, 0x04, 0x04, 0xff,
 199   0xff, 0x02, 0x0f, 0xff, 0x04, 0xff, 0xff, 0x07,
 200   0xff, 0x05, 0x05, 0x05, 0x04, 0xff, 0xff, 0x05,
 201   0x06, 0xff, 0xff, 0x05, 0xff, 0x0e, 0x03, 0xff,
 202   0xff, 0x0c, 0x01, 0xff, 0x0a, 0xff, 0xff, 0x09,
 203   0x0a, 0xff, 0xff, 0x0b, 0x0a, 0x0a, 0x0a, 0xff,
 204   0x08, 0xff, 0xff, 0x0b, 0xff, 0x00, 0x0d, 0xff,
 205   0xff, 0x0b, 0x0b, 0x0b, 0x0a, 0xff, 0xff, 0x0b,
 206   0x0c, 0x0c, 0xff, 0x0c, 0xff, 0x0c, 0x0d, 0xff,
 207   0xff, 0x0c, 0x0f, 0xff, 0x0a, 0xff, 0xff, 0x07,
 208   0xff, 0x0c, 0x0d, 0xff, 0x0d, 0xff, 0x0d, 0x0d,
 209   0x06, 0xff, 0xff, 0x0b, 0xff, 0x0e, 0x0d, 0xff,
 210   0x08, 0xff, 0xff, 0x09, 0xff, 0x09, 0x09, 0x09,
 211   0xff, 0x02, 0x0f, 0xff, 0x0a, 0xff, 0xff, 0x09,
 212   0x08, 0x08, 0x08, 0xff, 0x08, 0xff, 0xff, 0x09,
 213   0x08, 0xff, 0xff, 0x0b, 0xff, 0x0e, 0x03, 0xff,
 214   0xff, 0x0c, 0x0f, 0xff, 0x04, 0xff, 0xff, 0x09,
 215   0x0f, 0xff, 0x0f, 0x0f, 0xff, 0x0e, 0x0f, 0xff,
 216   0x08, 0xff, 0xff, 0x05, 0xff, 0x0e, 0x0d, 0xff,
 217   0xff, 0x0e, 0x0f, 0xff, 0x0e, 0x0e, 0xff, 0x0e };
 218
 219
 220 enum {
 221   LATIN=0,
 222   CYRILLIC1,
 223   CYRILLIC2,
 224   CYRILLIC3,
 225   GREEK,
 226   LANGS
 227 };
 228
 229 // conversion table for chars 0x20-0x7F (UTF8)
 230 // TODO: add another languages
 231 static const unsigned int lang_chars[LANGS][0x60]={
 232  {
 233   //Latin
 234   0x20,0x21,0x22,0x23,0x24,0x25,0x26,0x27,
 235   0x28,0x29,0x2a,0x2b,0x2c,0x2d,0x2e,0x2f,
 236   0x30,0x31,0x32,0x33,0x34,0x35,0x36,0x37,
 237   0x38,0x39,0x3a,0x3b,0x3c,0x3d,0x3e,0x3f,
 238   0x40,0x41,0x42,0x43,0x44,0x45,0x46,0x47,
 239   0x48,0x49,0x4a,0x4b,0x4c,0x4d,0x4e,0x4f,
 240   0x50,0x51,0x52,0x53,0x54,0x55,0x56,0x57,
 241   0x58,0x59,0x5a,0x5b,0x5c,0x5d,0x5e,0x5f,
 242   0x60,0x61,0x62,0x63,0x64,0x65,0x66,0x67,
 243   0x68,0x69,0x6a,0x6b,0x6c,0x6d,0x6e,0x6f,
 244   0x70,0x71,0x72,0x73,0x74,0x75,0x76,0x77,
 245   0x78,0x79,0x7a,0x7b,0x7c,0x7d,0x7e,0x7f
 246  },
 247  {
 248   //Cyrillic-1 (Serbian/Croatian)
 249   0x20,0x21,0x22,0x23,0x24,0x25,0x044b,0x27,
 250   0x28,0x29,0x2a,0x2b,0x2c,0x2d,0x2e,0x2f,
 251   0x30,0x31,0x32,0x33,0x34,0x35,0x36,0x37,
 252   0x38,0x39,0x3a,0x3b,0x3c,0x3d,0x3e,0x3f,
 253   0x0427,0x0410,0x0411,0x0426,0x0414,0x0415,0x0424,0x0413,
 254   0x0425,0x0418,0x0408,0x041a,0x041b,0x041c,0x041d,0x041e,
 255   0x041f,0x040c,0x0420,0x0421,0x0422,0x0423,0x0412,0x0403,
 256   0x0409,0x040a,0x0417,0x040b,0x0416,0x0402,0x0428,0x040f,
 257   0x0447,0x0430,0x0431,0x0446,0x0434,0x0435,0x0444,0x0433,
 258   0x0445,0x0438,0x0428,0x043a,0x043b,0x043c,0x043d,0x043e,
 259   0x043f,0x042c,0x0440,0x0441,0x0442,0x0443,0x0432,0x0423,
 260   0x0429,0x042a,0x0437,0x042b,0x0436,0x0422,0x0448,0x042f
 261  },
 262  {
 263   //Cyrillic-2 (Russian/Bulgarian)
 264   0x20,0x21,0x22,0x23,0x24,0x25,0x044b,0x27,
 265   0x28,0x29,0x2a,0x2b,0x2c,0x2d,0x2e,0x2f,
 266   0x30,0x31,0x32,0x33,0x34,0x35,0x36,0x37,
 267   0x38,0x39,0x3a,0x3b,0x3c,0x3d,0x3e,0x3f,
 268   0x042e,0x0410,0x0411,0x0426,0x0414,0x0415,0x0424,0x0413,
 269   0x0425,0x0418,0x0419,0x041a,0x041b,0x041c,0x041d,0x041e,
 270   0x041f,0x042f,0x0420,0x0421,0x0422,0x0423,0x0416,0x0412,
 271   0x042c,0x042a,0x0417,0x0428,0x042d,0x0429,0x0427,0x042b,
 272   0x044e,0x0430,0x0431,0x0446,0x0434,0x0435,0x0444,0x0433,
 273   0x0445,0x0438,0x0439,0x043a,0x043b,0x043c,0x043d,0x043e,
 274   0x043f,0x044f,0x0440,0x0441,0x0442,0x0443,0x0436,0x0432,
 275   0x044c,0x044a,0x0437,0x0448,0x044d,0x0449,0x0447,0x044b
 276  },
 277  {
 278   //Cyrillic-3 (Ukrainian)
 279   0x20,0x21,0x22,0x23,0x24,0x25,0xef,0x27,
 280   0x28,0x29,0x2a,0x2b,0x2c,0x2d,0x2e,0x2f,
 281   0x30,0x31,0x32,0x33,0x34,0x35,0x36,0x37,
 282   0x38,0x39,0x3a,0x3b,0x3c,0x3d,0x3e,0x3f,
 283   0x042e,0x0410,0x0411,0x0426,0x0414,0x0415,0x0424,0x0413,
 284   0x0425,0x0418,0x0419,0x041a,0x041b,0x041c,0x041d,0x041e,
 285   0x041f,0x042f,0x0420,0x0421,0x0422,0x0423,0x0416,0x0412,
 286   0x042c,0x49,0x0417,0x0428,0x042d,0x0429,0x0427,0xcf,
 287   0x044e,0x0430,0x0431,0x0446,0x0434,0x0435,0x0444,0x0433,
 288   0x0445,0x0438,0x0439,0x043a,0x043b,0x043c,0x043d,0x043e,
 289   0x043f,0x044f,0x0440,0x0441,0x0442,0x0443,0x0436,0x0432,
 290   0x044c,0x69,0x0437,0x0448,0x044d,0x0449,0x0447,0xFF
 291  },
 292  {
 293   //Greek
 294   0x20,0x21,0x22,0x23,0x24,0x25,0x26,0x27,
 295   0x28,0x29,0x2a,0x2b,0x2c,0x2d,0x2e,0x2f,
 296   0x30,0x31,0x32,0x33,0x34,0x35,0x36,0x37,
 297   0x38,0x39,0x3a,0x3b,0x3c,0x3d,0x3e,0x3f,
 298   0x0390,0x0391,0x0392,0x0393,0x0394,0x0395,0x0396,0x0397,
 299   0x0398,0x0399,0x039a,0x039b,0x039c,0x039d,0x039e,0x039f,
 300   0x03a0,0x03a1,0x03a2,0x03a3,0x03a4,0x03a5,0x03a6,0x03a7,
 301   0x03a8,0x03a9,0x03aa,0x03ab,0x03ac,0x03ad,0x03ae,0x03af,
 302   0x03b0,0x03b1,0x03b2,0x03b3,0x03b4,0x03b5,0x03b6,0x03b7,
 303   0x03b8,0x03b9,0x03ba,0x03bb,0x03bc,0x03bd,0x03be,0x03bf,
 304   0x03c0,0x03c1,0x03c2,0x03c3,0x03c4,0x03c5,0x03c6,0x03c7,
 305   0x03c8,0x03c9,0x03ca,0x03cb,0x03cc,0x03cd,0x03ce,0x03cf
 306  }
 307 };
 308
 309 /**
 310  * Latin National Option Sub-Sets
 311  * see Table 36 of ETS specification for details.
 312  *
 313  * 00:  £ $ @ « ½ » ¬ #  ¼ ¦ ¾ ÷  English
 314  * 01:  é ï à ë ê ù î # è â ô û ç  French
 315  * 02:  # ¤ É Ä Ö Å Ü _ é ä ö å ü  Swedish/Finnish/Hungarian
 316  * 03:  # ů č ť ž ý í ř é á ě ú š  Czech/Slovak
 317  * 04:  # $ § Ä Ö Ü ^ _ ° ä ö ü ß  German
 318  * 05:  ç $ ¡ á é í ó ú ¿ ü ñ è à  Portuguese/Spanish
 319  * 06:  £ $ é ° ç » ¬ # ù à ò è ì  Italian
 320  *
 321  */
 322 static const unsigned int latin_subchars[8][13]={
 323   // English
 324   {0xa3,0x24,0x40,0xab,0xbd,0xbb,0xac,0x23,0xad,0xbc,0xa6,0xbe,0xf7},
 325   // French
 326   {0xe9,0xef,0xe0,0xeb,0xea,0xf9,0xee,0x23,0xe8,0xe2,0xf4,0xfb,0xe7},
 327   // Swedish/Finnish/Hungarian
 328   {0x23,0xa4,0xc9,0xc4,0xd6,0xc5,0xdc,0x5f,0xe9,0xe4,0xf6,0xe5,0xfc},
 329   // Czech/Slovak
 330   {0x23,0x16f,0x10d,0x165,0x17e,0xfd,0xed,0x159,0xe9,0xe1,0x11b,0xfa,0x161},
 331   // German
 332   {0x23,0x24,0xa7,0xc4,0xd6,0xdc,0x5e,0x5f,0xb0,0xe4,0xf6,0xfc,0xdf},
 333   // Portuguese/Spanish
 334   {0xe7,0x24,0xa1,0xe1,0xe9,0xed,0xf3,0xfa,0xbf,0xfc,0xf1,0xe8,0xe0},
 335   // Italian
 336   {0xa3,0x24,0xe9,0xb0,0xe7,0xbb,0xac,0x23,0xf9,0xe0,0xf2,0xe8,0xec},
 337   // Reserved
 338   {0x23,0x24,0x40,0x5b,0x5c,0x5d,0x5e,0x5f,0x60,0x7b,0x7c,0x7d,0x7e}
 339 };
 340
 341 /**
 342  * List of supported languages.
 343  *
 344  * lang_code bits for primary Language:
 345  * bits 7-4 corresponds to bits 14-11 of 28 packet's first triplet
 346  * bits 3-1 corresponds to bits C12-C14 of packet 0 (lang)
 347  *
 348  * lang_code bits for secondary Language:
 349  * bits 7-5 corresponds to bits 3-1 of 28 packet's second triplet
 350  * bits 4,2 corresponds to bits 18,16 of 28 packet's first triplet
 351  * bits 3,1 corresponds to bits 15,17 of 28 packet's first triplet
 352  *
 353  * For details see Tables 32 and 33 of specification (subclause 15.2)
 354  */
 355 struct {
 356     unsigned char lang_code;
 357     unsigned char charset;
 358     const char* lang_name;
 359 } const tt_languages[]=
 360 {
 361   { 0x01, LATIN,     "French"},
 362   { 0x02, LATIN,     "Swedish/Finnish/Hungarian"},
 363   { 0x03, LATIN,     "Czech/Slovak"},
 364   { 0x04, LATIN,     "German"},
 365   { 0x05, LATIN,     "Portuguese/Spanish"},
 366   { 0x06, LATIN,     "Italian"},
 367
 368   { 0x08, LATIN,     "Polish"},
 369   { 0x09, LATIN,     "French"},
 370   { 0x0a, LATIN,     "Swedish/Finnish/Hungarian"},
 371   { 0x0b, LATIN,     "Czech/Slovak"},
 372   { 0x0c, LATIN,     "German"},
 373   { 0x0e, LATIN,     "Italian"},
 374
 375   { 0x10, LATIN,     "English"},
 376   { 0x11, LATIN,     "French"},
 377   { 0x12, LATIN,     "Swedish/Finnish/Hungarian"},
 378   { 0x13, LATIN,     "Turkish"},
 379   { 0x14, LATIN,     "German"},
 380   { 0x15, LATIN,     "Portuguese/Spanish"},
 381   { 0x16, LATIN,     "Italian"},
 382
 383   { 0x1d, LATIN,     "Serbian/Croatian/Slovenian (Latin)"},
 384
 385   { 0x20, CYRILLIC1, "Serbian/Croatian (Cyrillic)"},
 386   { 0x21, CYRILLIC2, "Russian, Bulgarian"},
 387   { 0x22, LATIN,     "Estonian"},
 388   { 0x23, LATIN,     "Czech/Slovak"},
 389   { 0x24, LATIN,     "German"},
 390   { 0x25, CYRILLIC3, "Ukrainian"},
 391   { 0x26, LATIN,     "Lettish/Lithuanian"},
 392
 393   { 0x33, LATIN,     "Turkish"},
 394   { 0x37, GREEK,     "Greek"},
 395
 396   { 0x40, LATIN,     "English"},
 397   { 0x41, LATIN,     "French"},
 398 //  { 0x47, ARABIC,    "Arabic"},
 399
 400 //  { 0x55, HEBREW,    "Hebrew"},
 401 //  { 0x57, ARABIC,    "Arabic"},
 402
 403   { 0x00, LATIN,     "English"},
 404 };
 405
 406 /**
 407  * \brief 24/18 Hamming code decoding
 408  * \param data bytes with hamming code (array must be at least 3 bytes long)
 409  * \return -1 if multiple bit error occured, D1-DI data bits - otherwise
 410  *
 411  * \note Bits must be correctly ordered, that is for 24/18 (lowest bit first)
 412  * P1 P2 D1 P3 D2 D3 D4 P4  D5 D6 D7 D8 D9 DA DB P5  DC DD DE DF DG DH DI P6
 413  */
 414 static int corrHamm24(unsigned char *data){
 415     unsigned char syndrom=0;
 416     int cw=data[0] | (data[1]<<8) | (data[2]<<16);
 417     int i;
 418
 419     for(i=0;i<23;i++)
 420         syndrom^=((cw>>i)&1)*(i+33);
 421
 422     syndrom^=(cw>>11)&32;
 423
 424     if(syndrom&31){
 425         if(syndrom < 32 || syndrom > 55)
 426             return -1;
 427         cw ^= 1<<((syndrom&31)-1);
 428    }
 429
 430    return (cw&4)>>2 |
 431           (cw&0x70)>>3 |
 432           (cw&0x3f00)>>4 |
 433           (cw&0x3f0000)>>5;
 434 }
 435
 436 /**
 437  * \brief converts language bits to charset index
 438  * \param lang language bits
 439  * \return charset index in lang_chars array
 440  */
 441 static int lang2charset (int lang){
 442     int i;
 443     for(i=0;tt_languages[i].lang_code;i++)
 444         if(tt_languages[i].lang_code==lang)
 445             break;
 446
 447     return tt_languages[i].charset;
 448 }
 449
 450 /**
 451  * \brief convert chars from curent teletext codepage into MPlayer charset
 452  * \param p raw teletext char to decode
 453  * \param charset index on lang_chars
 454  * \param lang index in substitution array (latin charset only)
 455  * \return UTF8 char
 456  *
 457  * \remarks
 458  * routine will analyze raw member of given tt_char structure and
 459  * fill unicode member of the same struct with appropriate utf8 code.
 460  */
 461 static unsigned int conv2uni(unsigned int p,int charset,int lang)
 462 {
 463
 464     if(p<0x80 && p>=0x20){
 465         if(charset==LATIN){
 466             lang&=7;
 467             if (p>=0x23 && p<=0x24){
 468                 return latin_subchars[lang][p-0x23];
 469             }else if (p==0x40){
 470                 return latin_subchars[lang][2];
 471             }else if (p>=0x5b && p<=0x60){
 472                 return latin_subchars[lang][p-0x5b+3];
 473             }else if (p>=0x7b && p<=0x7e){
 474                 return latin_subchars[lang][p-0x7b+9];
 475             }
 476         }
 477         return lang_chars[charset][p-0x20];
 478     }else
 479         return 0x20;
 480 }
 481
 482 static void init_vbi_consts(priv_vbi_t* priv){
 483     int i,j;
 484     double ang;
 485     for(i=0; i<256; i++){
 486         j=i&0x7F;
 487         j^= j+j;
 488         j^= j<<2;
 489         j^= j<<4;
 490         fixParity[i]= i ^ (j&0x80) ^ 0x80;
 491     }
 492
 493     for(i=0,ang=0; i<12; i++,ang+=M_PI/priv->bpb){
 494         si[i]= sin(ang);
 495         co[i]= cos(ang);
 496     }
 497
 498     priv->bpb=(priv->ptsp->sampling_rate/6937500.0)*ONE_FIXP+0.5;
 499     priv->soc=FFMAX(9.2e-6*priv->ptsp->sampling_rate-priv->ptsp->offset, 0);
 500     priv->eoc=FFMIN(12.9e-6*priv->ptsp->sampling_rate-priv->ptsp->offset,
 501                     priv->ptsp->samples_per_line-43*8*priv->bpb/ONE_FIXP);
 502     if (priv->eoc - priv->soc<16*priv->bpb/ONE_FIXP){ // invalid [soc:eoc]
 503         priv->soc=0;
 504         priv->eoc=92;
 505     }
 506     priv->bp8bl=0.97*8*priv->bpb/ONE_FIXP; // -3% tolerance
 507     priv->bp8bh=1.03*8*priv->bpb/ONE_FIXP; // +3% tolerance
 508 }
 509 /**
 510  * \brief calculate increased/decreased by given value page number
 511  * \param curr  current page number in hexadecimal for
 512  * \param direction decimal value (can be negative) to add to value
 513  *        of curr parameter
 514  * \return new page number in hexadecimal form
 515  *
 516  * VBI page numbers are represented in special hexadecimal form, e.g.
 517  * page with number 123 (as seen by user) internally has number 0x123.
 518  * and equation 0x123+8 should be equal to 0x131 instead of regular 0x12b.
 519  *
 520  *
 521  * Page numbers 0xYYY (where Y is not belongs to (0..9).
 522  * Page number belongs to [0x000,0x799] or [0x100:0x899] (first 0 can be
 523  * treated as '8')
 524  */
 525 static int steppage(int p, int direction, int skip_hidden)
 526 {
 527     if(skip_hidden)
 528         p=(p&15)+((p>>4)&15)*10+(p>>8)*100;
 529     p+=direction;
 530     if(skip_hidden){
 531         p=(p+800)%800;
 532         p=(p%10)+((p/10)%10)*16+(p/100)*256;
 533     }
 534
 535     return p&0x7ff;
 536 }
 537
 538 /*
 539 ------------------------------------------------------------------
 540    Cache stuff
 541 ------------------------------------------------------------------
 542 */
 543
 544 /**
 545  * \brief add/update entry in cache
 546  * \param priv private data structure
 547  * \param pg page to store in cache
 548  * \param line line to update (value below 0 means update entire page)
 549  */
 550 static void put_to_cache(priv_vbi_t* priv,tt_page* pg,int line){
 551     tt_page* pgc; //page in cache
 552     int i,j,count;
 553
 554     if(line<0){
 555         i=0;
 556         count=VBI_ROWS*VBI_COLUMNS;
 557     }else if(line<VBI_ROWS){
 558         i=line*VBI_COLUMNS;
 559         count=(line+1)*VBI_COLUMNS;
 560     }else
 561         return;
 562
 563     pthread_mutex_lock(&(priv->buffer_mutex));
 564
 565     if(!priv->ptt_cache[pg->pagenum]){
 566         priv->ptt_cache[pg->pagenum]=calloc(1,sizeof(tt_page));
 567         pgc=priv->ptt_cache[pg->pagenum];
 568     }else{
 569         pgc=priv->ptt_cache[pg->pagenum];
 570         while(pgc->next_subpage && pgc->subpagenum!=pg->subpagenum)
 571             pgc=pgc->next_subpage;
 572
 573         if(pgc->subpagenum!=pg->subpagenum){
 574             pgc->next_subpage=calloc(1,sizeof(tt_page));
 575             pgc=pgc->next_subpage;
 576         }
 577     }
 578     pgc->pagenum=pg->pagenum;
 579     pgc->subpagenum=pg->subpagenum;
 580     pgc->primary_lang=pg->primary_lang;
 581     pgc->secondary_lang=pg->secondary_lang;
 582     pgc->flags=pg->flags;
 583     for(j=0;j<6;++j)
 584         pgc->links[j]=pg->links[j];
 585     //instead of copying entire page into cache, copy only undamaged
 586     //symbols into cache
 587     for(;i<count;i++){
 588         if(!(pg->raw[i]&0x80))
 589             pgc->raw[i]=pg->raw[i];
 590         else
 591             mp_msg(MSGT_TELETEXT,MSGL_DBG3,"char error. pg:%x, c[%d]=0x%x\n",
 592                 pg->pagenum,i,pg->raw[i]);
 593     }
 594     pgc->active=1;
 595     pthread_mutex_unlock(&(priv->buffer_mutex));
 596 }
 597
 598 /**
 599  * \brief get any subpage number of given page
 600  * \param priv private data structure
 601  * \param pagenum page number to search subpages in
 602  *
 603  * \return subpage number of first found subpage which belongs to
 604  * given page number
 605  *
 606  * \note page itself is subpage too (and usually has subpage number 0)
 607  */
 608 static inline int get_subpagenum_from_cache(priv_vbi_t* priv, int pagenum){
 609     if (!priv->ptt_cache[pagenum])
 610         return 0x3f7f;
 611     else
 612         return priv->ptt_cache[pagenum]->subpagenum;
 613 }
 614
 615 /**
 616  * \brief get page from cache by it page and subpage number
 617  * \param priv private data structure
 618  * \param pagenum page number
 619  * \param subpagenum subpage number
 620  *
 621  * \return pointer to tt_page structure if requested page is found
 622  * and NULL otherwise
 623  */
 624 static inline tt_page* get_from_cache(priv_vbi_t* priv, int pagenum,int subpagenum){
 625     tt_page* tp=priv->ptt_cache[pagenum];
 626
 627     while(tp && tp->subpagenum!=subpagenum)
 628         tp=tp->next_subpage;
 629     return tp;
 630 }
 631
 632 /**
 633  * \brief clears cache
 634  * \param priv private data structure
 635  *
 636  * Deletes all tt_page structures from cache and frees allocated memory.
 637  * Only zero-filled array of pointers remains in memory
 638  */
 639 static void clear_cache(priv_vbi_t* priv){
 640     int i;
 641     tt_page* tp;
 642
 643     /*
 644       Skip next 5 buffers to avoid mixing teletext pages from different
 645       channels during channel switch
 646     */
 647     priv->cache_reset=5;
 648     for(i=0;i<VBI_MAX_PAGES;i++){
 649         while(priv->ptt_cache[i]){
 650             tp=priv->ptt_cache[i];
 651             priv->ptt_cache[i]=tp->next_subpage;
 652             free(tp);
 653         }
 654     }
 655     priv->initialsubpage=priv->networkid=0;
 656     priv->timeoffset=0;
 657     priv->juliandate=priv->universaltime=0;
 658     memset(priv->networkname,0,21);
 659 }
 660
 661 /**
 662  * \brief cache initialization
 663  * \param priv private data structure
 664  *
 665  * \note Has to be called before any cache operations!
 666  */
 667 static void init_cache(priv_vbi_t* priv){
 668     priv->ptt_cache=calloc(VBI_MAX_PAGES,sizeof(tt_page*));
 669 }
 670
 671 /**
 672  * \brief destroys cache
 673  * \param priv private data structure
 674  *
 675  * Frees all memory allocated for cache (including array of pointers).
 676  * It is safe to call this routine multiple times
 677  */
 678 static void destroy_cache(priv_vbi_t* priv){
 679     if(priv->ptt_cache){
 680         clear_cache(priv);
 681         free(priv->ptt_cache);
 682         priv->ptt_cache=NULL;
 683     }
 684 }
 685
 686 /*
 687 ------------------------------------------------------------------
 688    Decoder stuff
 689 ------------------------------------------------------------------
 690 */
 691 /**
 692  * \brief converts raw teletext page into useful format (1st rendering stage)
 693  * \param pg page to decode
 694  * \param raw raw data to decode page from
 695  * \param primary_lang primary language code
 696  * \param secondary_lang secondary language code
 697 *
 698  * Routine fills tt_char structure of each teletext_page character with proper
 699  * info about foreground and background colors, character
 700  * type (graphics/control/text).
 701  */
 702 static void decode_page(tt_char* p,unsigned char* raw,int primary_lang,int secondary_lang,int flags)
 703 {
 704     int row,col;
 705     int prim_charset=lang2charset(primary_lang);
 706     int sec_charset=lang2charset(secondary_lang);
 707
 708     for(row=0;row<VBI_ROWS;row++)   {
 709         int prim_lang=1;
 710         int gfx=0;
 711         int fg_color=7;
 712         int bg_color=0;
 713         int separated=0;
 714         int conceal=0;
 715         int hold=0;
 716         int flash=0;
 717         int box=0;
 718
 719         tt_char tt_held=tt_space;
 720         for(col=0;col<VBI_COLUMNS;col++){
 721             int i=row*VBI_COLUMNS+col;
 722             int c=raw[i];
 723             p[i].raw=c;
 724             if(c&0x80){ //damaged char
 725                 p[i]=tt_error;
 726                 continue;
 727             }
 728             if((flags&TT_PGFL_SUBTITLE) || (flags&TT_PGFL_NEWFLASH))
 729                 p[i].hidden=!box;
 730             else
 731                 p[i].hidden=0;
 732             p[i].gfx=gfx?(separated?2:1):0;
 733             p[i].lng=prim_lang;
 734             p[i].ctl=(c&0x60)==0?1:0;
 735             p[i].fg=fg_color;
 736             p[i].bg=bg_color;
 737             p[i].flh=flash;
 738
 739             if ((c&0x60)==0){ //control chars
 740                 if(c>=0x08 && c<=0x09){//Flash/Steady
 741                     flash=c==0x08;
 742                     p[i].flh=flash;
 743                     if(c==0x09){
 744                         p[i].fg=fg_color;
 745                         p[i].bg=bg_color;
 746                     }
 747                 }else if(c>=0x0a && c<=0x0b){
 748                     box=c&1;
 749                 }else if(c>=0x0c && c<=0x0f){
 750                 }else if (c<=0x17){ //colors
 751                     fg_color=c&0x0f;
 752                     gfx=c>>4;
 753                     conceal=0;
 754                     if(!gfx) hold=0;
 755                 }else if (c<=0x18){
 756                     conceal=1;
 757                 }else if (c<=0x1a){ //Contiguous/Separated gfx
 758                     separated=!(c&1);
 759                 }else if (c<=0x1b){
 760                     prim_lang=!prim_lang;
 761                 }else if (c<=0x1d){
 762                     bg_color=(c&1)?fg_color:0;
 763                     p[i].bg=bg_color;
 764                 }else{ //Hold/Release Graphics
 765                     hold=!(c&1);
 766                 }
 767                 p[i].ctl=1;
 768                 if(hold || c==0x1f){
 769                     p[i]=tt_held;
 770                     p[i].fg=fg_color;
 771                     p[i].bg=bg_color;
 772                 }else
 773                     p[i].unicode=p[i].gfx?0:' ';
 774                 continue;
 775             }
 776
 777             if(conceal){
 778                 p[i].gfx=0;
 779                 p[i].unicode=' ';
 780             }else if(gfx){
 781                 p[i].unicode=c-0x20;
 782                 if (p[i].unicode>0x3f) p[i].unicode-=0x20;
 783                 tt_held=p[i];
 784             }else{
 785                 if(p[i].lng){
 786                     p[i].unicode=conv2uni(c,prim_charset,primary_lang&7);
 787                 }else{
 788                     p[i].unicode=conv2uni(c,sec_charset,secondary_lang&7);
 789                 }
 790             }
 791             p[i].fg=fg_color;
 792             p[i].bg=bg_color;
 793         }
 794     }
 795 }
 796
 797 /**
 798  * \brief prepares current page for displaying
 799  * \param priv_vbi private data structure
 800  *
 801  * Routine adds some useful info (time and page number of page, grabbed by
 802  * background thread to top line of current page). Displays "No teletext"
 803  * string if no vbi data available.
 804  */
 805 #define PRINT_HEX(dp,i,h) dp[i].unicode=((h)&0xf)>9?'A'+((h)&0xf)-10:'0'+((h)&0xf)
 806 static void prepare_visible_page(priv_vbi_t* priv){
 807     tt_page *pg,*curr_pg;
 808     unsigned char *p;
 809     int i;
 810
 811     pthread_mutex_lock(&(priv->buffer_mutex));
 812     mp_msg(MSGT_TELETEXT,MSGL_DBG3,"dec_teletext: prepare_visible_page pg:0x%x, sub:0x%x\n",
 813         priv->pagenum,priv->subpagenum);
 814     if(priv->subpagenum==0x3f7f) //no page yet
 815         priv->subpagenum=get_subpagenum_from_cache(priv,priv->pagenum);
 816
 817     pg=get_from_cache(priv,priv->pagenum,priv->subpagenum);
 818     mp_dbg(MSGT_TELETEXT,MSGL_DBG3,"dec_teletext: prepare_vibible_page2 pg:0x%x, sub:0x%x\n",
 819         priv->pagenum,priv->subpagenum);
 820
 821     curr_pg=get_from_cache(priv,priv->curr_pagenum,
 822         get_subpagenum_from_cache(priv,priv->curr_pagenum));
 823     if (!pg && !curr_pg){
 824         p=_("No teletext");
 825         for(i=0;i<VBI_COLUMNS && *p;i++){
 826             GET_UTF8(priv->display_page[i].unicode,*p++,break;);
 827         }
 828         for(;i<VBI_ROWS*VBI_COLUMNS;i++)
 829             priv->display_page[i]=tt_space;
 830         pthread_mutex_unlock(&(priv->buffer_mutex));
 831         return;
 832     }
 833
 834     if (!pg || !pg->active){
 835         for(i=0;i<VBI_ROWS*VBI_COLUMNS;i++){
 836             priv->display_page[i]=tt_space;
 837         }
 838     }else{
 839         decode_page(priv->display_page,pg->raw,pg->primary_lang,pg->secondary_lang,pg->flags);
 840         mp_msg(MSGT_TELETEXT,MSGL_DBG3,"page #%x was decoded!\n",pg->pagenum);
 841     }
 842
 843     PRINT_HEX(priv->display_page,0,(priv->curr_pagenum&0x700)?priv->curr_pagenum>>8:8);
 844     PRINT_HEX(priv->display_page,1,priv->curr_pagenum>>4);
 845     PRINT_HEX(priv->display_page,2,priv->curr_pagenum);
 846     priv->display_page[3].unicode=' ';
 847     priv->display_page[4].unicode=' ';
 848     switch(priv->pagenumdec>>12){
 849     case 1:
 850         priv->display_page[5].unicode='_';
 851         priv->display_page[6].unicode='_';
 852         PRINT_HEX(priv->display_page,7,priv->pagenumdec);
 853         break;
 854     case 2:
 855         priv->display_page[5].unicode='_';
 856         PRINT_HEX(priv->display_page,6,priv->pagenumdec>>4);
 857         PRINT_HEX(priv->display_page,7,priv->pagenumdec);
 858     break;
 859     default:
 860         PRINT_HEX(priv->display_page,5,(priv->pagenum&0x700)?priv->pagenum>>8:8);
 861         PRINT_HEX(priv->display_page,6,priv->pagenum>>4);
 862         PRINT_HEX(priv->display_page,7,priv->pagenum);
 863     }
 864     if(priv->subpagenum!=0x3f7f){
 865         priv->display_page[8].unicode='.';
 866         PRINT_HEX(priv->display_page,9,priv->subpagenum>>4);
 867         PRINT_HEX(priv->display_page,10,priv->subpagenum);
 868     }else{
 869         priv->display_page[8].unicode=' ';
 870         priv->display_page[9].unicode=' ';
 871         priv->display_page[10].unicode=' ';
 872     }
 873     priv->display_page[11].unicode=' ';
 874     for(i=VBI_COLUMNS;i>VBI_TIME_LINEPOS ||
 875             ((curr_pg->raw[i]&0x60) && curr_pg->raw[i]!=0x20 && i>11);
 876             --i)
 877         if(curr_pg->raw[i]&0x60)
 878             priv->display_page[i].unicode=curr_pg->raw[i];
 879         else
 880             priv->display_page[i].unicode=' ';
 881     pthread_mutex_unlock(&(priv->buffer_mutex));
 882 }
 883 /*
 884 ------------------------------------------------------------------
 885    Renderer stuff
 886 ------------------------------------------------------------------
 887 */
 888 #ifdef DEBUG_DUMP
 889 /**
 890  * \brief renders teletext page into given file
 891  * \param pt page to render
 892  * \param f opened file descriptor
 893  * \param pagenum which page to render
 894  * \param colored use colors not implemented yet)
 895  *
 896  * Text will be UTF8 encoded
 897  */
 898 static void render2text(tt_page* pt,FILE* f,int colored){
 899     int i,j;
 900     unsigned int u;
 901     unsigned char buf[8];
 902     unsigned char tmp;
 903     int pos;
 904     tt_char dp[VBI_ROWS*VBI_COLUMNS];
 905     int color=0;
 906     int bkg=0;
 907     int c1,b1;
 908     if(!pt)
 909         return;
 910     fprintf(f,"+========================================+\n");
 911     fprintf(f,"| lang:%d pagenum:0x%x subpagenum:%d flags:0x%x|\n",
 912     pt->lang,
 913     pt->pagenum,
 914     pt->subpagenum,
 915     0);
 916     fprintf(f,"+----------------------------------------+\n");
 917
 918     decode_page(dp,pt->raw,pt->primary_lang,pt->secondary_lang,pt->flags);
 919     for(i=0;i<VBI_ROWS;i++){
 920         fprintf(f,"|");
 921         if(colored) fprintf(f,"\033[40m");
 922         for(j=0;j<VBI_COLUMNS;j++)
 923         {
 924              u=dp[i*VBI_COLUMNS+j].unicode;
 925               if(dp[i*VBI_COLUMNS+j].fg <= 7)
 926                 c1=30+dp[i*VBI_COLUMNS+j].fg;
 927               else
 928                 c1=38;
 929               if(dp[i*VBI_COLUMNS+j].bg <= 7)
 930                   b1=40+dp[i*VBI_COLUMNS+j].bg;
 931               else
 932                 b1=40;
 933             if (b1!=bkg  && colored){
 934                 fprintf(f,"\033[%dm",b1);
 935                 bkg=b1;
 936             }
 937             if(c1!=color && colored){
 938                 fprintf(f,"\033[%dm",c1);
 939                 color=c1;
 940             }
 941             if(dp[i*VBI_COLUMNS+j].gfx){
 942                 fprintf(f,"*");
 943             }else{
 944                 pos=0;
 945                 PUT_UTF8(u,tmp,if(pos<7) buf[pos++]=tmp;);
 946                 buf[pos]='\0';
 947                 fprintf(f,"%s",buf);
 948             }
 949         }
 950
 951         if (colored) fprintf(f,"\033[0m");
 952         color=-1;bkg=-1;
 953         fprintf(f,"|\n");
 954     }
 955     //for debug
 956     fprintf(f,"+====================raw=================+\n");
 957     for(i=0;i<VBI_ROWS;i++){
 958         for(j=0;j<VBI_COLUMNS;j++)
 959             fprintf(f,"%02x ",dp[i*VBI_COLUMNS+j].raw);
 960         fprintf(f,"\n");
 961     }
 962     fprintf(f,"+====================lng=================+\n");
 963     for(i=0;i<VBI_ROWS;i++){
 964         for(j=0;j<VBI_COLUMNS;j++)
 965             fprintf(f,"%02x ",dp[i*VBI_COLUMNS+j].lng);
 966         fprintf(f,"\n");
 967     }
 968     fprintf(f,"+========================================+\n");
 969 }
 970
 971 /**
 972  * \brief dump page into pgXXX.txt file in vurrent directory
 973  * \param pt page to dump
 974  *
 975  * \note XXX in filename is page number
 976  * \note use only for debug purposes
 977  */
 978 static void dump_page(tt_page* pt)
 979 {
 980     FILE*f;
 981     char name[100];
 982     snprintf(name,99,"pg%x.txt",pt->pagenum);
 983     f=fopen(name,"wb");
 984     render2text(pt,f,1);
 985     fclose(f);
 986 }
 987 #endif //DEBUG_DUMP
 988
 989
 990 /**
 991  * \brief checks whether page is ready and copies it into cache array if so
 992  * \param priv private data structure
 993  * \param magAddr page's magazine address (0-7)
 994  */
 995 static void store_in_cache(priv_vbi_t* priv, int magAddr, int line){
 996     mp_msg(MSGT_TELETEXT,MSGL_DBG2,"store_in_cache(%d): pagenum:%x\n",
 997         priv->mag[magAddr].order,
 998         priv->mag[magAddr].pt->pagenum);
 999
1000     put_to_cache(priv,priv->mag[magAddr].pt,line);
1001     priv->curr_pagenum=priv->mag[magAddr].pt->pagenum;
1002
1003 #ifdef DEBUG_DUMP
1004     dump_page(get_from_cache(priv,
1005         priv->mag[magAddr].pt->pagenum,
1006         priv->mag[magAddr].pt->subpagenum));
1007 #endif
1008 }
1009
1010
1011 /*
1012 ------------------------------------------------------------------
1013   Grabber stuff
1014 ------------------------------------------------------------------
1015 */
1016 #define PLL_SAMPLES 4
1017 #define PLL_ERROR   4
1018 #define PLL_ADJUST  4
1019
1020 /**
1021  * \brief adjust current phase for better signal decoding
1022  * \param n count of bytes processed (?)
1023  * \param err count of error bytes (?)
1024  *
1025  * \remarks code was got from MythTV project
1026  */
1027 static void pll_add(priv_vbi_t* priv,int n,int err){
1028     if(priv->pll_fixed)
1029         return;
1030     if(err>PLL_ERROR*2/3)
1031         err=PLL_ERROR*2/3;
1032     priv->pll_err+=err;
1033     priv->pll_cnt+=n;
1034     if(priv->pll_cnt<PLL_SAMPLES)
1035         return;
1036     if(priv->pll_err>PLL_ERROR)
1037     {
1038         if(priv->pll_err>priv->pll_lerr)
1039             priv->pll_dir= -priv->pll_dir;
1040         priv->pll_lerr=priv->pll_err;
1041         priv->pll_adj+=priv->pll_dir;
1042         if (priv->pll_adj<-PLL_ADJUST || priv->pll_adj>PLL_ADJUST)
1043         {
1044             priv->pll_adj=0;
1045             priv->pll_dir=-1;
1046             priv->pll_lerr=0;
1047         }
1048         mp_msg(MSGT_TELETEXT,MSGL_DBG3,"vbi: pll_adj=%2d\n",priv->pll_adj);
1049     }
1050     priv->pll_cnt=0;
1051     priv->pll_err=0;
1052 }
1053
1054 /**
1055  * \brief reset error correction
1056  * \param priv private data structure
1057  * \param fine_tune shift value for adjusting
1058  *
1059  * \remarks code was got from MythTV project
1060  */
1061 static void pll_reset(priv_vbi_t* priv,int fine_tune){
1062     priv->pll_fixed=fine_tune >= -PLL_ADJUST && fine_tune <= PLL_ADJUST;
1063
1064     priv->pll_err=0;
1065     priv->pll_lerr=0;
1066     priv->pll_cnt=0;
1067     priv->pll_dir=-1;
1068     priv->pll_adj=0;
1069     if(priv->pll_fixed)
1070         priv->pll_adj=fine_tune;
1071     if(priv->pll_fixed)
1072         mp_msg(MSGT_TELETEXT,MSGL_DBG3,"pll_reset (fixed@%2d)\n",priv->pll_adj);
1073     else
1074         mp_msg(MSGT_TELETEXT,MSGL_DBG3,"pll_reset (auto)\n");
1075
1076 }
1077 /**
1078  * \brief decode packet 0 (teletext page header)
1079  * \param priv private data structure
1080  * \param data raw teletext data (with not applied hamm correction yet)
1081  * \param magAddr teletext page's magazine address
1082  *
1083  * \remarks
1084  * data buffer was shifted by 6 and now contains:
1085  *  0..1 page number
1086  *  2..5 sub-code
1087  *  6..7 control codes
1088  *  8..39 display data
1089  *
1090  *  only first 8 bytes protected by Hamm 8/4 code
1091  */
1092 static int decode_pkt0(priv_vbi_t* priv,unsigned char* data,int magAddr)
1093 {
1094     int d[8];
1095     int i,err;
1096
1097     if (magAddr<0 || magAddr>7)
1098         return 0;
1099     for(i=0;i<8;i++){
1100         d[i]= corrHamm48[ data[i] ];
1101         if(d[i]&0x80){
1102             pll_add(priv,2,4);
1103
1104             if(priv->mag[magAddr].pt)
1105                   free(priv->mag[magAddr].pt);
1106             priv->mag[magAddr].pt=NULL;
1107             priv->mag[magAddr].order=0;
1108             return 0;
1109         }
1110     }
1111     if (!priv->mag[magAddr].pt)
1112         priv->mag[magAddr].pt= malloc(sizeof(tt_page));
1113
1114     if(priv->primary_language)
1115         priv->mag[magAddr].pt->primary_lang=priv->primary_language;
1116     else
1117         priv->mag[magAddr].pt->primary_lang= (d[7]>>1)&7;
1118     priv->mag[magAddr].pt->secondary_lang=priv->secondary_language;
1119     priv->mag[magAddr].pt->subpagenum=(d[2]|(d[3]<<4)|(d[4]<<8)|(d[5]<<12))&0x3f7f;
1120     priv->mag[magAddr].pt->pagenum=(magAddr<<8) | d[0] | (d[1]<<4);
1121     priv->mag[magAddr].pt->flags=((d[7]&1)<<7) | ((d[3]&8)<<3) | ((d[5]&12)<<2) | d[6];
1122
1123     memset(priv->mag[magAddr].pt->raw, 0x00, VBI_COLUMNS*VBI_ROWS);
1124     priv->mag[magAddr].order=0;
1125
1126     for(i=0;i<8;i++){
1127         priv->mag[magAddr].pt->raw[i]=0x20;
1128     }
1129     err=0;
1130     for(i=8; i<VBI_COLUMNS; i++){
1131         data[i]= fixParity[data[i]];
1132         priv->mag[magAddr].pt->raw[i]=data[i];
1133         if(data[i]&0x80) //Error
1134             err++;
1135         pll_add(priv,1,err);
1136     }
1137
1138     store_in_cache(priv,magAddr,0);
1139
1140     return 1;
1141 }
1142
1143 /**
1144  * \brief decode teletext 8/30 Format 1 packet
1145  * \param priv private data structure
1146  * \param data raw teletext data (with not applied hamm correction yet)
1147  * \param magAddr teletext page's magazine address
1148  *
1149  * \remarks
1150  * packet contains:
1151  * 0      designation code
1152  * 1..2   initial page
1153  * 3..6   initial subpage & magazine address
1154  * 7..8   network id
1155  * 9      time offset
1156  * 10..12 julian date
1157  * 13..15 universal time
1158  * 20..40 network name
1159  *
1160  * First 7 bytes are protected by Hamm 8/4 code.
1161  * Bytes 20-40 has odd parity check.
1162  *
1163  * See subcaluse 9.8.1 of specification for details
1164  */
1165 static int decode_pkt30(priv_vbi_t* priv,unsigned char* data,int magAddr)
1166 {
1167     int d[8];
1168     int i,err;
1169
1170     for(i=0;i<7;i++){
1171         d[i]= corrHamm48[ data[i] ];
1172         if(d[i]&0x80){
1173             pll_add(priv,2,4);
1174             return 0;
1175         }
1176         d[i]&=0xf;
1177     }
1178
1179     err=0;
1180     for(i=20; i<40; i++){
1181         data[i]= fixParity[data[i]];
1182         if(data[i]&0x80)//Unrecoverable error
1183             err++;
1184         pll_add(priv,1,err);
1185     }
1186     if (err) return 0;
1187
1188     if (d[0]&0xe) //This is not 8/30 Format 1 packet
1189         return 1;
1190
1191     priv->initialpage=d[1] | d[2]<<4 | (d[6]&0xc)<<7 | (d[4]&1)<<8;
1192     priv->initialsubpage=d[3] | d[4]<<4 | d[5]<<8 | d[6]<<12;
1193     priv->networkid=data[7]<<8 | data[8];
1194
1195     priv->timeoffset=(data[9]>>1)&0xf;
1196     if(data[9]&0x40)
1197         priv->timeoffset=-priv->timeoffset;
1198
1199     priv->juliandate=(data[10]&0xf)<<16 | data[11]<<8 | data[12];
1200     priv->juliandate-=0x11111;
1201
1202     priv->universaltime=data[13]<<16 | data[14]<<8 | data[15];
1203     priv->universaltime-=0x111111;
1204
1205     snprintf(priv->networkname,21,"%s",data+20);
1206
1207     return 1;
1208 }
1209
1210 /**
1211  * \brief decode packets 1..24 (teletext page header)
1212  * \param priv private data structure
1213  * \param data raw teletext data
1214  * \param magAddr teletext page's magazine address
1215  * \param rowAddr teletext page's row number
1216  *
1217  * \remarks
1218  * data buffer was shifted by 6 and now contains 40 bytes of display data:
1219  * this type of packet is not proptected by Hamm 8/4 code
1220  */
1221 static void decode_pkt_page(priv_vbi_t* priv,unsigned char*data,int magAddr,int rowAddr){
1222     int i,err;
1223     if (!priv->mag[magAddr].pt)
1224         return;
1225
1226     priv->mag[magAddr].order=rowAddr;
1227
1228     err=0;
1229     for(i=0; i<VBI_COLUMNS; i++){
1230         data[i]= fixParity[ data[i] ];
1231         priv->mag[magAddr].pt->raw[i+rowAddr*VBI_COLUMNS]=data[i];
1232         if( data[i]&0x80) //HammError
1233             err++;
1234     }
1235     pll_add(priv,1,err);
1236
1237     store_in_cache(priv,magAddr,rowAddr);
1238 }
1239
1240 /**
1241  * \brief decode packets 27 (teletext links)
1242  * \param priv private data structure
1243  * \param data raw teletext data
1244  * \param magAddr teletext page's magazine address
1245  */
1246 static int decode_pkt27(priv_vbi_t* priv,unsigned char* data,int magAddr){
1247     int i,hpg;
1248
1249     if (!priv->mag[magAddr].pt)
1250         return 0;
1251     for(i=0;i<38;++i)
1252         if ((data[i] = corrHamm48[ data[i] ]) & 0x80){
1253             pll_add(priv,2,4);
1254             return 0;
1255         }
1256
1257     /*
1258       Not a X/27/0 Format 1 packet or
1259       flag "show links on row 24" is not set.
1260     */
1261     if (data[0] || !(data[37] & 8))
1262         return 1;
1263     for(i=0;i<6;++i) {
1264         hpg = (magAddr<<8) ^ ((data[4+i*6]&0x8)<<5 | (data[6+i*6]&0xc)<<7);
1265         if (!hpg) hpg=0x800;
1266         priv->mag[magAddr].pt->links[i].pagenum = (data[1+i*6] & 0xf) |
1267                 ((data[2+i*6] & 0xf) << 4) | hpg;
1268         priv->mag[magAddr].pt->links[i].subpagenum = ((data[3+i*6] & 0xf) |
1269                 (data[4+i*6] & 0xf) << 4 | (data[5+i*6] & 0xf) << 8 |
1270                 (data[6+i*6] & 0xf) << 12) & 0x3f7f;
1271     }
1272     put_to_cache(priv,priv->mag[magAddr].pt,-1);
1273     return 1;
1274 }
1275
1276 /**
1277  * \brief Decode teletext X/28/0 Format 1 packet
1278  * \param priv private data structure
1279  * \param data raw teletext data
1280  *
1281  * Primary G0 charset is transmitted in bits 14-8 of Triplet 1
1282  * See Table 32 of specification for details.
1283  *
1284  * Secondary G0 charset is transmitted in bits 3-1 of Triplet 2 and
1285  * bits 18-15 of Triplet 1
1286  * See Table 33 of specification for details.
1287  *
1288  */
1289 static void decode_pkt28(priv_vbi_t* priv,unsigned char*data){
1290     int d;
1291     int t1,t2;
1292     d=corrHamm48[ data[0] ];
1293     if(d) return; //this is not X/28/0 Format 1 packet or error occured
1294
1295     t1=corrHamm24(data+1);
1296     t2=corrHamm24(data+4);
1297     if (t1<0 || t2<0){
1298         pll_add(priv,1,4);
1299         return;
1300     }
1301
1302     priv->primary_language=(t1>>7)&0x7f;
1303     priv->secondary_language=((t2<<4) | (t1>>14))&0x7f;
1304     if (priv->secondary_language==0x7f)
1305         //No secondary language required
1306         priv->secondary_language=priv->primary_language;
1307     else // Swapping bits 1 and 3
1308         priv->secondary_language=(priv->secondary_language&0x7a) |
1309                                 (priv->secondary_language&4)>>2 |
1310                                 (priv->secondary_language&1)<<2;
1311
1312     mp_msg(MSGT_TELETEXT,MSGL_DBG2,"pkt28: language: primary=%02x secondary=0x%02x\n",
1313         priv->primary_language,priv->secondary_language);
1314 }
1315
1316 /**
1317  * \brief decodes raw vbi data (signal amplitudes) into sequence of bytes
1318  * \param priv private data structure
1319  * \param buf raw vbi data (one line of frame)
1320  * \param data output buffer for decoded bytes (at least 45 bytes long)
1321  *
1322  * Used XawTV's algorithm. Signal phase is calculated with help of starting clock
1323  * run-in sequence (min/max values and bit distance values are calculated)
1324  */
1325 static int decode_raw_line_runin(priv_vbi_t* priv,unsigned char* buf,unsigned char* data){
1326     const int magic= 0x27; // reversed 1110010
1327     int dt[256],hi[6],lo[6];
1328     int i,x,r;
1329     int decoded;
1330     int sync;
1331     unsigned char min,max;
1332     int thr=0; //threshold
1333
1334     //stubs
1335     int soc=priv->soc;
1336     int eoc=priv->eoc;
1337
1338     for(i=soc;i<eoc;i++)
1339         dt[i]=buf[i+priv->bpb/ONE_FIXP]-buf[i];    // amplifies the edges best.
1340     /* set barrier */
1341     for (i=eoc; i<eoc+16; i+=2)
1342         dt[i]=100, dt[i+1]=-100;
1343
1344     /* find 6 rising and falling edges */
1345     for (i=soc, x=0; x<6; ++x)
1346     {
1347         while (dt[i]<32)
1348             i++;
1349         hi[x]=i;
1350         while (dt[i]>-32)
1351             i++;
1352         lo[x]=i;
1353     }
1354     if (i>=eoc)
1355     {
1356         return 0;      // not enough periods found
1357     }
1358     i=hi[5]-hi[1]; // length of 4 periods (8 bits)
1359     if (i<priv->bp8bl || i>priv->bp8bh)
1360     {
1361         mp_msg(MSGT_TELETEXT,MSGL_DBG3,"vbi: wrong freq %d (%d,%d)\n",
1362             i,priv->bp8bl,priv->bp8bh);
1363         return 0;      // bad frequency
1364     }
1365     /* AGC and sync-reference */
1366     min=255, max=0, sync=0;
1367     for (i=hi[4]; i<hi[5]; ++i)
1368         if (buf[i]>max)
1369             max=buf[i], sync=i;
1370     for (i=lo[4]; i<lo[5]; ++i)
1371         if (buf[i]<min)
1372             min=buf[i];
1373     thr=(min+max)/2;
1374
1375     buf+=sync;
1376     // searching for '11'
1377     for(i=priv->pll_adj*priv->bpb/10;i<16*priv->bpb;i+=priv->bpb)
1378         if(buf[FIXP2INT(i)]>thr && buf[FIXP2INT(i+priv->bpb)]>thr)
1379             break;
1380     r=0;
1381     for(decoded=1; decoded<= (VBI_COLUMNS+3)<<3;decoded++){
1382         r>>=1;
1383         if(buf[FIXP2INT(i)]>thr) r|=0x80;
1384         if(!(decoded & 0x07)){
1385             data[(decoded>>3) - 1]=r;
1386             r=0;
1387         }
1388         i+=priv->bpb;
1389     }
1390     if(data[0]!=magic)
1391         return 0; //magic not found
1392
1393     //stub
1394     for(i=0;i<43;i++){
1395         data[i]=data[i+1];
1396     }
1397     mp_msg(MSGT_TELETEXT,MSGL_DBG3,"thr:%d sync:%d ",thr,sync);
1398
1399     return 1;
1400 }
1401
1402 #if 0
1403 //See comment in vbi_decode for a reason of commenting out this routine.
1404
1405 /**
1406  * \brief decodes raw vbi data (signal amplitudes) into sequence of bytes
1407  * \param priv private data structure
1408  * \param buf raw vbi data (one line of frame)
1409  * \param data output buffer for decoded bytes (at least 45 bytes long)
1410  *
1411  * Used Michael Niedermayer's algorithm.
1412  * Signal phase is calculated using correlation between given samples data and
1413  * pure sine
1414  */
1415 static int decode_raw_line_sine(priv_vbi_t* priv,unsigned char* buf,unsigned char* data){
1416     int i,x,r,amp,xFixp;
1417     int avg=0;
1418     double sin_sum=0, cos_sum=0;
1419
1420     for(x=0; x< FIXP2INT(10*priv->bpb); x++)
1421       avg+=buf[x];
1422
1423     avg/=FIXP2INT(10*priv->bpb);
1424
1425     for(x=0; x<12; x++){
1426       amp= buf[x<<1];
1427       sin_sum+= si[x]*(amp-avg);
1428       cos_sum+= co[x]*(amp-avg);
1429     }
1430     //this is always zero. Why ?
1431     xFixp= atan(sin_sum/cos_sum)*priv->bpb/M_PI;
1432
1433     //Without this line the result is full of errors
1434     //and routine is unable to find magic sequence
1435     buf+=FIXP2INT(10*priv->bpb);
1436
1437     r=0;
1438     for(x=FIXP2INT(xFixp);x<70;x=FIXP2INT(xFixp)){
1439       r=(r<<1) & 0xFFFF;
1440       if(buf[x]>avg) r|=1;
1441       xFixp+=priv->bpb;
1442       if(r==0xAAE4) break;
1443     }
1444
1445     //this is not teletext
1446     if (r!=0xaae4) return 0;
1447
1448     //Decode remaining 45-2(clock run-in)-1(framing code)=42 bytes
1449     for(i=1; i<=(42<<3); i++){
1450       r>>=1;
1451       x=FIXP2INT(xFixp);
1452       if(buf[x]> avg)
1453           r|=0x80;
1454
1455       if(!(i & 0x07)){
1456           data[(i>>3)-1]=r;
1457           r=0;
1458       }
1459       xFixp+=priv->bpb;
1460     }
1461
1462     return 1;
1463 }
1464 #endif
1465
1466 /**
1467  * \brief decodes one vbi line from one video frame
1468  * \param priv private data structure
1469  * \param data buffer with raw vbi data in it
1470  */
1471 static void vbi_decode_line(priv_vbi_t *priv, unsigned char *data) {
1472     int d0,d1,magAddr,pkt;
1473
1474     d0= corrHamm48[ data[0] ];
1475     d1= corrHamm48[ data[1] ];
1476
1477     if(d0&0x80 || d1&0x80){
1478         pll_add(priv,2,4);
1479         mp_msg(MSGT_TELETEXT,MSGL_V,"vbi_decode_line: HammErr\n");
1480
1481         return; //hamError
1482     }
1483     magAddr=d0 & 0x7;
1484     pkt=(d0>>3)|(d1<<1);
1485     mp_msg(MSGT_TELETEXT,MSGL_DBG3,"vbi_decode_line:%x %x (mag:%x, pkt:%d)\n",
1486             d0,d1,magAddr,pkt);
1487     if(!pkt){
1488         decode_pkt0(priv,data+2,magAddr); //skip MRGA
1489     }else if(pkt>0 && pkt<VBI_ROWS){
1490         if(!priv->mag[magAddr].pt)
1491             return;
1492         decode_pkt_page(priv,data+2,magAddr,pkt);//skip MRGA
1493     }else if(pkt==27) {
1494         decode_pkt27(priv,data+2,magAddr);
1495     }else if(pkt==28){
1496         decode_pkt28(priv,data+2);
1497     }else if(pkt==30){
1498         decode_pkt30(priv,data+2,magAddr);
1499     } else {
1500         mp_msg(MSGT_TELETEXT,MSGL_DBG3,"unsupported packet:%d\n",pkt);
1501     }
1502 }
1503
1504 /**
1505  * \brief decodes all vbi lines from one video frame
1506  * \param priv private data structure
1507  * \param buf buffer with raw vbi data in it
1508  *
1509  * \note buffer size have to be at least priv->ptsp->bufsize bytes
1510  */
1511 static void vbi_decode(priv_vbi_t* priv,unsigned char*buf){
1512     unsigned char data[64];
1513     unsigned char* linep;
1514     int i=0;
1515     mp_msg(MSGT_TELETEXT,MSGL_DBG3,"vbi: vbi_decode\n");
1516     for(linep=buf; !priv->cache_reset && linep<buf+priv->ptsp->bufsize; linep+=priv->ptsp->samples_per_line,i++){
1517 #if 0
1518         /*
1519           This routine is alternative implementation of raw VBI data decoding.
1520           Unfortunately, it detects only about 20% of incoming data,
1521           but Michael says that this algorithm is better, and he wants to fix it.
1522         */
1523         if(decode_raw_line_sine(priv,linep,data)<=0){
1524 #endif
1525         if(decode_raw_line_runin(priv,linep,data)<=0){
1526              continue; //this is not valid teletext line
1527         }
1528         vbi_decode_line(priv, data);
1529     }
1530     if (priv->cache_reset){
1531         pthread_mutex_lock(&(priv->buffer_mutex));
1532         priv->cache_reset--;
1533         pthread_mutex_unlock(&(priv->buffer_mutex));
1534     }
1535
1536 }
1537
1538 /**
1539  * \brief decodes a vbi line from a DVB teletext stream
1540  * \param priv private data structure
1541  * \param buf buffer with DVB teletext data
1542  *
1543  * No locking is done since this is only called from a single-threaded context
1544  */
1545 static void vbi_decode_dvb(priv_vbi_t *priv, const uint8_t buf[44]){
1546     int i;
1547     uint8_t data[42];
1548
1549     mp_msg(MSGT_TELETEXT,MSGL_DBG3, "vbi: vbi_decode_dvb\n");
1550
1551     /* Reverse bit order, skipping the first two bytes (field parity, line
1552        offset and framing code). */
1553     for (i = 0; i < sizeof(data); i++)
1554         data[i] = av_reverse[buf[2 + i]];
1555
1556     vbi_decode_line(priv, data);
1557     if (priv->cache_reset)
1558         priv->cache_reset--;
1559 }
1560
1561 /*
1562 ---------------------------------------------------------------------------------
1563     Public routines
1564 ---------------------------------------------------------------------------------
1565 */
1566
1567 /**
1568  * \brief toggles teletext page displaying format
1569  * \param priv_vbi private data structure
1570  * \param flag new format
1571  * \return
1572  *   VBI_CONTROL_TRUE is success,
1573  *   VBI_CONTROL_FALSE otherwise
1574  *
1575  * flag:
1576  * 0 - opaque
1577  * 1 - transparent
1578  * 2 - opaque  with black foreground color (only in bw mode)
1579  * 3 - transparent  with black foreground color (only in bw mode)
1580  */
1581 static int teletext_set_format(priv_vbi_t * priv, teletext_format flag)
1582 {
1583     flag&=3;
1584
1585     mp_msg(MSGT_TELETEXT,MSGL_DBG3,"teletext_set_format_is called. mode:%d\n",flag);
1586     pthread_mutex_lock(&(priv->buffer_mutex));
1587
1588     priv->tformat=flag;
1589
1590     priv->pagenumdec=0;
1591
1592     pthread_mutex_unlock(&(priv->buffer_mutex));
1593     return VBI_CONTROL_TRUE;
1594 }
1595
1596 /**
1597  * \brief append just entered digit to editing page number
1598  * \param priv_vbi private data structure
1599  * \param dec decimal digit to append
1600  *
1601  *  dec:
1602  *   '0'..'9' append digit
1603  *    '-' remove last digit (backspace emulation)
1604  *
1605  * This routine allows user to jump to arbitrary page.
1606  * It implements simple page number editing algorithm.
1607  *
1608  * Subsystem can be on one of two modes: normal and page number edit mode.
1609  * Zero value of priv->pagenumdec means normal mode
1610  * Non-zero value means page number edit mode and equals to packed
1611  * decimal number of already entered part of page number.
1612  *
1613  * How this works.
1614  * Let's assume that current mode is normal (pagenumdec is zero), teletext page
1615  * 100 are displayed as usual. topmost left corner of page contains page number.
1616  * Then vbi_add_dec is sequentially called (through slave
1617  * command of course) with 1,4,-,2,3 * values of dec parameter.
1618  *
1619  * +-----+------------+------------------+
1620  * | dec | pagenumdec | displayed number |
1621  * +-----+------------+------------------+
1622  * |     | 0x000      | 100              |
1623  * +-----+------------+------------------+
1624  * | 1   | 0x001      | __1              |
1625  * +-----+------------+------------------+
1626  * | 4   | 0x014      | _14              |
1627  * +-----+------------+------------------+
1628  * | -   | 0x001      | __1              |
1629  * +-----+------------+------------------+
1630  * | 2   | 0x012      | _12              |
1631  * +-----+------------+------------------+
1632  * | 3   | 0x123      | 123              |
1633  * +-----+------------+------------------+
1634  * |     | 0x000      | 123              |
1635  * +-----+------------+------------------+
1636  *
1637  * pagenumdec will automatically receive zero value after third digit of page
1638  * number is entered and current page will be switched to another one with
1639  * entered page number.
1640  */
1641 static void vbi_add_dec(priv_vbi_t * priv, char *dec)
1642 {
1643     int count, shift;
1644     if (!dec)
1645         return;
1646     if (!priv->on)
1647         return;
1648     if ((*dec<'0' || *dec>'9') && *dec!='-')
1649         return;
1650     if (!priv->pagenumdec) //first digit cannot be '0','9' or '-'
1651         if(*dec=='-' || *dec=='0' || *dec=='9')
1652             return;
1653     pthread_mutex_lock(&(priv->buffer_mutex));
1654     count=(priv->pagenumdec>>12)&0xf;
1655     if (*dec=='-') {
1656         count--;
1657         if (count)
1658             priv->pagenumdec=((priv->pagenumdec>>4)&0xfff)|(count<<12);
1659         else
1660             priv->pagenumdec=0;
1661     } else {
1662         shift = count * 4;
1663         count++;
1664         priv->pagenumdec=
1665             (((priv->pagenumdec)<<4|(*dec-'0'))&0xfff)|(count<<12);
1666         if (count==3) {
1667             priv->pagenum=priv->pagenumdec&0x7ff;
1668             priv->subpagenum=get_subpagenum_from_cache(priv,priv->pagenum);
1669             priv->pagenumdec=0;
1670         }
1671     }
1672     pthread_mutex_unlock(&(priv->buffer_mutex));
1673 }
1674
1675
1676 /**
1677  * \brief Teletext control routine
1678  * \param priv_vbi private data structure
1679  * \param cmd command
1680  * \param arg command parameter (has to be not null)
1681  */
1682 int teletext_control(void* p, int cmd, void *arg)
1683 {
1684     int fine_tune=99;
1685     priv_vbi_t* priv=(priv_vbi_t*)p;
1686     tt_page* pgc;
1687
1688     if (!priv && cmd!=TV_VBI_CONTROL_START)
1689         return VBI_CONTROL_FALSE;
1690     if (!arg && cmd!=TV_VBI_CONTROL_STOP && cmd!=TV_VBI_CONTROL_MARK_UNCHANGED)
1691         return VBI_CONTROL_FALSE;
1692
1693     switch (cmd) {
1694     case TV_VBI_CONTROL_RESET:
1695     {
1696         int i;
1697         struct tt_param* tt_param=arg;
1698         pthread_mutex_lock(&(priv->buffer_mutex));
1699         priv->pagenumdec=0;
1700         clear_cache(priv);
1701         priv->pagenum=steppage(0,tt_param->page&0x7ff,1);
1702         priv->tformat=tt_param->format;
1703         priv->subpagenum=0x3f7f;
1704         pll_reset(priv,fine_tune);
1705         if(tt_param->lang==-1){
1706             mp_tmsg(MSGT_TELETEXT,MSGL_INFO,"Supported Teletext languages:\n");
1707             for(i=0; tt_languages[i].lang_code; i++){
1708                 mp_msg(MSGT_TELETEXT,MSGL_INFO,"  %3d  %s\n",
1709                     tt_languages[i].lang_code, tt_languages[i].lang_name);
1710             }
1711             mp_msg(MSGT_TELETEXT,MSGL_INFO,"  %3d  %s\n",
1712                 tt_languages[i].lang_code, tt_languages[i].lang_name);
1713         }else{
1714             for(i=0; tt_languages[i].lang_code; i++){
1715                 if(tt_languages[i].lang_code==tt_param->lang)
1716                     break;
1717             }
1718             if (priv->primary_language!=tt_languages[i].lang_code){
1719                 mp_tmsg(MSGT_TELETEXT,MSGL_INFO,"Selected default teletext language: %s\n",
1720                     tt_languages[i].lang_name);
1721                 priv->primary_language=tt_languages[i].lang_code;
1722             }
1723         }
1724         priv->page_changed=1;
1725         pthread_mutex_unlock(&(priv->buffer_mutex));
1726         return VBI_CONTROL_TRUE;
1727     }
1728     case TV_VBI_CONTROL_START:
1729     {
1730         int i;
1731         tt_stream_props* ptsp=*(tt_stream_props**)arg;
1732
1733         if(!ptsp)
1734             return VBI_CONTROL_FALSE;
1735
1736         priv=calloc(1,sizeof(priv_vbi_t));
1737
1738         priv->ptsp=malloc(sizeof(tt_stream_props));
1739         memcpy(priv->ptsp,ptsp,sizeof(tt_stream_props));
1740         *(priv_vbi_t**)arg=priv;
1741
1742         priv->subpagenum=0x3f7f;
1743         pthread_mutex_init(&priv->buffer_mutex, NULL);
1744         priv->pagenumdec=0;
1745         for(i=0;i<VBI_ROWS*VBI_COLUMNS;i++)
1746             priv->display_page[i]=tt_space;
1747
1748         priv->mag=calloc(8,sizeof(mag_t));
1749         init_cache(priv);
1750         init_vbi_consts(priv);
1751         pll_reset(priv,fine_tune);
1752         priv->page_changed=1;
1753         return VBI_CONTROL_TRUE;
1754     }
1755     case TV_VBI_CONTROL_STOP:
1756     {
1757         if(priv->mag)
1758             free(priv->mag);
1759         if(priv->ptsp)
1760             free(priv->ptsp);
1761         destroy_cache(priv);
1762         priv->page_changed=1;
1763         pthread_mutex_destroy(&priv->buffer_mutex);
1764         free(priv);
1765         return VBI_CONTROL_TRUE;
1766     }
1767     case TV_VBI_CONTROL_SET_MODE:
1768         priv->on=(*(int*)arg%2);
1769         priv->page_changed=1;
1770         return VBI_CONTROL_TRUE;
1771     case TV_VBI_CONTROL_GET_MODE:
1772         *(int*)arg=priv->on;
1773         return VBI_CONTROL_TRUE;
1774     case TV_VBI_CONTROL_SET_FORMAT:
1775         priv->page_changed=1;
1776         return teletext_set_format(priv, *(int *) arg);
1777     case TV_VBI_CONTROL_GET_FORMAT:
1778         pthread_mutex_lock(&(priv->buffer_mutex));
1779         *(int*)arg=priv->tformat;
1780         pthread_mutex_unlock(&(priv->buffer_mutex));
1781         return VBI_CONTROL_TRUE;
1782     case TV_VBI_CONTROL_GET_HALF_PAGE:
1783         if(!priv->on)
1784             return VBI_CONTROL_FALSE;
1785         *(int *)arg=priv->zoom;
1786         return VBI_CONTROL_TRUE;
1787     case TV_VBI_CONTROL_SET_HALF_PAGE:
1788     {
1789         int val=*(int*)arg;
1790         val%=3;
1791         if(val<0)
1792             val+=3;
1793         pthread_mutex_lock(&(priv->buffer_mutex));
1794         priv->zoom=val;
1795         priv->page_changed=1;
1796         pthread_mutex_unlock(&(priv->buffer_mutex));
1797         return VBI_CONTROL_TRUE;
1798     }
1799     case TV_VBI_CONTROL_GO_LINK:
1800     {
1801         int val=*(int *) arg;
1802         if(val<1 || val>6)
1803             return VBI_CONTROL_FALSE;
1804         pthread_mutex_lock(&(priv->buffer_mutex));
1805         if (!(pgc = priv->ptt_cache[priv->pagenum])) {
1806             pthread_mutex_unlock(&(priv->buffer_mutex));
1807             return VBI_CONTROL_FALSE;
1808         }
1809         if (!pgc->links[val-1].pagenum || pgc->links[val-1].pagenum>0x7ff) {
1810             pthread_mutex_unlock(&(priv->buffer_mutex));
1811             return VBI_CONTROL_FALSE;
1812         }
1813         priv->pagenum=pgc->links[val-1].pagenum;
1814         if(pgc->links[val-1].subpagenum!=0x3f7f)
1815             priv->subpagenum=pgc->links[val-1].subpagenum;
1816         else
1817             priv->subpagenum=get_subpagenum_from_cache(priv,priv->pagenum);
1818         priv->page_changed=1;
1819         pthread_mutex_unlock(&(priv->buffer_mutex));
1820         return VBI_CONTROL_TRUE;
1821     }
1822     case TV_VBI_CONTROL_SET_PAGE:
1823     {
1824         int val=*(int *) arg;
1825         if(val<100 || val>0x899)
1826             return VBI_CONTROL_FALSE;
1827         pthread_mutex_lock(&(priv->buffer_mutex));
1828         priv->pagenum=val&0x7ff;
1829         priv->subpagenum=get_subpagenum_from_cache(priv,priv->pagenum);
1830         priv->pagenumdec=0;
1831         priv->page_changed=1;
1832         pthread_mutex_unlock(&(priv->buffer_mutex));
1833         return VBI_CONTROL_TRUE;
1834     }
1835     case TV_VBI_CONTROL_STEP_PAGE:
1836     {
1837         int direction=*(int *) arg;
1838         pthread_mutex_lock(&(priv->buffer_mutex));
1839         priv->pagenum=steppage(priv->pagenum, direction,1);
1840         priv->subpagenum=get_subpagenum_from_cache(priv,priv->pagenum);
1841         priv->pagenumdec=0;
1842         priv->page_changed=1;
1843         pthread_mutex_unlock(&(priv->buffer_mutex));
1844         return VBI_CONTROL_TRUE;
1845     }
1846     case TV_VBI_CONTROL_GET_PAGE:
1847         *(int*)arg=((priv->pagenum+0x700)&0x7ff)+0x100;
1848         return VBI_CONTROL_TRUE;
1849     case TV_VBI_CONTROL_SET_SUBPAGE:
1850         pthread_mutex_lock(&(priv->buffer_mutex));
1851         priv->pagenumdec=0;
1852         priv->subpagenum=*(int*)arg;
1853         if(priv->subpagenum<0)
1854             priv->subpagenum=0x3f7f;
1855         if(priv->subpagenum>=VBI_MAX_SUBPAGES)
1856             priv->subpagenum=VBI_MAX_SUBPAGES-1;
1857         priv->page_changed=1;
1858         pthread_mutex_unlock(&(priv->buffer_mutex));
1859         return VBI_CONTROL_TRUE;
1860     case TV_VBI_CONTROL_GET_SUBPAGE:
1861         *(int*)arg=priv->subpagenum;
1862         return VBI_CONTROL_TRUE;
1863     case TV_VBI_CONTROL_ADD_DEC:
1864         vbi_add_dec(priv, *(char **) arg);
1865         priv->page_changed=1;
1866         return VBI_CONTROL_TRUE;
1867     case TV_VBI_CONTROL_DECODE_PAGE:
1868         vbi_decode(priv,*(unsigned char**)arg);
1869         return VBI_CONTROL_TRUE;
1870     case TV_VBI_CONTROL_DECODE_DVB:
1871         vbi_decode_dvb(priv, arg);
1872         return VBI_CONTROL_TRUE;
1873     case TV_VBI_CONTROL_GET_VBIPAGE:
1874         if(!priv->on)
1875             return VBI_CONTROL_FALSE;
1876         prepare_visible_page(priv);
1877         *(void **)arg=priv->display_page;
1878         return VBI_CONTROL_TRUE;
1879     case TV_VBI_CONTROL_GET_NETWORKNAME:
1880         *(void **)arg=priv->networkname;
1881         return VBI_CONTROL_TRUE;
1882     case TV_VBI_CONTROL_MARK_UNCHANGED:
1883         priv->page_changed=0;
1884         priv->last_rendered=GetTimerMS();
1885         return VBI_CONTROL_TRUE;
1886     case TV_VBI_CONTROL_IS_CHANGED:
1887         if(GetTimerMS()-priv->last_rendered> 250)  //forcing page update every 1/4 sec
1888             priv->page_changed=3; //mark that header update is enough
1889         *(int*)arg=priv->page_changed;
1890         return VBI_CONTROL_TRUE;
1891     }
1892     return VBI_CONTROL_UNKNOWN;
1893 }