home *** CD-ROM | disk | FTP | other *** search
/ Maximum CD 2009 May / maximum-cd-2009-05.iso / DiscContents / vlc-0.9.8a-win32.exe / sdk / include / vlc / plugins / vlc_input.h < prev    next >
Encoding:
C/C++ Source or Header  |  2008-12-06  |  22.0 KB  |  557 lines
  1. /*****************************************************************************
  2.  * vlc_input.h: Core input structures
  3.  *****************************************************************************
  4.  * Copyright (C) 1999-2006 the VideoLAN team
  5.  * $Id: f97d196061c900d61048b5c98437724b71056d67 $
  6.  *
  7.  * Authors: Christophe Massiot <massiot@via.ecp.fr>
  8.  *          Laurent Aimar <fenrir@via.ecp.fr>
  9.  *
  10.  * This program is free software; you can redistribute it and/or modify
  11.  * it under the terms of the GNU General Public License as published by
  12.  * the Free Software Foundation; either version 2 of the License, or
  13.  * (at your option) any later version.
  14.  *
  15.  * This program is distributed in the hope that it will be useful,
  16.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18.  * GNU General Public License for more details.
  19.  *
  20.  * You should have received a copy of the GNU General Public License
  21.  * along with this program; if not, write to the Free Software
  22.  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
  23.  *****************************************************************************/
  24.  
  25. /* __ is need because conflict with <vlc/input.h> */
  26. #ifndef VLC__INPUT_H
  27. #define VLC__INPUT_H 1
  28.  
  29. /**
  30.  * \file
  31.  * This file defines functions, structures and enums for input objects in vlc
  32.  */
  33.  
  34. #include <vlc_es.h>
  35. #include <vlc_meta.h>
  36. #include <vlc_epg.h>
  37. #include <vlc_events.h>
  38.  
  39. #include <string.h>                                     /* strcasestr() */
  40.  
  41. struct vlc_meta_t;
  42.  
  43. /*****************************************************************************
  44.  * input_item_t: Describes an input and is used to spawn input_thread_t objects
  45.  *****************************************************************************/
  46. struct info_t
  47. {
  48.     char *psz_name;            /**< Name of this info */
  49.     char *psz_value;           /**< Value of the info */
  50. };
  51.  
  52. struct info_category_t
  53. {
  54.     char   *psz_name;      /**< Name of this category */
  55.     int    i_infos;        /**< Number of infos in the category */
  56.     struct info_t **pp_infos;     /**< Pointer to an array of infos */
  57. };
  58.  
  59. struct input_item_t
  60. {
  61.     VLC_GC_MEMBERS
  62.     int        i_id;                 /**< Identifier of the item */
  63.  
  64.     char       *psz_name;            /**< text describing this item */
  65.     char       *psz_uri;             /**< mrl of this item */
  66.     bool       b_fixed_name;        /**< Can the interface change the name ?*/
  67.  
  68.     int        i_options;            /**< Number of input options */
  69.     char       **ppsz_options;       /**< Array of input options */
  70.     uint8_t    *optflagv;            /**< Some flags of input options */
  71.     unsigned   optflagc;
  72.  
  73.     mtime_t    i_duration;           /**< Duration in milliseconds*/
  74.  
  75.     uint8_t    i_type;               /**< Type (file, disc, ...) */
  76.     bool b_prefers_tree;             /**< Do we prefer being displayed as tree*/
  77.  
  78.     int        i_categories;         /**< Number of info categories */
  79.     info_category_t **pp_categories; /**< Pointer to the first info category */
  80.  
  81.     int         i_es;                /**< Number of es format descriptions */
  82.     es_format_t **es;                /**< Es formats */
  83.  
  84.     input_stats_t *p_stats;          /**< Statistics */
  85.     int           i_nb_played;       /**< Number of times played */
  86.  
  87.     bool          b_error_when_reading;       /**< Error When Reading */
  88.  
  89.     vlc_meta_t *p_meta;
  90.  
  91.     vlc_event_manager_t event_manager;
  92.  
  93.     vlc_mutex_t lock;                 /**< Lock for the item */
  94. };
  95.  
  96. #define ITEM_TYPE_UNKNOWN       0
  97. #define ITEM_TYPE_FILE          1
  98. #define ITEM_TYPE_DIRECTORY     2
  99. #define ITEM_TYPE_DISC          3
  100. #define ITEM_TYPE_CDDA          4
  101. #define ITEM_TYPE_CARD          5
  102. #define ITEM_TYPE_NET           6
  103. #define ITEM_TYPE_PLAYLIST      7
  104. #define ITEM_TYPE_NODE          8
  105. #define ITEM_TYPE_NUMBER        9
  106.  
  107. VLC_EXPORT( void, input_item_CopyOptions, ( input_item_t *p_parent, input_item_t *p_child ) );
  108. VLC_EXPORT( void, input_item_SetName, ( input_item_t *p_item, const char *psz_name ) );
  109.  
  110. /* This won't hold the item, but can tell to interested third parties
  111.  * Like the playlist, that there is a new sub item. With this design
  112.  * It is not the input item's responsability to keep all the ref of
  113.  * the input item children. */
  114. VLC_EXPORT( void, input_item_AddSubItem, ( input_item_t *p_parent, input_item_t *p_child ) );
  115.  
  116.  
  117. /* Flags handled past input_item_AddOpt() */
  118. #define VLC_INPUT_OPTION_TRUSTED 0x2
  119.  
  120. /* Flags handled within input_item_AddOpt() */
  121. #define VLC_INPUT_OPTION_UNIQUE  0x100
  122.  
  123. VLC_EXPORT( int, input_item_AddOpt, ( input_item_t *, const char *str, unsigned flags ) );
  124. VLC_EXPORT( int, input_item_AddOption, (input_item_t *item, const char *str) );
  125. VLC_EXPORT( int ,input_item_AddOption, (input_item_t *item, const char *str) );
  126. VLC_EXPORT( bool,input_item_HasErrorWhenReading, (input_item_t *item) );
  127. VLC_EXPORT( void, input_item_SetMeta, ( input_item_t *p_i, vlc_meta_type_t meta_type, const char *psz_val ));
  128.  
  129. VLC_EXPORT( bool,input_item_HasErrorWhenReading, (input_item_t *item) );
  130.  
  131. VLC_EXPORT( bool,input_item_MetaMatch, ( input_item_t *p_i, vlc_meta_type_t meta_type, const char *psz ) );
  132. VLC_EXPORT( char *, input_item_GetMeta, ( input_item_t *p_i, vlc_meta_type_t meta_type ) );
  133. VLC_EXPORT( char *, input_item_GetName, ( input_item_t * p_i ) );
  134. VLC_EXPORT( char *, input_item_GetURI, ( input_item_t * p_i ) );
  135. VLC_EXPORT( void,   input_item_SetURI, ( input_item_t * p_i, char * psz_uri ));
  136. VLC_EXPORT(mtime_t, input_item_GetDuration, ( input_item_t * p_i ) );
  137. VLC_EXPORT( void,   input_item_SetDuration, ( input_item_t * p_i, mtime_t i_duration ));
  138. VLC_EXPORT( bool,   input_item_IsPreparsed, ( input_item_t *p_i ));
  139. VLC_EXPORT( bool,   input_item_IsArtFetched, ( input_item_t *p_i ));
  140. VLC_EXPORT( const vlc_meta_t *, input_item_GetMetaObject, ( input_item_t *p_i ));
  141. VLC_EXPORT( void,   input_item_MetaMerge, ( input_item_t *p_i, const vlc_meta_t * p_new_meta ));
  142.  
  143.  
  144. #define input_item_SetTitle( item, b )       input_item_SetMeta( item, vlc_meta_Title, b )
  145. #define input_item_SetArtist( item, b )      input_item_SetMeta( item, vlc_meta_Artist, b )
  146. #define input_item_SetGenre( item, b )       input_item_SetMeta( item, vlc_meta_Genre, b )
  147. #define input_item_SetCopyright( item, b )   input_item_SetMeta( item, vlc_meta_Copyright, b )
  148. #define input_item_SetAlbum( item, b )       input_item_SetMeta( item, vlc_meta_Album, b )
  149. #define input_item_SetTrackNum( item, b )    input_item_SetMeta( item, vlc_meta_TrackNumber, b )
  150. #define input_item_SetDescription( item, b ) input_item_SetMeta( item, vlc_meta_Description, b )
  151. #define input_item_SetRating( item, b )      input_item_SetMeta( item, vlc_meta_Rating, b )
  152. #define input_item_SetDate( item, b )        input_item_SetMeta( item, vlc_meta_Date, b )
  153. #define input_item_SetSetting( item, b )     input_item_SetMeta( item, vlc_meta_Setting, b )
  154. #define input_item_SetURL( item, b )         input_item_SetMeta( item, vlc_meta_URL, b )
  155. #define input_item_SetLanguage( item, b )    input_item_SetMeta( item, vlc_meta_Language, b )
  156. #define input_item_SetNowPlaying( item, b )  input_item_SetMeta( item, vlc_meta_NowPlaying, b )
  157. #define input_item_SetPublisher( item, b )   input_item_SetMeta( item, vlc_meta_Publisher, b )
  158. #define input_item_SetEncodedBy( item, b )   input_item_SetMeta( item, vlc_meta_EncodedBy, b )
  159. #define input_item_SetArtURL( item, b )      input_item_SetMeta( item, vlc_meta_ArtworkURL, b )
  160. #define input_item_SetTrackID( item, b )     input_item_SetMeta( item, vlc_meta_TrackID, b )
  161.  
  162. #define input_item_GetTitle( item )          input_item_GetMeta( item, vlc_meta_Title )
  163. #define input_item_GetArtist( item )         input_item_GetMeta( item, vlc_meta_Artist )
  164. #define input_item_GetGenre( item )          input_item_GetMeta( item, vlc_meta_Genre )
  165. #define input_item_GetCopyright( item )      input_item_GetMeta( item, vlc_meta_Copyright )
  166. #define input_item_GetAlbum( item )          input_item_GetMeta( item, vlc_meta_Album )
  167. #define input_item_GetTrackNum( item )       input_item_GetMeta( item, vlc_meta_TrackNumber )
  168. #define input_item_GetDescription( item )    input_item_GetMeta( item, vlc_meta_Description )
  169. #define input_item_GetRating( item )         input_item_GetMeta( item, vlc_meta_Rating )
  170. #define input_item_GetDate( item )           input_item_GetMeta( item, vlc_meta_Date )
  171. #define input_item_GetGetting( item )        input_item_GetMeta( item, vlc_meta_Getting )
  172. #define input_item_GetURL( item )            input_item_GetMeta( item, vlc_meta_URL )
  173. #define input_item_GetLanguage( item )       input_item_GetMeta( item, vlc_meta_Language )
  174. #define input_item_GetNowPlaying( item )     input_item_GetMeta( item, vlc_meta_NowPlaying )
  175. #define input_item_GetPublisher( item )      input_item_GetMeta( item, vlc_meta_Publisher )
  176. #define input_item_GetEncodedBy( item )      input_item_GetMeta( item, vlc_meta_EncodedBy )
  177. #define input_item_GetArtURL( item )         input_item_GetMeta( item, vlc_meta_ArtworkURL )
  178. #define input_item_GetTrackID( item )        input_item_GetMeta( item, vlc_meta_TrackID )
  179. #define input_item_GetSetting( item )        input_item_GetMeta( item, vlc_meta_Setting )
  180.  
  181. VLC_EXPORT( char *, input_item_GetInfo, ( input_item_t *p_i, const char *psz_cat,const char *psz_name ) );
  182. VLC_EXPORT(int, input_item_AddInfo, ( input_item_t *p_i, const char *psz_cat, const char *psz_name, const char *psz_format, ... ) LIBVLC_FORMAT( 4, 5 ) );
  183.  
  184. #define input_item_New( a,b,c ) input_item_NewExt( a, b, c, 0, NULL, -1 )
  185. #define input_item_NewExt(a,b,c,d,e,f) __input_item_NewExt( VLC_OBJECT(a),b,c,d,e,f)
  186. VLC_EXPORT( input_item_t *, __input_item_NewExt, (vlc_object_t *, const char *, const char*, int, const char *const *, mtime_t i_duration )  );
  187. VLC_EXPORT( input_item_t *, input_item_NewWithType, ( vlc_object_t *, const char *, const char *e, int, const char *const *, mtime_t i_duration, int ) );
  188.  
  189. #define input_item_GetById(a,b) __input_item_GetById( VLC_OBJECT(a),b )
  190. VLC_EXPORT( input_item_t *, __input_item_GetById, (vlc_object_t *, int ) );
  191.  
  192. /*****************************************************************************
  193.  * Meta data helpers
  194.  *****************************************************************************/
  195. static inline void vlc_audio_replay_gain_MergeFromMeta( audio_replay_gain_t *p_dst,
  196.                                                         const vlc_meta_t *p_meta )
  197. {
  198.     char * psz_value;
  199.  
  200.     if( !p_meta )
  201.         return;
  202.  
  203.     if( (psz_value = (char *)vlc_dictionary_value_for_key( &p_meta->extra_tags, "REPLAYGAIN_TRACK_GAIN" )) ||
  204.         (psz_value = (char *)vlc_dictionary_value_for_key( &p_meta->extra_tags, "RG_RADIO" )) )
  205.     {
  206.         p_dst->pb_gain[AUDIO_REPLAY_GAIN_TRACK] = true;
  207.         p_dst->pf_gain[AUDIO_REPLAY_GAIN_TRACK] = atof( psz_value );
  208.     }
  209.     else if( (psz_value = (char *)vlc_dictionary_value_for_key( &p_meta->extra_tags, "REPLAYGAIN_TRACK_PEAK" )) ||
  210.              (psz_value = (char *)vlc_dictionary_value_for_key( &p_meta->extra_tags, "RG_PEAK" )) )
  211.     {
  212.         p_dst->pb_peak[AUDIO_REPLAY_GAIN_TRACK] = true;
  213.         p_dst->pf_peak[AUDIO_REPLAY_GAIN_TRACK] = atof( psz_value );
  214.     }
  215.     else if( (psz_value = (char *)vlc_dictionary_value_for_key( &p_meta->extra_tags, "REPLAYGAIN_ALBUM_GAIN" )) ||
  216.              (psz_value = (char *)vlc_dictionary_value_for_key( &p_meta->extra_tags, "RG_AUDIOPHILE" )) )
  217.     {
  218.         p_dst->pb_gain[AUDIO_REPLAY_GAIN_ALBUM] = true;
  219.         p_dst->pf_gain[AUDIO_REPLAY_GAIN_ALBUM] = atof( psz_value );
  220.     }
  221.     else if( (psz_value = (char *)vlc_dictionary_value_for_key( &p_meta->extra_tags, "REPLAYGAIN_ALBUM_PEAK" )) )
  222.     {
  223.         p_dst->pb_peak[AUDIO_REPLAY_GAIN_ALBUM] = true;
  224.         p_dst->pf_peak[AUDIO_REPLAY_GAIN_ALBUM] = atof( psz_value );
  225.     }
  226. }
  227.  
  228. /*****************************************************************************
  229.  * Seek point: (generalisation of chapters)
  230.  *****************************************************************************/
  231. struct seekpoint_t
  232. {
  233.     int64_t i_byte_offset;
  234.     int64_t i_time_offset;
  235.     char    *psz_name;
  236.     int     i_level;
  237. };
  238.  
  239. static inline seekpoint_t *vlc_seekpoint_New( void )
  240. {
  241.     seekpoint_t *point = (seekpoint_t*)malloc( sizeof( seekpoint_t ) );
  242.     point->i_byte_offset =
  243.     point->i_time_offset = -1;
  244.     point->i_level = 0;
  245.     point->psz_name = NULL;
  246.     return point;
  247. }
  248.  
  249. static inline void vlc_seekpoint_Delete( seekpoint_t *point )
  250. {
  251.     if( !point ) return;
  252.     free( point->psz_name );
  253.     free( point );
  254. }
  255.  
  256. static inline seekpoint_t *vlc_seekpoint_Duplicate( seekpoint_t *src )
  257. {
  258.     seekpoint_t *point = vlc_seekpoint_New();
  259.     if( src->psz_name ) point->psz_name = strdup( src->psz_name );
  260.     point->i_time_offset = src->i_time_offset;
  261.     point->i_byte_offset = src->i_byte_offset;
  262.     return point;
  263. }
  264.  
  265. /*****************************************************************************
  266.  * Title:
  267.  *****************************************************************************/
  268. typedef struct
  269. {
  270.     char        *psz_name;
  271.  
  272.     bool        b_menu;      /* Is it a menu or a normal entry */
  273.  
  274.     int64_t     i_length;   /* Length(microsecond) if known, else 0 */
  275.     int64_t     i_size;     /* Size (bytes) if known, else 0 */
  276.  
  277.     /* Title seekpoint */
  278.     int         i_seekpoint;
  279.     seekpoint_t **seekpoint;
  280.  
  281. } input_title_t;
  282.  
  283. static inline input_title_t *vlc_input_title_New(void)
  284. {
  285.     input_title_t *t = (input_title_t*)malloc( sizeof( input_title_t ) );
  286.  
  287.     t->psz_name = NULL;
  288.     t->b_menu = false;
  289.     t->i_length = 0;
  290.     t->i_size   = 0;
  291.     t->i_seekpoint = 0;
  292.     t->seekpoint = NULL;
  293.  
  294.     return t;
  295. }
  296.  
  297. static inline void vlc_input_title_Delete( input_title_t *t )
  298. {
  299.     int i;
  300.     if( t == NULL )
  301.         return;
  302.  
  303.     free( t->psz_name );
  304.     for( i = 0; i < t->i_seekpoint; i++ )
  305.     {
  306.         free( t->seekpoint[i]->psz_name );
  307.         free( t->seekpoint[i] );
  308.     }
  309.     free( t->seekpoint );
  310.     free( t );
  311. }
  312.  
  313. static inline input_title_t *vlc_input_title_Duplicate( input_title_t *t )
  314. {
  315.     input_title_t *dup = vlc_input_title_New( );
  316.     int i;
  317.  
  318.     if( t->psz_name ) dup->psz_name = strdup( t->psz_name );
  319.     dup->b_menu      = t->b_menu;
  320.     dup->i_length    = t->i_length;
  321.     dup->i_size      = t->i_size;
  322.     dup->i_seekpoint = t->i_seekpoint;
  323.     if( t->i_seekpoint > 0 )
  324.     {
  325.         dup->seekpoint = (seekpoint_t**)calloc( t->i_seekpoint,
  326.                                                 sizeof(seekpoint_t*) );
  327.  
  328.         for( i = 0; i < t->i_seekpoint; i++ )
  329.         {
  330.             dup->seekpoint[i] = vlc_seekpoint_Duplicate( t->seekpoint[i] );
  331.         }
  332.     }
  333.  
  334.     return dup;
  335. }
  336.  
  337. /*****************************************************************************
  338.  * Attachments
  339.  *****************************************************************************/
  340. struct input_attachment_t
  341. {
  342.     char *psz_name;
  343.     char *psz_mime;
  344.     char *psz_description;
  345.  
  346.     int  i_data;
  347.     void *p_data;
  348. };
  349.  
  350. static inline input_attachment_t *vlc_input_attachment_New( const char *psz_name,
  351.                                                             const char *psz_mime,
  352.                                                             const char *psz_description,
  353.                                                             const void *p_data,
  354.                                                             int i_data )
  355. {
  356.     input_attachment_t *a =
  357.         (input_attachment_t*)malloc( sizeof(input_attachment_t) );
  358.     if( !a )
  359.         return NULL;
  360.     a->psz_name = strdup( psz_name ? psz_name : "" );
  361.     a->psz_mime = strdup( psz_mime ? psz_mime : "" );
  362.     a->psz_description = strdup( psz_description ? psz_description : "" );
  363.     a->i_data = i_data;
  364.     a->p_data = NULL;
  365.     if( i_data > 0 )
  366.     {
  367.         a->p_data = malloc( i_data );
  368.         if( a->p_data && p_data )
  369.             memcpy( a->p_data, p_data, i_data );
  370.     }
  371.     return a;
  372. }
  373. static inline input_attachment_t *vlc_input_attachment_Duplicate( const input_attachment_t *a )
  374. {
  375.     return vlc_input_attachment_New( a->psz_name, a->psz_mime, a->psz_description,
  376.                                      a->p_data, a->i_data );
  377. }
  378. static inline void vlc_input_attachment_Delete( input_attachment_t *a )
  379. {
  380.     if( !a )
  381.         return;
  382.     free( a->psz_name );
  383.     free( a->psz_mime );
  384.     free( a->psz_description );
  385.     free( a->p_data );
  386.     free( a );
  387. }
  388.  
  389. /*****************************************************************************
  390.  * input defines/constants.
  391.  *****************************************************************************/
  392.  
  393. /* "state" value */
  394. /* NOTE: you need to update ppsz_input_state in the RC interface
  395.  * if you modify this list. */
  396. typedef enum input_state_e
  397. {
  398.     INIT_S = 0,
  399.     OPENING_S,
  400.     BUFFERING_S,
  401.     PLAYING_S,
  402.     PAUSE_S,
  403.     STOP_S,
  404.     FORWARD_S,
  405.     BACKWARD_S,
  406.     END_S,
  407.     ERROR_S,
  408. } input_state_e;
  409.  
  410. /* "rate" default, min/max
  411.  * A rate below 1000 plays the movie faster,
  412.  * A rate above 1000 plays the movie slower.
  413.  */
  414. #define INPUT_RATE_DEFAULT  1000
  415. #define INPUT_RATE_MIN       125            /* Up to 8/1 */
  416. #define INPUT_RATE_MAX     32000            /* Up to 1/32 */
  417.  
  418. /* i_update field of access_t/demux_t */
  419. #define INPUT_UPDATE_NONE       0x0000
  420. #define INPUT_UPDATE_SIZE       0x0001
  421. #define INPUT_UPDATE_TITLE      0x0010
  422. #define INPUT_UPDATE_SEEKPOINT  0x0020
  423. #define INPUT_UPDATE_META       0x0040
  424.  
  425. /* Input control XXX: internal */
  426. #define INPUT_CONTROL_FIFO_SIZE    100
  427.  
  428. /** Get the input item for an input thread */
  429. VLC_EXPORT(input_item_t*, input_GetItem, (input_thread_t*));
  430.  
  431. typedef struct input_thread_private_t input_thread_private_t;
  432.  
  433. /**
  434.  * Main structure representing an input thread. This structure is mostly
  435.  * private. The only public fields are READ-ONLY. You must use the helpers
  436.  * to modify them
  437.  */
  438. struct input_thread_t
  439. {
  440.     VLC_COMMON_MEMBERS;
  441.  
  442.     bool  b_eof;
  443.     bool b_preparsing;
  444.  
  445.     int i_state;
  446.     bool b_can_pace_control;
  447.     int64_t     i_time;     /* Current time */
  448.  
  449.     /* Internal caching common to all inputs */
  450.     mtime_t i_pts_delay;
  451.  
  452.     /* All other data is input_thread is PRIVATE. You can't access it
  453.      * outside of src/input */
  454.     input_thread_private_t *p;
  455. };
  456.  
  457. /*****************************************************************************
  458.  * Prototypes
  459.  *****************************************************************************/
  460.  
  461. /* input_CreateThread
  462.  * Release the returned input_thread_t using vlc_object_release() */
  463. #define input_CreateThread(a,b) __input_CreateThread(VLC_OBJECT(a),b)
  464. VLC_EXPORT( input_thread_t *, __input_CreateThread, ( vlc_object_t *, input_item_t * ) );
  465.  
  466. #define input_Preparse(a,b) __input_Preparse(VLC_OBJECT(a),b)
  467. VLC_EXPORT( int, __input_Preparse, ( vlc_object_t *, input_item_t * ) );
  468.  
  469. #define input_Read(a,b,c) __input_Read(VLC_OBJECT(a),b, c)
  470. VLC_EXPORT( int, __input_Read, ( vlc_object_t *, input_item_t *, bool ) );
  471. VLC_EXPORT( void,             input_StopThread,     ( input_thread_t * ) );
  472.  
  473. enum input_query_e
  474. {
  475.     /* input variable "position" */
  476.     INPUT_GET_POSITION,         /* arg1= double *       res=    */
  477.     INPUT_SET_POSITION,         /* arg1= double         res=can fail    */
  478.  
  479.     /* input variable "length" */
  480.     INPUT_GET_LENGTH,           /* arg1= int64_t *      res=can fail    */
  481.  
  482.     /* input variable "time" */
  483.     INPUT_GET_TIME,             /* arg1= int64_t *      res=    */
  484.     INPUT_SET_TIME,             /* arg1= int64_t        res=can fail    */
  485.  
  486.     /* input variable "rate" (1 is DEFAULT_RATE) */
  487.     INPUT_GET_RATE,             /* arg1= int *          res=    */
  488.     INPUT_SET_RATE,             /* arg1= int            res=can fail    */
  489.  
  490.     /* input variable "state" */
  491.     INPUT_GET_STATE,            /* arg1= int *          res=    */
  492.     INPUT_SET_STATE,            /* arg1= int            res=can fail    */
  493.  
  494.     /* input variable "audio-delay" and "sub-delay" */
  495.     INPUT_GET_AUDIO_DELAY,      /* arg1 = int* res=can fail */
  496.     INPUT_SET_AUDIO_DELAY,      /* arg1 = int  res=can fail */
  497.     INPUT_GET_SPU_DELAY,        /* arg1 = int* res=can fail */
  498.     INPUT_SET_SPU_DELAY,        /* arg1 = int  res=can fail */
  499.  
  500.     /* Meta datas */
  501.     INPUT_ADD_INFO,   /* arg1= char* arg2= char* arg3=...     res=can fail */
  502.     INPUT_GET_INFO,   /* arg1= char* arg2= char* arg3= char** res=can fail */
  503.     INPUT_DEL_INFO,   /* arg1= char* arg2= char*              res=can fail */
  504.     INPUT_SET_NAME,   /* arg1= char* res=can fail    */
  505.  
  506.     /* Input config options */
  507.     INPUT_ADD_OPTION,      /* arg1= char * arg2= char *  res=can fail*/
  508.  
  509.     /* Input properties */
  510.     INPUT_GET_BYTE_POSITION,     /* arg1= int64_t *       res=    */
  511.     INPUT_SET_BYTE_SIZE,         /* arg1= int64_t *       res=    */
  512.     INPUT_GET_VIDEO_FPS,         /* arg1= double *        res=can fail */
  513.  
  514.     /* bookmarks */
  515.     INPUT_GET_BOOKMARKS,   /* arg1= seekpoint_t *** arg2= int * res=can fail */
  516.     INPUT_CLEAR_BOOKMARKS, /* res=can fail */
  517.     INPUT_ADD_BOOKMARK,    /* arg1= seekpoint_t *  res=can fail   */
  518.     INPUT_CHANGE_BOOKMARK, /* arg1= seekpoint_t * arg2= int * res=can fail   */
  519.     INPUT_DEL_BOOKMARK,    /* arg1= seekpoint_t *  res=can fail   */
  520.     INPUT_SET_BOOKMARK,    /* arg1= int  res=can fail    */
  521.  
  522.     /* Attachments */
  523.     INPUT_GET_ATTACHMENTS, /* arg1=input_attachment_t***, arg2=int*  res=can fail */
  524.     INPUT_GET_ATTACHMENT,  /* arg1=input_attachment_t**, arg2=char*  res=can fail */
  525.  
  526.     /* On the fly input slave */
  527.     INPUT_ADD_SLAVE        /* arg1= char * */
  528. };
  529.  
  530. VLC_EXPORT( int, input_vaControl,( input_thread_t *, int i_query, va_list  ) );
  531. VLC_EXPORT( int, input_Control,  ( input_thread_t *, int i_query, ...  ) );
  532.  
  533. static inline input_state_e input_GetState( input_thread_t * p_input )
  534. {
  535.     input_state_e state = INIT_S;
  536.     input_Control( p_input, INPUT_GET_STATE, &state );
  537.     return state;
  538. }
  539. VLC_EXPORT( decoder_t *, input_DecoderNew, ( input_thread_t *, es_format_t *, bool b_force_decoder ) );
  540. VLC_EXPORT( void, input_DecoderDelete, ( decoder_t * ) );
  541. VLC_EXPORT( void, input_DecoderDecode,( decoder_t *, block_t * ) );
  542.  
  543. VLC_EXPORT( bool, input_AddSubtitles, ( input_thread_t *, char *, bool ) );
  544.  
  545. VLC_EXPORT( vlc_event_manager_t *, input_get_event_manager, ( input_thread_t * ) );
  546.  
  547. /**
  548.  * This function allows to split a MRL into access, demux and path part.
  549.  *
  550.  *  You should not write into access and demux string as they may not point into
  551.  * the provided buffer.
  552.  *  The buffer provided by psz_dup will be modified.
  553.  */
  554. VLC_EXPORT( void, input_SplitMRL, ( const char **ppsz_access, const char **ppsz_demux, char **ppsz_path, char *psz_dup ) );
  555.  
  556. #endif
  557.