Teletext support.

Part 1/5: core stuff



git-svn-id: svn://svn.mplayerhq.hu/mplayer/trunk@23919 b3059339-0415-0410-9bf9-f77b7e298cf2

1 files changed, 1365 insertions, 0 deletions

diff --git a/stream/tvi_vbi.c b/stream/tvi_vbi.c
new file mode 100644
index 0000000000..3491426a1f
--- /dev/null
+++ b/stream/tvi_vbi.c
@@ -0,0 +1,1365 @@
+/*
+ * Teletext support
+ * Copyright (C) 2007 Vladimir Voroshilov <voroshil@gmail.com>
+ *
+ * This file is part of MPlayer.
+ *
+ * MPlayer is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * MPlayer is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with MPlayer; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ *
+ *
+ * Based on Attila Otvos' teletext patch, Michael Niedermayer's
+ * proof-of-concept teletext capture utility and some parts
+ * (decode_raw_line_runin,pll_add,pll_reset) of MythTV project.
+ *
+ *
+ * Some implementation details:
+ * How to port teletext to another tvi_* driver (see tvi_v4l2.c for example):
+ *
+ * 1. Implement TVI_CONTROL_VBI_INIT (initialize driver-related vbi subsystem,
+ *    start grabbing thread)
+ *    input data: vbi device name.
+ *    (driver should also call TV_VBI_CONTROL_START for common vbi subsystem initialization
+ *    with pointer to initialized tt_stream_properties structure.
+ *    After ioctl call variable will contain pointer to initialized priv_vbi_t structure.
+ *
+ * 2. After receiving next chunk of raw vbi data call TV_VBI_CONTROL_DECODE_PAGE
+ *    ioctl with pointer to data buffer
+ * 3. pass all other VBI related ioctl cmds to teletext_control routine
+ *
+ * Page displaying process consist of following stages:
+ *
+ * ---grabbing stage---
+ * 0. stream/tvi_*.c: vbi_grabber(...)
+ *      getting vbi data from video device
+ * ---decoding stage---
+ * 1. stream/tvi_vbi.c: decode_raw_line_runin(...) or decode_raw_line_sine(...)
+ *      decode raw vbi data into sliced 45(?) bytes long packets
+ * 2. stream/tvi_vbi.c: decode_pkt0(...), decode_pkt_page(...)
+ *      packets processing (header analyzing, storing complete page in cache,
+ *      only raw member of tt_char is filled at this stage)
+ * 3. stream/tvi_vbi.c: decode_page(...)
+ *      page decoding. filling unicode,gfx,ctl,etc members of tt_char structure
+ *      with appropriate values according to teletext control chars, converting
+ *      text to utf8.
+ * ---rendering stage---
+ * 4. stream/tvi_vbi.c: prepare_visible_page(...)
+ *      processing page. adding number of just received by background process
+ *      teletext page, adding current time,etc.
+ * 5. libvo/sub.c: vo_update_text_teletext(...)
+ *      rendering displayable osd with text and graphics
+ *
+ * TODO:
+ *  v4lv1,bktr support
+ *  spu rendering
+ *  is better quality on poor signal possible ?
+ *  link support
+ *  font autoscale
+ *  greyscale osd
+ *  slave command for dumping pages
+ *  fix bcd<->dec as suggested my Michael
+ *
+ *  BUGS:
+ *  wrong colors in debug dump
+ *  blinking when visible page was just updated
+ */
+
+#include "config.h"
+
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include <errno.h>
+#include <math.h>
+#include <stdio.h>
+
+#include <pthread.h>
+
+#include "tv.h"
+#include "mp_msg.h"
+#include "help_mp.h"
+#include "libmpcodecs/img_format.h"
+#include "libavutil/common.h"
+#include "input/input.h"
+
+//#define DEBUG_DUMP 1
+
+/// page magazine entry structure
+typedef struct mag_s{
+    tt_page* pt;
+    int      order;
+    int      lang;
+} mag_t;
+
+typedef struct {
+    int             on;            ///< teletext on/off
+    int             pagenum;       ///< seek page number
+    int             subpagenum;    ///< seek subpage
+    int             curr_pagenum;  ///< current page number
+    int             pagenumdec;    ///< set page num with dec
+
+    teletext_format tformat;       ///< see teletext_format enum
+    teletext_zoom   zoom;          ///< see teletext_zoom enum
+    mag_t*          mag;           ///< pages magazine (has 8 entities)
+    /// Currently displayed page (with additional info, e.g current time)
+    tt_char         display_page[VBI_ROWS*VBI_COLUMNS];
+    /// number of raw bytes between two subsequent encoded bits
+    int bpb;
+    /// clock run-in sequence will be searched in buffer in [soc:eoc] bytes range
+    int soc;
+    int eoc;
+    /// minimum number of raw vbi bytes wich can be decoded into 8 data bits
+    int bp8bl;
+    /// maximum number of raw vbi bytes wich can be decoded into 8 data bits
+    int bp8bh;
+
+    int pll_adj;
+    int pll_dir;
+    int pll_cnt;
+    int pll_err;
+    int pll_lerr;
+    int pll_fixed;
+    /// vbi stream properties (buffer size,bytes per line, etc)
+    tt_stream_props* ptsp;
+    pthread_mutex_t buffer_mutex;
+
+    tt_page** ptt_cache;
+    unsigned char* ptt_cache_first_subpage;
+} priv_vbi_t;
+
+static unsigned char fixParity[256];
+
+static tt_char tt_space={0x20,7,0,0,0,0,0x20};
+static tt_char tt_error={'?',1,0,0,0,0,'?'}; // Red '?' on black background
+static double si[12];
+static double co[12];
+
+#define VBI_FORMAT(priv) (*(priv->ptsp))
+
+#define FIXP_SH 16
+#define ONE_FIXP (1<<FIXP_SH)
+#define FIXP2INT(a) ((a)>>FIXP_SH)
+#define ANY2FIXP(a) ((int)((a)*ONE_FIXP))
+
+static const unsigned char corrHamm48[256]={
+  0x01, 0xff, 0x01, 0x01, 0xff, 0x00, 0x01, 0xff,
+  0xff, 0x02, 0x01, 0xff, 0x0a, 0xff, 0xff, 0x07,
+  0xff, 0x00, 0x01, 0xff, 0x00, 0x00, 0xff, 0x00,
+  0x06, 0xff, 0xff, 0x0b, 0xff, 0x00, 0x03, 0xff,
+  0xff, 0x0c, 0x01, 0xff, 0x04, 0xff, 0xff, 0x07,
+  0x06, 0xff, 0xff, 0x07, 0xff, 0x07, 0x07, 0x07,
+  0x06, 0xff, 0xff, 0x05, 0xff, 0x00, 0x0d, 0xff,
+  0x06, 0x06, 0x06, 0xff, 0x06, 0xff, 0xff, 0x07,
+  0xff, 0x02, 0x01, 0xff, 0x04, 0xff, 0xff, 0x09,
+  0x02, 0x02, 0xff, 0x02, 0xff, 0x02, 0x03, 0xff,
+  0x08, 0xff, 0xff, 0x05, 0xff, 0x00, 0x03, 0xff,
+  0xff, 0x02, 0x03, 0xff, 0x03, 0xff, 0x03, 0x03,
+  0x04, 0xff, 0xff, 0x05, 0x04, 0x04, 0x04, 0xff,
+  0xff, 0x02, 0x0f, 0xff, 0x04, 0xff, 0xff, 0x07,
+  0xff, 0x05, 0x05, 0x05, 0x04, 0xff, 0xff, 0x05,
+  0x06, 0xff, 0xff, 0x05, 0xff, 0x0e, 0x03, 0xff,
+  0xff, 0x0c, 0x01, 0xff, 0x0a, 0xff, 0xff, 0x09,
+  0x0a, 0xff, 0xff, 0x0b, 0x0a, 0x0a, 0x0a, 0xff,
+  0x08, 0xff, 0xff, 0x0b, 0xff, 0x00, 0x0d, 0xff,
+  0xff, 0x0b, 0x0b, 0x0b, 0x0a, 0xff, 0xff, 0x0b,
+  0x0c, 0x0c, 0xff, 0x0c, 0xff, 0x0c, 0x0d, 0xff,
+  0xff, 0x0c, 0x0f, 0xff, 0x0a, 0xff, 0xff, 0x07,
+  0xff, 0x0c, 0x0d, 0xff, 0x0d, 0xff, 0x0d, 0x0d,
+  0x06, 0xff, 0xff, 0x0b, 0xff, 0x0e, 0x0d, 0xff,
+  0x08, 0xff, 0xff, 0x09, 0xff, 0x09, 0x09, 0x09,
+  0xff, 0x02, 0x0f, 0xff, 0x0a, 0xff, 0xff, 0x09,
+  0x08, 0x08, 0x08, 0xff, 0x08, 0xff, 0xff, 0x09,
+  0x08, 0xff, 0xff, 0x0b, 0xff, 0x0e, 0x03, 0xff,
+  0xff, 0x0c, 0x0f, 0xff, 0x04, 0xff, 0xff, 0x09,
+  0x0f, 0xff, 0x0f, 0x0f, 0xff, 0x0e, 0x0f, 0xff,
+  0x08, 0xff, 0xff, 0x05, 0xff, 0x0e, 0x0d, 0xff,
+  0xff, 0x0e, 0x0f, 0xff, 0x0e, 0x0e, 0xff, 0x0e };
+
+
+enum {
+  LAT_UNI=0,
+  RUS_UNI,
+  LANGS
+};
+
+// conversion table for chars 0x20-0x7F (UTF8)
+// TODO: add another languages
+static unsigned int lang_chars[LANGS][0x60]={
+ {
+  //Latin
+  0x20,0x21,0x22,0x23,0x24,0x25,0x26,0x27,
+  0x28,0x29,0x2a,0x2b,0x2c,0x2d,0x2e,0x2f,
+  0x30,0x31,0x32,0x33,0x34,0x35,0x36,0x37,
+  0x38,0x39,0x3a,0x3b,0x3c,0x3d,0x3e,0x3f,
+  0x40,0x41,0x42,0x43,0x44,0x45,0x46,0x47,
+  0x48,0x49,0x4a,0x4b,0x4c,0x4d,0x4e,0x4f,
+  0x50,0x51,0x52,0x53,0x54,0x55,0x56,0x57,
+  0x58,0x59,0x5a,0x5b,0x5c,0x5d,0x5e,0x5f,
+  0x60,0x61,0x62,0x63,0x64,0x65,0x66,0x67,
+  0x68,0x69,0x6a,0x6b,0x6c,0x6d,0x6e,0x6f,
+  0x70,0x71,0x72,0x73,0x74,0x75,0x76,0x77,
+  0x78,0x79,0x7a,0x7b,0x7c,0x7d,0x7e,0x7f
+ },
+ {
+  //Russian
+  0x20,0x21,0x22,0x23,0x24,0x25,0x044b,0x27,
+  0x28,0x29,0x2a,0x2b,0x2c,0x2d,0x2e,0x2f,
+  0x30,0x31,0x32,0x33,0x34,0x35,0x36,0x37,
+  0x38,0x39,0x3a,0x3b,0x3c,0x3d,0x3e,0x3f,
+  0x042e,0x0410,0x0411,0x0426,0x0414,0x0415,0x0424,0x0413,
+  0x0425,0x0418,0x0419,0x041a,0x041b,0x041c,0x041d,0x041e,
+  0x041f,0x042f,0x0420,0x0421,0x0422,0x0423,0x0416,0x0412,
+  0x042c,0x042a,0x0417,0x0428,0x042d,0x0429,0x0427,0x042b,
+  0x044e,0x0430,0x0431,0x0446,0x0434,0x0435,0x0444,0x0433,
+  0x0445,0x0438,0x0439,0x043a,0x043b,0x043c,0x043d,0x043e,
+  0x043f,0x044f,0x0440,0x0441,0x0442,0x0443,0x0436,0x0432,
+  0x044c,0x044a,0x0437,0x0448,0x044d,0x0449,0x0447,0x044b
+ }
+};
+
+static int lang2id (int lang){
+  switch(lang){
+  case 0:
+      return LAT_UNI;
+  case 3: /* Stub. My teletext provider (1TV, Russia) sets this this language 
+             code for russian teletext pages
+             TODO: make this configurable
+           */
+      return RUS_UNI;
+  default:
+      return LAT_UNI;
+  }
+}
+
+/**
+ * \brief convert chars from curent teletext codepage into MPlayer charset
+ * \param p raw teletext char to decode
+ * \param lang teletext internal language code (see lang2id)
+ * \return UTF8 char
+ *
+ * \remarks
+ * routine will analyze raw member of given tt_char structure and
+ * fill unicode member of the same struct with appropriate utf8 code.
+ */
+static unsigned int conv2uni(unsigned int p,int lang)
+{
+    if(p<0x80 && p>=0x20){
+        return lang_chars[lang][p-0x20];
+    }else
+        return 0x20;
+}
+
+static void init_vbi_consts(priv_vbi_t* priv){
+    int i,j;
+    double ang;
+    for(i=0; i<256; i++){
+        j=i&0x7F;
+        j^= j+j;
+        j^= j<<2;
+        j^= j<<4;
+        fixParity[i]= i ^ (j&0x80) ^ 0x80;
+    }
+
+    for(i=0,ang=0; i<12; i++,ang+=M_PI/priv->bpb){
+        si[i]= sin(ang);
+        co[i]= cos(ang);
+    }
+
+    priv->bpb=(priv->ptsp->sampling_rate/6937500.0)*ONE_FIXP+0.5;
+//FIXME: STUBS!!!!
+    priv->soc=0;
+    priv->eoc=92;
+//END STUBS!!!
+    priv->bp8bl=0.97*8*priv->bpb/ONE_FIXP; // -3% tolerance
+    priv->bp8bh=1.03*8*priv->bpb/ONE_FIXP; // +3% tolerance
+}
+/**
+ * \brief calculate increased/decreased by given value page number
+ * \param curr  current page number in hexadecimal for
+ * \param direction decimal value (can be negative) to add to value
+ *        of curr parameter
+ * \return new page number in hexadecimal form
+ *
+ * VBI page numbers are represented in special hexadecimal form, e.g.
+ * page with number 123 (as seen by user) internally has number 0x123.
+ * and equation 0x123+8 should be equal to 0x131 instead of regular 0x12b.
+ *
+ *
+ * Page numbers 0xYYY (where Y is not belongs to (0..9).
+ * Page number belongs to [0x000,0x799] or [0x100:0x899] (first 0 can be 
+ * treated as '8')
+ */
+static int steppage(int p, int direction, int skip_hidden)
+{
+    if(skip_hidden)
+        p=(p&15)+((p>>4)&15)*10+(p>>8)*100;
+    p+=direction;
+    if(skip_hidden){
+        p=(p+800)%800;
+        p=(p%10)+((p/10)%10)*16+(p/100)*256;
+    }
+
+    return p&0x7ff;
+}
+
+/*
+------------------------------------------------------------------
+   Cache stuff
+------------------------------------------------------------------
+*/
+
+/**
+ * \brief add/update entry in cache
+ * \param priv private data structure
+ * \param pg page to store in cache
+ * \param line line to update (value below 0 means update entire page)
+ */
+static void put_to_cache(priv_vbi_t* priv,tt_page* pg,int line){
+    tt_page* pgc; //page in cache
+    int i,count;
+
+    if(line<0){
+        i=0;
+	count=VBI_ROWS*VBI_COLUMNS;
+    }else if(line<VBI_ROWS){
+        i=line*VBI_COLUMNS;
+        count=(line+1)*VBI_COLUMNS;
+    }else
+        return;
+
+    pthread_mutex_lock(&(priv->buffer_mutex));
+
+    if(!priv->ptt_cache[pg->pagenum]){
+        priv->ptt_cache[pg->pagenum]=calloc(1,sizeof(tt_page));
+        pgc=priv->ptt_cache[pg->pagenum];
+    }else{
+        pgc=priv->ptt_cache[pg->pagenum];
+        while(pgc->next_subpage && pgc->subpagenum!=pg->subpagenum)
+            pgc=pgc->next_subpage;
+
+        if(pgc->subpagenum!=pg->subpagenum){
+            pgc->next_subpage=calloc(1,sizeof(tt_page));
+            pgc=pgc->next_subpage;
+        }
+    }
+    pgc->pagenum=pg->pagenum;
+    pgc->subpagenum=pg->subpagenum;
+    pgc->lang=pg->lang;
+    pgc->flags=pg->flags;
+    //instead of copying entire page into cache, copy only undamaged
+    //symbols into cache
+    for(;i<count;i++){
+        if(!(pg->raw[i]&0x80))
+            pgc->raw[i]=pg->raw[i];
+        else
+            mp_msg(MSGT_TV,MSGL_DBG3,"char error. pg:%x, c[%d]=0x%x\n",
+                pg->pagenum,i,pg->raw[i]);
+    }
+    pgc->active=1;
+    pthread_mutex_unlock(&(priv->buffer_mutex));
+}
+
+/**
+ * \brief get any subpage number of given page
+ * \param priv private data structure
+ * \param pagenum page number to search subpages in
+ *
+ * \return subpage number of first found subpage which belongs to
+ * given page number
+ *
+ * \note page itself is subpage too (and usually has subpage number 0)
+ */
+static inline int get_subpagenum_from_cache(priv_vbi_t* priv, int pagenum){
+    if (!priv->ptt_cache[pagenum])
+        return -1;
+    else
+        return priv->ptt_cache[pagenum]->subpagenum;
+}
+
+/**
+ * \brief get page from cache by it page and subpage number
+ * \param priv private data structure
+ * \param pagenum page number
+ * \param subpagenum subpage number
+ *
+ * \return pointer to tt_page structure if requested page is found
+ * and NULL otherwise
+ */
+static inline tt_page* get_from_cache(priv_vbi_t* priv, int pagenum,int subpagenum){
+    tt_page* tp=priv->ptt_cache[pagenum];
+
+    while(tp && tp->subpagenum!=subpagenum)
+        tp=tp->next_subpage;
+    return tp;
+}
+
+/**
+ * \brief clears cache
+ * \param priv private data structure
+ *
+ * Deletes all tt_page structures from cache and frees allocated memory.
+ * Only zero-filled array of pointers remains in memory
+ */
+static void clear_cache(priv_vbi_t* priv){
+    int i;
+    tt_page* tp;
+    for(i=0;i<VBI_MAX_PAGES;i++){
+        while(priv->ptt_cache[i]){
+            tp=priv->ptt_cache[i];
+            priv->ptt_cache[i]=tp->next_subpage;
+            free(tp);
+        }
+    }
+}
+
+/**
+ * \brief cache initialization
+ * \param priv private data structure
+ *
+ * \note Has to be called before any cache operations!
+ */
+static void init_cache(priv_vbi_t* priv){
+    priv->ptt_cache=calloc(VBI_MAX_PAGES,sizeof(tt_page*));
+}
+
+/**
+ * \brief destroys cache
+ * \param priv private data structure
+ *
+ * Frees all memory allocated for cache (including array of pointers).
+ * It is safe to call this routine multiple times
+ */
+static void destroy_cache(priv_vbi_t* priv){
+    if(priv->ptt_cache){
+        clear_cache(priv);
+        free(priv->ptt_cache);
+        priv->ptt_cache=NULL;
+    }
+}
+
+/*
+------------------------------------------------------------------
+   Decoder stuff
+------------------------------------------------------------------
+*/
+/**
+ * \brief converts raw teletext page into useful format (1st rendering stage)
+ * \param pg page to decode
+ *
+ * Routine fills tt_char structure of each teletext_page character with proper
+ * info about foreground and background colors, character
+ * type (graphics/control/text).
+ */
+static void decode_page(tt_char* p,int lang,unsigned char* raw)
+{
+    int c,gfx=0,lat=0;
+    int i=0;
+    int fg_color=0;
+    int bg_color=0;
+    int row,col;
+    int separated=0;
+
+    for(row=0;row<VBI_ROWS;row++)   {
+        lat=(lang==0);
+        gfx=0;
+        fg_color=7;
+        bg_color=0;
+        separated=0;
+        for(col=0;col<VBI_COLUMNS;col++){
+            i=row*VBI_COLUMNS+col;
+            c=raw[i];
+            p[i].raw=c;
+            if(c&0x80){ //damaged char
+                p[i]=tt_error;
+                continue;
+            }
+            p[i].gfx=gfx?(separated?2:1):0;
+            p[i].lng=lat?0:lang;
+            p[i].ctl=(c&0x60)==0?1:0;
+            p[i].fg=fg_color;
+            p[i].bg=bg_color;
+
+            if ((c&0x60)==0){ //control chars
+                if(c>=0x08 && c<=0x0f){
+                }else if (c<=0x17){ //colors
+                    fg_color=c&0x0f;
+                    gfx=c>>4;
+                }else if (c<=0x18){
+                }else if (c<=0x1a){ //Contiguous/Separated gfx
+                    separated=!(c&1);
+                }else if (c<=0x1b){
+                    lat=!lat;
+                }else if (c<=0x1d){
+                    bg_color=(c&1)?fg_color:0;
+                    p[i].bg=bg_color;
+                }
+                p[i].ctl=1;
+                p[i].unicode=p[i].gfx?0:' ';
+                continue;
+            }
+
+            if(gfx){
+                p[i].unicode=c-0x20;
+                if (p[i].unicode>0x3f) p[i].unicode-=0x20;
+            }else
+                p[i].unicode=conv2uni(c,lang2id(p[i].lng));
+
+            p[i].fg=fg_color;
+            p[i].bg=bg_color;
+        }
+    }
+}
+
+/**
+ * \brief prepares current page for displaying
+ * \param priv_vbi private data structure
+ *
+ * Routine adds some useful info (time and page number of page, grabbed by
+ * background thread to top line of current page). Displays "No teletext"
+ * string if no vbi data available.
+ */
+#define PRINT_HEX(dp,i,h) dp[i].unicode=((h)&0xf)>9?'A'+((h)&0xf):'0'+((h)&0xf)
+static void prepare_visible_page(priv_vbi_t* priv){
+    tt_page *pg,*curr_pg;
+    unsigned char *p;
+    int i;
+
+    pthread_mutex_lock(&(priv->buffer_mutex));
+    mp_msg(MSGT_TV,MSGL_DBG3,"tvi_vbi: prepare_visible_page pg:0x%x, sub:0x%x\n",
+        priv->pagenum,priv->subpagenum);
+    if(priv->subpagenum==-1) //no page yet
+        priv->subpagenum=get_subpagenum_from_cache(priv,priv->pagenum);
+
+    pg=get_from_cache(priv,priv->pagenum,priv->subpagenum);
+    mp_dbg(MSGT_TV,MSGL_DBG3,"tvi_vbi: prepare_vibible_page2 pg:0x%x, sub:0x%x\n",
+        priv->pagenum,priv->subpagenum);
+
+    curr_pg=get_from_cache(priv,priv->curr_pagenum,
+        get_subpagenum_from_cache(priv,priv->curr_pagenum));
+    if (!pg && !curr_pg){
+        p=MSGTR_TV_NoTeletext;
+        for(i=0;i<VBI_COLUMNS && *p;i++){
+            GET_UTF8(priv->display_page[i].unicode,*p++,break;);
+        }
+        for(;i<VBI_ROWS*VBI_COLUMNS;i++)
+            priv->display_page[i]=tt_space;
+        pthread_mutex_unlock(&(priv->buffer_mutex));
+        return;
+    }
+
+    if (!pg || !pg->active){
+        for(i=0;i<VBI_ROWS*VBI_COLUMNS;i++){
+            priv->display_page[i]=tt_space;
+        }
+    }else{
+        decode_page(priv->display_page,pg->lang,pg->raw);
+        mp_msg(MSGT_TV,MSGL_DBG3,"page #%x was decoded!\n",pg->pagenum);
+    }
+
+    PRINT_HEX(priv->display_page,0,(priv->curr_pagenum&0x700)?priv->curr_pagenum>>8:8);
+    PRINT_HEX(priv->display_page,1,priv->curr_pagenum>>4);
+    PRINT_HEX(priv->display_page,2,priv->curr_pagenum);
+    priv->display_page[3].unicode=' ';
+    priv->display_page[4].unicode=' ';
+    switch(priv->pagenumdec>>12){
+    case 1:
+        priv->display_page[5].unicode='_';
+        priv->display_page[6].unicode='_';
+        PRINT_HEX(priv->display_page,7,priv->pagenumdec);
+        break;
+    case 2:
+        priv->display_page[5].unicode='_';
+        PRINT_HEX(priv->display_page,6,priv->pagenumdec>>4);
+        PRINT_HEX(priv->display_page,7,priv->pagenumdec);
+    break;
+    default:
+        PRINT_HEX(priv->display_page,5,(priv->pagenum&0x700)?priv->pagenum>>8:8);
+        PRINT_HEX(priv->display_page,6,priv->pagenum>>4);
+        PRINT_HEX(priv->display_page,7,priv->pagenum);
+    }
+    if(priv->subpagenum!=-1){
+        priv->display_page[8].unicode='.';
+        PRINT_HEX(priv->display_page,9,priv->subpagenum>>4);
+        PRINT_HEX(priv->display_page,10,priv->subpagenum);
+    }else{
+        priv->display_page[8].unicode=' ';
+        priv->display_page[9].unicode=' ';
+        priv->display_page[10].unicode=' ';
+    }
+    priv->display_page[11].unicode=' ';
+    for(i=VBI_TIME_LINEPOS;i<VBI_COLUMNS;i++){
+        priv->display_page[i].unicode=curr_pg->raw[i];
+    }
+    pthread_mutex_unlock(&(priv->buffer_mutex));
+}
+/*
+------------------------------------------------------------------
+   Renderer stuff
+------------------------------------------------------------------
+*/
+#ifdef DEBUG_DUMP
+/**
+ * \brief renders teletext page into given file
+ * \param pt page to render
+ * \param f opened file descriptor
+ * \param pagenum which page to render
+ * \param colored use colors not implementede yet)
+ *
+ * Text will be UTF8 encoded
+ */
+static void render2text(tt_page* pt,FILE* f,int colored){
+    int i,j;
+    unsigned int u;
+    unsigned char buf[8];
+    unsigned char tmp;
+    int pos;
+    tt_char dp[VBI_ROWS*VBI_COLUMNS];
+    int color=0;
+    int bkg=0;
+    int c1,b1;
+    if(!pt)
+        return;
+    fprintf(f,"+========================================+\n");
+    fprintf(f,"| lang:%d pagenum:0x%x subpagenum:%d flags:0x%x|\n",
+    pt->lang,
+    pt->pagenum,
+    pt->subpagenum,
+    0);
+    fprintf(f,"+----------------------------------------+\n");
+
+    decode_page(dp,pt->lang,pt->raw);
+    for(i=0;i<VBI_ROWS;i++){
+        fprintf(f,"|");
+        if(colored) fprintf(f,"\033[40m");
+        for(j=0;j<VBI_COLUMNS;j++)
+        {
+             u=dp[i*VBI_COLUMNS+j].unicode;
+              switch(dp[i*VBI_COLUMNS+j].fg){
+              case 0 ... 7:
+                c1=30+dp[i*VBI_COLUMNS+j].fg;
+                break;
+              default:
+                c1=38;
+                  break;
+              }
+              switch(dp[i*VBI_COLUMNS+j].bg){
+              case 0 ... 7:
+                  b1=40+dp[i*VBI_COLUMNS+j].bg;
+                break;
+              default:
+                b1=40;
+              }
+            if (b1!=bkg  && colored){
+                fprintf(f,"\033[%dm",b1);
+                bkg=b1;
+            }
+            if(c1!=color && colored){
+                fprintf(f,"\033[%dm",c1);
+                color=c1;
+            }
+            if(dp[i*VBI_COLUMNS+j].gfx){
+                fprintf(f,"*");
+            }else{
+                pos=0;
+                PUT_UTF8(u,tmp,if(pos<7) buf[pos++]=tmp;);
+                buf[pos]='\0';
+                fprintf(f,"%s",buf);
+            }
+        }
+
+        if (colored) fprintf(f,"\033[0m");
+        color=-1;bkg=-1;
+        fprintf(f,"|\n");
+    }
+#if 1
+    //for debug
+    fprintf(f,"+====================raw=================+\n");
+    for(i=0;i<VBI_ROWS;i++){
+        for(j=0;j<VBI_COLUMNS;j++)
+            fprintf(f,"%02x ",dp[i*VBI_COLUMNS+j].raw);
+        fprintf(f,"\n");
+    }
+    fprintf(f,"+====================lng=================+\n");
+    for(i=0;i<VBI_ROWS;i++){
+        for(j=0;j<VBI_COLUMNS;j++)
+            fprintf(f,"%02x ",dp[i*VBI_COLUMNS+j].lng);
+        fprintf(f,"\n");
+    }
+#endif
+    fprintf(f,"+========================================+\n");
+}
+
+/**
+ * \brief dump page into pgXXX.txt file in vurrent directory
+ * \param pt page to dump
+ *
+ * \note XXX in filename is page number
+ * \note use only for debug purposes
+ */
+static void dump_page(tt_page* pt)
+{
+    FILE*f;
+    char name[100];
+    snprintf(name,99,"pg%x.txt",pt->pagenum);
+    f=fopen(name,"wb");
+    render2text(pt,f,1);
+    fclose(f);
+}
+#endif //DEBUG_DUMP
+
+
+/**
+ * \brief checks whether page is ready and copies it into cache array if so
+ * \param priv private data structure
+ * \param magAddr page's magazine address (0-7)
+ *
+ * Routine also calls decode_page to perform 1st stage of rendering
+ */
+static void store_in_cache(priv_vbi_t* priv, int magAddr, int line){
+    mp_msg(MSGT_TV,MSGL_DBG2,"store_in_cache(%d): pagenum:%x\n",
+        priv->mag[magAddr].order,
+        priv->mag[magAddr].pt->pagenum);
+
+    put_to_cache(priv,priv->mag[magAddr].pt,line);
+    priv->curr_pagenum=priv->mag[magAddr].pt->pagenum;
+
+#ifdef DEBUG_DUMP
+    dump_page(get_from_cache(priv,
+        priv->mag[magAddr].pt->pagenum,
+        priv->mag[magAddr].pt->subpagenum));
+#endif
+}
+
+
+/*
+------------------------------------------------------------------
+  Grabber stuff
+------------------------------------------------------------------
+*/
+#define PLL_SAMPLES 4
+#define PLL_ERROR   4
+#define PLL_ADJUST  4
+
+/**
+ * \brief adjust current phase for better signal decoding
+ * \param n count of bytes processed (?)
+ * \param err count of error bytes (?)
+ *
+ * \remarks code was got from MythTV project
+ */
+static void pll_add(priv_vbi_t* priv,int n,int err){
+    if(priv->pll_fixed)
+        return;
+    if(err>PLL_ERROR*2/3)
+        err=PLL_ERROR*2/3;
+    priv->pll_err+=err;
+    priv->pll_cnt+=n;
+    if(priv->pll_cnt<PLL_SAMPLES)
+        return;
+    if(priv->pll_err>PLL_ERROR)
+    {
+        if(priv->pll_err>priv->pll_lerr)
+            priv->pll_dir= -priv->pll_dir;
+        priv->pll_lerr=priv->pll_err;
+        priv->pll_adj+=priv->pll_dir;
+        if (priv->pll_adj<-PLL_ADJUST || priv->pll_adj>PLL_ADJUST)
+        {
+            priv->pll_adj=0;
+            priv->pll_dir=-1;
+            priv->pll_lerr=0;
+        }
+        mp_msg(MSGT_TV,MSGL_DBG3,"vbi: pll_adj=%2d\n",priv->pll_adj);
+    }
+    priv->pll_cnt=0;
+    priv->pll_err=0;
+}
+
+/**
+ * \brief reset error correction
+ * \param priv private data structure
+ * \param fine_tune shift value for adjusting
+ *
+ * \remarks code was got from MythTV project
+ */
+static void pll_reset(priv_vbi_t* priv,int fine_tune){
+    priv->pll_fixed=fine_tune >= -PLL_ADJUST && fine_tune <= PLL_ADJUST;
+
+    priv->pll_err=0;
+    priv->pll_lerr=0;
+    priv->pll_cnt=0;
+    priv->pll_dir=-1;
+    priv->pll_adj=0;
+    if(priv->pll_fixed)
+        priv->pll_adj=fine_tune;
+    if(priv->pll_fixed)
+        mp_msg(MSGT_TV,MSGL_DBG3,"pll_reset (fixed@%2d)\n",priv->pll_adj);
+    else
+        mp_msg(MSGT_TV,MSGL_DBG3,"pll_reset (auto)\n");
+
+}
+/**
+ * \brief decode packet 0 (teletext page header)
+ * \param priv private data structure
+ * \param data raw teletext data (with not applied hamm correction yet)
+ * \param magAddr teletext page's magazine address
+ *
+ * \remarks
+ * data buffer was shifted by 6 and now contains:
+ *  0..1 page number
+ *  2..5 sub-code
+ *  6..7 control codes
+ *  8..39 display data
+ *
+ *  only first 8 bytes protected by Hamm 8/4 code
+ */
+static int decode_pkt0(priv_vbi_t* priv,unsigned char* data,int magAddr)
+{
+    int d[8];
+    int i,err;
+
+    if (magAddr<0 || magAddr>7)
+        return 0;
+    for(i=0;i<8;i++){
+        d[i]= corrHamm48[ data[i] ];
+        if(d[i]&0x80){
+            pll_add(priv,2,4);
+
+            if(priv->mag[magAddr].pt)
+                  free(priv->mag[magAddr].pt);
+            priv->mag[magAddr].pt=NULL;
+            priv->mag[magAddr].order=0;
+            return 0;
+        }
+    }
+    if (!priv->mag[magAddr].pt)
+        priv->mag[magAddr].pt= malloc(sizeof(tt_page));
+
+    priv->mag[magAddr].lang= d[7] & 0x7;
+    priv->mag[magAddr].pt->lang=priv->mag[magAddr].lang;
+    priv->mag[magAddr].pt->subpagenum=(d[2]|(d[3]<<4)|(d[4]<<8)|(d[5]<<12))&0x3f7f;
+    priv->mag[magAddr].pt->pagenum=(magAddr<<8) | d[0] | (d[1]<<4);
+    priv->mag[magAddr].pt->flags=( d[6] | (d[7]<<4));
+
+    memset(priv->mag[magAddr].pt->raw, 0x00, VBI_COLUMNS*VBI_ROWS);
+    priv->mag[magAddr].order=0;
+
+    for(i=0;i<8;i++){
+        priv->mag[magAddr].pt->raw[i]=0x20;
+    }
+    err=0;
+    for(i=8; i<VBI_COLUMNS; i++){
+        data[i]= fixParity[data[i]];
+        priv->mag[magAddr].pt->raw[i]=data[i];
+        if(data[i]&0x80) //Error
+            err++;
+        pll_add(priv,1,err);
+    }
+
+    store_in_cache(priv,magAddr,0);
+
+    return 1;
+}
+
+/**
+ * \brief decode packets 1..24 (teletext page header)
+ * \param priv private data structure
+ * \param data raw teletext data
+ * \param magAddr teletext page's magazine address
+ * \param rowAddr teletext page's row number
+ *
+ * \remarks
+ * data buffer was shifted by 6 and now contains 40 bytes of display data:
+ * this type of packet is not proptected by Hamm 8/4 code
+ */
+static void decode_pkt_page(priv_vbi_t* priv,unsigned char*data,int magAddr,int rowAddr){
+    int i,err;
+    if (!priv->mag[magAddr].pt)
+        return;
+
+    priv->mag[magAddr].order=rowAddr;
+
+    err=0;
+    for(i=0; i<VBI_COLUMNS; i++){
+        data[i]= fixParity[ data[i] ];
+        priv->mag[magAddr].pt->raw[i+rowAddr*VBI_COLUMNS]=data[i];
+        if( data[i]&0x80) //HammError
+            err++;
+    }
+    pll_add(priv,1,err);
+
+    store_in_cache(priv,magAddr,rowAddr);
+}
+
+/**
+ * \brief decodes raw vbi data (signal amplitudes) into sequence of bytes
+ * \param priv private data structure
+ * \param buf raw vbi data (one line of frame)
+ * \param data output buffer for decoded bytes (at least 45 bytes long)
+ *
+ * Used XawTV's algorithm. Signal phase is calculated with help of starting clock
+ * run-in sequence (min/max values and bit distance values are calculated)
+ */
+static int decode_raw_line_runin(priv_vbi_t* priv,unsigned char* buf,unsigned char* data){
+    const int magic= 0x27; // reversed 1110010
+    int dt[256],hi[6],lo[6];
+    int i,x,r;
+    int decoded;
+    int sync;
+    unsigned char min,max;
+    int thr=0; //threshold
+
+    //stubs
+    int soc=0;
+    int eoc=92;
+
+    for(i=soc;i<eoc;i++)
+        dt[i]=buf[i+priv->bpb/ONE_FIXP]-buf[i];    // amplifies the edges best.
+    /* set barrier */
+    for (i=eoc; i<eoc+16; i+=2)
+        dt[i]=100, dt[i+1]=-100;
+
+    /* find 6 rising and falling edges */
+    for (i=soc, x=0; x<6; ++x)
+    {
+        while (dt[i]<32)
+            i++;
+        hi[x]=i;
+        while (dt[i]>-32)
+            i++;
+        lo[x]=i;
+    }
+    if (i>=eoc)
+    {
+        return 0;      // not enough periods found
+    }
+    i=hi[5]-hi[1]; // length of 4 periods (8 bits)
+    if (i<priv->bp8bl || i>priv->bp8bh)
+    {
+        mp_msg(MSGT_TV,MSGL_DBG3,"vbi: wrong freq %d (%d,%d)\n",
+            i,priv->bp8bl,priv->bp8bh);
+        return 0;      // bad frequency
+    }
+    /* AGC and sync-reference */
+    min=255, max=0, sync=0;
+    for (i=hi[4]; i<hi[5]; ++i)
+        if (buf[i]>max)
+            max=buf[i], sync=i;
+    for (i=lo[4]; i<lo[5]; ++i)
+        if (buf[i]<min)
+            min=buf[i];
+    thr=(min+max)/2;
+
+    buf+=sync;
+    // searching for '11'
+    for(i=priv->pll_adj*priv->bpb/10;i<16*priv->bpb;i+=priv->bpb)
+        if(buf[FIXP2INT(i)]>thr && buf[FIXP2INT(i+priv->bpb)]>thr)
+            break;
+    r=0;
+    for(decoded=1; decoded<= (VBI_COLUMNS+3)<<3;decoded++){
+        r>>=1;
+        if(buf[FIXP2INT(i)]>thr) r|=0x80;
+        if(!(decoded & 0x07)){
+            data[(decoded>>3) - 1]=r;
+            r=0;
+        }
+        i+=priv->bpb;
+    }
+    if(data[0]!=magic)
+        return 0; //magic not found
+
+    //stub
+    for(i=0;i<43;i++){
+        data[i]=data[i+1];
+    }
+    mp_msg(MSGT_TV,MSGL_DBG3,"thr:%d sync:%d ",thr,sync);
+
+    return 1;
+}
+
+/**
+ * \brief decodes raw vbi data (signal amplitudes) into sequence of bytes
+ * \param priv private data structure
+ * \param buf raw vbi data (one line of frame)
+ * \param data output buffer for decoded bytes (at least 45 bytes long)
+ *
+ * Used Michael Niedermayer's algorithm.
+ * Signal phase is calculated using correlation between given samples data and
+ * pure sine
+ */
+static int decode_raw_line_sine(priv_vbi_t* priv,unsigned char* buf,unsigned char* data){
+    int i,x,r,amp,xFixp;
+    int avg=0;
+    double sin_sum=0, cos_sum=0;
+
+    for(x=0; x< FIXP2INT(10*priv->bpb); x++)
+      avg+=buf[x];
+
+    avg/=FIXP2INT(10*priv->bpb);
+
+    for(x=0; x<12; x++){
+      amp= buf[x<<1];
+      sin_sum+= si[x]*(amp-avg);
+      cos_sum+= co[x]*(amp-avg);
+    }
+    //this is always zero. Why ?
+    xFixp= atan(sin_sum/cos_sum)*priv->bpb/M_PI;
+
+    //Without this line the result is full of errors
+    //and routine is unable to find magic sequence
+    buf+=FIXP2INT(10*priv->bpb);
+
+    r=0;
+    for(x=FIXP2INT(xFixp);x<70;x=FIXP2INT(xFixp)){
+      r=(r<<1) & 0xFFFF;
+      if(buf[x]>avg) r|=1;
+      xFixp+=priv->bpb;
+      if(r==0xAAE4) break;
+    }
+
+    //this is not teletext
+    if (r!=0xaae4) return 0;
+
+    //Decode remaining 45-2(clock run-in)-1(framing code)=42 bytes
+    for(i=1; i<=(42<<3); i++){
+      r>>=1;
+      x=FIXP2INT(xFixp);
+      if(buf[x]> avg)
+          r|=0x80;
+
+      if(!(i & 0x07)){
+          data[(i>>3)-1]=r;
+          r=0;
+      }
+      xFixp+=priv->bpb;
+    }
+
+    return 1;
+}
+</