Mercurial > mplayer.hg
view stream/tvi_bsdbt848.c @ 34697:ac6b38cd0d45
Rename sub window video window.
It was a bad idea to name the video window "sub window" at the time
the GUI was written. The term "sub window" does make sense from the
programmer's point of view, but it doesn't make any sense at all from
the user's point of view, because the sub window simply is the window
where the video will be displayed.
Moreover, since the term "sub" is generally short for "subtitles",
the renaming makes the code much easier to understand.
author | ib |
---|---|
date | Sat, 03 Mar 2012 16:45:15 +0000 |
parents | 2802b8095bf7 |
children | 25429dbfa18e |
line wrap: on
line source
/* * *BSD (hopefully, requires working driver!) BrookTree capture support. * * Still in (active) development! * * v1.1 Mar 13 2002 Fully functional, need to move ring buffer to * the kernel driver. * v1.0 Feb 19 2002 First Release, need to add support for changing * audio parameters. * * Copyright (C) 2002 Charles R. Henrich (henrich@msu.edu) * * 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. */ #include "config.h" #define RINGSIZE 8 #define FRAGSIZE 4096 /* (2^12 see SETFRAGSIZE below) */ #define TRUE (1==1) #define FALSE (1==0) #define PAL_WIDTH 768 #define PAL_HEIGHT 576 #define PAL_FPS 25 #define NTSC_WIDTH 640 #define NTSC_HEIGHT 480 #define NTSC_FPS 29.97 #include <stdio.h> #include <stdlib.h> #include <unistd.h> #include <fcntl.h> #include <sys/types.h> #include <sys/mman.h> #include <sys/filio.h> #include <sys/time.h> #include <signal.h> #include <string.h> #include <errno.h> #include <sys/param.h> #ifdef CONFIG_SUN_AUDIO #include <sys/audioio.h> #endif #ifdef IOCTL_METEOR_H_NAME #include IOCTL_METEOR_H_NAME #endif #ifdef IOCTL_BT848_H_NAME #include IOCTL_BT848_H_NAME #endif #ifdef HAVE_SYS_SOUNDCARD_H #include <sys/soundcard.h> #else #ifdef HAVE_SOUNDCARD_H #include <soundcard.h> #else #include <machine/soundcard.h> #endif #endif #include "libaf/af_format.h" #include "libmpcodecs/img_format.h" #include "tv.h" #include "help_mp.h" #include "mp_msg.h" static tvi_handle_t *tvi_init_bsdbt848(tv_param_t* tv_param); /* information about this file */ const tvi_info_t tvi_info_bsdbt848 = { tvi_init_bsdbt848, "Brooktree848 Support", "bsdbt848", "Charles Henrich", "in development" }; typedef struct { int dirty; double timestamp; char *buf; } RBFRAME; /* private data's */ typedef struct priv { /* Audio */ char *dspdev; int dspready; int dspfd; int dspsamplesize; int dspstereo; int dspspeed; int dspfmt; int dspframesize; int dsprate; long long dspbytesread; /* Video */ char *btdev; int videoready; int btfd; int source; float maxfps; float fps; int iformat; int maxheight; int maxwidth; struct meteor_geomet geom; struct meteor_capframe capframe; /* Frame Buffer */ int framebufsize; float timestamp; int curpaintframe; int curbufframe; unsigned char *livebuf; RBFRAME framebuf[RINGSIZE]; /* Inputs */ int input; /* Tuner */ char *tunerdev; int tunerfd; int tunerready; u_long tunerfreq; struct bktr_chnlset cset; /* Other */ int immediatemode; double starttime; tv_param_t *tv_param; } priv_t; #include "tvi_def.h" static priv_t *G_private=NULL; static int getinput(int innumber); static void processframe(int signal) { struct timeval curtime; if(G_private->immediatemode == TRUE) return; gettimeofday(&curtime, NULL); if(G_private->framebuf[G_private->curpaintframe].dirty == TRUE) { memcpy(G_private->framebuf[G_private->curpaintframe].buf, G_private->livebuf, G_private->framebufsize); G_private->framebuf[G_private->curpaintframe].dirty = FALSE; G_private->framebuf[G_private->curpaintframe].timestamp = curtime.tv_sec + curtime.tv_usec*.000001; G_private->curpaintframe++; if(G_private->curpaintframe >= RINGSIZE) G_private->curpaintframe = 0; } return; } /* handler creator - entry point ! */ static tvi_handle_t *tvi_init_bsdbt848(tv_param_t* tv_param) { char* sep ; tvi_handle_t* tvh; priv_t* priv; tvh = tv_new_handle(sizeof(priv_t), &functions); if(!tvh) return NULL; priv=(priv_t*)tvh->priv; /* if user needs to specify both /dev/bktr<n> and /dev/tuner<n> it can do this with "-tv device=/dev/bktr1,/dev/tuner1" */ /* set video device name */ if (!tv_param->device){ priv->btdev = strdup("/dev/bktr0"); priv->tunerdev = strdup("/dev/tuner0"); }else{ sep = strchr(tv_param->device,','); priv->btdev = strdup(tv_param->device); if(sep){ // tuner device is also passed priv->tunerdev = strdup(sep+1); priv->btdev[sep - tv_param->device] = 0; }else{ priv->tunerdev = strdup("/dev/tuner0"); } } /* set audio device name */ if (!tv_param->adevice) #ifdef CONFIG_SUN_AUDIO priv->dspdev = strdup("/dev/sound"); #else priv->dspdev = strdup("/dev/dsp"); #endif else priv->dspdev = strdup(tv_param->adevice); priv->tv_param=tv_param; return tvh; } static int control(priv_t *priv, int cmd, void *arg) { switch(cmd) { /* Tuner Controls */ case TVI_CONTROL_IS_TUNER: if(priv->tunerready == FALSE) return TVI_CONTROL_FALSE; return TVI_CONTROL_TRUE; case TVI_CONTROL_TUN_GET_FREQ: { if(ioctl(priv->tunerfd, TVTUNER_GETFREQ, &priv->tunerfreq) < 0) { mp_msg(MSGT_TV, MSGL_ERR, MSGTR_TV_Bt848IoctlFailed, "TVTUNER_GETFREQ", strerror(errno)); return TVI_CONTROL_FALSE; } *(int *)arg = priv->tunerfreq; return TVI_CONTROL_TRUE; } case TVI_CONTROL_TUN_SET_FREQ: { priv->tunerfreq = *(int *)arg; if(ioctl(priv->tunerfd, TVTUNER_SETFREQ, &priv->tunerfreq) < 0) { mp_msg(MSGT_TV, MSGL_ERR, MSGTR_TV_Bt848IoctlFailed, "TVTUNER_SETFREQ", strerror(errno)); return 0; } return TVI_CONTROL_TRUE; } case TVI_CONTROL_TUN_GET_SIGNAL: { int status; if(ioctl(priv->tunerfd, TVTUNER_GETSTATUS, &status) < 0) { mp_msg(MSGT_TV, MSGL_ERR, MSGTR_TV_Bt848IoctlFailed, "GETSTATUS", strerror(errno)); return 0; } *(int*)arg=(status & 0x02)? 100 : 0; return TVI_CONTROL_TRUE; } case TVI_CONTROL_TUN_GET_TUNER: case TVI_CONTROL_TUN_SET_TUNER: /* Inputs */ case TVI_CONTROL_SPC_GET_INPUT: { if(ioctl(priv->btfd, METEORGINPUT, &priv->input) < 0) { mp_msg(MSGT_TV, MSGL_ERR, MSGTR_TV_Bt848IoctlFailed, "METEORGINPUT", strerror(errno)); return TVI_CONTROL_FALSE; } *(int *)arg = priv->input; return TVI_CONTROL_TRUE; } case TVI_CONTROL_SPC_SET_INPUT: { priv->input = getinput(*(int *)arg); if(ioctl(priv->btfd, METEORSINPUT, &priv->input) < 0) { mp_msg(MSGT_TV, MSGL_ERR, MSGTR_TV_Bt848IoctlFailed, "METEORSINPUT", strerror(errno)); return 0; } return TVI_CONTROL_TRUE; } /* Audio Controls */ case TVI_CONTROL_IS_AUDIO: if(priv->dspready == FALSE) return TVI_CONTROL_FALSE; return TVI_CONTROL_TRUE; case TVI_CONTROL_AUD_GET_FORMAT: { *(int *)arg = AF_FORMAT_S16_LE; return TVI_CONTROL_TRUE; } case TVI_CONTROL_AUD_GET_CHANNELS: { *(int *)arg = 2; return TVI_CONTROL_TRUE; } case TVI_CONTROL_AUD_SET_SAMPLERATE: { int dspspeed = *(int *)arg; if(ioctl(priv->dspfd, SNDCTL_DSP_SPEED, &dspspeed) == -1) { mp_msg(MSGT_TV, MSGL_ERR, MSGTR_TV_Bt848InvalidAudioRate, strerror(errno)); return TVI_CONTROL_FALSE; } priv->dspspeed = dspspeed; priv->dspframesize = priv->dspspeed*priv->dspsamplesize/8/ priv->fps * (priv->dspstereo+1); priv->dsprate = priv->dspspeed * priv->dspsamplesize/8* (priv->dspstereo+1); return TVI_CONTROL_TRUE; } case TVI_CONTROL_AUD_GET_SAMPLERATE: { *(int *)arg = priv->dspspeed; return TVI_CONTROL_TRUE; } case TVI_CONTROL_AUD_GET_SAMPLESIZE: { *(int *)arg = priv->dspsamplesize/8; return TVI_CONTROL_TRUE; } /* Video Controls */ case TVI_CONTROL_IS_VIDEO: if(priv->videoready == FALSE) return TVI_CONTROL_FALSE; return TVI_CONTROL_TRUE; case TVI_CONTROL_TUN_SET_NORM: { int req_mode = *(int *)arg; u_short tmp_fps; priv->iformat = METEOR_FMT_AUTOMODE; if(req_mode == TV_NORM_PAL) { priv->iformat = METEOR_FMT_PAL; priv->maxheight = PAL_HEIGHT; priv->maxwidth = PAL_WIDTH; priv->maxfps = PAL_FPS; priv->fps = PAL_FPS; if(priv->fps > priv->maxfps) priv->fps = priv->maxfps; if(priv->geom.rows > priv->maxheight) { priv->geom.rows = priv->maxheight; } if(priv->geom.columns > priv->maxwidth) { priv->geom.columns = priv->maxwidth; } } if(req_mode == TV_NORM_NTSC) { priv->iformat = METEOR_FMT_NTSC; priv->maxheight = NTSC_HEIGHT; priv->maxwidth = NTSC_WIDTH; priv->maxfps = NTSC_FPS; priv->fps = NTSC_FPS; priv->dspframesize = priv->dspspeed*priv->dspsamplesize/8/ priv->fps * (priv->dspstereo+1); priv->dsprate = priv->dspspeed * priv->dspsamplesize/8 * (priv->dspstereo+1); if(priv->fps > priv->maxfps) priv->fps = priv->maxfps; if(priv->geom.rows > priv->maxheight) { priv->geom.rows = priv->maxheight; } if(priv->geom.columns > priv->maxwidth) { priv->geom.columns = priv->maxwidth; } } if(req_mode == TV_NORM_SECAM) priv->iformat = METEOR_FMT_SECAM; if(ioctl(priv->btfd, METEORSFMT, &priv->iformat) < 0) { mp_msg(MSGT_TV, MSGL_ERR, MSGTR_TV_Bt848IoctlFailed, "METEORSFMT", strerror(errno)); return TVI_CONTROL_FALSE; } if(ioctl(priv->btfd, METEORSETGEO, &priv->geom) < 0) { mp_msg(MSGT_TV, MSGL_ERR, MSGTR_TV_Bt848IoctlFailed, "METEORSETGEO", strerror(errno)); return 0; } tmp_fps = priv->fps; if(ioctl(priv->btfd, METEORSFPS, &tmp_fps) < 0) { mp_msg(MSGT_TV, MSGL_ERR, MSGTR_TV_Bt848IoctlFailed, "METEORSFPS", strerror(errno)); return 0; } #ifdef BT848_SAUDIO if(priv->tunerready == TRUE && ioctl(priv->tunerfd, BT848_SAUDIO, &priv->tv_param->audio_id) < 0) { mp_msg(MSGT_TV, MSGL_ERR, MSGTR_TV_Bt848IoctlFailed, "BT848_SAUDIO", strerror(errno)); } #endif return TVI_CONTROL_TRUE; } case TVI_CONTROL_VID_GET_FORMAT: *(int *)arg = IMGFMT_UYVY; return TVI_CONTROL_TRUE; case TVI_CONTROL_VID_SET_FORMAT: { int req_fmt = *(int *)arg; if(req_fmt != IMGFMT_UYVY) return TVI_CONTROL_FALSE; return TVI_CONTROL_TRUE; } case TVI_CONTROL_VID_SET_WIDTH: priv->geom.columns = *(int *)arg; if(priv->geom.columns > priv->maxwidth) { priv->geom.columns = priv->maxwidth; } if(ioctl(priv->btfd, METEORSETGEO, &priv->geom) < 0) { mp_msg(MSGT_TV, MSGL_ERR, MSGTR_TV_Bt848ErrorSettingWidth, strerror(errno)); return 0; } return TVI_CONTROL_TRUE; case TVI_CONTROL_VID_GET_WIDTH: *(int *)arg = priv->geom.columns; return TVI_CONTROL_TRUE; case TVI_CONTROL_VID_SET_HEIGHT: priv->geom.rows = *(int *)arg; if(priv->geom.rows > priv->maxheight) { priv->geom.rows = priv->maxheight; } if(priv->geom.rows <= priv->maxheight / 2) { priv->geom.oformat |= METEOR_GEO_EVEN_ONLY; } if(ioctl(priv->btfd, METEORSETGEO, &priv->geom) < 0) { mp_msg(MSGT_TV, MSGL_ERR, MSGTR_TV_Bt848ErrorSettingWidth, strerror(errno)); return 0; } return TVI_CONTROL_TRUE; case TVI_CONTROL_VID_GET_HEIGHT: *(int *)arg = priv->geom.rows; return TVI_CONTROL_TRUE; case TVI_CONTROL_VID_GET_FPS: *(float *)arg = priv->fps; return TVI_CONTROL_TRUE; /* case TVI_CONTROL_VID_SET_FPS: priv->fps = *(int *)arg; if(priv->fps > priv->maxfps) priv->fps = priv->maxfps; if(ioctl(priv->btfd, METEORSFPS, &priv->fps) < 0) { mp_msg(MSGT_TV, MSGL_ERR, MSGTR_TV_Bt848IoctlFailed, "METEORSFPS", strerror(errno)); return 0; } return TVI_CONTROL_TRUE; */ case TVI_CONTROL_VID_CHK_WIDTH: case TVI_CONTROL_VID_CHK_HEIGHT: return TVI_CONTROL_TRUE; case TVI_CONTROL_IMMEDIATE: priv->immediatemode = TRUE; return TVI_CONTROL_TRUE; } return TVI_CONTROL_UNKNOWN; } static int init(priv_t *priv) { int marg; int count; u_short tmp_fps; G_private = priv; /* Oooh, sick */ /* Video Configuration */ priv->videoready = TRUE; priv->immediatemode = FALSE; priv->iformat = METEOR_FMT_PAL; priv->maxheight = PAL_HEIGHT; priv->maxwidth = PAL_WIDTH; priv->maxfps = PAL_FPS; priv->source = METEOR_INPUT_DEV0; priv->fps = priv->maxfps; priv->starttime=0; priv->curpaintframe=0; priv->curbufframe=0; priv->geom.columns = priv->maxwidth; priv->geom.rows = priv->maxheight; priv->geom.frames = 1; priv->geom.oformat = METEOR_GEO_YUV_PACKED; priv->btfd = open(priv->btdev, O_RDONLY); if(priv->btfd < 0) { mp_msg(MSGT_TV, MSGL_ERR, MSGTR_TV_Bt848ErrorOpeningBktrDev, strerror(errno)); priv->videoready = FALSE; } if(priv->videoready == TRUE && ioctl(priv->btfd, METEORSFMT, &priv->iformat) < 0) { mp_msg(MSGT_TV, MSGL_ERR, MSGTR_TV_Bt848IoctlFailed, "SETEORSFMT", strerror(errno)); } if(priv->videoready == TRUE && ioctl(priv->btfd, METEORSINPUT, &priv->source) < 0) { mp_msg(MSGT_TV, MSGL_ERR, MSGTR_TV_Bt848IoctlFailed, "METEORSINPUT", strerror(errno)); } tmp_fps = priv->fps; if(priv->videoready == TRUE && ioctl(priv->btfd, METEORSFPS, &tmp_fps) < 0) { mp_msg(MSGT_TV, MSGL_ERR, MSGTR_TV_Bt848IoctlFailed, "METEORSFPS", strerror(errno)); } if(priv->videoready == TRUE && ioctl(priv->btfd, METEORSETGEO, &priv->geom) < 0) { mp_msg(MSGT_TV, MSGL_ERR, MSGTR_TV_Bt848IoctlFailed, "METEORSGEQ", strerror(errno)); } if(priv->videoready == TRUE) { priv->framebufsize = (priv->geom.columns * priv->geom.rows * 2); priv->livebuf = (u_char *)mmap((caddr_t)0, priv->framebufsize, PROT_READ, MAP_SHARED, priv->btfd, (off_t)0); if(priv->livebuf == (u_char *) MAP_FAILED) { mp_msg(MSGT_TV, MSGL_ERR, MSGTR_TV_Bt848MmapFailed, strerror(errno)); priv->videoready = FALSE; } for(count=0;count<RINGSIZE;count++) { priv->framebuf[count].buf = malloc(priv->framebufsize); if(priv->framebuf[count].buf == NULL) { mp_msg(MSGT_TV, MSGL_ERR, MSGTR_TV_Bt848FrameBufAllocFailed, strerror(errno)); priv->videoready = FALSE; break; } priv->framebuf[count].dirty = TRUE; priv->framebuf[count].timestamp = 0; } } /* Tuner Configuration */ priv->tunerready = TRUE; priv->tunerfd = open(priv->tunerdev, O_RDONLY); if(priv->tunerfd < 0) { mp_msg(MSGT_TV, MSGL_ERR, MSGTR_TV_Bt848ErrorOpeningTunerDev, strerror(errno)); priv->tunerready = FALSE; } /* Audio Configuration */ priv->dspready = TRUE; priv->dspsamplesize = 16; priv->dspstereo = 1; priv->dspspeed = 44100; priv->dspfmt = AFMT_S16_LE; priv->dspbytesread = 0; priv->dsprate = priv->dspspeed * priv->dspsamplesize/8*(priv->dspstereo+1); priv->dspframesize = priv->dspspeed*priv->dspsamplesize/8/priv->fps * (priv->dspstereo+1); if((priv->dspfd = open (priv->dspdev, O_RDONLY, 0)) < 0) { mp_msg(MSGT_TV, MSGL_ERR, MSGTR_TV_Bt848ErrorOpeningDspDev, strerror(errno)); priv->dspready = FALSE; } marg = (256 << 16) | 12; if (ioctl(priv->dspfd, SNDCTL_DSP_SETFRAGMENT, &marg ) < 0 ) { mp_msg(MSGT_TV, MSGL_ERR, MSGTR_TV_Bt848IoctlFailed, "SNDCTL_DSP_SETFRAGMENT", strerror(errno)); priv->dspready = FALSE; } if((priv->dspready == TRUE) && ((ioctl(priv->dspfd, SNDCTL_DSP_SAMPLESIZE, &priv->dspsamplesize) == -1) || (ioctl(priv->dspfd, SNDCTL_DSP_STEREO, &priv->dspstereo) == -1) || (ioctl(priv->dspfd, SNDCTL_DSP_SPEED, &priv->dspspeed) == -1) || (ioctl(priv->dspfd, SNDCTL_DSP_SETFMT, &priv->dspfmt) == -1))) { mp_msg(MSGT_TV, MSGL_ERR, MSGTR_TV_Bt848ErrorConfiguringDsp, strerror(errno)); close(priv->dspfd); priv->dspready = FALSE; } return 1; } /* that's the real start, we'got the format parameters (checked with control) */ static int start(priv_t *priv) { int tmp; struct timeval curtime; int marg; fprintf(stderr,"START\n"); if(priv->videoready == FALSE) return 0; signal(SIGUSR1, processframe); signal(SIGALRM, processframe); marg = SIGUSR1; if(ioctl(priv->btfd, METEORSSIGNAL, &marg) < 0) { mp_msg(MSGT_TV, MSGL_ERR, MSGTR_TV_Bt848IoctlFailed, "METEORSSIGNAL", strerror(errno)); return 0; } read(priv->dspfd, &tmp, 2); gettimeofday(&curtime, NULL); priv->starttime = curtime.tv_sec + (curtime.tv_usec *.000001); marg = METEOR_CAP_CONTINOUS; if(ioctl(priv->btfd, METEORCAPTUR, &marg) < 0) { mp_msg(MSGT_TV, MSGL_ERR, MSGTR_TV_Bt848IoctlFailed, "METEORCAPTUR", strerror(errno)); return 0; } return 1; } static int uninit(priv_t *priv) { int marg; if(priv->videoready == FALSE) return 0; marg = METEOR_SIG_MODE_MASK; if(ioctl( priv->btfd, METEORSSIGNAL, &marg) < 0 ) { mp_msg(MSGT_TV, MSGL_ERR, MSGTR_TV_Bt848IoctlFailed, "METEORSSIGNAL", strerror(errno)); return 0; } marg = METEOR_CAP_STOP_CONT; if(ioctl(priv->btfd, METEORCAPTUR, &marg) < 0 ) { mp_msg(MSGT_TV, MSGL_ERR, MSGTR_TV_Bt848UnableToStopCapture, strerror(errno)); return 0; } close(priv->btfd); close(priv->dspfd); priv->dspfd = -1; priv->btfd = -1; priv->dspready = priv->videoready = FALSE; return 1; } static double grabimmediate_video_frame(priv_t *priv, char *buffer, int len) { sigset_t sa_mask; if(priv->videoready == FALSE) return 0; alarm(1); sigfillset(&sa_mask); sigdelset(&sa_mask,SIGINT); sigdelset(&sa_mask,SIGUSR1); sigdelset(&sa_mask,SIGALRM); sigsuspend(&sa_mask); alarm(0); memcpy(buffer, priv->livebuf, len); /* PTS = 0, show the frame NOW, this routine is only used in playback mode without audio capture .. */ return 0; } static double grab_video_frame(priv_t *priv, char *buffer, int len) { double timestamp=0; sigset_t sa_mask; if(priv->videoready == FALSE) return 0; if(priv->immediatemode == TRUE) { return grabimmediate_video_frame(priv, buffer, len); } while(priv->framebuf[priv->curbufframe].dirty == TRUE) { alarm(1); sigemptyset(&sa_mask); sigsuspend(&sa_mask); alarm(0); } memcpy(buffer, priv->framebuf[priv->curbufframe].buf, len); timestamp = priv->framebuf[priv->curbufframe].timestamp; priv->framebuf[priv->curbufframe].dirty = TRUE; priv->curbufframe++; if(priv->curbufframe >= RINGSIZE) priv->curbufframe = 0; return timestamp-priv->starttime; } static int get_video_framesize(priv_t *priv) { return priv->geom.columns * priv->geom.rows * 16 / 8; } static double grab_audio_frame(priv_t *priv, char *buffer, int len) { struct timeval curtime; double curpts; double timeskew; int bytesread; int ret; if(priv->dspready == FALSE) return 0; gettimeofday(&curtime, NULL); /* Get exactly one frame of audio, which forces video sync to audio.. */ bytesread=read(priv->dspfd, buffer, len); while(bytesread < len) { ret=read(priv->dspfd, &buffer[bytesread], len-bytesread); if(ret == -1) { mp_msg(MSGT_TV, MSGL_ERR, MSGTR_TV_Bt848ErrorReadingAudio, strerror(errno)); return 0; } bytesread+=ret; } priv->dspbytesread += bytesread; curpts = curtime.tv_sec + curtime.tv_usec * .000001; timeskew = priv->dspbytesread * 1.0 / priv->dsprate - (curpts-priv->starttime); if(timeskew > .125/priv->fps) { priv->starttime -= timeskew; } else { if(timeskew < -.125/priv->fps) { priv->starttime -= timeskew; } } return priv->dspbytesread * 1.0 / priv->dsprate; } static int get_audio_framesize(priv_t *priv) { int bytesavail; #ifdef CONFIG_SUN_AUDIO struct audio_info auinf; #endif if(priv->dspready == FALSE) return 0; #ifdef CONFIG_SUN_AUDIO if(ioctl(priv->dspfd, AUDIO_GETINFO, &auinf) < 0) { mp_msg(MSGT_TV, MSGL_ERR, MSGTR_TV_Bt848IoctlFailed, "AUDIO_GETINFO", strerror(errno)); return TVI_CONTROL_FALSE; } else bytesavail = auinf.record.seek; /* *priv->dspsamplesize; */ #else if(ioctl(priv->dspfd, FIONREAD, &bytesavail) < 0) { mp_msg(MSGT_TV, MSGL_ERR, MSGTR_TV_Bt848IoctlFailed, "FIONREAD", strerror(errno)); return TVI_CONTROL_FALSE; } #endif /* When mencoder wants audio data, it wants data.. it won't go do anything else until it gets it :( */ if(bytesavail == 0) return FRAGSIZE; return bytesavail; } static int getinput(int innumber) { switch(innumber) { case 0: return METEOR_INPUT_DEV0; /* RCA */ case 1: return METEOR_INPUT_DEV1; /* Tuner */ case 2: return METEOR_INPUT_DEV2; /* In 1 */ case 3: return METEOR_INPUT_DEV3; /* In 2 */ case 4: return METEOR_INPUT_DEV_RGB; /* RGB */ case 5: return METEOR_INPUT_DEV_SVIDEO; /* SVid */ } return 0; }