int wmain(int argc, wchar_t **argv) {
// having these declarations at the start of the function is only needed for C compatibility
int i;
int soutBufferSize;
int nr;
char **vlc_argv;
wchar_t *soutOption;
wchar_t *config;
wchar_t *path;
libvlc_instance_t *vlc;
libvlc_media_t *media;
libvlc_media_player_t *player;
libvlc_event_manager_t *eventManager;
// init arguments
if(argc < 3) {
fwprintf(stdout, ENDLN(L"Usage: vlcwrapper <input> <soutstring> [optional vlc arguments]"));
return 1;
}
// print some information
path = argv[1];
config = argv[2];
fwprintf(stdout, ENDLN(L"I VLCWrapper version %s, using VLC %hs"), VERSION, libvlc_get_version());
fwprintf(stdout, ENDLN(L"A path %s"), path);
fwprintf(stdout, ENDLN(L"A config %s"), config);
// 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(nr * sizeof(char*));
for(i = 3; i < argc; i++) {
fwprintf(stdout, ENDLN(L"A cmd %d %s"), i - 3, argv[i]);
vlc_argv[i - 3] = to_utf8(argv[i]);
}
// init vlc
vlc = libvlc_new(nr, vlc_argv);
libvlc_set_user_agent(vlc, to_utf8(USER_AGENT), to_utf8(HTTP_USER_AGENT));
// create media and set sout string
media = libvlc_media_new_path(vlc, to_utf8(path));
soutBufferSize = wcslen(config) + 6;
soutOption = (wchar_t*)malloc(soutBufferSize * sizeof(wchar_t));
snwprintf(soutOption, soutBufferSize, soutBufferSize, L"sout=%s", config);
libvlc_media_add_option(media, to_utf8(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) {
fwprintf(stdout, ENDLN(L"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;
}
void VideoSource::UpdateSettings()
{
EnterCriticalSection(&textureLock);
isRendering = false;
LeaveCriticalSection(&textureLock);
if (mediaPlayer) {
libvlc_video_set_callbacks(mediaPlayer, nullptr, nullptr, nullptr, nullptr);
libvlc_media_player_stop(mediaPlayer);
}
config->Reload();
hasSetVolume = false;
videoSize.x = float(config->width);
videoSize.y = float(config->height);
if (mediaPlayer == nullptr) {
mediaPlayer = libvlc_media_player_new(vlc);
libvlc_event_manager_t *em = libvlc_media_player_event_manager(mediaPlayer);
libvlc_event_attach(em, libvlc_MediaPlayerEndReached, vlcEvent, this);
libvlc_event_attach(em, libvlc_MediaPlayerPlaying, vlcEvent, this);
}
if (mediaListPlayer == nullptr) {
mediaListPlayer = libvlc_media_list_player_new(vlc);
libvlc_media_list_player_set_media_player(mediaListPlayer, mediaPlayer);
} else {
libvlc_media_list_player_stop(mediaListPlayer);
}
if (mediaList) {
libvlc_media_list_lock(mediaList);
while(libvlc_media_list_count(mediaList)) {
libvlc_media_list_remove_index(mediaList, 0);
}
libvlc_media_list_unlock(mediaList);
} else {
mediaList = libvlc_media_list_new(vlc);
libvlc_media_list_player_set_media_list(mediaListPlayer, mediaList);
}
char *utf8PathOrUrl;
for(unsigned int i = 0; i < config->playlist.Num(); i++) {
String &mediaEntry = config->playlist[i];
String token = mediaEntry.GetToken(1, L':');
// .. Yup.
bool isStream = token.Length() >= 2 && token[0] == L'/' && token[1] == L'/';
utf8PathOrUrl = config->playlist[i].CreateUTF8String();
if (utf8PathOrUrl) {
libvlc_media_t *media;
if (!isStream) {
media = libvlc_media_new_path(vlc, utf8PathOrUrl);
} else {
media = libvlc_media_new_location(vlc, utf8PathOrUrl);
}
libvlc_media_list_lock(mediaList);
libvlc_media_list_add_media(mediaList, media);
libvlc_media_list_unlock(mediaList);
libvlc_media_release(media);
Free(utf8PathOrUrl);
}
}
if (!config->isPlaylistLooping) {
remainingVideos = config->playlist.Num();
}
libvlc_video_set_callbacks(mediaPlayer, lock, unlock, display, this);
libvlc_video_set_format_callbacks(mediaPlayer, videoFormatProxy, videoCleanupProxy);
libvlc_media_list_player_set_playback_mode(mediaListPlayer, config->isPlaylistLooping ? libvlc_playback_mode_loop : libvlc_playback_mode_default);
if (!audioOutputStreamHandler) {
audioOutputStreamHandler = new AudioOutputStreamHandler(vlc, mediaPlayer);
}
audioOutputStreamHandler->SetOutputParameters(
config->audioOutputType,
config->audioOutputTypeDevice,
config->audioOutputDevice,
config->isAudioOutputToStream);
audioOutputStreamHandler->SetVolume(config->volume);
// set (possibly in vane) the volume. If it doesn't work it will try later until it works
// vlc... que pasa amigo
hasSetVolume = libvlc_audio_set_volume(mediaPlayer, config->volume) == 0;
EnterCriticalSection(&textureLock);
isRendering = true;
LeaveCriticalSection(&textureLock);
libvlc_media_list_player_play(mediaListPlayer);
}
void
AudioOutput::setCurrentSource( MediaStream* stream )
{
tDebug() << Q_FUNC_INFO;
setState( Loading );
if ( m_vlcMedia != nullptr )
{
// Ensure playback is stopped, then release media
libvlc_media_player_stop( m_vlcPlayer );
libvlc_media_release( m_vlcMedia );
m_vlcMedia = nullptr;
}
if ( m_autoDelete && m_currentStream != nullptr )
{
delete m_currentStream;
}
m_currentStream = stream;
m_totalTime = 0;
m_currentTime = 0;
m_justSeeked = false;
m_seekable = true;
QByteArray url;
switch ( stream->type() )
{
case MediaStream::Unknown:
tDebug() << Q_FUNC_INFO << "MediaStream Type is Invalid:" << stream->type();
break;
case MediaStream::Empty:
tDebug() << Q_FUNC_INFO << "MediaStream is empty.";
break;
case MediaStream::Url:
tDebug() << Q_FUNC_INFO << "MediaStream::Url:" << stream->url();
if ( stream->url().scheme().isEmpty() )
{
url = "file:///";
if ( stream->url().isRelative() )
{
url.append( QFile::encodeName( QDir::currentPath() ) + '/' );
}
}
url += stream->url().toEncoded();
break;
case MediaStream::Stream:
case MediaStream::IODevice:
url = QByteArray( "imem://" );
break;
}
tDebug() << Q_FUNC_INFO << "MediaStream::Final Url:" << url;
m_vlcMedia = libvlc_media_new_location( m_vlcInstance, url.constData() );
libvlc_event_manager_t* manager = libvlc_media_event_manager( m_vlcMedia );
libvlc_event_type_t events[] = {
libvlc_MediaDurationChanged,
};
const int eventCount = sizeof(events) / sizeof( *events );
for ( int i = 0; i < eventCount; i++ )
{
libvlc_event_attach( manager, events[ i ], &AudioOutput::vlcEventCallback, this );
}
libvlc_media_player_set_media( m_vlcPlayer, m_vlcMedia );
if ( stream->type() == MediaStream::Url )
{
m_totalTime = libvlc_media_get_duration( m_vlcMedia );
}
else if ( stream->type() == MediaStream::Stream || stream->type() == MediaStream::IODevice )
{
libvlc_media_add_option_flag(m_vlcMedia, "imem-cat=4", libvlc_media_option_trusted);
const char* imemData = QString( "imem-data=%1" ).arg( (uintptr_t)stream ).toLatin1().constData();
libvlc_media_add_option_flag(m_vlcMedia, imemData, libvlc_media_option_trusted);
const char* imemGet = QString( "imem-get=%1" ).arg( (uintptr_t)&readCallback ).toLatin1().constData();
libvlc_media_add_option_flag(m_vlcMedia, imemGet, libvlc_media_option_trusted);
const char* imemRelease = QString( "imem-release=%1" ).arg( (uintptr_t)&readDoneCallback ).toLatin1().constData();
libvlc_media_add_option_flag(m_vlcMedia, imemRelease, libvlc_media_option_trusted);
const char* imemSeek = QString( "imem-seek=%1" ).arg( (uintptr_t)&MediaStream::seekCallback ).toLatin1().constData();
libvlc_media_add_option_flag(m_vlcMedia, imemSeek, libvlc_media_option_trusted);
}
if ( qApp->arguments().contains( "--chromecast-ip" ) )
{
// This is very basic chromecast support through VLC 3+.
// Totally unstable, unusable and will suck more CPU than you can think of.
// If you want to improve this, please talk to the guys in #videolan and
// support them.
//
// Knonw problems:
// 1. It does not work eventhough the IP is correct.
// -> Open vlc with the same commandline and accept the Certificate in the VLC UI.
if ( qApp->arguments().length() > qApp->arguments().indexOf( "--chromecast-ip" ) + 1 )
{
QString castIP = qApp->arguments().at( qApp->arguments().indexOf( "--chromecast-ip" ) + 1 );
QString sout( ":sout=#transcode{vcodec=none,acodec=vorb,ab=320,channels=2,samplerate=44100}:chromecast{ip=%1,mux=webm}" );
libvlc_media_add_option( m_vlcMedia, sout.arg( castIP ).toLatin1().constData() );
}
else
{
tLog() << Q_FUNC_INFO << "Chromecast option but no IP supplied.";
}
}
// setState( Stopped );
}
bool VLCVideoTextureObjChunk::createVLCInstance(libvlc_time_t start_time,
bool play )
{
libvlc_media_t *m;
char const *vlc_argv[] =
{
"-I", "dumy", // No special interface
"--ignore-config", // Don't use VLC's config
"--quiet", // deactivates VLCs console outputs
"--no-xlib", // tell VLC to not use Xlib
"--no-video-title-show", // no titles
};
int vlc_argc = sizeof(vlc_argv ) / sizeof(*vlc_argv );
// Initialize libVLC
if (libvlc==NULL)
{
libvlc = libvlc_new(vlc_argc, vlc_argv);
}
else
{
if (vlcmediaplayer!=NULL)
{
ctx.idstr = NULL;
libvlc_media_player_stop(vlcmediaplayer);
libvlc_media_player_release(vlcmediaplayer);
vlcmediaplayer = NULL;
if (ctx.videothread!=NULL) {
ctx.videothread->runFunction(NULL,NULL); // reset thread structure: isInititialized=false
}
ctx.videothread = NULL;
}
}
m = libvlc_media_new_path(libvlc, getUrl().c_str());
vlcmediaplayer = libvlc_media_player_new_from_media(m);
libvlc_media_release(m);
ctx.idstr = strdup((std::string("video")+getVideoID()).c_str());
ctx.videothread = NULL;
ctx.img = Image::create();
ctx.img->set(OSG::Image::OSG_BGR_PF,getWidth(), getHeight());
ctx.lock = Lock::create();
this->setImage(ctx.img);
this->setTarget(GL_TEXTURE_2D);
ctx.self = this;
vlceventmgr = libvlc_media_player_event_manager( vlcmediaplayer );
// attach event to defined event handler callback
libvlc_event_attach( vlceventmgr, libvlc_MediaPlayerEndReached, vlc_event, &ctx);
libvlc_video_set_callbacks(vlcmediaplayer, vlc_lock, vlc_unlock, vlc_display, &ctx);
libvlc_video_set_format(vlcmediaplayer, "RV24", getWidth(), getHeight(), getWidth()*3);
if (getIsMaster()==false) libvlc_audio_set_mute(vlcmediaplayer, 1);
#if 0
{
SLOG << "available filters:" << std::endl;
libvlc_module_description_t *list = libvlc_video_filter_list_get(libvlc);
libvlc_module_description_t *iter = list;
while(iter!=NULL) {
SLOG << iter->psz_name << std::endl;
iter = iter->p_next;
}
libvlc_module_description_list_release(list);
}
#endif
libvlc_media_player_play(vlcmediaplayer);
libvlc_media_player_set_time(vlcmediaplayer, start_time);
if (!play) libvlc_media_player_pause(vlcmediaplayer); //not working?
// add to static list
//allVideoTextures.push_back(&ctx);
lastSync=OSG::getTimeStamp();
return true;
}
int main(int argc, char* argv[]){
FILE *f;
FILE *p;
FILE *r;
f = fopen("/home/michal/pass2.txt", "rw+");
p = fopen("krypt.txt", "rw+");
r = fopen("conf.txt", "rw+");
char done[100];
char check[100];
char pass[100];
char decode[100] = "./test 0";
char code[100] = "./test 1";
int t;
if(argc < 3){
perror("Zła liczba argumentów");
return 0;
}
while(!feof(f)){
fscanf(f, "%s", check);
}
fscanf(p, "%s", done);
if(strcmp("1", done) != 0){
printf("Konfirgurowanie\n");
fprintf(r, "/home/michal/key.txt\n");
fprintf(r, "/home/michal/key2.txt\n");
fprintf(r, "/home/michal/iv.txt\n");
fprintf(r, "/home/michal/pass.txt\n");
fprintf(r, "/home/michal/pass2.txt\n");
fclose(r);
printf("Zabezpiecz sciezki\n");
system("./test 1 conf.txt /home/michal/key2.txt /home/michal/iv.txt");
fprintf(p, "1");
printf("Uruchom ponownie program, aby dokończyc proces...\n");
fclose(p);
return 0;
}
strcat(decode, " ");
strcat(decode, argv[1]);
strcat(decode, " /home/michal/key.txt");
strcat(decode, " /home/michal/iv.txt");
strcat(code, " ");
strcat(code, argv[1]);
strcat(code, " /home/michal/key.txt");
strcat(code, " /home/michal/iv.txt");
printf("To execute program type password: "******"%s", pass);
tcsetattr(STDIN_FILENO, TCSANOW, &term_orig);
//Rozkodowywanie i odtworzenie pliku
if(strcmp(pass, check) == 0){
printf("OK\n");
printf("Type password to decode mp3\n");
system(decode);
libvlc_instance_t *inst;
libvlc_media_player_t *mp;
libvlc_media_t *m;
inst = libvlc_new(0, NULL);
m = libvlc_media_new_path(inst, argv[1]);
printf("%d", t);
mp = libvlc_media_player_new_from_media(m);
libvlc_media_player_play(mp);
sleep(atoi(argv[2]));
libvlc_media_player_stop(mp);
libvlc_media_release(m);
libvlc_media_player_release(mp);
libvlc_release(inst);
//Ponownie szyfrujemy plik.
printf("Type password to encode mp3\n");
system(code);
}
else{
printf("bledne haslo\n"); return 0;
}
fclose(f);
return 0;
}
/**
* Thumbnailer main function.
* return null if the thumbail generation failed.
**/
jbyteArray Java_org_videolan_libvlc_LibVLC_getThumbnail(JNIEnv *env, jobject thiz,
jlong instance, jstring filePath,
const jint frameWidth, const jint frameHeight)
{
libvlc_instance_t *libvlc = (libvlc_instance_t *)(intptr_t)instance;
jbyteArray byteArray = NULL;
/* Create the thumbnailer data structure */
thumbnailer_sys_t *sys = calloc(1, sizeof(thumbnailer_sys_t));
if (sys == NULL)
{
LOGE("Could not create the thumbnailer data structure!");
return NULL;
}
/* Initialize the barrier. */
pthread_mutex_init(&sys->doneMutex, NULL);
pthread_cond_init(&sys->doneCondVar, NULL);
/* Create a media player playing environment */
libvlc_media_player_t *mp = libvlc_media_player_new(libvlc);
libvlc_media_t *m = new_media(instance, env, thiz, filePath, true, false);
if (m == NULL)
{
LOGE("Could not create the media to play!");
goto end;
}
/* Fast and no options */
libvlc_media_add_option( m, ":no-audio" );
libvlc_media_add_option( m, ":no-spu" );
libvlc_media_add_option( m, ":no-osd" );
libvlc_media_player_set_media(mp, m);
/* Get the size of the video with the tracks information of the media. */
libvlc_media_track_t **tracks;
libvlc_media_parse(m);
int nbTracks = libvlc_media_tracks_get(m, &tracks);
libvlc_media_release(m);
/* Parse the results */
unsigned videoWidth = 0, videoHeight = 0;
bool hasVideoTrack = false;
for (unsigned i = 0; i < nbTracks; ++i)
if (tracks[i]->i_type == libvlc_track_video)
{
videoWidth = tracks[i]->video->i_width;
videoHeight = tracks[i]->video->i_height;
hasVideoTrack = true;
break;
}
libvlc_media_tracks_release(tracks, nbTracks);
/* Abort if we have not found a video track. */
if (!hasVideoTrack)
{
LOGE("Could not find any video track in this file.\n");
goto end;
}
LOGD("Video dimensions: %ix%i.\n", videoWidth, videoHeight );
/* VLC could not tell us the size */
if( videoWidth == 0 || videoHeight == 0 )
{
LOGE("Could not find the video dimensions.\n");
goto end;
}
if( videoWidth < 32 || videoHeight < 32 || videoWidth > 2048 || videoWidth > 2048 )
{
LOGE("Wrong video dimensions.\n");
goto end;
}
/* Compute the size parameters of the frame to generate. */
unsigned thumbWidth = frameWidth;
unsigned thumbHeight = frameHeight;
const float inputAR = (float)videoWidth / videoHeight;
const float screenAR = (float)frameWidth / frameHeight;
/* Most of the cases, video is wider than tall */
if (screenAR < inputAR)
{
thumbHeight = (float)frameWidth / inputAR + 1;
sys->blackBorders = ( (frameHeight - thumbHeight) / 2 ) * frameWidth;
}
else
{
LOGD("Weird aspect Ratio.\n");
thumbWidth = (float)frameHeight * inputAR;
sys->blackBorders = (frameWidth - thumbWidth) / 2;
}
sys->thumbPitch = thumbWidth * PIXEL_SIZE;
sys->thumbHeight = thumbHeight;
sys->frameWidth = frameWidth;
/* Allocate the memory to store the frames. */
size_t thumbSize = sys->thumbPitch * (sys->thumbHeight+1);
sys->thumbData = malloc(thumbSize);
if (sys->thumbData == NULL)
{
LOGE("Could not allocate the memory to store the frame!");
goto end;
}
/* Allocate the memory to store the thumbnail. */
unsigned frameSize = frameWidth * frameHeight * PIXEL_SIZE;
sys->frameData = calloc(frameSize, 1);
if (sys->frameData == NULL)
{
LOGE("Could not allocate the memory to store the thumbnail!");
goto end;
}
/* Set the video format and the callbacks. */
libvlc_video_set_format(mp, "RGBA", thumbWidth, thumbHeight, sys->thumbPitch);
libvlc_video_set_callbacks(mp, thumbnailer_lock, thumbnailer_unlock,
NULL, (void*)sys);
sys->state = THUMB_SEEKING;
/* Play the media. */
libvlc_media_player_play(mp);
libvlc_media_player_set_position(mp, THUMBNAIL_POSITION);
int loops = 100;
for (;;) {
float pos = libvlc_media_player_get_position(mp);
if (pos > THUMBNAIL_POSITION || !loops--)
break;
usleep(50000);
}
/* Wait for the thumbnail to be generated. */
pthread_mutex_lock(&sys->doneMutex);
sys->state = THUMB_SEEKED;
struct timespec deadline;
clock_gettime(CLOCK_REALTIME, &deadline);
deadline.tv_sec += 10; /* amount of seconds before we abort thumbnailer */
do {
int ret = pthread_cond_timedwait(&sys->doneCondVar, &sys->doneMutex, &deadline);
if (ret == ETIMEDOUT)
break;
} while (sys->state != THUMB_DONE);
pthread_mutex_unlock(&sys->doneMutex);
/* Stop and release the media player. */
libvlc_media_player_stop(mp);
libvlc_media_player_release(mp);
if (sys->state == THUMB_DONE) {
/* Create the Java byte array to return the create thumbnail. */
byteArray = (*env)->NewByteArray(env, frameSize);
if (byteArray == NULL)
{
LOGE("Could not allocate the Java byte array to store the frame!");
goto end;
}
(*env)->SetByteArrayRegion(env, byteArray, 0, frameSize,
(jbyte *)sys->frameData);
}
end:
pthread_mutex_destroy(&sys->doneMutex);
pthread_cond_destroy(&sys->doneCondVar);
free(sys->frameData);
free(sys->thumbData);
free(sys);
return byteArray;
}
void MainWindow::gameIsLoaded()
{
if(vlcPlayer!=NULL)
libvlc_media_player_stop(vlcPlayer);
}
JNIEXPORT void JNICALL NAME(nativeStop)(JNIEnv *env, jobject thiz) {
libvlc_media_player_t *mp = (libvlc_media_player_t *) getIntValue(env, thiz, "mLibVlcMediaPlayer");
libvlc_media_player_stop(mp);
}
/**
* Thumbnailer main function.
* return null if the thumbail generation failed.
**/
jbyteArray Java_org_videolan_vlc_android_LibVLC_getThumbnail(JNIEnv *env, jobject thiz,
jint instance, jstring filePath,
jint width, jint height)
{
libvlc_instance_t *libvlc = (libvlc_instance_t *)instance;
jbyteArray byteArray = NULL;
/* Create the thumbnailer data structure */
thumbnailer_sys_t *sys = calloc(1, sizeof(thumbnailer_sys_t));
if (sys == NULL)
{
LOGE("Couldn't create the thumbnailer data structure!");
return NULL;
}
/* Initialize the barrier. */
pthread_mutex_init(&sys->doneMutex, NULL);
pthread_cond_init(&sys->doneCondVar, NULL);
/* Create a media player playing environment */
sys->mp = libvlc_media_player_new(libvlc);
libvlc_media_t *m = new_media(instance, env, thiz, filePath);
if (m == NULL)
{
LOGE("Couldn't create the media to play!");
goto end;
}
libvlc_media_add_option( m, ":no-audio" );
libvlc_media_player_set_media(sys->mp, m);
libvlc_media_release(m);
/* Get the size of the video with the tracks information of the media. */
libvlc_media_track_info_t *tracks;
libvlc_media_parse(m);
int nbTracks = libvlc_media_get_tracks_info(m, &tracks);
unsigned i, videoWidth, videoHeight;
bool hasVideoTrack = false;
for (i = 0; i < nbTracks; ++i)
if (tracks[i].i_type == libvlc_track_video)
{
videoWidth = tracks[i].u.video.i_width;
videoHeight = tracks[i].u.video.i_height;
hasVideoTrack = true;
break;
}
free(tracks);
/* Abord if we have not found a video track. */
if (!hasVideoTrack)
{
LOGE("Could not find a video track in this file.\n");
goto end;
}
/* Compute the size parameters of the frame to generate. */
unsigned picWidth = width;
unsigned picHeight = height;
float videoAR = (float)videoWidth / videoHeight;
if (videoAR < ((float)width / height))
{
picHeight /= videoAR;
sys->thumbnailOffset = (picHeight - height) / 2 * sys->picPitch;
}
else
{
picWidth *= videoAR;
sys->thumbnailOffset = (picWidth - width) / 2 * PIXEL_SIZE;
}
sys->picPitch = picWidth * PIXEL_SIZE;
sys->lineSize = width * PIXEL_SIZE;
sys->nbLines = height;
/* Allocate the memory to store the frames. */
unsigned picSize = sys->picPitch * picHeight;
sys->frameData = malloc(picSize);
if (sys->frameData == NULL)
{
LOGE("Couldn't allocate the memory to store the frame!");
goto end;
}
/* Allocate the memory to store the thumbnail. */
unsigned thumbnailSize = width * height * PIXEL_SIZE;
sys->thumbnail = malloc(thumbnailSize);
if (sys->thumbnail == NULL)
{
LOGE("Couldn't allocate the memory to store the thumbnail!");
goto end;
}
/* Set the video format and the callbacks. */
libvlc_video_set_format(sys->mp, "RGBA", picWidth, picHeight, sys->picPitch);
libvlc_video_set_callbacks(sys->mp, thumbnailer_lock, thumbnailer_unlock,
NULL, (void*)sys);
/* Play the media. */
libvlc_media_player_play(sys->mp);
libvlc_media_player_set_position(sys->mp, THUMBNAIL_POSITION);
/* Wait for the thumbnail to be generated. */
pthread_mutex_lock(&sys->doneMutex);
while (!sys->hasThumb)
pthread_cond_wait(&sys->doneCondVar, &sys->doneMutex);
pthread_mutex_unlock(&sys->doneMutex);
/* Stop and realease the media player. */
libvlc_media_player_stop(sys->mp);
libvlc_media_player_release(sys->mp);
/* Create the Java byte array to return the create thumbnail. */
byteArray = (*env)->NewByteArray(env, thumbnailSize);
if (byteArray == NULL)
{
LOGE("Couldn't allocate the Java byte array to store the frame!");
goto end;
}
(*env)->SetByteArrayRegion(env, byteArray, 0, thumbnailSize,
(jbyte *)sys->thumbnail);
(*env)->DeleteLocalRef(env, byteArray);
end:
pthread_mutex_destroy(&sys->doneMutex);
pthread_cond_destroy(&sys->doneCondVar);
free(sys->thumbnail);
free(sys->frameData);
free(sys);
return byteArray;
}
void SMActionVideoVLC::stop()
{
libvlc_media_player_stop(_mp);
SMAction::stop();
}
/**
* Entry point (main func)
*/
int main(int argc, char **argv) {
// Init SDL + OpenGL
if(SDL_Init(SDL_INIT_VIDEO | SDL_INIT_EVENTTHREAD) == -1) {
return -1;
}
SDL_SetVideoMode(W, H, 16, SDL_OPENGL);
glewInit();
glEnable(GL_TEXTURE_2D);
glEnable(GL_DEPTH_TEST);
// Init Textures
glGenTextures(1, &textureId);
glBindTexture(GL_TEXTURE_2D, textureId);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glGenTextures(1, &textureId2);
glBindTexture(GL_TEXTURE_2D, textureId2);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glGenTextures(1, &textureId3);
glBindTexture(GL_TEXTURE_2D, textureId3);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
// Init SDL_surfaces
sdlStruct.sdlSurface = SDL_CreateRGBSurface(SDL_SWSURFACE, W, H, 16, 0xf800, 0x07e0, 0x001f, 0);
sdlStruct.sdlMutex = SDL_CreateMutex();
sdlStruct2.sdlSurface = SDL_CreateRGBSurface(SDL_SWSURFACE, W, H, 16, 0xf800, 0x07e0, 0x001f, 0);
sdlStruct2.sdlMutex = SDL_CreateMutex();
sdlStruct3.sdlSurface = SDL_CreateRGBSurface(SDL_SWSURFACE, W, H, 16, 0xf800, 0x07e0, 0x001f, 0);
sdlStruct3.sdlMutex = SDL_CreateMutex();
// Init LibVLC + media player
const char *vlc_argv[] = {};
int vlc_argc = sizeof(vlc_argv) / sizeof(*vlc_argv);
libvlc_instance_t * libVlcInstance = libvlc_new(vlc_argc, vlc_argv);
libvlc_media_t * media = libvlc_media_new_path(libVlcInstance, VIDEOFILE);
libvlc_media_player_t * mediaPlayer = libvlc_media_player_new_from_media(media);
libvlc_media_release(media);
libvlc_release(libVlcInstance);
libvlc_video_set_callbacks(mediaPlayer, lockfct, unlockfct, NULL, &sdlStruct);
libvlc_video_set_format(mediaPlayer, "RV16", W, H, W*2);
// Init LibVLC Round2
libvlc_instance_t * libVlcInstance2 = libvlc_new(vlc_argc, vlc_argv);
libvlc_media_t * media2 = libvlc_media_new_path(libVlcInstance2, VIDEOFILE2);
libvlc_media_player_t * mediaPlayer2 = libvlc_media_player_new_from_media(media2);
libvlc_media_release(media2);
libvlc_release(libVlcInstance2);
libvlc_video_set_callbacks(mediaPlayer2, lockfct2, unlockfct2, NULL, &sdlStruct2);
libvlc_video_set_format(mediaPlayer2, "RV16", W, H, W*2);
//Round 3
libvlc_instance_t * libVlcInstance3 = libvlc_new(vlc_argc, vlc_argv);
libvlc_media_t * media3 = libvlc_media_new_path(libVlcInstance3, VIDEOFILE3);
libvlc_media_player_t * mediaPlayer3 = libvlc_media_player_new_from_media(media3);
libvlc_media_release(media3);
libvlc_release(libVlcInstance3);
libvlc_video_set_callbacks(mediaPlayer3, lockfct3, unlockfct3, NULL, &sdlStruct3);
libvlc_video_set_format(mediaPlayer3, "RV16", W, H, W*2);
// Start reading the video
libvlc_media_player_play(mediaPlayer);
libvlc_media_player_play(mediaPlayer2);
libvlc_media_player_play(mediaPlayer3);
libvlc_state_t state = libvlc_media_player_get_state(mediaPlayer);
while ((state != libvlc_Ended) && (state != libvlc_Error)) {
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
loadTexture(); // Loading the texture
// Square
glBegin(GL_QUADS);
glTexCoord2d(0, 0);
glVertex2f(-0.95, 0.00);
glTexCoord2d(0, 1);
glVertex2f(-0.95, 0.95);
glTexCoord2d(1, 1);
glVertex2f(0.00, 0.95);
glTexCoord2d(1, 0);
glVertex2f(0.00, 0.00);
glEnd();
loadTexture2();
glBegin(GL_QUADS);
glTexCoord2d(0, 0);
glVertex2f(0.05, 0.00);
glTexCoord2d(0, 1);
glVertex2f(0.05, 0.95);
glTexCoord2d(1, 1);
glVertex2f(0.95, 0.95);
glTexCoord2d(1, 0);
glVertex2f(0.95, 0.00);
glEnd();
loadTexture3();
glBegin(GL_QUADS);
glTexCoord2d(0, 0);
glVertex2f(-0.95, -0.95);
glTexCoord2d(0, 1);
glVertex2f(-0.95, -0.05);
glTexCoord2d(1, 1);
glVertex2f(0.00, -0.05);
glTexCoord2d(1, 0);
glVertex2f(0.0, -0.95);
glEnd();
glFlush();
SDL_GL_SwapBuffers();
SDL_Delay(10);
state = libvlc_media_player_get_state(mediaPlayer);
}
// Frees
libvlc_media_player_stop(mediaPlayer);
libvlc_media_player_stop(mediaPlayer2);
libvlc_media_player_stop(mediaPlayer3);
libvlc_media_player_release(mediaPlayer);
libvlc_media_player_release(mediaPlayer2);
libvlc_media_player_release(mediaPlayer3);
SDL_DestroyMutex(sdlStruct.sdlMutex);
SDL_FreeSurface(sdlStruct.sdlSurface);
SDL_DestroyMutex(sdlStruct2.sdlMutex);
SDL_FreeSurface(sdlStruct2.sdlSurface);
SDL_DestroyMutex(sdlStruct3.sdlMutex);
SDL_FreeSurface(sdlStruct3.sdlSurface);
SDL_Quit();
return 0;
}
int Ibex::VLCVideoPlayer::playVLCVideo(const char *fileName, Display *dpy, GLXDrawable root) {
libvlc_instance_t *libvlc;
libvlc_media_t *m;
libvlc_media_player_t *mp;
char const *vlc_argv[] = {
//"-H"
"--text-renderer","none"
//"--reset-plugins-cache",
//"--reset-config"
//"--no-audio", // Don't play audio.
//"--no-xlib" // Don't use Xlib.
// Apply a video filter.
//"--video-filter", "sepia",
//"--sepia-intensity=200"
};
int vlc_argc = sizeof(vlc_argv) / sizeof(*vlc_argv);
int done = 0, action = 0, pause = 0;
struct context context;
context.isStereo = 0;
context.videoTexture = videoTexture;
context.player = this;
context.dpy = dpy;
context.root = root;
context.data = data;
// create texture/mutex
// If you don't have this variable set you must have plugins directory
// with the executable or libvlc_new() will not work!
printf("VLC_PLUGIN_PATH=%s\n", getenv("VLC_PLUGIN_PATH"));
// Initialise libVLC.
libvlc = libvlc_new(vlc_argc, vlc_argv);
if(NULL == libvlc) {
printf("LibVLC initialization failure.\n");
return EXIT_FAILURE;
}
m = libvlc_media_new_path(libvlc, fileName);
mp = libvlc_media_player_new_from_media(m);
libvlc_media_release(m);
pixels = new uint32_t[VIDEOWIDTH*VIDEOHEIGHT*4];
memset(pixels, 0, sizeof(uint32_t)*VIDEOWIDTH*VIDEOHEIGHT*4);
libvlc_video_set_callbacks(mp, vlclock, vlcunlock, vlcdisplay, &context);
libvlc_video_set_format(mp, "RV32", VIDEOWIDTH, VIDEOHEIGHT, VIDEOWIDTH*sizeof(uint32_t));
//libvlc_video_set_format(mp, "YUYV", VIDEOWIDTH, VIDEOHEIGHT, VIDEOWIDTH*2);
if(libvlc_video_get_size(mp, 0, &width, & height) == 0) {
VIDEOWIDTH = width;
VIDEOHEIGHT = height;
}
context.mp = mp;
libvlc_media_player_play(mp);
// Main loop.
while(!done) {
action = 0;
switch(action) {
case 'q':
done = 1;
break;
case ' ':
printf("Pause toggle.\n");
pause = !pause;
break;
}
if(!pause) { context.n++; }
std::this_thread::sleep_for(std::chrono::milliseconds(100));
}
// Stop stream and clean up libVLC.
libvlc_media_player_stop(mp);
libvlc_media_player_release(mp);
libvlc_release(libvlc);
// delete mutex/texture info
quit(0);
return 0;
}
void qtVlc::stop()
{
/* stop the media_player */
libvlc_media_player_stop (mp);
}
jboolean Java_org_videolan_libvlc_LibVLC_hasVideoTrack(JNIEnv *env, jobject thiz,
jstring fileLocation)
{
/* Create a new item and assign it to the media player. */
libvlc_media_t *p_m = new_media(env, thiz, fileLocation, false, false);
if (p_m == NULL)
{
LOGE("Could not create the media!");
return JNI_FALSE;
}
/* Get the tracks information of the media. */
libvlc_media_parse(p_m);
libvlc_media_player_t* p_mp = libvlc_media_player_new_from_media(p_m);
libvlc_media_player_set_video_title_display(p_mp, libvlc_position_disable, 0);
struct length_change_monitor* monitor;
monitor = malloc(sizeof(struct length_change_monitor));
if (!monitor) return 0;
/* Initialize pthread variables. */
pthread_mutex_init(&monitor->doneMutex, NULL);
pthread_cond_init(&monitor->doneCondVar, NULL);
monitor->length_changed = false;
libvlc_event_manager_t *ev = libvlc_media_player_event_manager(p_mp);
libvlc_event_attach(ev, libvlc_MediaPlayerLengthChanged, length_changed_callback, monitor);
libvlc_media_player_play( p_mp );
pthread_mutex_lock(&monitor->doneMutex);
struct timespec deadline;
clock_gettime(CLOCK_REALTIME, &deadline);
deadline.tv_sec += 2; /* If "VLC can't open the file", return */
int mp_alive = 1;
while( !monitor->length_changed && mp_alive ) {
pthread_cond_timedwait(&monitor->doneCondVar, &monitor->doneMutex, &deadline);
mp_alive = libvlc_media_player_will_play(p_mp);
}
pthread_mutex_unlock(&monitor->doneMutex);
int i_nbTracks;
if( mp_alive )
i_nbTracks = libvlc_video_get_track_count(p_mp);
else
i_nbTracks = -1;
LOGI("Number of video tracks: %d",i_nbTracks);
libvlc_event_detach(ev, libvlc_MediaPlayerLengthChanged, length_changed_callback, monitor);
libvlc_media_player_stop(p_mp);
libvlc_media_player_release(p_mp);
libvlc_media_release(p_m);
pthread_mutex_destroy(&monitor->doneMutex);
pthread_cond_destroy(&monitor->doneCondVar);
free(monitor);
if(i_nbTracks > 0)
return JNI_TRUE;
else if(i_nbTracks < 0)
(*env)->ThrowNew(env, (*env)->FindClass(env, "java/io/IOException"), "VLC can't open the file");
else
return JNI_FALSE;
}
void media_stop()
{
if(mediaplay != NULL)
libvlc_media_player_stop(mediaplay);
else;
}
