]> git.sesse.net Git - vlc/blob - src/input/control.c
Fixed INPUT_GET_BOOKMARK locking scheme.
[vlc] / src / input / control.c
1 /*****************************************************************************
2  * control.c
3  *****************************************************************************
4  * Copyright (C) 1999-2004 the VideoLAN team
5  * $Id$
6  *
7  * Authors: Gildas Bazin <gbazin@videolan.org>
8  *
9  * This program is free software; you can redistribute it and/or modify
10  * it under the terms of the GNU General Public License as published by
11  * the Free Software Foundation; either version 2 of the License, or
12  * (at your option) any later version.
13  *
14  * This program is distributed in the hope that it will be useful,
15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17  * GNU General Public License for more details.
18  *
19  * You should have received a copy of the GNU General Public License
20  * along with this program; if not, write to the Free Software
21  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
22  *****************************************************************************/
23
24 #ifdef HAVE_CONFIG_H
25 # include "config.h"
26 #endif
27
28 #include <vlc_common.h>
29
30 #include <stdio.h>
31 #include <stdlib.h>
32
33 #include "input_internal.h"
34 #include "event.h"
35
36
37 static void UpdateBookmarksOption( input_thread_t * );
38
39 /****************************************************************************
40  * input_Control
41  ****************************************************************************/
42 /**
43  * Control function for inputs.
44  * \param p_input input handle
45  * \param i_query query type
46  * \return VLC_SUCCESS if ok
47  */
48 int input_Control( input_thread_t *p_input, int i_query, ...  )
49 {
50     va_list args;
51     int     i_result;
52
53     va_start( args, i_query );
54     i_result = input_vaControl( p_input, i_query, args );
55     va_end( args );
56
57     return i_result;
58 }
59
60 int input_vaControl( input_thread_t *p_input, int i_query, va_list args )
61 {
62     seekpoint_t *p_bkmk, ***ppp_bkmk;
63     int i_bkmk = 0;
64     int *pi_bkmk;
65
66     int i_int, *pi_int;
67     bool b_bool, *pb_bool;
68     double f, *pf;
69     int64_t i_64, *pi_64;
70
71     char *psz;
72     vlc_value_t val;
73
74     switch( i_query )
75     {
76         case INPUT_GET_POSITION:
77             pf = (double*)va_arg( args, double * );
78             *pf = var_GetFloat( p_input, "position" );
79             return VLC_SUCCESS;
80
81         case INPUT_SET_POSITION:
82             f = (double)va_arg( args, double );
83             return var_SetFloat( p_input, "position", f );
84
85         case INPUT_GET_LENGTH:
86             pi_64 = (int64_t*)va_arg( args, int64_t * );
87             *pi_64 = var_GetTime( p_input, "length" );
88             return VLC_SUCCESS;
89
90         case INPUT_GET_TIME:
91             pi_64 = (int64_t*)va_arg( args, int64_t * );
92             *pi_64 = var_GetTime( p_input, "time" );
93             return VLC_SUCCESS;
94
95         case INPUT_SET_TIME:
96             i_64 = (int64_t)va_arg( args, int64_t );
97             return var_SetTime( p_input, "time", i_64 );
98
99         case INPUT_GET_RATE:
100             pi_int = (int*)va_arg( args, int * );
101             *pi_int = var_GetInteger( p_input, "rate" );
102             return VLC_SUCCESS;
103
104         case INPUT_SET_RATE:
105             i_int = (int)va_arg( args, int );
106             return var_SetInteger( p_input, "rate", i_int );
107
108         case INPUT_GET_STATE:
109             pi_int = (int*)va_arg( args, int * );
110             *pi_int = var_GetInteger( p_input, "state" );
111             return VLC_SUCCESS;
112
113         case INPUT_SET_STATE:
114             i_int = (int)va_arg( args, int );
115             return var_SetInteger( p_input, "state", i_int );
116
117         case INPUT_GET_AUDIO_DELAY:
118             pi_64 = (int64_t*)va_arg( args, int64_t * );
119             *pi_64 = var_GetTime( p_input, "audio-delay" );
120             return VLC_SUCCESS;
121
122         case INPUT_GET_SPU_DELAY:
123             pi_64 = (int64_t*)va_arg( args, int64_t * );
124             *pi_64 = var_GetTime( p_input, "spu-delay" );
125             return VLC_SUCCESS;
126
127         case INPUT_SET_AUDIO_DELAY:
128             i_64 = (int64_t)va_arg( args, int64_t );
129             return var_SetTime( p_input, "audio-delay", i_64 );
130
131         case INPUT_SET_SPU_DELAY:
132             i_64 = (int64_t)va_arg( args, int64_t );
133             return var_SetTime( p_input, "spu-delay", i_64 );
134
135         case INPUT_ADD_INFO:
136         {
137             char *psz_cat = (char *)va_arg( args, char * );
138             char *psz_name = (char *)va_arg( args, char * );
139             char *psz_format = (char *)va_arg( args, char * );
140
141             char *psz_value;
142             
143             if( vasprintf( &psz_value, psz_format, args ) == -1 )
144                 return VLC_EGENERIC;
145
146             int i_ret = input_item_AddInfo( p_input->p->p_item,
147                                             psz_cat, psz_name, "%s", psz_value );
148             free( psz_value );
149
150             if( !p_input->b_preparsing && !i_ret )
151                 input_SendEventMetaInfo( p_input );
152             return i_ret;
153         }
154
155         case INPUT_DEL_INFO:
156         {
157             char *psz_cat = (char *)va_arg( args, char * );
158             char *psz_name = (char *)va_arg( args, char * );
159
160             int i_ret = input_item_DelInfo( p_input->p->p_item,
161                                             psz_cat, psz_name );
162
163             if( !p_input->b_preparsing && !i_ret )
164                 input_SendEventMetaInfo( p_input );
165             return i_ret;
166         }
167
168
169         case INPUT_GET_INFO:
170         {
171             char *psz_cat = (char *)va_arg( args, char * );
172             char *psz_name = (char *)va_arg( args, char * );
173             char **ppsz_value = (char **)va_arg( args, char ** );
174             int i_ret = VLC_EGENERIC;
175             *ppsz_value = NULL;
176
177             *ppsz_value = input_item_GetInfo( p_input->p->p_item,
178                                                   psz_cat, psz_name );
179             return i_ret;
180         }
181
182         case INPUT_SET_NAME:
183         {
184             char *psz_name = (char *)va_arg( args, char * );
185
186             if( !psz_name ) return VLC_EGENERIC;
187
188             input_item_SetName( p_input->p->p_item, psz_name );
189
190             if( !p_input->b_preparsing )
191                 input_SendEventMetaName( p_input, psz_name );
192             return VLC_SUCCESS;
193         }
194
195         case INPUT_ADD_BOOKMARK:
196             p_bkmk = (seekpoint_t *)va_arg( args, seekpoint_t * );
197             p_bkmk = vlc_seekpoint_Duplicate( p_bkmk );
198
199             vlc_mutex_lock( &p_input->p->p_item->lock );
200             if( !p_bkmk->psz_name )
201             {
202                  if( asprintf( &p_bkmk->psz_name, _("Bookmark %i"),
203                                p_input->p->i_bookmark ) == -1 )
204                      p_bkmk->psz_name = NULL;
205             }
206
207             TAB_APPEND( p_input->p->i_bookmark, p_input->p->pp_bookmark, p_bkmk );
208
209             /* Reflect the changes on the object var */
210             var_Change( p_input, "bookmark", VLC_VAR_CLEARCHOICES, 0, 0 );
211             {
212                 vlc_value_t val, text;
213                 int i;
214
215                 for( i = 0; i < p_input->p->i_bookmark; i++ )
216                 {
217                     val.i_int = i;
218                     text.psz_string = p_input->p->pp_bookmark[i]->psz_name;
219                     var_Change( p_input, "bookmark", VLC_VAR_ADDCHOICE,
220                                 &val, &text );
221                 }
222             }
223             vlc_mutex_unlock( &p_input->p->p_item->lock );
224
225             UpdateBookmarksOption( p_input );
226
227             return VLC_SUCCESS;
228
229         case INPUT_CHANGE_BOOKMARK:
230             p_bkmk = (seekpoint_t *)va_arg( args, seekpoint_t * );
231             i_bkmk = (int)va_arg( args, int );
232
233             vlc_mutex_lock( &p_input->p->p_item->lock );
234             if( i_bkmk < p_input->p->i_bookmark )
235             {
236                 vlc_value_t val, text;
237                 int i;
238
239                 p_input->p->pp_bookmark[i_bkmk] = p_bkmk;
240
241                 /* Reflect the changes on the object var */
242                 var_Change( p_input, "bookmark", VLC_VAR_CLEARCHOICES, 0, 0 );
243                 for( i = 0; i < p_input->p->i_bookmark; i++ )
244                 {
245                     val.i_int = i;
246                     text.psz_string = p_input->p->pp_bookmark[i]->psz_name;
247                     var_Change( p_input, "bookmark", VLC_VAR_ADDCHOICE,
248                                 &val, &text );
249                 }
250             }
251             vlc_mutex_unlock( &p_input->p->p_item->lock );
252
253             UpdateBookmarksOption( p_input );
254
255             return VLC_SUCCESS;
256
257         case INPUT_DEL_BOOKMARK:
258             i_bkmk = (int)va_arg( args, int );
259
260             vlc_mutex_lock( &p_input->p->p_item->lock );
261             if( i_bkmk < p_input->p->i_bookmark )
262             {
263                 vlc_value_t val, text;
264                 int i;
265
266                 p_bkmk = p_input->p->pp_bookmark[i_bkmk];
267                 TAB_REMOVE( p_input->p->i_bookmark, p_input->p->pp_bookmark,
268                             p_bkmk );
269                 vlc_seekpoint_Delete( p_bkmk );
270
271                 /* Reflect the changes on the object var */
272                 var_Change( p_input, "bookmark", VLC_VAR_CLEARCHOICES, 0, 0 );
273                 for( i = 0; i < p_input->p->i_bookmark; i++ )
274                 {
275                     val.i_int = i;
276                     text.psz_string = p_input->p->pp_bookmark[i]->psz_name;
277                     var_Change( p_input, "bookmark", VLC_VAR_ADDCHOICE,
278                                 &val, &text );
279                 }
280                 vlc_mutex_unlock( &p_input->p->p_item->lock );
281
282                 UpdateBookmarksOption( p_input );
283
284                 return VLC_SUCCESS;
285             }
286             vlc_mutex_unlock( &p_input->p->p_item->lock );
287
288             return VLC_EGENERIC;
289
290         case INPUT_GET_BOOKMARKS:
291             ppp_bkmk = (seekpoint_t ***)va_arg( args, seekpoint_t *** );
292             pi_bkmk = (int *)va_arg( args, int * );
293
294             vlc_mutex_lock( &p_input->p->p_item->lock );
295             if( p_input->p->i_bookmark )
296             {
297                 int i;
298
299                 *pi_bkmk = p_input->p->i_bookmark;
300                 *ppp_bkmk = malloc( sizeof(seekpoint_t *) *
301                                     p_input->p->i_bookmark );
302                 for( i = 0; i < p_input->p->i_bookmark; i++ )
303                 {
304                     (*ppp_bkmk)[i] =
305                         vlc_seekpoint_Duplicate(p_input->p->pp_bookmark[i]);
306                 }
307
308                 vlc_mutex_unlock( &p_input->p->p_item->lock );
309                 return VLC_SUCCESS;
310             }
311             else
312             {
313                 *ppp_bkmk = NULL;
314                 *pi_bkmk = 0;
315
316                 vlc_mutex_unlock( &p_input->p->p_item->lock );
317                 return VLC_EGENERIC;
318             }
319             break;
320
321         case INPUT_CLEAR_BOOKMARKS:
322
323             vlc_mutex_lock( &p_input->p->p_item->lock );
324             if( p_input->p->i_bookmark )
325             {
326                 int i;
327
328                 for( i = p_input->p->i_bookmark - 1; i >= 0; i-- )
329                 {
330                     p_bkmk = p_input->p->pp_bookmark[i];
331                     TAB_REMOVE( p_input->p->i_bookmark, p_input->p->pp_bookmark,
332                                 p_bkmk );
333                     vlc_seekpoint_Delete( p_bkmk );
334                 }
335                 var_Change( p_input, "bookmark", VLC_VAR_CLEARCHOICES, 0, 0 );
336             }
337             vlc_mutex_unlock( &p_input->p->p_item->lock );
338
339             UpdateBookmarksOption( p_input );
340
341             return VLC_SUCCESS;
342
343         case INPUT_SET_BOOKMARK:
344             i_bkmk = (int)va_arg( args, int );
345
346             vlc_mutex_lock( &p_input->p->p_item->lock );
347             if( i_bkmk >= 0 && i_bkmk < p_input->p->i_bookmark )
348             {
349                 vlc_value_t pos;
350                 int i_ret;
351
352                 if( p_input->p->pp_bookmark[i_bkmk]->i_time_offset != -1 )
353                 {
354                     pos.i_time = p_input->p->pp_bookmark[i_bkmk]->i_time_offset;
355                     i_ret = var_Set( p_input, "time", pos );
356                 }
357                 else if( p_input->p->pp_bookmark[i_bkmk]->i_byte_offset != -1 )
358                 {
359                     // don't crash on bookmarks in live streams
360                     if( stream_Size( p_input->p->input.p_stream ) == 0 )
361                     {
362                         vlc_mutex_unlock( &p_input->p->p_item->lock );
363                         return VLC_EGENERIC;
364                     }
365                     pos.f_float = !p_input->p->input.p_stream ? 0 :
366                         p_input->p->pp_bookmark[i_bkmk]->i_byte_offset /
367                         stream_Size( p_input->p->input.p_stream );
368                     i_ret = var_Set( p_input, "position", pos );
369                 }
370                 else
371                 {
372                     pos.f_float = 0;
373                     i_ret = var_Set( p_input, "position", pos );
374                 }
375
376                 vlc_mutex_unlock( &p_input->p->p_item->lock );
377                 return i_ret;
378             }
379             else
380             {
381                 vlc_mutex_unlock( &p_input->p->p_item->lock );
382                 return VLC_EGENERIC;
383             }
384
385             break;
386
387         case INPUT_GET_BOOKMARK:
388             p_bkmk = (seekpoint_t *)va_arg( args, seekpoint_t * );
389
390             vlc_mutex_lock( &p_input->p->p_item->lock );
391             *p_bkmk = p_input->p->bookmark;
392             vlc_mutex_unlock( &p_input->p->p_item->lock );
393             return VLC_SUCCESS;
394
395         case INPUT_ADD_OPTION:
396         {
397             const char *psz_option = va_arg( args, const char * );
398             const char *psz_value = va_arg( args, const char * );
399             char *str;
400             int i;
401
402             if( asprintf( &str, "%s=%s", psz_option, psz_value ) == -1 )
403                 return VLC_ENOMEM;
404
405             i = input_item_AddOpt( p_input->p->p_item, str,
406                                   VLC_INPUT_OPTION_UNIQUE );
407             free( str );
408             return i;
409         }
410
411         case INPUT_GET_VIDEO_FPS:
412         {
413             int i;
414             pf = (double*)va_arg( args, double * );
415             vlc_mutex_lock( &p_input->p->p_item->lock );
416             *pf = p_input->p->input.f_fps;
417             for( i = 0; i < p_input->p->i_slave && *pf <= 0.001; i++ )
418                 *pf = p_input->p->slave[i]->f_fps;
419             vlc_mutex_unlock( &p_input->p->p_item->lock );
420             return VLC_SUCCESS;
421         }
422
423         case INPUT_ADD_SLAVE:
424             psz = (char*)va_arg( args, char * );
425             if( psz && *psz )
426             {
427                 val.psz_string = strdup( psz );
428                 input_ControlPush( p_input, INPUT_CONTROL_ADD_SLAVE, &val );
429             }
430             return VLC_SUCCESS;
431
432         case INPUT_GET_ATTACHMENTS: /* arg1=input_attachment_t***, arg2=int*  res=can fail */
433         {
434             input_attachment_t ***ppp_attachment = (input_attachment_t***)va_arg( args, input_attachment_t *** );
435             int *pi_attachment = (int*)va_arg( args, int * );
436             int i;
437
438             vlc_mutex_lock( &p_input->p->p_item->lock );
439             if( p_input->p->i_attachment <= 0 )
440             {
441                 vlc_mutex_unlock( &p_input->p->p_item->lock );
442                 *ppp_attachment = NULL;
443                 *pi_attachment = 0;
444                 return VLC_EGENERIC;
445             }
446             *pi_attachment = p_input->p->i_attachment;
447             *ppp_attachment = malloc( sizeof(input_attachment_t**) * p_input->p->i_attachment );
448             for( i = 0; i < p_input->p->i_attachment; i++ )
449                 (*ppp_attachment)[i] = vlc_input_attachment_Duplicate( p_input->p->attachment[i] );
450
451             vlc_mutex_unlock( &p_input->p->p_item->lock );
452             return VLC_SUCCESS;
453         }
454
455         case INPUT_GET_ATTACHMENT:  /* arg1=input_attachment_t**, arg2=char*  res=can fail */
456         {
457             input_attachment_t **pp_attachment = (input_attachment_t**)va_arg( args, input_attachment_t ** );
458             const char *psz_name = (const char*)va_arg( args, const char * );
459             int i;
460
461             vlc_mutex_lock( &p_input->p->p_item->lock );
462             for( i = 0; i < p_input->p->i_attachment; i++ )
463             {
464                 if( !strcmp( p_input->p->attachment[i]->psz_name, psz_name ) )
465                 {
466                     *pp_attachment = vlc_input_attachment_Duplicate( p_input->p->attachment[i] );
467                     vlc_mutex_unlock( &p_input->p->p_item->lock );
468                     return VLC_SUCCESS;
469                 }
470             }
471             *pp_attachment = NULL;
472             vlc_mutex_unlock( &p_input->p->p_item->lock );
473             return VLC_EGENERIC;
474         }
475
476         case INPUT_SET_RECORD_STATE:
477             b_bool = (bool)va_arg( args, int );
478             var_SetBool( p_input, "record", b_bool );
479             return VLC_SUCCESS;
480
481         case INPUT_GET_RECORD_STATE:
482             pb_bool = (bool*)va_arg( args, bool* );
483             *pb_bool = var_GetBool( p_input, "record" );
484             return VLC_SUCCESS;
485
486         case INPUT_RESTART_ES:
487             val.i_int = (int)va_arg( args, int );
488             input_ControlPush( p_input, INPUT_CONTROL_RESTART_ES, &val );
489             return VLC_SUCCESS;
490
491         default:
492             msg_Err( p_input, "unknown query in input_vaControl" );
493             return VLC_EGENERIC;
494     }
495 }
496
497 static void UpdateBookmarksOption( input_thread_t *p_input )
498 {
499     int i, i_len = 0;
500     char *psz_value = NULL, *psz_next = NULL;
501
502     vlc_mutex_lock( &p_input->p->p_item->lock );
503     if( p_input->p->i_bookmark > 0 )
504     {
505         for( i = 0; i < p_input->p->i_bookmark; i++ )
506         {
507             i_len += snprintf( NULL, 0, "{name=%s,bytes=%"PRId64",time=%"PRId64"}",
508                                p_input->p->pp_bookmark[i]->psz_name,
509                                p_input->p->pp_bookmark[i]->i_byte_offset,
510                                p_input->p->pp_bookmark[i]->i_time_offset/1000000 );
511         }
512         psz_value = psz_next = malloc( i_len + p_input->p->i_bookmark );
513
514         for( i = 0; i < p_input->p->i_bookmark; i++ )
515         {
516             sprintf( psz_next, "{name=%s,bytes=%"PRId64",time=%"PRId64"}",
517                      p_input->p->pp_bookmark[i]->psz_name,
518                      p_input->p->pp_bookmark[i]->i_byte_offset,
519                      p_input->p->pp_bookmark[i]->i_time_offset/1000000 );
520
521             psz_next += strlen( psz_next );
522             if( i < p_input->p->i_bookmark - 1)
523                 *psz_next = ','; psz_next++;
524         }
525     }
526     vlc_mutex_unlock( &p_input->p->p_item->lock );
527
528     input_Control( p_input, INPUT_ADD_OPTION, "bookmarks",
529                    psz_value ? psz_value : "" );
530     free( psz_value );
531 }
532