int main(int argc, char **argv) {
// having these declarations at the start of the function is only needed for C compatibility
int i;
char *path;
char **vlc_argv;
char *soutOption;
int nr;
libvlc_instance_t *vlc;
libvlc_media_t *media;
libvlc_media_player_t *player;
libvlc_event_manager_t *eventManager;
// init arguments
if(argc < 3) {
printf(ENDLN("Usage: vlcwrapper <input> <soutstring> [optional vlc arguments]"));
return 1;
}
// print some information
path = argv[1];
fprintf(stdout, ENDLN("I VLCWrapper version %s, using VLC %s"), VERSION, libvlc_get_version());
fprintf(stdout, ENDLN("A path %s"), path);
fprintf(stdout, ENDLN("A config %s"), argv[2]);
// init state machine
global_state = STATE_NULL;
// arguments (you shouldn't need these in normal usage; but we don't support all arguments by ourself yet)
nr = argc - 3;
vlc_argv = (char**)malloc(sizeof(char*)*nr);
for(i = 3; i < argc; i++) {
vlc_argv[i-3] = (char*)malloc(sizeof(char)* (strlen(argv[i]) + 1));
strcpy(vlc_argv[i-3], argv[i]);
}
for(i = 0; i < nr; i++)
fprintf(stdout, ENDLN("A cmd %d %s"), i, vlc_argv[i]);
// init vlc
vlc = libvlc_new(nr, vlc_argv);
libvlc_set_user_agent(vlc, USER_AGENT, HTTP_USER_AGENT);
// create media and set sout string
media = libvlc_media_new_path(vlc, path);
soutOption = (char*)malloc(strlen(argv[2]) * sizeof(char) + 6);
snprintf(soutOption, strlen(argv[2]) + 6, "sout=%s", argv[2]);
libvlc_media_add_option(media, soutOption);
// create player and listen for events
player = libvlc_media_player_new_from_media(media);
eventManager = libvlc_media_player_event_manager(player);
register_event(eventManager, libvlc_MediaPlayerPlaying, STATE_PLAYING);
register_event(eventManager, libvlc_MediaPlayerEncounteredError, STATE_ERROR);
register_event(eventManager, libvlc_MediaPlayerEndReached, STATE_FINISHED);
// start playing it
libvlc_media_player_play(player);
// wait till it's started or stopped because of an error
while(global_state != STATE_ERROR && global_state != STATE_PLAYING)
millisleep(100);
// let it play till it has finished, while printing status information
while(global_state == STATE_PLAYING) {
fprintf(stdout, ENDLN("P %d"), libvlc_media_player_get_time(player));
fflush(stdout);
millisleep(LOG_INTERVAL);
}
// stop playing
libvlc_media_player_stop(player);
// release objects in memory
libvlc_media_release(media);
libvlc_media_player_release(player);
libvlc_release(vlc);
return 0;
}
int vlc_in_prepare(
unsigned verbosity,
unsigned int rate,
const char* uri,
unsigned channels,
const char* icy_write_file
)
{
fprintf(stderr, "Initialising VLC...\n");
vlc_nowplaying_running = 0;
vlc_nowplaying_filename = icy_write_file;
long long int handleStream_address;
long long int prepareRender_address;
int vlc_version_check = check_vlc_uses_size_t();
if (vlc_version_check == 0) {
fprintf(stderr, "You are using VLC with unsigned int size callbacks\n");
handleStream_address = (long long int)(intptr_t)(void*)&handleStream;
prepareRender_address = (long long int)(intptr_t)(void*)&prepareRender;
}
else if (vlc_version_check == 1) {
fprintf(stderr, "You are using VLC with size_t size callbacks\n");
handleStream_address = (long long int)(intptr_t)(void*)&handleStream_size_t;
prepareRender_address = (long long int)(intptr_t)(void*)&prepareRender_size_t;
}
else {
fprintf(stderr, "Error detecting VLC version!\n");
fprintf(stderr, " you are using %s\n", libvlc_get_version());
return -1;
}
vlc_rate = rate;
vlc_channels = channels;
// VLC options
char smem_options[512];
snprintf(smem_options, sizeof(smem_options),
"#transcode{acodec=s16l,samplerate=%d}:"
// We are using transcode because smem only support raw audio and
// video formats
"smem{"
"audio-postrender-callback=%lld,"
"audio-prerender-callback=%lld"
"}",
vlc_rate,
handleStream_address,
prepareRender_address);
char verb_options[512];
snprintf(verb_options, sizeof(verb_options),
"--verbose=%d", verbosity);
const char * const vlc_args[] = {
verb_options,
"--sout", smem_options // Stream to memory
};
// Launch VLC
m_vlc = libvlc_new(sizeof(vlc_args) / sizeof(vlc_args[0]), vlc_args);
// Load the media
libvlc_media_t *m;
m = libvlc_media_new_location(m_vlc, uri);
m_mp = libvlc_media_player_new_from_media(m);
libvlc_media_release(m);
// Allocate the list
head_buffer = vlc_buffer_new();
// Start playing
int ret = libvlc_media_player_play(m_mp);
if (ret == 0) {
libvlc_media_t *media = libvlc_media_player_get_media(m_mp);
libvlc_state_t st;
ret = -1;
int timeout;
for (timeout = 0; timeout < 100; timeout++) {
st = libvlc_media_get_state(media);
usleep(10*1000);
if (st != libvlc_NothingSpecial) {
ret = 0;
break;
}
}
}
return ret;
}
QString VlcInstance::version()
{
// Returns libvlc version
return QString(libvlc_get_version());
}
jstring Java_org_videolan_libvlc_LibVLC_version(JNIEnv* env, jobject thiz)
{
return (*env)->NewStringUTF(env, libvlc_get_version());
}
/*****************************************************************************
* main: parse command line, start interface and spawn threads.
*****************************************************************************/
int main( int i_argc, const char *ppsz_argv[] )
{
/* The so-called POSIX-compliant MacOS X reportedly processes SIGPIPE even
* if it is blocked in all thread.
* Note: this is NOT an excuse for not protecting against SIGPIPE. If
* LibVLC runs outside of VLC, we cannot rely on this code snippet. */
signal (SIGPIPE, SIG_IGN);
/* Restore SIGCHLD in case our parent process ignores it. */
signal (SIGCHLD, SIG_DFL);
#ifndef NDEBUG
/* Activate malloc checking routines to detect heap corruptions. */
setenv ("MALLOC_CHECK_", "2", 1);
#endif
#ifdef TOP_BUILDDIR
setenv ("VLC_PLUGIN_PATH", TOP_BUILDDIR"/modules", 1);
setenv ("VLC_DATA_PATH", TOP_SRCDIR"/share", 1);
#endif
#ifndef ALLOW_RUN_AS_ROOT
if (geteuid () == 0)
{
fprintf (stderr, "VLC is not supposed to be run as root. Sorry.\n"
"If you need to use real-time priorities and/or privileged TCP ports\n"
"you can use %s-wrapper (make sure it is Set-UID root and\n"
"cannot be run by non-trusted users first).\n", ppsz_argv[0]);
return 1;
}
#endif
setlocale (LC_ALL, "");
if (isatty (STDERR_FILENO))
/* This message clutters error logs. It is printed only on a TTY.
* Fortunately, LibVLC prints version info with -vv anyway. */
fprintf (stderr, "VLC media player %s (revision %s)\n",
libvlc_get_version(), libvlc_get_changeset());
sigset_t set;
sigemptyset (&set);
/* VLC uses sigwait() to dequeue interesting signals.
* For this to work, those signals must be blocked in all threads,
* including the thread calling sigwait() (see the man page for details).
*
* There are two advantages to sigwait() over traditional signal handlers:
* - delivery is synchronous: no need to worry about async-safety,
* - EINTR is not generated: other threads need not handle that error.
* That being said, some LibVLC programs do not use sigwait(). Therefore
* EINTR must still be handled cleanly, notably from poll() calls.
*
* Signals that request a clean shutdown, and force an unclean shutdown
* if they are triggered again 2+ seconds later.
* We have to handle SIGTERM cleanly because of daemon mode. */
sigaddset (&set, SIGINT);
sigaddset (&set, SIGHUP);
sigaddset (&set, SIGQUIT);
sigaddset (&set, SIGTERM);
/* SIGPIPE can happen and would crash the process. On modern systems,
* the MSG_NOSIGNAL flag protects socket write operations against SIGPIPE.
* But we still need to block SIGPIPE when:
* - writing to pipes,
* - using write() instead of send() for code not specific to sockets.
* LibVLC code assumes that SIGPIPE is blocked. Other LibVLC applications
* shall block it (or handle it somehow) too.
*/
sigaddset (&set, SIGPIPE);
/* SIGCHLD must be dequeued to clean up zombie child processes.
* Furthermore the handler must not be set to SIG_IGN (see above).
* We cannot pragmatically handle EINTR, short reads and short writes
* in every code paths (including underlying libraries). So we just
* block SIGCHLD in all threads, and dequeue it below. */
sigaddset (&set, SIGCHLD);
/* Block all these signals */
pthread_t self = pthread_self ();
pthread_sigmask (SIG_SETMASK, &set, NULL);
const char *argv[i_argc + 3];
int argc = 0;
argv[argc++] = "--no-ignore-config";
argv[argc++] = "--media-library";
argv[argc++] = "--stats";
/* overwrite system language on Mac */
#if !TARGET_OS_IPHONE && !TARGET_IPHONE_SIMULATOR // TARGET_OS_MAC is unspecific
char *lang = NULL;
for (int i = 0; i < i_argc; i++) {
if (!strncmp(ppsz_argv[i], "--language", 10)) {
lang = strstr(ppsz_argv[i], "=");
ppsz_argv++, i_argc--;
continue;
}
}
if (lang && strncmp( lang, "auto", 4 )) {
char tmp[11];
snprintf(tmp, 11, "LANG%s", lang);
putenv(tmp);
}
if (!lang) {
CFStringRef language;
language = (CFStringRef)CFPreferencesCopyAppValue(CFSTR("language"),
kCFPreferencesCurrentApplication);
if (language) {
CFIndex length = CFStringGetLength(language) + 1;
if (length > 0) {
CFIndex maxSize = CFStringGetMaximumSizeForEncoding(length, kCFStringEncodingUTF8);
lang = (char *)malloc(maxSize);
CFStringGetCString(language, lang, maxSize - 1, kCFStringEncodingUTF8);
}
if (strncmp( lang, "auto", 4 )) {
char tmp[11];
snprintf(tmp, 11, "LANG=%s", lang);
putenv(tmp);
}
CFRelease(language);
}
}
#endif
ppsz_argv++; i_argc--; /* skip executable path */
/* When VLC.app is run by double clicking in Mac OS X, the 2nd arg
* is the PSN - process serial number (a unique PID-ish thingie)
* still ok for real Darwin & when run from command line
* for example -psn_0_9306113 */
if (i_argc >= 1 && !strncmp (*ppsz_argv, "-psn" , 4))
ppsz_argv++, i_argc--;
memcpy (argv + argc, ppsz_argv, i_argc * sizeof (*argv));
argc += i_argc;
argv[argc] = NULL;
vlc_enable_override ();
/* Initialize libvlc */
libvlc_instance_t *vlc = libvlc_new (argc, argv);
if (vlc == NULL)
return 1;
int ret = 1;
libvlc_set_exit_handler (vlc, vlc_kill, &self);
libvlc_set_app_id (vlc, "org.VideoLAN.VLC", PACKAGE_VERSION, PACKAGE_NAME);
libvlc_set_user_agent (vlc, "VLC media player", "VLC/"PACKAGE_VERSION);
libvlc_add_intf (vlc, "hotkeys,none");
if (libvlc_add_intf (vlc, NULL))
goto out;
libvlc_playlist_play (vlc, -1, 0, NULL);
/* Qt4 insists on catching SIGCHLD via signal handler. To work around that,
* unblock it after all our child threads are created. */
sigdelset (&set, SIGCHLD);
pthread_sigmask (SIG_SETMASK, &set, NULL);
/* Do not dequeue SIGHUP if it is ignored (nohup) */
if (signal_ignored (SIGHUP))
sigdelset (&set, SIGHUP);
/* Ignore SIGPIPE */
sigdelset (&set, SIGPIPE);
int signum;
sigwait (&set, &signum);
/* Restore default signal behaviour after 3 seconds */
sigemptyset (&set);
sigaddset (&set, SIGINT);
sigaddset (&set, SIGALRM);
signal (SIGINT, SIG_IGN);
signal (SIGALRM, exit_timeout);
pthread_sigmask (SIG_UNBLOCK, &set, NULL);
alarm (3);
ret = 0;
/* Cleanup */
out:
libvlc_release (vlc);
return ret;
}
void Mwindow::about()
{
QMessageBox::about(this, "Qt libVLC player demo", QString::fromUtf8(libvlc_get_version()) );
}
const char* LibVLC::getVersion(){
return libvlc_get_version();
}
QString QmlVlcPlayerProxy::get_vlcVersion()
{
return QString::fromLatin1( libvlc_get_version() );
}
std::string FBVLCAPI::get_vlcVersion()
{
return libvlc_get_version();
}
/*****************************************************************************
* main: parse command line, start interface and spawn threads.
*****************************************************************************/
int main( int i_argc, const char *ppsz_argv[] )
{
/* The so-called POSIX-compliant MacOS X reportedly processes SIGPIPE even
* if it is blocked in all thread.
* Note: this is NOT an excuse for not protecting against SIGPIPE. If
* LibVLC runs outside of VLC, we cannot rely on this code snippet. */
signal (SIGPIPE, SIG_IGN);
/* Restore SIGCHLD in case our parent process ignores it. */
signal (SIGCHLD, SIG_DFL);
#ifndef NDEBUG
/* Activate malloc checking routines to detect heap corruptions. */
setenv ("MALLOC_CHECK_", "2", 1);
/* Disable the ugly Gnome crash dialog so that we properly segfault */
setenv ("GNOME_DISABLE_CRASH_DIALOG", "1", 1);
#endif
#ifdef TOP_BUILDDIR
setenv ("VLC_PLUGIN_PATH", TOP_BUILDDIR"/modules", 1);
setenv ("VLC_DATA_PATH", TOP_SRCDIR"/share", 1);
#endif
/* Clear the X.Org startup notification ID. Otherwise the UI might try to
* change the environment while the process is multi-threaded. That could
* crash. Screw you X.Org. Next time write a thread-safe specification. */
unsetenv ("DESKTOP_STARTUP_ID");
#ifndef ALLOW_RUN_AS_ROOT
if (geteuid () == 0)
{
fprintf (stderr, "VLC is not supposed to be run as root. Sorry.\n"
"If you need to use real-time priorities and/or privileged TCP ports\n"
"you can use %s-wrapper (make sure it is Set-UID root and\n"
"cannot be run by non-trusted users first).\n", ppsz_argv[0]);
return 1;
}
#endif
setlocale (LC_ALL, "");
if (isatty (STDERR_FILENO))
/* This message clutters error logs. It is printed only on a TTY.
* Fortunately, LibVLC prints version info with -vv anyway. */
fprintf (stderr, "VLC media player %s (revision %s)\n",
libvlc_get_version(), libvlc_get_changeset());
sigset_t set;
sigemptyset (&set);
/* VLC uses sigwait() to dequeue interesting signals.
* For this to work, those signals must be blocked in all threads,
* including the thread calling sigwait() (see the man page for details).
*
* There are two advantages to sigwait() over traditional signal handlers:
* - delivery is synchronous: no need to worry about async-safety,
* - EINTR is not generated: other threads need not handle that error.
* That being said, some LibVLC programs do not use sigwait(). Therefore
* EINTR must still be handled cleanly, notably from poll() calls.
*
* Signals that request a clean shutdown, and force an unclean shutdown
* if they are triggered again 2+ seconds later.
* We have to handle SIGTERM cleanly because of daemon mode. */
sigaddset (&set, SIGINT);
sigaddset (&set, SIGHUP);
sigaddset (&set, SIGQUIT);
sigaddset (&set, SIGTERM);
/* SIGPIPE can happen and would crash the process. On modern systems,
* the MSG_NOSIGNAL flag protects socket write operations against SIGPIPE.
* But we still need to block SIGPIPE when:
* - writing to pipes,
* - using write() instead of send() for code not specific to sockets.
* LibVLC code assumes that SIGPIPE is blocked. Other LibVLC applications
* shall block it (or handle it somehow) too.
*/
sigaddset (&set, SIGPIPE);
/* SIGCHLD must be dequeued to clean up zombie child processes.
* Furthermore the handler must not be set to SIG_IGN (see above).
* We cannot pragmatically handle EINTR, short reads and short writes
* in every code paths (including underlying libraries). So we just
* block SIGCHLD in all threads, and dequeue it below. */
sigaddset (&set, SIGCHLD);
/* Block all these signals */
pthread_t self = pthread_self ();
pthread_sigmask (SIG_SETMASK, &set, NULL);
const char *argv[i_argc + 3];
int argc = 0;
argv[argc++] = "--no-ignore-config";
argv[argc++] = "--media-library";
argv[argc++] = "--stats";
ppsz_argv++; i_argc--; /* skip executable path */
#ifdef __OS2__
for (int i = 0; i < i_argc; i++)
if ((argv[argc++] = FromSystem (ppsz_argv[i])) == NULL)
{
fprintf (stderr, "Converting '%s' to UTF-8 failed.\n",
ppsz_argv[i]);
return 1;
}
#else
memcpy (argv + argc, ppsz_argv, i_argc * sizeof (*argv));
argc += i_argc;
#endif
argv[argc] = NULL;
vlc_enable_override ();
/* Initialize libvlc */
libvlc_instance_t *vlc = libvlc_new (argc, argv);
if (vlc == NULL)
return 1;
int ret = 1;
libvlc_set_exit_handler (vlc, vlc_kill, &self);
libvlc_set_app_id (vlc, "org.VideoLAN.VLC", PACKAGE_VERSION, PACKAGE_NAME);
libvlc_set_user_agent (vlc, "VLC media player", "VLC/"PACKAGE_VERSION);
libvlc_add_intf (vlc, "hotkeys,none");
#if !defined (__OS2__)
libvlc_add_intf (vlc, "globalhotkeys,none");
#endif
#ifdef HAVE_DBUS
libvlc_add_intf (vlc, "dbus,none");
#endif
if (libvlc_add_intf (vlc, NULL))
goto out;
libvlc_playlist_play (vlc, -1, 0, NULL);
/* Qt4 insists on catching SIGCHLD via signal handler. To work around that,
* unblock it after all our child threads are created. */
sigdelset (&set, SIGCHLD);
pthread_sigmask (SIG_SETMASK, &set, NULL);
/* Do not dequeue SIGHUP if it is ignored (nohup) */
if (signal_ignored (SIGHUP))
sigdelset (&set, SIGHUP);
/* Ignore SIGPIPE */
sigdelset (&set, SIGPIPE);
int signum;
sigwait (&set, &signum);
/* Restore default signal behaviour after 3 seconds */
sigemptyset (&set);
sigaddset (&set, SIGINT);
sigaddset (&set, SIGALRM);
signal (SIGINT, SIG_IGN);
signal (SIGALRM, exit_timeout);
pthread_sigmask (SIG_UNBLOCK, &set, NULL);
alarm (3);
ret = 0;
/* Cleanup */
out:
libvlc_release (vlc);
#ifdef __OS2__
for (int i = 2; i < argc; i++)
free (argv[i]);
#endif
return ret;
}
void VlcInstance::setUserAgent(const QString &application, const QString &version)
{
QString applicationOutput = application + " " + version;
QString httpOutput = application + "/" + version + " " + "VLC" + "/" + libvlc_get_version();
libvlc_set_user_agent(_vlcInstance, applicationOutput.toUtf8().data(), httpOutput.toUtf8().data());
}
QString getLibVlcVersion(){
return QString(libvlc_get_version());
}
QString BuildTab::buildBuildString() {
const char *qt_compile_version = QT_VERSION_STR;
#ifdef _GC_SrmDevice_h
const char *srm_output = "SRM IO Support<br/>";
#else
const char *srm_output = "";
#endif
#ifdef _GC_PT_D2XX_h
const char *d2xx_output = "D2XX Support<br/>";
#else
const char *d2xx_output = "";
#endif
#ifdef GC_HAVE_LIBOAUTH
const char *oauth_output = "Lib OAUTH Support<br/>";
#else
const char *oauth_output = "";
#endif
#ifdef GC_HAVE_QWTPLOT3D
const char *qwtplot3d_output = "QWT Plot 3D Support<br/>";
#else
const char *qwtplot3d_output = "";
#endif
#ifdef GC_HAVE_KML
const char *libkml_output = "KML Support<br/>";
#else
const char *libkml_output = "";
#endif
#ifdef GC_HAVE_ICAL
const char *libical_output = "iCal support<br/>";
#else
const char *libical_output = "";
#endif
const char *usbxpress_output = "";
#ifdef WIN32
#ifdef GC_HAVE_USBXPRESS
usbxpress_output = "USBXpress support<br/>";
#endif
#endif
#ifdef GC_HAVE_LIBUSB
const char *libusb_output = "LIB USB Support<br/>";
const usb_version *ver = usb_get_version();
// ver->dll.major
//libusb_output = "LIB USB: " + ver->dll.major + "." + ver->dll.minor + "<br/>";
#else
const char *libusb_output = "";
#endif
#ifdef GC_HAVE_VLC
QString libvlc_output = "VLC: " + QString(libvlc_get_version()) + "<br/>";
#else
QString libvlc_output = "";
#endif
const char *soap_output = "";
#if (defined Q_OS_MAC) && (defined GC_HAVE_LION)
const char *lion_support_output = "Mac OSX Lion Support<br/>";
#else
const char *lion_support_output = "";
#endif
return tr(
"<center>"
"<h2>Build Information</h2>"
"<p>Build date: %1 %2<br/>"
"Git Commit:%3<br/>"
"Qt Build Ver:%4<br/>"
"Boost Build Ver:%5.%6.%7<br/>"
"GCC Build Ver:%8.%9.%10<br/>"
"OS Info:%11<br/>"
"<hr/>"
"%12" "%13" "%14" "%15" "%16" "%17"
"%18" "%19" "%20" "%21" "%22")
.arg(__DATE__)
.arg(__TIME__)
.arg(gitrevision)
.arg(qt_compile_version)
.arg(BOOST_VERSION / 100000)
.arg((BOOST_VERSION / 100) % 1000)
.arg(BOOST_VERSION % 100)
.arg(__GNUC__)
.arg(__GNUC_MINOR__)
.arg(__GNUC_PATCHLEVEL__)
.arg(osversion)
.arg(srm_output)
.arg(d2xx_output)
.arg(oauth_output)
.arg(qwtplot3d_output)
.arg(libkml_output)
.arg(libical_output)
.arg(usbxpress_output)
.arg(libusb_output)
.arg(libvlc_output)
.arg(soap_output)
.arg(lion_support_output);
}
