tvi_vbi.c

君正早期ucos系统(只有早期的才不没有打包成库),MPLAYER,文件系统,图片解码,浏览,电子书,录音,想学ucos,识货的人就下吧 russblock fmradio explore set

/*
 * Teletext support
 * Copyright (C) 2007 Vladimir Voroshilov <[e-mail]>
 *
 * 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.
 * Code for calculating [soc:eoc] is based on aletv of Edgar Toernig.
 *
 * Teletext system is described in
 * ETS 300 706 "Enhanced Teletext specification" : May 1997
 * http://www.themm.net/~mihu/linux/saa7146/specs/ets_300706e01p.pdf
 *
 * 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 <mplaylib.h>
#include <mplaylib.h>
#include <mplaylib.h>
#include <errno.h>
#include <math.h>
#include <mplaylib.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"
#include "osdep/timer.h"
#undef memcpy
#define memcpy uc_memcpy
//#define DEBUG_DUMP 1

/// page magazine entry structure
typedef struct mag_s{
    tt_page* pt;
    int      order;
} 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)
    int             primary_language;      ///< primary character set
    int             secondary_language;    ///< secondary character set
    /// 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;
    /// network info
    unsigned char initialpage;
    unsigned int  initialsubpage;
    unsigned int  networkid;
    int           timeoffset; // timeoffset=realoffset*2
    unsigned int  juliandate;
    unsigned int  universaltime;
    unsigned char networkname[21];
    int           cache_reset;
    /// "page changed" flag: 0-unchanged, 1-entire page, 3-only header
    int           page_changed;
    int           last_rendered;
} priv_vbi_t;

static unsigned char fixParity[256];

static tt_char tt_space={0x20,7,0,0,0,0,0,0,0x20};
static tt_char tt_error={'?',1,0,0,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 {
  LATIN=0,
  CYRILLIC1,
  CYRILLIC2,
  CYRILLIC3,
  GREEK,
  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
 },
 {
  //Cyrillic-1 (Serbian/Croatian)
  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,
  0x0427,0x0410,0x0411,0x0426,0x0414,0x0415,0x0424,0x0413,
  0x0425,0x0418,0x0408,0x041a,0x041b,0x041c,0x041d,0x041e,
  0x041f,0x040c,0x0420,0x0421,0x0422,0x0423,0x0412,0x0403,
  0x0409,0x040a,0x0417,0x040b,0x0416,0x0402,0x0428,0x040f,
  0x0447,0x0430,0x0431,0x0446,0x0434,0x0435,0x0444,0x0433,
  0x0445,0x0438,0x0428,0x043a,0x043b,0x043c,0x043d,0x043e,
  0x043f,0x042c,0x0440,0x0441,0x0442,0x0443,0x0432,0x0423,
  0x0429,0x042a,0x0437,0x042b,0x0436,0x0422,0x0448,0x042f
 },
 {
  //Cyrillic-2 (Russian/Bulgarian)
  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
 },
 {
  //Cyrillic-3 (Ukrainian)
  0x20,0x21,0x22,0x23,0x24,0x25,0xef,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,0x49,0x0417,0x0428,0x042d,0x0429,0x0427,0xcf,
  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,0x69,0x0437,0x0448,0x044d,0x0449,0x0447,0xFF
 },
 {
  //Greek
  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,
  0x0390,0x0391,0x0392,0x0393,0x0394,0x0395,0x0396,0x0397,
  0x0398,0x0399,0x039a,0x039b,0x039c,0x039d,0x039e,0x039f,
  0x03a0,0x03a1,0x03a2,0x03a3,0x03a4,0x03a5,0x03a6,0x03a7,
  0x03a8,0x03a9,0x03aa,0x03ab,0x03ac,0x03ad,0x03ae,0x03af,
  0x03b0,0x03b1,0x03b2,0x03b3,0x03b4,0x03b5,0x03b6,0x03b7,
  0x03b8,0x03b9,0x03ba,0x03bb,0x03bc,0x03bd,0x03be,0x03bf,
  0x03c0,0x03c1,0x03c2,0x03c3,0x03c4,0x03c5,0x03c6,0x03c7,
  0x03c8,0x03c9,0x03ca,0x03cb,0x03cc,0x03cd,0x03ce,0x03cf
 }
};

/**
 * Latin National Option Sub-Sets
 * see Table 36 of ETS specification for details.
 *
 * 00:  £ $ @ « ½ » ¬ # ­ ¼ ¦ ¾ ÷  English
 * 01:  é ï à ë ê ù î # è â ô û ç  French
 * 02:  # ¤ É Ä Ö Å Ü _ é ä ö å ü  Swedish/Finnish/Hungarian
 * 03:  # u c t z ý í r é á e ú s  Czech/Slovak
 * 04:  # $ § Ä Ö Ü ^ _ ° ä ö ü ß  German
 * 05:  ç $ ¡ á é í ó ú ¿ ü ñ è à  Portuguese/Spanish
 * 06:  £ $ é ° ç » ¬ # ù à ò è ì  Italian
 *
 */
