int vlc_open (const char *filename, int flags, ...)
{
unsigned int mode = 0;
va_list ap;
va_start (ap, flags);
if (flags & O_CREAT)
mode = va_arg (ap, unsigned int);
va_end (ap);
const char *local_name = ToLocaleDup (filename);
if (local_name == NULL)
{
errno = ENOENT;
return -1;
}
int fd = open (local_name, flags, mode);
if (fd != -1)
fcntl (fd, F_SETFD, FD_CLOEXEC);
free (local_name);
return fd;
}
/**
* Formats an UTF-8 string as vfprintf(), then print it, with
* appropriate conversion to local encoding.
*/
int utf8_vfprintf( FILE *stream, const char *fmt, va_list ap )
{
#ifdef ASSUME_UTF8
return vfprintf (stream, fmt, ap);
#else
char *str;
int res;
# if defined( WIN32 ) && !defined( UNDER_CE )
/* Writing to the console is a lot of fun on Microsoft Windows.
* If you use the standard I/O functions, you must use the OEM code page,
* which is different from the usual ANSI code page. Or maybe not, if the
* user called "chcp". Anyway, we prefer Unicode. */
int fd = _fileno (stream);
if (likely(fd != -1) && _isatty (fd))
{
res = vasprintf (&str, fmt, ap);
if (unlikely(res == -1))
return -1;
size_t wlen = 2 * (res + 1);
wchar_t *wide = malloc (wlen);
if (likely(wide != NULL))
{
wlen = MultiByteToWideChar (CP_UTF8, 0, str, res + 1, wide, wlen);
if (wlen > 0)
{
HANDLE h = (HANDLE)(intptr_t)_get_osfhandle (fd);
DWORD out;
WriteConsoleW (h, wide, wlen - 1, &out, NULL);
}
else
res = -1;
free (wide);
}
else
res = -1;
free (str);
return res;
}
# endif
res = vasprintf (&str, fmt, ap);
if (unlikely(res == -1))
return -1;
char *ansi = ToLocaleDup (str);
free (str);
if (ansi == NULL)
return -1;
fputs (ansi, stream);
free (ansi);
return res;
#endif
}
int vlc_rename (const char *oldpath, const char *newpath)
{
const char *lo = ToLocaleDup (oldpath);
if (lo == NULL)
goto error;
const char *ln = ToLocaleDup (newpath);
if (ln == NULL)
{
free (lo);
error:
errno = ENOENT;
return -1;
}
int ret = rename (lo, ln);
free (lo);
free (ln);
return ret;
}
/**
* Determines the current working directory.
*
* @return the current working directory (must be free()'d)
* or NULL on error
*/
char *vlc_getcwd (void)
{
/* Try $PWD */
const char *pwd = getenv ("PWD");
if (pwd != NULL)
{
struct stat s1, s2;
/* Make sure $PWD is correct */
if (stat (pwd, &s1) == 0 && stat (".", &s2) == 0
&& s1.st_dev == s2.st_dev && s1.st_ino == s2.st_ino)
return ToLocaleDup (pwd);
}
/* Otherwise iterate getcwd() until the buffer is big enough */
long path_max = pathconf (".", _PC_PATH_MAX);
size_t size = (path_max == -1 || path_max > 4096) ? 4096 : path_max;
for (;; size *= 2)
{
char *buf = malloc (size);
if (unlikely(buf == NULL))
break;
if (getcwd (buf, size) != NULL)
#ifdef ASSUME_UTF8
return buf;
#else
{
char *ret = ToLocaleDup (buf);
free (buf);
return ret; /* success */
}
#endif
free (buf);
if (errno != ERANGE)
break;
}
return NULL;
}
int vlc_mkdir (const char *dirname, mode_t mode)
{
char *locname = ToLocaleDup (dirname);
if (unlikely(locname == NULL))
{
errno = ENOENT;
return -1;
}
int res = mkdir (locname, mode);
free (locname);
return res;
}
int vlc_unlink (const char *filename)
{
const char *local_name = ToLocaleDup (filename);
if (unlikely(local_name == NULL))
{
errno = ENOENT;
return -1;
}
int ret = unlink (local_name);
free (local_name);
return ret;
}
static int vlc_statEx (const char *filename, struct stat *buf, bool deref)
{
const char *local_name = ToLocaleDup (filename);
if (unlikely(local_name == NULL))
{
errno = ENOENT;
return -1;
}
int res = deref ? stat (local_name, buf)
: lstat (local_name, buf);
free (local_name);
return res;
}
DIR *vlc_opendir (const char *dirname)
{
const char *locname = ToLocaleDup (dirname);
if (unlikely(locname == NULL))
{
errno = ENOENT;
return NULL;
}
DIR *dir = opendir (locname);
free (locname);
return dir;
}
/** Replacement for luaL_dofile, using VLC's input capabilities */
int vlclua_dofile( vlc_object_t *p_this, lua_State *L, const char *curi )
{
char *uri = ToLocaleDup( curi );
if( !strstr( uri, "://" ) ) {
int ret = luaL_dofile( L, uri );
free( uri );
return ret;
}
if( !strncasecmp( uri, "file://", 7 ) ) {
int ret = luaL_dofile( L, uri + 7 );
free( uri );
return ret;
}
stream_t *s = stream_UrlNew( p_this, uri );
if( !s )
{
free( uri );
return 1;
}
int64_t i_size = stream_Size( s );
char *p_buffer = ( i_size > 0 ) ? malloc( i_size ) : NULL;
if( !p_buffer )
{
// FIXME: read the whole stream until we reach the end (if no size)
stream_Delete( s );
free( uri );
return 1;
}
int64_t i_read = stream_Read( s, p_buffer, (int) i_size );
int i_ret = ( i_read == i_size ) ? 0 : 1;
if( !i_ret )
i_ret = luaL_loadbuffer( L, p_buffer, (size_t) i_size, uri );
if( !i_ret )
i_ret = lua_pcall( L, 0, LUA_MULTRET, 0 );
stream_Delete( s );
free( p_buffer );
free( uri );
return i_ret;
}
/*****************************************************************************
* VCDOpen: open vcd
*****************************************************************************/
static int Open( vlc_object_t *p_this )
{
access_t *p_access = (access_t *)p_this;
access_sys_t *p_sys;
if( p_access->psz_filepath == NULL )
return VLC_EGENERIC;
char *psz_dup = ToLocaleDup( p_access->psz_filepath );
char *psz;
int i_title = 0;
int i_chapter = 0;
vcddev_t *vcddev;
/* Command line: vcd://[dev_path][#title[,chapter]] */
if( ( psz = strchr( psz_dup, '#' ) ) )
{
*psz++ = '\0';
i_title = strtol( psz, &psz, 0 );
if( *psz )
i_chapter = strtol( psz+1, &psz, 0 );
}
if( *psz_dup == '\0' )
{
free( psz_dup );
/* Only when selected */
if( strcmp( p_access->psz_access, "vcd" ) &&
strcmp( p_access->psz_access, "svcd" ) )
return VLC_EGENERIC;
psz_dup = var_CreateGetString( p_access, "vcd" );
if( *psz_dup == '\0' )
{
free( psz_dup );
return VLC_EGENERIC;
}
}
#if defined( WIN32 ) || defined( __OS2__ )
if( psz_dup[0] && psz_dup[1] == ':' &&
psz_dup[2] == '\\' && psz_dup[3] == '\0' ) psz_dup[2] = '\0';
#endif
/* Open VCD */
vcddev = ioctl_Open( p_this, psz_dup );
free( psz_dup );
if( !vcddev )
return VLC_EGENERIC;
/* Set up p_access */
p_access->p_sys = p_sys = calloc( 1, sizeof( access_sys_t ) );
if( unlikely(!p_sys ))
goto error;
p_sys->vcddev = vcddev;
/* We read the Table Of Content information */
p_sys->i_titles = ioctl_GetTracksMap( VLC_OBJECT(p_access),
p_sys->vcddev, &p_sys->p_sectors );
if( p_sys->i_titles < 0 )
{
msg_Err( p_access, "unable to count tracks" );
goto error;
}
else if( p_sys->i_titles <= 1 )
{
msg_Err( p_access, "no movie tracks found" );
goto error;
}
/* The first title isn't usable */
p_sys->i_titles--;
/* Build title table */
for( int i = 0; i < p_sys->i_titles; i++ )
{
input_title_t *t = p_sys->title[i] = vlc_input_title_New();
msg_Dbg( p_access, "title[%d] start=%d", i, p_sys->p_sectors[1+i] );
msg_Dbg( p_access, "title[%d] end=%d", i, p_sys->p_sectors[i+2] );
t->i_size = ( p_sys->p_sectors[i+2] - p_sys->p_sectors[i+1] ) *
(int64_t)VCD_DATA_SIZE;
}
/* Map entry points into chapters */
if( EntryPoints( p_access ) )
{
msg_Warn( p_access, "could not read entry points, will not use them" );
}
/* Starting title/chapter and sector */
if( i_title >= p_sys->i_titles )
i_title = 0;
if( i_chapter >= p_sys->title[i_title]->i_seekpoint )
i_chapter = 0;
p_sys->i_sector = p_sys->p_sectors[1+i_title];
if( i_chapter > 0 )
{
p_sys->i_sector += ( p_sys->title[i_title]->seekpoint[i_chapter]->i_byte_offset /
VCD_DATA_SIZE );
}
/* p_access */
p_access->pf_read = NULL;
p_access->pf_block = Block;
p_access->pf_control = Control;
p_access->pf_seek = Seek;
p_access->info.i_update = 0;
p_access->info.b_eof = false;
p_access->info.i_title = i_title;
p_access->info.i_seekpoint = i_chapter;
p_access->info.i_size = p_sys->title[i_title]->i_size;
p_access->info.i_pos = (uint64_t)( p_sys->i_sector - p_sys->p_sectors[1+i_title] ) *
VCD_DATA_SIZE;
free( p_access->psz_demux );
p_access->psz_demux = strdup( "ps" );
return VLC_SUCCESS;
error:
ioctl_Close( VLC_OBJECT(p_access), vcddev );
free( p_sys );
return VLC_EGENERIC;
}
/*****************************************************************************
* vcd_Open: Opens a VCD device or file initializes, a list of
tracks, segements and entry lsns and sizes and returns an opaque handle.
*****************************************************************************/
static vcdinfo_obj_t *
vcd_Open( vlc_object_t *p_this, const char *psz_dev )
{
access_t *p_access = (access_t *)p_this;
vcdplayer_t *p_vcdplayer = (vcdplayer_t *) p_access->p_sys;
vcdinfo_obj_t *p_vcdobj;
char *actual_dev;
unsigned int i;
dbg_print(INPUT_DBG_CALL, "called with %s", psz_dev);
if( !psz_dev ) return NULL;
actual_dev= ToLocaleDup(psz_dev);
if( vcdinfo_open(&p_vcdobj, &actual_dev, DRIVER_UNKNOWN, NULL) !=
VCDINFO_OPEN_VCD)
{
free(actual_dev);
return NULL;
}
free(actual_dev);
/*
Save summary info on tracks, segments and entries...
*/
if ( 0 < (p_vcdplayer->i_tracks = vcdinfo_get_num_tracks(p_vcdobj)) )
{
p_vcdplayer->track = (vcdplayer_play_item_info_t *)
calloc(p_vcdplayer->i_tracks, sizeof(vcdplayer_play_item_info_t));
for (i=0; i<p_vcdplayer->i_tracks; i++)
{
unsigned int track_num=i+1;
p_vcdplayer->track[i].size =
vcdinfo_get_track_sect_count(p_vcdobj, track_num);
p_vcdplayer->track[i].start_LSN =
vcdinfo_get_track_lsn(p_vcdobj, track_num);
}
} else
p_vcdplayer->track = NULL;
if( 0 < (p_vcdplayer->i_entries = vcdinfo_get_num_entries(p_vcdobj)) )
{
p_vcdplayer->entry = (vcdplayer_play_item_info_t *)
calloc(p_vcdplayer->i_entries, sizeof(vcdplayer_play_item_info_t));
for (i=0; i<p_vcdplayer->i_entries; i++)
{
p_vcdplayer->entry[i].size =
vcdinfo_get_entry_sect_count(p_vcdobj, i);
p_vcdplayer->entry[i].start_LSN =
vcdinfo_get_entry_lsn(p_vcdobj, i);
}
} else
p_vcdplayer->entry = NULL;
if ( 0 < (p_vcdplayer->i_segments = vcdinfo_get_num_segments(p_vcdobj)) )
{
p_vcdplayer->segment = (vcdplayer_play_item_info_t *)
calloc(p_vcdplayer->i_segments, sizeof(vcdplayer_play_item_info_t));
for (i=0; i<p_vcdplayer->i_segments; i++)
{
p_vcdplayer->segment[i].size =
vcdinfo_get_seg_sector_count(p_vcdobj, i);
p_vcdplayer->segment[i].start_LSN =
vcdinfo_get_seg_lsn(p_vcdobj, i);
}
} else
p_vcdplayer->segment = NULL;
return p_vcdobj;
}
/*****************************************************************************
* Open: open cdda
*****************************************************************************/
static int Open( vlc_object_t *p_this )
{
access_t *p_access = (access_t*)p_this;
access_sys_t *p_sys;
vcddev_t *vcddev;
char *psz_name;
if( !p_access->psz_filepath || !*p_access->psz_filepath )
{
/* Only when selected */
if( !p_access->psz_access || !*p_access->psz_access )
return VLC_EGENERIC;
psz_name = var_InheritString( p_this, "cd-audio" );
if( !psz_name )
return VLC_EGENERIC;
}
else psz_name = ToLocaleDup( p_access->psz_filepath );
#if defined( _WIN32 ) || defined( __OS2__ )
if( psz_name[0] && psz_name[1] == ':' &&
psz_name[2] == '\\' && psz_name[3] == '\0' ) psz_name[2] = '\0';
#endif
/* Open CDDA */
if( (vcddev = ioctl_Open( VLC_OBJECT(p_access), psz_name ) ) == NULL )
{
msg_Warn( p_access, "could not open %s", psz_name );
free( psz_name );
return VLC_EGENERIC;
}
free( psz_name );
/* Set up p_access */
STANDARD_BLOCK_ACCESS_INIT
p_sys->vcddev = vcddev;
/* Do we play a single track ? */
p_sys->i_track = var_InheritInteger( p_access, "cdda-track" ) - 1;
if( p_sys->i_track < 0 )
{
/* We only do separate items if the whole disc is requested */
input_thread_t *p_input = access_GetParentInput( p_access );
int i_ret = -1;
if( p_input )
{
input_item_t *p_current = input_GetItem( p_input );
if( p_current )
i_ret = GetTracks( p_access, p_current );
vlc_object_release( p_input );
}
if( i_ret < 0 )
goto error;
}
else
{
/* Build a WAV header for the output data */
memset( &p_sys->waveheader, 0, sizeof(WAVEHEADER) );
SetWLE( &p_sys->waveheader.Format, 1 ); /*WAVE_FORMAT_PCM*/
SetWLE( &p_sys->waveheader.BitsPerSample, 16);
p_sys->waveheader.MainChunkID = VLC_FOURCC('R', 'I', 'F', 'F');
p_sys->waveheader.Length = 0; /* we just don't know */
p_sys->waveheader.ChunkTypeID = VLC_FOURCC('W', 'A', 'V', 'E');
p_sys->waveheader.SubChunkID = VLC_FOURCC('f', 'm', 't', ' ');
SetDWLE( &p_sys->waveheader.SubChunkLength, 16);
SetWLE( &p_sys->waveheader.Modus, 2);
SetDWLE( &p_sys->waveheader.SampleFreq, 44100);
SetWLE( &p_sys->waveheader.BytesPerSample,
2 /*Modus*/ * 16 /*BitsPerSample*/ / 8 );
SetDWLE( &p_sys->waveheader.BytesPerSec,
2*16/8 /*BytesPerSample*/ * 44100 /*SampleFreq*/ );
p_sys->waveheader.DataChunkID = VLC_FOURCC('d', 'a', 't', 'a');
p_sys->waveheader.DataLength = 0; /* we just don't know */
p_sys->i_first_sector = var_InheritInteger( p_access,
"cdda-first-sector" );
p_sys->i_last_sector = var_InheritInteger( p_access,
"cdda-last-sector" );
/* Tracknumber in MRL */
if( p_sys->i_first_sector < 0 || p_sys->i_last_sector < 0 )
{
const int i_titles = ioctl_GetTracksMap( VLC_OBJECT(p_access),
p_sys->vcddev, &p_sys->p_sectors );
if( p_sys->i_track >= i_titles )
{
msg_Err( p_access, "invalid track number" );
goto error;
}
p_sys->i_first_sector = p_sys->p_sectors[p_sys->i_track];
p_sys->i_last_sector = p_sys->p_sectors[p_sys->i_track+1];
}
p_sys->i_sector = p_sys->i_first_sector;
p_access->info.i_size = (p_sys->i_last_sector - p_sys->i_first_sector)
* (int64_t)CDDA_DATA_SIZE;
}
return VLC_SUCCESS;
error:
free( p_sys->p_sectors );
ioctl_Close( VLC_OBJECT(p_access), p_sys->vcddev );
free( p_sys );
return VLC_EGENERIC;
}
/*****************************************************************************
* Open:
*****************************************************************************/
static int Open( vlc_object_t *p_this )
{
demux_t *p_demux = (demux_t*)p_this;
demux_sys_t *p_sys;
char *psz_name;
dvd_reader_t *p_dvdread;
ifo_handle_t *p_vmg_file;
if( !p_demux->psz_file || !*p_demux->psz_file )
{
/* Only when selected */
if( !p_demux->psz_access || !*p_demux->psz_access )
return VLC_EGENERIC;
psz_name = var_CreateGetString( p_this, "dvd" );
if( !psz_name )
{
psz_name = strdup("");
}
}
else
psz_name = ToLocaleDup( p_demux->psz_file );
#ifdef WIN32
if( psz_name[0] && psz_name[1] == ':' &&
psz_name[2] == '\\' && psz_name[3] == '\0' ) psz_name[2] = '\0';
#endif
/* Open dvdread */
if( !(p_dvdread = DVDOpen( psz_name )) )
{
msg_Err( p_demux, "DVDRead cannot open source: %s", psz_name );
dialog_Fatal( p_demux, _("Playback failure"),
_("DVDRead could not open the disc \"%s\"."), psz_name );
free( psz_name );
return VLC_EGENERIC;
}
free( psz_name );
/* Ifo allocation & initialisation */
if( !( p_vmg_file = ifoOpen( p_dvdread, 0 ) ) )
{
msg_Warn( p_demux, "cannot open VMG info" );
return VLC_EGENERIC;
}
msg_Dbg( p_demux, "VMG opened" );
/* Fill p_demux field */
DEMUX_INIT_COMMON(); p_sys = p_demux->p_sys;
ps_track_init( p_sys->tk );
p_sys->i_sar_num = 0;
p_sys->i_sar_den = 0;
p_sys->i_title_cur_time = (mtime_t) 0;
p_sys->i_cell_cur_time = (mtime_t) 0;
p_sys->i_cell_duration = (mtime_t) 0;
p_sys->p_dvdread = p_dvdread;
p_sys->p_vmg_file = p_vmg_file;
p_sys->p_title = NULL;
p_sys->p_vts_file = NULL;
p_sys->i_title = p_sys->i_chapter = -1;
p_sys->i_mux_rate = 0;
p_sys->i_angle = var_CreateGetInteger( p_demux, "dvdread-angle" );
if( p_sys->i_angle <= 0 ) p_sys->i_angle = 1;
DemuxTitles( p_demux, &p_sys->i_angle );
if( DvdReadSetArea( p_demux, 0, 0, p_sys->i_angle ) != VLC_SUCCESS )
{
Close( p_this );
msg_Err( p_demux, "DvdReadSetArea(0,0,%i) failed (can't decrypt DVD?)",
p_sys->i_angle );
return VLC_EGENERIC;
}
/* Update default_pts to a suitable value for dvdread access */
var_Create( p_demux, "dvdread-caching",
VLC_VAR_INTEGER|VLC_VAR_DOINHERIT );
return VLC_SUCCESS;
}
