2006-01-08 17:32:33 +01:00
|
|
|
/*****************************************************************************
|
2008-03-30 03:59:32 +02:00
|
|
|
* media_player.c: Libvlc API Media Instance management functions
|
2006-01-08 17:32:33 +01:00
|
|
|
*****************************************************************************
|
2015-01-26 20:37:02 +01:00
|
|
|
* Copyright (C) 2005-2015 VLC authors and VideoLAN
|
2006-01-08 17:32:33 +01:00
|
|
|
*
|
2006-02-01 19:06:48 +01:00
|
|
|
* Authors: Clément Stenac <zorglub@videolan.org>
|
2006-01-08 17:32:33 +01:00
|
|
|
*
|
LGPL
Re-license almost all of libVLC and libVLCcore to LGPLv2.1+
This move was authorized by the developers, either:
- by e-mail,
- by vote at the VideoLAN Dev Days 2011,
- on the license website,
- in a contract, oral or written.
No objection was raised, so far.
The developers agreeing are:
Justus Piater
Alexis Ballier
Alexander Bethke
Mohammed Adnène Trojette
Alex Converse
Alexey Sokolov
Alexis de Lattre
Andre Pang
Anthony Loiseau
Cyril Deguet
André Weber
Boris Dorès
Brieuc Jeunhomme
Benjamin Drung
Hugo Beauzée-Luyssen
Benoit Steiner
Benjamin Pracht
Bernie Purcell
Przemyslaw Fiala
Arnaud de Bossoreille de Ribou
Brad Smith
Nick Briggs
Christopher Rath
Christophe Courtaut
Christopher Mueller
Clement Chesnin
Andres Krapf
Damien Fouilleul
David Flynn
Sebastien Zwickert
Antoine Cellerier
Jérôme Decoodt
Jérome Decoodt
Dylan Yudaken
Eduard Babayan
Eugenio Jarosiewicz
Elliot Murphy
Eric Petit
Erwan Tulou
Etienne Membrives
Ludovic Fauvet
Fabio Ritrovato
Tobias Güntner
Jakub Wieczorek
Frédéric Crozat
Francois Cartegnie
Laurent Aimar
Florian G. Pflug
Felix Paul Kühne
Frank Enderle
Rafaël Carré
Simon Latapie
Gildas Bazin
Geoffroy Couprie
Julien / Gellule
Gildas Bazin
Arnaud Schauly
Toralf Niebuhr
Vicente Jimenez Aguilar
Derk-Jan Hartman
Henri Fallon
Ilkka Ollakka
Olivier Teulière
Rémi Duraffort
Jakob Leben
Jean-Baptiste Kempf
Jean-Paul Saman
Jean-Philippe Grimaldi
Jean-François Massol
Gaël Hendryckx
Jakob Leben
Jean-Marc Dressler
Jai Menon
Johan Bilien
Johann Ransay
Joris van Rooij
JP Dinger
Jean-Philippe André
Adrien Grand
Juha Jeronen
Juho Vähä-Herttua
Kaarlo Raiha
Kaarlo Raiha
Kamil Baldyga
Keary Griffin
Ken Self
KO Myung-Hun
Pierre Ynard
Filippo Carone
Loïc Minier
Luca Barbato
Lucas C. Villa Real
Lukas Durfina
Adrien Maglo
Marc Ariberti
Mark Lee
Mark Moriarty
Martin Storsjö
Christophe Massiot
Michel Kaempf
Marian Ďurkovič
Mirsal Ennaime
Carlo Calabrò
Damien Lucas
Naohiro Koriyama
Basos G
Pierre Baillet
Vincent Penquerc'h
Olivier Aubert
Pankaj Yadav
Paul Corke
Pierre d'Herbemont
Philippe Morin
Antoine Lejeune
Michael Ploujnikov
Jean-Marc Dressler
Michael Hanselmann
Rafaël Carré
Ramiro Polla
Rémi Denis-Courmont
Renaud Dartus
Richard Shepherd
Faustino Osuna
Arnaud Vallat
Rob Jonson
Robert Jedrzejczyk
Steve Lhomme
Rocky Bernstein
Romain Goyet
Rov Juvano
Sam Hocevar
Martin T. H. Sandsmark
Sebastian Birk
Sébastien Escudier
Vincent Seguin
Fabio Ritrovato
Sigmund Augdal Helberg
Casian Andrei
Srikanth Raju
Hannes Domani
Stéphane Borel
Stephan Krempel
Stephan Assmus
Tony Castley
Pavlov Konstantin
Eric Petit
Tanguy Krotoff
Dennis van Amerongen
Michel Lespinasse
Can Wu
Xavier Marchesini
Sébastien Toque
Christophe Mutricy
Yoann Peronneau
Yohann Martineau
Yuval Tze
Scott Caudle
Clément Stenac
It is possible, that some minor piece of code was badly tracked, for
some reasons (SVN, mainly) or that some small developers did not answer.
However, as an "œuvre collective", defined as in "CPI 113-2 alinéa 3",
and seeing "Cour. Cass. 17 Mai 1978", and seeing that the editor and
the very vast majority of developers have agreed (> 99.99% of the code,
> 99% of developers), we are fine here.
2011-11-27 21:44:15 +01:00
|
|
|
* This program is free software; you can redistribute it and/or modify it
|
|
|
|
* under the terms of the GNU Lesser General Public License as published by
|
|
|
|
* the Free Software Foundation; either version 2.1 of the License, or
|
2006-01-08 17:32:33 +01:00
|
|
|
* (at your option) any later version.
|
|
|
|
*
|
|
|
|
* This program is distributed in the hope that it will be useful,
|
|
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
LGPL
Re-license almost all of libVLC and libVLCcore to LGPLv2.1+
This move was authorized by the developers, either:
- by e-mail,
- by vote at the VideoLAN Dev Days 2011,
- on the license website,
- in a contract, oral or written.
No objection was raised, so far.
The developers agreeing are:
Justus Piater
Alexis Ballier
Alexander Bethke
Mohammed Adnène Trojette
Alex Converse
Alexey Sokolov
Alexis de Lattre
Andre Pang
Anthony Loiseau
Cyril Deguet
André Weber
Boris Dorès
Brieuc Jeunhomme
Benjamin Drung
Hugo Beauzée-Luyssen
Benoit Steiner
Benjamin Pracht
Bernie Purcell
Przemyslaw Fiala
Arnaud de Bossoreille de Ribou
Brad Smith
Nick Briggs
Christopher Rath
Christophe Courtaut
Christopher Mueller
Clement Chesnin
Andres Krapf
Damien Fouilleul
David Flynn
Sebastien Zwickert
Antoine Cellerier
Jérôme Decoodt
Jérome Decoodt
Dylan Yudaken
Eduard Babayan
Eugenio Jarosiewicz
Elliot Murphy
Eric Petit
Erwan Tulou
Etienne Membrives
Ludovic Fauvet
Fabio Ritrovato
Tobias Güntner
Jakub Wieczorek
Frédéric Crozat
Francois Cartegnie
Laurent Aimar
Florian G. Pflug
Felix Paul Kühne
Frank Enderle
Rafaël Carré
Simon Latapie
Gildas Bazin
Geoffroy Couprie
Julien / Gellule
Gildas Bazin
Arnaud Schauly
Toralf Niebuhr
Vicente Jimenez Aguilar
Derk-Jan Hartman
Henri Fallon
Ilkka Ollakka
Olivier Teulière
Rémi Duraffort
Jakob Leben
Jean-Baptiste Kempf
Jean-Paul Saman
Jean-Philippe Grimaldi
Jean-François Massol
Gaël Hendryckx
Jakob Leben
Jean-Marc Dressler
Jai Menon
Johan Bilien
Johann Ransay
Joris van Rooij
JP Dinger
Jean-Philippe André
Adrien Grand
Juha Jeronen
Juho Vähä-Herttua
Kaarlo Raiha
Kaarlo Raiha
Kamil Baldyga
Keary Griffin
Ken Self
KO Myung-Hun
Pierre Ynard
Filippo Carone
Loïc Minier
Luca Barbato
Lucas C. Villa Real
Lukas Durfina
Adrien Maglo
Marc Ariberti
Mark Lee
Mark Moriarty
Martin Storsjö
Christophe Massiot
Michel Kaempf
Marian Ďurkovič
Mirsal Ennaime
Carlo Calabrò
Damien Lucas
Naohiro Koriyama
Basos G
Pierre Baillet
Vincent Penquerc'h
Olivier Aubert
Pankaj Yadav
Paul Corke
Pierre d'Herbemont
Philippe Morin
Antoine Lejeune
Michael Ploujnikov
Jean-Marc Dressler
Michael Hanselmann
Rafaël Carré
Ramiro Polla
Rémi Denis-Courmont
Renaud Dartus
Richard Shepherd
Faustino Osuna
Arnaud Vallat
Rob Jonson
Robert Jedrzejczyk
Steve Lhomme
Rocky Bernstein
Romain Goyet
Rov Juvano
Sam Hocevar
Martin T. H. Sandsmark
Sebastian Birk
Sébastien Escudier
Vincent Seguin
Fabio Ritrovato
Sigmund Augdal Helberg
Casian Andrei
Srikanth Raju
Hannes Domani
Stéphane Borel
Stephan Krempel
Stephan Assmus
Tony Castley
Pavlov Konstantin
Eric Petit
Tanguy Krotoff
Dennis van Amerongen
Michel Lespinasse
Can Wu
Xavier Marchesini
Sébastien Toque
Christophe Mutricy
Yoann Peronneau
Yohann Martineau
Yuval Tze
Scott Caudle
Clément Stenac
It is possible, that some minor piece of code was badly tracked, for
some reasons (SVN, mainly) or that some small developers did not answer.
However, as an "œuvre collective", defined as in "CPI 113-2 alinéa 3",
and seeing "Cour. Cass. 17 Mai 1978", and seeing that the editor and
the very vast majority of developers have agreed (> 99.99% of the code,
> 99% of developers), we are fine here.
2011-11-27 21:44:15 +01:00
|
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
* GNU Lesser General Public License for more details.
|
2006-01-08 17:32:33 +01:00
|
|
|
*
|
LGPL
Re-license almost all of libVLC and libVLCcore to LGPLv2.1+
This move was authorized by the developers, either:
- by e-mail,
- by vote at the VideoLAN Dev Days 2011,
- on the license website,
- in a contract, oral or written.
No objection was raised, so far.
The developers agreeing are:
Justus Piater
Alexis Ballier
Alexander Bethke
Mohammed Adnène Trojette
Alex Converse
Alexey Sokolov
Alexis de Lattre
Andre Pang
Anthony Loiseau
Cyril Deguet
André Weber
Boris Dorès
Brieuc Jeunhomme
Benjamin Drung
Hugo Beauzée-Luyssen
Benoit Steiner
Benjamin Pracht
Bernie Purcell
Przemyslaw Fiala
Arnaud de Bossoreille de Ribou
Brad Smith
Nick Briggs
Christopher Rath
Christophe Courtaut
Christopher Mueller
Clement Chesnin
Andres Krapf
Damien Fouilleul
David Flynn
Sebastien Zwickert
Antoine Cellerier
Jérôme Decoodt
Jérome Decoodt
Dylan Yudaken
Eduard Babayan
Eugenio Jarosiewicz
Elliot Murphy
Eric Petit
Erwan Tulou
Etienne Membrives
Ludovic Fauvet
Fabio Ritrovato
Tobias Güntner
Jakub Wieczorek
Frédéric Crozat
Francois Cartegnie
Laurent Aimar
Florian G. Pflug
Felix Paul Kühne
Frank Enderle
Rafaël Carré
Simon Latapie
Gildas Bazin
Geoffroy Couprie
Julien / Gellule
Gildas Bazin
Arnaud Schauly
Toralf Niebuhr
Vicente Jimenez Aguilar
Derk-Jan Hartman
Henri Fallon
Ilkka Ollakka
Olivier Teulière
Rémi Duraffort
Jakob Leben
Jean-Baptiste Kempf
Jean-Paul Saman
Jean-Philippe Grimaldi
Jean-François Massol
Gaël Hendryckx
Jakob Leben
Jean-Marc Dressler
Jai Menon
Johan Bilien
Johann Ransay
Joris van Rooij
JP Dinger
Jean-Philippe André
Adrien Grand
Juha Jeronen
Juho Vähä-Herttua
Kaarlo Raiha
Kaarlo Raiha
Kamil Baldyga
Keary Griffin
Ken Self
KO Myung-Hun
Pierre Ynard
Filippo Carone
Loïc Minier
Luca Barbato
Lucas C. Villa Real
Lukas Durfina
Adrien Maglo
Marc Ariberti
Mark Lee
Mark Moriarty
Martin Storsjö
Christophe Massiot
Michel Kaempf
Marian Ďurkovič
Mirsal Ennaime
Carlo Calabrò
Damien Lucas
Naohiro Koriyama
Basos G
Pierre Baillet
Vincent Penquerc'h
Olivier Aubert
Pankaj Yadav
Paul Corke
Pierre d'Herbemont
Philippe Morin
Antoine Lejeune
Michael Ploujnikov
Jean-Marc Dressler
Michael Hanselmann
Rafaël Carré
Ramiro Polla
Rémi Denis-Courmont
Renaud Dartus
Richard Shepherd
Faustino Osuna
Arnaud Vallat
Rob Jonson
Robert Jedrzejczyk
Steve Lhomme
Rocky Bernstein
Romain Goyet
Rov Juvano
Sam Hocevar
Martin T. H. Sandsmark
Sebastian Birk
Sébastien Escudier
Vincent Seguin
Fabio Ritrovato
Sigmund Augdal Helberg
Casian Andrei
Srikanth Raju
Hannes Domani
Stéphane Borel
Stephan Krempel
Stephan Assmus
Tony Castley
Pavlov Konstantin
Eric Petit
Tanguy Krotoff
Dennis van Amerongen
Michel Lespinasse
Can Wu
Xavier Marchesini
Sébastien Toque
Christophe Mutricy
Yoann Peronneau
Yohann Martineau
Yuval Tze
Scott Caudle
Clément Stenac
It is possible, that some minor piece of code was badly tracked, for
some reasons (SVN, mainly) or that some small developers did not answer.
However, as an "œuvre collective", defined as in "CPI 113-2 alinéa 3",
and seeing "Cour. Cass. 17 Mai 1978", and seeing that the editor and
the very vast majority of developers have agreed (> 99.99% of the code,
> 99% of developers), we are fine here.
2011-11-27 21:44:15 +01:00
|
|
|
* You should have received a copy of the GNU Lesser General Public License
|
|
|
|
* along with this program; if not, write to the Free Software Foundation,
|
|
|
|
* Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
|
2006-01-08 17:32:33 +01:00
|
|
|
*****************************************************************************/
|
|
|
|
|
2009-05-25 15:09:40 +02:00
|
|
|
#ifdef HAVE_CONFIG_H
|
|
|
|
# include "config.h"
|
|
|
|
#endif
|
|
|
|
|
2009-05-25 10:47:38 +02:00
|
|
|
#include <assert.h>
|
2008-01-23 22:50:58 +01:00
|
|
|
|
2006-01-08 17:32:33 +01:00
|
|
|
#include <vlc/libvlc.h>
|
2009-05-25 10:47:38 +02:00
|
|
|
#include <vlc/libvlc_media.h>
|
|
|
|
#include <vlc/libvlc_events.h>
|
|
|
|
|
2006-11-26 15:20:34 +01:00
|
|
|
#include <vlc_demux.h>
|
|
|
|
#include <vlc_input.h>
|
2008-06-13 15:47:11 +02:00
|
|
|
#include <vlc_vout.h>
|
2013-07-13 20:21:37 +02:00
|
|
|
#include <vlc_aout.h>
|
2010-09-10 08:47:10 +02:00
|
|
|
#include <vlc_keys.h>
|
2009-05-25 10:47:38 +02:00
|
|
|
|
|
|
|
#include "libvlc_internal.h"
|
|
|
|
#include "media_internal.h" // libvlc_media_set_state()
|
|
|
|
#include "media_player_internal.h"
|
2006-01-08 17:32:33 +01:00
|
|
|
|
2008-01-13 23:41:45 +01:00
|
|
|
static int
|
2008-02-28 00:57:11 +01:00
|
|
|
input_seekable_changed( vlc_object_t * p_this, char const * psz_cmd,
|
|
|
|
vlc_value_t oldval, vlc_value_t newval,
|
|
|
|
void * p_userdata );
|
|
|
|
static int
|
|
|
|
input_pausable_changed( vlc_object_t * p_this, char const * psz_cmd,
|
|
|
|
vlc_value_t oldval, vlc_value_t newval,
|
|
|
|
void * p_userdata );
|
|
|
|
static int
|
2014-02-06 22:03:24 +01:00
|
|
|
input_scrambled_changed( vlc_object_t * p_this, char const * psz_cmd,
|
|
|
|
vlc_value_t oldval, vlc_value_t newval,
|
|
|
|
void * p_userdata );
|
|
|
|
static int
|
2008-11-23 15:21:12 +01:00
|
|
|
input_event_changed( vlc_object_t * p_this, char const * psz_cmd,
|
2008-01-13 23:41:45 +01:00
|
|
|
vlc_value_t oldval, vlc_value_t newval,
|
|
|
|
void * p_userdata );
|
|
|
|
|
2014-08-04 12:07:25 +02:00
|
|
|
static int
|
|
|
|
input_es_changed( vlc_object_t * p_this, char const * psz_cmd,
|
|
|
|
int action, vlc_value_t *p_val,
|
|
|
|
void *p_userdata);
|
|
|
|
|
|
|
|
static int
|
|
|
|
input_es_selected( vlc_object_t * p_this, char const * psz_cmd,
|
|
|
|
vlc_value_t oldval, vlc_value_t newval,
|
|
|
|
void * p_userdata );
|
|
|
|
|
2015-07-27 12:42:38 +02:00
|
|
|
static int
|
|
|
|
corks_changed(vlc_object_t *obj, const char *name, vlc_value_t old,
|
|
|
|
vlc_value_t cur, void *opaque);
|
|
|
|
|
2015-07-27 13:00:08 +02:00
|
|
|
static int
|
|
|
|
mute_changed(vlc_object_t *obj, const char *name, vlc_value_t old,
|
|
|
|
vlc_value_t cur, void *opaque);
|
|
|
|
|
2015-07-27 13:05:37 +02:00
|
|
|
static int
|
|
|
|
volume_changed(vlc_object_t *obj, const char *name, vlc_value_t old,
|
|
|
|
vlc_value_t cur, void *opaque);
|
|
|
|
|
2014-08-04 12:07:25 +02:00
|
|
|
static void
|
|
|
|
add_es_callbacks( input_thread_t *p_input_thread, libvlc_media_player_t *p_mi );
|
|
|
|
|
|
|
|
static void
|
|
|
|
del_es_callbacks( input_thread_t *p_input_thread, libvlc_media_player_t *p_mi );
|
|
|
|
|
2009-09-16 09:28:23 +02:00
|
|
|
static int
|
|
|
|
snapshot_was_taken( vlc_object_t *p_this, char const *psz_cmd,
|
|
|
|
vlc_value_t oldval, vlc_value_t newval, void *p_data );
|
2008-10-30 10:45:56 +01:00
|
|
|
|
2009-07-24 16:35:21 +02:00
|
|
|
static void libvlc_media_player_destroy( libvlc_media_player_t *p_mi );
|
2007-12-24 19:45:10 +01:00
|
|
|
|
2009-09-16 09:28:23 +02:00
|
|
|
/*
|
|
|
|
* Shortcuts
|
|
|
|
*/
|
|
|
|
|
2010-02-17 23:04:39 +01:00
|
|
|
/*
|
|
|
|
* The input lock protects the input and input resource pointer.
|
|
|
|
* It MUST NOT be used from callbacks.
|
|
|
|
*
|
|
|
|
* The object lock protects the reset, namely the media and the player state.
|
|
|
|
* It can, and usually needs to be taken from callbacks.
|
|
|
|
* The object lock can be acquired under the input lock... and consequently
|
|
|
|
* the opposite order is STRICTLY PROHIBITED.
|
|
|
|
*/
|
2009-09-16 09:28:23 +02:00
|
|
|
static inline void lock(libvlc_media_player_t *mp)
|
|
|
|
{
|
|
|
|
vlc_mutex_lock(&mp->object_lock);
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline void unlock(libvlc_media_player_t *mp)
|
|
|
|
{
|
|
|
|
vlc_mutex_unlock(&mp->object_lock);
|
|
|
|
}
|
|
|
|
|
2010-02-17 23:04:39 +01:00
|
|
|
static inline void lock_input(libvlc_media_player_t *mp)
|
|
|
|
{
|
|
|
|
vlc_mutex_lock(&mp->input.lock);
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline void unlock_input(libvlc_media_player_t *mp)
|
|
|
|
{
|
|
|
|
vlc_mutex_unlock(&mp->input.lock);
|
|
|
|
}
|
|
|
|
|
2007-06-24 15:19:21 +02:00
|
|
|
/*
|
2009-03-04 11:38:26 +01:00
|
|
|
* Release the associated input thread.
|
2007-07-08 17:22:53 +02:00
|
|
|
*
|
|
|
|
* Object lock is NOT held.
|
2010-02-17 23:04:39 +01:00
|
|
|
* Input lock is held or instance is being destroyed.
|
2007-06-24 15:19:21 +02:00
|
|
|
*/
|
2015-02-05 21:40:42 +01:00
|
|
|
static void release_input_thread( libvlc_media_player_t *p_mi )
|
2007-06-24 15:19:21 +02:00
|
|
|
{
|
2010-02-17 22:09:19 +01:00
|
|
|
assert( p_mi );
|
2007-06-24 15:19:21 +02:00
|
|
|
|
2010-02-17 23:04:39 +01:00
|
|
|
input_thread_t *p_input_thread = p_mi->input.p_thread;
|
2010-02-17 22:09:19 +01:00
|
|
|
if( !p_input_thread )
|
2007-07-11 20:00:35 +02:00
|
|
|
return;
|
2011-05-22 21:49:58 +02:00
|
|
|
p_mi->input.p_thread = NULL;
|
2007-06-24 15:19:21 +02:00
|
|
|
|
2009-05-13 17:27:19 +02:00
|
|
|
var_DelCallback( p_input_thread, "can-seek",
|
|
|
|
input_seekable_changed, p_mi );
|
|
|
|
var_DelCallback( p_input_thread, "can-pause",
|
|
|
|
input_pausable_changed, p_mi );
|
2014-02-06 22:03:24 +01:00
|
|
|
var_DelCallback( p_input_thread, "program-scrambled",
|
|
|
|
input_scrambled_changed, p_mi );
|
2009-05-13 17:27:19 +02:00
|
|
|
var_DelCallback( p_input_thread, "intf-event",
|
|
|
|
input_event_changed, p_mi );
|
2014-08-04 12:07:25 +02:00
|
|
|
del_es_callbacks( p_input_thread, p_mi );
|
2009-05-13 17:27:19 +02:00
|
|
|
|
|
|
|
/* We owned this one */
|
2015-02-05 21:40:42 +01:00
|
|
|
input_Stop( p_input_thread );
|
2011-05-22 21:49:58 +02:00
|
|
|
input_Close( p_input_thread );
|
2007-06-24 15:19:21 +02:00
|
|
|
}
|
|
|
|
|
2006-06-05 20:23:56 +02:00
|
|
|
/*
|
|
|
|
* Retrieve the input thread. Be sure to release the object
|
2007-06-07 14:34:50 +02:00
|
|
|
* once you are done with it. (libvlc Internal)
|
2006-06-05 20:23:56 +02:00
|
|
|
*/
|
2010-01-31 18:52:07 +01:00
|
|
|
input_thread_t *libvlc_get_input_thread( libvlc_media_player_t *p_mi )
|
2006-01-08 17:32:33 +01:00
|
|
|
{
|
|
|
|
input_thread_t *p_input_thread;
|
|
|
|
|
2010-01-31 18:52:07 +01:00
|
|
|
assert( p_mi );
|
2008-05-18 13:09:26 +02:00
|
|
|
|
2010-02-17 23:04:39 +01:00
|
|
|
lock_input(p_mi);
|
|
|
|
p_input_thread = p_mi->input.p_thread;
|
2010-01-31 18:52:07 +01:00
|
|
|
if( p_input_thread )
|
|
|
|
vlc_object_hold( p_input_thread );
|
2010-01-31 19:54:18 +01:00
|
|
|
else
|
|
|
|
libvlc_printerr( "No active input" );
|
2010-02-17 23:04:39 +01:00
|
|
|
unlock_input(p_mi);
|
2008-03-19 02:32:28 +01:00
|
|
|
|
2006-06-05 20:23:56 +02:00
|
|
|
return p_input_thread;
|
|
|
|
}
|
|
|
|
|
2009-12-07 20:35:10 +01:00
|
|
|
/*
|
|
|
|
* Set the internal state of the media_player. (media player Internal)
|
|
|
|
*
|
|
|
|
* Function will lock the media_player.
|
|
|
|
*/
|
2010-01-18 09:06:16 +01:00
|
|
|
static void set_state( libvlc_media_player_t *p_mi, libvlc_state_t state,
|
|
|
|
bool b_locked )
|
|
|
|
{
|
|
|
|
if(!b_locked)
|
|
|
|
lock(p_mi);
|
2009-12-07 20:35:10 +01:00
|
|
|
p_mi->state = state;
|
2010-02-05 14:13:29 +01:00
|
|
|
|
2009-12-07 20:35:10 +01:00
|
|
|
libvlc_media_t *media = p_mi->p_md;
|
|
|
|
if (media)
|
|
|
|
libvlc_media_retain(media);
|
2010-02-05 14:13:29 +01:00
|
|
|
|
2010-01-18 09:06:16 +01:00
|
|
|
if(!b_locked)
|
|
|
|
unlock(p_mi);
|
2009-12-07 20:35:10 +01:00
|
|
|
|
2010-02-05 14:13:29 +01:00
|
|
|
if (media)
|
|
|
|
{
|
2009-12-07 20:35:10 +01:00
|
|
|
// Also set the state of the corresponding media
|
|
|
|
// This is strictly for convenience.
|
|
|
|
libvlc_media_set_state(media, state);
|
2010-01-29 01:16:50 +01:00
|
|
|
|
|
|
|
libvlc_media_release(media);
|
2009-12-07 20:35:10 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-02-28 00:45:10 +01:00
|
|
|
static int
|
2008-02-28 00:57:11 +01:00
|
|
|
input_seekable_changed( vlc_object_t * p_this, char const * psz_cmd,
|
2008-02-28 00:45:10 +01:00
|
|
|
vlc_value_t oldval, vlc_value_t newval,
|
|
|
|
void * p_userdata )
|
|
|
|
{
|
|
|
|
VLC_UNUSED(oldval);
|
2008-02-28 00:57:11 +01:00
|
|
|
VLC_UNUSED(p_this);
|
|
|
|
VLC_UNUSED(psz_cmd);
|
2008-03-30 03:59:32 +02:00
|
|
|
libvlc_media_player_t * p_mi = p_userdata;
|
2008-02-28 00:45:10 +01:00
|
|
|
libvlc_event_t event;
|
|
|
|
|
2008-03-31 06:35:08 +02:00
|
|
|
event.type = libvlc_MediaPlayerSeekableChanged;
|
2008-03-30 03:59:32 +02:00
|
|
|
event.u.media_player_seekable_changed.new_seekable = newval.b_bool;
|
2008-02-28 00:45:10 +01:00
|
|
|
|
|
|
|
libvlc_event_send( p_mi->p_event_manager, &event );
|
|
|
|
return VLC_SUCCESS;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
input_pausable_changed( vlc_object_t * p_this, char const * psz_cmd,
|
|
|
|
vlc_value_t oldval, vlc_value_t newval,
|
|
|
|
void * p_userdata )
|
|
|
|
{
|
|
|
|
VLC_UNUSED(oldval);
|
2008-02-28 00:57:11 +01:00
|
|
|
VLC_UNUSED(p_this);
|
|
|
|
VLC_UNUSED(psz_cmd);
|
2008-03-30 03:59:32 +02:00
|
|
|
libvlc_media_player_t * p_mi = p_userdata;
|
2008-02-28 00:45:10 +01:00
|
|
|
libvlc_event_t event;
|
|
|
|
|
2008-03-31 06:35:08 +02:00
|
|
|
event.type = libvlc_MediaPlayerPausableChanged;
|
2008-03-30 03:59:32 +02:00
|
|
|
event.u.media_player_pausable_changed.new_pausable = newval.b_bool;
|
2008-02-28 00:45:10 +01:00
|
|
|
|
|
|
|
libvlc_event_send( p_mi->p_event_manager, &event );
|
|
|
|
return VLC_SUCCESS;
|
|
|
|
}
|
|
|
|
|
2014-02-06 22:03:24 +01:00
|
|
|
static int
|
|
|
|
input_scrambled_changed( vlc_object_t * p_this, char const * psz_cmd,
|
|
|
|
vlc_value_t oldval, vlc_value_t newval,
|
|
|
|
void * p_userdata )
|
|
|
|
{
|
|
|
|
VLC_UNUSED(oldval);
|
|
|
|
VLC_UNUSED(p_this);
|
|
|
|
VLC_UNUSED(psz_cmd);
|
|
|
|
libvlc_media_player_t * p_mi = p_userdata;
|
|
|
|
libvlc_event_t event;
|
|
|
|
|
|
|
|
event.type = libvlc_MediaPlayerScrambledChanged;
|
|
|
|
event.u.media_player_scrambled_changed.new_scrambled = newval.b_bool;
|
|
|
|
|
|
|
|
libvlc_event_send( p_mi->p_event_manager, &event );
|
|
|
|
return VLC_SUCCESS;
|
|
|
|
}
|
|
|
|
|
2007-08-20 06:43:48 +02:00
|
|
|
static int
|
2008-11-23 15:21:12 +01:00
|
|
|
input_event_changed( vlc_object_t * p_this, char const * psz_cmd,
|
2007-08-20 06:43:48 +02:00
|
|
|
vlc_value_t oldval, vlc_value_t newval,
|
|
|
|
void * p_userdata )
|
|
|
|
{
|
2015-10-15 14:02:55 +02:00
|
|
|
VLC_UNUSED(oldval); VLC_UNUSED(psz_cmd);
|
2008-11-23 15:21:12 +01:00
|
|
|
input_thread_t * p_input = (input_thread_t *)p_this;
|
2008-03-30 03:59:32 +02:00
|
|
|
libvlc_media_player_t * p_mi = p_userdata;
|
2008-11-23 15:21:12 +01:00
|
|
|
libvlc_event_t event;
|
2007-12-29 02:29:48 +01:00
|
|
|
|
2008-12-11 23:03:32 +01:00
|
|
|
assert( !strcmp( psz_cmd, "intf-event" ) );
|
2007-12-29 02:29:48 +01:00
|
|
|
|
2008-12-11 23:03:32 +01:00
|
|
|
if( newval.i_int == INPUT_EVENT_STATE )
|
|
|
|
{
|
2009-07-06 04:50:03 +02:00
|
|
|
libvlc_state_t libvlc_state;
|
2008-12-11 23:03:32 +01:00
|
|
|
|
|
|
|
switch ( var_GetInteger( p_input, "state" ) )
|
|
|
|
{
|
|
|
|
case INIT_S:
|
|
|
|
libvlc_state = libvlc_NothingSpecial;
|
|
|
|
event.type = libvlc_MediaPlayerNothingSpecial;
|
|
|
|
break;
|
|
|
|
case OPENING_S:
|
|
|
|
libvlc_state = libvlc_Opening;
|
|
|
|
event.type = libvlc_MediaPlayerOpening;
|
|
|
|
break;
|
|
|
|
case PLAYING_S:
|
|
|
|
libvlc_state = libvlc_Playing;
|
|
|
|
event.type = libvlc_MediaPlayerPlaying;
|
|
|
|
break;
|
|
|
|
case PAUSE_S:
|
|
|
|
libvlc_state = libvlc_Paused;
|
|
|
|
event.type = libvlc_MediaPlayerPaused;
|
|
|
|
break;
|
|
|
|
case END_S:
|
|
|
|
libvlc_state = libvlc_Ended;
|
|
|
|
event.type = libvlc_MediaPlayerEndReached;
|
|
|
|
break;
|
|
|
|
case ERROR_S:
|
|
|
|
libvlc_state = libvlc_Error;
|
|
|
|
event.type = libvlc_MediaPlayerEncounteredError;
|
|
|
|
break;
|
|
|
|
|
|
|
|
default:
|
|
|
|
return VLC_SUCCESS;
|
|
|
|
}
|
2010-01-29 01:16:50 +01:00
|
|
|
|
2010-01-18 09:06:16 +01:00
|
|
|
set_state( p_mi, libvlc_state, false );
|
2008-12-11 23:03:32 +01:00
|
|
|
libvlc_event_send( p_mi->p_event_manager, &event );
|
|
|
|
}
|
2015-02-05 21:30:36 +01:00
|
|
|
else if( newval.i_int == INPUT_EVENT_DEAD )
|
2009-07-24 16:35:21 +02:00
|
|
|
{
|
2015-02-08 15:32:10 +01:00
|
|
|
libvlc_state_t libvlc_state = libvlc_Ended;
|
2009-07-24 16:35:21 +02:00
|
|
|
event.type = libvlc_MediaPlayerStopped;
|
|
|
|
|
2010-01-18 09:06:16 +01:00
|
|
|
set_state( p_mi, libvlc_state, false );
|
2009-07-24 16:35:21 +02:00
|
|
|
libvlc_event_send( p_mi->p_event_manager, &event );
|
|
|
|
}
|
2009-05-11 22:17:54 +02:00
|
|
|
else if( newval.i_int == INPUT_EVENT_POSITION )
|
2008-12-11 23:03:32 +01:00
|
|
|
{
|
|
|
|
if( var_GetInteger( p_input, "state" ) != PLAYING_S )
|
|
|
|
return VLC_SUCCESS; /* Don't send the position while stopped */
|
|
|
|
|
|
|
|
/* */
|
|
|
|
event.type = libvlc_MediaPlayerPositionChanged;
|
2009-03-04 11:38:26 +01:00
|
|
|
event.u.media_player_position_changed.new_position =
|
|
|
|
var_GetFloat( p_input, "position" );
|
2008-12-11 23:03:32 +01:00
|
|
|
libvlc_event_send( p_mi->p_event_manager, &event );
|
|
|
|
|
|
|
|
/* */
|
|
|
|
event.type = libvlc_MediaPlayerTimeChanged;
|
2009-03-04 11:38:26 +01:00
|
|
|
event.u.media_player_time_changed.new_time =
|
2015-05-22 20:52:42 +02:00
|
|
|
from_mtime(var_GetInteger( p_input, "time" ));
|
2008-12-11 23:03:32 +01:00
|
|
|
libvlc_event_send( p_mi->p_event_manager, &event );
|
|
|
|
}
|
2009-05-14 14:52:32 +02:00
|
|
|
else if( newval.i_int == INPUT_EVENT_LENGTH )
|
|
|
|
{
|
|
|
|
event.type = libvlc_MediaPlayerLengthChanged;
|
|
|
|
event.u.media_player_length_changed.new_length =
|
2015-05-22 20:52:42 +02:00
|
|
|
from_mtime(var_GetInteger( p_input, "length" ));
|
2009-05-14 14:52:32 +02:00
|
|
|
libvlc_event_send( p_mi->p_event_manager, &event );
|
|
|
|
}
|
2010-05-18 16:21:37 +02:00
|
|
|
else if( newval.i_int == INPUT_EVENT_CACHE )
|
|
|
|
{
|
|
|
|
event.type = libvlc_MediaPlayerBuffering;
|
|
|
|
event.u.media_player_buffering.new_cache = (int)(100 *
|
|
|
|
var_GetFloat( p_input, "cache" ));
|
|
|
|
libvlc_event_send( p_mi->p_event_manager, &event );
|
|
|
|
}
|
2011-09-05 19:37:35 +02:00
|
|
|
else if( newval.i_int == INPUT_EVENT_VOUT )
|
|
|
|
{
|
|
|
|
vout_thread_t **pp_vout;
|
|
|
|
size_t i_vout;
|
|
|
|
if( input_Control( p_input, INPUT_GET_VOUTS, &pp_vout, &i_vout ) )
|
|
|
|
{
|
|
|
|
i_vout = 0;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
for( size_t i = 0; i < i_vout; i++ )
|
|
|
|
vlc_object_release( pp_vout[i] );
|
|
|
|
free( pp_vout );
|
|
|
|
}
|
|
|
|
|
|
|
|
event.type = libvlc_MediaPlayerVout;
|
|
|
|
event.u.media_player_vout.new_count = i_vout;
|
|
|
|
libvlc_event_send( p_mi->p_event_manager, &event );
|
|
|
|
}
|
2015-11-24 16:29:48 +01:00
|
|
|
else if ( newval.i_int == INPUT_EVENT_TITLE )
|
|
|
|
{
|
|
|
|
event.type = libvlc_MediaPlayerTitleChanged;
|
|
|
|
event.u.media_player_title_changed.new_title = var_GetInteger( p_input, "title" );
|
|
|
|
libvlc_event_send( p_mi->p_event_manager, &event );
|
|
|
|
}
|
2015-11-24 16:33:40 +01:00
|
|
|
else if ( newval.i_int == INPUT_EVENT_CHAPTER )
|
|
|
|
{
|
|
|
|
event.type = libvlc_MediaPlayerChapterChanged;
|
|
|
|
event.u.media_player_chapter_changed.new_chapter = var_GetInteger( p_input, "chapter" );
|
|
|
|
libvlc_event_send( p_mi->p_event_manager, &event );
|
|
|
|
}
|
2008-11-23 15:21:12 +01:00
|
|
|
|
2007-08-20 06:43:48 +02:00
|
|
|
return VLC_SUCCESS;
|
|
|
|
}
|
|
|
|
|
2014-08-04 12:07:25 +02:00
|
|
|
static int track_type_from_name(const char *psz_name)
|
|
|
|
{
|
|
|
|
if( !strcmp( psz_name, "video-es" ) )
|
|
|
|
return libvlc_track_video;
|
|
|
|
else if( !strcmp( psz_name, "audio-es" ) )
|
|
|
|
return libvlc_track_audio;
|
|
|
|
else if( !strcmp( psz_name, "spu-es" ) )
|
|
|
|
return libvlc_track_text;
|
|
|
|
else
|
|
|
|
return libvlc_track_unknown;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int input_es_changed( vlc_object_t *p_this,
|
|
|
|
char const *psz_cmd,
|
|
|
|
int action,
|
|
|
|
vlc_value_t *p_val,
|
|
|
|
void *p_userdata )
|
|
|
|
{
|
|
|
|
VLC_UNUSED(p_this);
|
|
|
|
libvlc_media_player_t *mp = p_userdata;
|
|
|
|
libvlc_event_t event;
|
|
|
|
|
|
|
|
/* Ignore the "Disable" element */
|
|
|
|
if (p_val && p_val->i_int < 0)
|
|
|
|
return VLC_EGENERIC;
|
|
|
|
|
|
|
|
switch (action)
|
|
|
|
{
|
|
|
|
case VLC_VAR_ADDCHOICE:
|
|
|
|
event.type = libvlc_MediaPlayerESAdded;
|
|
|
|
break;
|
|
|
|
case VLC_VAR_DELCHOICE:
|
|
|
|
case VLC_VAR_CLEARCHOICES:
|
|
|
|
event.type = libvlc_MediaPlayerESDeleted;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
return VLC_EGENERIC;
|
|
|
|
}
|
|
|
|
|
|
|
|
event.u.media_player_es_changed.i_type = track_type_from_name(psz_cmd);
|
|
|
|
|
|
|
|
int i_id;
|
|
|
|
if (action != VLC_VAR_CLEARCHOICES)
|
|
|
|
{
|
|
|
|
if (!p_val)
|
|
|
|
return VLC_EGENERIC;
|
|
|
|
i_id = p_val->i_int;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
/* -1 means all ES tracks of this type were deleted. */
|
|
|
|
i_id = -1;
|
|
|
|
}
|
|
|
|
event.u.media_player_es_changed.i_id = i_id;
|
|
|
|
|
|
|
|
libvlc_event_send(mp->p_event_manager, &event);
|
|
|
|
|
|
|
|
return VLC_SUCCESS;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
input_es_selected( vlc_object_t * p_this, char const * psz_cmd,
|
|
|
|
vlc_value_t oldval, vlc_value_t newval,
|
|
|
|
void * p_userdata )
|
|
|
|
{
|
|
|
|
VLC_UNUSED(p_this);
|
|
|
|
VLC_UNUSED(oldval);
|
|
|
|
libvlc_media_player_t *mp = p_userdata;
|
|
|
|
libvlc_event_t event;
|
|
|
|
|
|
|
|
event.type = libvlc_MediaPlayerESSelected;
|
|
|
|
event.u.media_player_es_changed.i_type = track_type_from_name(psz_cmd);
|
|
|
|
event.u.media_player_es_changed.i_id = newval.i_int;
|
|
|
|
|
|
|
|
libvlc_event_send(mp->p_event_manager, &event);
|
|
|
|
|
|
|
|
return VLC_SUCCESS;
|
|
|
|
}
|
|
|
|
|
2009-09-16 09:28:23 +02:00
|
|
|
/**************************************************************************
|
|
|
|
* Snapshot Taken Event.
|
|
|
|
*
|
|
|
|
* FIXME: This snapshot API interface makes no sense in media_player.
|
|
|
|
*************************************************************************/
|
|
|
|
static int snapshot_was_taken(vlc_object_t *p_this, char const *psz_cmd,
|
|
|
|
vlc_value_t oldval, vlc_value_t newval, void *p_data )
|
|
|
|
{
|
|
|
|
VLC_UNUSED(psz_cmd); VLC_UNUSED(oldval); VLC_UNUSED(p_this);
|
|
|
|
|
|
|
|
libvlc_media_player_t *mp = p_data;
|
|
|
|
libvlc_event_t event;
|
|
|
|
event.type = libvlc_MediaPlayerSnapshotTaken;
|
|
|
|
event.u.media_player_snapshot_taken.psz_filename = newval.psz_string;
|
|
|
|
libvlc_event_send(mp->p_event_manager, &event);
|
|
|
|
|
|
|
|
return VLC_SUCCESS;
|
|
|
|
}
|
|
|
|
|
2015-07-27 12:42:38 +02:00
|
|
|
static int corks_changed(vlc_object_t *obj, const char *name, vlc_value_t old,
|
|
|
|
vlc_value_t cur, void *opaque)
|
|
|
|
{
|
|
|
|
libvlc_media_player_t *mp = (libvlc_media_player_t *)obj;
|
|
|
|
|
|
|
|
if (!old.i_int != !cur.i_int)
|
|
|
|
{
|
|
|
|
libvlc_event_t event;
|
|
|
|
|
|
|
|
event.type = cur.i_int ? libvlc_MediaPlayerCorked
|
|
|
|
: libvlc_MediaPlayerUncorked;
|
|
|
|
libvlc_event_send(mp->p_event_manager, &event);
|
|
|
|
}
|
|
|
|
VLC_UNUSED(name); VLC_UNUSED(opaque);
|
|
|
|
return VLC_SUCCESS;
|
|
|
|
}
|
|
|
|
|
2015-07-27 15:30:33 +02:00
|
|
|
static int audio_device_changed(vlc_object_t *obj, const char *name,
|
|
|
|
vlc_value_t old, vlc_value_t cur, void *opaque)
|
|
|
|
{
|
|
|
|
libvlc_media_player_t *mp = (libvlc_media_player_t *)obj;
|
|
|
|
libvlc_event_t event;
|
|
|
|
|
|
|
|
event.type = libvlc_MediaPlayerAudioDevice;
|
|
|
|
event.u.media_player_audio_device.device = cur.psz_string;
|
|
|
|
libvlc_event_send(mp->p_event_manager, &event);
|
|
|
|
VLC_UNUSED(name); VLC_UNUSED(old); VLC_UNUSED(opaque);
|
|
|
|
return VLC_SUCCESS;
|
|
|
|
}
|
|
|
|
|
2015-07-27 13:00:08 +02:00
|
|
|
static int mute_changed(vlc_object_t *obj, const char *name, vlc_value_t old,
|
|
|
|
vlc_value_t cur, void *opaque)
|
|
|
|
{
|
|
|
|
libvlc_media_player_t *mp = (libvlc_media_player_t *)obj;
|
|
|
|
|
|
|
|
if (old.b_bool != cur.b_bool)
|
|
|
|
{
|
|
|
|
libvlc_event_t event;
|
|
|
|
|
|
|
|
event.type = cur.b_bool ? libvlc_MediaPlayerMuted
|
|
|
|
: libvlc_MediaPlayerUnmuted;
|
|
|
|
libvlc_event_send(mp->p_event_manager, &event);
|
|
|
|
}
|
|
|
|
VLC_UNUSED(name); VLC_UNUSED(opaque);
|
|
|
|
return VLC_SUCCESS;
|
|
|
|
}
|
|
|
|
|
2015-07-27 13:05:37 +02:00
|
|
|
static int volume_changed(vlc_object_t *obj, const char *name, vlc_value_t old,
|
|
|
|
vlc_value_t cur, void *opaque)
|
|
|
|
{
|
|
|
|
libvlc_media_player_t *mp = (libvlc_media_player_t *)obj;
|
|
|
|
libvlc_event_t event;
|
|
|
|
|
|
|
|
event.type = libvlc_MediaPlayerAudioVolume;
|
|
|
|
event.u.media_player_audio_volume.volume = cur.f_float;
|
|
|
|
libvlc_event_send(mp->p_event_manager, &event);
|
|
|
|
VLC_UNUSED(name); VLC_UNUSED(old); VLC_UNUSED(opaque);
|
|
|
|
return VLC_SUCCESS;
|
|
|
|
}
|
|
|
|
|
2007-06-17 22:54:32 +02:00
|
|
|
/**************************************************************************
|
2009-03-04 11:38:26 +01:00
|
|
|
* Create a Media Instance object.
|
|
|
|
*
|
|
|
|
* Refcount strategy:
|
|
|
|
* - All items created by _new start with a refcount set to 1.
|
|
|
|
* - Accessor _release decrease the refcount by 1, if after that
|
|
|
|
* operation the refcount is 0, the object is destroyed.
|
|
|
|
* - Accessor _retain increase the refcount by 1 (XXX: to implement)
|
|
|
|
*
|
|
|
|
* Object locking strategy:
|
|
|
|
* - No lock held while in constructor.
|
|
|
|
* - When accessing any member variable this lock is held. (XXX who locks?)
|
|
|
|
* - When attempting to destroy the object the lock is also held.
|
2007-06-17 22:54:32 +02:00
|
|
|
**************************************************************************/
|
2008-03-30 03:59:32 +02:00
|
|
|
libvlc_media_player_t *
|
2010-01-31 18:30:49 +01:00
|
|
|
libvlc_media_player_new( libvlc_instance_t *instance )
|
2007-06-24 15:19:21 +02:00
|
|
|
{
|
2009-09-16 09:28:23 +02:00
|
|
|
libvlc_media_player_t * mp;
|
2007-06-24 15:19:21 +02:00
|
|
|
|
2009-09-16 09:28:23 +02:00
|
|
|
assert(instance);
|
2007-06-24 15:19:21 +02:00
|
|
|
|
2010-01-31 17:45:12 +01:00
|
|
|
mp = vlc_object_create (instance->p_libvlc_int, sizeof(*mp));
|
|
|
|
if (unlikely(mp == NULL))
|
2008-05-18 13:09:26 +02:00
|
|
|
{
|
2009-09-16 09:28:23 +02:00
|
|
|
libvlc_printerr("Not enough memory");
|
2008-05-18 13:09:26 +02:00
|
|
|
return NULL;
|
|
|
|
}
|
2010-01-31 17:56:56 +01:00
|
|
|
|
2010-02-14 12:50:36 +01:00
|
|
|
/* Input */
|
|
|
|
var_Create (mp, "rate", VLC_VAR_FLOAT|VLC_VAR_DOINHERIT);
|
|
|
|
|
2010-02-01 17:49:24 +01:00
|
|
|
/* Video */
|
2010-07-08 19:24:32 +02:00
|
|
|
var_Create (mp, "vout", VLC_VAR_STRING|VLC_VAR_DOINHERIT);
|
2010-07-08 18:52:30 +02:00
|
|
|
var_Create (mp, "window", VLC_VAR_STRING);
|
2010-07-10 17:09:05 +02:00
|
|
|
var_Create (mp, "vmem-lock", VLC_VAR_ADDRESS);
|
|
|
|
var_Create (mp, "vmem-unlock", VLC_VAR_ADDRESS);
|
|
|
|
var_Create (mp, "vmem-display", VLC_VAR_ADDRESS);
|
|
|
|
var_Create (mp, "vmem-data", VLC_VAR_ADDRESS);
|
2010-11-21 14:54:13 +01:00
|
|
|
var_Create (mp, "vmem-setup", VLC_VAR_ADDRESS);
|
|
|
|
var_Create (mp, "vmem-cleanup", VLC_VAR_ADDRESS);
|
2010-07-10 17:09:05 +02:00
|
|
|
var_Create (mp, "vmem-chroma", VLC_VAR_STRING | VLC_VAR_DOINHERIT);
|
|
|
|
var_Create (mp, "vmem-width", VLC_VAR_INTEGER | VLC_VAR_DOINHERIT);
|
|
|
|
var_Create (mp, "vmem-height", VLC_VAR_INTEGER | VLC_VAR_DOINHERIT);
|
2010-07-14 21:39:18 +02:00
|
|
|
var_Create (mp, "vmem-pitch", VLC_VAR_INTEGER | VLC_VAR_DOINHERIT);
|
2014-10-11 13:37:52 +02:00
|
|
|
var_Create (mp, "avcodec-hw", VLC_VAR_STRING);
|
2010-01-31 17:56:56 +01:00
|
|
|
var_Create (mp, "drawable-xid", VLC_VAR_INTEGER);
|
2013-06-05 15:41:18 +02:00
|
|
|
#if defined (_WIN32) || defined (__OS2__)
|
2011-04-11 17:21:34 +02:00
|
|
|
var_Create (mp, "drawable-hwnd", VLC_VAR_INTEGER);
|
2010-01-31 17:56:56 +01:00
|
|
|
#endif
|
|
|
|
#ifdef __APPLE__
|
|
|
|
var_Create (mp, "drawable-nsobject", VLC_VAR_ADDRESS);
|
|
|
|
#endif
|
2015-06-25 13:52:59 +02:00
|
|
|
#ifdef __ANDROID__
|
|
|
|
var_Create (mp, "android-jvm", VLC_VAR_ADDRESS);
|
|
|
|
var_Create (mp, "drawable-androidwindow", VLC_VAR_ADDRESS);
|
|
|
|
#endif
|
2015-10-23 18:46:02 +02:00
|
|
|
#ifdef HAVE_EVAS
|
|
|
|
var_Create (mp, "drawable-evasobject", VLC_VAR_ADDRESS);
|
|
|
|
#endif
|
2010-01-31 17:56:56 +01:00
|
|
|
|
|
|
|
var_Create (mp, "keyboard-events", VLC_VAR_BOOL);
|
|
|
|
var_SetBool (mp, "keyboard-events", true);
|
|
|
|
var_Create (mp, "mouse-events", VLC_VAR_BOOL);
|
2010-02-01 17:49:24 +01:00
|
|
|
var_SetBool (mp, "mouse-events", true);
|
2010-01-31 17:56:56 +01:00
|
|
|
|
2010-02-01 18:47:45 +01:00
|
|
|
var_Create (mp, "fullscreen", VLC_VAR_BOOL);
|
2014-10-23 20:06:26 +02:00
|
|
|
var_Create (mp, "autoscale", VLC_VAR_BOOL | VLC_VAR_DOINHERIT);
|
|
|
|
var_Create (mp, "zoom", VLC_VAR_FLOAT | VLC_VAR_DOINHERIT);
|
2010-02-01 18:47:45 +01:00
|
|
|
var_Create (mp, "aspect-ratio", VLC_VAR_STRING);
|
|
|
|
var_Create (mp, "crop", VLC_VAR_STRING);
|
|
|
|
var_Create (mp, "deinterlace", VLC_VAR_INTEGER);
|
|
|
|
var_Create (mp, "deinterlace-mode", VLC_VAR_STRING);
|
2010-02-06 19:18:35 +01:00
|
|
|
|
2015-01-15 20:21:53 +01:00
|
|
|
var_Create (mp, "vbi-page", VLC_VAR_INTEGER);
|
|
|
|
var_SetInteger (mp, "vbi-page", 100);
|
2010-02-01 18:47:45 +01:00
|
|
|
|
2010-02-06 19:18:35 +01:00
|
|
|
var_Create (mp, "marq-marquee", VLC_VAR_STRING);
|
|
|
|
var_Create (mp, "marq-color", VLC_VAR_INTEGER | VLC_VAR_DOINHERIT);
|
|
|
|
var_Create (mp, "marq-opacity", VLC_VAR_INTEGER | VLC_VAR_DOINHERIT);
|
|
|
|
var_Create (mp, "marq-position", VLC_VAR_INTEGER | VLC_VAR_DOINHERIT);
|
|
|
|
var_Create (mp, "marq-refresh", VLC_VAR_INTEGER | VLC_VAR_DOINHERIT);
|
|
|
|
var_Create (mp, "marq-size", VLC_VAR_INTEGER | VLC_VAR_DOINHERIT);
|
|
|
|
var_Create (mp, "marq-timeout", VLC_VAR_INTEGER | VLC_VAR_DOINHERIT);
|
|
|
|
var_Create (mp, "marq-x", VLC_VAR_INTEGER | VLC_VAR_DOINHERIT);
|
|
|
|
var_Create (mp, "marq-y", VLC_VAR_INTEGER | VLC_VAR_DOINHERIT);
|
|
|
|
|
|
|
|
var_Create (mp, "logo-file", VLC_VAR_STRING);
|
|
|
|
var_Create (mp, "logo-x", VLC_VAR_INTEGER | VLC_VAR_DOINHERIT);
|
|
|
|
var_Create (mp, "logo-y", VLC_VAR_INTEGER | VLC_VAR_DOINHERIT);
|
|
|
|
var_Create (mp, "logo-delay", VLC_VAR_INTEGER | VLC_VAR_DOINHERIT);
|
|
|
|
var_Create (mp, "logo-repeat", VLC_VAR_INTEGER | VLC_VAR_DOINHERIT);
|
|
|
|
var_Create (mp, "logo-opacity", VLC_VAR_INTEGER | VLC_VAR_DOINHERIT);
|
|
|
|
var_Create (mp, "logo-position", VLC_VAR_INTEGER | VLC_VAR_DOINHERIT);
|
|
|
|
|
Add adjust filter features to libvlc_media_player/libvlc_video
This patch exposes the adjust module to libvlc_media_player/libvlc_video
and adds a frequently requested featureset: to manipulate brightness,
contrast, gamma, saturation and hue through libvlc. The patch introduces
a new set of functions analogous to
libvlc_video_{get,set}_{marq,logo}_*, hence the use of the function set
should be self explanatory.
New Functions:
* value = libvlc_video_get_adjust_int( p_mi, option );
* libvlc_video_set_adjust_int( p_mi, option, value );
* value = libvlc_video_get_adjust_float( p_mi, option );
* libvlc_video_set_adjust_float( p_mi, option, value );
New Options:
* libvlc_adjust_Enable
* libvlc_adjust_Contrast
* libvlc_adjust_Brightness
* libvlc_adjust_Hue
* libvlc_adjust_Saturation
* libvlc_adjust_Gamma
Signed-off-by: Rémi Denis-Courmont <remi@remlab.net>
2010-06-24 02:16:04 +02:00
|
|
|
var_Create (mp, "contrast", VLC_VAR_FLOAT | VLC_VAR_DOINHERIT);
|
|
|
|
var_Create (mp, "brightness", VLC_VAR_FLOAT | VLC_VAR_DOINHERIT);
|
2014-08-19 20:38:41 +02:00
|
|
|
var_Create (mp, "hue", VLC_VAR_FLOAT | VLC_VAR_DOINHERIT);
|
Add adjust filter features to libvlc_media_player/libvlc_video
This patch exposes the adjust module to libvlc_media_player/libvlc_video
and adds a frequently requested featureset: to manipulate brightness,
contrast, gamma, saturation and hue through libvlc. The patch introduces
a new set of functions analogous to
libvlc_video_{get,set}_{marq,logo}_*, hence the use of the function set
should be self explanatory.
New Functions:
* value = libvlc_video_get_adjust_int( p_mi, option );
* libvlc_video_set_adjust_int( p_mi, option, value );
* value = libvlc_video_get_adjust_float( p_mi, option );
* libvlc_video_set_adjust_float( p_mi, option, value );
New Options:
* libvlc_adjust_Enable
* libvlc_adjust_Contrast
* libvlc_adjust_Brightness
* libvlc_adjust_Hue
* libvlc_adjust_Saturation
* libvlc_adjust_Gamma
Signed-off-by: Rémi Denis-Courmont <remi@remlab.net>
2010-06-24 02:16:04 +02:00
|
|
|
var_Create (mp, "saturation", VLC_VAR_FLOAT | VLC_VAR_DOINHERIT);
|
|
|
|
var_Create (mp, "gamma", VLC_VAR_FLOAT | VLC_VAR_DOINHERIT);
|
|
|
|
|
2010-02-01 18:47:45 +01:00
|
|
|
/* Audio */
|
2010-01-31 19:54:18 +01:00
|
|
|
var_Create (mp, "aout", VLC_VAR_STRING | VLC_VAR_DOINHERIT);
|
2015-07-27 15:30:06 +02:00
|
|
|
var_Create (mp, "audio-device", VLC_VAR_STRING);
|
2011-04-07 22:08:37 +02:00
|
|
|
var_Create (mp, "mute", VLC_VAR_BOOL);
|
2012-07-21 16:36:08 +02:00
|
|
|
var_Create (mp, "volume", VLC_VAR_FLOAT);
|
2012-08-08 17:48:35 +02:00
|
|
|
var_Create (mp, "corks", VLC_VAR_INTEGER);
|
2014-05-24 06:55:30 +02:00
|
|
|
var_Create (mp, "audio-filter", VLC_VAR_STRING);
|
2011-05-10 19:56:21 +02:00
|
|
|
var_Create (mp, "amem-data", VLC_VAR_ADDRESS);
|
|
|
|
var_Create (mp, "amem-setup", VLC_VAR_ADDRESS);
|
2011-09-12 23:19:09 +02:00
|
|
|
var_Create (mp, "amem-cleanup", VLC_VAR_ADDRESS);
|
2011-05-10 19:56:21 +02:00
|
|
|
var_Create (mp, "amem-play", VLC_VAR_ADDRESS);
|
2011-08-04 18:40:53 +02:00
|
|
|
var_Create (mp, "amem-pause", VLC_VAR_ADDRESS);
|
|
|
|
var_Create (mp, "amem-resume", VLC_VAR_ADDRESS);
|
|
|
|
var_Create (mp, "amem-flush", VLC_VAR_ADDRESS);
|
|
|
|
var_Create (mp, "amem-drain", VLC_VAR_ADDRESS);
|
2011-05-10 19:56:21 +02:00
|
|
|
var_Create (mp, "amem-set-volume", VLC_VAR_ADDRESS);
|
|
|
|
var_Create (mp, "amem-format", VLC_VAR_STRING | VLC_VAR_DOINHERIT);
|
|
|
|
var_Create (mp, "amem-rate", VLC_VAR_INTEGER | VLC_VAR_DOINHERIT);
|
|
|
|
var_Create (mp, "amem-channels", VLC_VAR_INTEGER | VLC_VAR_DOINHERIT);
|
2010-01-31 19:54:18 +01:00
|
|
|
|
2013-07-03 18:24:57 +02:00
|
|
|
/* Video Title */
|
|
|
|
var_Create (mp, "video-title-show", VLC_VAR_BOOL);
|
|
|
|
var_Create (mp, "video-title-position", VLC_VAR_INTEGER);
|
|
|
|
var_Create (mp, "video-title-timeout", VLC_VAR_INTEGER);
|
|
|
|
|
2013-07-13 20:21:37 +02:00
|
|
|
/* Equalizer */
|
|
|
|
var_Create (mp, "equalizer-preamp", VLC_VAR_FLOAT);
|
2014-03-19 01:16:17 +01:00
|
|
|
var_Create (mp, "equalizer-vlcfreqs", VLC_VAR_BOOL);
|
2013-07-13 20:21:37 +02:00
|
|
|
var_Create (mp, "equalizer-bands", VLC_VAR_STRING);
|
|
|
|
|
2009-09-16 09:28:23 +02:00
|
|
|
mp->p_md = NULL;
|
2009-12-07 20:35:10 +01:00
|
|
|
mp->state = libvlc_NothingSpecial;
|
2009-09-16 09:28:23 +02:00
|
|
|
mp->p_libvlc_instance = instance;
|
2010-02-17 23:04:39 +01:00
|
|
|
mp->input.p_thread = NULL;
|
2012-10-31 21:59:14 +01:00
|
|
|
mp->input.p_resource = input_resource_New(VLC_OBJECT(mp));
|
|
|
|
if (unlikely(mp->input.p_resource == NULL))
|
|
|
|
{
|
|
|
|
vlc_object_release(mp);
|
|
|
|
return NULL;
|
|
|
|
}
|
2015-06-26 09:08:46 +02:00
|
|
|
audio_output_t *aout = input_resource_GetAout(mp->input.p_resource);
|
|
|
|
if( aout != NULL )
|
|
|
|
input_resource_PutAout(mp->input.p_resource, aout);
|
|
|
|
|
2010-02-17 23:04:39 +01:00
|
|
|
vlc_mutex_init (&mp->input.lock);
|
2009-09-16 09:28:23 +02:00
|
|
|
mp->i_refcount = 1;
|
2015-07-30 22:47:20 +02:00
|
|
|
mp->p_event_manager = libvlc_event_manager_new(mp);
|
2010-01-25 18:19:19 +01:00
|
|
|
if (unlikely(mp->p_event_manager == NULL))
|
2007-08-08 01:51:17 +02:00
|
|
|
{
|
2012-10-31 21:59:14 +01:00
|
|
|
input_resource_Release(mp->input.p_resource);
|
2010-01-31 17:45:12 +01:00
|
|
|
vlc_object_release(mp);
|
2007-08-08 01:51:17 +02:00
|
|
|
return NULL;
|
|
|
|
}
|
2010-01-25 18:19:19 +01:00
|
|
|
vlc_mutex_init(&mp->object_lock);
|
2008-03-31 06:35:07 +02:00
|
|
|
|
2015-07-27 12:42:38 +02:00
|
|
|
var_AddCallback(mp, "corks", corks_changed, NULL);
|
2015-07-27 15:30:33 +02:00
|
|
|
var_AddCallback(mp, "audio-device", audio_device_changed, NULL);
|
2015-07-27 13:00:08 +02:00
|
|
|
var_AddCallback(mp, "mute", mute_changed, NULL);
|
2015-07-27 13:05:37 +02:00
|
|
|
var_AddCallback(mp, "volume", volume_changed, NULL);
|
2011-09-05 21:12:58 +02:00
|
|
|
|
2008-10-30 10:45:56 +01:00
|
|
|
/* Snapshot initialization */
|
|
|
|
/* Attach a var callback to the global object to provide the glue between
|
2009-09-16 09:28:23 +02:00
|
|
|
* vout_thread that generates the event and media_player that re-emits it
|
|
|
|
* with its own event manager
|
|
|
|
*
|
|
|
|
* FIXME: It's unclear why we want to put this in public API, and why we
|
|
|
|
* want to expose it in such a limiting and ugly way.
|
|
|
|
*/
|
2010-01-31 17:45:12 +01:00
|
|
|
var_AddCallback(mp->p_libvlc, "snapshot-file", snapshot_was_taken, mp);
|
2009-09-16 09:28:23 +02:00
|
|
|
|
2010-02-06 17:43:14 +01:00
|
|
|
libvlc_retain(instance);
|
2009-09-16 09:28:23 +02:00
|
|
|
return mp;
|
2007-06-24 15:19:21 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/**************************************************************************
|
2009-03-04 11:38:26 +01:00
|
|
|
* Create a Media Instance object with a media descriptor.
|
2007-06-24 15:19:21 +02:00
|
|
|
**************************************************************************/
|
2008-03-30 03:59:32 +02:00
|
|
|
libvlc_media_player_t *
|
2010-01-31 18:30:49 +01:00
|
|
|
libvlc_media_player_new_from_media( libvlc_media_t * p_md )
|
2007-06-17 22:54:32 +02:00
|
|
|
{
|
2008-03-30 03:59:32 +02:00
|
|
|
libvlc_media_player_t * p_mi;
|
2007-06-17 22:54:32 +02:00
|
|
|
|
2010-01-31 18:30:49 +01:00
|
|
|
p_mi = libvlc_media_player_new( p_md->p_libvlc_instance );
|
2007-08-07 20:59:45 +02:00
|
|
|
if( !p_mi )
|
2007-06-17 22:54:32 +02:00
|
|
|
return NULL;
|
|
|
|
|
2008-03-30 03:59:32 +02:00
|
|
|
libvlc_media_retain( p_md );
|
2007-08-25 16:35:40 +02:00
|
|
|
p_mi->p_md = p_md;
|
2007-06-17 22:54:32 +02:00
|
|
|
|
|
|
|
return p_mi;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**************************************************************************
|
2007-06-24 15:26:17 +02:00
|
|
|
* Destroy a Media Instance object (libvlc internal)
|
2007-07-08 17:22:53 +02:00
|
|
|
*
|
2009-03-04 11:38:26 +01:00
|
|
|
* Warning: No lock held here, but hey, this is internal. Caller must lock.
|
2007-06-17 22:54:32 +02:00
|
|
|
**************************************************************************/
|
2009-05-13 17:50:46 +02:00
|
|
|
static void libvlc_media_player_destroy( libvlc_media_player_t *p_mi )
|
2007-06-17 22:54:32 +02:00
|
|
|
{
|
2009-05-13 17:50:46 +02:00
|
|
|
assert( p_mi );
|
2009-05-09 21:57:51 +02:00
|
|
|
|
2009-05-13 17:50:46 +02:00
|
|
|
/* Detach Callback from the main libvlc object */
|
2010-01-31 17:45:12 +01:00
|
|
|
var_DelCallback( p_mi->p_libvlc,
|
2009-09-16 09:28:23 +02:00
|
|
|
"snapshot-file", snapshot_was_taken, p_mi );
|
2008-10-30 10:45:56 +01:00
|
|
|
|
2015-07-27 12:42:38 +02:00
|
|
|
/* Detach callback from the media player / input manager object */
|
2015-07-27 13:05:37 +02:00
|
|
|
var_DelCallback( p_mi, "volume", volume_changed, NULL );
|
2015-07-27 13:00:08 +02:00
|
|
|
var_DelCallback( p_mi, "mute", mute_changed, NULL );
|
2015-07-27 15:30:33 +02:00
|
|
|
var_DelCallback( p_mi, "audio-device", audio_device_changed, NULL );
|
2015-07-27 12:42:38 +02:00
|
|
|
var_DelCallback( p_mi, "corks", corks_changed, NULL );
|
|
|
|
|
2010-02-17 23:04:39 +01:00
|
|
|
/* No need for lock_input() because no other threads knows us anymore */
|
|
|
|
if( p_mi->input.p_thread )
|
2015-02-05 21:40:42 +01:00
|
|
|
release_input_thread(p_mi);
|
2012-10-31 21:59:14 +01:00
|
|
|
input_resource_Terminate( p_mi->input.p_resource );
|
|
|
|
input_resource_Release( p_mi->input.p_resource );
|
2010-02-17 23:04:39 +01:00
|
|
|
vlc_mutex_destroy( &p_mi->input.lock );
|
2009-08-25 19:11:06 +02:00
|
|
|
|
2009-05-13 17:50:46 +02:00
|
|
|
libvlc_event_manager_release( p_mi->p_event_manager );
|
2009-05-20 20:55:55 +02:00
|
|
|
libvlc_media_release( p_mi->p_md );
|
2009-05-13 17:50:46 +02:00
|
|
|
vlc_mutex_destroy( &p_mi->object_lock );
|
2010-02-06 17:43:14 +01:00
|
|
|
|
|
|
|
libvlc_instance_t *instance = p_mi->p_libvlc_instance;
|
2010-01-31 17:45:12 +01:00
|
|
|
vlc_object_release( p_mi );
|
2010-02-06 17:43:14 +01:00
|
|
|
libvlc_release(instance);
|
2007-06-17 22:54:32 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/**************************************************************************
|
2009-03-04 11:38:26 +01:00
|
|
|
* Release a Media Instance object.
|
|
|
|
*
|
|
|
|
* Function does the locking.
|
2007-06-17 22:54:32 +02:00
|
|
|
**************************************************************************/
|
2008-03-30 03:59:32 +02:00
|
|
|
void libvlc_media_player_release( libvlc_media_player_t *p_mi )
|
2007-06-17 22:54:32 +02:00
|
|
|
{
|
2009-05-13 17:50:46 +02:00
|
|
|
bool destroy;
|
2007-06-17 22:54:32 +02:00
|
|
|
|
2009-05-13 17:50:46 +02:00
|
|
|
assert( p_mi );
|
2009-09-16 09:28:23 +02:00
|
|
|
lock(p_mi);
|
2009-05-13 17:50:46 +02:00
|
|
|
destroy = !--p_mi->i_refcount;
|
2009-09-16 09:28:23 +02:00
|
|
|
unlock(p_mi);
|
2009-05-10 16:05:07 +02:00
|
|
|
|
2009-05-13 17:50:46 +02:00
|
|
|
if( destroy )
|
|
|
|
libvlc_media_player_destroy( p_mi );
|
2007-06-24 15:19:21 +02:00
|
|
|
}
|
2007-06-23 13:40:40 +02:00
|
|
|
|
2007-08-08 23:12:02 +02:00
|
|
|
/**************************************************************************
|
2009-03-04 11:38:26 +01:00
|
|
|
* Retain a Media Instance object.
|
|
|
|
*
|
|
|
|
* Caller must hold the lock.
|
2007-08-08 23:12:02 +02:00
|
|
|
**************************************************************************/
|
2008-03-30 03:59:32 +02:00
|
|
|
void libvlc_media_player_retain( libvlc_media_player_t *p_mi )
|
2007-08-08 23:12:02 +02:00
|
|
|
{
|
2009-05-13 17:51:01 +02:00
|
|
|
assert( p_mi );
|
2007-08-08 23:12:02 +02:00
|
|
|
|
2009-09-16 09:28:23 +02:00
|
|
|
lock(p_mi);
|
2007-08-08 23:12:02 +02:00
|
|
|
p_mi->i_refcount++;
|
2009-09-16 09:28:23 +02:00
|
|
|
unlock(p_mi);
|
2007-08-08 23:12:02 +02:00
|
|
|
}
|
2007-10-02 13:29:20 +02:00
|
|
|
|
2007-06-24 15:19:21 +02:00
|
|
|
/**************************************************************************
|
2009-03-04 11:38:26 +01:00
|
|
|
* Set the Media descriptor associated with the instance.
|
|
|
|
*
|
|
|
|
* Enter without lock -- function will lock the object.
|
2007-06-24 15:19:21 +02:00
|
|
|
**************************************************************************/
|
2008-03-30 03:59:32 +02:00
|
|
|
void libvlc_media_player_set_media(
|
|
|
|
libvlc_media_player_t *p_mi,
|
2010-01-24 10:09:46 +01:00
|
|
|
libvlc_media_t *p_md )
|
2007-06-24 15:19:21 +02:00
|
|
|
{
|
2010-02-17 23:04:39 +01:00
|
|
|
lock_input(p_mi);
|
2007-08-16 21:04:26 +02:00
|
|
|
|
2015-02-05 21:40:42 +01:00
|
|
|
release_input_thread( p_mi );
|
2009-12-07 20:35:10 +01:00
|
|
|
|
2010-02-17 23:04:39 +01:00
|
|
|
lock( p_mi );
|
2010-02-18 14:44:53 +01:00
|
|
|
set_state( p_mi, libvlc_NothingSpecial, true );
|
2010-02-17 23:04:39 +01:00
|
|
|
unlock_input( p_mi );
|
2008-01-16 11:32:14 +01:00
|
|
|
|
2008-03-30 03:59:32 +02:00
|
|
|
libvlc_media_release( p_mi->p_md );
|
2007-06-17 22:54:32 +02:00
|
|
|
|
2007-06-24 15:19:21 +02:00
|
|
|
if( !p_md )
|
|
|
|
{
|
|
|
|
p_mi->p_md = NULL;
|
2009-09-16 09:28:23 +02:00
|
|
|
unlock(p_mi);
|
2007-06-24 15:19:21 +02:00
|
|
|
return; /* It is ok to pass a NULL md */
|
|
|
|
}
|
|
|
|
|
2008-03-30 03:59:32 +02:00
|
|
|
libvlc_media_retain( p_md );
|
2007-08-25 16:35:40 +02:00
|
|
|
p_mi->p_md = p_md;
|
2008-05-18 13:09:26 +02:00
|
|
|
|
2007-06-24 15:19:21 +02:00
|
|
|
/* The policy here is to ignore that we were created using a different
|
|
|
|
* libvlc_instance, because we don't really care */
|
|
|
|
p_mi->p_libvlc_instance = p_md->p_libvlc_instance;
|
|
|
|
|
2009-09-16 09:28:23 +02:00
|
|
|
unlock(p_mi);
|
2009-12-22 20:49:31 +01:00
|
|
|
|
|
|
|
/* Send an event for the newly available media */
|
|
|
|
libvlc_event_t event;
|
|
|
|
event.type = libvlc_MediaPlayerMediaChanged;
|
|
|
|
event.u.media_player_media_changed.new_media = p_md;
|
|
|
|
libvlc_event_send( p_mi->p_event_manager, &event );
|
2010-01-29 01:16:50 +01:00
|
|
|
|
2007-06-24 15:19:21 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/**************************************************************************
|
2009-03-04 11:38:26 +01:00
|
|
|
* Get the Media descriptor associated with the instance.
|
2007-06-24 15:19:21 +02:00
|
|
|
**************************************************************************/
|
2008-03-30 03:59:32 +02:00
|
|
|
libvlc_media_t *
|
2010-01-24 10:09:46 +01:00
|
|
|
libvlc_media_player_get_media( libvlc_media_player_t *p_mi )
|
2007-06-24 15:19:21 +02:00
|
|
|
{
|
2009-07-12 22:18:23 +02:00
|
|
|
libvlc_media_t *p_m;
|
2007-06-24 15:19:21 +02:00
|
|
|
|
2014-04-06 12:49:30 +02:00
|
|
|
lock( p_mi );
|
2009-07-12 22:18:23 +02:00
|
|
|
p_m = p_mi->p_md;
|
|
|
|
if( p_m )
|
2014-04-06 12:49:30 +02:00
|
|
|
libvlc_media_retain( p_m );
|
|
|
|
unlock( p_mi );
|
|
|
|
|
|
|
|
return p_m;
|
2007-06-17 22:54:32 +02:00
|
|
|
}
|
|
|
|
|
2007-08-08 01:51:17 +02:00
|
|
|
/**************************************************************************
|
2009-03-04 11:38:26 +01:00
|
|
|
* Get the event Manager.
|
2007-08-08 01:51:17 +02:00
|
|
|
**************************************************************************/
|
|
|
|
libvlc_event_manager_t *
|
2010-01-24 10:09:46 +01:00
|
|
|
libvlc_media_player_event_manager( libvlc_media_player_t *p_mi )
|
2007-08-08 01:51:17 +02:00
|
|
|
{
|
|
|
|
return p_mi->p_event_manager;
|
|
|
|
}
|
|
|
|
|
2014-08-04 12:07:25 +02:00
|
|
|
static void add_es_callbacks( input_thread_t *p_input_thread, libvlc_media_player_t *p_mi )
|
|
|
|
{
|
|
|
|
var_AddListCallback( p_input_thread, "video-es", input_es_changed, p_mi );
|
|
|
|
var_AddListCallback( p_input_thread, "audio-es", input_es_changed, p_mi );
|
|
|
|
var_AddListCallback( p_input_thread, "spu-es", input_es_changed, p_mi );
|
|
|
|
var_AddCallback( p_input_thread, "video-es", input_es_selected, p_mi );
|
|
|
|
var_AddCallback( p_input_thread, "audio-es", input_es_selected, p_mi );
|
|
|
|
var_AddCallback( p_input_thread, "spu-es", input_es_selected, p_mi );
|
|
|
|
}
|
|
|
|
|
|
|
|
static void del_es_callbacks( input_thread_t *p_input_thread, libvlc_media_player_t *p_mi )
|
|
|
|
{
|
|
|
|
var_DelListCallback( p_input_thread, "video-es", input_es_changed, p_mi );
|
|
|
|
var_DelListCallback( p_input_thread, "audio-es", input_es_changed, p_mi );
|
|
|
|
var_DelListCallback( p_input_thread, "spu-es", input_es_changed, p_mi );
|
|
|
|
var_DelCallback( p_input_thread, "video-es", input_es_selected, p_mi );
|
|
|
|
var_DelCallback( p_input_thread, "audio-es", input_es_selected, p_mi );
|
|
|
|
var_DelCallback( p_input_thread, "spu-es", input_es_selected, p_mi );
|
|
|
|
}
|
|
|
|
|
2007-06-17 22:54:32 +02:00
|
|
|
/**************************************************************************
|
2009-03-04 11:38:26 +01:00
|
|
|
* Tell media player to start playing.
|
2007-06-17 22:54:32 +02:00
|
|
|
**************************************************************************/
|
2010-01-31 18:30:49 +01:00
|
|
|
int libvlc_media_player_play( libvlc_media_player_t *p_mi )
|
2007-06-17 22:54:32 +02:00
|
|
|
{
|
2010-02-17 23:04:39 +01:00
|
|
|
lock_input( p_mi );
|
2007-06-17 22:54:32 +02:00
|
|
|
|
2010-02-17 23:04:39 +01:00
|
|
|
input_thread_t *p_input_thread = p_mi->input.p_thread;
|
|
|
|
if( p_input_thread )
|
2007-06-17 22:54:32 +02:00
|
|
|
{
|
2008-03-21 22:25:30 +01:00
|
|
|
/* A thread already exists, send it a play message */
|
2007-10-01 00:20:31 +02:00
|
|
|
input_Control( p_input_thread, INPUT_SET_STATE, PLAYING_S );
|
2010-02-17 23:04:39 +01:00
|
|
|
unlock_input( p_mi );
|
2010-01-31 18:30:49 +01:00
|
|
|
return 0;
|
2007-06-17 22:54:32 +02:00
|
|
|
}
|
|
|
|
|
2007-08-11 14:10:25 +02:00
|
|
|
/* Ignore previous exception */
|
2009-09-16 09:28:23 +02:00
|
|
|
lock(p_mi);
|
2008-05-18 13:09:26 +02:00
|
|
|
|
2007-06-24 15:19:21 +02:00
|
|
|
if( !p_mi->p_md )
|
|
|
|
{
|
2009-09-16 09:28:23 +02:00
|
|
|
unlock(p_mi);
|
2010-02-28 16:47:07 +01:00
|
|
|
unlock_input( p_mi );
|
2009-09-07 21:13:49 +02:00
|
|
|
libvlc_printerr( "No associated media descriptor" );
|
2010-01-31 18:30:49 +01:00
|
|
|
return -1;
|
2007-06-24 15:19:21 +02:00
|
|
|
}
|
|
|
|
|
2010-02-17 23:04:39 +01:00
|
|
|
p_input_thread = input_Create( p_mi, p_mi->p_md->p_input_item, NULL,
|
|
|
|
p_mi->input.p_resource );
|
|
|
|
unlock(p_mi);
|
|
|
|
if( !p_input_thread )
|
2008-01-13 23:41:45 +01:00
|
|
|
{
|
2010-02-17 23:04:39 +01:00
|
|
|
unlock_input(p_mi);
|
2010-01-31 18:30:49 +01:00
|
|
|
libvlc_printerr( "Not enough memory" );
|
|
|
|
return -1;
|
2008-01-13 23:41:45 +01:00
|
|
|
}
|
2007-06-23 13:40:40 +02:00
|
|
|
|
2008-11-23 15:29:49 +01:00
|
|
|
var_AddCallback( p_input_thread, "can-seek", input_seekable_changed, p_mi );
|
|
|
|
var_AddCallback( p_input_thread, "can-pause", input_pausable_changed, p_mi );
|
2014-02-06 22:03:24 +01:00
|
|
|
var_AddCallback( p_input_thread, "program-scrambled", input_scrambled_changed, p_mi );
|
2008-11-23 15:21:12 +01:00
|
|
|
var_AddCallback( p_input_thread, "intf-event", input_event_changed, p_mi );
|
2014-08-04 12:07:25 +02:00
|
|
|
add_es_callbacks( p_input_thread, p_mi );
|
2007-08-08 03:13:31 +02:00
|
|
|
|
2009-05-08 02:03:05 +02:00
|
|
|
if( input_Start( p_input_thread ) )
|
|
|
|
{
|
2010-02-17 23:04:39 +01:00
|
|
|
unlock_input(p_mi);
|
2014-08-04 12:07:25 +02:00
|
|
|
del_es_callbacks( p_input_thread, p_mi );
|
2010-02-17 23:04:39 +01:00
|
|
|
var_DelCallback( p_input_thread, "intf-event", input_event_changed, p_mi );
|
|
|
|
var_DelCallback( p_input_thread, "can-pause", input_pausable_changed, p_mi );
|
2014-02-06 22:03:24 +01:00
|
|
|
var_DelCallback( p_input_thread, "program-scrambled", input_scrambled_changed, p_mi );
|
2010-02-17 23:04:39 +01:00
|
|
|
var_DelCallback( p_input_thread, "can-seek", input_seekable_changed, p_mi );
|
2015-05-21 18:36:02 +02:00
|
|
|
input_Close( p_input_thread );
|
2010-02-17 23:04:39 +01:00
|
|
|
libvlc_printerr( "Input initialization failure" );
|
|
|
|
return -1;
|
2009-05-08 02:03:05 +02:00
|
|
|
}
|
2010-02-17 23:04:39 +01:00
|
|
|
p_mi->input.p_thread = p_input_thread;
|
|
|
|
unlock_input(p_mi);
|
2010-01-31 18:30:49 +01:00
|
|
|
return 0;
|
2007-06-17 22:54:32 +02:00
|
|
|
}
|
|
|
|
|
2010-06-27 15:52:58 +02:00
|
|
|
void libvlc_media_player_set_pause( libvlc_media_player_t *p_mi, int paused )
|
2007-06-17 22:54:32 +02:00
|
|
|
{
|
2010-01-31 18:52:07 +01:00
|
|
|
input_thread_t * p_input_thread = libvlc_get_input_thread( p_mi );
|
2007-06-25 20:06:52 +02:00
|
|
|
if( !p_input_thread )
|
2007-06-17 22:54:32 +02:00
|
|
|
return;
|
|
|
|
|
2010-01-24 10:09:46 +01:00
|
|
|
libvlc_state_t state = libvlc_media_player_get_state( p_mi );
|
2009-05-05 11:36:55 +02:00
|
|
|
if( state == libvlc_Playing || state == libvlc_Buffering )
|
2008-01-07 19:09:45 +01:00
|
|
|
{
|
2010-06-27 15:52:58 +02:00
|
|
|
if( paused )
|
|
|
|
{
|
|
|
|
if( libvlc_media_player_can_pause( p_mi ) )
|
|
|
|
input_Control( p_input_thread, INPUT_SET_STATE, PAUSE_S );
|
|
|
|
else
|
2015-02-05 21:40:42 +01:00
|
|
|
input_Stop( p_input_thread );
|
2010-06-27 15:52:58 +02:00
|
|
|
}
|
2008-01-07 19:09:45 +01:00
|
|
|
}
|
2008-01-07 16:49:39 +01:00
|
|
|
else
|
2010-06-27 15:52:58 +02:00
|
|
|
{
|
|
|
|
if( !paused )
|
|
|
|
input_Control( p_input_thread, INPUT_SET_STATE, PLAYING_S );
|
|
|
|
}
|
2008-01-07 19:09:45 +01:00
|
|
|
|
2007-06-23 13:40:40 +02:00
|
|
|
vlc_object_release( p_input_thread );
|
2007-06-17 22:54:32 +02:00
|
|
|
}
|
2006-06-05 20:23:56 +02:00
|
|
|
|
2010-06-27 15:52:58 +02:00
|
|
|
/**************************************************************************
|
|
|
|
* Toggle pause.
|
|
|
|
**************************************************************************/
|
|
|
|
void libvlc_media_player_pause( libvlc_media_player_t *p_mi )
|
|
|
|
{
|
|
|
|
libvlc_state_t state = libvlc_media_player_get_state( p_mi );
|
|
|
|
bool playing = (state == libvlc_Playing || state == libvlc_Buffering);
|
|
|
|
|
|
|
|
libvlc_media_player_set_pause( p_mi, playing );
|
|
|
|
}
|
|
|
|
|
2009-01-06 22:48:03 +01:00
|
|
|
/**************************************************************************
|
2009-03-04 11:38:26 +01:00
|
|
|
* Tells whether the media player is currently playing.
|
|
|
|
*
|
|
|
|
* Enter with lock held.
|
2009-01-06 22:48:03 +01:00
|
|
|
**************************************************************************/
|
2010-01-24 10:09:46 +01:00
|
|
|
int libvlc_media_player_is_playing( libvlc_media_player_t *p_mi )
|
2009-01-06 22:48:03 +01:00
|
|
|
{
|
2010-01-24 10:09:46 +01:00
|
|
|
libvlc_state_t state = libvlc_media_player_get_state( p_mi );
|
2009-05-05 11:36:55 +02:00
|
|
|
return (libvlc_Playing == state) || (libvlc_Buffering == state);
|
2009-01-06 22:48:03 +01:00
|
|
|
}
|
|
|
|
|
2007-08-08 23:12:02 +02:00
|
|
|
/**************************************************************************
|
2009-03-04 11:38:26 +01:00
|
|
|
* Stop playing.
|
2007-08-08 23:12:02 +02:00
|
|
|
**************************************************************************/
|
2010-01-24 10:09:46 +01:00
|
|
|
void libvlc_media_player_stop( libvlc_media_player_t *p_mi )
|
2007-08-08 23:12:02 +02:00
|
|
|
{
|
2010-02-17 23:04:39 +01:00
|
|
|
lock_input(p_mi);
|
2015-02-05 21:40:42 +01:00
|
|
|
release_input_thread( p_mi ); /* This will stop the input thread */
|
2009-12-07 20:35:10 +01:00
|
|
|
|
|
|
|
/* Force to go to stopped state, in case we were in Ended, or Error
|
|
|
|
* state. */
|
2015-02-08 15:34:45 +01:00
|
|
|
if( p_mi->state != libvlc_Stopped )
|
2008-05-30 05:12:38 +02:00
|
|
|
{
|
2010-01-18 09:06:16 +01:00
|
|
|
set_state( p_mi, libvlc_Stopped, false );
|
2008-05-30 05:12:38 +02:00
|
|
|
|
|
|
|
/* Construct and send the event */
|
|
|
|
libvlc_event_t event;
|
2008-12-21 16:39:26 +01:00
|
|
|
event.type = libvlc_MediaPlayerStopped;
|
2008-05-30 05:12:38 +02:00
|
|
|
libvlc_event_send( p_mi->p_event_manager, &event );
|
|
|
|
}
|
2010-06-08 20:05:44 +02:00
|
|
|
|
2012-10-31 21:59:14 +01:00
|
|
|
input_resource_Terminate( p_mi->input.p_resource );
|
2010-02-17 23:04:39 +01:00
|
|
|
unlock_input(p_mi);
|
2007-08-09 14:45:37 +02:00
|
|
|
}
|
|
|
|
|
2010-07-10 17:09:05 +02:00
|
|
|
|
|
|
|
void libvlc_video_set_callbacks( libvlc_media_player_t *mp,
|
|
|
|
void *(*lock_cb) (void *, void **),
|
|
|
|
void (*unlock_cb) (void *, void *, void *const *),
|
|
|
|
void (*display_cb) (void *, void *),
|
|
|
|
void *opaque )
|
|
|
|
{
|
|
|
|
var_SetAddress( mp, "vmem-lock", lock_cb );
|
|
|
|
var_SetAddress( mp, "vmem-unlock", unlock_cb );
|
|
|
|
var_SetAddress( mp, "vmem-display", display_cb );
|
|
|
|
var_SetAddress( mp, "vmem-data", opaque );
|
2014-10-11 13:37:52 +02:00
|
|
|
var_SetString( mp, "avcodec-hw", "none" );
|
2015-04-15 17:41:20 +02:00
|
|
|
var_SetString( mp, "vout", "vmem" );
|
|
|
|
var_SetString( mp, "window", "none" );
|
2010-07-10 17:09:05 +02:00
|
|
|
}
|
|
|
|
|
2010-11-21 14:54:13 +01:00
|
|
|
void libvlc_video_set_format_callbacks( libvlc_media_player_t *mp,
|
|
|
|
libvlc_video_format_cb setup,
|
|
|
|
libvlc_video_cleanup_cb cleanup )
|
|
|
|
{
|
|
|
|
var_SetAddress( mp, "vmem-setup", setup );
|
|
|
|
var_SetAddress( mp, "vmem-cleanup", cleanup );
|
|
|
|
}
|
|
|
|
|
2010-07-10 17:09:05 +02:00
|
|
|
void libvlc_video_set_format( libvlc_media_player_t *mp, const char *chroma,
|
|
|
|
unsigned width, unsigned height, unsigned pitch )
|
|
|
|
{
|
|
|
|
var_SetString( mp, "vmem-chroma", chroma );
|
|
|
|
var_SetInteger( mp, "vmem-width", width );
|
|
|
|
var_SetInteger( mp, "vmem-height", height );
|
|
|
|
var_SetInteger( mp, "vmem-pitch", pitch );
|
|
|
|
}
|
|
|
|
|
2009-04-11 19:29:35 +02:00
|
|
|
/**************************************************************************
|
|
|
|
* set_nsobject
|
|
|
|
**************************************************************************/
|
|
|
|
void libvlc_media_player_set_nsobject( libvlc_media_player_t *p_mi,
|
2010-01-24 10:09:46 +01:00
|
|
|
void * drawable )
|
2009-04-11 19:29:35 +02:00
|
|
|
{
|
2010-01-31 17:56:56 +01:00
|
|
|
assert (p_mi != NULL);
|
|
|
|
#ifdef __APPLE__
|
2015-04-15 17:41:20 +02:00
|
|
|
var_SetString (p_mi, "avcodec-hw", "");
|
|
|
|
var_SetString (p_mi, "vout", "");
|
|
|
|
var_SetString (p_mi, "window", "");
|
2010-01-31 17:56:56 +01:00
|
|
|
var_SetAddress (p_mi, "drawable-nsobject", drawable);
|
|
|
|
#else
|
2015-10-15 14:05:38 +02:00
|
|
|
(void)drawable;
|
|
|
|
libvlc_printerr ("can't set nsobject: APPLE build required");
|
|
|
|
assert(false);
|
|
|
|
var_SetString (p_mi, "vout", "none");
|
|
|
|
var_SetString (p_mi, "window", "none");
|
2010-01-31 17:56:56 +01:00
|
|
|
#endif
|
2009-04-11 19:29:35 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
/**************************************************************************
|
2009-05-01 16:31:37 +02:00
|
|
|
* get_nsobject
|
2009-04-11 19:29:35 +02:00
|
|
|
**************************************************************************/
|
2009-05-25 12:04:23 +02:00
|
|
|
void * libvlc_media_player_get_nsobject( libvlc_media_player_t *p_mi )
|
2009-04-11 19:29:35 +02:00
|
|
|
{
|
2010-01-31 17:56:56 +01:00
|
|
|
assert (p_mi != NULL);
|
|
|
|
#ifdef __APPLE__
|
|
|
|
return var_GetAddress (p_mi, "drawable-nsobject");
|
|
|
|
#else
|
2015-10-15 14:02:55 +02:00
|
|
|
(void) p_mi;
|
2010-01-31 17:56:56 +01:00
|
|
|
return NULL;
|
|
|
|
#endif
|
2009-04-11 19:29:35 +02:00
|
|
|
}
|
|
|
|
|
2009-03-02 21:32:13 +01:00
|
|
|
/**************************************************************************
|
|
|
|
* set_agl
|
|
|
|
**************************************************************************/
|
|
|
|
void libvlc_media_player_set_agl( libvlc_media_player_t *p_mi,
|
2010-01-24 10:09:46 +01:00
|
|
|
uint32_t drawable )
|
2009-03-02 21:32:13 +01:00
|
|
|
{
|
2015-10-15 14:05:38 +02:00
|
|
|
(void)drawable;
|
|
|
|
libvlc_printerr ("can't set agl: use libvlc_media_player_set_nsobject instead");
|
|
|
|
assert(false);
|
|
|
|
var_SetString (p_mi, "vout", "none");
|
|
|
|
var_SetString (p_mi, "window", "none");
|
2009-03-02 21:32:13 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
/**************************************************************************
|
|
|
|
* get_agl
|
|
|
|
**************************************************************************/
|
|
|
|
uint32_t libvlc_media_player_get_agl( libvlc_media_player_t *p_mi )
|
|
|
|
{
|
2015-07-25 16:10:53 +02:00
|
|
|
(void) p_mi;
|
2010-01-31 17:56:56 +01:00
|
|
|
return 0;
|
2009-03-02 21:32:13 +01:00
|
|
|
}
|
|
|
|
|
2009-03-04 11:38:26 +01:00
|
|
|
/**************************************************************************
|
|
|
|
* set_xwindow
|
|
|
|
**************************************************************************/
|
2009-02-09 17:28:20 +01:00
|
|
|
void libvlc_media_player_set_xwindow( libvlc_media_player_t *p_mi,
|
2010-01-24 10:09:46 +01:00
|
|
|
uint32_t drawable )
|
2009-02-07 18:21:01 +01:00
|
|
|
{
|
2010-01-31 17:56:56 +01:00
|
|
|
assert (p_mi != NULL);
|
2010-07-08 19:24:32 +02:00
|
|
|
|
2014-10-11 13:37:52 +02:00
|
|
|
var_SetString (p_mi, "avcodec-hw", "");
|
2015-04-15 17:41:20 +02:00
|
|
|
var_SetString (p_mi, "vout", drawable ? "xid" : "");
|
|
|
|
var_SetString (p_mi, "window", drawable ? "embed-xid,any" : "");
|
2010-01-31 17:56:56 +01:00
|
|
|
var_SetInteger (p_mi, "drawable-xid", drawable);
|
2009-02-07 18:21:01 +01:00
|
|
|
}
|
|
|
|
|
2009-03-04 11:38:26 +01:00
|
|
|
/**************************************************************************
|
|
|
|
* get_xwindow
|
|
|
|
**************************************************************************/
|
2009-02-12 21:22:34 +01:00
|
|
|
uint32_t libvlc_media_player_get_xwindow( libvlc_media_player_t *p_mi )
|
|
|
|
{
|
2010-01-31 17:56:56 +01:00
|
|
|
return var_GetInteger (p_mi, "drawable-xid");
|
2009-02-12 21:22:34 +01:00
|
|
|
}
|
|
|
|
|
2009-03-04 11:38:26 +01:00
|
|
|
/**************************************************************************
|
|
|
|
* set_hwnd
|
|
|
|
**************************************************************************/
|
2009-02-07 18:21:01 +01:00
|
|
|
void libvlc_media_player_set_hwnd( libvlc_media_player_t *p_mi,
|
2010-01-24 10:09:46 +01:00
|
|
|
void *drawable )
|
2009-02-07 18:21:01 +01:00
|
|
|
{
|
2010-01-31 17:56:56 +01:00
|
|
|
assert (p_mi != NULL);
|
2013-06-05 15:41:18 +02:00
|
|
|
#if defined (_WIN32) || defined (__OS2__)
|
2015-04-15 17:41:20 +02:00
|
|
|
var_SetString (p_mi, "avcodec-hw", "");
|
|
|
|
var_SetString (p_mi, "vout", "");
|
2010-07-08 19:19:49 +02:00
|
|
|
var_SetString (p_mi, "window",
|
|
|
|
(drawable != NULL) ? "embed-hwnd,any" : "");
|
2011-04-11 17:21:34 +02:00
|
|
|
var_SetInteger (p_mi, "drawable-hwnd", (uintptr_t)drawable);
|
2010-01-31 17:56:56 +01:00
|
|
|
#else
|
2015-10-15 14:05:38 +02:00
|
|
|
(void) drawable;
|
|
|
|
libvlc_printerr ("can't set nsobject: WIN32 build required");
|
|
|
|
assert(false);
|
|
|
|
var_SetString (p_mi, "vout", "none");
|
|
|
|
var_SetString (p_mi, "window", "none");
|
2010-01-31 17:56:56 +01:00
|
|
|
#endif
|
2009-02-07 18:21:01 +01:00
|
|
|
}
|
|
|
|
|
2009-03-04 11:38:26 +01:00
|
|
|
/**************************************************************************
|
|
|
|
* get_hwnd
|
|
|
|
**************************************************************************/
|
2009-02-12 21:22:34 +01:00
|
|
|
void *libvlc_media_player_get_hwnd( libvlc_media_player_t *p_mi )
|
|
|
|
{
|
2010-01-31 17:56:56 +01:00
|
|
|
assert (p_mi != NULL);
|
2013-06-05 15:41:18 +02:00
|
|
|
#if defined (_WIN32) || defined (__OS2__)
|
2011-04-11 17:21:34 +02:00
|
|
|
return (void *)(uintptr_t)var_GetInteger (p_mi, "drawable-hwnd");
|
2010-01-31 17:56:56 +01:00
|
|
|
#else
|
2015-10-15 14:02:55 +02:00
|
|
|
(void) p_mi;
|
2010-01-31 17:56:56 +01:00
|
|
|
return NULL;
|
|
|
|
#endif
|
2009-02-12 21:22:34 +01:00
|
|
|
}
|
|
|
|
|
2015-06-25 13:52:59 +02:00
|
|
|
/**************************************************************************
|
|
|
|
* set_android_context
|
|
|
|
**************************************************************************/
|
|
|
|
void libvlc_media_player_set_android_context( libvlc_media_player_t *p_mi,
|
|
|
|
void *p_jvm,
|
|
|
|
void *p_awindow_handler )
|
|
|
|
{
|
|
|
|
assert (p_mi != NULL);
|
|
|
|
#ifdef __ANDROID__
|
|
|
|
var_SetAddress (p_mi, "android-jvm", p_jvm);
|
|
|
|
var_SetAddress (p_mi, "drawable-androidwindow", p_awindow_handler);
|
|
|
|
#else
|
2015-10-15 14:05:38 +02:00
|
|
|
(void) p_jvm; (void) p_awindow_handler;
|
|
|
|
libvlc_printerr ("can't set android context: ANDROID build required");
|
|
|
|
assert(false);
|
|
|
|
var_SetString (p_mi, "vout", "none");
|
|
|
|
var_SetString (p_mi, "window", "none");
|
2015-06-25 13:52:59 +02:00
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
2015-10-23 18:46:02 +02:00
|
|
|
/**************************************************************************
|
|
|
|
* set_evas_object
|
|
|
|
**************************************************************************/
|
|
|
|
int libvlc_media_player_set_evas_object( libvlc_media_player_t *p_mi,
|
|
|
|
void *p_evas_object )
|
|
|
|
{
|
|
|
|
assert (p_mi != NULL);
|
|
|
|
#ifdef HAVE_EVAS
|
|
|
|
var_SetString (p_mi, "vout", "evas");
|
|
|
|
var_SetString (p_mi, "window", "none");
|
|
|
|
var_SetAddress (p_mi, "drawable-evasobject", p_evas_object);
|
|
|
|
return 0;
|
|
|
|
#else
|
|
|
|
(void) p_mi; (void) p_evas_object;
|
|
|
|
return -1;
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
2011-05-10 19:56:21 +02:00
|
|
|
void libvlc_audio_set_callbacks( libvlc_media_player_t *mp,
|
|
|
|
libvlc_audio_play_cb play_cb,
|
2011-08-04 15:42:31 +02:00
|
|
|
libvlc_audio_pause_cb pause_cb,
|
|
|
|
libvlc_audio_resume_cb resume_cb,
|
|
|
|
libvlc_audio_flush_cb flush_cb,
|
|
|
|
libvlc_audio_drain_cb drain_cb,
|
2011-05-10 19:56:21 +02:00
|
|
|
void *opaque )
|
|
|
|
{
|
|
|
|
var_SetAddress( mp, "amem-play", play_cb );
|
2011-08-04 15:42:31 +02:00
|
|
|
var_SetAddress( mp, "amem-pause", pause_cb );
|
|
|
|
var_SetAddress( mp, "amem-resume", resume_cb );
|
|
|
|
var_SetAddress( mp, "amem-flush", flush_cb );
|
|
|
|
var_SetAddress( mp, "amem-drain", drain_cb );
|
2011-05-10 19:56:21 +02:00
|
|
|
var_SetAddress( mp, "amem-data", opaque );
|
2011-08-04 18:41:07 +02:00
|
|
|
var_SetString( mp, "aout", "amem,none" );
|
2014-03-10 18:18:43 +01:00
|
|
|
|
|
|
|
input_resource_ResetAout(mp->input.p_resource);
|
2011-05-10 19:56:21 +02:00
|
|
|
}
|
|
|
|
|
2011-08-04 15:42:31 +02:00
|
|
|
void libvlc_audio_set_volume_callback( libvlc_media_player_t *mp,
|
|
|
|
libvlc_audio_set_volume_cb cb )
|
|
|
|
{
|
|
|
|
var_SetAddress( mp, "amem-set-volume", cb );
|
2014-03-10 18:18:43 +01:00
|
|
|
|
|
|
|
input_resource_ResetAout(mp->input.p_resource);
|
2011-08-04 15:42:31 +02:00
|
|
|
}
|
|
|
|
|
2011-05-10 19:56:21 +02:00
|
|
|
void libvlc_audio_set_format_callbacks( libvlc_media_player_t *mp,
|
|
|
|
libvlc_audio_setup_cb setup,
|
|
|
|
libvlc_audio_cleanup_cb cleanup )
|
|
|
|
{
|
|
|
|
var_SetAddress( mp, "amem-setup", setup );
|
|
|
|
var_SetAddress( mp, "amem-cleanup", cleanup );
|
2014-03-10 18:18:43 +01:00
|
|
|
|
|
|
|
input_resource_ResetAout(mp->input.p_resource);
|
2011-05-10 19:56:21 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
void libvlc_audio_set_format( libvlc_media_player_t *mp, const char *format,
|
|
|
|
unsigned rate, unsigned channels )
|
|
|
|
{
|
|
|
|
var_SetString( mp, "amem-format", format );
|
|
|
|
var_SetInteger( mp, "amem-rate", rate );
|
|
|
|
var_SetInteger( mp, "amem-channels", channels );
|
2014-03-10 18:18:43 +01:00
|
|
|
|
|
|
|
input_resource_ResetAout(mp->input.p_resource);
|
2011-05-10 19:56:21 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2006-06-05 20:23:56 +02:00
|
|
|
/**************************************************************************
|
|
|
|
* Getters for stream information
|
|
|
|
**************************************************************************/
|
2008-03-30 03:59:32 +02:00
|
|
|
libvlc_time_t libvlc_media_player_get_length(
|
2010-01-31 18:30:49 +01:00
|
|
|
libvlc_media_player_t *p_mi )
|
2006-06-05 20:23:56 +02:00
|
|
|
{
|
|
|
|
input_thread_t *p_input_thread;
|
2009-07-24 09:30:09 +02:00
|
|
|
libvlc_time_t i_time;
|
2006-06-05 20:23:56 +02:00
|
|
|
|
2010-01-31 18:52:07 +01:00
|
|
|
p_input_thread = libvlc_get_input_thread ( p_mi );
|
2007-03-27 21:01:51 +02:00
|
|
|
if( !p_input_thread )
|
2006-10-29 10:35:43 +01:00
|
|
|
return -1;
|
|
|
|
|
2015-05-22 20:52:42 +02:00
|
|
|
i_time = from_mtime(var_GetInteger( p_input_thread, "length" ));
|
2006-01-08 17:32:33 +01:00
|
|
|
vlc_object_release( p_input_thread );
|
|
|
|
|
2010-01-16 16:11:08 +01:00
|
|
|
return i_time;
|
2006-01-08 17:32:33 +01:00
|
|
|
}
|
|
|
|
|
2010-01-31 18:30:49 +01:00
|
|
|
libvlc_time_t libvlc_media_player_get_time( libvlc_media_player_t *p_mi )
|
2006-01-08 17:32:33 +01:00
|
|
|
{
|
|
|
|
input_thread_t *p_input_thread;
|
2009-07-24 09:30:09 +02:00
|
|
|
libvlc_time_t i_time;
|
2006-01-08 17:32:33 +01:00
|
|
|
|
2010-01-31 18:52:07 +01:00
|
|
|
p_input_thread = libvlc_get_input_thread ( p_mi );
|
2007-03-27 21:01:51 +02:00
|
|
|
if( !p_input_thread )
|
2006-10-29 10:35:43 +01:00
|
|
|
return -1;
|
2006-06-05 20:23:56 +02:00
|
|
|
|
2015-05-22 20:52:42 +02:00
|
|
|
i_time = from_mtime(var_GetInteger( p_input_thread , "time" ));
|
2006-01-08 17:32:33 +01:00
|
|
|
vlc_object_release( p_input_thread );
|
2010-01-16 16:11:08 +01:00
|
|
|
return i_time;
|
2006-01-08 17:32:33 +01:00
|
|
|
}
|
|
|
|
|
2010-01-31 18:30:49 +01:00
|
|
|
void libvlc_media_player_set_time( libvlc_media_player_t *p_mi,
|
|
|
|
libvlc_time_t i_time )
|
2006-07-31 11:31:35 +02:00
|
|
|
{
|
|
|
|
input_thread_t *p_input_thread;
|
|
|
|
|
2010-01-31 18:52:07 +01:00
|
|
|
p_input_thread = libvlc_get_input_thread ( p_mi );
|
2007-03-27 21:01:51 +02:00
|
|
|
if( !p_input_thread )
|
2006-10-29 10:35:43 +01:00
|
|
|
return;
|
|
|
|
|
2015-05-22 20:52:42 +02:00
|
|
|
var_SetInteger( p_input_thread, "time", to_mtime(i_time) );
|
2006-07-31 11:31:35 +02:00
|
|
|
vlc_object_release( p_input_thread );
|
|
|
|
}
|
|
|
|
|
2010-01-31 18:30:49 +01:00
|
|
|
void libvlc_media_player_set_position( libvlc_media_player_t *p_mi,
|
|
|
|
float position )
|
2006-07-31 11:31:35 +02:00
|
|
|
{
|
|
|
|
input_thread_t *p_input_thread;
|
2006-10-29 10:35:43 +01:00
|
|
|
|
2010-01-31 18:52:07 +01:00
|
|
|
p_input_thread = libvlc_get_input_thread ( p_mi );
|
2007-03-27 21:01:51 +02:00
|
|
|
if( !p_input_thread )
|
2006-10-29 10:35:43 +01:00
|
|
|
return;
|
2006-07-31 11:31:35 +02:00
|
|
|
|
2009-04-01 22:46:30 +02:00
|
|
|
var_SetFloat( p_input_thread, "position", position );
|
2006-07-31 11:31:35 +02:00
|
|
|
vlc_object_release( p_input_thread );
|
|
|
|
}
|
|
|
|
|
2010-01-31 18:30:49 +01:00
|
|
|
float libvlc_media_player_get_position( libvlc_media_player_t *p_mi )
|
2006-01-08 17:32:33 +01:00
|
|
|
{
|
|
|
|
input_thread_t *p_input_thread;
|
2009-08-17 15:21:44 +02:00
|
|
|
float f_position;
|
2006-01-08 17:32:33 +01:00
|
|
|
|
2010-01-31 18:52:07 +01:00
|
|
|
p_input_thread = libvlc_get_input_thread ( p_mi );
|
2007-03-27 21:01:51 +02:00
|
|
|
if( !p_input_thread )
|
2006-10-29 10:35:43 +01:00
|
|
|
return -1.0;
|
2006-06-05 20:23:56 +02:00
|
|
|
|
2009-08-17 15:21:44 +02:00
|
|
|
f_position = var_GetFloat( p_input_thread, "position" );
|
2006-01-08 17:32:33 +01:00
|
|
|
vlc_object_release( p_input_thread );
|
|
|
|
|
2009-08-17 15:21:44 +02:00
|
|
|
return f_position;
|
2006-01-08 17:32:33 +01:00
|
|
|
}
|
2006-06-02 13:27:30 +02:00
|
|
|
|
2010-01-31 18:30:49 +01:00
|
|
|
void libvlc_media_player_set_chapter( libvlc_media_player_t *p_mi,
|
|
|
|
int chapter )
|
2007-10-25 14:28:04 +02:00
|
|
|
{
|
|
|
|
input_thread_t *p_input_thread;
|
|
|
|
|
2010-01-31 18:52:07 +01:00
|
|
|
p_input_thread = libvlc_get_input_thread ( p_mi );
|
2007-10-25 14:28:04 +02:00
|
|
|
if( !p_input_thread )
|
|
|
|
return;
|
|
|
|
|
2009-04-01 22:46:30 +02:00
|
|
|
var_SetInteger( p_input_thread, "chapter", chapter );
|
2007-10-25 14:28:04 +02:00
|
|
|
vlc_object_release( p_input_thread );
|
|
|
|
}
|
|
|
|
|
2010-01-31 18:30:49 +01:00
|
|
|
int libvlc_media_player_get_chapter( libvlc_media_player_t *p_mi )
|
2007-10-25 14:28:04 +02:00
|
|
|
{
|
|
|
|
input_thread_t *p_input_thread;
|
2009-08-17 15:21:44 +02:00
|
|
|
int i_chapter;
|
2007-10-25 14:28:04 +02:00
|
|
|
|
2010-01-31 18:52:07 +01:00
|
|
|
p_input_thread = libvlc_get_input_thread ( p_mi );
|
2007-10-25 14:28:04 +02:00
|
|
|
if( !p_input_thread )
|
2008-10-04 22:00:52 +02:00
|
|
|
return -1;
|
2007-10-25 14:28:04 +02:00
|
|
|
|
2009-08-17 15:21:44 +02:00
|
|
|
i_chapter = var_GetInteger( p_input_thread, "chapter" );
|
2007-10-25 14:28:04 +02:00
|
|
|
vlc_object_release( p_input_thread );
|
|
|
|
|
2009-08-17 15:21:44 +02:00
|
|
|
return i_chapter;
|
2007-10-25 14:28:04 +02:00
|
|
|
}
|
|
|
|
|
2010-01-31 18:30:49 +01:00
|
|
|
int libvlc_media_player_get_chapter_count( libvlc_media_player_t *p_mi )
|
2007-10-25 14:28:04 +02:00
|
|
|
{
|
|
|
|
input_thread_t *p_input_thread;
|
|
|
|
vlc_value_t val;
|
|
|
|
|
2010-01-31 18:52:07 +01:00
|
|
|
p_input_thread = libvlc_get_input_thread ( p_mi );
|
2007-10-25 14:28:04 +02:00
|
|
|
if( !p_input_thread )
|
2008-10-04 22:00:52 +02:00
|
|
|
return -1;
|
2007-10-25 14:28:04 +02:00
|
|
|
|
2014-07-07 12:41:32 +02:00
|
|
|
int i_ret = var_Change( p_input_thread, "chapter", VLC_VAR_CHOICESCOUNT, &val, NULL );
|
2007-10-25 14:28:04 +02:00
|
|
|
vlc_object_release( p_input_thread );
|
|
|
|
|
2014-07-07 12:41:32 +02:00
|
|
|
return i_ret == VLC_SUCCESS ? val.i_int : -1;
|
2007-10-25 14:28:04 +02:00
|
|
|
}
|
|
|
|
|
2008-10-04 22:00:52 +02:00
|
|
|
int libvlc_media_player_get_chapter_count_for_title(
|
|
|
|
libvlc_media_player_t *p_mi,
|
2010-01-31 18:30:49 +01:00
|
|
|
int i_title )
|
2008-10-04 22:00:52 +02:00
|
|
|
{
|
|
|
|
vlc_value_t val;
|
|
|
|
|
2015-05-23 18:08:27 +02:00
|
|
|
input_thread_t *p_input_thread = libvlc_get_input_thread ( p_mi );
|
2008-10-04 22:00:52 +02:00
|
|
|
if( !p_input_thread )
|
|
|
|
return -1;
|
|
|
|
|
2015-05-23 18:08:27 +02:00
|
|
|
char psz_name[sizeof ("title ") + 3 * sizeof (int)];
|
|
|
|
sprintf( psz_name, "title %2u", i_title );
|
|
|
|
|
2014-07-07 12:41:32 +02:00
|
|
|
int i_ret = var_Change( p_input_thread, psz_name, VLC_VAR_CHOICESCOUNT, &val, NULL );
|
2008-10-04 22:00:52 +02:00
|
|
|
vlc_object_release( p_input_thread );
|
|
|
|
|
2014-07-07 12:41:32 +02:00
|
|
|
return i_ret == VLC_SUCCESS ? val.i_int : -1;
|
2008-10-04 22:00:52 +02:00
|
|
|
}
|
|
|
|
|
2010-01-31 18:30:49 +01:00
|
|
|
void libvlc_media_player_set_title( libvlc_media_player_t *p_mi,
|
|
|
|
int i_title )
|
2008-10-04 22:00:52 +02:00
|
|
|
{
|
|
|
|
input_thread_t *p_input_thread;
|
|
|
|
|
2010-01-31 18:52:07 +01:00
|
|
|
p_input_thread = libvlc_get_input_thread ( p_mi );
|
2008-10-04 22:00:52 +02:00
|
|
|
if( !p_input_thread )
|
|
|
|
return;
|
|
|
|
|
2009-04-01 22:46:30 +02:00
|
|
|
var_SetInteger( p_input_thread, "title", i_title );
|
2008-10-04 22:00:52 +02:00
|
|
|
vlc_object_release( p_input_thread );
|
|
|
|
|
|
|
|
//send event
|
|
|
|
libvlc_event_t event;
|
|
|
|
event.type = libvlc_MediaPlayerTitleChanged;
|
|
|
|
event.u.media_player_title_changed.new_title = i_title;
|
|
|
|
libvlc_event_send( p_mi->p_event_manager, &event );
|
|
|
|
}
|
|
|
|
|
2010-01-31 18:30:49 +01:00
|
|
|
int libvlc_media_player_get_title( libvlc_media_player_t *p_mi )
|
2008-10-04 22:00:52 +02:00
|
|
|
{
|
|
|
|
input_thread_t *p_input_thread;
|
2009-08-17 15:21:44 +02:00
|
|
|
int i_title;
|
2008-10-04 22:00:52 +02:00
|
|
|
|
2010-01-31 18:52:07 +01:00
|
|
|
p_input_thread = libvlc_get_input_thread ( p_mi );
|
2008-10-04 22:00:52 +02:00
|
|
|
if( !p_input_thread )
|
|
|
|
return -1;
|
|
|
|
|
2009-08-17 15:21:44 +02:00
|
|
|
i_title = var_GetInteger( p_input_thread, "title" );
|
2008-10-04 22:00:52 +02:00
|
|
|
vlc_object_release( p_input_thread );
|
|
|
|
|
2009-08-17 15:21:44 +02:00
|
|
|
return i_title;
|
2008-10-04 22:00:52 +02:00
|
|
|
}
|
|
|
|
|
2010-01-31 18:30:49 +01:00
|
|
|
int libvlc_media_player_get_title_count( libvlc_media_player_t *p_mi )
|
2008-10-04 22:00:52 +02:00
|
|
|
{
|
|
|
|
input_thread_t *p_input_thread;
|
|
|
|
vlc_value_t val;
|
|
|
|
|
2010-01-31 18:52:07 +01:00
|
|
|
p_input_thread = libvlc_get_input_thread ( p_mi );
|
2008-10-04 22:00:52 +02:00
|
|
|
if( !p_input_thread )
|
|
|
|
return -1;
|
|
|
|
|
2014-07-07 12:41:32 +02:00
|
|
|
int i_ret = var_Change( p_input_thread, "title", VLC_VAR_CHOICESCOUNT, &val, NULL );
|
2008-10-04 22:00:52 +02:00
|
|
|
vlc_object_release( p_input_thread );
|
|
|
|
|
2014-07-07 12:41:32 +02:00
|
|
|
return i_ret == VLC_SUCCESS ? val.i_int : -1;
|
2008-10-04 22:00:52 +02:00
|
|
|
}
|
|
|
|
|
2015-01-26 20:37:02 +01:00
|
|
|
int libvlc_media_player_get_full_title_descriptions( libvlc_media_player_t *p_mi,
|
|
|
|
libvlc_title_description_t *** pp_titles )
|
|
|
|
{
|
|
|
|
assert( p_mi );
|
|
|
|
|
|
|
|
input_thread_t *p_input_thread = libvlc_get_input_thread( p_mi );
|
|
|
|
|
|
|
|
if( !p_input_thread )
|
|
|
|
return -1;
|
|
|
|
|
2015-06-17 23:08:35 +02:00
|
|
|
input_title_t **p_input_title;
|
|
|
|
int count;
|
2015-01-26 20:37:02 +01:00
|
|
|
|
|
|
|
/* fetch data */
|
2015-06-17 23:08:35 +02:00
|
|
|
int ret = input_Control( p_input_thread, INPUT_GET_FULL_TITLE_INFO,
|
|
|
|
&p_input_title, &count );
|
2015-01-26 20:37:02 +01:00
|
|
|
vlc_object_release( p_input_thread );
|
2015-06-17 23:08:35 +02:00
|
|
|
if( ret != VLC_SUCCESS )
|
2015-01-26 20:37:02 +01:00
|
|
|
return -1;
|
|
|
|
|
2015-06-17 23:08:35 +02:00
|
|
|
libvlc_title_description_t **titles = malloc( count * sizeof (*titles) );
|
|
|
|
if( count > 0 && unlikely(titles == NULL) )
|
2015-01-26 20:37:02 +01:00
|
|
|
return -1;
|
|
|
|
|
|
|
|
/* fill array */
|
2015-06-17 23:08:35 +02:00
|
|
|
for( int i = 0; i < count; i++)
|
2015-01-26 20:37:02 +01:00
|
|
|
{
|
2015-06-17 23:08:35 +02:00
|
|
|
libvlc_title_description_t *title = malloc( sizeof (*title) );
|
|
|
|
if( unlikely(title == NULL) )
|
2015-01-26 20:37:02 +01:00
|
|
|
{
|
2015-08-05 20:38:09 +02:00
|
|
|
libvlc_title_descriptions_release( titles, i );
|
2015-01-26 20:37:02 +01:00
|
|
|
return -1;
|
|
|
|
}
|
2015-06-17 23:08:35 +02:00
|
|
|
titles[i] = title;
|
2015-01-26 20:37:02 +01:00
|
|
|
|
|
|
|
/* we want to return milliseconds to match the rest of the API */
|
2015-06-17 23:08:35 +02:00
|
|
|
title->i_duration = p_input_title[i]->i_length / 1000;
|
2015-12-02 13:55:46 +01:00
|
|
|
title->b_menu = p_input_title[i]->i_flags & INPUT_TITLE_MENU;
|
2015-01-26 20:37:02 +01:00
|
|
|
if( p_input_title[i]->psz_name )
|
2015-06-17 23:08:35 +02:00
|
|
|
title->psz_name = strdup( p_input_title[i]->psz_name );
|
2015-01-26 20:37:02 +01:00
|
|
|
else
|
2015-06-17 23:08:35 +02:00
|
|
|
title->psz_name = NULL;
|
2015-01-26 20:37:02 +01:00
|
|
|
vlc_input_title_Delete( p_input_title[i] );
|
|
|
|
}
|
2015-06-17 23:09:41 +02:00
|
|
|
free( p_input_title );
|
2015-01-26 20:37:02 +01:00
|
|
|
|
2015-06-17 23:08:35 +02:00
|
|
|
*pp_titles = titles;
|
|
|
|
return count;
|
2015-01-26 20:37:02 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
void libvlc_title_descriptions_release( libvlc_title_description_t **p_titles,
|
|
|
|
unsigned i_count )
|
|
|
|
{
|
|
|
|
for (unsigned i = 0; i < i_count; i++ )
|
|
|
|
{
|
|
|
|
if ( !p_titles[i] )
|
|
|
|
continue;
|
|
|
|
|
|
|
|
free( p_titles[i]->psz_name );
|
|
|
|
free( p_titles[i] );
|
|
|
|
}
|
|
|
|
free( p_titles );
|
|
|
|
}
|
|
|
|
|
2015-06-04 14:02:44 +02:00
|
|
|
int libvlc_media_player_get_full_chapter_descriptions( libvlc_media_player_t *p_mi,
|
|
|
|
int i_chapters_of_title,
|
|
|
|
libvlc_chapter_description_t *** pp_chapters )
|
|
|
|
{
|
|
|
|
assert( p_mi );
|
|
|
|
|
|
|
|
input_thread_t *p_input_thread = libvlc_get_input_thread( p_mi );
|
|
|
|
|
|
|
|
if( !p_input_thread )
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
seekpoint_t **p_seekpoint = NULL;
|
|
|
|
|
|
|
|
/* fetch data */
|
|
|
|
int ret = input_Control(p_input_thread, INPUT_GET_SEEKPOINTS, &p_seekpoint, &i_chapters_of_title);
|
|
|
|
vlc_object_release( p_input_thread );
|
|
|
|
|
|
|
|
if( ret != VLC_SUCCESS)
|
|
|
|
{
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (i_chapters_of_title == 0 || p_seekpoint == NULL)
|
|
|
|
{
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
const int ci_chapter_count = (const int)i_chapters_of_title;
|
|
|
|
|
|
|
|
*pp_chapters = calloc( ci_chapter_count, sizeof(**pp_chapters) );
|
|
|
|
if( !*pp_chapters )
|
|
|
|
{
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* fill array */
|
|
|
|
for( int i = 0; i < ci_chapter_count; i++)
|
|
|
|
{
|
2015-06-16 12:52:45 +02:00
|
|
|
libvlc_chapter_description_t *p_chapter = malloc( sizeof(*p_chapter) );
|
2015-06-04 14:02:44 +02:00
|
|
|
if( unlikely(p_chapter == NULL) )
|
|
|
|
{
|
|
|
|
libvlc_chapter_descriptions_release( *pp_chapters, ci_chapter_count );
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
(*pp_chapters)[i] = p_chapter;
|
|
|
|
|
|
|
|
p_chapter->i_time_offset = p_seekpoint[i]->i_time_offset / 1000;
|
|
|
|
|
|
|
|
if( i > 0 )
|
|
|
|
{
|
|
|
|
p_chapter->i_duration = p_chapter->i_time_offset - (*pp_chapters)[i-1]->i_time_offset;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
p_chapter->i_duration = p_chapter->i_time_offset;
|
|
|
|
}
|
|
|
|
|
|
|
|
if( p_seekpoint[i]->psz_name )
|
|
|
|
{
|
|
|
|
p_chapter->psz_name = strdup( p_seekpoint[i]->psz_name );
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
p_chapter->psz_name = NULL;
|
|
|
|
}
|
|
|
|
vlc_seekpoint_Delete( p_seekpoint[i] );
|
|
|
|
}
|
|
|
|
|
|
|
|
return ci_chapter_count;
|
|
|
|
}
|
|
|
|
|
|
|
|
void libvlc_chapter_descriptions_release( libvlc_chapter_description_t **p_chapters,
|
|
|
|
unsigned i_count )
|
|
|
|
{
|
|
|
|
for (unsigned i = 0; i < i_count; i++ )
|
|
|
|
{
|
|
|
|
if ( !p_chapters[i] )
|
|
|
|
continue;
|
|
|
|
|
|
|
|
free( p_chapters[i]->psz_name );
|
|
|
|
free( p_chapters[i] );
|
|
|
|
}
|
|
|
|
free( p_chapters );
|
|
|
|
}
|
|
|
|
|
2010-01-31 18:30:49 +01:00
|
|
|
void libvlc_media_player_next_chapter( libvlc_media_player_t *p_mi )
|
2008-10-04 22:00:52 +02:00
|
|
|
{
|
|
|
|
input_thread_t *p_input_thread;
|
|
|
|
|
2010-01-31 18:52:07 +01:00
|
|
|
p_input_thread = libvlc_get_input_thread ( p_mi );
|
2008-10-04 22:00:52 +02:00
|
|
|
if( !p_input_thread )
|
|
|
|
return;
|
|
|
|
|
|
|
|
int i_type = var_Type( p_input_thread, "next-chapter" );
|
2010-11-07 09:30:46 +01:00
|
|
|
var_TriggerCallback( p_input_thread, (i_type & VLC_VAR_TYPE) != 0 ?
|
|
|
|
"next-chapter":"next-title" );
|
2008-10-04 22:00:52 +02:00
|
|
|
|
|
|
|
vlc_object_release( p_input_thread );
|
|
|
|
}
|
|
|
|
|
2010-01-31 18:30:49 +01:00
|
|
|
void libvlc_media_player_previous_chapter( libvlc_media_player_t *p_mi )
|
2008-10-04 22:00:52 +02:00
|
|
|
{
|
|
|
|
input_thread_t *p_input_thread;
|
|
|
|
|
2010-01-31 18:52:07 +01:00
|
|
|
p_input_thread = libvlc_get_input_thread ( p_mi );
|
2008-10-04 22:00:52 +02:00
|
|
|
if( !p_input_thread )
|
|
|
|
return;
|
|
|
|
|
|
|
|
int i_type = var_Type( p_input_thread, "next-chapter" );
|
2010-11-07 09:30:46 +01:00
|
|
|
var_TriggerCallback( p_input_thread, (i_type & VLC_VAR_TYPE) != 0 ?
|
|
|
|
"prev-chapter":"prev-title" );
|
2008-10-04 22:00:52 +02:00
|
|
|
|
|
|
|
vlc_object_release( p_input_thread );
|
|
|
|
}
|
|
|
|
|
2010-01-31 18:30:49 +01:00
|
|
|
float libvlc_media_player_get_fps( libvlc_media_player_t *p_mi )
|
2006-06-10 18:13:38 +02:00
|
|
|
{
|
2015-10-24 20:23:25 +02:00
|
|
|
libvlc_media_t *media = libvlc_media_player_get_media( p_mi );
|
|
|
|
if( media == NULL )
|
|
|
|
return 0.f;
|
2006-06-10 18:13:38 +02:00
|
|
|
|
2015-10-24 20:23:25 +02:00
|
|
|
input_item_t *item = p_mi->p_md->p_input_item;
|
|
|
|
float fps = 0.f;
|
|
|
|
|
|
|
|
vlc_mutex_lock( &item->lock );
|
|
|
|
for( int i = 0; i < item->i_es; i++ )
|
2006-06-10 19:36:22 +02:00
|
|
|
{
|
2015-10-24 20:23:25 +02:00
|
|
|
const es_format_t *fmt = item->es[i];
|
|
|
|
|
|
|
|
if( fmt->i_cat == VIDEO_ES && fmt->video.i_frame_rate_base > 0 )
|
|
|
|
fps = (float)fmt->video.i_frame_rate
|
|
|
|
/ (float)fmt->video.i_frame_rate_base;
|
2006-06-10 19:36:22 +02:00
|
|
|
}
|
2015-10-24 20:23:25 +02:00
|
|
|
vlc_mutex_unlock( &item->lock );
|
|
|
|
|
|
|
|
return fps;
|
2006-06-10 18:13:38 +02:00
|
|
|
}
|
|
|
|
|
2010-01-31 18:30:49 +01:00
|
|
|
int libvlc_media_player_will_play( libvlc_media_player_t *p_mi )
|
2006-06-02 13:27:30 +02:00
|
|
|
{
|
2006-08-01 11:22:35 +02:00
|
|
|
input_thread_t *p_input_thread =
|
2010-01-31 18:52:07 +01:00
|
|
|
libvlc_get_input_thread ( p_mi );
|
2007-03-27 21:01:51 +02:00
|
|
|
if ( !p_input_thread )
|
2008-04-14 00:08:29 +02:00
|
|
|
return false;
|
2006-06-02 13:27:30 +02:00
|
|
|
|
2015-06-05 21:25:58 +02:00
|
|
|
int state = var_GetInteger( p_input_thread, "state" );
|
2006-06-05 18:00:27 +02:00
|
|
|
vlc_object_release( p_input_thread );
|
2009-11-20 12:28:26 +01:00
|
|
|
|
2015-06-05 21:25:58 +02:00
|
|
|
return state != END_S && state != ERROR_S;
|
2006-06-05 17:06:45 +02:00
|
|
|
}
|
2006-09-04 19:51:10 +02:00
|
|
|
|
2010-01-31 18:30:49 +01:00
|
|
|
int libvlc_media_player_set_rate( libvlc_media_player_t *p_mi, float rate )
|
2006-09-04 19:51:10 +02:00
|
|
|
{
|
2010-02-14 12:50:36 +01:00
|
|
|
var_SetFloat (p_mi, "rate", rate);
|
|
|
|
|
|
|
|
input_thread_t *p_input_thread = libvlc_get_input_thread ( p_mi );
|
|
|
|
if( !p_input_thread )
|
|
|
|
return 0;
|
2009-11-23 17:44:52 +01:00
|
|
|
var_SetFloat( p_input_thread, "rate", rate );
|
2006-09-04 19:51:10 +02:00
|
|
|
vlc_object_release( p_input_thread );
|
2010-01-31 18:30:49 +01:00
|
|
|
return 0;
|
2006-09-04 19:51:10 +02:00
|
|
|
}
|
|
|
|
|
2010-01-31 18:30:49 +01:00
|
|
|
float libvlc_media_player_get_rate( libvlc_media_player_t *p_mi )
|
2006-09-04 19:51:10 +02:00
|
|
|
{
|
2010-02-14 12:50:36 +01:00
|
|
|
return var_GetFloat (p_mi, "rate");
|
2006-09-04 19:51:10 +02:00
|
|
|
}
|
|
|
|
|
2010-01-24 10:09:46 +01:00
|
|
|
libvlc_state_t libvlc_media_player_get_state( libvlc_media_player_t *p_mi )
|
2006-09-04 19:51:10 +02:00
|
|
|
{
|
2009-12-07 20:35:10 +01:00
|
|
|
lock(p_mi);
|
|
|
|
libvlc_state_t state = p_mi->state;
|
|
|
|
unlock(p_mi);
|
2009-03-09 16:53:10 +01:00
|
|
|
return state;
|
2006-09-04 19:51:10 +02:00
|
|
|
}
|
2007-12-29 04:29:10 +01:00
|
|
|
|
2010-01-31 18:30:49 +01:00
|
|
|
int libvlc_media_player_is_seekable( libvlc_media_player_t *p_mi )
|
2007-12-29 04:29:10 +01:00
|
|
|
{
|
|
|
|
input_thread_t *p_input_thread;
|
2009-08-17 15:21:44 +02:00
|
|
|
bool b_seekable;
|
2007-12-29 04:29:10 +01:00
|
|
|
|
2010-01-31 18:52:07 +01:00
|
|
|
p_input_thread = libvlc_get_input_thread ( p_mi );
|
2007-12-29 04:29:10 +01:00
|
|
|
if ( !p_input_thread )
|
2008-04-14 00:08:29 +02:00
|
|
|
return false;
|
2009-08-17 15:21:44 +02:00
|
|
|
b_seekable = var_GetBool( p_input_thread, "can-seek" );
|
2007-12-29 04:29:10 +01:00
|
|
|
vlc_object_release( p_input_thread );
|
|
|
|
|
2009-08-17 15:21:44 +02:00
|
|
|
return b_seekable;
|
2007-12-29 04:29:10 +01:00
|
|
|
}
|
2008-01-07 15:46:08 +01:00
|
|
|
|
2010-09-10 08:47:10 +02:00
|
|
|
void libvlc_media_player_navigate( libvlc_media_player_t* p_mi,
|
2011-09-15 15:59:21 +02:00
|
|
|
unsigned navigate )
|
2010-09-10 08:47:10 +02:00
|
|
|
{
|
2013-02-01 16:58:31 +01:00
|
|
|
static const vlc_action_t map[] =
|
|
|
|
{
|
|
|
|
INPUT_NAV_ACTIVATE, INPUT_NAV_UP, INPUT_NAV_DOWN,
|
|
|
|
INPUT_NAV_LEFT, INPUT_NAV_RIGHT,
|
|
|
|
};
|
2010-09-10 08:47:10 +02:00
|
|
|
|
2013-02-01 16:58:31 +01:00
|
|
|
if( navigate >= sizeof(map) / sizeof(map[0]) )
|
2010-09-10 08:47:10 +02:00
|
|
|
return;
|
|
|
|
|
2013-02-01 16:58:31 +01:00
|
|
|
input_thread_t *p_input = libvlc_get_input_thread ( p_mi );
|
|
|
|
if ( p_input == NULL )
|
2010-09-10 08:47:10 +02:00
|
|
|
return;
|
|
|
|
|
2013-02-01 16:58:31 +01:00
|
|
|
input_Control( p_input, map[navigate], NULL );
|
|
|
|
vlc_object_release( p_input );
|
2010-09-10 08:47:10 +02:00
|
|
|
}
|
|
|
|
|
2008-10-12 16:40:30 +02:00
|
|
|
/* internal function, used by audio, video */
|
|
|
|
libvlc_track_description_t *
|
|
|
|
libvlc_get_track_description( libvlc_media_player_t *p_mi,
|
2010-01-31 18:30:49 +01:00
|
|
|
const char *psz_variable )
|
2008-10-12 16:40:30 +02:00
|
|
|
{
|
2010-01-31 18:52:07 +01:00
|
|
|
input_thread_t *p_input = libvlc_get_input_thread( p_mi );
|
2009-05-20 22:06:07 +02:00
|
|
|
libvlc_track_description_t *p_track_description = NULL,
|
|
|
|
*p_actual, *p_previous;
|
2008-10-12 16:40:30 +02:00
|
|
|
|
|
|
|
if( !p_input )
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
vlc_value_t val_list, text_list;
|
2014-10-23 20:32:01 +02:00
|
|
|
int i_ret = var_Change( p_input, psz_variable, VLC_VAR_GETCHOICES, &val_list, &text_list );
|
2014-07-07 12:41:32 +02:00
|
|
|
if( i_ret != VLC_SUCCESS )
|
|
|
|
return NULL;
|
2008-10-12 16:40:30 +02:00
|
|
|
|
2009-05-20 22:06:07 +02:00
|
|
|
/* no tracks */
|
|
|
|
if( val_list.p_list->i_count <= 0 )
|
|
|
|
goto end;
|
2008-10-12 16:40:30 +02:00
|
|
|
|
|
|
|
p_track_description = ( libvlc_track_description_t * )
|
|
|
|
malloc( sizeof( libvlc_track_description_t ) );
|
|
|
|
if ( !p_track_description )
|
|
|
|
{
|
2009-09-07 21:13:49 +02:00
|
|
|
libvlc_printerr( "Not enough memory" );
|
2009-05-20 22:06:07 +02:00
|
|
|
goto end;
|
2008-10-12 16:40:30 +02:00
|
|
|
}
|
|
|
|
p_actual = p_track_description;
|
|
|
|
p_previous = NULL;
|
|
|
|
for( int i = 0; i < val_list.p_list->i_count; i++ )
|
|
|
|
{
|
|
|
|
if( !p_actual )
|
|
|
|
{
|
|
|
|
p_actual = ( libvlc_track_description_t * )
|
|
|
|
malloc( sizeof( libvlc_track_description_t ) );
|
|
|
|
if ( !p_actual )
|
|
|
|
{
|
2011-09-21 18:13:00 +02:00
|
|
|
libvlc_track_description_list_release( p_track_description );
|
2009-09-07 21:13:49 +02:00
|
|
|
libvlc_printerr( "Not enough memory" );
|
2009-05-20 22:06:07 +02:00
|
|
|
goto end;
|
2008-10-12 16:40:30 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
p_actual->i_id = val_list.p_list->p_values[i].i_int;
|
|
|
|
p_actual->psz_name = strdup( text_list.p_list->p_values[i].psz_string );
|
|
|
|
p_actual->p_next = NULL;
|
|
|
|
if( p_previous )
|
|
|
|
p_previous->p_next = p_actual;
|
|
|
|
p_previous = p_actual;
|
|
|
|
p_actual = NULL;
|
|
|
|
}
|
2009-05-20 22:06:07 +02:00
|
|
|
|
|
|
|
end:
|
|
|
|
var_FreeList( &val_list, &text_list );
|
2008-10-12 16:40:30 +02:00
|
|
|
vlc_object_release( p_input );
|
|
|
|
|
|
|
|
return p_track_description;
|
|
|
|
}
|
|
|
|
|
2011-09-21 18:13:00 +02:00
|
|
|
// Deprecated alias for libvlc_track_description_list_release
|
2009-03-04 11:38:26 +01:00
|
|
|
void libvlc_track_description_release( libvlc_track_description_t *p_td )
|
2011-09-21 18:13:00 +02:00
|
|
|
{
|
|
|
|
libvlc_track_description_list_release( p_td );
|
|
|
|
}
|
|
|
|
|
|
|
|
void libvlc_track_description_list_release( libvlc_track_description_t *p_td )
|
2008-10-12 16:40:30 +02:00
|
|
|
{
|
|
|
|
libvlc_track_description_t *p_actual, *p_before;
|
2009-03-04 11:38:26 +01:00
|
|
|
p_actual = p_td;
|
2008-10-12 16:40:30 +02:00
|
|
|
|
|
|
|
while ( p_actual )
|
|
|
|
{
|
|
|
|
free( p_actual->psz_name );
|
|
|
|
p_before = p_actual;
|
|
|
|
p_actual = p_before->p_next;
|
|
|
|
free( p_before );
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-01-31 18:30:49 +01:00
|
|
|
int libvlc_media_player_can_pause( libvlc_media_player_t *p_mi )
|
2008-01-07 15:46:08 +01:00
|
|
|
{
|
|
|
|
input_thread_t *p_input_thread;
|
2009-08-17 15:21:44 +02:00
|
|
|
bool b_can_pause;
|
2008-01-07 15:46:08 +01:00
|
|
|
|
2010-01-31 18:52:07 +01:00
|
|
|
p_input_thread = libvlc_get_input_thread ( p_mi );
|
2008-01-07 15:46:08 +01:00
|
|
|
if ( !p_input_thread )
|
2008-04-14 00:08:29 +02:00
|
|
|
return false;
|
2009-08-17 15:21:44 +02:00
|
|
|
b_can_pause = var_GetBool( p_input_thread, "can-pause" );
|
2008-01-07 15:46:08 +01:00
|
|
|
vlc_object_release( p_input_thread );
|
|
|
|
|
2009-08-17 15:21:44 +02:00
|
|
|
return b_can_pause;
|
2008-01-07 15:46:08 +01:00
|
|
|
}
|
2009-08-13 14:17:07 +02:00
|
|
|
|
2014-02-06 22:03:24 +01:00
|
|
|
int libvlc_media_player_program_scrambled( libvlc_media_player_t *p_mi )
|
|
|
|
{
|
|
|
|
input_thread_t *p_input_thread;
|
|
|
|
bool b_program_scrambled;
|
|
|
|
|
|
|
|
p_input_thread = libvlc_get_input_thread ( p_mi );
|
|
|
|
if ( !p_input_thread )
|
|
|
|
return false;
|
|
|
|
b_program_scrambled = var_GetBool( p_input_thread, "program-scrambled" );
|
|
|
|
vlc_object_release( p_input_thread );
|
|
|
|
|
|
|
|
return b_program_scrambled;
|
|
|
|
}
|
|
|
|
|
2010-01-31 18:30:49 +01:00
|
|
|
void libvlc_media_player_next_frame( libvlc_media_player_t *p_mi )
|
2009-08-13 14:17:07 +02:00
|
|
|
{
|
2010-01-31 18:52:07 +01:00
|
|
|
input_thread_t *p_input_thread = libvlc_get_input_thread ( p_mi );
|
2009-08-13 14:17:07 +02:00
|
|
|
if( p_input_thread != NULL )
|
2009-08-17 14:52:33 +02:00
|
|
|
{
|
2009-08-13 14:17:07 +02:00
|
|
|
var_TriggerCallback( p_input_thread, "frame-next" );
|
2009-08-17 14:52:33 +02:00
|
|
|
vlc_object_release( p_input_thread );
|
|
|
|
}
|
2009-08-13 14:17:07 +02:00
|
|
|
}
|
2013-07-03 18:24:57 +02:00
|
|
|
|
2014-05-24 08:41:47 +02:00
|
|
|
/**
|
|
|
|
* Private lookup table to get subpicture alignment flag values corresponding
|
|
|
|
* to a libvlc_position_t enumerated value.
|
|
|
|
*/
|
2014-05-24 14:00:24 +02:00
|
|
|
static const unsigned char position_subpicture_alignment[] = {
|
|
|
|
[libvlc_position_center] = 0,
|
|
|
|
[libvlc_position_left] = SUBPICTURE_ALIGN_LEFT,
|
|
|
|
[libvlc_position_right] = SUBPICTURE_ALIGN_RIGHT,
|
|
|
|
[libvlc_position_top] = SUBPICTURE_ALIGN_TOP,
|
|
|
|
[libvlc_position_top_left] = SUBPICTURE_ALIGN_TOP | SUBPICTURE_ALIGN_LEFT,
|
|
|
|
[libvlc_position_top_right] = SUBPICTURE_ALIGN_TOP | SUBPICTURE_ALIGN_RIGHT,
|
|
|
|
[libvlc_position_bottom] = SUBPICTURE_ALIGN_BOTTOM,
|
|
|
|
[libvlc_position_bottom_left] = SUBPICTURE_ALIGN_BOTTOM | SUBPICTURE_ALIGN_LEFT,
|
|
|
|
[libvlc_position_bottom_right] = SUBPICTURE_ALIGN_BOTTOM | SUBPICTURE_ALIGN_RIGHT
|
2014-05-24 08:41:47 +02:00
|
|
|
};
|
|
|
|
|
2013-07-03 18:24:57 +02:00
|
|
|
void libvlc_media_player_set_video_title_display( libvlc_media_player_t *p_mi, libvlc_position_t position, unsigned timeout )
|
|
|
|
{
|
2014-05-24 08:41:47 +02:00
|
|
|
assert( position >= libvlc_position_disable && position <= libvlc_position_bottom_right );
|
|
|
|
|
2013-07-03 18:24:57 +02:00
|
|
|
if ( position != libvlc_position_disable )
|
|
|
|
{
|
|
|
|
var_SetBool( p_mi, "video-title-show", true );
|
2014-05-24 08:41:47 +02:00
|
|
|
var_SetInteger( p_mi, "video-title-position", position_subpicture_alignment[position] );
|
2013-07-03 18:24:57 +02:00
|
|
|
var_SetInteger( p_mi, "video-title-timeout", timeout );
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
var_SetBool( p_mi, "video-title-show", false );
|
|
|
|
}
|
|
|
|
}
|
2013-07-13 20:21:37 +02:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Maximum size of a formatted equalizer amplification band frequency value.
|
|
|
|
*
|
|
|
|
* The allowed value range is supposed to be constrained from -20.0 to 20.0.
|
|
|
|
*
|
|
|
|
* The format string " %.07f" with a minimum value of "-20" gives a maximum
|
|
|
|
* string length of e.g. " -19.1234567", i.e. 12 bytes (not including the null
|
|
|
|
* terminator).
|
|
|
|
*/
|
|
|
|
#define EQZ_BAND_VALUE_SIZE 12
|
|
|
|
|
|
|
|
int libvlc_media_player_set_equalizer( libvlc_media_player_t *p_mi, libvlc_equalizer_t *p_equalizer )
|
|
|
|
{
|
2014-05-24 06:55:30 +02:00
|
|
|
char bands[EQZ_BANDS_MAX * EQZ_BAND_VALUE_SIZE + 1];
|
2013-07-13 20:21:37 +02:00
|
|
|
|
2014-05-24 06:55:30 +02:00
|
|
|
if( p_equalizer != NULL )
|
2013-07-13 20:21:37 +02:00
|
|
|
{
|
2014-05-24 06:55:30 +02:00
|
|
|
for( unsigned i = 0, c = 0; i < EQZ_BANDS_MAX; i++ )
|
2013-07-13 20:21:37 +02:00
|
|
|
{
|
2014-06-16 16:47:44 +02:00
|
|
|
c += snprintf( bands + c, sizeof(bands) - c, " %.07f",
|
2014-05-24 06:55:30 +02:00
|
|
|
p_equalizer->f_amp[i] );
|
|
|
|
if( unlikely(c >= sizeof(bands)) )
|
2013-07-13 20:21:37 +02:00
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2014-05-24 06:55:30 +02:00
|
|
|
var_SetFloat( p_mi, "equalizer-preamp", p_equalizer->f_preamp );
|
|
|
|
var_SetString( p_mi, "equalizer-bands", bands );
|
|
|
|
}
|
|
|
|
var_SetString( p_mi, "audio-filter", p_equalizer ? "equalizer" : "" );
|
2013-07-13 20:21:37 +02:00
|
|
|
|
|
|
|
audio_output_t *p_aout = input_resource_HoldAout( p_mi->input.p_resource );
|
2014-05-24 06:55:30 +02:00
|
|
|
if( p_aout != NULL )
|
2013-07-13 20:21:37 +02:00
|
|
|
{
|
2014-05-24 06:55:30 +02:00
|
|
|
if( p_equalizer != NULL )
|
|
|
|
{
|
|
|
|
var_SetFloat( p_aout, "equalizer-preamp", p_equalizer->f_preamp );
|
|
|
|
var_SetString( p_aout, "equalizer-bands", bands );
|
|
|
|
}
|
2013-07-13 20:21:37 +02:00
|
|
|
|
2014-06-16 16:47:44 +02:00
|
|
|
var_SetString( p_aout, "audio-filter", p_equalizer ? "equalizer" : "" );
|
2013-07-13 20:21:37 +02:00
|
|
|
vlc_object_release( p_aout );
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|