void QmlVlcVideo::getVideoSize( unsigned* width, unsigned* height )
{
libvlc_media_t* media = libvlc_media_player_get_media( m_player.get_mp() );
if( media && !libvlc_media_is_parsed( media ) )
libvlc_media_parse( media );
*width = *height = 0;
libvlc_video_get_size( m_player.get_mp(), 0, width, height );
if( media && ( !*width || !*height ) ) {
/*FIXME: It's not absolutely correct way to detect media dimensions,
since now will be returned dimensions of first track with not zero demensions,
and there are no any guarantee it will be be current playing track.
But we nothing can do with it, since there are no way to match current
playing track and track info received from libvlc_media_get_tracks_info for now.*/
libvlc_media_track_info_t* info;
int infoCount = libvlc_media_get_tracks_info( media, &info );
for( int i = 0; i < infoCount; ++i ) {
if( libvlc_track_video == info[i].i_type &&
info[i].u.video.i_width &&
info[i].u.video.i_height )
{
*width = info[i].u.video.i_width;
*height = info[i].u.video.i_height;
break;
}
}
libvlc_free( info );
}
}
void FBVLCVideoAPI::getVideoSize( unsigned* width, unsigned* height )
{
FBVLCPtr plg = getPlugin();
vlc_player& p = plg->get_player();
vlc::media media = p.current_media();
libvlc_media_t* libvlc_media = media.libvlc_media_t();
if( media && !media.is_parsed() )
media.parse();
*width = *height = 0;
libvlc_video_get_size( p.get_mp(), 0, width, height );
if( media && ( !*width || !*height ) ) {
/*FIXME: It's not absolutely correct way to detect media dimensions,
since now will be returned dimensions of first track with not zero demensions,
and there are no any guarantee it will be be current playing track.
But we nothing can do with it, since there are no way to match current
playing track and track info received from libvlc_media_get_tracks_info for now.*/
libvlc_media_track_info_t* info;
int infoCount = libvlc_media_get_tracks_info( libvlc_media, &info );
for( int i = 0; i < infoCount; ++i ) {
if( libvlc_track_video == info[i].i_type &&
info[i].u.video.i_width &&
info[i].u.video.i_height )
{
*width = info[i].u.video.i_width;
*height = info[i].u.video.i_height;
break;
}
}
libvlc_free( info );
}
}
void VPlayer::play()
{
if(mp){
if(state==Stop){
libvlc_media_track_info_t *info;
libvlc_media_parse(m);
int i=libvlc_media_get_tracks_info(m,&info);
for(--i;i>=0;--i){
if(info[i].i_type==libvlc_track_video){
srcSize.setWidth (info[i].u.video.i_width);
srcSize.setHeight(info[i].u.video.i_height);
}
}
free(info);
dstSize=srcSize;
avpicture_alloc(&srcFrame,PIX_FMT_RGB32,srcSize.width(),srcSize.height());
avpicture_alloc(&dstFrame,PIX_FMT_RGB32,dstSize.width(),dstSize.height());
valid=true;
libvlc_video_set_format(mp,"RV32",srcSize.width(),srcSize.height(),srcSize.width()*4);
libvlc_video_set_callbacks(mp,lock,NULL,display,this);
Utils::delayExec(50,[this](){libvlc_media_player_play(mp);});
}
else{
libvlc_media_player_pause(mp);
if(state==Play){
state=Pause;
emit paused();
}
else{
state=Play;
}
}
}
}
void Media::parseMediaInfos()
{
libvlc_media_parse(_vlcMedia);
libvlc_media_track_info_t* tracks;
int tracksCount = libvlc_media_get_tracks_info(_vlcMedia, &tracks);
for (int track = 0; track < tracksCount; track++) {
switch (tracks[track].i_type)
{
case libvlc_track_audio:
_audioTracks << AudioTrack( &tracks[track] );
break;
case libvlc_track_video:
_videoTracks << VideoTrack( &tracks[track] );
break;
case libvlc_track_text:
_subtitlesTracks << Track( &tracks[track] );
break;
default:
break;
}
}
_originalDuration = libvlc_media_get_duration(_vlcMedia);
_duration = _originalDuration;
QFile file(this->location());
_size = file.size();
file.close();
}
// retorna true si es un video, false en caso contrario
// Si es un video ademas rellena los parametros Tiempo, nAncho y nAlto
const bool InformacionArchivoEx::_AnalisisVLC(const TCHAR *Path, UINT64 &Tiempo, UINT &nAncho, UINT &nAlto, libvlc_instance_t *Instancia) {
char Destino[2049];
size_t TamnTexto = wcslen(Path);
int TamRes = WideCharToMultiByte(CP_UTF8, NULL, Path, TamnTexto, Destino, 2048, NULL, NULL);
Destino[TamRes] = 0;
libvlc_media_t *Media = NULL;
libvlc_media_player_t *nMediaPlayer = NULL;
Media = libvlc_media_new_path(Instancia, Destino);
libvlc_media_parse(Media);
libvlc_media_add_option(Media, "sout=#description:dummy");
nMediaPlayer = libvlc_media_player_new_from_media(Media);
libvlc_state_t Estado = libvlc_Opening;
libvlc_media_player_play(nMediaPlayer);
//posible deadlock
// Esperamos hasta que empieze el play
while (Estado != libvlc_Playing && Estado != libvlc_Ended) {
Estado = libvlc_media_player_get_state(nMediaPlayer);
Sleep(100);
if (Estado == libvlc_Error) { // Hay un error en la libvlc, salimos
Sleep(300); // Nos aseguramos de que el log se escriba
libvlc_media_player_stop(nMediaPlayer);
libvlc_media_release(Media);
libvlc_media_player_release(nMediaPlayer);
Tiempo = 0;
nAncho = 0;
nAlto = 0;
return false;
}
}
// Miramos los streams disponibles y buscamos el de video
libvlc_media_track_info_t *TI = NULL;
int z = libvlc_media_get_tracks_info(Media, &TI);
for (int n = 0; n < z; n++) {
if (TI->i_type == libvlc_track_video) {
libvlc_media_player_stop(nMediaPlayer);
Tiempo = 0; //libvlc_media_player_get_length(nMediaPlayer); // NO DA BIEN EL TIEMPO..............
nAncho = TI->u.video.i_width;
nAlto = TI->u.video.i_height;
libvlc_media_release(Media);
libvlc_media_player_release(nMediaPlayer);
return true;
}
TI ++;
}
libvlc_media_release(Media);
libvlc_media_player_release(nMediaPlayer);
// No hay streams de video retornamos false
Tiempo = 0;
nAncho = 0;
nAlto = 0;
return false;
}
MediaMeta VLCWrapper::GetItemMeta (int row, const QString& location) const
{
MediaMeta meta;
auto m = libvlc_media_list_item_at_index (List_.get (), row);
if (!m)
return meta;
if (!QUrl (location).scheme ().isEmpty ())
{
meta.Artist_ = tr ("Internet stream");
meta.Title_ = location;
return meta;
}
libvlc_media_parse (m);
meta.Artist_ = QString::fromUtf8 (libvlc_media_get_meta (m, libvlc_meta_Artist));
meta.Album_ = QString::fromUtf8 (libvlc_media_get_meta (m, libvlc_meta_Album));
meta.Title_ = QString::fromUtf8 (libvlc_media_get_meta (m, libvlc_meta_Title));
meta.Genre_ = QString::fromUtf8 (libvlc_media_get_meta (m, libvlc_meta_Genre));
meta.Date_ = libvlc_media_get_meta (m, libvlc_meta_Date);
meta.Length_ = libvlc_media_get_duration (m) / 1000;
if (location.isNull ())
meta.Location_ = QUrl (libvlc_media_get_mrl (m));
else
meta.Location_ = QUrl (location);
libvlc_media_track_info_t *pTrackInfo;
int numOfStream = libvlc_media_get_tracks_info (m, &pTrackInfo);
if (numOfStream >= 1)
meta.Type_ = pTrackInfo->i_type;
meta.TrackNumber_ = QString (libvlc_media_get_meta (m,
libvlc_meta_TrackNumber))
.toInt ();
return meta;
}
JNIEXPORT jint JNICALL NAME(nativeGetVideoWidth)(JNIEnv *env, jobject thiz)
{
libvlc_media_t *media = (libvlc_media_t *) getIntValue(env, thiz, "mLibVlcMedia");
if (!media || !libvlc_media_is_parsed(media))
return 0;
/* FIXME: it returns the first video's information only */
int i, n;
int width = 0, height = 0;
libvlc_media_track_info_t *track = 0;
n = libvlc_media_get_tracks_info(media, &track);
if (n <= 0)
return 0;
for (i = 0; i < n; i++) {
libvlc_media_track_info_t t = track[i];
if (t.i_type == libvlc_track_video) {
width = t.u.video.i_width;
height = t.u.video.i_height;
break;
}
}
free(track);
return width;
}
/**
* Thumbnailer main function.
* return null if the thumbail generation failed.
**/
jbyteArray Java_org_videolan_vlc_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;
float screenAR = (float)width / height;
if (screenAR < videoAR)
{
picHeight = (float)width / videoAR;
sys->thumbnailOffset = (height - picHeight) / 2 * width * PIXEL_SIZE;
}
else
{
picWidth = (float)height * videoAR;
sys->thumbnailOffset = (width - picWidth) / 2 * PIXEL_SIZE;
}
sys->picPitch = picWidth * PIXEL_SIZE;
sys->lineSize = width * PIXEL_SIZE;
sys->nbLines = picHeight;
/* 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 = calloc(thumbnailSize, 1);
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;
}
/**
* Thumbnailer main function.
* return null if the thumbail generation failed.
**/
jbyteArray Java_org_videolan_vlc_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_info_t *tracks;
libvlc_media_parse(m);
int nbTracks = libvlc_media_get_tracks_info(m, &tracks);
libvlc_media_release(m);
/* Parse the results */
unsigned videoWidth, videoHeight;
bool hasVideoTrack = false;
for (unsigned 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);
/* Abort if we have not found a video track. */
if (!hasVideoTrack)
{
LOGE("Could not find any video track in this file.\n");
goto end;
}
/* VLC could not tell us the size */
if( videoWidth == 0 || videoHeight == 0 )
{
LOGE("Could not find the 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;
}
