videolan
/
vlc
mirror of https://gitea.goldendeliverer.com/videolan/vlc.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
Browse Source

Remove mediacontrol bindings 

They are old, broken and not up-to-date
pull/2/head
Jean-Baptiste Kempf 14 years ago
parent
e848e4443b
commit
01fad0ca83
7 changed files with 0 additions and 1499 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 29
      bindings/mediacontrol/libmediacontrol.sym
  2. 342
      bindings/mediacontrol/mediacontrol.h
  3. 286
      bindings/mediacontrol/mediacontrol_audio_video.c
  4. 367
      bindings/mediacontrol/mediacontrol_core.c
  5. 83
      bindings/mediacontrol/mediacontrol_internal.h
  6. 144
      bindings/mediacontrol/mediacontrol_structures.h
  7. 248
      bindings/mediacontrol/mediacontrol_util.c

29
bindings/mediacontrol/libmediacontrol.sym
View File

@ -1,29 +0,0 @@
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

342
bindings/mediacontrol/mediacontrol.h
View File

@ -1,342 +0,0 @@
/*****************************************************************************
* 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
/** @} */

286
bindings/mediacontrol/mediacontrol_audio_video.c
View File

@ -1,286 +0,0 @@
/*****************************************************************************
* 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 );
}

367
bindings/mediacontrol/mediacontrol_core.c
View File

@ -1,367 +0,0 @@
/*****************************************************************************
* 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;
}

83
bindings/mediacontrol/mediacontrol_internal.h
View File

@ -1,83 +0,0 @@
/*****************************************************************************
* 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

144
bindings/mediacontrol/mediacontrol_structures.h
View File

@ -1,144 +0,0 @@
/*****************************************************************************
* 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
/** @} */

248
bindings/mediacontrol/mediacontrol_util.c
View File

@ -1,248 +0,0 @@
/*****************************************************************************
* 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;
}
Write Preview
Loading…
Cancel
Save