static void vlc_rand_init (void)
{
#if defined (__OpenBSD__) || defined (__OpenBSD_kernel__)
static const char randfile[] = "/dev/random";
#else
static const char randfile[] = "/dev/urandom";
#endif
uint8_t key[BLOCK_SIZE];
/* Get non-predictible value as key for HMAC */
int fd = vlc_open (randfile, O_RDONLY);
if (fd == -1)
return; /* Uho! */
for (size_t i = 0; i < sizeof (key);)
{
ssize_t val = read (fd, key + i, sizeof (key) - i);
if (val > 0)
i += val;
}
/* Precompute outer and inner keys for HMAC */
for (size_t i = 0; i < sizeof (key); i++)
{
okey[i] = key[i] ^ 0x5c;
ikey[i] = key[i] ^ 0x36;
}
close (fd);
}
/*****************************************************************************
* openNextFile: Open the segment file
*****************************************************************************/
static ssize_t openNextFile( sout_access_out_t *p_access, sout_access_out_sys_t *p_sys )
{
int fd;
uint32_t i_newseg = p_sys->i_segment + 1;
char *psz_seg = formatSegmentPath( p_access, p_access->psz_path, i_newseg, true );
if ( !psz_seg )
return -1;
fd = vlc_open( psz_seg, O_WRONLY | O_CREAT | O_LARGEFILE |
O_TRUNC, 0666 );
if ( fd == -1 )
{
msg_Err( p_access, "cannot open `%s' (%m)", psz_seg );
free( psz_seg );
return -1;
}
msg_Dbg( p_access, "Successfully opened livehttp file: %s (%"PRIu32")" , psz_seg, i_newseg );
//free( psz_seg );
p_sys->psz_cursegPath = psz_seg;
p_sys->i_handle = fd;
p_sys->i_segment = i_newseg;
return fd;
}
/** Opens the device directory for the specified DVB adapter */
static int dvb_open_adapter (uint8_t adapter)
{
char dir[20];
snprintf (dir, sizeof (dir), "/dev/dvb/adapter%"PRIu8, adapter);
return vlc_open (dir, O_SEARCH|O_DIRECTORY);
}
int tar_open( TAR **t, char *pathname, int oflags )
{
(void)oflags;
int fd = vlc_open( pathname, O_BINARY | O_RDONLY );
if( fd == -1 )
{
fprintf( stderr, "Couldn't open %s\n", pathname );
return -1;
}
gzFile f = gzdopen( fd, "rb" );
if( f == NULL )
{
fprintf( stderr, "Couldn't gzopen %s\n", pathname );
vlc_close( fd );
return -1;
}
*t = (gzFile *)malloc( sizeof(gzFile) );
if( *t == NULL )
{
gzclose( f );
return -1;
}
**t = f;
return 0;
}
void FBVLC::onPluginReady()
{
// When this is called, the BrowserHost is attached, the JSAPI object is
// created, and we are ready to interact with the page and such. The
// PluginWindow may or may not have already fire the AttachedEvent at
// this point.
vlc_open();
}
/*****************************************************************************
* Close the current file and open another
*****************************************************************************/
static bool SwitchFile( access_t *p_access, unsigned i_file )
{
access_sys_t *p_sys = p_access->p_sys;
/* requested file already open? */
if( p_sys->fd != -1 && p_sys->i_current_file == i_file )
return true;
/* close old file */
if( p_sys->fd != -1 )
{
close( p_sys->fd );
p_sys->fd = -1;
}
/* switch */
if( i_file >= FILE_COUNT )
return false;
p_sys->i_current_file = i_file;
/* open new file */
char *psz_path = GetFilePath( p_access, i_file );
if( !psz_path )
return false;
p_sys->fd = vlc_open( psz_path, O_RDONLY );
if( p_sys->fd == -1 )
{
msg_Err( p_access, "Failed to open %s: %s", psz_path,
vlc_strerror_c(errno) );
goto error;
}
/* cannot handle anything except normal files */
struct stat st;
if( fstat( p_sys->fd, &st ) || !S_ISREG( st.st_mode ) )
{
msg_Err( p_access, "%s is not a regular file", psz_path );
goto error;
}
OptimizeForRead( p_sys->fd );
msg_Dbg( p_access, "opened %s", psz_path );
free( psz_path );
return true;
error:
dialog_Fatal (p_access, _("File reading failed"), _("VLC could not"
" open the file \"%s\" (%s)."), psz_path, vlc_strerror(errno) );
if( p_sys->fd != -1 )
{
close( p_sys->fd );
p_sys->fd = -1;
}
free( psz_path );
return false;
}
static int OpenAudioDev( demux_t *p_demux )
{
demux_sys_t *p_sys = p_demux->p_sys;
char *psz_device = p_sys->audio_device;
int i_format = AFMT_S16_LE;
int result;
p_sys->fd_audio = vlc_open( psz_device, O_RDONLY | O_NONBLOCK );
if( p_sys->fd_audio < 0 )
{
msg_Err( p_demux, "Cannot open audio device (%s)", psz_device );
return VLC_EGENERIC;
}
if( !p_sys->i_sample_rate )
p_sys->i_sample_rate = 44100;
result = ioctl( p_sys->fd_audio, SNDCTL_DSP_SETFMT, &i_format );
if( (result < 0) || (i_format != AFMT_S16_LE) )
{
msg_Err( p_demux, "Cannot set audio format (16b little endian) "
"(%d)", i_format );
goto error;
}
result = ioctl( p_sys->fd_audio, SNDCTL_DSP_CHANNELS, &p_sys->channels );
if( result < 0 )
{
msg_Err( p_demux, "Cannot set audio channels count (%d)",
p_sys->channels );
goto error;
}
result = ioctl( p_sys->fd_audio, SNDCTL_DSP_SPEED, &p_sys->i_sample_rate );
if( result < 0 )
{
msg_Err( p_demux, "Cannot set audio sample rate (%d)",
p_sys->i_sample_rate );
goto error;
}
msg_Dbg( p_demux, "Opened adev=`%s' %s %dHz",
psz_device,
(p_sys->channels > 1) ? "stereo" : "mono",
p_sys->i_sample_rate );
p_sys->i_audio_max_frame_size = 32 * 1024;
return VLC_SUCCESS;
error:
CloseAudioDev( p_demux );
p_sys->fd_audio = -1;
return VLC_EGENERIC;
}
/**
* Opens a FILE pointer.
* @param filename file path, using UTF-8 encoding
* @param mode fopen file open mode
* @return NULL on error, an open FILE pointer on success.
*/
FILE *vlc_fopen (const char *filename, const char *mode)
{
int rwflags = 0, oflags = 0;
for (const char *ptr = mode; *ptr; ptr++)
{
switch (*ptr)
{
case 'r':
rwflags = O_RDONLY;
break;
case 'a':
rwflags = O_WRONLY;
oflags |= O_CREAT | O_APPEND;
break;
case 'w':
rwflags = O_WRONLY;
oflags |= O_CREAT | O_TRUNC;
break;
case 'x':
oflags |= O_EXCL;
break;
case '+':
rwflags = O_RDWR;
break;
#ifdef O_BINARY
case 'b':
oflags = (oflags & ~O_TEXT) | O_BINARY;
break;
case 't':
oflags = (oflags & ~O_BINARY) | O_TEXT;
break;
#endif
}
}
int fd = vlc_open (filename, rwflags | oflags, 0666);
if (fd == -1)
return NULL;
FILE *stream = fdopen (fd, mode);
if (stream == NULL)
close (fd);
return stream;
}
int DemuxOpen( vlc_object_t *obj )
{
demux_t *demux = (demux_t *)obj;
demux_sys_t *sys = malloc (sizeof (*sys));
if (unlikely(sys == NULL))
return VLC_ENOMEM;
demux->p_sys = sys;
ParseMRL( obj, demux->psz_location );
char *path = var_InheritString (obj, CFG_PREFIX"dev");
if (unlikely(path == NULL))
goto error; /* probably OOM */
msg_Dbg (obj, "opening device '%s'", path);
int rawfd = vlc_open (path, O_RDWR);
if (rawfd == -1)
{
msg_Err (obj, "cannot open device '%s': %m", path);
free (path);
goto error;
}
free (path);
int fd = v4l2_fd_open (rawfd, 0);
if (fd == -1)
{
msg_Warn (obj, "cannot initialize user-space library: %m");
/* fallback to direct kernel mode anyway */
fd = rawfd;
}
sys->fd = fd;
if (InitVideo (demux, fd))
{
v4l2_close (fd);
goto error;
}
sys->controls = ControlsInit (VLC_OBJECT(demux), fd);
demux->pf_demux = NULL;
demux->pf_control = DemuxControl;
demux->info.i_update = 0;
demux->info.i_title = 0;
demux->info.i_seekpoint = 0;
return VLC_SUCCESS;
error:
free (sys);
return VLC_EGENERIC;
}
/*****************************************************************************
* OpenDecoder: Open the decoder
*****************************************************************************/
static int OpenDecoderCommon( vlc_object_t *p_this, bool b_force_dump )
{
decoder_t *p_dec = (decoder_t*)p_this;
decoder_sys_t *p_sys;
char psz_file[ PATH_MAX ];
/* Allocate the memory needed to store the decoder's structure */
if( ( p_dec->p_sys = p_sys =
(decoder_sys_t *)malloc(sizeof(decoder_sys_t)) ) == NULL )
{
return VLC_ENOMEM;
}
snprintf( psz_file, sizeof( psz_file), "stream.%p", p_dec );
#ifndef UNDER_CE
if( !b_force_dump )
{
b_force_dump = var_CreateGetBool( p_dec, "dummy-save-es" );
}
if( b_force_dump )
{
p_sys->i_fd = vlc_open( psz_file, O_WRONLY | O_CREAT | O_TRUNC, 00644 );
if( p_sys->i_fd == -1 )
{
msg_Err( p_dec, "cannot create `%s'", psz_file );
free( p_sys );
return VLC_EGENERIC;
}
msg_Dbg( p_dec, "dumping stream to file `%s'", psz_file );
}
else
#endif
{
p_sys->i_fd = -1;
}
/* Set callbacks */
p_dec->pf_decode_video = (picture_t *(*)(decoder_t *, block_t **))
DecodeBlock;
p_dec->pf_decode_audio = (aout_buffer_t *(*)(decoder_t *, block_t **))
DecodeBlock;
p_dec->pf_decode_sub = (subpicture_t *(*)(decoder_t *, block_t **))
DecodeBlock;
es_format_Copy( &p_dec->fmt_out, &p_dec->fmt_in );
return VLC_SUCCESS;
}
struct vlc_vaapi_instance *
vlc_vaapi_InitializeInstanceDRM(vlc_object_t *o,
VADisplay (*pf_getDisplayDRM)(int),
VADisplay *pdpy, const char *device)
{
static const char *default_drm_device_paths[] = {
"/dev/dri/renderD128",
"/dev/dri/card0",
"/dev/dri/renderD129",
"/dev/dri/card1",
};
const char *user_drm_device_paths[] = { device };
const char **drm_device_paths;
size_t drm_device_paths_count;
if (device != NULL)
{
drm_device_paths = user_drm_device_paths;
drm_device_paths_count = 1;
}
else
{
drm_device_paths = default_drm_device_paths;
drm_device_paths_count = ARRAY_SIZE(default_drm_device_paths);
}
for (size_t i = 0; i < drm_device_paths_count; i++)
{
int drm_fd = vlc_open(drm_device_paths[i], O_RDWR);
if (drm_fd < 0)
continue;
VADisplay dpy = pf_getDisplayDRM(drm_fd);
if (dpy)
{
struct vlc_vaapi_instance *va_inst =
vlc_vaapi_InitializeInstance(o, dpy,
(VANativeDisplay)(intptr_t)drm_fd,
native_drm_destroy_cb);
if (va_inst)
{
*pdpy = dpy;
return va_inst;
}
}
else
vlc_close(drm_fd);
}
return NULL;
}
vlc_v4l2_vbi_t *OpenVBI (demux_t *demux, const char *psz_device)
{
vlc_v4l2_vbi_t *vbi = malloc (sizeof (*vbi));
if (unlikely(vbi == NULL))
return NULL;
int rawfd = vlc_open (psz_device, O_RDWR);
if (rawfd == -1)
{
msg_Err (demux, "cannot open device '%s': %m", psz_device);
goto err;
}
//Can put more in here. See osd.c in zvbi package.
unsigned int services = VBI_SLICED_CAPTION_525;
char *errstr = NULL;
vbi->cap = vbi_capture_v4l2k_new (psz_device, rawfd,
/* buffers */ 5,
&services,
/* strict */ 1,
&errstr,
/* verbose */ 1);
if (vbi->cap == NULL)
{
msg_Err (demux, "cannot capture VBI data: %s", errstr);
free (errstr);
goto err;
}
for (unsigned i = 0; i < VBI_NUM_CC_STREAMS; i++)
{
es_format_t fmt;
es_format_Init (&fmt, SPU_ES, VLC_FOURCC('c', 'c', '1' + i, ' '));
if (asprintf (&fmt.psz_description, "Closed captions %d", i + 1) >= 0)
{
msg_Dbg (demux, "new spu es %4.4s", (char *)&fmt.i_codec);
vbi->es[i] = es_out_Add (demux->out, &fmt);
}
}
/* Do a single read and throw away the results so that ZVBI calls
the STREAMON ioctl() */
GrabVBI(demux, vbi);
return vbi;
err:
free (vbi);
return NULL;
}
int gzopen_frontend( const char *pathname, int oflags, int mode )
{
(void)mode;
const char *gzflags;
gzFile gzf;
switch( oflags )
{
case O_WRONLY:
gzflags = "wb";
break;
case O_RDONLY:
gzflags = "rb";
break;
case O_RDWR:
default:
errno = EINVAL;
return -1;
}
int fd = vlc_open( pathname, oflags );
if( fd == -1 )
{
fprintf( stderr, "Couldn't open %s\n", pathname );
return -1;
}
gzf = gzdopen( fd, gzflags );
if( !gzf )
{
errno = ENOMEM;
vlc_close( fd );
return -1;
}
/** Hum ... */
currentGzFd = 42;
currentGzVp = gzf;
return currentGzFd;
}
int vlc_mkstemp( char *_template ) // sunqueen modify
{
static const char digits[] = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
static const int i_digits = sizeof(digits)/sizeof(*digits) - 1;
/* */
assert( _template ); // sunqueen modify
/* Check template validity */
const size_t i_length = strlen( _template ); // sunqueen modify
char *psz_rand = &_template[i_length-6]; // sunqueen modify
if( i_length < 6 || strcmp( psz_rand, "XXXXXX" ) )
{
errno = EINVAL;
return -1;
}
/* */
for( int i = 0; i < 256; i++ )
{
/* Create a pseudo random file name */
uint8_t pi_rand[6];
vlc_rand_bytes( pi_rand, sizeof(pi_rand) );
for( int j = 0; j < 6; j++ )
psz_rand[j] = digits[pi_rand[j] % i_digits];
/* */
int fd = vlc_open( _template, O_CREAT | O_EXCL | O_RDWR, 0600 ); // sunqueen modify
if( fd >= 0 )
return fd;
if( errno != EEXIST )
return -1;
}
errno = EEXIST;
return -1;
}
bool Chimera_Win::onWindowAttached( FB::AttachedEvent *evt, FB::PluginWindowWin* w )
{
vlc_open();
m_quickViewPtr.reset( new QQuickView );
m_quickViewPtr->setResizeMode( QQuickView::SizeRootObjectToView );
m_quickViewPtr->setProperty( "_q_embedded_native_parent_handle", WId( w->getHWND() ) );
m_quickViewPtr->setFlags( m_quickViewPtr->flags() | Qt::FramelessWindowHint );
QQmlContext* context = m_quickViewPtr->rootContext();
m_qmlVlcPlayer = new QmlVlcSurfacePlayerProxy( (vlc::player*)this, m_quickViewPtr.data() );
m_qmlVlcPlayer->classBegin();
context->setContextProperty( "vlcPlayer", QVariant::fromValue( m_qmlVlcPlayer ) );
process_startup_options();
m_quickViewPtr->setSource( getQmlSource() );
MoveWindow( (HWND)m_quickViewPtr->winId(), 0, 0, w->getWindowWidth(), w->getWindowHeight(), FALSE );
m_quickViewPtr->show();
return false;
}
/************************************************************************
* CryptSetup: Initialize encryption
************************************************************************/
static int CryptSetup( sout_access_out_t *p_access, char *key_file )
{
sout_access_out_sys_t *p_sys = p_access->p_sys;
uint8_t key[16];
char *keyfile = NULL;
if( !p_sys->key_uri ) /*No key uri, assume no encryption wanted*/
{
msg_Dbg( p_access, "No key uri, no encryption");
return VLC_SUCCESS;
}
if( key_file )
keyfile = strdup( key_file );
else
keyfile = var_InheritString( p_access, SOUT_CFG_PREFIX "key-file" );
if( unlikely(keyfile == NULL) )
{
msg_Err( p_access, "No key-file, no encryption" );
return VLC_EGENERIC;
}
vlc_gcrypt_init();
/*Setup encryption cipher*/
gcry_error_t err = gcry_cipher_open( &p_sys->aes_ctx, GCRY_CIPHER_AES,
GCRY_CIPHER_MODE_CBC, 0 );
if( err )
{
msg_Err( p_access, "Openin AES Cipher failed: %s", gpg_strerror(err));
free( keyfile );
return VLC_EGENERIC;
}
int keyfd = vlc_open( keyfile, O_RDONLY | O_NONBLOCK );
if( unlikely( keyfd == -1 ) )
{
msg_Err( p_access, "Unable to open keyfile %s: %s", keyfile,
vlc_strerror_c(errno) );
free( keyfile );
gcry_cipher_close( p_sys->aes_ctx );
return VLC_EGENERIC;
}
free( keyfile );
ssize_t keylen = read( keyfd, key, 16 );
vlc_close( keyfd );
if( keylen < 16 )
{
msg_Err( p_access, "No key at least 16 octects (you provided %zd), no encryption", keylen );
gcry_cipher_close( p_sys->aes_ctx );
return VLC_EGENERIC;
}
err = gcry_cipher_setkey( p_sys->aes_ctx, key, 16 );
if(err)
{
msg_Err(p_access, "Setting AES key failed: %s", gpg_strerror(err));
gcry_cipher_close( p_sys->aes_ctx );
return VLC_EGENERIC;
}
if( p_sys->b_generate_iv )
vlc_rand_bytes( p_sys->aes_ivs, sizeof(uint8_t)*16);
return VLC_SUCCESS;
}
/****************************************************************************
* OpenVCDImage: try to open a vcd image from a .cue file
****************************************************************************/
static int OpenVCDImage( vlc_object_t * p_this, const char *psz_dev,
vcddev_t *p_vcddev )
{
int i_ret = -1;
char *p_pos;
char *psz_vcdfile = NULL;
char *psz_cuefile = NULL;
FILE *cuefile = NULL;
int *p_sectors = NULL;
char line[1024];
bool b_found = false;
/* Check if we are dealing with a .cue file */
p_pos = strrchr( psz_dev, '.' );
if( p_pos && !strcmp( p_pos, ".cue" ) )
{
/* psz_dev must be the cue file. Let's assume there's a .bin
* file with the same filename */
if( asprintf( &psz_vcdfile, "%.*s.bin", (int)(p_pos - psz_dev),
psz_dev ) < 0 )
psz_vcdfile = NULL;
psz_cuefile = strdup( psz_dev );
}
else
if( p_pos )
{
/* psz_dev must be the actual vcd file. Let's assume there's a .cue
* file with the same filename */
if( asprintf( &psz_cuefile, "%.*s.cue", (int)(p_pos - psz_dev),
psz_dev ) < 0 )
psz_cuefile = NULL;
psz_vcdfile = strdup( psz_dev );
}
else
{
if( asprintf( &psz_cuefile, "%s.cue", psz_dev ) == -1 )
psz_cuefile = NULL;
/* If we need to look up the .cue file, then we don't have to look
* for the vcd */
psz_vcdfile = strdup( psz_dev );
}
if( psz_cuefile == NULL || psz_vcdfile == NULL )
goto error;
/* Open the cue file and try to parse it */
msg_Dbg( p_this,"trying .cue file: %s", psz_cuefile );
cuefile = vlc_fopen( psz_cuefile, "rt" );
if( cuefile == NULL )
{
msg_Dbg( p_this, "could not find .cue file" );
goto error;
}
msg_Dbg( p_this,"guessing vcd image file: %s", psz_vcdfile );
p_vcddev->i_vcdimage_handle = vlc_open( psz_vcdfile,
O_RDONLY | O_NONBLOCK | O_BINARY );
while( fgets( line, 1024, cuefile ) && !b_found )
{
/* We have a cue file, but no valid vcd file yet */
char filename[1024];
char type[16];
int i_temp = sscanf( line, "FILE \"%1023[^\"]\" %15s", filename, type );
switch( i_temp )
{
case 2:
msg_Dbg( p_this, "the cue file says the data file is %s", type );
if( strcasecmp( type, "BINARY" ) )
goto error; /* Error if not binary, otherwise treat as case 1 */
case 1:
if( p_vcddev->i_vcdimage_handle == -1 )
{
msg_Dbg( p_this, "we could not find the data file, but we found a new path" );
free( psz_vcdfile);
if( *filename != '/' && ((p_pos = strrchr( psz_cuefile, '/' ))
|| (p_pos = strrchr( psz_cuefile, '\\' ) )) )
{
psz_vcdfile = malloc( strlen(filename) +
(p_pos - psz_cuefile + 1) + 1 );
strncpy( psz_vcdfile, psz_cuefile, (p_pos - psz_cuefile + 1) );
strcpy( psz_vcdfile + (p_pos - psz_cuefile + 1), filename );
} else psz_vcdfile = strdup( filename );
msg_Dbg( p_this,"using vcd image file: %s", psz_vcdfile );
p_vcddev->i_vcdimage_handle = vlc_open( psz_vcdfile,
O_RDONLY | O_NONBLOCK | O_BINARY );
}
b_found = true;
default:
break;
}
}
if( p_vcddev->i_vcdimage_handle == -1)
goto error;
/* Try to parse the i_tracks and p_sectors info so we can just forget
* about the cuefile */
size_t i_tracks = 0;
while( fgets( line, 1024, cuefile ) && i_tracks < INT_MAX-1 )
{
/* look for a TRACK line */
char psz_dummy[10];
if( !sscanf( line, "%9s", psz_dummy ) || strcmp(psz_dummy, "TRACK") )
continue;
/* look for an INDEX line */
while( fgets( line, 1024, cuefile ) )
{
int i_num, i_min, i_sec, i_frame;
if( (sscanf( line, "%*9s %2u %2u:%2u:%2u", &i_num,
&i_min, &i_sec, &i_frame ) != 4) || (i_num != 1) )
continue;
int *buf = realloc (p_sectors, (i_tracks + 1) * sizeof (*buf));
if (buf == NULL)
goto error;
p_sectors = buf;
p_sectors[i_tracks] = MSF_TO_LBA(i_min, i_sec, i_frame);
msg_Dbg( p_this, "vcd track %i begins at sector:%i",
(int)i_tracks, (int)p_sectors[i_tracks] );
i_tracks++;
break;
}
}
/* fill in the last entry */
int *buf = realloc (p_sectors, (i_tracks + 1) * sizeof (*buf));
if (buf == NULL)
goto error;
p_sectors = buf;
p_sectors[i_tracks] = lseek(p_vcddev->i_vcdimage_handle, 0, SEEK_END)
/ VCD_SECTOR_SIZE;
msg_Dbg( p_this, "vcd track %i, begins at sector:%i",
(int)i_tracks, (int)p_sectors[i_tracks] );
p_vcddev->i_tracks = ++i_tracks;
p_vcddev->p_sectors = p_sectors;
p_sectors = NULL;
i_ret = 0;
error:
if( cuefile ) fclose( cuefile );
free( p_sectors );
free( psz_cuefile );
free( psz_vcdfile );
return i_ret;
}
/*****************************************************************************
* ioctl_Open: Opens a VCD device or file and returns an opaque handle
*****************************************************************************/
vcddev_t *ioctl_Open( vlc_object_t *p_this, const char *psz_dev )
{
int i_ret;
int b_is_file;
vcddev_t *p_vcddev;
#if !defined( _WIN32 ) && !defined( __OS2__ )
struct stat fileinfo;
#endif
if( !psz_dev ) return NULL;
/*
* Initialize structure with default values
*/
p_vcddev = malloc( sizeof(*p_vcddev) );
if( p_vcddev == NULL )
return NULL;
p_vcddev->i_vcdimage_handle = -1;
p_vcddev->psz_dev = NULL;
b_is_file = 1;
/*
* Check if we are dealing with a device or a file (vcd image)
*/
#if defined( _WIN32 ) || defined( __OS2__ )
if( (strlen( psz_dev ) == 2 && psz_dev[1] == ':') )
{
b_is_file = 0;
}
#else
if( vlc_stat( psz_dev, &fileinfo ) < 0 )
{
free( p_vcddev );
return NULL;
}
/* Check if this is a block/char device */
if( S_ISBLK( fileinfo.st_mode ) || S_ISCHR( fileinfo.st_mode ) )
b_is_file = 0;
#endif
if( b_is_file )
{
i_ret = OpenVCDImage( p_this, psz_dev, p_vcddev );
}
else
{
/*
* open the vcd device
*/
#ifdef _WIN32
i_ret = win32_vcd_open( p_this, psz_dev, p_vcddev );
#elif defined( __OS2__ )
i_ret = os2_vcd_open( p_this, psz_dev, p_vcddev );
#else
p_vcddev->i_device_handle = -1;
p_vcddev->i_device_handle = vlc_open( psz_dev, O_RDONLY | O_NONBLOCK );
i_ret = (p_vcddev->i_device_handle == -1) ? -1 : 0;
#endif
}
if( i_ret == 0 )
{
p_vcddev->psz_dev = (char *)strdup( psz_dev );
}
else
{
free( p_vcddev );
p_vcddev = NULL;
}
return p_vcddev;
}
dev = strdup( mrl );
}
if( dev != NULL )
{
var_Create( obj, CFG_PREFIX"dev", VLC_VAR_STRING );
var_SetString( obj, CFG_PREFIX"dev", dev );
free( dev );
}
}
int OpenDevice (vlc_object_t *obj, const char *path, uint32_t *restrict caps)
{
msg_Dbg (obj, "opening device '%s'", path);
int rawfd = vlc_open (path, O_RDWR);
if (rawfd == -1)
{
msg_Err (obj, "cannot open device '%s': %m", path);
return -1;
}
int fd = v4l2_fd_open (rawfd, 0);
if (fd == -1)
{
msg_Warn (obj, "cannot initialize user-space library: %m");
/* fallback to direct kernel mode anyway */
fd = rawfd;
}
/* Get device capabilites */
/*****************************************************************************
* Render: displays previously rendered output
*****************************************************************************
* This function send the currently rendered image to adjust modified image,
* waits until it is displayed and switch the two rendering buffers, preparing
* next frame.
*****************************************************************************/
static subpicture_t *Filter( filter_t *p_filter, mtime_t date )
{
filter_sys_t *p_sys = p_filter->p_sys;
/* We might need to open these at any time. */
vlc_mutex_lock( &p_sys->lock );
if( p_sys->i_inputfd == -1 )
{
p_sys->i_inputfd = vlc_open( p_sys->psz_inputfile, O_RDONLY | O_NONBLOCK );
if( p_sys->i_inputfd == -1 )
{
msg_Warn( p_filter, "Failed to grab input file: %s (%m)",
p_sys->psz_inputfile );
}
else
{
msg_Info( p_filter, "Grabbed input file: %s",
p_sys->psz_inputfile );
}
}
if( p_sys->i_outputfd == -1 )
{
p_sys->i_outputfd = vlc_open( p_sys->psz_outputfile,
O_WRONLY | O_NONBLOCK );
if( p_sys->i_outputfd == -1 )
{
if( errno != ENXIO )
{
msg_Warn( p_filter, "Failed to grab output file: %s (%m)",
p_sys->psz_outputfile );
}
}
else
{
msg_Info( p_filter, "Grabbed output file: %s",
p_sys->psz_outputfile );
}
}
vlc_mutex_unlock( &p_sys->lock );
/* Read any waiting commands */
if( p_sys->i_inputfd != -1 )
{
char p_buffer[1024];
ssize_t i_len = read( p_sys->i_inputfd, p_buffer, 1024 );
if( i_len == -1 )
{
/* We hit an error */
if( errno != EAGAIN )
{
msg_Warn( p_filter, "Error on input file: %m" );
close( p_sys->i_inputfd );
p_sys->i_inputfd = -1;
}
}
else if( i_len == 0 )
{
/* We hit the end-of-file */
}
else
{
BufferAdd( &p_sys->input, p_buffer, i_len );
}
}
/* Parse any complete commands */
char *p_end, *p_cmd;
while( ( p_end = memchr( p_sys->input.p_begin, '\n',
p_sys->input.i_length ) ) )
{
commanddesc_t *p_cur = NULL;
bool b_found = false;
size_t i_index = 0;
*p_end = '\0';
p_cmd = BufferGetToken( &p_sys->input );
msg_Info( p_filter, "Search command: %s", p_cmd );
for( i_index = 0; i_index < p_sys->i_commands; i_index++ )
{
p_cur = p_sys->pp_commands[i_index];
if( !strncmp( p_cur->psz_command, p_cmd, strlen(p_cur->psz_command) ) )
{
p_cmd[strlen(p_cur->psz_command)] = '\0';
b_found = true;
break;
}
}
if( !b_found )
{
/* No matching command */
msg_Err( p_filter, "Got invalid command: %s", p_cmd );
BufferPrintf( &p_sys->output, "FAILURE: %d Invalid Command\n", VLC_EGENERIC );
}
else
{
msg_Info( p_filter, "Got valid command: %s", p_cmd );
command_t *p_cmddesc = malloc( sizeof( command_t ) );
if( !p_cmddesc )
return NULL;
p_cmd = p_cmd + strlen(p_cur->psz_command) +1;
p_cmddesc->p_command = p_cur;
p_cmddesc->p_command->pf_parser( p_cmd, p_end,
&p_cmddesc->params );
if( p_cmddesc->p_command->b_atomic && p_sys->b_atomic )
QueueEnqueue( &p_sys->atomic, p_cmddesc );
else
QueueEnqueue( &p_sys->pending, p_cmddesc );
}
BufferDel( &p_sys->input, p_end - p_sys->input.p_begin + 1 );
}
/* Process any pending commands */
command_t *p_command = NULL;
while( (p_command = QueueDequeue( &p_sys->pending )) )
{
p_command->i_status =
p_command->p_command->pf_execute( p_filter, &p_command->params,
&p_command->results );
QueueEnqueue( &p_sys->processed, p_command );
}
/* Output any processed commands */
while( (p_command = QueueDequeue( &p_sys->processed )) )
{
if( p_command->i_status == VLC_SUCCESS )
{
const char *psz_success = "SUCCESS:";
const char *psz_nl = "\n";
BufferAdd( &p_sys->output, psz_success, 8 );
p_command->p_command->pf_unparse( &p_command->results,
&p_sys->output );
BufferAdd( &p_sys->output, psz_nl, 1 );
}
else
{
BufferPrintf( &p_sys->output, "FAILURE: %d\n",
p_command->i_status );
}
}
/* Try emptying the output buffer */
if( p_sys->i_outputfd != -1 )
{
ssize_t i_len = write( p_sys->i_outputfd, p_sys->output.p_begin,
p_sys->output.i_length );
if( i_len == -1 )
{
/* We hit an error */
if( errno != EAGAIN )
{
msg_Warn( p_filter, "Error on output file: %m" );
close( p_sys->i_outputfd );
p_sys->i_outputfd = -1;
}
}
else
{
BufferDel( &p_sys->output, i_len );
}
}
if( !p_sys->b_updated )
return NULL;
subpicture_t *p_spu = NULL;
overlay_t *p_overlay = NULL;
p_spu = p_filter->pf_sub_buffer_new( p_filter );
if( !p_spu )
{
msg_Err( p_filter, "cannot allocate subpicture" );
return NULL;
}
p_spu->b_absolute = true;
p_spu->i_start = date;
p_spu->i_stop = 0;
p_spu->b_ephemer = true;
subpicture_region_t **pp_region = &p_spu->p_region;
while( (p_overlay = ListWalk( &p_sys->overlays )) )
{
subpicture_region_t *p_region;
*pp_region = p_region = subpicture_region_New( &p_overlay->format );
if( !p_region )
break;
msg_Dbg( p_filter, "Displaying overlay: %4.4s, %d, %d, %d",
(char*)&p_overlay->format.i_chroma, p_overlay->i_x, p_overlay->i_y,
p_overlay->i_alpha );
if( p_overlay->format.i_chroma == VLC_CODEC_TEXT )
{
p_region->psz_text = strdup( p_overlay->data.p_text );
p_region->p_style = text_style_Duplicate( p_overlay->p_fontstyle );
}
else
{
/* FIXME the copy is probably not needed anymore */
picture_Copy( p_region->p_picture, p_overlay->data.p_pic );
}
p_region->i_x = p_overlay->i_x;
p_region->i_y = p_overlay->i_y;
p_region->i_align = SUBPICTURE_ALIGN_LEFT | SUBPICTURE_ALIGN_TOP;
p_region->i_alpha = p_overlay->i_alpha;
pp_region = &p_region->p_next;
}
p_sys->b_updated = false;
return p_spu;
}
bool FBVLC::onWindowAttached(FB::AttachedEvent *evt, FB::PluginWindow *)
{
vlc_open();
return true;
}
/*****************************************************************************
* config_SaveConfigFile: Save a module's config options.
*****************************************************************************
* This will save the specified module's config options to the config file.
* If psz_module_name is NULL then we save all the modules config options.
* It's no use to save the config options that kept their default values, so
* we'll try to be a bit clever here.
*
* When we save we mustn't delete the config options of the modules that
* haven't been loaded. So we cannot just create a new config file with the
* config structures we've got in memory.
* I don't really know how to deal with this nicely, so I will use a completly
* dumb method ;-)
* I will load the config file in memory, but skipping all the sections of the
* modules we want to save. Then I will create a brand new file, dump the file
* loaded in memory and then append the sections of the modules we want to
* save.
* Really stupid no ?
*****************************************************************************/
static int SaveConfigFile( vlc_object_t *p_this, const char *psz_module_name,
bool b_autosave )
{
module_t *p_parser;
char *permanent = NULL, *temporary = NULL;
if( config_PrepareDir( p_this ) )
{
msg_Err( p_this, "no configuration directory" );
return -1;
}
/* List all available modules */
module_t **list = module_list_get (NULL);
char *bigbuf = NULL;
size_t bigsize = 0;
FILE *file = config_OpenConfigFile (p_this);
if (file != NULL)
{
struct stat st;
/* Some users make vlcrc read-only to prevent changes.
* The atomic replacement scheme breaks this "feature",
* so we check for read-only by hand. */
if (fstat (fileno (file), &st)
|| !(st.st_mode & S_IWUSR))
{
msg_Err (p_this, "configuration file is read-only");
goto error;
}
bigsize = (st.st_size < LONG_MAX) ? st.st_size : 0;
bigbuf = malloc (bigsize + 1);
if (bigbuf == NULL)
goto error;
/* backup file into memory, we only need to backup the sections we
* won't save later on */
char *p_index = bigbuf;
char *line = NULL;
size_t bufsize;
ssize_t linelen;
bool backup = false;
while ((linelen = getline (&line, &bufsize, file)) != -1)
{
char *p_index2;
if ((line[0] == '[') && (p_index2 = strchr(line,']')))
{
/* we found a new section, check if we need to do a backup */
backup = true;
for (int i = 0; (p_parser = list[i]) != NULL; i++)
{
if (!strncmp (line + 1, p_parser->psz_object_name,
strlen (p_parser->psz_object_name))
&& ((psz_module_name == NULL)
|| !strcmp (psz_module_name, p_parser->psz_object_name)))
{
backup = false; /* no, we will rewrite it! */
break;
}
}
}
/* save line if requested and line is valid (doesn't begin with a
* space, tab, or eol) */
if (backup && !memchr ("\n\t ", line[0], 3))
{
memcpy (p_index, line, linelen);
p_index += linelen;
}
}
fclose (file);
file = NULL;
free (line);
*p_index = '\0';
bigsize = p_index - bigbuf;
}
/*
* Save module config in file
*/
permanent = config_GetConfigFile (p_this);
if (!permanent)
{
module_list_free (list);
goto error;
}
if (asprintf (&temporary, "%s.%u", permanent, getpid ()) == -1)
{
temporary = NULL;
module_list_free (list);
goto error;
}
/* Configuration lock must be taken before vlcrc serializer below. */
vlc_rwlock_rdlock (&config_lock);
/* The temporary configuration file is per-PID. Therefore SaveConfigFile()
* should be serialized against itself within a given process. */
static vlc_mutex_t lock = VLC_STATIC_MUTEX;
vlc_mutex_lock (&lock);
int fd = vlc_open (temporary, O_CREAT|O_WRONLY|O_TRUNC, S_IRUSR|S_IWUSR);
if (fd == -1)
{
vlc_rwlock_unlock (&config_lock);
vlc_mutex_unlock (&lock);
module_list_free (list);
goto error;
}
file = fdopen (fd, "wt");
if (file == NULL)
{
msg_Err (p_this, "cannot create configuration file: %m");
vlc_rwlock_unlock (&config_lock);
close (fd);
vlc_mutex_unlock (&lock);
module_list_free (list);
goto error;
}
fprintf( file,
"\xEF\xBB\xBF###\n"
"### "PACKAGE_NAME" "PACKAGE_VERSION"\n"
"###\n"
"\n"
"###\n"
"### lines beginning with a '#' character are comments\n"
"###\n"
"\n" );
/* Ensure consistent number formatting... */
locale_t loc = newlocale (LC_NUMERIC_MASK, "C", NULL);
locale_t baseloc = uselocale (loc);
/* We would take the config lock here. But this would cause a lock
* inversion with the serializer above and config_AutoSaveConfigFile().
vlc_rwlock_rdlock (&config_lock);*/
/* Look for the selected module, if NULL then save everything */
for (int i = 0; (p_parser = list[i]) != NULL; i++)
{
module_config_t *p_item, *p_end;
if( psz_module_name && strcmp( psz_module_name,
p_parser->psz_object_name ) )
continue;
if( !p_parser->i_config_items )
continue;
if( psz_module_name )
msg_Dbg( p_this, "saving config for module \"%s\"",
p_parser->psz_object_name );
fprintf( file, "[%s]", p_parser->psz_object_name );
if( p_parser->psz_longname )
fprintf( file, " # %s\n\n", p_parser->psz_longname );
else
fprintf( file, "\n\n" );
for( p_item = p_parser->p_config, p_end = p_item + p_parser->confsize;
p_item < p_end;
p_item++ )
{
if ((p_item->i_type & CONFIG_HINT) /* ignore hint */
|| p_item->b_removed /* ignore deprecated option */
|| p_item->b_unsaveable) /* ignore volatile option */
continue;
/* Do not save the new value in the configuration file
* if doing an autosave, and the item is not an "autosaved" one. */
bool b_retain = b_autosave && !p_item->b_autosave;
if (IsConfigIntegerType (p_item->i_type))
{
int64_t val = b_retain ? p_item->saved.i : p_item->value.i;
config_Write (file, p_item->psz_text,
(p_item->i_type == CONFIG_ITEM_BOOL)
? N_("boolean") : N_("integer"),
val == p_item->orig.i,
p_item->psz_name, "%"PRId64, val);
p_item->saved.i = val;
}
else
if (IsConfigFloatType (p_item->i_type))
{
float val = b_retain ? p_item->saved.f : p_item->value.f;
config_Write (file, p_item->psz_text, N_("float"),
val == p_item->orig.f,
p_item->psz_name, "%f", val);
p_item->saved.f = val;
}
else
{
const char *psz_value = b_retain ? p_item->saved.psz
: p_item->value.psz;
bool modified;
assert (IsConfigStringType (p_item->i_type));
if (b_retain && (psz_value == NULL)) /* FIXME: hack */
psz_value = p_item->orig.psz;
modified =
(psz_value != NULL)
? ((p_item->orig.psz != NULL)
? (strcmp (psz_value, p_item->orig.psz) != 0)
: true)
: (p_item->orig.psz != NULL);
config_Write (file, p_item->psz_text, N_("string"),
!modified, p_item->psz_name, "%s",
psz_value ? psz_value : "");
if ( !b_retain )
{
free ((char *)p_item->saved.psz);
if( (psz_value && p_item->orig.psz &&
strcmp( psz_value, p_item->orig.psz )) ||
!psz_value || !p_item->orig.psz)
p_item->saved.psz = strdupnull (psz_value);
else
p_item->saved.psz = NULL;
}
}
if (!b_retain)
p_item->b_dirty = false;
}
}
vlc_rwlock_unlock (&config_lock);
module_list_free (list);
if (loc != (locale_t)0)
{
uselocale (baseloc);
freelocale (loc);
}
/*
* Restore old settings from the config in file
*/
if (bigsize)
fwrite (bigbuf, 1, bigsize, file);
/*
* Flush to disk and replace atomically
*/
fflush (file); /* Flush from run-time */
if (ferror (file))
{
vlc_unlink (temporary);
vlc_mutex_unlock (&lock);
msg_Err (p_this, "cannot write configuration file");
clearerr (file);
goto error;
}
#ifndef WIN32
#ifdef __APPLE__
fsync (fd); /* Flush from OS */
#else
fdatasync (fd); /* Flush from OS */
#endif
/* Atomically replace the file... */
if (vlc_rename (temporary, permanent))
vlc_unlink (temporary);
/* (...then synchronize the directory, err, TODO...) */
/* ...and finally close the file */
vlc_mutex_unlock (&lock);
#endif
fclose (file);
#ifdef WIN32
/* Windows cannot remove open files nor overwrite existing ones */
vlc_unlink (permanent);
if (vlc_rename (temporary, permanent))
vlc_unlink (temporary);
vlc_mutex_unlock (&lock);
#endif
free (temporary);
free (permanent);
free (bigbuf);
return 0;
error:
if( file )
fclose( file );
free (temporary);
free (permanent);
free (bigbuf);
return -1;
}
/*****************************************************************************
* Open: open the file
*****************************************************************************/
static int Open( vlc_object_t *p_this )
{
sout_access_out_t *p_access = (sout_access_out_t*)p_this;
int fd;
config_ChainParse( p_access, SOUT_CFG_PREFIX, ppsz_sout_options, p_access->p_cfg );
if( !p_access->psz_path )
{
msg_Err( p_access, "no file name specified" );
return VLC_EGENERIC;
}
bool overwrite = var_GetBool (p_access, SOUT_CFG_PREFIX"overwrite");
bool append = var_GetBool( p_access, SOUT_CFG_PREFIX "append" );
if (!strcmp (p_access->psz_access, "fd"))
{
char *end;
fd = strtol (p_access->psz_path, &end, 0);
if (!*p_access->psz_path || *end)
{
msg_Err (p_access, "invalid file descriptor: %s",
p_access->psz_path);
return VLC_EGENERIC;
}
fd = vlc_dup (fd);
if (fd == -1)
{
msg_Err (p_access, "cannot use file descriptor: %s",
vlc_strerror_c(errno));
return VLC_EGENERIC;
}
}
else
if( !strcmp( p_access->psz_path, "-" ) )
{
#if defined( _WIN32 ) || defined( __OS2__ )
setmode (STDOUT_FILENO, O_BINARY);
#endif
fd = vlc_dup (STDOUT_FILENO);
if (fd == -1)
{
msg_Err (p_access, "cannot use standard output: %s",
vlc_strerror_c(errno));
return VLC_EGENERIC;
}
msg_Dbg( p_access, "using stdout" );
}
else
{
const char *path = p_access->psz_path;
char *buf = NULL;
if (var_InheritBool (p_access, SOUT_CFG_PREFIX"format"))
{
buf = str_format_time (path);
path_sanitize (buf);
path = buf;
}
int flags = O_RDWR | O_CREAT | O_LARGEFILE;
if (!overwrite)
flags |= O_EXCL;
if (!append)
flags |= O_TRUNC;
#ifdef O_SYNC
if (var_GetBool (p_access, SOUT_CFG_PREFIX"sync"))
flags |= O_SYNC;
#endif
do
{
fd = vlc_open (path, flags, 0666);
if (fd != -1)
break;
if (fd == -1)
msg_Err (p_access, "cannot create %s: %s", path,
vlc_strerror_c(errno));
if (overwrite || errno != EEXIST)
break;
flags &= ~O_EXCL;
}
while (vlc_dialog_wait_question (p_access, VLC_DIALOG_QUESTION_NORMAL,
_("Keep existing file"),
_("Overwrite"), NULL, path,
_("The output file already exists. "
"If recording continues, the file will be "
"overridden and its content will be lost.")) == 1);
free (buf);
if (fd == -1)
return VLC_EGENERIC;
}
struct stat st;
if (fstat (fd, &st))
{
msg_Err (p_access, "write error: %s", vlc_strerror_c(errno));
close (fd);
return VLC_EGENERIC;
}
p_access->pf_read = Read;
if (S_ISREG(st.st_mode) || S_ISBLK(st.st_mode))
{
p_access->pf_write = Write;
p_access->pf_seek = Seek;
}
#ifdef S_ISSOCK
else if (S_ISSOCK(st.st_mode))
{
p_access->pf_write = Send;
p_access->pf_seek = NoSeek;
}
#endif
else
{
p_access->pf_write = WritePipe;
p_access->pf_seek = NoSeek;
}
p_access->pf_control = Control;
p_access->p_sys = (void *)(intptr_t)fd;
msg_Dbg( p_access, "file access output opened (%s)", p_access->psz_path );
if (append)
lseek (fd, 0, SEEK_END);
return VLC_SUCCESS;
}
/*****************************************************************************
* Open: open the file
*****************************************************************************/
static int Open( vlc_object_t *p_this )
{
sout_access_out_t *p_access = (sout_access_out_t*)p_this;
int fd;
config_ChainParse( p_access, SOUT_CFG_PREFIX, ppsz_sout_options, p_access->p_cfg );
if( !p_access->psz_path )
{
msg_Err( p_access, "no file name specified" );
return VLC_EGENERIC;
}
bool append = var_GetBool( p_access, SOUT_CFG_PREFIX "append" );
if (!strcmp (p_access->psz_access, "fd"))
{
char *end;
fd = strtol (p_access->psz_path, &end, 0);
if (!*p_access->psz_path || *end)
{
msg_Err (p_access, "invalid file descriptor: %s",
p_access->psz_path);
return VLC_EGENERIC;
}
fd = vlc_dup (fd);
if (fd == -1)
{
msg_Err (p_access, "cannot use file descriptor: %m");
return VLC_EGENERIC;
}
}
#ifndef UNDER_CE
else
if( !strcmp( p_access->psz_path, "-" ) )
{
#ifdef WIN32
setmode (fileno (stdout), O_BINARY);
#endif
fd = vlc_dup (fileno (stdout));
if (fd == -1)
{
msg_Err (p_access, "cannot use standard output: %m");
return VLC_EGENERIC;
}
msg_Dbg( p_access, "using stdout" );
}
#endif
else
{
char *psz_tmp = str_format( p_access, p_access->psz_path );
path_sanitize( psz_tmp );
fd = vlc_open( psz_tmp, O_RDWR | O_CREAT | O_LARGEFILE |
#ifdef O_SYNC
(var_GetBool( p_access, SOUT_CFG_PREFIX "sync" ) ? O_SYNC : 0) |
#endif
(append ? 0 : O_TRUNC), 0666 );
free( psz_tmp );
if (fd == -1)
{
msg_Err (p_access, "cannot create %s: %m", p_access->psz_path);
return VLC_EGENERIC;
}
}
p_access->pf_write = Write;
p_access->pf_read = Read;
p_access->pf_seek = Seek;
p_access->pf_control = Control;
p_access->p_sys = (void *)(intptr_t)fd;
msg_Dbg( p_access, "file access output opened (%s)", p_access->psz_path );
if (append)
lseek (fd, 0, SEEK_END);
return VLC_SUCCESS;
}
/*****************************************************************************
* OpenDisplay: initialize framebuffer
*****************************************************************************/
static int OpenDisplay(vout_display_t *vd, bool force_resolution)
{
vout_display_sys_t *sys = vd->sys;
char *psz_device; /* framebuffer device path */
/* Open framebuffer device */
if (!(psz_device = var_InheritString(vd, FB_DEV_VAR))) {
msg_Err(vd, "don't know which fb device to open");
return VLC_EGENERIC;
}
sys->fd = vlc_open(psz_device, O_RDWR);
if (sys->fd == -1) {
msg_Err(vd, "cannot open %s (%s)", psz_device, vlc_strerror_c(errno));
free(psz_device);
return VLC_EGENERIC;
}
free(psz_device);
/* Get framebuffer device information */
if (ioctl(sys->fd, FBIOGET_VSCREENINFO, &sys->var_info)) {
msg_Err(vd, "cannot get fb info (%s)", vlc_strerror_c(errno));
close(sys->fd);
return VLC_EGENERIC;
}
sys->old_info = sys->var_info;
/* Get some info on the framebuffer itself */
if (force_resolution) {
sys->var_info.xres = sys->var_info.xres_virtual = sys->width;
sys->var_info.yres = sys->var_info.yres_virtual = sys->height;
}
/* Set some attributes */
sys->var_info.activate = sys->is_tty ? FB_ACTIVATE_NXTOPEN :
FB_ACTIVATE_NOW;
sys->var_info.xoffset = 0;
sys->var_info.yoffset = 0;
if (ioctl(sys->fd, FBIOPUT_VSCREENINFO, &sys->var_info)) {
msg_Err(vd, "cannot set fb info (%s)", vlc_strerror_c(errno));
close(sys->fd);
return VLC_EGENERIC;
}
struct fb_fix_screeninfo fix_info;
/* Get some information again, in the definitive configuration */
if (ioctl(sys->fd, FBIOGET_FSCREENINFO, &fix_info) ||
ioctl(sys->fd, FBIOGET_VSCREENINFO, &sys->var_info)) {
msg_Err(vd, "cannot get additional fb info (%s)",
vlc_strerror_c(errno));
/* Restore fb config */
ioctl(sys->fd, FBIOPUT_VSCREENINFO, &sys->old_info);
close(sys->fd);
return VLC_EGENERIC;
}
/* If the fb has limitations on mode change,
* then keep the resolution of the fb */
if ((sys->height != sys->var_info.yres) ||
(sys->width != sys->var_info.xres)) {
msg_Warn(vd,
"using framebuffer native resolution instead of requested (%ix%i)",
sys->width, sys->height);
}
sys->height = sys->var_info.yres;
sys->width = sys->var_info.xres_virtual ? sys->var_info.xres_virtual :
sys->var_info.xres;
sys->line_length = fix_info.line_length;
/* FIXME: if the image is full-size, it gets cropped on the left
* because of the xres / xres_virtual slight difference */
msg_Dbg(vd, "%ix%i (virtual %ix%i) (request %ix%i)",
sys->var_info.xres, sys->var_info.yres,
sys->var_info.xres_virtual,
sys->var_info.yres_virtual,
sys->width, sys->height);
sys->palette = NULL;
sys->has_pan = (fix_info.ypanstep || fix_info.ywrapstep);
switch (sys->var_info.bits_per_pixel) {
case 8:
sys->palette = malloc(4 * 256 * sizeof(uint16_t));
if (!sys->palette) {
/* Restore fb config */
ioctl(sys->fd, FBIOPUT_VSCREENINFO, &sys->old_info);
close(sys->fd);
return VLC_ENOMEM;
}
sys->fb_cmap.start = 0;
sys->fb_cmap.len = 256;
sys->fb_cmap.red = sys->palette;
sys->fb_cmap.green = sys->palette + 256;
sys->fb_cmap.blue = sys->palette + 2 * 256;
sys->fb_cmap.transp = sys->palette + 3 * 256;
/* Save the colormap */
ioctl(sys->fd, FBIOGETCMAP, &sys->fb_cmap);
sys->bytes_per_pixel = 1;
break;
case 15:
case 16:
sys->bytes_per_pixel = 2;
break;
case 24:
sys->bytes_per_pixel = 3;
break;
case 32:
sys->bytes_per_pixel = 4;
break;
default:
msg_Err(vd, "screen depth %d is not supported",
sys->var_info.bits_per_pixel);
/* Restore fb config */
ioctl(sys->fd, FBIOPUT_VSCREENINFO, &sys->old_info);
close(sys->fd);
return VLC_EGENERIC;
}
sys->video_size = sys->line_length * sys->var_info.yres_virtual;
/* Map a framebuffer at the beginning */
sys->video_ptr = mmap(NULL, sys->video_size,
PROT_READ | PROT_WRITE, MAP_SHARED, sys->fd, 0);
if (sys->video_ptr == MAP_FAILED) {
msg_Err(vd, "cannot map video memory (%s)", vlc_strerror_c(errno));
if (sys->var_info.bits_per_pixel == 8) {
free(sys->palette);
sys->palette = NULL;
}
/* Restore fb config */
ioctl(sys->fd, FBIOPUT_VSCREENINFO, &sys->old_info);
close(sys->fd);
return VLC_EGENERIC;
}
ClearScreen(sys);
msg_Dbg(vd,
"framebuffer type=%d, visual=%d, ypanstep=%d, ywrap=%d, accel=%d",
fix_info.type, fix_info.visual,
fix_info.ypanstep, fix_info.ywrapstep, fix_info.accel);
return VLC_SUCCESS;
}
/*****************************************************************************
* FrontendOpen : Determine frontend device information and capabilities
*****************************************************************************/
int FrontendOpen( access_t *p_access )
{
access_sys_t *p_sys = p_access->p_sys;
frontend_t * p_frontend;
unsigned int i_adapter, i_device;
bool b_probe;
char frontend[128];
i_adapter = var_GetInteger( p_access, "dvb-adapter" );
i_device = var_GetInteger( p_access, "dvb-device" );
b_probe = var_GetBool( p_access, "dvb-probe" );
if( snprintf( frontend, sizeof(frontend), FRONTEND, i_adapter, i_device ) >= (int)sizeof(frontend) )
{
msg_Err( p_access, "snprintf() truncated string for FRONTEND" );
frontend[sizeof(frontend) - 1] = '\0';
}
p_sys->p_frontend = p_frontend = malloc( sizeof(frontend_t) );
if( !p_frontend )
return VLC_ENOMEM;
msg_Dbg( p_access, "Opening device %s", frontend );
if( (p_sys->i_frontend_handle = vlc_open(frontend, O_RDWR | O_NONBLOCK)) < 0 )
{
msg_Err( p_access, "FrontEndOpen: opening device failed (%m)" );
free( p_frontend );
return VLC_EGENERIC;
}
if( b_probe )
{
const char * psz_expected = NULL;
const char * psz_real;
if( FrontendInfo( p_access ) < 0 )
{
close( p_sys->i_frontend_handle );
free( p_frontend );
return VLC_EGENERIC;
}
switch( p_frontend->info.type )
{
case FE_OFDM:
psz_real = "DVB-T";
break;
case FE_QAM:
psz_real = "DVB-C";
break;
case FE_QPSK:
psz_real = "DVB-S";
break;
case FE_ATSC:
psz_real = "ATSC";
break;
default:
psz_real = "unknown";
}
/* Sanity checks */
if( (!strncmp( p_access->psz_access, "qpsk", 4 ) ||
!strncmp( p_access->psz_access, "dvb-s", 5 ) ||
!strncmp( p_access->psz_access, "satellite", 9 ) ) &&
(p_frontend->info.type != FE_QPSK) )
{
psz_expected = "DVB-S";
}
if( (!strncmp( p_access->psz_access, "cable", 5 ) ||
!strncmp( p_access->psz_access, "dvb-c", 5 ) ) &&
(p_frontend->info.type != FE_QAM) )
{
psz_expected = "DVB-C";
}
if( (!strncmp( p_access->psz_access, "terrestrial", 11 ) ||
!strncmp( p_access->psz_access, "dvb-t", 5 ) ) &&
(p_frontend->info.type != FE_OFDM) )
{
psz_expected = "DVB-T";
}
if( (!strncmp( p_access->psz_access, "usdigital", 9 ) ||
!strncmp( p_access->psz_access, "atsc", 4 ) ) &&
(p_frontend->info.type != FE_ATSC) )
{
psz_expected = "ATSC";
}
if( psz_expected != NULL )
{
msg_Err( p_access, "requested type %s not supported by %s tuner",
psz_expected, psz_real );
close( p_sys->i_frontend_handle );
free( p_frontend );
return VLC_EGENERIC;
}
}
else /* no frontend probing is done so use default border values. */
{
msg_Dbg( p_access, "using default values for frontend info" );
msg_Dbg( p_access, "method of access is %s", p_access->psz_access );
p_frontend->info.type = FE_QPSK;
if( !strncmp( p_access->psz_access, "qpsk", 4 ) ||
!strncmp( p_access->psz_access, "dvb-s", 5 ) )
p_frontend->info.type = FE_QPSK;
else if( !strncmp( p_access->psz_access, "cable", 5 ) ||
!strncmp( p_access->psz_access, "dvb-c", 5 ) )
p_frontend->info.type = FE_QAM;
else if( !strncmp( p_access->psz_access, "terrestrial", 11 ) ||
!strncmp( p_access->psz_access, "dvb-t", 5 ) )
p_frontend->info.type = FE_OFDM;
else if( !strncmp( p_access->psz_access, "usdigital", 9 ) ||
!strncmp( p_access->psz_access, "atsc", 4 ) )
p_frontend->info.type = FE_ATSC;
}
return VLC_SUCCESS;
}
ATMO_BOOL CAtmoClassicConnection::OpenConnection() {
#if defined(_ATMO_VLC_PLUGIN_)
char *serdevice = m_pAtmoConfig->getSerialDevice();
if(!serdevice)
return ATMO_FALSE;
#else
int portNummer = m_pAtmoConfig->getComport();
m_dwLastWin32Error = 0;
if(portNummer < 1) return ATMO_FALSE; // make no real sense;-)
#endif
CloseConnection();
#if !defined(_ATMO_VLC_PLUGIN_)
char serdevice[16]; // com4294967295
sprintf(serdevice,"com%d",portNummer);
#endif
#if defined(_WIN32)
m_hComport = CreateFileA(serdevice, GENERIC_WRITE, 0, NULL, OPEN_EXISTING, 0, NULL);
if(m_hComport == INVALID_HANDLE_VALUE) {
// we have a problem here can't open com port... somebody else may use it?
// m_dwLastWin32Error = GetLastError();
return ATMO_FALSE;
}
/* change serial settings (Speed, stopbits etc.) */
DCB dcb; // für comport-parameter
dcb.DCBlength = sizeof(DCB);
GetCommState (m_hComport, &dcb); // ger current serialport settings
dcb.BaudRate = 38400; // set speed
dcb.ByteSize = 8; // set databits
dcb.Parity = NOPARITY; // set parity
dcb.StopBits = ONESTOPBIT; // set one stop bit
SetCommState (m_hComport, &dcb); // apply settings
#else
int bconst = B38400;
m_hComport = vlc_open(serdevice,O_RDWR | O_NOCTTY);
if(m_hComport < 0) {
return ATMO_FALSE;
}
struct termios tio;
memset(&tio,0,sizeof(tio));
tio.c_cflag = (CS8 | CREAD | HUPCL | CLOCAL);
tio.c_iflag = (INPCK | BRKINT);
cfsetispeed(&tio, bconst);
cfsetospeed(&tio, bconst);
if(!tcsetattr(m_hComport, TCSANOW, &tio)) {
tcflush(m_hComport, TCIOFLUSH);
} else {
// can't change parms
close(m_hComport);
m_hComport = -1;
return false;
}
#endif
return true;
}
/*****************************************************************************
* Open: open the audio device (the digital sound processor)
*****************************************************************************
* This function opens the DSP as a usual non-blocking write-only file, and
* modifies the p_aout->p_sys->i_fd with the file's descriptor.
*****************************************************************************/
static int Open( vlc_object_t *p_this )
{
audio_output_t * p_aout = (audio_output_t *)p_this;
struct aout_sys_t * p_sys;
char * psz_device;
vlc_value_t val;
/* Allocate structure */
p_aout->sys = p_sys = malloc( sizeof( aout_sys_t ) );
if( p_sys == NULL )
return VLC_ENOMEM;
/* Get device name */
if( (psz_device = var_InheritString( p_aout, "oss-audio-device" )) == NULL )
{
msg_Err( p_aout, "no audio device specified (maybe /dev/dsp?)" );
free( p_sys );
return VLC_EGENERIC;
}
/* Open the sound device in non-blocking mode, because ALSA's OSS
* emulation and some broken OSS drivers would make a blocking call
* wait forever until the device is available. Since this breaks the
* OSS spec, we immediately put it back to blocking mode if the
* operation was successful. */
p_sys->i_fd = vlc_open( psz_device, O_WRONLY | O_NDELAY );
if( p_sys->i_fd < 0 )
{
msg_Err( p_aout, "cannot open audio device (%s)", psz_device );
free( psz_device );
free( p_sys );
return VLC_EGENERIC;
}
/* if the opening was ok, put the device back in blocking mode */
fcntl( p_sys->i_fd, F_SETFL,
fcntl( p_sys->i_fd, F_GETFL ) &~ FNDELAY );
free( psz_device );
p_aout->pf_play = aout_PacketPlay;
p_aout->pf_pause = aout_PacketPause;
p_aout->pf_flush = aout_PacketFlush;
if ( var_Type( p_aout, "audio-device" ) == 0 )
Probe( p_aout );
var_AddCallback( p_aout, "audio-device", aout_ChannelsRestart, NULL );
if ( var_Get( p_aout, "audio-device", &val ) < 0 )
/* Probe() has failed. */
goto error;
if ( val.i_int == AOUT_VAR_SPDIF )
{
p_aout->format.i_format = VLC_CODEC_SPDIFL;
}
else if ( val.i_int == AOUT_VAR_5_1 )
{
p_aout->format.i_format = VLC_CODEC_S16N;
p_aout->format.i_physical_channels
= AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT | AOUT_CHAN_CENTER
| AOUT_CHAN_REARLEFT | AOUT_CHAN_REARRIGHT
| AOUT_CHAN_LFE;
}
else if ( val.i_int == AOUT_VAR_2F2R )
{
p_aout->format.i_format = VLC_CODEC_S16N;
p_aout->format.i_physical_channels
= AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT
| AOUT_CHAN_REARLEFT | AOUT_CHAN_REARRIGHT;
}
else if ( val.i_int == AOUT_VAR_STEREO )
{
p_aout->format.i_format = VLC_CODEC_S16N;
p_aout->format.i_physical_channels
= AOUT_CHAN_LEFT | AOUT_CHAN_RIGHT;
}
else if ( val.i_int == AOUT_VAR_MONO )
{
p_aout->format.i_format = VLC_CODEC_S16N;
p_aout->format.i_physical_channels = AOUT_CHAN_CENTER;
}
else
{
/* This should not happen ! */
msg_Err( p_aout, "internal: can't find audio-device (%"PRId64")",
val.i_int );
goto error;
}
var_TriggerCallback( p_aout, "intf-change" );
/* Reset the DSP device */
if( ioctl( p_sys->i_fd, SNDCTL_DSP_RESET, NULL ) < 0 )
{
msg_Err( p_aout, "cannot reset OSS audio device" );
goto error;
}
/* Set the output format */
if ( AOUT_FMT_SPDIF( &p_aout->format ) )
{
int i_format = AFMT_AC3;
if( ioctl( p_sys->i_fd, SNDCTL_DSP_SETFMT, &i_format ) < 0
|| i_format != AFMT_AC3 )
{
msg_Err( p_aout, "cannot reset OSS audio device" );
goto error;
}
p_aout->format.i_format = VLC_CODEC_SPDIFL;
p_aout->format.i_bytes_per_frame = AOUT_SPDIF_SIZE;
p_aout->format.i_frame_length = A52_FRAME_NB;
aout_PacketInit( p_aout, &p_sys->packet, A52_FRAME_NB );
aout_VolumeNoneInit( p_aout );
}
else
{
unsigned int i_format = AFMT_S16_NE;
unsigned int i_frame_size, i_fragments;
unsigned int i_rate;
unsigned int i_nb_channels;
audio_buf_info audio_buf;
if( ioctl( p_sys->i_fd, SNDCTL_DSP_SETFMT, &i_format ) < 0 )
{
msg_Err( p_aout, "cannot set audio output format" );
goto error;
}
switch ( i_format )
{
case AFMT_U8:
p_aout->format.i_format = VLC_CODEC_U8;
break;
case AFMT_S8:
p_aout->format.i_format = VLC_CODEC_S8;
break;
case AFMT_U16_LE:
p_aout->format.i_format = VLC_CODEC_U16L;
break;
case AFMT_S16_LE:
p_aout->format.i_format = VLC_CODEC_S16L;
break;
case AFMT_U16_BE:
p_aout->format.i_format = VLC_CODEC_U16B;
break;
case AFMT_S16_BE:
p_aout->format.i_format = VLC_CODEC_S16B;
break;
default:
msg_Err( p_aout, "OSS fell back to an unknown format (%d)",
i_format );
goto error;
}
i_nb_channels = aout_FormatNbChannels( &p_aout->format );
/* Set the number of channels */
if( ioctl( p_sys->i_fd, SNDCTL_DSP_CHANNELS, &i_nb_channels ) < 0 ||
i_nb_channels != aout_FormatNbChannels( &p_aout->format ) )
{
msg_Err( p_aout, "cannot set number of audio channels (%s)",
aout_FormatPrintChannels( &p_aout->format) );
goto error;
}
/* Set the output rate */
i_rate = p_aout->format.i_rate;
if( ioctl( p_sys->i_fd, SNDCTL_DSP_SPEED, &i_rate ) < 0 )
{
msg_Err( p_aout, "cannot set audio output rate (%i)",
p_aout->format.i_rate );
goto error;
}
if( i_rate != p_aout->format.i_rate )
{
p_aout->format.i_rate = i_rate;
}
/* Set the fragment size */
aout_FormatPrepare( &p_aout->format );
/* i_fragment = xxxxyyyy where: xxxx is fragtotal
* 1 << yyyy is fragsize */
i_frame_size = ((uint64_t)p_aout->format.i_bytes_per_frame * p_aout->format.i_rate * 65536) / (48000 * 2 * 2) / FRAME_COUNT;
i_fragments = 4;
while( i_fragments < 12 && (1U << i_fragments) < i_frame_size )
{
++i_fragments;
}
i_fragments |= FRAME_COUNT << 16;
if( ioctl( p_sys->i_fd, SNDCTL_DSP_SETFRAGMENT, &i_fragments ) < 0 )
{
msg_Warn( p_aout, "cannot set fragment size (%.8x)", i_fragments );
}
if( ioctl( p_sys->i_fd, SNDCTL_DSP_GETOSPACE, &audio_buf ) < 0 )
{
msg_Err( p_aout, "cannot get fragment size" );
goto error;
}
/* Number of fragments actually allocated */
p_aout->sys->i_fragstotal = audio_buf.fragstotal;
/* Maximum duration the soundcard's buffer can hold */
p_aout->sys->max_buffer_duration =
(mtime_t)audio_buf.fragstotal * audio_buf.fragsize * 1000000
/ p_aout->format.i_bytes_per_frame
/ p_aout->format.i_rate
* p_aout->format.i_frame_length;
aout_PacketInit( p_aout, &p_sys->packet,
audio_buf.fragsize/p_aout->format.i_bytes_per_frame );
aout_VolumeSoftInit( p_aout );
}
/* Create OSS thread and wait for its readiness. */
if( vlc_clone( &p_sys->thread, OSSThread, p_aout,
VLC_THREAD_PRIORITY_OUTPUT ) )
{
msg_Err( p_aout, "cannot create OSS thread (%m)" );
aout_PacketDestroy( p_aout );
goto error;
}
return VLC_SUCCESS;
error:
var_DelCallback( p_aout, "audio-device", aout_ChannelsRestart, NULL );
close( p_sys->i_fd );
free( p_sys );
return VLC_EGENERIC;
}
/**
* Saves the in-memory configuration into a file.
* @return 0 on success, -1 on error.
*/
int config_SaveConfigFile (vlc_object_t *p_this)
{
if( config_PrepareDir( p_this ) )
{
msg_Err( p_this, "no configuration directory" );
return -1;
}
/*
* Save module config in file
*/
char *temporary;
char *permanent = config_GetConfigFile (p_this);
if (permanent == NULL)
return -1;
if (asprintf (&temporary, "%s.%u", permanent, getpid ()) == -1)
{
free (permanent);
return -1;
}
else
{
struct stat st;
/* Some users make vlcrc read-only to prevent changes.
* The atomic replacement scheme breaks this "feature",
* so we check for read-only by hand. */
if (stat (permanent, &st) == 0 && !(st.st_mode & S_IWUSR))
{
msg_Err (p_this, "configuration file is read-only");
goto error;
}
}
/* Configuration lock must be taken before vlcrc serializer below. */
vlc_rwlock_rdlock (&config_lock);
/* The temporary configuration file is per-PID. Therefore this function
* should be serialized against itself within a given process. */
static vlc_mutex_t lock = VLC_STATIC_MUTEX;
vlc_mutex_lock (&lock);
int fd = vlc_open (temporary, O_CREAT|O_WRONLY|O_TRUNC, S_IRUSR|S_IWUSR);
if (fd == -1)
{
vlc_rwlock_unlock (&config_lock);
vlc_mutex_unlock (&lock);
goto error;
}
FILE *file = fdopen (fd, "wt");
if (file == NULL)
{
msg_Err (p_this, "cannot create configuration file: %s",
vlc_strerror_c(errno));
vlc_rwlock_unlock (&config_lock);
close (fd);
vlc_mutex_unlock (&lock);
goto error;
}
fprintf( file,
"\xEF\xBB\xBF###\n"
"### "PACKAGE_NAME" "PACKAGE_VERSION"\n"
"###\n"
"\n"
"###\n"
"### lines beginning with a '#' character are comments\n"
"###\n"
"\n" );
/* Ensure consistent number formatting... */
locale_t loc = newlocale (LC_NUMERIC_MASK, "C", NULL);
locale_t baseloc = uselocale (loc);
/* We would take the config lock here. But this would cause a lock
* inversion with the serializer above and config_AutoSaveConfigFile().
vlc_rwlock_rdlock (&config_lock);*/
/* Look for the selected module, if NULL then save everything */
size_t count;
module_t **list = module_list_get (&count);
for (size_t i = 0; i < count; i++)
{
module_t *p_parser = list[i];
module_config_t *p_item, *p_end;
if( !p_parser->i_config_items )
continue;
fprintf( file, "[%s]", module_get_object (p_parser) );
if( p_parser->psz_longname )
fprintf( file, " # %s\n\n", p_parser->psz_longname );
else
fprintf( file, "\n\n" );
for( p_item = p_parser->p_config, p_end = p_item + p_parser->confsize;
p_item < p_end;
p_item++ )
{
if (!CONFIG_ITEM(p_item->i_type) /* ignore hint */
|| p_item->b_removed /* ignore deprecated option */
|| p_item->b_unsaveable) /* ignore volatile option */
continue;
if (IsConfigIntegerType (p_item->i_type))
{
int64_t val = p_item->value.i;
config_Write (file, p_item->psz_text,
(CONFIG_CLASS(p_item->i_type) == CONFIG_ITEM_BOOL)
? N_("boolean") : N_("integer"),
val == p_item->orig.i,
p_item->psz_name, "%"PRId64, val);
}
else
if (IsConfigFloatType (p_item->i_type))
{
float val = p_item->value.f;
config_Write (file, p_item->psz_text, N_("float"),
val == p_item->orig.f,
p_item->psz_name, "%f", val);
}
else
{
const char *psz_value = p_item->value.psz;
bool modified;
assert (IsConfigStringType (p_item->i_type));
modified = !!strcmp (psz_value ? psz_value : "",
p_item->orig.psz ? p_item->orig.psz : "");
config_Write (file, p_item->psz_text, N_("string"),
!modified, p_item->psz_name, "%s",
psz_value ? psz_value : "");
}
}
}
vlc_rwlock_unlock (&config_lock);
module_list_free (list);
if (loc != (locale_t)0)
{
uselocale (baseloc);
freelocale (loc);
}
/*
* Flush to disk and replace atomically
*/
fflush (file); /* Flush from run-time */
if (ferror (file))
{
vlc_unlink (temporary);
vlc_mutex_unlock (&lock);
msg_Err (p_this, "cannot write configuration file");
fclose (file);
goto error;
}
#if defined(__APPLE__) || defined(__ANDROID__)
fsync (fd); /* Flush from OS */
#else
fdatasync (fd); /* Flush from OS */
#endif
#if defined (_WIN32) || defined (__OS2__)
/* Windows cannot (re)move open files nor overwrite existing ones */
fclose (file);
vlc_unlink (permanent);
#endif
/* Atomically replace the file... */
if (vlc_rename (temporary, permanent))
vlc_unlink (temporary);
/* (...then synchronize the directory, err, TODO...) */
/* ...and finally close the file */
vlc_mutex_unlock (&lock);
#if !defined (_WIN32) && !defined (__OS2__)
fclose (file);
#endif
free (temporary);
free (permanent);
return 0;
error:
free (temporary);
free (permanent);
return -1;
}
static int Create( vlc_va_t *va, AVCodecContext *ctx, enum PixelFormat pix_fmt,
const es_format_t *fmt, picture_sys_t *p_sys )
{
if( pix_fmt != AV_PIX_FMT_VAAPI_VLD )
return VLC_EGENERIC;
(void) fmt;
(void) p_sys;
#ifdef VLC_VA_BACKEND_XLIB
if( !vlc_xlib_init( VLC_OBJECT(va) ) )
{
msg_Warn( va, "Ignoring VA-X11 API" );
return VLC_EGENERIC;
}
#endif
VAProfile i_profile, *p_profiles_list;
bool b_supported_profile = false;
int i_profiles_nb = 0;
unsigned count = 3;
/* */
switch( ctx->codec_id )
{
case AV_CODEC_ID_MPEG1VIDEO:
case AV_CODEC_ID_MPEG2VIDEO:
i_profile = VAProfileMPEG2Main;
count = 4;
break;
case AV_CODEC_ID_MPEG4:
i_profile = VAProfileMPEG4AdvancedSimple;
break;
case AV_CODEC_ID_WMV3:
i_profile = VAProfileVC1Main;
break;
case AV_CODEC_ID_VC1:
i_profile = VAProfileVC1Advanced;
break;
case AV_CODEC_ID_H264:
i_profile = VAProfileH264High;
count = 18;
break;;
default:
return VLC_EGENERIC;
}
count += ctx->thread_count;
vlc_va_sys_t *sys;
void *mem;
assert(popcount(sizeof (sys->surfaces)) == 1);
if (unlikely(posix_memalign(&mem, sizeof (sys->surfaces), sizeof (*sys))))
return VLC_ENOMEM;
sys = mem;
memset(sys, 0, sizeof (*sys));
/* */
sys->hw_ctx.display = NULL;
sys->hw_ctx.config_id = VA_INVALID_ID;
sys->hw_ctx.context_id = VA_INVALID_ID;
sys->width = ctx->coded_width;
sys->height = ctx->coded_height;
sys->count = count;
sys->available = (1 << sys->count) - 1;
assert(count < sizeof (sys->available) * CHAR_BIT);
assert(count * sizeof (sys->surfaces[0]) <= sizeof (sys->surfaces));
/* Create a VA display */
#ifdef VLC_VA_BACKEND_XLIB
sys->p_display_x11 = XOpenDisplay(NULL);
if( !sys->p_display_x11 )
{
msg_Err( va, "Could not connect to X server" );
goto error;
}
sys->hw_ctx.display = vaGetDisplay(sys->p_display_x11);
#endif
#ifdef VLC_VA_BACKEND_DRM
sys->drm_fd = vlc_open("/dev/dri/card0", O_RDWR);
if( sys->drm_fd == -1 )
{
msg_Err( va, "Could not access rendering device: %m" );
goto error;
}
sys->hw_ctx.display = vaGetDisplayDRM(sys->drm_fd);
#endif
if (sys->hw_ctx.display == NULL)
{
msg_Err( va, "Could not get a VAAPI device" );
goto error;
}
int major, minor;
if (vaInitialize(sys->hw_ctx.display, &major, &minor))
{
msg_Err( va, "Failed to initialize the VAAPI device" );
goto error;
}
/* Check if the selected profile is supported */
i_profiles_nb = vaMaxNumProfiles(sys->hw_ctx.display);
p_profiles_list = calloc( i_profiles_nb, sizeof( VAProfile ) );
if( !p_profiles_list )
goto error;
if (vaQueryConfigProfiles(sys->hw_ctx.display, p_profiles_list,
&i_profiles_nb) == VA_STATUS_SUCCESS)
{
for( int i = 0; i < i_profiles_nb; i++ )
{
if ( p_profiles_list[i] == i_profile )
{
b_supported_profile = true;
break;
}
}
}
free( p_profiles_list );
if ( !b_supported_profile )
{
msg_Dbg( va, "Codec and profile not supported by the hardware" );
goto error;
}
/* Create a VA configuration */
VAConfigAttrib attrib;
memset( &attrib, 0, sizeof(attrib) );
attrib.type = VAConfigAttribRTFormat;
if (vaGetConfigAttributes(sys->hw_ctx.display, i_profile, VAEntrypointVLD,
&attrib, 1))
goto error;
/* Not sure what to do if not, I don't have a way to test */
if( (attrib.value & VA_RT_FORMAT_YUV420) == 0 )
goto error;
if (vaCreateConfig(sys->hw_ctx.display, i_profile, VAEntrypointVLD,
&attrib, 1, &sys->hw_ctx.config_id))
{
sys->hw_ctx.config_id = VA_INVALID_ID;
goto error;
}
/* Create surfaces */
assert(ctx->coded_width > 0 && ctx->coded_height > 0);
if (vaCreateSurfaces(sys->hw_ctx.display, VA_RT_FORMAT_YUV420,
ctx->coded_width, ctx->coded_height,
sys->surfaces, sys->count, NULL, 0))
{
goto error;
}
/* Create a context */
if (vaCreateContext(sys->hw_ctx.display, sys->hw_ctx.config_id,
ctx->coded_width, ctx->coded_height, VA_PROGRESSIVE,
sys->surfaces, sys->count, &sys->hw_ctx.context_id))
{
sys->hw_ctx.context_id = VA_INVALID_ID;
vaDestroySurfaces(sys->hw_ctx.display, sys->surfaces, sys->count);
goto error;
}
if (FindFormat(sys))
goto error;
if (unlikely(CopyInitCache(&sys->image_cache, ctx->coded_width)))
goto error;
vlc_mutex_init(&sys->lock);
msg_Dbg(va, "using %s image format 0x%08x",
sys->do_derive ? "derive" : "get", sys->format.fourcc);
ctx->hwaccel_context = &sys->hw_ctx;
va->sys = sys;
va->description = vaQueryVendorString(sys->hw_ctx.display);
va->get = Get;
va->release = Release;
va->extract = Extract;
return VLC_SUCCESS;
error:
if (sys->hw_ctx.context_id != VA_INVALID_ID)
{
vaDestroyContext(sys->hw_ctx.display, sys->hw_ctx.context_id);
vaDestroySurfaces(sys->hw_ctx.display, sys->surfaces, sys->count);
}
if (sys->hw_ctx.config_id != VA_INVALID_ID)
vaDestroyConfig(sys->hw_ctx.display, sys->hw_ctx.config_id);
if (sys->hw_ctx.display != NULL)
vaTerminate(sys->hw_ctx.display);
#ifdef VLC_VA_BACKEND_XLIB
if( sys->p_display_x11 != NULL )
XCloseDisplay( sys->p_display_x11 );
#endif
#ifdef VLC_VA_BACKEND_DRM
if( sys->drm_fd != -1 )
close( sys->drm_fd );
#endif
free( sys );
return VLC_EGENERIC;
}
