Skip to content

V
vlc
Commit 01fad0ca authored by Jean-Baptiste Kempf's avatar Jean-Baptiste Kempf
Browse files
Options

Remove mediacontrol bindings 

They are old, broken and not up-to-date
parent e848e444
Hide whitespace changes
Inline Side-by-side
Showing with 0 additions and 1499 deletions
bindings/mediacontrol/libmediacontrol.sym deleted 100644 → 0
View file @ e848e444
mediacontrol_RGBPicture__free
mediacontrol_StreamInformation__free
mediacontrol_display_text
mediacontrol_exception_cleanup
mediacontrol_exception_create
mediacontrol_exception_free
mediacontrol_exception_init
mediacontrol_exit
mediacontrol_get_fullscreen
mediacontrol_get_libvlc_instance
mediacontrol_get_media_player
mediacontrol_get_media_position
mediacontrol_get_mrl
mediacontrol_get_rate
mediacontrol_get_stream_information
mediacontrol_new
mediacontrol_new_from_instance
mediacontrol_pause
mediacontrol_resume
mediacontrol_set_fullscreen
mediacontrol_set_media_position
mediacontrol_set_mrl
mediacontrol_set_rate
mediacontrol_set_visual
mediacontrol_snapshot
mediacontrol_sound_get_volume
mediacontrol_sound_set_volume
mediacontrol_start
mediacontrol_stop
bindings/mediacontrol/mediacontrol.h deleted 100644 → 0
View file @ e848e444
/*****************************************************************************
* mediacontrol.h: global header for mediacontrol
*****************************************************************************
* Copyright (C) 2005-2008 the VideoLAN team
* $Id$
*
* Authors: Olivier Aubert <olivier.aubert@liris.univ-lyon1.fr>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (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
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU 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.
*****************************************************************************/
/**
* \file
* This file defines libvlc mediacontrol_* external API
*/
/**
* \defgroup mediacontrol MediaControl
* This is the MediaControl API, * intended to provide a generic API to movie players.
*
* @{
*/
#ifndef VLC_CONTROL_H
#define VLC_CONTROL_H 1
# ifdef __cplusplus
extern "C" {
# endif
#if defined( WIN32 )
#include <windows.h>
typedef HWND WINDOWHANDLE;
#else
typedef int WINDOWHANDLE;
#endif
#include <vlc/libvlc.h>
#include <vlc/mediacontrol_structures.h>
/**
* mediacontrol_Instance is an opaque structure, defined in
* mediacontrol_internal.h. API users do not have to mess with it.
*/
typedef struct mediacontrol_Instance mediacontrol_Instance;
/**************************************************************************
* Helper functions
***************************************************************************/
/**
* Free a RGBPicture structure.
* \param pic: the RGBPicture structure
*/
LIBVLC_API void mediacontrol_RGBPicture__free( mediacontrol_RGBPicture *pic );
LIBVLC_API void mediacontrol_PlaylistSeq__free( mediacontrol_PlaylistSeq *ps );
/**
* Free a StreamInformation structure.
* \param pic: the StreamInformation structure
*/
LIBVLC_API void
mediacontrol_StreamInformation__free( mediacontrol_StreamInformation* p_si );
/**
* Instanciate and initialize an exception structure.
* \return the exception
*/
LIBVLC_API mediacontrol_Exception *
mediacontrol_exception_create( void );
/**
* Initialize an existing exception structure.
* \param p_exception the exception to initialize.
*/
LIBVLC_API void
mediacontrol_exception_init( mediacontrol_Exception *exception );
/**
* Clean up an existing exception structure after use.
* \param p_exception the exception to clean up.
*/
LIBVLC_API void
mediacontrol_exception_cleanup( mediacontrol_Exception *exception );
/**
* Free an exception structure created with mediacontrol_exception_create().
* \param p_exception the exception to free.
*/
LIBVLC_API void mediacontrol_exception_free(mediacontrol_Exception *exception);
/*****************************************************************************
* Core functions
*****************************************************************************/
/**
* Create a MediaControl instance with parameters
* \param argc the number of arguments
* \param argv parameters
* \param exception an initialized exception pointer
* \return a mediacontrol_Instance
*/
LIBVLC_API mediacontrol_Instance *
mediacontrol_new( int argc, char **argv, mediacontrol_Exception *exception );
/**
* Create a MediaControl instance from an existing libvlc instance
* \param p_instance the libvlc instance
* \param exception an initialized exception pointer
* \return a mediacontrol_Instance
*/
LIBVLC_API mediacontrol_Instance *
mediacontrol_new_from_instance( libvlc_instance_t* p_instance,
mediacontrol_Exception *exception );
/**
* Get the associated libvlc instance
* \param self: the mediacontrol instance
* \return a libvlc instance
*/
LIBVLC_API libvlc_instance_t*
mediacontrol_get_libvlc_instance( mediacontrol_Instance* self );
/**
* Get the associated libvlc_media_player
* \param self: the mediacontrol instance
* \return a libvlc_media_player_t instance
*/
LIBVLC_API libvlc_media_player_t*
mediacontrol_get_media_player( mediacontrol_Instance* self );
/**
* Get the current position
* \param self the mediacontrol instance
* \param an_origin the position origin
* \param a_key the position unit
* \param exception an initialized exception pointer
* \return a mediacontrol_Position
*/
LIBVLC_API mediacontrol_Position * mediacontrol_get_media_position(
mediacontrol_Instance *self,
const mediacontrol_PositionOrigin an_origin,
const mediacontrol_PositionKey a_key,
mediacontrol_Exception *exception );
/**
* Set the position
* \param self the mediacontrol instance
* \param a_position a mediacontrol_Position
* \param exception an initialized exception pointer
*/
LIBVLC_API void mediacontrol_set_media_position( mediacontrol_Instance *self,
const mediacontrol_Position *a_position,
mediacontrol_Exception *exception );
/**
* Play the movie at a given position
* \param self the mediacontrol instance
* \param a_position a mediacontrol_Position
* \param exception an initialized exception pointer
*/
LIBVLC_API void mediacontrol_start( mediacontrol_Instance *self,
const mediacontrol_Position *a_position,
mediacontrol_Exception *exception );
/**
* Pause the movie at a given position
* \param self the mediacontrol instance
* \param exception an initialized exception pointer
*/
LIBVLC_API void mediacontrol_pause( mediacontrol_Instance *self,
mediacontrol_Exception *exception );
/**
* Resume the movie at a given position
* \param self the mediacontrol instance
* \param exception an initialized exception pointer
*/
LIBVLC_API void mediacontrol_resume( mediacontrol_Instance *self,
mediacontrol_Exception *exception );
/**
* Stop the movie at a given position
* \param self the mediacontrol instance
* \param exception an initialized exception pointer
*/
LIBVLC_API void mediacontrol_stop( mediacontrol_Instance *self,
mediacontrol_Exception *exception );
/**
* Exit the player
* \param self the mediacontrol instance
*/
LIBVLC_API void mediacontrol_exit( mediacontrol_Instance *self );
/**
* Set the MRL to be played.
* \param self the mediacontrol instance
* \param psz_file the MRL
* \param exception an initialized exception pointer
*/
LIBVLC_API void mediacontrol_set_mrl( mediacontrol_Instance *self,
const char* psz_file,
mediacontrol_Exception *exception );
/**
* Get the MRL to be played.
* \param self the mediacontrol instance
* \param exception an initialized exception pointer
*/
LIBVLC_API char * mediacontrol_get_mrl( mediacontrol_Instance *self,
mediacontrol_Exception *exception );
/*****************************************************************************
* A/V functions
*****************************************************************************/
/**
* Get a snapshot
* \param self the mediacontrol instance
* \param a_position the desired position (ignored for now)
* \param exception an initialized exception pointer
* \return a RGBpicture
*/
LIBVLC_API mediacontrol_RGBPicture *
mediacontrol_snapshot( mediacontrol_Instance *self,
const mediacontrol_Position *a_position,
mediacontrol_Exception *exception );
/**
* Displays the message string, between "begin" and "end" positions.
* \param self the mediacontrol instance
* \param message the message to display
* \param begin the begin position
* \param end the end position
* \param exception an initialized exception pointer
*/
LIBVLC_API void mediacontrol_display_text( mediacontrol_Instance *self,
const char *message,
const mediacontrol_Position *begin,
const mediacontrol_Position *end,
mediacontrol_Exception *exception );
/**
* Get information about a stream
* \param self the mediacontrol instance
* \param a_key the time unit
* \param exception an initialized exception pointer
* \return a mediacontrol_StreamInformation
*/
LIBVLC_API mediacontrol_StreamInformation *
mediacontrol_get_stream_information( mediacontrol_Instance *self,
mediacontrol_PositionKey a_key,
mediacontrol_Exception *exception );
/**
* Get the current audio level, normalized in [0..100]
* \param self the mediacontrol instance
* \param exception an initialized exception pointer
* \return the volume
*/
LIBVLC_API unsigned short
mediacontrol_sound_get_volume( mediacontrol_Instance *self,
mediacontrol_Exception *exception );
/**
* Set the audio level
* \param self the mediacontrol instance
* \param volume the volume (normalized in [0..100])
* \param exception an initialized exception pointer
*/
LIBVLC_API void mediacontrol_sound_set_volume( mediacontrol_Instance *self,
const unsigned short volume,
mediacontrol_Exception *exception );
/**
* Set the video output window
* \param self the mediacontrol instance
* \param visual_id the Xid or HWND, depending on the platform
* \param exception an initialized exception pointer
*/
LIBVLC_API int mediacontrol_set_visual( mediacontrol_Instance *self,
WINDOWHANDLE visual_id,
mediacontrol_Exception *exception );
/**
* Get the current playing rate, in percent
* \param self the mediacontrol instance
* \param exception an initialized exception pointer
* \return the rate
*/
LIBVLC_API int mediacontrol_get_rate( mediacontrol_Instance *self,
mediacontrol_Exception *exception );
/**
* Set the playing rate, in percent
* \param self the mediacontrol instance
* \param rate the desired rate
* \param exception an initialized exception pointer
*/
LIBVLC_API void mediacontrol_set_rate( mediacontrol_Instance *self,
const int rate,
mediacontrol_Exception *exception );
/**
* Get current fullscreen status
* \param self the mediacontrol instance
* \param exception an initialized exception pointer
* \return the fullscreen status
*/
LIBVLC_API int mediacontrol_get_fullscreen( mediacontrol_Instance *self,
mediacontrol_Exception *exception );
/**
* Set fullscreen status
* \param self the mediacontrol instance
* \param b_fullscreen the desired status
* \param exception an initialized exception pointer
*/
LIBVLC_API void mediacontrol_set_fullscreen( mediacontrol_Instance *self,
const int b_fullscreen,
mediacontrol_Exception *exception );
# ifdef __cplusplus
}
# endif
#endif
/** @} */
bindings/mediacontrol/mediacontrol_audio_video.c deleted 100644 → 0
View file @ e848e444
/*****************************************************************************
* mediacontrol_audio_video.c: Audio/Video management : volume, snapshot, OSD
*****************************************************************************
* Copyright (C) 2005 the VideoLAN team
* $Id$
*
* Authors: Olivier Aubert <olivier.aubert@liris.univ-lyon1.fr>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (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
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU 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.
*****************************************************************************/
#ifdef HAVE_CONFIG_H
# include "config.h"
#endif
#include "mediacontrol_internal.h"
#include "libvlc_internal.h"
#include "media_player_internal.h"
#include <vlc/mediacontrol.h>
#include <vlc/libvlc.h>
#include <vlc_vout.h>
#include <vlc_input.h>
#include <vlc_osd.h>
#include <vlc_block.h>
#include <stdlib.h> /* malloc(), free() */
#include <string.h>
#include <stdio.h>
#ifdef HAVE_UNISTD_H
# include <unistd.h>
#endif
#include <sys/types.h>
mediacontrol_RGBPicture *
mediacontrol_snapshot( mediacontrol_Instance *self,
const mediacontrol_Position * a_position,
mediacontrol_Exception *exception )
{
(void)a_position;
vout_thread_t* p_vout;
input_thread_t *p_input;
mediacontrol_RGBPicture *p_pic;
libvlc_exception_t ex;
libvlc_exception_init( &ex );
mediacontrol_exception_init( exception );
p_input = libvlc_get_input_thread( self->p_media_player );
if( ! p_input )
{
RAISE_NULL( mediacontrol_InternalException, "No input" );
}
p_vout = input_GetVout( p_input );
vlc_object_release( p_input );
if( ! p_vout )
{
RAISE_NULL( mediacontrol_InternalException, "No video output" );
}
block_t *p_image;
video_format_t fmt;
if( vout_GetSnapshot( p_vout, &p_image, NULL, &fmt, "png", 500*1000 ) )
{
vlc_object_release( p_vout );
RAISE_NULL( mediacontrol_InternalException, "Snapshot exception" );
return NULL;
}
/* */
char *p_data = malloc( p_image->i_buffer );
if( p_data )
{
memcpy( p_data, p_image->p_buffer, p_image->i_buffer );
p_pic = private_mediacontrol_createRGBPicture( fmt.i_width,
fmt.i_height,
fmt.i_chroma,
p_image->i_pts,
p_data,
p_image->i_buffer );
}
else
{
p_pic = NULL;
}
block_Release( p_image );
if( !p_pic )
RAISE_NULL( mediacontrol_InternalException, "Out of memory" );
vlc_object_release( p_vout );
return p_pic;
}
static
int mediacontrol_showtext( vout_thread_t *p_vout, int i_channel,
const char *psz_string, text_style_t *p_style,
int i_flags, int i_hmargin, int i_vmargin,
mtime_t i_start, mtime_t i_stop )
{
(void)p_style; (void)i_hmargin; (void)i_vmargin;
vout_OSDText( p_vout, i_channel, i_flags & ~SUBPICTURE_ALIGN_MASK,
i_stop - i_start, psz_string );
}
void
mediacontrol_display_text( mediacontrol_Instance *self,
const char * message,
const mediacontrol_Position * begin,
const mediacontrol_Position * end,
mediacontrol_Exception *exception )
{
vout_thread_t *p_vout = NULL;
input_thread_t *p_input;
libvlc_exception_t ex;
libvlc_exception_init( &ex );
mediacontrol_exception_init( exception );
if( !message )
{
RAISE_VOID( mediacontrol_InternalException, "Empty text" );
}
p_input = libvlc_get_input_thread( self->p_media_player );
if( ! p_input )
{
RAISE_VOID( mediacontrol_InternalException, "No input" );
}
p_vout = input_GetVout( p_input );
/*FIXME: take care of the next fixme that can use p_input */
vlc_object_release( p_input );
if( ! p_vout )
{
RAISE_VOID( mediacontrol_InternalException, "No video output" );
}
if( begin->origin == mediacontrol_RelativePosition &&
begin->value == 0 &&
end->origin == mediacontrol_RelativePosition )
{
mtime_t i_duration = 0;
mtime_t i_now = mdate();
i_duration = 1000 * private_mediacontrol_unit_convert(
self->p_media_player,
end->key,
mediacontrol_MediaTime,
end->value );
mediacontrol_showtext( p_vout, DEFAULT_CHAN, message, NULL,
OSD_ALIGN_BOTTOM | OSD_ALIGN_LEFT, 0, 0,
i_now, i_now + i_duration );
}
else
{
mtime_t i_debut, i_fin, i_now;
/* FIXME */
/* i_now = input_ClockGetTS( p_input, NULL, 0 ); */
i_now = mdate();
i_debut = private_mediacontrol_position2microsecond( self->p_media_player,
( mediacontrol_Position* ) begin );
i_debut += i_now;
i_fin = private_mediacontrol_position2microsecond( self->p_media_player,
( mediacontrol_Position * ) end );
i_fin += i_now;
vout_ShowTextAbsolute( p_vout, DEFAULT_CHAN, message, NULL,
OSD_ALIGN_BOTTOM | OSD_ALIGN_LEFT, 0, 0,
i_debut, i_fin );
}
vlc_object_release( p_vout );
}
unsigned short
mediacontrol_sound_get_volume( mediacontrol_Instance *self,
mediacontrol_Exception *exception )
{
int i_ret = 0;
mediacontrol_exception_init( exception );
//i_ret = libvlc_audio_get_volume( self->p_instance );
#warning FIXME: unimplented
/* FIXME: Normalize in [0..100] */
return (unsigned short)i_ret;
}
void
mediacontrol_sound_set_volume( mediacontrol_Instance *self,
const unsigned short volume,
mediacontrol_Exception *exception )
{
/* FIXME: Normalize in [0..100] */
mediacontrol_exception_init( exception );
//libvlc_audio_set_volume( self->p_instance, volume );
#warning FIXME: unimplented
}
int mediacontrol_set_visual( mediacontrol_Instance *self,
WINDOWHANDLE visual_id,
mediacontrol_Exception *exception )
{
mediacontrol_exception_init( exception );
#ifdef WIN32
libvlc_media_player_set_hwnd( self->p_media_player, visual_id );
#else
libvlc_media_player_set_xwindow( self->p_media_player, visual_id );
#endif
return true;
}
int
mediacontrol_get_rate( mediacontrol_Instance *self,
mediacontrol_Exception *exception )
{
int i_ret;
mediacontrol_exception_init( exception );
i_ret = libvlc_media_player_get_rate( self->p_media_player );
return (i_ret >= 0) ? (i_ret / 10) : -1;
}
void
mediacontrol_set_rate( mediacontrol_Instance *self,
const int rate,
mediacontrol_Exception *exception )
{
mediacontrol_exception_init( exception );
libvlc_media_player_set_rate( self->p_media_player, rate * 10 );
}
int
mediacontrol_get_fullscreen( mediacontrol_Instance *self,
mediacontrol_Exception *exception )
{
libvlc_exception_t ex;
int i_ret;
mediacontrol_exception_init( exception );
libvlc_exception_init( &ex );
i_ret = libvlc_get_fullscreen( self->p_media_player, &ex );
HANDLE_LIBVLC_EXCEPTION_ZERO( &ex );
return i_ret;
}
void
mediacontrol_set_fullscreen( mediacontrol_Instance *self,
const int b_fullscreen,
mediacontrol_Exception *exception )
{
libvlc_exception_t ex;
mediacontrol_exception_init( exception );
libvlc_exception_init( &ex );
libvlc_set_fullscreen( self->p_media_player, b_fullscreen, &ex );
HANDLE_LIBVLC_EXCEPTION_VOID( &ex );
}
bindings/mediacontrol/mediacontrol_core.c deleted 100644 → 0
View file @ e848e444
/*****************************************************************************
* mediacontrol_core.c: Core functions : init, playlist, stream management
*****************************************************************************
* Copyright (C) 2005 the VideoLAN team
* $Id$
*
* Authors: Olivier Aubert <olivier.aubert@liris.univ-lyon1.fr>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (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
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU 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.
*****************************************************************************/
#ifdef HAVE_CONFIG_H
# include "config.h"
#endif
#include "mediacontrol_internal.h"
#include <vlc/mediacontrol.h>
#include <vlc/libvlc.h>
#include <vlc_common.h>
#include <vlc_interface.h>
#include <vlc_playlist.h>
#include <vlc_vout.h>
#include <vlc_aout.h>
#include <vlc_input.h>
#include <vlc_osd.h>
#include <stdlib.h> /* malloc(), free() */
#include <string.h>
#include <stdio.h>
#ifdef HAVE_UNISTD_H
# include <unistd.h>
#endif
#include <sys/types.h>
mediacontrol_Instance* mediacontrol_new( int argc, char** argv, mediacontrol_Exception *exception )
{
mediacontrol_Instance* retval;
mediacontrol_exception_init( exception );
retval = ( mediacontrol_Instance* )malloc( sizeof( mediacontrol_Instance ) );
if( !retval )
RAISE_NULL( mediacontrol_InternalException, "Out of memory" );
retval->p_instance = libvlc_new( argc, (const char**)argv );
if( !retval->p_instance )
RAISE_NULL( mediacontrol_InternalException, "Out of memory" );
retval->p_media_player = libvlc_media_player_new( retval->p_instance );
if( !retval->p_media_player )
RAISE_NULL( mediacontrol_InternalException, "Out of memory" );
return retval;
}
void
mediacontrol_exit( mediacontrol_Instance *self )
{
libvlc_release( self->p_instance );
}
libvlc_instance_t*
mediacontrol_get_libvlc_instance( mediacontrol_Instance *self )
{
return self->p_instance;
}
libvlc_media_player_t*
mediacontrol_get_media_player( mediacontrol_Instance *self )
{
return self->p_media_player;
}
mediacontrol_Instance *
mediacontrol_new_from_instance( libvlc_instance_t* p_instance,
mediacontrol_Exception *exception )
{
mediacontrol_Instance* retval;
retval = ( mediacontrol_Instance* )malloc( sizeof( mediacontrol_Instance ) );
if( ! retval )
{
RAISE_NULL( mediacontrol_InternalException, "Out of memory" );
}
retval->p_instance = p_instance;
retval->p_media_player = libvlc_media_player_new( retval->p_instance );
if( ! retval->p_media_player )
RAISE_NULL( mediacontrol_InternalException, "Out of memory" );
return retval;
}
/**************************************************************************
* Playback management
**************************************************************************/
mediacontrol_Position*
mediacontrol_get_media_position( mediacontrol_Instance *self,
const mediacontrol_PositionOrigin an_origin,
const mediacontrol_PositionKey a_key,
mediacontrol_Exception *exception )
{
mediacontrol_Position* retval = NULL;
int64_t pos;
mediacontrol_exception_init( exception );
retval = ( mediacontrol_Position* )malloc( sizeof( mediacontrol_Position ) );
retval->origin = an_origin;
retval->key = a_key;
if( an_origin != mediacontrol_AbsolutePosition )
{
free( retval );
/* Relative or ModuloPosition make no sense */
RAISE_NULL( mediacontrol_PositionOriginNotSupported,
"Only absolute position is valid." );
}
/* We are asked for an AbsolutePosition. */
pos = libvlc_media_player_get_time( self->p_media_player );
if( a_key == mediacontrol_MediaTime )
{
retval->value = pos;
}
else
{
retval->value = private_mediacontrol_unit_convert( self->p_media_player,
mediacontrol_MediaTime,
a_key,
pos );
}
return retval;
}
/* Sets the media position */
void
mediacontrol_set_media_position( mediacontrol_Instance *self,
const mediacontrol_Position * a_position,
mediacontrol_Exception *exception )
{
int64_t i_pos;
mediacontrol_exception_init( exception );
i_pos = private_mediacontrol_position2microsecond( self->p_media_player, a_position );
libvlc_media_player_set_time( self->p_media_player, i_pos / 1000 );
}
/* Starts playing a stream */
/*
* Known issues: since moving in the playlist using playlist_Next
* or playlist_Prev implies starting to play items, the a_position
* argument will be only honored for the 1st item in the list.
*
* XXX:FIXME split moving in the playlist and playing items two
* different actions or make playlist_<Next|Prev> accept a time
* value to start to play from.
*/
void
mediacontrol_start( mediacontrol_Instance *self,
const mediacontrol_Position * a_position,
mediacontrol_Exception *exception )
{
libvlc_media_t * p_media;
char * psz_name;
libvlc_exception_t ex;
mediacontrol_exception_init( exception );
libvlc_exception_init( &ex );
p_media = libvlc_media_player_get_media( self->p_media_player );
if ( ! p_media )
{
/* No media was defined. */
RAISE( mediacontrol_PlaylistException, "No defined media." );
}
else
{
/* A media was defined. Get its mrl to reuse it, but reset the options
(because start-time may have been set on the previous invocation */
psz_name = libvlc_media_get_mrl( p_media );
HANDLE_LIBVLC_EXCEPTION_VOID( &ex );
/* Create a new media */
p_media = libvlc_media_new_location( self->p_instance, psz_name, &ex );
HANDLE_LIBVLC_EXCEPTION_VOID( &ex );
if( a_position->value )
{
char * psz_from;
libvlc_time_t i_from;
/* A start position was specified. Add it to media options */
psz_from = ( char * )malloc( 20 * sizeof( char ) );
i_from = private_mediacontrol_position2microsecond( self->p_media_player, a_position ) / 1000000;
snprintf( psz_from, 20, "start-time=%"PRId64, i_from );
libvlc_media_add_option( p_media, psz_from );
HANDLE_LIBVLC_EXCEPTION_VOID( &ex );
}
libvlc_media_player_set_media( self->p_media_player, p_media );
libvlc_media_player_play( self->p_media_player );
}
}
void
mediacontrol_pause( mediacontrol_Instance *self,
mediacontrol_Exception *exception )
{
mediacontrol_exception_init( exception );
libvlc_media_player_pause( self->p_media_player );
}
void
mediacontrol_resume( mediacontrol_Instance *self,
mediacontrol_Exception *exception )
{
mediacontrol_exception_init( exception );
libvlc_media_player_pause( self->p_media_player );
}
void
mediacontrol_stop( mediacontrol_Instance *self,
mediacontrol_Exception *exception )
{
mediacontrol_exception_init( exception );
libvlc_media_player_stop( self->p_media_player );
}
/**************************************************************************
* File management
**************************************************************************/
void
mediacontrol_set_mrl( mediacontrol_Instance *self,
const char * psz_file,
mediacontrol_Exception *exception )
{
libvlc_media_t * p_media;
libvlc_exception_t ex;
mediacontrol_exception_init( exception );
libvlc_exception_init( &ex );
p_media = libvlc_media_new_location( self->p_instance, psz_file, &ex );
HANDLE_LIBVLC_EXCEPTION_VOID( &ex );
libvlc_media_player_set_media( self->p_media_player, p_media );
}
char *
mediacontrol_get_mrl( mediacontrol_Instance *self,
mediacontrol_Exception *exception )
{
libvlc_media_t * p_media;
libvlc_exception_t ex;
mediacontrol_exception_init( exception );
libvlc_exception_init( &ex );
p_media = libvlc_media_player_get_media( self->p_media_player );
if ( ! p_media )
{
return strdup( "" );
}
else
{
char * psz_mrl;
psz_mrl = libvlc_media_get_mrl( p_media );
HANDLE_LIBVLC_EXCEPTION_NULL( &ex );
return psz_mrl;
}
}
/***************************************************************************
* Status feedback
***************************************************************************/
mediacontrol_StreamInformation *
mediacontrol_get_stream_information( mediacontrol_Instance *self,
mediacontrol_PositionKey a_key,
mediacontrol_Exception *exception )
{
(void)a_key;
mediacontrol_StreamInformation *retval = NULL;
libvlc_media_t * p_media;
libvlc_exception_t ex;
libvlc_exception_init( &ex );
retval = ( mediacontrol_StreamInformation* )
malloc( sizeof( mediacontrol_StreamInformation ) );
if( ! retval )
{
RAISE( mediacontrol_InternalException, "Out of memory" );
return NULL;
}
p_media = libvlc_media_player_get_media( self->p_media_player );
if( ! p_media )
{
/* No p_media defined */
retval->streamstatus = mediacontrol_UndefinedStatus;
retval->url = strdup( "" );
retval->position = 0;
retval->length = 0;
}
else
{
libvlc_state_t state;
state = libvlc_media_player_get_state( self->p_media_player );
switch( state )
{
case libvlc_NothingSpecial:
retval->streamstatus = mediacontrol_UndefinedStatus;
break;
case libvlc_Opening :
retval->streamstatus = mediacontrol_InitStatus;
break;
case libvlc_Buffering:
retval->streamstatus = mediacontrol_BufferingStatus;
break;
case libvlc_Playing:
retval->streamstatus = mediacontrol_PlayingStatus;
break;
case libvlc_Paused:
retval->streamstatus = mediacontrol_PauseStatus;
break;
case libvlc_Stopped:
retval->streamstatus = mediacontrol_StopStatus;
break;
case libvlc_Ended:
retval->streamstatus = mediacontrol_EndStatus;
break;
case libvlc_Error:
retval->streamstatus = mediacontrol_ErrorStatus;
break;
default :
retval->streamstatus = mediacontrol_UndefinedStatus;
break;
}
retval->url = libvlc_media_get_mrl( p_media );
retval->position = libvlc_media_player_get_time( self->p_media_player );
retval->length = libvlc_media_player_get_length( self->p_media_player );
}
return retval;
}
bindings/mediacontrol/mediacontrol_internal.h deleted 100644 → 0
View file @ e848e444
/*****************************************************************************
* mediacontrol_internal.h: private header for mediacontrol
*****************************************************************************
* Copyright (C) 2005 the VideoLAN team
* $Id$
*
* Authors: Olivier Aubert <olivier.aubert@liris.univ-lyon1.fr>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (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
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU 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.
*****************************************************************************/
#ifndef _VLC_MEDIACONTROL_INTERNAL_H
#define _VLC_MEDIACONTROL_INTERNAL_H 1
# ifdef __cplusplus
extern "C" {
# endif
#include <vlc/vlc.h>
#include <vlc/mediacontrol_structures.h>
#include <vlc/libvlc_structures.h>
#include <vlc/libvlc.h>
struct mediacontrol_Instance {
libvlc_instance_t * p_instance;
libvlc_media_player_t * p_media_player;
};
libvlc_time_t private_mediacontrol_unit_convert( libvlc_media_player_t *p_media_player,
mediacontrol_PositionKey from,
mediacontrol_PositionKey to,
int64_t value );
libvlc_time_t private_mediacontrol_position2microsecond( libvlc_media_player_t *p_media_player,
const mediacontrol_Position *pos );
/**
* Allocate a RGBPicture structure.
* \param datasize: the size of the data
*/
mediacontrol_RGBPicture *private_mediacontrol_RGBPicture__alloc( int datasize );
mediacontrol_RGBPicture *private_mediacontrol_createRGBPicture( int, int, long, int64_t l_date, char *, int);
#define RAISE( c, m ) if( exception ) { exception->code = c; \
exception->message = strdup(m); }
#define RAISE_NULL( c, m ) do{ RAISE( c, m ); return NULL; } while(0)
#define RAISE_VOID( c, m ) do{ RAISE( c, m ); return; } while(0)
#define HANDLE_LIBVLC_EXCEPTION_VOID( e ) if( libvlc_exception_raised( e ) ) { \
RAISE( mediacontrol_InternalException, libvlc_errmsg()); \
libvlc_exception_clear( e ); \
return; }
#define HANDLE_LIBVLC_EXCEPTION_NULL( e ) if( libvlc_exception_raised( e ) ) { \
RAISE( mediacontrol_InternalException, libvlc_errmsg()); \
libvlc_exception_clear( e ); \
return NULL; }
#define HANDLE_LIBVLC_EXCEPTION_ZERO( e ) if( libvlc_exception_raised( e ) ) { \
RAISE( mediacontrol_InternalException, libvlc_errmsg()); \
libvlc_exception_clear( e ); \
return 0; }
# ifdef __cplusplus
}
# endif
#endif
bindings/mediacontrol/mediacontrol_structures.h deleted 100644 → 0
View file @ e848e444
/*****************************************************************************
* mediacontrol_structures.h: global header for mediacontrol
*****************************************************************************
* Copyright (C) 2005-2008 the VideoLAN team
* $Id$
*
* Authors: Olivier Aubert <olivier.aubert@liris.univ-lyon1.fr>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (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
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU 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.
*****************************************************************************/
/**
* \file
* This file defines libvlc mediacontrol_* data structures
*/
/**
* \defgroup mediacontrol_structures MediaControl Structures
* Data structures used in the MediaControl API.
*
* @{
*/
#ifndef VLC_CONTROL_STRUCTURES_H
#define VLC_CONTROL_STRUCTURES_H 1
# ifdef __cplusplus
extern "C" {
# endif
#include <stdint.h>
/**
* A position may have different origins:
* - absolute counts from the movie start
* - relative counts from the current position
* - modulo counts from the current position and wraps at the end of the movie
*/
typedef enum {
mediacontrol_AbsolutePosition,
mediacontrol_RelativePosition,
mediacontrol_ModuloPosition
} mediacontrol_PositionOrigin;
/**
* Units available in mediacontrol Positions
* - ByteCount number of bytes
* - SampleCount number of frames
* - MediaTime time in milliseconds
*/
typedef enum {
mediacontrol_ByteCount,
mediacontrol_SampleCount,
mediacontrol_MediaTime
} mediacontrol_PositionKey;
/**
* Possible player status
* Note the order of these enums must match exactly the order of
* libvlc_state_t and input_state_e enums.
*/
typedef enum {
mediacontrol_UndefinedStatus=0, mediacontrol_InitStatus,
mediacontrol_BufferingStatus, mediacontrol_PlayingStatus,
mediacontrol_PauseStatus, mediacontrol_StopStatus,
mediacontrol_EndStatus, mediacontrol_ErrorStatus,
} mediacontrol_PlayerStatus;
/**
* MediaControl Position
*/
typedef struct {
mediacontrol_PositionOrigin origin;
mediacontrol_PositionKey key;
int64_t value;
} mediacontrol_Position;
/**
* RGBPicture structure
* This generic structure holds a picture in an encoding specified by type.
*/
typedef struct {
int width;
int height;
uint32_t type;
int64_t date;
int size;
char *data;
} mediacontrol_RGBPicture;
/**
* Playlist sequence
* A simple list of strings.
*/
typedef struct {
int size;
char **data;
} mediacontrol_PlaylistSeq;
typedef struct {
int code;
char *message;
} mediacontrol_Exception;
/**
* Exception codes
*/
#define mediacontrol_PositionKeyNotSupported 1
#define mediacontrol_PositionOriginNotSupported 2
#define mediacontrol_InvalidPosition 3
#define mediacontrol_PlaylistException 4
#define mediacontrol_InternalException 5
/**
* Stream information
* This structure allows to quickly get various information about the stream.
*/
typedef struct {
mediacontrol_PlayerStatus streamstatus;
char *url; /* The URL of the current media stream */
int64_t position; /* actual location in the stream (in ms) */
int64_t length; /* total length of the stream (in ms) */
} mediacontrol_StreamInformation;
# ifdef __cplusplus
}
# endif
#endif
/** @} */
bindings/mediacontrol/mediacontrol_util.c deleted 100644 → 0
View file @ e848e444
/*****************************************************************************
* mediacontrol_util.c: Utility functions and exceptions management
*****************************************************************************
* Copyright (C) 2005 the VideoLAN team
* $Id$
*
* Authors: Olivier Aubert <olivier.aubert@liris.univ-lyon1.fr>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (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
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU 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.
*****************************************************************************/
#ifdef HAVE_CONFIG_H
# include "config.h"
#endif
#include "mediacontrol_internal.h"
#include <vlc/mediacontrol.h>
#include <vlc_common.h>
#include <vlc_vout.h>
#include <vlc_osd.h>
#include <stdlib.h> /* malloc(), free() */
#include <string.h>
#include <stdio.h>
#ifdef HAVE_UNISTD_H
# include <unistd.h>
#endif
#include <sys/types.h>
libvlc_time_t private_mediacontrol_unit_convert( libvlc_media_player_t *p_media_player,
mediacontrol_PositionKey from,
mediacontrol_PositionKey to,
int64_t value )
{
if( to == from )
return value;
if( !p_media_player )
return 0;
switch( from )
{
case mediacontrol_MediaTime:
if( to == mediacontrol_ByteCount )
{
/* FIXME Unsupported */
/* vlc < 0.8 API */
/* return value * 50 * p_input->stream.i_mux_rate / 1000; */
return 0;
}
if( to == mediacontrol_SampleCount )
{
double f_fps;
f_fps = libvlc_media_player_get_rate( p_media_player );
if( f_fps < 0 )
return 0;
else
return( value * f_fps / 1000.0 );
}
/* Cannot happen */
/* See http://catb.org/~esr/jargon/html/entry/can-t-happen.html */
break;
case mediacontrol_SampleCount:
{
double f_fps;
f_fps = libvlc_media_player_get_rate( p_media_player );
if( f_fps < 0 )
return 0;
if( to == mediacontrol_ByteCount )
{
/* FIXME */
/* vlc < 0.8 API */
/* return ( int64_t )( value * 50 * p_input->stream.i_mux_rate / f_fps ); */
return 0;
}
if( to == mediacontrol_MediaTime )
return( int64_t )( value * 1000.0 / ( double )f_fps );
/* Cannot happen */
break;
}
case mediacontrol_ByteCount:
/* FIXME */
return 0;
}
/* Cannot happen */
return 0;
}
/* Converts a mediacontrol_Position into a time in microseconds in
movie clock time */
libvlc_time_t
private_mediacontrol_position2microsecond( libvlc_media_player_t * p_media_player,
const mediacontrol_Position * pos )
{
switch( pos->origin )
{
case mediacontrol_AbsolutePosition:
return ( 1000 * private_mediacontrol_unit_convert( p_media_player,
pos->key, /* from */
mediacontrol_MediaTime, /* to */
pos->value ) );
break;
case mediacontrol_RelativePosition:
{
libvlc_time_t l_time = 0;
libvlc_time_t l_pos = 0;
l_time = libvlc_media_player_get_time( p_media_player );
/* Ignore exception, we will assume a 0 time value */
l_pos = private_mediacontrol_unit_convert( p_media_player,
pos->key,
mediacontrol_MediaTime,
pos->value );
return 1000 * ( l_time + l_pos );
break;
}
case mediacontrol_ModuloPosition:
{
libvlc_time_t l_time = 0;
libvlc_time_t l_length = 0;
libvlc_time_t l_pos = 0;
l_length = libvlc_media_player_get_length( p_media_player );
if( l_length <= 0 )
return 0;
l_time = libvlc_media_player_get_time( p_media_player );
/* Ignore exception, we will assume a 0 time value */
l_pos = private_mediacontrol_unit_convert( p_media_player,
pos->key,
mediacontrol_MediaTime,
pos->value );
return 1000 * ( ( l_time + l_pos ) % l_length );
break;
}
}
return 0;
}
void
mediacontrol_RGBPicture__free( mediacontrol_RGBPicture* pic )
{
if( pic )
{
free( pic->data );
free( pic );
}
}
void
mediacontrol_StreamInformation__free( mediacontrol_StreamInformation* p_si )
{
if( p_si )
{
free( p_si->url );
free( p_si );
}
}
mediacontrol_Exception*
mediacontrol_exception_create( void )
{
mediacontrol_Exception* exception;
exception = ( mediacontrol_Exception* )malloc( sizeof( mediacontrol_Exception ) );
mediacontrol_exception_init( exception );
return exception;
}
void
mediacontrol_exception_init( mediacontrol_Exception *exception )
{
if( exception )
{
exception->code = 0;
exception->message = NULL;
}
}
void
mediacontrol_exception_cleanup( mediacontrol_Exception *exception )
{
if( exception )
free( exception->message );
}
void
mediacontrol_exception_free( mediacontrol_Exception *exception )
{
mediacontrol_exception_cleanup( exception );
free( exception );
}
/**
* Allocates and initializes a mediacontrol_RGBPicture object.
*
* @param i_width: picture width
* @param i_height: picture width
* @param i_chroma: picture chroma
* @param l_date: picture timestamp
* @param p_data: pointer to the data. The data will be directly used, not copied.
* @param i_datasize: data size in bytes
*
* @return the new object, or NULL on error.
*/
mediacontrol_RGBPicture*
private_mediacontrol_createRGBPicture( int i_width, int i_height, long i_chroma, int64_t l_date,
char* p_data, int i_datasize )
{
mediacontrol_RGBPicture *retval;
retval = ( mediacontrol_RGBPicture * )malloc( sizeof( mediacontrol_RGBPicture ) );
if( retval )
{
retval->width = i_width;
retval->height = i_height;
retval->type = i_chroma;
retval->date = l_date;
retval->size = i_datasize;
retval->data = p_data;
}
return retval;
}
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment