stream/tv.c

   1 /*
   2  * TV Interface for MPlayer
   3  *
   4  * API idea based on libvo2
   5  *
   6  * Copyright (C) 2001 Alex Beregszaszi
   7  *
   8  * Feb 19, 2002: Significant rewrites by Charles R. Henrich (henrich@msu.edu)
   9  *               to add support for audio, and bktr *BSD support.
  10  *
  11  * This file is part of MPlayer.
  12  *
  13  * MPlayer is free software; you can redistribute it and/or modify
  14  * it under the terms of the GNU General Public License as published by
  15  * the Free Software Foundation; either version 2 of the License, or
  16  * (at your option) any later version.
  17  *
  18  * MPlayer is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU General Public License for more details.
  22  *
  23  * You should have received a copy of the GNU General Public License along
  24  * with MPlayer; if not, write to the Free Software Foundation, Inc.,
  25  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  26  */
  27
  28 #include <stdio.h>
  29 #include <stdlib.h>
  30 #include <unistd.h>
  31 #include <string.h>
  32 #include <ctype.h>
  33 #include <sys/time.h>
  34
  35 #include "config.h"
  36
  37
  38 #include "mp_msg.h"
  39 #include "help_mp.h"
  40
  41 #include "stream.h"
  42 #include "libmpdemux/demuxer.h"
  43 #include "libmpdemux/stheader.h"
  44
  45 #include "libaf/af_format.h"
  46 #include "libmpcodecs/img_format.h"
  47 #include "libmpcodecs/dec_teletext.h"
  48 #include "libavutil/avstring.h"
  49 #include "osdep/timer.h"
  50
  51 #include "tv.h"
  52
  53 #include "frequencies.h"
  54
  55 tv_channels_t *tv_channel_list;
  56 tv_channels_t *tv_channel_current, *tv_channel_last;
  57 char *tv_channel_last_real;
  58
  59 /* enumerating drivers (like in stream.c) */
  60 extern const tvi_info_t tvi_info_dummy;
  61 extern const tvi_info_t tvi_info_dshow;
  62 extern const tvi_info_t tvi_info_v4l;
  63 extern const tvi_info_t tvi_info_v4l2;
  64 extern const tvi_info_t tvi_info_bsdbt848;
  65
  66 /** List of drivers in autodetection order */
  67 static const tvi_info_t* tvi_driver_list[]={
  68 #ifdef CONFIG_TV_V4L2
  69     &tvi_info_v4l2,
  70 #endif
  71 #ifdef CONFIG_TV_V4L1
  72     &tvi_info_v4l,
  73 #endif
  74 #ifdef CONFIG_TV_BSDBT848
  75     &tvi_info_bsdbt848,
  76 #endif
  77 #ifdef CONFIG_TV_DSHOW
  78     &tvi_info_dshow,
  79 #endif
  80     &tvi_info_dummy,
  81     NULL
  82 };
  83
  84 void tv_start_scan(tvi_handle_t *tvh, int start)
  85 {
  86     mp_msg(MSGT_TV,MSGL_INFO,"start scan\n");
  87     tvh->tv_param->scan=start?1:0;
  88 }
  89
  90 static void tv_scan(tvi_handle_t *tvh)
  91 {
  92     unsigned int now;
  93     struct CHANLIST cl;
  94     tv_channels_t *tv_channel_tmp=NULL;
  95     tv_channels_t *tv_channel_add=NULL;
  96     tv_scan_t* scan;
  97     int found=0, index=1;
  98
  99     //Channel scanner without tuner is useless and causes crash due to uninitialized chanlist_s
 100     if (tvh->functions->control(tvh->priv, TVI_CONTROL_IS_TUNER, 0) != TVI_CONTROL_TRUE)
 101     {
 102         mp_msg(MSGT_TV, MSGL_WARN, MSGTR_TV_ScannerNotAvailableWithoutTuner);
 103         tvh->tv_param->scan=0;
 104         return;
 105     }
 106
 107     scan = tvh->scan;
 108     now=GetTimer();
 109     if (!scan) {
 110         scan=calloc(1,sizeof(tv_scan_t));
 111         tvh->scan=scan;
 112         cl = tvh->chanlist_s[scan->channel_num];
 113         tv_set_freq(tvh, (unsigned long)(((float)cl.freq/1000)*16));
 114         scan->scan_timer=now+1e6*tvh->tv_param->scan_period;
 115     }
 116     if(scan->scan_timer>now)
 117         return;
 118
 119     if (tv_get_signal(tvh)>tvh->tv_param->scan_threshold) {
 120         cl = tvh->chanlist_s[scan->channel_num];
 121         tv_channel_tmp=tv_channel_list;
 122         while (tv_channel_tmp) {
 123             index++;
 124             if (cl.freq==tv_channel_tmp->freq){
 125                 found=1;
 126                 break;
 127             }
 128             tv_channel_add=tv_channel_tmp;
 129             tv_channel_tmp=tv_channel_tmp->next;
 130         }
 131         if (!found) {
 132             mp_msg(MSGT_TV, MSGL_INFO, "Found new channel: %s (#%d). \n",cl.name,index);
 133             scan->new_channels++;
 134             tv_channel_tmp = malloc(sizeof(tv_channels_t));
 135             tv_channel_tmp->index=index;
 136             tv_channel_tmp->next=NULL;
 137             tv_channel_tmp->prev=tv_channel_add;
 138             tv_channel_tmp->freq=cl.freq;
 139             snprintf(tv_channel_tmp->name,sizeof(tv_channel_tmp->name),"ch%d",index);
 140             strncpy(tv_channel_tmp->number, cl.name, 5);
 141             tv_channel_tmp->number[4]='\0';
 142             if (!tv_channel_list)
 143                 tv_channel_list=tv_channel_tmp;
 144             else {
 145                 tv_channel_add->next=tv_channel_tmp;
 146                 tv_channel_list->prev=tv_channel_tmp;
 147             }
 148         }else
 149             mp_msg(MSGT_TV, MSGL_INFO, "Found existing channel: %s-%s.\n",
 150                 tv_channel_tmp->number,tv_channel_tmp->name);
 151     }
 152     scan->channel_num++;
 153     scan->scan_timer=now+1e6*tvh->tv_param->scan_period;
 154     if (scan->channel_num>=chanlists[tvh->chanlist].count) {
 155         tvh->tv_param->scan=0;
 156         mp_msg(MSGT_TV, MSGL_INFO, "TV scan end. Found %d new channels.\n", scan->new_channels);
 157         tv_channel_tmp=tv_channel_list;
 158         if(tv_channel_tmp){
 159             mp_msg(MSGT_TV,MSGL_INFO,"channels=");
 160             while(tv_channel_tmp){
 161                 mp_msg(MSGT_TV,MSGL_INFO,"%s-%s",tv_channel_tmp->number,tv_channel_tmp->name);
 162                 if(tv_channel_tmp->next)
 163                     mp_msg(MSGT_TV,MSGL_INFO,",");
 164                 tv_channel_tmp=tv_channel_tmp->next;
 165             }
 166             mp_msg(MSGT_TV, MSGL_INFO, "\n");
 167         }
 168         if (!tv_channel_current) tv_channel_current=tv_channel_list;
 169         if (tv_channel_current)
 170             tv_set_freq(tvh, (unsigned long)(((float)tv_channel_current->freq/1000)*16));
 171         free(tvh->scan);
 172         tvh->scan=NULL;
 173     }else{
 174         cl = tvh->chanlist_s[scan->channel_num];
 175         tv_set_freq(tvh, (unsigned long)(((float)cl.freq/1000)*16));
 176         mp_msg(MSGT_TV, MSGL_INFO, "Trying: %s (%.2f). \n",cl.name,1e-3*cl.freq);
 177     }
 178 }
 179
 180 /* ================== DEMUX_TV ===================== */
 181 /*
 182   Return value:
 183     0 = EOF(?) or no stream
 184     1 = successfully read a packet
 185 */
 186 /* fill demux->video and demux->audio */
 187
 188 static int demux_tv_fill_buffer(demuxer_t *demux, demux_stream_t *ds)
 189 {
 190     tvi_handle_t *tvh=(tvi_handle_t*)(demux->priv);
 191     demux_packet_t* dp;
 192     unsigned int len=0;
 193
 194     /* ================== ADD AUDIO PACKET =================== */
 195
 196     if (ds==demux->audio && tvh->tv_param->noaudio == 0 &&
 197         tvh->functions->control(tvh->priv,
 198                                 TVI_CONTROL_IS_AUDIO, 0) == TVI_CONTROL_TRUE)
 199         {
 200         len = tvh->functions->get_audio_framesize(tvh->priv);
 201
 202         dp=new_demux_packet(len);
 203         dp->flags|=1; /* Keyframe */
 204         dp->pts=tvh->functions->grab_audio_frame(tvh->priv, dp->buffer,len);
 205         ds_add_packet(demux->audio,dp);
 206         }
 207
 208     /* ================== ADD VIDEO PACKET =================== */
 209
 210     if (ds==demux->video && tvh->functions->control(tvh->priv,
 211                             TVI_CONTROL_IS_VIDEO, 0) == TVI_CONTROL_TRUE)
 212         {
 213                 len = tvh->functions->get_video_framesize(tvh->priv);
 214         dp=new_demux_packet(len);
 215                 dp->flags|=1; /* Keyframe */
 216                 dp->pts=tvh->functions->grab_video_frame(tvh->priv, dp->buffer, len);
 217                 ds_add_packet(demux->video,dp);
 218          }
 219
 220     if (tvh->tv_param->scan) tv_scan(tvh);
 221     return 1;
 222 }
 223
 224 static int norm_from_string(tvi_handle_t *tvh, char* norm)
 225 {
 226     const tvi_functions_t *funcs = tvh->functions;
 227     char str[20];
 228     int ret;
 229
 230     strncpy(str, norm, sizeof(str)-1);
 231     str[sizeof(str)-1] = '\0';
 232     ret=funcs->control(tvh->priv, TVI_CONTROL_SPC_GET_NORMID, str);
 233
 234     if(ret==TVI_CONTROL_TRUE)
 235         return *(int *)str;
 236
 237     if(ret!=TVI_CONTROL_UNKNOWN)
 238     {
 239         mp_msg(MSGT_TV, MSGL_WARN, MSGTR_TV_BogusNormParameter, norm,"default");
 240         return 0;
 241     }
 242
 243     if (!strcasecmp(norm, "pal"))
 244         return TV_NORM_PAL;
 245     else if (!strcasecmp(norm, "ntsc"))
 246         return TV_NORM_NTSC;
 247     else if (!strcasecmp(norm, "secam"))
 248         return TV_NORM_SECAM;
 249     else if (!strcasecmp(norm, "palnc"))
 250         return TV_NORM_PALNC;
 251     else if (!strcasecmp(norm, "palm"))
 252         return TV_NORM_PALM;
 253     else if (!strcasecmp(norm, "paln"))
 254         return TV_NORM_PALN;
 255     else if (!strcasecmp(norm, "ntscjp"))
 256         return TV_NORM_NTSCJP;
 257     else {
 258         mp_msg(MSGT_TV, MSGL_WARN, MSGTR_TV_BogusNormParameter, norm, "PAL");
 259         return TV_NORM_PAL;
 260     }
 261 }
 262
 263 static void parse_channels(tvi_handle_t *tvh)
 264 {
 265     char** channels = tvh->tv_param->channels;
 266
 267     mp_msg(MSGT_TV, MSGL_INFO, MSGTR_TV_ChannelNamesDetected);
 268     tv_channel_list = malloc(sizeof(tv_channels_t));
 269     tv_channel_list->index=1;
 270     tv_channel_list->next=NULL;
 271     tv_channel_list->prev=NULL;
 272     tv_channel_current = tv_channel_list;
 273     tv_channel_current->norm = tvh->norm;
 274
 275     while (*channels) {
 276         char* tmp = *(channels++);
 277         char* sep = strchr(tmp,'-');
 278         int i;
 279         struct CHANLIST cl;
 280
 281         if (!sep) continue; // Wrong syntax, but mplayer should not crash
 282
 283         av_strlcpy(tv_channel_current->name, sep + 1,
 284                         sizeof(tv_channel_current->name));
 285         sep[0] = '\0';
 286         strncpy(tv_channel_current->number, tmp, 5);
 287         tv_channel_current->number[4]='\0';
 288
 289         while ((sep=strchr(tv_channel_current->name, '_')))
 290             sep[0] = ' ';
 291
 292         // if channel number is a number and larger than 1000 threat it as frequency
 293         // tmp still contain pointer to null-terminated string with channel number here
 294         if (atoi(tmp)>1000){
 295             tv_channel_current->freq=atoi(tmp);
 296         }else{
 297             tv_channel_current->freq = 0;
 298             for (i = 0; i < chanlists[tvh->chanlist].count; i++) {
 299                 cl = tvh->chanlist_s[i];
 300                 if (!strcasecmp(cl.name, tv_channel_current->number)) {
 301                     tv_channel_current->freq=cl.freq;
 302                     break;
 303                 }
 304             }
 305         }
 306         if (tv_channel_current->freq == 0)
 307             mp_msg(MSGT_TV, MSGL_ERR, MSGTR_TV_NoFreqForChannel,
 308                             tv_channel_current->number, tv_channel_current->name);
 309         else {
 310           sep = strchr(tv_channel_current->name, '-');
 311           if ( !sep ) sep = strchr(tv_channel_current->name, '+');
 312
 313           if ( sep ) {
 314             i = atoi (sep+1);
 315             if ( sep[0] == '+' ) tv_channel_current->freq += i * 100;
 316             if ( sep[0] == '-' ) tv_channel_current->freq -= i * 100;
 317             sep[0] = '\0';
 318           }
 319
 320           sep = strchr(tv_channel_current->name, '=');
 321           if ( sep ) {
 322             tv_channel_current->norm = norm_from_string(tvh, sep+1);
 323             sep[0] = '\0';
 324           }
 325         }
 326
 327         /*mp_msg(MSGT_TV, MSGL_INFO, "-- Detected channel %s - %s (%5.3f)\n",
 328                         tv_channel_current->number, tv_channel_current->name,
 329                         (float)tv_channel_current->freq/1000);*/
 330
 331         tv_channel_current->next = malloc(sizeof(tv_channels_t));
 332         tv_channel_current->next->index = tv_channel_current->index + 1;
 333         tv_channel_current->next->prev = tv_channel_current;
 334         tv_channel_current->next->next = NULL;
 335         tv_channel_current = tv_channel_current->next;
 336         tv_channel_current->norm = tvh->norm;
 337     }
 338     if (tv_channel_current->prev)
 339         tv_channel_current->prev->next = NULL;
 340     free(tv_channel_current);
 341 }
 342
 343 int tv_set_norm(tvi_handle_t *tvh, char* norm)
 344 {
 345     tvh->norm = norm_from_string(tvh, norm);
 346
 347     mp_msg(MSGT_TV, MSGL_V, MSGTR_TV_SelectedNorm, norm);
 348     if (tvh->functions->control(tvh->priv, TVI_CONTROL_TUN_SET_NORM, &tvh->norm) != TVI_CONTROL_TRUE) {
 349         mp_msg(MSGT_TV, MSGL_ERR, MSGTR_TV_CannotSetNorm);
 350         return 0;
 351     }
 352     teletext_control(tvh->demuxer->teletext,TV_VBI_CONTROL_RESET,
 353                      &tvh->tv_param->teletext);
 354     return 1;
 355 }
 356
 357 static int tv_set_norm_i(tvi_handle_t *tvh, int norm)
 358 {
 359    tvh->norm = norm;
 360
 361    mp_msg(MSGT_TV, MSGL_V, MSGTR_TV_SelectedNormId, norm);
 362    if (tvh->functions->control(tvh->priv, TVI_CONTROL_TUN_SET_NORM, &tvh->norm) != TVI_CONTROL_TRUE) {
 363       mp_msg(MSGT_TV, MSGL_ERR, MSGTR_TV_CannotSetNorm);
 364       return 0;
 365    }
 366
 367    teletext_control(tvh->demuxer->teletext,TV_VBI_CONTROL_RESET,
 368                     &tvh->tv_param->teletext);
 369    return 1;
 370 }
 371
 372 static int open_tv(tvi_handle_t *tvh)
 373 {
 374     int i;
 375     const tvi_functions_t *funcs = tvh->functions;
 376     int tv_fmt_list[] = {
 377       IMGFMT_YV12,
 378       IMGFMT_I420,
 379       IMGFMT_UYVY,
 380       IMGFMT_YUY2,
 381       IMGFMT_RGB32,
 382       IMGFMT_RGB24,
 383       IMGFMT_RGB16,
 384       IMGFMT_RGB15
 385     };
 386
 387     if (funcs->control(tvh->priv, TVI_CONTROL_IS_VIDEO, 0) != TVI_CONTROL_TRUE)
 388     {
 389         mp_msg(MSGT_TV, MSGL_ERR, MSGTR_TV_NoVideoInputPresent);
 390         return 0;
 391     }
 392
 393     if (tvh->tv_param->outfmt == -1)
 394       for (i = 0; i < sizeof (tv_fmt_list) / sizeof (*tv_fmt_list); i++)
 395         {
 396           tvh->tv_param->outfmt = tv_fmt_list[i];
 397           if (funcs->control (tvh->priv, TVI_CONTROL_VID_SET_FORMAT,
 398                               &tvh->tv_param->outfmt) == TVI_CONTROL_TRUE)
 399             break;
 400         }
 401     else
 402     {
 403     switch(tvh->tv_param->outfmt)
 404     {
 405         case IMGFMT_YV12:
 406         case IMGFMT_I420:
 407         case IMGFMT_UYVY:
 408         case IMGFMT_YUY2:
 409         case IMGFMT_RGB32:
 410         case IMGFMT_RGB24:
 411         case IMGFMT_BGR32:
 412         case IMGFMT_BGR24:
 413         case IMGFMT_BGR16:
 414         case IMGFMT_BGR15:
 415             break;
 416         default:
 417             mp_msg(MSGT_TV, MSGL_ERR, MSGTR_TV_UnknownImageFormat,tvh->tv_param->outfmt);
 418     }
 419     funcs->control(tvh->priv, TVI_CONTROL_VID_SET_FORMAT, &tvh->tv_param->outfmt);
 420     }
 421
 422     /* set some params got from cmdline */
 423     funcs->control(tvh->priv, TVI_CONTROL_SPC_SET_INPUT, &tvh->tv_param->input);
 424
 425 #if defined(CONFIG_TV_V4L2) || defined(CONFIG_TV_DSHOW)
 426     if (0
 427 #ifdef CONFIG_TV_V4L2
 428     || (!strcmp(tvh->tv_param->driver, "v4l2") && tvh->tv_param->normid >= 0)
 429 #endif
 430 #ifdef CONFIG_TV_DSHOW
 431     || (!strcmp(tvh->tv_param->driver, "dshow") && tvh->tv_param->normid >= 0)
 432 #endif
 433     )
 434         tv_set_norm_i(tvh, tvh->tv_param->normid);
 435     else
 436 #endif
 437     tv_set_norm(tvh,tvh->tv_param->norm);
 438
 439 #ifdef CONFIG_TV_V4L1
 440     if ( tvh->tv_param->mjpeg )
 441     {
 442       /* set width to expected value */
 443       if (tvh->tv_param->width == -1)
 444         {
 445           tvh->tv_param->width = 704/tvh->tv_param->decimation;
 446         }
 447       if (tvh->tv_param->height == -1)
 448         {
 449           if ( tvh->norm != TV_NORM_NTSC )
 450             tvh->tv_param->height = 576/tvh->tv_param->decimation;
 451           else
 452             tvh->tv_param->height = 480/tvh->tv_param->decimation;
 453         }
 454       mp_msg(MSGT_TV, MSGL_INFO,
 455                MSGTR_TV_MJP_WidthHeight, tvh->tv_param->width, tvh->tv_param->height);
 456     }
 457 #endif
 458
 459     /* limits on w&h are norm-dependent -- JM */
 460     if (tvh->tv_param->width != -1 && tvh->tv_param->height != -1) {
 461         // first tell the driver both width and height, some drivers do not support setting them independently.
 462         int dim[2];
 463         dim[0] = tvh->tv_param->width; dim[1] = tvh->tv_param->height;
 464         funcs->control(tvh->priv, TVI_CONTROL_VID_SET_WIDTH_HEIGHT, dim);
 465     }
 466     /* set width */
 467     if (tvh->tv_param->width != -1)
 468     {
 469         if (funcs->control(tvh->priv, TVI_CONTROL_VID_CHK_WIDTH, &tvh->tv_param->width) == TVI_CONTROL_TRUE)
 470             funcs->control(tvh->priv, TVI_CONTROL_VID_SET_WIDTH, &tvh->tv_param->width);
 471         else
 472         {
 473             mp_msg(MSGT_TV, MSGL_ERR, MSGTR_TV_UnableToSetWidth, tvh->tv_param->width);
 474             funcs->control(tvh->priv, TVI_CONTROL_VID_GET_WIDTH, &tvh->tv_param->width);
 475         }
 476     }
 477
 478     /* set height */
 479     if (tvh->tv_param->height != -1)
 480     {
 481         if (funcs->control(tvh->priv, TVI_CONTROL_VID_CHK_HEIGHT, &tvh->tv_param->height) == TVI_CONTROL_TRUE)
 482             funcs->control(tvh->priv, TVI_CONTROL_VID_SET_HEIGHT, &tvh->tv_param->height);
 483         else
 484         {
 485             mp_msg(MSGT_TV, MSGL_ERR, MSGTR_TV_UnableToSetHeight, tvh->tv_param->height);
 486             funcs->control(tvh->priv, TVI_CONTROL_VID_GET_HEIGHT, &tvh->tv_param->height);
 487         }
 488     }
 489
 490     if (funcs->control(tvh->priv, TVI_CONTROL_IS_TUNER, 0) != TVI_CONTROL_TRUE)
 491     {
 492         mp_msg(MSGT_TV, MSGL_WARN, MSGTR_TV_NoTuner);
 493         goto done;
 494     }
 495
 496     /* select channel list */
 497     for (i = 0; chanlists[i].name != NULL; i++)
 498     {
 499         if (!strcasecmp(chanlists[i].name, tvh->tv_param->chanlist))
 500         {
 501             tvh->chanlist = i;
 502             tvh->chanlist_s = chanlists[i].list;
 503             break;
 504         }
 505     }
 506
 507     if (tvh->chanlist == -1)
 508         mp_msg(MSGT_TV, MSGL_WARN, MSGTR_TV_UnableFindChanlist,
 509             tvh->tv_param->chanlist);
 510     else
 511         mp_msg(MSGT_TV, MSGL_V, MSGTR_TV_SelectedChanlist,
 512             chanlists[tvh->chanlist].name, chanlists[tvh->chanlist].count);
 513
 514     if (tvh->tv_param->freq && tvh->tv_param->channel)
 515     {
 516         mp_msg(MSGT_TV, MSGL_WARN, MSGTR_TV_ChannelFreqParamConflict);
 517         goto done;
 518     }
 519
 520     /* Handle channel names */
 521     if (tvh->tv_param->channels) {
 522         parse_channels(tvh);
 523     } else
 524             tv_channel_last_real = malloc(5);
 525
 526     if (tv_channel_list) {
 527         int i;
 528         int channel = 0;
 529         if (tvh->tv_param->channel)
 530          {
 531            if (isdigit(*tvh->tv_param->channel))
 532                 /* if tvh->tv_param->channel begins with a digit interpret it as a number */
 533                 channel = atoi(tvh->tv_param->channel);
 534            else
 535               {
 536                 /* if tvh->tv_param->channel does not begin with a digit
 537                    set the first channel that contains tvh->tv_param->channel in its name */
 538
 539                 tv_channel_current = tv_channel_list;
 540                 while ( tv_channel_current ) {
 541                         if ( strstr(tv_channel_current->name, tvh->tv_param->channel) )
 542                           break;
 543                         tv_channel_current = tv_channel_current->next;
 544                         }
 545                 if ( !tv_channel_current ) tv_channel_current = tv_channel_list;
 546               }
 547          }
 548         else
 549                 channel = 1;
 550
 551         if ( channel ) {
 552         tv_channel_current = tv_channel_list;
 553         for (i = 1; i < channel; i++)
 554                 if (tv_channel_current->next)
 555                         tv_channel_current = tv_channel_current->next;
 556         }
 557
 558         mp_msg(MSGT_TV, MSGL_INFO, MSGTR_TV_SelectedChannel3, tv_channel_current->number,
 559                         tv_channel_current->name, (float)tv_channel_current->freq/1000);
 560         tv_set_norm_i(tvh, tv_channel_current->norm);
 561         tv_set_freq(tvh, (unsigned long)(((float)tv_channel_current->freq/1000)*16));
 562         tv_channel_last = tv_channel_current;
 563     } else {
 564     /* we need to set frequency */
 565     if (tvh->tv_param->freq)
 566     {
 567         unsigned long freq = atof(tvh->tv_param->freq)*16;
 568
 569         /* set freq in MHz */
 570         funcs->control(tvh->priv, TVI_CONTROL_TUN_SET_FREQ, &freq);
 571
 572         funcs->control(tvh->priv, TVI_CONTROL_TUN_GET_FREQ, &freq);
 573         mp_msg(MSGT_TV, MSGL_V, MSGTR_TV_SelectedFrequency,
 574             freq, (float)freq/16);
 575     }
 576
 577             if (tvh->tv_param->channel) {
 578         struct CHANLIST cl;
 579
 580         mp_msg(MSGT_TV, MSGL_V, MSGTR_TV_RequestedChannel, tvh->tv_param->channel);
 581         for (i = 0; i < chanlists[tvh->chanlist].count; i++)
 582         {
 583             cl = tvh->chanlist_s[i];
 584                     //  printf("count%d: name: %s, freq: %d\n",
 585                     //  i, cl.name, cl.freq);
 586             if (!strcasecmp(cl.name, tvh->tv_param->channel))
 587             {
 588                         strcpy(tv_channel_last_real, cl.name);
 589                 tvh->channel = i;
 590                 mp_msg(MSGT_TV, MSGL_INFO, MSGTR_TV_SelectedChannel2,
 591                     cl.name, (float)cl.freq/1000);
 592                 tv_set_freq(tvh, (unsigned long)(((float)cl.freq/1000)*16));
 593                 break;
 594             }
 595         }
 596     }
 597     }
 598
 599     /* grep frequency in chanlist */
 600     {
 601         unsigned long i2;
 602         int freq;
 603
 604         tv_get_freq(tvh, &i2);
 605
 606         freq = (int) (((float)(i2/16))*1000)+250;
 607
 608         for (i = 0; i < chanlists[tvh->chanlist].count; i++)
 609         {
 610             if (tvh->chanlist_s[i].freq == freq)
 611             {
 612                 tvh->channel = i+1;
 613                 break;
 614             }
 615         }
 616     }
 617
 618 done:
 619     /* also start device! */
 620         return 1;
 621 }
 622
 623 static tvi_handle_t *tv_begin(tv_param_t* tv_param)
 624 {
 625     int i;
 626     tvi_handle_t* h;
 627     if(tv_param->driver && !strcmp(tv_param->driver,"help")){
 628         mp_msg(MSGT_TV,MSGL_INFO,MSGTR_TV_AvailableDrivers);
 629         for(i=0;tvi_driver_list[i];i++){
 630             mp_msg(MSGT_TV,MSGL_INFO," %s\t%s",tvi_driver_list[i]->short_name,tvi_driver_list[i]->name);
 631             if(tvi_driver_list[i]->comment)
 632                 mp_msg(MSGT_TV,MSGL_INFO," (%s)",tvi_driver_list[i]->comment);
 633             mp_msg(MSGT_TV,MSGL_INFO,"\n");
 634         }
 635         return NULL;
 636     }
 637
 638     for(i=0;tvi_driver_list[i];i++){
 639         if (!tv_param->driver || !strcmp(tvi_driver_list[i]->short_name, tv_param->driver)){
 640             h=tvi_driver_list[i]->tvi_init(tv_param);
 641             //Requested driver initialization failed
 642             if (!h && tv_param->driver)
 643                 return NULL;
 644             //Driver initialization failed during autodetection process.
 645             if (!h)
 646                 continue;
 647
 648             h->tv_param=tv_param;
 649             mp_msg(MSGT_TV, MSGL_INFO, MSGTR_TV_DriverInfo, tvi_driver_list[i]->short_name,
 650             tvi_driver_list[i]->name,
 651             tvi_driver_list[i]->author,
 652             tvi_driver_list[i]->comment?tvi_driver_list[i]->comment:"");
 653             tv_param->driver=strdup(tvi_driver_list[i]->short_name);
 654             return h;
 655         }
 656     }
 657
 658     if(tv_param->driver)
 659         mp_msg(MSGT_TV, MSGL_ERR, MSGTR_TV_NoSuchDriver, tv_param->driver);
 660     else
 661         mp_msg(MSGT_TV, MSGL_ERR, MSGTR_TV_DriverAutoDetectionFailed);
 662     return NULL;
 663 }
 664
 665 static int tv_uninit(tvi_handle_t *tvh)
 666 {
 667     int res;
 668     if(!tvh) return 1;
 669     if (!tvh->priv) return 1;
 670     res=tvh->functions->uninit(tvh->priv);
 671     if(res) {
 672         free(tvh->priv);
 673         tvh->priv=NULL;
 674     }
 675     return res;
 676 }
 677
 678 static demuxer_t* demux_open_tv(demuxer_t *demuxer)
 679 {
 680     tvi_handle_t *tvh;
 681     sh_video_t *sh_video;
 682     sh_audio_t *sh_audio = NULL;
 683     const tvi_functions_t *funcs;
 684
 685     demuxer->priv=NULL;
 686     if(!(tvh=tv_begin(demuxer->stream->priv))) return NULL;
 687     if (!tvh->functions->init(tvh->priv)) return NULL;
 688
 689     tvh->demuxer = demuxer;
 690     tvh->functions->control(tvh->priv,TVI_CONTROL_VBI_INIT,
 691                             &(tvh->tv_param->teletext.device));
 692     tvh->functions->control(tvh->priv,TVI_CONTROL_GET_VBI_PTR,
 693                             &demuxer->teletext);
 694
 695     if (!open_tv(tvh)){
 696         tv_uninit(tvh);
 697         return NULL;
 698     }
 699     funcs = tvh->functions;
 700     demuxer->priv=tvh;
 701
 702     sh_video = new_sh_video(demuxer, 0);
 703
 704     /* get IMAGE FORMAT */
 705     funcs->control(tvh->priv, TVI_CONTROL_VID_GET_FORMAT, &sh_video->format);
 706 //    if (IMGFMT_IS_RGB(sh_video->format) || IMGFMT_IS_BGR(sh_video->format))
 707 //      sh_video->format = 0x0;
 708
 709     /* set FPS and FRAMETIME */
 710
 711     if(!sh_video->fps)
 712     {
 713         float tmp;
 714         if (funcs->control(tvh->priv, TVI_CONTROL_VID_GET_FPS, &tmp) != TVI_CONTROL_TRUE)
 715              sh_video->fps = 25.0f; /* on PAL */
 716         else sh_video->fps = tmp;
 717     }
 718
 719     if (tvh->tv_param->fps != -1.0f)
 720         sh_video->fps = tvh->tv_param->fps;
 721
 722     sh_video->frametime = 1.0f/sh_video->fps;
 723
 724     /* If playback only mode, go to immediate mode, fail silently */
 725     if(tvh->tv_param->immediate == 1)
 726         {
 727         funcs->control(tvh->priv, TVI_CONTROL_IMMEDIATE, 0);
 728         tvh->tv_param->noaudio = 1;
 729         }
 730
 731     /* disable TV audio if -nosound is present */
 732     if (!demuxer->audio || demuxer->audio->id == -2) {
 733         tvh->tv_param->noaudio = 1;
 734     }
 735
 736     /* set width */
 737     funcs->control(tvh->priv, TVI_CONTROL_VID_GET_WIDTH, &sh_video->disp_w);
 738
 739     /* set height */
 740     funcs->control(tvh->priv, TVI_CONTROL_VID_GET_HEIGHT, &sh_video->disp_h);
 741
 742     demuxer->video->sh = sh_video;
 743     sh_video->ds = demuxer->video;
 744     demuxer->video->id = 0;
 745     demuxer->seekable = 0;
 746
 747     /* here comes audio init */
 748     if (tvh->tv_param->noaudio == 0 && funcs->control(tvh->priv, TVI_CONTROL_IS_AUDIO, 0) == TVI_CONTROL_TRUE)
 749     {
 750         int audio_format;
 751         int sh_audio_format;
 752         char buf[128];
 753
 754         /* yeah, audio is present */
 755
 756         funcs->control(tvh->priv, TVI_CONTROL_AUD_SET_SAMPLERATE,
 757                                   &tvh->tv_param->audiorate);
 758
 759         if (funcs->control(tvh->priv, TVI_CONTROL_AUD_GET_FORMAT, &audio_format) != TVI_CONTROL_TRUE)
 760             goto no_audio;
 761
 762         switch(audio_format)
 763         {
 764             case AF_FORMAT_U8:
 765             case AF_FORMAT_S8:
 766             case AF_FORMAT_U16_LE:
 767             case AF_FORMAT_U16_BE:
 768             case AF_FORMAT_S16_LE:
 769             case AF_FORMAT_S16_BE:
 770             case AF_FORMAT_S32_LE:
 771             case AF_FORMAT_S32_BE:
 772                 sh_audio_format = 0x1; /* PCM */
 773                 break;
 774             case AF_FORMAT_IMA_ADPCM:
 775             case AF_FORMAT_MU_LAW:
 776             case AF_FORMAT_A_LAW:
 777             case AF_FORMAT_MPEG2:
 778             default:
 779                 mp_msg(MSGT_TV, MSGL_ERR, MSGTR_TV_UnsupportedAudioType,
 780                     af_fmt2str(audio_format, buf, 128), audio_format);
 781                 goto no_audio;
 782         }
 783
 784         sh_audio = new_sh_audio(demuxer, 0);
 785
 786         funcs->control(tvh->priv, TVI_CONTROL_AUD_GET_SAMPLERATE,
 787                    &sh_audio->samplerate);
 788         funcs->control(tvh->priv, TVI_CONTROL_AUD_GET_SAMPLESIZE,
 789                    &sh_audio->samplesize);
 790         funcs->control(tvh->priv, TVI_CONTROL_AUD_GET_CHANNELS,
 791                    &sh_audio->channels);
 792
 793         sh_audio->format = sh_audio_format;
 794         sh_audio->sample_format = audio_format;
 795
 796         sh_audio->i_bps = sh_audio->o_bps =
 797             sh_audio->samplerate * sh_audio->samplesize *
 798             sh_audio->channels;
 799
 800         // emulate WF for win32 codecs:
 801         sh_audio->wf = malloc(sizeof(WAVEFORMATEX));
 802         sh_audio->wf->wFormatTag = sh_audio->format;
 803         sh_audio->wf->nChannels = sh_audio->channels;
 804         sh_audio->wf->wBitsPerSample = sh_audio->samplesize * 8;
 805         sh_audio->wf->nSamplesPerSec = sh_audio->samplerate;
 806         sh_audio->wf->nBlockAlign = sh_audio->samplesize * sh_audio->channels;
 807         sh_audio->wf->nAvgBytesPerSec = sh_audio->i_bps;
 808
 809         mp_msg(MSGT_DECVIDEO, MSGL_V, MSGTR_TV_AudioFormat,
 810           sh_audio->wf->nChannels, sh_audio->wf->wBitsPerSample,
 811           sh_audio->wf->nSamplesPerSec);
 812
 813         demuxer->audio->sh = sh_audio;
 814         sh_audio->ds = demuxer->audio;
 815         demuxer->audio->id = 0;
 816     }
 817 no_audio:
 818
 819     if(!(funcs->start(tvh->priv))){
 820         // start failed :(
 821         tv_uninit(tvh);
 822         return NULL;
 823     }
 824
 825     /* set color eq */
 826     tv_set_color_options(tvh, TV_COLOR_BRIGHTNESS, tvh->tv_param->brightness);
 827     tv_set_color_options(tvh, TV_COLOR_HUE, tvh->tv_param->hue);
 828     tv_set_color_options(tvh, TV_COLOR_SATURATION, tvh->tv_param->saturation);
 829     tv_set_color_options(tvh, TV_COLOR_CONTRAST, tvh->tv_param->contrast);
 830
 831     if(tvh->tv_param->gain!=-1)
 832         if(funcs->control(tvh->priv,TVI_CONTROL_VID_SET_GAIN,&tvh->tv_param->gain)!=TVI_CONTROL_TRUE)
 833             mp_msg(MSGT_TV,MSGL_WARN,"Unable to set gain control!\n");
 834
 835     teletext_control(demuxer->teletext,TV_VBI_CONTROL_RESET,
 836                      &tvh->tv_param->teletext);
 837
 838     return demuxer;
 839 }
 840
 841 static void demux_close_tv(demuxer_t *demuxer)
 842 {
 843     tvi_handle_t *tvh=(tvi_handle_t*)(demuxer->priv);
 844     if (!tvh) return;
 845     tv_uninit(tvh);
 846     free(tvh);
 847     demuxer->priv=NULL;
 848     demuxer->teletext=NULL;
 849 }
 850
 851 /* utilities for mplayer (not mencoder!!) */
 852 int tv_set_color_options(tvi_handle_t *tvh, int opt, int value)
 853 {
 854     const tvi_functions_t *funcs = tvh->functions;
 855
 856     switch(opt)
 857     {
 858         case TV_COLOR_BRIGHTNESS:
 859             return funcs->control(tvh->priv, TVI_CONTROL_VID_SET_BRIGHTNESS, &value);
 860         case TV_COLOR_HUE:
 861             return funcs->control(tvh->priv, TVI_CONTROL_VID_SET_HUE, &value);
 862         case TV_COLOR_SATURATION:
 863             return funcs->control(tvh->priv, TVI_CONTROL_VID_SET_SATURATION, &value);
 864         case TV_COLOR_CONTRAST:
 865             return funcs->control(tvh->priv, TVI_CONTROL_VID_SET_CONTRAST, &value);
 866         default:
 867             mp_msg(MSGT_TV, MSGL_WARN, MSGTR_TV_UnknownColorOption, opt);
 868     }
 869
 870     return TVI_CONTROL_UNKNOWN;
 871 }
 872
 873 int tv_get_color_options(tvi_handle_t *tvh, int opt, int* value)
 874 {
 875     const tvi_functions_t *funcs = tvh->functions;
 876
 877     switch(opt)
 878     {
 879         case TV_COLOR_BRIGHTNESS:
 880             return funcs->control(tvh->priv, TVI_CONTROL_VID_GET_BRIGHTNESS, value);
 881         case TV_COLOR_HUE:
 882             return funcs->control(tvh->priv, TVI_CONTROL_VID_GET_HUE, value);
 883         case TV_COLOR_SATURATION:
 884             return funcs->control(tvh->priv, TVI_CONTROL_VID_GET_SATURATION, value);
 885         case TV_COLOR_CONTRAST:
 886             return funcs->control(tvh->priv, TVI_CONTROL_VID_GET_CONTRAST, value);
 887         default:
 888             mp_msg(MSGT_TV, MSGL_WARN, MSGTR_TV_UnknownColorOption, opt);
 889     }
 890
 891     return TVI_CONTROL_UNKNOWN;
 892 }
 893
 894 int tv_get_freq(tvi_handle_t *tvh, unsigned long *freq)
 895 {
 896     if (tvh->functions->control(tvh->priv, TVI_CONTROL_IS_TUNER, 0) == TVI_CONTROL_TRUE)
 897     {
 898         tvh->functions->control(tvh->priv, TVI_CONTROL_TUN_GET_FREQ, freq);
 899         mp_msg(MSGT_TV, MSGL_V, MSGTR_TV_CurrentFrequency,
 900             *freq, (float)*freq/16);
 901     }
 902     return 1;
 903 }
 904
 905 int tv_set_freq(tvi_handle_t *tvh, unsigned long freq)
 906 {
 907     if (tvh->functions->control(tvh->priv, TVI_CONTROL_IS_TUNER, 0) == TVI_CONTROL_TRUE)
 908     {
 909 //      unsigned long freq = atof(tvh->tv_param->freq)*16;
 910
 911         /* set freq in MHz */
 912         tvh->functions->control(tvh->priv, TVI_CONTROL_TUN_SET_FREQ, &freq);
 913
 914         tvh->functions->control(tvh->priv, TVI_CONTROL_TUN_GET_FREQ, &freq);
 915         mp_msg(MSGT_TV, MSGL_V, MSGTR_TV_CurrentFrequency,
 916             freq, (float)freq/16);
 917     }
 918     teletext_control(tvh->demuxer->teletext,TV_VBI_CONTROL_RESET,
 919                      &tvh->tv_param->teletext);
 920     return 1;
 921 }
 922
 923 int tv_get_signal(tvi_handle_t *tvh)
 924 {
 925     int signal=0;
 926     if (tvh->functions->control(tvh->priv, TVI_CONTROL_IS_TUNER, 0) != TVI_CONTROL_TRUE ||
 927         tvh->functions->control(tvh->priv, TVI_CONTROL_TUN_GET_SIGNAL, &signal)!=TVI_CONTROL_TRUE)
 928         return 0;
 929
 930     return signal;
 931 }
 932
 933 /*****************************************************************
 934  * \brief tune current frequency by step_interval value
 935  * \parameter step_interval increment value in 1/16 MHz
 936  * \note frequency is rounded to 1/16 MHz value
 937  * \return 1
 938  *
 939  */
 940 int tv_step_freq(tvi_handle_t* tvh, float step_interval){
 941     unsigned long frequency;
 942
 943     tvh->tv_param->scan=0;
 944     tv_get_freq(tvh,&frequency);
 945     frequency+=step_interval;
 946     return tv_set_freq(tvh,frequency);
 947 }
 948
 949 int tv_step_channel_real(tvi_handle_t *tvh, int direction)
 950 {
 951     struct CHANLIST cl;
 952
 953     tvh->tv_param->scan=0;
 954     if (direction == TV_CHANNEL_LOWER)
 955     {
 956         if (tvh->channel-1 >= 0)
 957         {
 958             strcpy(tv_channel_last_real, tvh->chanlist_s[tvh->channel].name);
 959             cl = tvh->chanlist_s[--tvh->channel];
 960             mp_msg(MSGT_TV, MSGL_INFO, MSGTR_TV_SelectedChannel2,
 961                 cl.name, (float)cl.freq/1000);
 962             tv_set_freq(tvh, (unsigned long)(((float)cl.freq/1000)*16));
 963         }
 964     }
 965
 966     if (direction == TV_CHANNEL_HIGHER)
 967     {
 968         if (tvh->channel+1 < chanlists[tvh->chanlist].count)
 969         {
 970             strcpy(tv_channel_last_real, tvh->chanlist_s[tvh->channel].name);
 971             cl = tvh->chanlist_s[++tvh->channel];
 972             mp_msg(MSGT_TV, MSGL_INFO, MSGTR_TV_SelectedChannel2,
 973                 cl.name, (float)cl.freq/1000);
 974             tv_set_freq(tvh, (unsigned long)(((float)cl.freq/1000)*16));
 975         }
 976     }
 977     return 1;
 978 }
 979
 980 int tv_step_channel(tvi_handle_t *tvh, int direction) {
 981         tvh->tv_param->scan=0;
 982         if (tv_channel_list) {
 983                 if (direction == TV_CHANNEL_HIGHER) {
 984                         tv_channel_last = tv_channel_current;
 985                         if (tv_channel_current->next)
 986                                 tv_channel_current = tv_channel_current->next;
 987                         else
 988                                 tv_channel_current = tv_channel_list;
 989
 990                                 tv_set_norm_i(tvh, tv_channel_current->norm);
 991                                 tv_set_freq(tvh, (unsigned long)(((float)tv_channel_current->freq/1000)*16));
 992                                 mp_msg(MSGT_TV, MSGL_INFO, MSGTR_TV_SelectedChannel3,
 993                         tv_channel_current->number, tv_channel_current->name, (float)tv_channel_current->freq/1000);
 994                 }
 995                 if (direction == TV_CHANNEL_LOWER) {
 996                         tv_channel_last = tv_channel_current;
 997                         if (tv_channel_current->prev)
 998                                 tv_channel_current = tv_channel_current->prev;
 999                         else
1000                                 while (tv_channel_current->next)
1001                                         tv_channel_current = tv_channel_current->next;
1002                                 tv_set_norm_i(tvh, tv_channel_current->norm);
1003                                 tv_set_freq(tvh, (unsigned long)(((float)tv_channel_current->freq/1000)*16));
1004                                 mp_msg(MSGT_TV, MSGL_INFO, MSGTR_TV_SelectedChannel3,
1005                         tv_channel_current->number, tv_channel_current->name, (float)tv_channel_current->freq/1000);
1006                 }
1007         } else tv_step_channel_real(tvh, direction);
1008         return 1;
1009 }
1010
1011 int tv_set_channel_real(tvi_handle_t *tvh, char *channel) {
1012         int i;
1013         struct CHANLIST cl;
1014
1015         tvh->tv_param->scan=0;
1016         strcpy(tv_channel_last_real, tvh->chanlist_s[tvh->channel].name);
1017         for (i = 0; i < chanlists[tvh->chanlist].count; i++)
1018         {
1019             cl = tvh->chanlist_s[i];
1020 //          printf("count%d: name: %s, freq: %d\n",
1021 //              i, cl.name, cl.freq);
1022             if (!strcasecmp(cl.name, channel))
1023             {
1024                 tvh->channel = i;
1025                 mp_msg(MSGT_TV, MSGL_INFO, MSGTR_TV_SelectedChannel2,
1026                     cl.name, (float)cl.freq/1000);
1027                 tv_set_freq(tvh, (unsigned long)(((float)cl.freq/1000)*16));
1028                 break;
1029             }
1030         }
1031         return 1;
1032 }
1033
1034 int tv_set_channel(tvi_handle_t *tvh, char *channel) {
1035         int i, channel_int;
1036
1037         tvh->tv_param->scan=0;
1038         if (tv_channel_list) {
1039                 tv_channel_last = tv_channel_current;
1040                 channel_int = atoi(channel);
1041                 tv_channel_current = tv_channel_list;
1042                 for (i = 1; i < channel_int; i++)
1043                         if (tv_channel_current->next)
1044                                 tv_channel_current = tv_channel_current->next;
1045                 mp_msg(MSGT_TV, MSGL_INFO, MSGTR_TV_SelectedChannel3, tv_channel_current->number,
1046                                 tv_channel_current->name, (float)tv_channel_current->freq/1000);
1047                 tv_set_norm_i(tvh, tv_channel_current->norm);
1048                 tv_set_freq(tvh, (unsigned long)(((float)tv_channel_current->freq/1000)*16));
1049         } else tv_set_channel_real(tvh, channel);
1050         return 1;
1051 }
1052
1053 int tv_last_channel(tvi_handle_t *tvh) {
1054
1055         tvh->tv_param->scan=0;
1056         if (tv_channel_list) {
1057                 tv_channels_t *tmp;
1058
1059                 tmp = tv_channel_last;
1060                 tv_channel_last = tv_channel_current;
1061                 tv_channel_current = tmp;
1062
1063                 mp_msg(MSGT_TV, MSGL_INFO, MSGTR_TV_SelectedChannel3, tv_channel_current->number,
1064                                 tv_channel_current->name, (float)tv_channel_current->freq/1000);
1065                 tv_set_norm_i(tvh, tv_channel_current->norm);
1066                 tv_set_freq(tvh, (unsigned long)(((float)tv_channel_current->freq/1000)*16));
1067         } else {
1068                 int i;
1069                 struct CHANLIST cl;
1070
1071                 for (i = 0; i < chanlists[tvh->chanlist].count; i++)
1072                 {
1073                     cl = tvh->chanlist_s[i];
1074                     if (!strcasecmp(cl.name, tv_channel_last_real))
1075                     {
1076                         strcpy(tv_channel_last_real, tvh->chanlist_s[tvh->channel].name);
1077                         tvh->channel = i;
1078                         mp_msg(MSGT_TV, MSGL_INFO, MSGTR_TV_SelectedChannel2,
1079                             cl.name, (float)cl.freq/1000);
1080                         tv_set_freq(tvh, (unsigned long)(((float)cl.freq/1000)*16));
1081                         break;
1082                     }
1083                 }
1084         }
1085         return 1;
1086 }
1087
1088 int tv_step_norm(tvi_handle_t *tvh)
1089 {
1090   tvh->norm++;
1091   if (tvh->functions->control(tvh->priv, TVI_CONTROL_TUN_SET_NORM,
1092                               &tvh->norm) != TVI_CONTROL_TRUE) {
1093     tvh->norm = 0;
1094     if (tvh->functions->control(tvh->priv, TVI_CONTROL_TUN_SET_NORM,
1095                                 &tvh->norm) != TVI_CONTROL_TRUE) {
1096       mp_msg(MSGT_TV, MSGL_ERR, MSGTR_TV_CannotSetNorm);
1097       return 0;
1098     }
1099   }
1100     teletext_control(tvh->demuxer->teletext,TV_VBI_CONTROL_RESET,
1101                      &tvh->tv_param->teletext);
1102     return 1;
1103 }
1104
1105 int tv_step_chanlist(tvi_handle_t *tvh)
1106 {
1107     return 1;
1108 }
1109
1110 demuxer_desc_t demuxer_desc_tv = {
1111   "Tv card demuxer",
1112   "tv",
1113   "TV",
1114   "Alex Beregszaszi, Charles R. Henrich",
1115   "?",
1116   DEMUXER_TYPE_TV,
1117   0, // no autodetect
1118   NULL,
1119   demux_tv_fill_buffer,
1120   demux_open_tv,
1121   demux_close_tv,
1122   NULL,
1123   NULL
1124 };