static unsigned int latin_subchars[8][13]={
  // English
  {0xa3,0x24,0x40,0xab,0xbd,0xbb,0xac,0x23,0xad,0xbc,0xa6,0xbe,0xf7},
  // French
  {0xe9,0xef,0xe0,0xeb,0xea,0xf9,0xee,0x23,0xe8,0xe2,0xf4,0xfb,0xe7},
  // Swedish/Finnish/Hungarian
  {0x23,0xa4,0xc9,0xc4,0xd6,0xc5,0xdc,0x5f,0xe9,0xe4,0xf6,0xe5,0xfc},
  // Czech/Slovak
  {0x23,0x75,0x63,0x74,0x7a,0xfd,0xed,0x72,0xe9,0xe1,0x65,0xfa,0x73},
  // German
  {0x23,0x24,0xa7,0xc4,0xd6,0xdc,0x5e,0x5f,0xb0,0xe4,0xf6,0xfc,0xdf},
  // Portuguese/Spanish
  {0xe7,0x24,0xa1,0xe1,0xe9,0xed,0xf3,0xfa,0xbf,0xfc,0xf1,0xe8,0xe0},
  // Italian
  {0xa3,0x24,0xe9,0xb0,0xe7,0xbb,0xac,0x23,0xf9,0xe0,0xf2,0xe8,0xec},
  // Reserved
  {0x23,0x24,0x40,0x5b,0x5c,0x5d,0x5e,0x5f,0x60,0x7b,0x7c,0x7d,0x7e}
};

/**
 * List of supported languages.
 *
 * lang_code bits for primary Language:
 * bits 7-4 corresponds to bits 14-11 of 28 packet's first triplet 
 * bits 3-1 corresponds to bits C12-C14 of packet 0 (lang)
 *
 * lang_code bits for secondary Language:
 * bits 7-5 corresponds to bits 3-1 of 28 packet's second triplet 
 * bits 4,2 corresponds to bits 18,16 of 28 packet's first triplet
 * bits 3,1 corresponds to bits 15,17 of 28 packet's first triplet
 *
 * For details see Tables 32 and 33 of specification (subclause 15.2)
 */
struct {
    unsigned char lang_code;
    unsigned char charset;
    char* lang_name;
} tt_languages[]=
{
  { 0x01, LATIN,     "French"},
  { 0x02, LATIN,     "Swedish/Finnish/Hungarian"},
  { 0x03, LATIN,     "Czech/Slovak"},
  { 0x04, LATIN,     "German"},
  { 0x05, LATIN,     "Portuguese/Spanish"},
  { 0x06, LATIN,     "Italian"},

  { 0x08, LATIN,     "Polish"},
  { 0x09, LATIN,     "French"},
  { 0x0a, LATIN,     "Swedish/Finnish/Hungarian"},
  { 0x0b, LATIN,     "Czech/Slovak"},
  { 0x0c, LATIN,     "German"},
  { 0x0e, LATIN,     "Italian"},

  { 0x10, LATIN,     "English"},
  { 0x11, LATIN,     "French"},
  { 0x12, LATIN,     "Swedish/Finnish/Hungarian"},
  { 0x13, LATIN,     "Turkish"},
  { 0x14, LATIN,     "German"},
  { 0x15, LATIN,     "Portuguese/Spanish"},
  { 0x16, LATIN,     "Italian"},

  { 0x1d, LATIN,     "Serbian/Croatian/Slovenian (Latin)"},
  
  { 0x20, CYRILLIC1, "Serbian/Croatian (Cyrillic)"},
  { 0x21, CYRILLIC2, "Russian, Bulgarian"},
  { 0x22, LATIN,     "Estonian"},
  { 0x23, LATIN,     "Czech/Slovak"},
  { 0x24, LATIN,     "German"},
  { 0x25, CYRILLIC3, "Ukrainian"},
  { 0x26, LATIN,     "Lettish/Lithuanian"},

  { 0x33, LATIN,     "Turkish"},
  { 0x37, GREEK,     "Greek"},

  { 0x40, LATIN,     "English"},
  { 0x41, LATIN,     "French"},
//  { 0x47, ARABIC,    "Arabic"},

//  { 0x55, HEBREW,    "Hebrew"},
//  { 0x57, ARABIC,    "Arabic"},

  { 0x00, LATIN,     "English"},
};

/**
 * \brief 24/18 Hamming code decoding
 * \param data bytes with hamming code (array must be at least 3 bytes long)
 * \return -1 if multiple bit error occured, D1-DI data bits - otherwise
 *
 * \note Bits must be correctly ordered, that is for 24/18 (lowest bit first)
 * P1 P2 D1 P3 D2 D3 D4 P4  D5 D6 D7 D8 D9 DA DB P5  DC DD DE DF DG DH DI P6
 */
int corrHamm24(unsigned char *data){
    unsigned char syndrom=0;
    int cw=data[0] | (data[1]<<8) | (data[2]<<16);
    int i;

    for(i=0;i<23;i++)
        syndrom^=((cw>>i)&1)*(i+33);

    syndrom^=(cw>>11)&32;
   
    if(syndrom&31){
        if(syndrom < 32 || syndrom > 55)
            return -1;
        cw ^= 1<<((syndrom&31)-1);
   }

   return (cw&4)>>2 |
          (cw&0x70)>>3 |
          (cw&0x3f00)>>4 |
          (cw&0x3f0000)>>5;
}

/**
 * \brief converts language bits to charset index
 * \param lang language bits
 * \return charset index in lang_chars array
 */
static int lang2charset (int lang){
    int i;
    for(i=0;tt_languages[i].lang_code;i++)
        if(tt_languages[i].lang_code==lang)
            break;

    return tt_languages[i].charset;
}

/**
 * \brief convert chars from curent teletext codepage into MPlayer charset
 * \param p raw teletext char to decode
 * \param charset index on lang_chars
 * \param lang index in substitution array (latin charset only)
 * \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 charset,int lang)
{

    if(p<0x80 && p>=0x20){
        if(charset==LATIN){
            lang&=7;
            if (p>=0x23 && p<=0x24){
                return latin_subchars[lang][p-0x23];
            }else if (p==0x40){
                return latin_subchars[lang][2];
            }else if (p>=0x5b && p<=0x60){
                return latin_subchars[lang][p-0x5b+3];
            }else if (p>=0x7b && p<=0x7e){
                return latin_subchars[lang][p-0x7b+9];