libvlc: Move input_item array from playlist to libvlc.
[vlc.git] / include / vlc_input.h
1 /*****************************************************************************
2  * vlc_input.h: Core input structures
3  *****************************************************************************
4  * Copyright (C) 1999-2006 the VideoLAN team
5  * $Id$
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 #if !defined( __LIBVLC__ )
26   #error You are not libvlc or one of its plugins. You cannot include this file
27 #endif
28
29 /* __ is need because conflict with <vlc/input.h> */
30 #ifndef _VLC__INPUT_H
31 #define _VLC__INPUT_H 1
32
33 #include <vlc_es.h>
34 #include <vlc_meta.h>
35 #include <vlc_epg.h>
36 #include <vlc_events.h>
37
38 #include <string.h>                                     /* strcasestr() */
39
40 struct vlc_meta_t;
41
42 /*****************************************************************************
43  * input_item_t: Describes an input and is used to spawn input_thread_t objects
44  *****************************************************************************/
45 struct info_t
46 {
47     char *psz_name;            /**< Name of this info */
48     char *psz_value;           /**< Value of the info */
49 };
50
51 struct info_category_t
52 {
53     char   *psz_name;      /**< Name of this category */
54     int    i_infos;        /**< Number of infos in the category */
55     struct info_t **pp_infos;     /**< Pointer to an array of infos */
56 };
57
58 struct input_item_t
59 {
60     VLC_GC_MEMBERS
61     int        i_id;                 /**< Identifier of the item */
62
63     char       *psz_name;            /**< text describing this item */
64     char       *psz_uri;             /**< mrl of this item */
65     vlc_bool_t  b_fixed_name;        /**< Can the interface change the name ?*/
66
67     int        i_options;            /**< Number of input options */
68     char       **ppsz_options;       /**< Array of input options */
69     uint8_t    *optflagv;            /**< Some flags of input options */
70     unsigned   optflagc;
71
72     mtime_t    i_duration;           /**< Duration in milliseconds*/
73
74     uint8_t    i_type;               /**< Type (file, disc, ...) */
75     vlc_bool_t b_prefers_tree;      /**< Do we prefer being displayed as tree*/
76
77     int        i_categories;         /**< Number of info categories */
78     info_category_t **pp_categories; /**< Pointer to the first info category */
79
80     int         i_es;                /**< Number of es format descriptions */
81     es_format_t **es;                /**< Es formats */
82
83     input_stats_t *p_stats;          /**< Statistics */
84     int           i_nb_played;       /**< Number of times played */
85
86     vlc_meta_t *p_meta;
87
88     vlc_event_manager_t event_manager;
89
90     vlc_mutex_t lock;                 /**< Lock for the item */
91 };
92
93 #define ITEM_TYPE_UNKNOWN       0
94 #define ITEM_TYPE_FILE          1
95 #define ITEM_TYPE_DIRECTORY     2
96 #define ITEM_TYPE_DISC          3
97 #define ITEM_TYPE_CDDA          4
98 #define ITEM_TYPE_CARD          5
99 #define ITEM_TYPE_NET           6
100 #define ITEM_TYPE_PLAYLIST      7
101 #define ITEM_TYPE_NODE          8
102 #define ITEM_TYPE_NUMBER        9
103
104 static inline void input_ItemCopyOptions( input_item_t *p_parent,
105                                           input_item_t *p_child )
106 {
107     int i;
108     for( i = 0 ; i< p_parent->i_options; i++ )
109     {
110         char *psz_option= strdup( p_parent->ppsz_options[i] );
111         if( !strcmp( psz_option, "meta-file" ) )
112         {
113             free( psz_option );
114             continue;
115         }
116         p_child->i_options++;
117         p_child->ppsz_options = (char **)realloc( p_child->ppsz_options,
118                                                   p_child->i_options *
119                                                   sizeof( char * ) );
120         p_child->ppsz_options[p_child->i_options-1] = psz_option;
121         p_child->optflagc++;
122         p_child->optflagv = (uint8_t *)realloc( p_child->optflagv,
123                                                 p_child->optflagc );
124         p_child->optflagv[p_child->optflagc - 1] = p_parent->optflagv[i];
125     }
126 }
127
128 static inline void input_item_SetName( input_item_t *p_item, const char *psz_name )
129 {
130     free( p_item->psz_name );
131     p_item->psz_name = strdup( psz_name );
132 }
133
134 /* This won't hold the item, but can tell to interested third parties
135  * Like the playlist, that there is a new sub item. With this design
136  * It is not the input item's responsability to keep all the ref of
137  * the input item children. */
138 static inline void input_ItemAddSubItem( input_item_t *p_parent,
139                                          input_item_t *p_child )
140 {
141     vlc_event_t event;
142
143     p_parent->i_type = ITEM_TYPE_PLAYLIST;
144
145     /* Notify interested third parties */
146     event.type = vlc_InputItemSubItemAdded;
147     event.u.input_item_subitem_added.p_new_child = p_child;
148     vlc_event_send( &p_parent->event_manager, &event );
149 }
150
151 /* Flags handled past input_ItemAddOpt() */
152 #define VLC_INPUT_OPTION_TRUSTED 0x2
153
154 /* Flags handled within input_ItemAddOpt() */
155 #define VLC_INPUT_OPTION_UNIQUE  0x100
156
157 VLC_EXPORT( int, input_ItemAddOpt, ( input_item_t *, const char *str, unsigned flags ) );
158
159 static inline
160 int input_ItemAddOption (input_item_t *item, const char *str)
161 {
162     return input_ItemAddOpt (item, str, VLC_INPUT_OPTION_TRUSTED);
163 }
164
165 static inline void input_ItemClean( input_item_t *p_i )
166 {
167     int i;
168
169     vlc_event_manager_fini( &p_i->event_manager );
170
171     free( p_i->psz_name );
172     free( p_i->psz_uri );
173     if( p_i->p_stats )
174     {
175         vlc_mutex_destroy( &p_i->p_stats->lock );
176         free( p_i->p_stats );
177     }
178
179     if( p_i->p_meta )
180         vlc_meta_Delete( p_i->p_meta );
181
182     for( i = 0; i < p_i->i_options; i++ )
183         free( p_i->ppsz_options[i] );
184     TAB_CLEAN( p_i->i_options, p_i->ppsz_options );
185     free( p_i->optflagv);
186
187     for( i = 0; i < p_i->i_es; i++ )
188     {
189         es_format_Clean( p_i->es[i] );
190         free( p_i->es[i] );
191     }
192     TAB_CLEAN( p_i->i_es, p_i->es );
193
194     for( i = 0; i < p_i->i_categories; i++ )
195     {
196         info_category_t *p_category = p_i->pp_categories[i];
197         int j;
198
199         for( j = 0; j < p_category->i_infos; j++ )
200         {
201             struct info_t *p_info = p_category->pp_infos[j];
202
203             free( p_info->psz_name);
204             free( p_info->psz_value );
205             free( p_info );
206         }
207         TAB_CLEAN( p_category->i_infos, p_category->pp_infos );
208
209         free( p_category->psz_name );
210         free( p_category );
211     }
212     TAB_CLEAN( p_i->i_categories, p_i->pp_categories );
213
214     vlc_mutex_destroy( &p_i->lock );
215 }
216
217 VLC_EXPORT( void, input_item_SetMeta, ( input_item_t *p_i, vlc_meta_type_t meta_type, const char *psz_val ));
218
219 static inline vlc_bool_t input_item_MetaMatch( input_item_t *p_i, vlc_meta_type_t meta_type, const char *psz )
220 {
221     vlc_mutex_lock( &p_i->lock );
222     if( !p_i->p_meta )
223     {
224         vlc_mutex_unlock( &p_i->lock );
225         return VLC_FALSE;
226     }
227     const char * meta = vlc_meta_Get( p_i->p_meta, meta_type );
228     vlc_bool_t ret = meta && strcasestr( meta, psz );
229     vlc_mutex_unlock( &p_i->lock );
230
231     return ret;
232 }
233
234 static inline char * input_item_GetMeta( input_item_t *p_i, vlc_meta_type_t meta_type )
235 {
236     char * psz = NULL;
237     vlc_mutex_lock( &p_i->lock );
238
239     if( !p_i->p_meta )
240     {
241         vlc_mutex_unlock( &p_i->lock );
242         return NULL;
243     }
244
245     if( vlc_meta_Get( p_i->p_meta, meta_type ) )
246         psz = strdup( vlc_meta_Get( p_i->p_meta, meta_type ) );
247
248     vlc_mutex_unlock( &p_i->lock );
249     return psz;
250 }
251
252 static inline char * input_item_GetName( input_item_t * p_i )
253 {
254     vlc_mutex_lock( &p_i->lock );
255     char *psz_s = p_i->psz_name ? strdup( p_i->psz_name ) : NULL;
256     vlc_mutex_unlock( &p_i->lock );
257     return psz_s;
258 }
259
260 static inline char * input_item_GetURI( input_item_t * p_i )
261 {
262     vlc_mutex_lock( &p_i->lock );
263     char *psz_s = p_i->psz_uri ? strdup( p_i->psz_uri ) : NULL;
264     vlc_mutex_unlock( &p_i->lock );
265     return psz_s;
266 }
267
268 static inline void input_item_SetURI( input_item_t * p_i, char * psz_uri )
269 {
270     vlc_mutex_lock( &p_i->lock );
271     free( p_i->psz_uri );
272     p_i->psz_uri = strdup( psz_uri );
273     vlc_mutex_unlock( &p_i->lock );
274 }
275
276 static inline mtime_t input_item_GetDuration( input_item_t * p_i )
277 {
278     vlc_mutex_lock( &p_i->lock );
279     mtime_t i_duration = p_i->i_duration;
280     vlc_mutex_unlock( &p_i->lock );
281     return i_duration;
282 }
283
284 static inline void input_item_SetDuration( input_item_t * p_i, mtime_t i_duration )
285 {
286     vlc_bool_t send_event = VLC_FALSE;
287
288     vlc_mutex_lock( &p_i->lock );
289     if( p_i->i_duration != i_duration )
290     {
291         p_i->i_duration = i_duration;
292         send_event = VLC_TRUE;
293     }
294     vlc_mutex_unlock( &p_i->lock );
295
296     if ( send_event == VLC_TRUE )
297     {
298         vlc_event_t event;
299         event.type = vlc_InputItemDurationChanged;
300         event.u.input_item_duration_changed.new_duration = i_duration;
301         vlc_event_send( &p_i->event_manager, &event );
302     }
303
304     return;
305 }
306
307
308 static inline vlc_bool_t input_item_IsPreparsed( input_item_t *p_i )
309 {
310     return p_i->p_meta ? p_i->p_meta->i_status & ITEM_PREPARSED : VLC_FALSE ;
311 }
312
313 static inline vlc_bool_t input_item_IsMetaFetched( input_item_t *p_i )
314 {
315     return p_i->p_meta ? p_i->p_meta->i_status & ITEM_META_FETCHED : VLC_FALSE ;
316 }
317
318
319 static inline vlc_bool_t input_item_IsArtFetched( input_item_t *p_i )
320 {
321     return p_i->p_meta ? p_i->p_meta->i_status & ITEM_ART_FETCHED : VLC_FALSE ;
322 }
323
324 static inline const vlc_meta_t * input_item_GetMetaObject( input_item_t *p_i )
325 {
326     if( !p_i->p_meta )
327         p_i->p_meta = vlc_meta_New();
328
329     return p_i->p_meta;
330 }
331
332 static inline void input_item_MetaMerge( input_item_t *p_i, const vlc_meta_t * p_new_meta )
333 {
334     if( !p_i->p_meta )
335         p_i->p_meta = vlc_meta_New();
336
337     vlc_meta_Merge( p_i->p_meta, p_new_meta );
338 }
339
340 #define input_item_SetTitle( item, b )       input_item_SetMeta( item, vlc_meta_Title, b )
341 #define input_item_SetArtist( item, b )      input_item_SetMeta( item, vlc_meta_Artist, b )
342 #define input_item_SetGenre( item, b )       input_item_SetMeta( item, vlc_meta_Genre, b )
343 #define input_item_SetCopyright( item, b )   input_item_SetMeta( item, vlc_meta_Copyright, b )
344 #define input_item_SetAlbum( item, b )       input_item_SetMeta( item, vlc_meta_Album, b )
345 #define input_item_SetTrackNum( item, b )    input_item_SetMeta( item, vlc_meta_TrackNumber, b )
346 #define input_item_SetDescription( item, b ) input_item_SetMeta( item, vlc_meta_Description, b )
347 #define input_item_SetRating( item, b )      input_item_SetMeta( item, vlc_meta_Rating, b )
348 #define input_item_SetDate( item, b )        input_item_SetMeta( item, vlc_meta_Date, b )
349 #define input_item_SetSetting( item, b )     input_item_SetMeta( item, vlc_meta_Setting, b )
350 #define input_item_SetURL( item, b )         input_item_SetMeta( item, vlc_meta_URL, b )
351 #define input_item_SetLanguage( item, b )    input_item_SetMeta( item, vlc_meta_Language, b )
352 #define input_item_SetNowPlaying( item, b )  input_item_SetMeta( item, vlc_meta_NowPlaying, b )
353 #define input_item_SetPublisher( item, b )   input_item_SetMeta( item, vlc_meta_Publisher, b )
354 #define input_item_SetEncodedBy( item, b )   input_item_SetMeta( item, vlc_meta_EncodedBy, b )
355 #define input_item_SetArtURL( item, b )      input_item_SetMeta( item, vlc_meta_ArtworkURL, b )
356 #define input_item_SetTrackID( item, b )     input_item_SetMeta( item, vlc_meta_TrackID, b )
357
358 #define input_item_GetTitle( item )          input_item_GetMeta( item, vlc_meta_Title )
359 #define input_item_GetArtist( item )         input_item_GetMeta( item, vlc_meta_Artist )
360 #define input_item_GetGenre( item )          input_item_GetMeta( item, vlc_meta_Genre )
361 #define input_item_GetCopyright( item )      input_item_GetMeta( item, vlc_meta_Copyright )
362 #define input_item_GetAlbum( item )          input_item_GetMeta( item, vlc_meta_Album )
363 #define input_item_GetTrackNum( item )       input_item_GetMeta( item, vlc_meta_TrackNumber )
364 #define input_item_GetDescription( item )    input_item_GetMeta( item, vlc_meta_Description )
365 #define input_item_GetRating( item )         input_item_GetMeta( item, vlc_meta_Rating )
366 #define input_item_GetDate( item )           input_item_GetMeta( item, vlc_meta_Date )
367 #define input_item_GetGetting( item )        input_item_GetMeta( item, vlc_meta_Getting )
368 #define input_item_GetURL( item )            input_item_GetMeta( item, vlc_meta_URL )
369 #define input_item_GetLanguage( item )       input_item_GetMeta( item, vlc_meta_Language )
370 #define input_item_GetNowPlaying( item )     input_item_GetMeta( item, vlc_meta_NowPlaying )
371 #define input_item_GetPublisher( item )      input_item_GetMeta( item, vlc_meta_Publisher )
372 #define input_item_GetEncodedBy( item )      input_item_GetMeta( item, vlc_meta_EncodedBy )
373 #define input_item_GetArtURL( item )         input_item_GetMeta( item, vlc_meta_ArtworkURL )
374 #define input_item_GetTrackID( item )        input_item_GetMeta( item, vlc_meta_TrackID )
375 #define input_item_GetSetting( item )        input_item_GetMeta( item, vlc_meta_Setting )
376
377 VLC_EXPORT( char *, input_ItemGetInfo, ( input_item_t *p_i, const char *psz_cat,const char *psz_name ) );
378 VLC_EXPORT(int, input_ItemAddInfo, ( input_item_t *p_i, const char *psz_cat, const char *psz_name, const char *psz_format, ... ) ATTRIBUTE_FORMAT( 4, 5 ) );
379
380 #define input_ItemNew( a,b,c ) input_ItemNewExt( a, b, c, 0, NULL, -1 )
381 #define input_ItemNewExt(a,b,c,d,e,f) __input_ItemNewExt( VLC_OBJECT(a),b,c,d,e,f)
382 VLC_EXPORT( input_item_t *, __input_ItemNewExt, (vlc_object_t *, const char *, const char*, int, const char *const *, mtime_t i_duration )  );
383 VLC_EXPORT( input_item_t *, input_ItemNewWithType, ( vlc_object_t *, const char *, const char *e, int, const char *const *, mtime_t i_duration, int ) );
384
385 #define input_ItemGetById(a,b) __input_ItemGetById( VLC_OBJECT(a),b )
386 VLC_EXPORT( input_item_t *, __input_ItemGetById, (vlc_object_t *, int ) );
387
388 /*****************************************************************************
389  * Meta data helpers
390  *****************************************************************************/
391 static inline void vlc_audio_replay_gain_MergeFromMeta( audio_replay_gain_t *p_dst,
392                                                         const vlc_meta_t *p_meta )
393 {
394     char * psz_value;
395
396     if( !p_meta )
397         return;
398
399     if( (psz_value = (char *)vlc_dictionary_value_for_key( &p_meta->extra_tags, "REPLAYGAIN_TRACK_GAIN" )) ||
400         (psz_value = (char *)vlc_dictionary_value_for_key( &p_meta->extra_tags, "RG_RADIO" )) )
401     {
402         p_dst->pb_gain[AUDIO_REPLAY_GAIN_TRACK] = VLC_TRUE;
403         p_dst->pf_gain[AUDIO_REPLAY_GAIN_TRACK] = atof( psz_value );
404     }
405     else if( (psz_value = (char *)vlc_dictionary_value_for_key( &p_meta->extra_tags, "REPLAYGAIN_TRACK_PEAK" )) ||
406              (psz_value = (char *)vlc_dictionary_value_for_key( &p_meta->extra_tags, "RG_PEAK" )) )
407     {
408         p_dst->pb_peak[AUDIO_REPLAY_GAIN_TRACK] = VLC_TRUE;
409         p_dst->pf_peak[AUDIO_REPLAY_GAIN_TRACK] = atof( psz_value );
410     }
411     else if( (psz_value = (char *)vlc_dictionary_value_for_key( &p_meta->extra_tags, "REPLAYGAIN_ALBUM_GAIN" )) ||
412              (psz_value = (char *)vlc_dictionary_value_for_key( &p_meta->extra_tags, "RG_AUDIOPHILE" )) )
413     {
414         p_dst->pb_gain[AUDIO_REPLAY_GAIN_ALBUM] = VLC_TRUE;
415         p_dst->pf_gain[AUDIO_REPLAY_GAIN_ALBUM] = atof( psz_value );
416     }
417     else if( (psz_value = (char *)vlc_dictionary_value_for_key( &p_meta->extra_tags, "REPLAYGAIN_ALBUM_PEAK" )) )
418     {
419         p_dst->pb_peak[AUDIO_REPLAY_GAIN_ALBUM] = VLC_TRUE;
420         p_dst->pf_peak[AUDIO_REPLAY_GAIN_ALBUM] = atof( psz_value );
421     }
422 }
423
424 /*****************************************************************************
425  * Seek point: (generalisation of chapters)
426  *****************************************************************************/
427 struct seekpoint_t
428 {
429     int64_t i_byte_offset;
430     int64_t i_time_offset;
431     char    *psz_name;
432     int     i_level;
433 };
434
435 static inline seekpoint_t *vlc_seekpoint_New( void )
436 {
437     seekpoint_t *point = (seekpoint_t*)malloc( sizeof( seekpoint_t ) );
438     point->i_byte_offset =
439     point->i_time_offset = -1;
440     point->i_level = 0;
441     point->psz_name = NULL;
442     return point;
443 }
444
445 static inline void vlc_seekpoint_Delete( seekpoint_t *point )
446 {
447     if( !point ) return;
448     free( point->psz_name );
449     free( point );
450 }
451
452 static inline seekpoint_t *vlc_seekpoint_Duplicate( seekpoint_t *src )
453 {
454     seekpoint_t *point = vlc_seekpoint_New();
455     if( src->psz_name ) point->psz_name = strdup( src->psz_name );
456     point->i_time_offset = src->i_time_offset;
457     point->i_byte_offset = src->i_byte_offset;
458     return point;
459 }
460
461 /*****************************************************************************
462  * Title:
463  *****************************************************************************/
464 typedef struct
465 {
466     char        *psz_name;
467
468     vlc_bool_t  b_menu;      /* Is it a menu or a normal entry */
469
470     int64_t     i_length;   /* Length(microsecond) if known, else 0 */
471     int64_t     i_size;     /* Size (bytes) if known, else 0 */
472
473     /* Title seekpoint */
474     int         i_seekpoint;
475     seekpoint_t **seekpoint;
476
477 } input_title_t;
478
479 static inline input_title_t *vlc_input_title_New(void)
480 {
481     input_title_t *t = (input_title_t*)malloc( sizeof( input_title_t ) );
482
483     t->psz_name = NULL;
484     t->b_menu = VLC_FALSE;
485     t->i_length = 0;
486     t->i_size   = 0;
487     t->i_seekpoint = 0;
488     t->seekpoint = NULL;
489
490     return t;
491 }
492
493 static inline void vlc_input_title_Delete( input_title_t *t )
494 {
495     int i;
496     if( t == NULL )
497         return;
498
499     free( t->psz_name );
500     for( i = 0; i < t->i_seekpoint; i++ )
501     {
502         free( t->seekpoint[i]->psz_name );
503         free( t->seekpoint[i] );
504     }
505     free( t->seekpoint );
506     free( t );
507 }
508
509 static inline input_title_t *vlc_input_title_Duplicate( input_title_t *t )
510 {
511     input_title_t *dup = vlc_input_title_New( );
512     int i;
513
514     if( t->psz_name ) dup->psz_name = strdup( t->psz_name );
515     dup->b_menu      = t->b_menu;
516     dup->i_length    = t->i_length;
517     dup->i_size      = t->i_size;
518     dup->i_seekpoint = t->i_seekpoint;
519     if( t->i_seekpoint > 0 )
520     {
521         dup->seekpoint = (seekpoint_t**)calloc( t->i_seekpoint,
522                                                 sizeof(seekpoint_t*) );
523
524         for( i = 0; i < t->i_seekpoint; i++ )
525         {
526             dup->seekpoint[i] = vlc_seekpoint_Duplicate( t->seekpoint[i] );
527         }
528     }
529
530     return dup;
531 }
532 /*****************************************************************************
533  * Attachments
534  *****************************************************************************/
535 struct input_attachment_t
536 {
537     char *psz_name;
538     char *psz_mime;
539     char *psz_description;
540
541     int  i_data;
542     void *p_data;
543 };
544 static inline input_attachment_t *vlc_input_attachment_New( const char *psz_name,
545                                                             const char *psz_mime,
546                                                             const char *psz_description,
547                                                             const void *p_data,
548                                                             int i_data )
549 {
550     input_attachment_t *a =
551         (input_attachment_t*)malloc( sizeof(input_attachment_t) );
552     if( !a )
553         return NULL;
554     a->psz_name = strdup( psz_name ? psz_name : "" );
555     a->psz_mime = strdup( psz_mime ? psz_mime : "" );
556     a->psz_description = strdup( psz_description ? psz_description : "" );
557     a->i_data = i_data;
558     a->p_data = NULL;
559     if( i_data > 0 )
560     {
561         a->p_data = malloc( i_data );
562         if( a->p_data && p_data )
563             memcpy( a->p_data, p_data, i_data );
564     }
565     return a;
566 }
567 static inline input_attachment_t *vlc_input_attachment_Duplicate( const input_attachment_t *a )
568 {
569     return vlc_input_attachment_New( a->psz_name, a->psz_mime, a->psz_description,
570                                      a->p_data, a->i_data );
571 }
572 static inline void vlc_input_attachment_Delete( input_attachment_t *a )
573 {
574     if( !a )
575         return;
576     free( a->psz_name );
577     free( a->psz_mime );
578     free( a->psz_description );
579     free( a->p_data );
580     free( a );
581 }
582 /*****************************************************************************
583  * input defines/constants.
584  *****************************************************************************/
585
586 /* "state" value */
587 enum input_state_e
588 {
589     INIT_S,
590     OPENING_S,
591     BUFFERING_S,
592     PLAYING_S,
593     PAUSE_S,
594     END_S,
595     ERROR_S
596 };
597
598 /* "rate" default, min/max
599  * A rate below 1000 plays the movie faster,
600  * A rate above 1000 plays the movie slower.
601  */
602 #define INPUT_RATE_DEFAULT  1000
603 #define INPUT_RATE_MIN       125            /* Up to 8/1 */
604 #define INPUT_RATE_MAX     32000            /* Up to 1/32 */
605
606 /* i_update field of access_t/demux_t */
607 #define INPUT_UPDATE_NONE       0x0000
608 #define INPUT_UPDATE_SIZE       0x0001
609 #define INPUT_UPDATE_TITLE      0x0010
610 #define INPUT_UPDATE_SEEKPOINT  0x0020
611 #define INPUT_UPDATE_META       0x0040
612
613 /* Input control XXX: internal */
614 #define INPUT_CONTROL_FIFO_SIZE    100
615
616 /** Get the input item for an input thread */
617 VLC_EXPORT(input_item_t*, input_GetItem, (input_thread_t*));
618
619 typedef struct input_thread_private_t input_thread_private_t;
620
621 /**
622  * Main structure representing an input thread. This structure is mostly
623  * private. The only public fields are READ-ONLY. You must use the helpers
624  * to modify them
625  */
626 struct input_thread_t
627 {
628     VLC_COMMON_MEMBERS;
629
630     vlc_bool_t  b_eof;
631     vlc_bool_t b_preparsing;
632
633     int i_state;
634     vlc_bool_t b_can_pace_control;
635     int64_t     i_time;     /* Current time */
636
637     /* Internal caching common to all inputs */
638     int i_pts_delay;
639
640     /* All other data is input_thread is PRIVATE. You can't access it
641      * outside of src/input */
642     input_thread_private_t *p;
643 };
644
645 /*****************************************************************************
646  * Prototypes
647  *****************************************************************************/
648
649 /* input_CreateThread
650  * Release the returned input_thread_t using vlc_object_release() */
651 #define input_CreateThread(a,b) __input_CreateThread(VLC_OBJECT(a),b)
652 VLC_EXPORT( input_thread_t *, __input_CreateThread, ( vlc_object_t *, input_item_t * ) );
653
654 #define input_Preparse(a,b) __input_Preparse(VLC_OBJECT(a),b)
655 VLC_EXPORT( int, __input_Preparse, ( vlc_object_t *, input_item_t * ) );
656
657 #define input_Read(a,b,c) __input_Read(VLC_OBJECT(a),b, c)
658 VLC_EXPORT( int, __input_Read, ( vlc_object_t *, input_item_t *, vlc_bool_t ) );
659 VLC_EXPORT( void,             input_StopThread,     ( input_thread_t * ) );
660
661 enum input_query_e
662 {
663     /* input variable "position" */
664     INPUT_GET_POSITION,         /* arg1= double *       res=    */
665     INPUT_SET_POSITION,         /* arg1= double         res=can fail    */
666
667     /* input variable "length" */
668     INPUT_GET_LENGTH,           /* arg1= int64_t *      res=can fail    */
669
670     /* input variable "time" */
671     INPUT_GET_TIME,             /* arg1= int64_t *      res=    */
672     INPUT_SET_TIME,             /* arg1= int64_t        res=can fail    */
673
674     /* input variable "rate" (1 is DEFAULT_RATE) */
675     INPUT_GET_RATE,             /* arg1= int *          res=    */
676     INPUT_SET_RATE,             /* arg1= int            res=can fail    */
677
678     /* input variable "state" */
679     INPUT_GET_STATE,            /* arg1= int *          res=    */
680     INPUT_SET_STATE,            /* arg1= int            res=can fail    */
681
682     /* input variable "audio-delay" and "sub-delay" */
683     INPUT_GET_AUDIO_DELAY,      /* arg1 = int* res=can fail */
684     INPUT_SET_AUDIO_DELAY,      /* arg1 = int  res=can fail */
685     INPUT_GET_SPU_DELAY,        /* arg1 = int* res=can fail */
686     INPUT_SET_SPU_DELAY,        /* arg1 = int  res=can fail */
687
688     /* Meta datas */
689     INPUT_ADD_INFO,   /* arg1= char* arg2= char* arg3=...     res=can fail */
690     INPUT_GET_INFO,   /* arg1= char* arg2= char* arg3= char** res=can fail */
691     INPUT_DEL_INFO,   /* arg1= char* arg2= char*              res=can fail */
692     INPUT_SET_NAME,   /* arg1= char* res=can fail    */
693
694     /* Input config options */
695     INPUT_ADD_OPTION,      /* arg1= char * arg2= char *  res=can fail*/
696
697     /* Input properties */
698     INPUT_GET_BYTE_POSITION,     /* arg1= int64_t *       res=    */
699     INPUT_SET_BYTE_SIZE,         /* arg1= int64_t *       res=    */
700     INPUT_GET_VIDEO_FPS,         /* arg1= double *        res=can fail */
701
702     /* bookmarks */
703     INPUT_GET_BOOKMARKS,   /* arg1= seekpoint_t *** arg2= int * res=can fail */
704     INPUT_CLEAR_BOOKMARKS, /* res=can fail */
705     INPUT_ADD_BOOKMARK,    /* arg1= seekpoint_t *  res=can fail   */
706     INPUT_CHANGE_BOOKMARK, /* arg1= seekpoint_t * arg2= int * res=can fail   */
707     INPUT_DEL_BOOKMARK,    /* arg1= seekpoint_t *  res=can fail   */
708     INPUT_SET_BOOKMARK,    /* arg1= int  res=can fail    */
709
710     /* Attachments */
711     INPUT_GET_ATTACHMENTS, /* arg1=input_attachment_t***, arg2=int*  res=can fail */
712     INPUT_GET_ATTACHMENT,  /* arg1=input_attachment_t**, arg2=char*  res=can fail */
713
714     /* On the fly input slave */
715     INPUT_ADD_SLAVE        /* arg1= char * */
716 };
717
718 VLC_EXPORT( int, input_vaControl,( input_thread_t *, int i_query, va_list  ) );
719 VLC_EXPORT( int, input_Control,  ( input_thread_t *, int i_query, ...  ) );
720
721 VLC_EXPORT( decoder_t *, input_DecoderNew, ( input_thread_t *, es_format_t *, vlc_bool_t b_force_decoder ) );
722 VLC_EXPORT( void, input_DecoderDelete, ( decoder_t * ) );
723 VLC_EXPORT( void, input_DecoderDecode,( decoder_t *, block_t * ) );
724
725 VLC_EXPORT( vlc_bool_t, input_AddSubtitles, ( input_thread_t *, char *, vlc_bool_t ) );
726
727 #endif