stream/tvi_bsdbt848.c

   1 /*
   2     (C)2002 Charles R. Henrich (henrich@msu.edu)
   3     *BSD (hopefully, requires working driver!) BrookTree capture support.
   4
   5     Still in (active) development!
   6
   7         v1.1    Mar 13 2002   Fully functional, need to move ring buffer to
   8                                                   the kernel driver.
   9     v1.0    Feb 19 2002   First Release, need to add support for changing
  10                             audio parameters.
  11 */
  12
  13 #include "config.h"
  14
  15 #define RINGSIZE 8
  16 #define FRAGSIZE 4096 /* (2^12 see SETFRAGSIZE below) */
  17
  18 #define TRUE  (1==1)
  19 #define FALSE (1==0)
  20
  21 #define PAL_WIDTH  768
  22 #define PAL_HEIGHT 576
  23 #define PAL_FPS    25
  24
  25 #define NTSC_WIDTH  640
  26 #define NTSC_HEIGHT 480
  27 #define NTSC_FPS    29.97
  28
  29 #include <stdio.h>
  30 #include <stdlib.h>
  31 #include <unistd.h>
  32 #include <fcntl.h>
  33 #include <sys/types.h>
  34 #include <sys/mman.h>
  35 #include <sys/filio.h>
  36 #include <sys/time.h>
  37 #include <signal.h>
  38 #include <string.h>
  39 #include <errno.h>
  40
  41 #include <sys/param.h>
  42 #ifdef USE_SUN_AUDIO
  43 #include <sys/audioio.h>
  44 #endif
  45
  46 #ifdef IOCTL_METEOR_H_NAME
  47 #include IOCTL_METEOR_H_NAME
  48 #endif
  49
  50 #ifdef IOCTL_BT848_H_NAME
  51 #include IOCTL_BT848_H_NAME
  52 #endif
  53
  54 #ifdef HAVE_SYS_SOUNDCARD_H
  55 #include <sys/soundcard.h>
  56 #else
  57 #ifdef HAVE_SOUNDCARD_H
  58 #include <soundcard.h>
  59 #else
  60 #include <machine/soundcard.h>
  61 #endif
  62 #endif
  63
  64 #include "libaf/af_format.h"
  65 #include "libmpcodecs/img_format.h"
  66 #include "tv.h"
  67 #include "help_mp.h"
  68 #include "mp_msg.h"
  69
  70 static tvi_handle_t *tvi_init_bsdbt848(tv_param_t* tv_param);
  71 /* information about this file */
  72 tvi_info_t tvi_info_bsdbt848 = {
  73     tvi_init_bsdbt848,
  74     "Brooktree848 Support",
  75     "bsdbt848",
  76     "Charles Henrich",
  77     "in development"
  78 };
  79
  80 typedef struct {
  81     int dirty;
  82     double timestamp;
  83     char *buf;
  84 } RBFRAME;
  85
  86 /* private data's */
  87 typedef struct {
  88
  89 /* Audio */
  90     char *dspdev;
  91     int dspready;
  92     int dspfd;
  93     int dspsamplesize;
  94     int dspstereo;
  95     int dspspeed;
  96     int dspfmt;
  97     int dspframesize;
  98     int dsprate;
  99     long long dspbytesread;
 100
 101 /* Video */
 102     char *btdev;
 103     int videoready;
 104     int btfd;
 105     int source;
 106     float maxfps;
 107     float fps;
 108     int iformat;
 109     int maxheight;
 110     int maxwidth;
 111     struct meteor_geomet geom;
 112     struct meteor_capframe capframe;
 113
 114 /* Frame Buffer */
 115
 116     int framebufsize;
 117     float timestamp;
 118     int curpaintframe;
 119     int curbufframe;
 120     unsigned char *livebuf;
 121     RBFRAME framebuf[RINGSIZE];
 122
 123 /* Inputs */
 124
 125     int input;
 126
 127 /* Tuner */
 128
 129     char *tunerdev;
 130     int tunerfd;
 131     int tunerready;
 132     u_long tunerfreq;
 133     struct bktr_chnlset cset;
 134
 135 /* Other */
 136
 137     int immediatemode;
 138     double starttime;
 139
 140     tv_param_t *tv_param;
 141 } priv_t;
 142
 143 #include "tvi_def.h"
 144
 145 static priv_t *G_private=NULL;
 146
 147 static int getinput(int innumber);
 148
 149 static void processframe(int signal)
 150 {
 151 struct timeval curtime;
 152
 153 if(G_private->immediatemode == TRUE) return;
 154
 155 gettimeofday(&curtime, NULL);
 156
 157 if(G_private->framebuf[G_private->curpaintframe].dirty == TRUE)
 158     {
 159     memcpy(G_private->framebuf[G_private->curpaintframe].buf,
 160             G_private->livebuf, G_private->framebufsize);
 161
 162     G_private->framebuf[G_private->curpaintframe].dirty = FALSE;
 163
 164     G_private->framebuf[G_private->curpaintframe].timestamp =
 165             curtime.tv_sec + curtime.tv_usec*.000001;
 166
 167     G_private->curpaintframe++;
 168
 169     if(G_private->curpaintframe >= RINGSIZE) G_private->curpaintframe = 0;
 170     }
 171
 172 return;
 173 }
 174
 175 /* handler creator - entry point ! */
 176 static tvi_handle_t *tvi_init_bsdbt848(tv_param_t* tv_param)
 177 {
 178     char* sep ;
 179     tvi_handle_t* tvh;
 180     priv_t* priv;
 181
 182     tvh=new_handle();
 183     if(!tvh)
 184         return NULL;
 185     priv=(priv_t*)tvh->priv;
 186     /*
 187     if user needs to specify both /dev/bktr<n> and /dev/tuner<n>
 188     it can do this with "-tv device=/dev/bktr1,/dev/tuner1"
 189     */
 190
 191     /* set video device name */
 192     if (!tv_param->device){
 193         priv->btdev = strdup("/dev/bktr0");
 194         priv->tunerdev = strdup("/dev/tuner0");
 195     }else{
 196         sep = strchr(tv_param->device,',');
 197         priv->btdev = strdup(tv_param->device);
 198         if(sep){
 199             // tuner device is also passed
 200             priv->tunerdev = strdup(sep+1);
 201             priv->btdev[sep - tv_param->device] = 0;
 202         }else{
 203             priv->tunerdev = strdup("/dev/tuner0");
 204         }
 205     }
 206
 207     /* set audio device name */
 208     if (!tv_param->adevice)
 209 #ifdef USE_SUN_AUDIO
 210         priv->dspdev = strdup("/dev/sound");
 211 #else
 212         priv->dspdev = strdup("/dev/dsp");
 213 #endif
 214     else
 215         priv->dspdev = strdup(tv_param->adevice);
 216
 217     priv->tv_param=tv_param;
 218     return tvh;
 219 }
 220
 221 static int control(priv_t *priv, int cmd, void *arg)
 222 {
 223     switch(cmd)
 224     {
 225
 226 /* Tuner Controls */
 227
 228     case TVI_CONTROL_IS_TUNER:
 229         if(priv->tunerready == FALSE) return TVI_CONTROL_FALSE;
 230         return(TVI_CONTROL_TRUE);
 231
 232     case TVI_CONTROL_TUN_GET_FREQ:
 233         {
 234         if(ioctl(priv->tunerfd, TVTUNER_GETFREQ, &priv->tunerfreq) < 0)
 235             {
 236             mp_msg(MSGT_TV, MSGL_ERR, MSGTR_TV_Bt848IoctlFailed, "TVTUNER_GETFREQ", strerror(errno));
 237             return(TVI_CONTROL_FALSE);
 238             }
 239
 240         *(int *)arg = priv->tunerfreq;
 241         return(TVI_CONTROL_TRUE);
 242         }
 243
 244     case TVI_CONTROL_TUN_SET_FREQ:
 245         {
 246         priv->tunerfreq = *(int *)arg;
 247
 248         if(ioctl(priv->tunerfd, TVTUNER_SETFREQ, &priv->tunerfreq) < 0)
 249             {
 250             mp_msg(MSGT_TV, MSGL_ERR, MSGTR_TV_Bt848IoctlFailed, "TVTUNER_SETFREQ", strerror(errno));
 251             return(0);
 252             }
 253
 254         return(TVI_CONTROL_TRUE);
 255         }
 256     case TVI_CONTROL_TUN_GET_SIGNAL:
 257         {
 258         int status;
 259         if(ioctl(priv->tunerfd, TVTUNER_GETSTATUS, &status) < 0)
 260             {
 261             mp_msg(MSGT_TV, MSGL_ERR, MSGTR_TV_Bt848IoctlFailed, "GETSTATUS", strerror(errno));
 262             return(0);
 263             }
 264         *(int*)arg=(status & 0x02)? 100 : 0;
 265         return (TVI_CONTROL_TRUE);
 266         }
 267
 268     case TVI_CONTROL_TUN_GET_TUNER:
 269     case TVI_CONTROL_TUN_SET_TUNER:
 270
 271 /* Inputs */
 272
 273     case TVI_CONTROL_SPC_GET_INPUT:
 274         {
 275         if(ioctl(priv->btfd, METEORGINPUT, &priv->input) < 0)
 276             {
 277             mp_msg(MSGT_TV, MSGL_ERR, MSGTR_TV_Bt848IoctlFailed, "METEORGINPUT", strerror(errno));
 278             return(TVI_CONTROL_FALSE);
 279             }
 280
 281         *(int *)arg = priv->input;
 282         return(TVI_CONTROL_TRUE);
 283         }
 284
 285     case TVI_CONTROL_SPC_SET_INPUT:
 286         {
 287         priv->input = getinput(*(int *)arg);
 288
 289         if(ioctl(priv->btfd, METEORSINPUT, &priv->input) < 0)
 290             {
 291             mp_msg(MSGT_TV, MSGL_ERR, MSGTR_TV_Bt848IoctlFailed, "METEORSINPUT", strerror(errno));
 292             return(0);
 293             }
 294
 295         return(TVI_CONTROL_TRUE);
 296         }
 297
 298 /* Audio Controls */
 299
 300     case TVI_CONTROL_IS_AUDIO:
 301         if(priv->dspready == FALSE) return TVI_CONTROL_FALSE;
 302         return(TVI_CONTROL_TRUE);
 303
 304     case TVI_CONTROL_AUD_GET_FORMAT:
 305         {
 306         *(int *)arg = AF_FORMAT_S16_LE;
 307         return(TVI_CONTROL_TRUE);
 308         }
 309     case TVI_CONTROL_AUD_GET_CHANNELS:
 310         {
 311         *(int *)arg = 2;
 312         return(TVI_CONTROL_TRUE);
 313         }
 314     case TVI_CONTROL_AUD_SET_SAMPLERATE:
 315         {
 316         int dspspeed = *(int *)arg;
 317
 318            if(ioctl(priv->dspfd, SNDCTL_DSP_SPEED, &dspspeed) == -1)
 319             {
 320             mp_msg(MSGT_TV, MSGL_ERR, MSGTR_TV_Bt848InvalidAudioRate, strerror(errno));
 321             return(TVI_CONTROL_FALSE);
 322             }
 323
 324         priv->dspspeed = dspspeed;
 325
 326         priv->dspframesize = priv->dspspeed*priv->dspsamplesize/8/
 327                                 priv->fps * (priv->dspstereo+1);
 328         priv->dsprate = priv->dspspeed * priv->dspsamplesize/8*
 329                                 (priv->dspstereo+1);
 330
 331         return(TVI_CONTROL_TRUE);
 332         }
 333     case TVI_CONTROL_AUD_GET_SAMPLERATE:
 334         {
 335         *(int *)arg = priv->dspspeed;
 336         return(TVI_CONTROL_TRUE);
 337         }
 338     case TVI_CONTROL_AUD_GET_SAMPLESIZE:
 339         {
 340         *(int *)arg = priv->dspsamplesize/8;
 341         return(TVI_CONTROL_TRUE);
 342         }
 343
 344 /* Video Controls */
 345
 346     case TVI_CONTROL_IS_VIDEO:
 347         if(priv->videoready == FALSE) return TVI_CONTROL_FALSE;
 348         return(TVI_CONTROL_TRUE);
 349
 350     case TVI_CONTROL_TUN_SET_NORM:
 351         {
 352         int req_mode = *(int *)arg;
 353         u_short tmp_fps;
 354
 355         priv->iformat = METEOR_FMT_AUTOMODE;
 356
 357         if(req_mode == TV_NORM_PAL)
 358             {
 359             priv->iformat = METEOR_FMT_PAL;
 360             priv->maxheight = PAL_HEIGHT;
 361             priv->maxwidth = PAL_WIDTH;
 362             priv->maxfps = PAL_FPS;
 363             priv->fps = PAL_FPS;
 364
 365             if(priv->fps > priv->maxfps) priv->fps = priv->maxfps;
 366
 367             if(priv->geom.rows > priv->maxheight)
 368                 {
 369                 priv->geom.rows = priv->maxheight;
 370                 }
 371
 372             if(priv->geom.columns > priv->maxwidth)
 373                 {
 374                 priv->geom.columns = priv->maxwidth;
 375                 }
 376             }
 377
 378         if(req_mode == TV_NORM_NTSC)
 379             {
 380             priv->iformat = METEOR_FMT_NTSC;
 381             priv->maxheight = NTSC_HEIGHT;
 382             priv->maxwidth = NTSC_WIDTH;
 383             priv->maxfps = NTSC_FPS;
 384             priv->fps = NTSC_FPS;
 385
 386             priv->dspframesize = priv->dspspeed*priv->dspsamplesize/8/
 387                                  priv->fps * (priv->dspstereo+1);
 388             priv->dsprate = priv->dspspeed * priv->dspsamplesize/8 *
 389                                 (priv->dspstereo+1);
 390
 391             if(priv->fps > priv->maxfps) priv->fps = priv->maxfps;
 392
 393             if(priv->geom.rows > priv->maxheight)
 394                 {
 395                 priv->geom.rows = priv->maxheight;
 396                 }
 397
 398             if(priv->geom.columns > priv->maxwidth)
 399                 {
 400                 priv->geom.columns = priv->maxwidth;
 401                 }
 402             }
 403
 404         if(req_mode == TV_NORM_SECAM) priv->iformat = METEOR_FMT_SECAM;
 405
 406         if(ioctl(priv->btfd, METEORSFMT, &priv->iformat) < 0)
 407             {
 408             mp_msg(MSGT_TV, MSGL_ERR, MSGTR_TV_Bt848IoctlFailed, "METEORSFMT", strerror(errno));
 409             return(TVI_CONTROL_FALSE);
 410             }
 411
 412         if(ioctl(priv->btfd, METEORSETGEO, &priv->geom) < 0)
 413             {
 414             mp_msg(MSGT_TV, MSGL_ERR, MSGTR_TV_Bt848IoctlFailed, "METEORSETGEO", strerror(errno));
 415             return(0);
 416             }
 417
 418         tmp_fps = priv->fps;
 419         if(ioctl(priv->btfd, METEORSFPS, &tmp_fps) < 0)
 420             {
 421             mp_msg(MSGT_TV, MSGL_ERR, MSGTR_TV_Bt848IoctlFailed, "METEORSFPS", strerror(errno));
 422             return(0);
 423             }
 424
 425 #ifdef BT848_SAUDIO
 426         if(priv->tunerready == TRUE &&
 427             ioctl(priv->tunerfd, BT848_SAUDIO, &priv->tv_param->audio_id) < 0)
 428             {
 429            mp_msg(MSGT_TV, MSGL_ERR, MSGTR_TV_Bt848IoctlFailed, "BT848_SAUDIO", strerror(errno));
 430             }
 431 #endif
 432
 433         return(TVI_CONTROL_TRUE);
 434         }
 435
 436     case TVI_CONTROL_VID_GET_FORMAT:
 437         *(int *)arg = IMGFMT_UYVY;
 438         return(TVI_CONTROL_TRUE);
 439
 440     case TVI_CONTROL_VID_SET_FORMAT:
 441         {
 442         int req_fmt = *(int *)arg;
 443
 444         if(req_fmt != IMGFMT_UYVY) return(TVI_CONTROL_FALSE);
 445
 446         return(TVI_CONTROL_TRUE);
 447         }
 448     case TVI_CONTROL_VID_SET_WIDTH:
 449         priv->geom.columns = *(int *)arg;
 450
 451         if(priv->geom.columns > priv->maxwidth)
 452             {
 453             priv->geom.columns = priv->maxwidth;
 454             }
 455
 456         if(ioctl(priv->btfd, METEORSETGEO, &priv->geom) < 0)
 457             {
 458             mp_msg(MSGT_TV, MSGL_ERR, MSGTR_TV_Bt848ErrorSettingWidth, strerror(errno));
 459             return(0);
 460             }
 461
 462         return(TVI_CONTROL_TRUE);
 463
 464     case TVI_CONTROL_VID_GET_WIDTH:
 465         *(int *)arg = priv->geom.columns;
 466         return(TVI_CONTROL_TRUE);
 467
 468     case TVI_CONTROL_VID_SET_HEIGHT:
 469         priv->geom.rows = *(int *)arg;
 470
 471         if(priv->geom.rows > priv->maxheight)
 472             {
 473             priv->geom.rows = priv->maxheight;
 474             }
 475
 476         if(priv->geom.rows <= priv->maxheight / 2)
 477             {
 478             priv->geom.oformat |= METEOR_GEO_EVEN_ONLY;
 479             }
 480
 481         if(ioctl(priv->btfd, METEORSETGEO, &priv->geom) < 0)
 482             {
 483             mp_msg(MSGT_TV, MSGL_ERR, MSGTR_TV_Bt848ErrorSettingWidth, strerror(errno));
 484             return(0);
 485             }
 486
 487         return(TVI_CONTROL_TRUE);
 488
 489     case TVI_CONTROL_VID_GET_HEIGHT:
 490         *(int *)arg = priv->geom.rows;
 491         return(TVI_CONTROL_TRUE);
 492
 493     case TVI_CONTROL_VID_GET_FPS:
 494         *(float *)arg = priv->fps;
 495         return(TVI_CONTROL_TRUE);
 496
 497 /*
 498     case TVI_CONTROL_VID_SET_FPS:
 499         priv->fps = *(int *)arg;
 500
 501         if(priv->fps > priv->maxfps) priv->fps = priv->maxfps;
 502
 503         if(ioctl(priv->btfd, METEORSFPS, &priv->fps) < 0)
 504             {
 505             mp_msg(MSGT_TV, MSGL_ERR, MSGTR_TV_Bt848IoctlFailed, "METEORSFPS", strerror(errno));
 506             return(0);
 507             }
 508
 509         return(TVI_CONTROL_TRUE);
 510 */
 511
 512     case TVI_CONTROL_VID_CHK_WIDTH:
 513     case TVI_CONTROL_VID_CHK_HEIGHT:
 514         return(TVI_CONTROL_TRUE);
 515
 516     case TVI_CONTROL_IMMEDIATE:
 517         priv->immediatemode = TRUE;
 518         return(TVI_CONTROL_TRUE);
 519     }
 520
 521     return(TVI_CONTROL_UNKNOWN);
 522 }
 523
 524 static int init(priv_t *priv)
 525 {
 526 int marg;
 527 int count;
 528 u_short tmp_fps;
 529
 530 G_private = priv; /* Oooh, sick */
 531
 532 /* Video Configuration */
 533
 534 priv->videoready = TRUE;
 535 priv->immediatemode = FALSE;
 536 priv->iformat = METEOR_FMT_PAL;
 537 priv->maxheight = PAL_HEIGHT;
 538 priv->maxwidth = PAL_WIDTH;
 539 priv->maxfps = PAL_FPS;
 540 priv->source = METEOR_INPUT_DEV0;
 541 priv->fps = priv->maxfps;
 542
 543 priv->starttime=0;
 544 priv->curpaintframe=0;
 545 priv->curbufframe=0;
 546
 547 priv->geom.columns = priv->maxwidth;
 548 priv->geom.rows = priv->maxheight;
 549 priv->geom.frames = 1;
 550 priv->geom.oformat = METEOR_GEO_YUV_PACKED;
 551
 552 priv->btfd = open(priv->btdev, O_RDONLY);
 553
 554 if(priv->btfd < 0)
 555     {
 556     mp_msg(MSGT_TV, MSGL_ERR, MSGTR_TV_Bt848ErrorOpeningBktrDev, strerror(errno));
 557     priv->videoready = FALSE;
 558     }
 559
 560 if(priv->videoready == TRUE &&
 561    ioctl(priv->btfd, METEORSFMT, &priv->iformat) < 0)
 562     {
 563     mp_msg(MSGT_TV, MSGL_ERR, MSGTR_TV_Bt848IoctlFailed, "SETEORSFMT", strerror(errno));
 564     }
 565
 566 if(priv->videoready == TRUE &&
 567    ioctl(priv->btfd, METEORSINPUT, &priv->source) < 0)
 568     {
 569     mp_msg(MSGT_TV, MSGL_ERR, MSGTR_TV_Bt848IoctlFailed, "METEORSINPUT", strerror(errno));
 570     }
 571
 572 tmp_fps = priv->fps;
 573 if(priv->videoready == TRUE &&
 574    ioctl(priv->btfd, METEORSFPS, &tmp_fps) < 0)
 575     {
 576     mp_msg(MSGT_TV, MSGL_ERR, MSGTR_TV_Bt848IoctlFailed, "METEORSFPS", strerror(errno));
 577     }
 578
 579 if(priv->videoready == TRUE &&
 580    ioctl(priv->btfd, METEORSETGEO, &priv->geom) < 0)
 581     {
 582     mp_msg(MSGT_TV, MSGL_ERR, MSGTR_TV_Bt848IoctlFailed, "METEORSGEQ", strerror(errno));
 583     }
 584
 585 if(priv->videoready == TRUE)
 586     {
 587     priv->framebufsize = (priv->geom.columns * priv->geom.rows * 2);
 588
 589     priv->livebuf = (u_char *)mmap((caddr_t)0, priv->framebufsize, PROT_READ,
 590                                 MAP_SHARED, priv->btfd, (off_t)0);
 591
 592     if(priv->livebuf == (u_char *) MAP_FAILED)
 593         {
 594         mp_msg(MSGT_TV, MSGL_ERR, MSGTR_TV_Bt848MmapFailed, strerror(errno));
 595         priv->videoready = FALSE;
 596         }
 597
 598     for(count=0;count<RINGSIZE;count++)
 599         {
 600         priv->framebuf[count].buf = malloc(priv->framebufsize);
 601
 602         if(priv->framebuf[count].buf == NULL)
 603             {
 604             mp_msg(MSGT_TV, MSGL_ERR, MSGTR_TV_Bt848FrameBufAllocFailed, strerror(errno));
 605             priv->videoready = FALSE;
 606             break;
 607             }
 608
 609         priv->framebuf[count].dirty = TRUE;
 610         priv->framebuf[count].timestamp = 0;
 611         }
 612     }
 613
 614 /* Tuner Configuration */
 615
 616 priv->tunerready = TRUE;
 617
 618 priv->tunerfd = open(priv->tunerdev, O_RDONLY);
 619
 620 if(priv->tunerfd < 0)
 621     {
 622     mp_msg(MSGT_TV, MSGL_ERR, MSGTR_TV_Bt848ErrorOpeningTunerDev, strerror(errno));
 623     priv->tunerready = FALSE;
 624     }
 625
 626 /* Audio Configuration */
 627
 628 priv->dspready = TRUE;
 629 priv->dspsamplesize = 16;
 630 priv->dspstereo = 1;
 631 priv->dspspeed = 44100;
 632 priv->dspfmt = AFMT_S16_LE;
 633 priv->dspbytesread = 0;
 634 priv->dsprate = priv->dspspeed * priv->dspsamplesize/8*(priv->dspstereo+1);
 635 priv->dspframesize = priv->dspspeed*priv->dspsamplesize/8/priv->fps *
 636                      (priv->dspstereo+1);
 637
 638 if((priv->dspfd = open (priv->dspdev, O_RDONLY, 0)) < 0)
 639     {
 640     mp_msg(MSGT_TV, MSGL_ERR, MSGTR_TV_Bt848ErrorOpeningDspDev, strerror(errno));
 641     priv->dspready = FALSE;
 642     }
 643
 644 marg = (256 << 16) | 12;
 645
 646 if (ioctl(priv->dspfd, SNDCTL_DSP_SETFRAGMENT, &marg ) < 0 )
 647     {
 648     mp_msg(MSGT_TV, MSGL_ERR, MSGTR_TV_Bt848IoctlFailed, "SNDCTL_DSP_SETFRAGMENT", strerror(errno));
 649     priv->dspready = FALSE;
 650     }
 651
 652 if((priv->dspready == TRUE) &&
 653    ((ioctl(priv->dspfd, SNDCTL_DSP_SAMPLESIZE, &priv->dspsamplesize) == -1) ||
 654    (ioctl(priv->dspfd, SNDCTL_DSP_STEREO, &priv->dspstereo) == -1) ||
 655    (ioctl(priv->dspfd, SNDCTL_DSP_SPEED, &priv->dspspeed) == -1) ||
 656    (ioctl(priv->dspfd, SNDCTL_DSP_SETFMT, &priv->dspfmt) == -1)))
 657     {
 658     mp_msg(MSGT_TV, MSGL_ERR, MSGTR_TV_Bt848ErrorConfiguringDsp, strerror(errno));
 659     close(priv->dspfd);
 660     priv->dspready = FALSE;
 661     }
 662
 663 return(1);
 664 }
 665
 666 /* that's the real start, we'got the format parameters (checked with control) */
 667 static int start(priv_t *priv)
 668 {
 669 int tmp;
 670 struct timeval curtime;
 671 int marg;
 672
 673 fprintf(stderr,"START\n");
 674 if(priv->videoready == FALSE) return(0);
 675
 676 signal(SIGUSR1, processframe);
 677 signal(SIGALRM, processframe);
 678
 679 marg = SIGUSR1;
 680
 681 if(ioctl(priv->btfd, METEORSSIGNAL, &marg) < 0)
 682     {
 683     mp_msg(MSGT_TV, MSGL_ERR, MSGTR_TV_Bt848IoctlFailed, "METEORSSIGNAL", strerror(errno));
 684     return(0);
 685     }
 686
 687 read(priv->dspfd, &tmp, 2);
 688
 689 gettimeofday(&curtime, NULL);
 690
 691 priv->starttime = curtime.tv_sec + (curtime.tv_usec *.000001);
 692
 693 marg = METEOR_CAP_CONTINOUS;
 694
 695 if(ioctl(priv->btfd, METEORCAPTUR, &marg) < 0)
 696     {
 697     mp_msg(MSGT_TV, MSGL_ERR, MSGTR_TV_Bt848IoctlFailed, "METEORCAPTUR", strerror(errno));
 698     return(0);
 699     }
 700
 701 return(1);
 702 }
 703
 704 static int uninit(priv_t *priv)
 705 {
 706 int marg;
 707
 708 if(priv->videoready == FALSE) return(0);
 709
 710 marg = METEOR_SIG_MODE_MASK;
 711
 712 if(ioctl( priv->btfd, METEORSSIGNAL, &marg) < 0 )
 713     {
 714     mp_msg(MSGT_TV, MSGL_ERR, MSGTR_TV_Bt848IoctlFailed, "METEORSSIGNAL", strerror(errno));
 715     return(0);
 716     }
 717
 718 marg = METEOR_CAP_STOP_CONT;
 719
 720 if(ioctl(priv->btfd, METEORCAPTUR, &marg) < 0 )
 721     {
 722     mp_msg(MSGT_TV, MSGL_ERR, MSGTR_TV_Bt848UnableToStopCapture, strerror(errno));
 723     return(0);
 724     }
 725
 726 close(priv->btfd);
 727 close(priv->dspfd);
 728
 729 priv->dspfd = -1;
 730 priv->btfd = -1;
 731
 732 priv->dspready = priv->videoready = FALSE;
 733
 734 return(1);
 735 }
 736
 737
 738 static double grabimmediate_video_frame(priv_t *priv, char *buffer, int len)
 739 {
 740 sigset_t sa_mask;
 741
 742 if(priv->videoready == FALSE) return(0);
 743
 744 alarm(1);
 745 sigfillset(&sa_mask);
 746 sigdelset(&sa_mask,SIGINT);
 747 sigdelset(&sa_mask,SIGUSR1);
 748 sigdelset(&sa_mask,SIGALRM);
 749 sigsuspend(&sa_mask);
 750 alarm(0);
 751
 752 memcpy(buffer, priv->livebuf, len);
 753
 754 /* PTS = 0, show the frame NOW, this routine is only used in playback mode
 755     without audio capture .. */
 756
 757 return(0);
 758 }
 759
 760 static double grab_video_frame(priv_t *priv, char *buffer, int len)
 761 {
 762 double timestamp=0;
 763 sigset_t sa_mask;
 764
 765 if(priv->videoready == FALSE) return(0);
 766
 767 if(priv->immediatemode == TRUE)
 768     {
 769     return grabimmediate_video_frame(priv, buffer, len);
 770     }
 771
 772 while(priv->framebuf[priv->curbufframe].dirty == TRUE)
 773     {
 774     alarm(1);
 775     sigemptyset(&sa_mask);
 776     sigsuspend(&sa_mask);
 777     alarm(0);
 778     }
 779
 780 memcpy(buffer, priv->framebuf[priv->curbufframe].buf, len);
 781 timestamp = priv->framebuf[priv->curbufframe].timestamp;
 782 priv->framebuf[priv->curbufframe].dirty = TRUE;
 783
 784 priv->curbufframe++;
 785 if(priv->curbufframe >= RINGSIZE) priv->curbufframe = 0;
 786
 787 return(timestamp-priv->starttime);
 788 }
 789
 790 static int get_video_framesize(priv_t *priv)
 791 {
 792 return(priv->geom.columns*priv->geom.rows*16/8);
 793 }
 794
 795 static double grab_audio_frame(priv_t *priv, char *buffer, int len)
 796 {
 797 struct timeval curtime;
 798 double curpts;
 799 double timeskew;
 800 int bytesread;
 801 int ret;
 802
 803 if(priv->dspready == FALSE) return 0;
 804
 805 gettimeofday(&curtime, NULL);
 806
 807 /* Get exactly one frame of audio, which forces video sync to audio.. */
 808
 809 bytesread=read(priv->dspfd, buffer, len);
 810
 811 while(bytesread < len)
 812     {
 813     ret=read(priv->dspfd, &buffer[bytesread], len-bytesread);
 814
 815     if(ret == -1)
 816         {
 817         mp_msg(MSGT_TV, MSGL_ERR, MSGTR_TV_Bt848ErrorReadingAudio, strerror(errno));
 818         return 0;
 819         }
 820
 821     bytesread+=ret;
 822     }
 823
 824 priv->dspbytesread += bytesread;
 825
 826 curpts = curtime.tv_sec + curtime.tv_usec * .000001;
 827
 828 timeskew = priv->dspbytesread * 1.0 / priv->dsprate - (curpts-priv->starttime);
 829
 830 if(timeskew > .125/priv->fps)
 831     {
 832     priv->starttime -= timeskew;
 833     }
 834 else
 835     {
 836     if(timeskew < -.125/priv->fps)
 837         {
 838         priv->starttime -= timeskew;
 839         }
 840     }
 841
 842 return(priv->dspbytesread * 1.0 / priv->dsprate);
 843 }
 844
 845 static int get_audio_framesize(priv_t *priv)
 846 {
 847 int bytesavail;
 848 #ifdef USE_SUN_AUDIO
 849 struct audio_info auinf;
 850 #endif
 851
 852 if(priv->dspready == FALSE) return 0;
 853
 854 #ifdef USE_SUN_AUDIO
 855 if(ioctl(priv->dspfd, AUDIO_GETINFO, &auinf) < 0)
 856     {
 857     mp_msg(MSGT_TV, MSGL_ERR, MSGTR_TV_Bt848IoctlFailed, "AUDIO_GETINFO", strerror(errno));
 858     return(TVI_CONTROL_FALSE);
 859     }
 860 else
 861     bytesavail = auinf.record.seek; /* *priv->dspsamplesize; */
 862 #else
 863 if(ioctl(priv->dspfd, FIONREAD, &bytesavail) < 0)
 864     {
 865     mp_msg(MSGT_TV, MSGL_ERR, MSGTR_TV_Bt848IoctlFailed, "FIONREAD", strerror(errno));
 866     return(TVI_CONTROL_FALSE);
 867     }
 868 #endif
 869
 870 /* When mencoder wants audio data, it wants data..
 871    it won't go do anything else until it gets it :( */
 872
 873 if(bytesavail == 0) return FRAGSIZE;
 874
 875 return(bytesavail);
 876 }
 877
 878 static int getinput(int innumber)
 879 {
 880 switch(innumber)
 881     {
 882     case 0: return METEOR_INPUT_DEV0;     /* RCA   */
 883     case 1: return METEOR_INPUT_DEV1;     /* Tuner */
 884     case 2: return METEOR_INPUT_DEV2;     /* In 1  */
 885     case 3: return METEOR_INPUT_DEV3;     /* In 2  */
 886     case 4: return METEOR_INPUT_DEV_RGB;     /* RGB   */
 887     case 5: return METEOR_INPUT_DEV_SVIDEO; /* SVid  */
 888     }
 889
 890 return 0;
 891 }