← Back to branch summary

~ubuntu-branches/ubuntu/maverick/vlc/maverick

« back to all changes in this revision

Viewing changes to src/input/control.c

  • Committer: Bazaar Package Importer
  • Author(s): Reinhard Tartler
  • Date: 2008-09-17 21:56:14 UTC
  • mfrom: (1.1.17 upstream)
  • Revision ID: james.westby@ubuntu.com-20080917215614-tj0vx8xzd57e52t8
Tags: 0.9.2-1ubuntu1
https://launchpad.net/bugs/270404
https://launchpad.net/bugs/210354
https://launchpad.net/bugs/199870
https://launchpad.net/bugs/261567
* New Upstream Release, exception granted by
    - dktrkranz, norsetto, Hobbsee (via irc). LP: #270404

Changes done in ubuntu:

* add libxul-dev to build-depends
* make sure that vlc is build against libxul in configure. This doesn't
  change anything in the package, but makes it more robust if building
  in an 'unclean' chroot or when modifying the package.
* debian/control: make Vcs-* fields point to the motumedia branch
* add libx264-dev and libass-dev to build-depends
  LP: #210354, #199870
* actually enable libass support by passing --enable-libass to configure
* enable libdca: add libdca-dev to build depends and --enable-libdca
* install the x264 plugin.

Changes already in the pkg-multimedia branch in debian:

* don't install usr/share/vlc/mozilla in debian/mozilla-plugin-vlc.install  
* new upstream .desktop file now registers flash video mimetype LP: #261567
* add Xb-Npp-Applications to mozilla-plugin-vlc
* remove duplicate entries in debian/vlc-nox.install

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/input/control.c
2
2
 * control.c
3
3
 *****************************************************************************
4
4
 * Copyright (C) 1999-2004 the VideoLAN team
5
 
 * $Id: af74a16dc6e67d646e19b84de9578be3e07807bf $
 
5
 * $Id: 123c9f908faa8c8f1a7d0ab4cc927757c6c9cb3d $
6
6
 *
7
7
 * Authors: Gildas Bazin <gbazin@videolan.org>
8
8
 *
21
21
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
22
22
 *****************************************************************************/
23
23
 
 
24
#ifdef HAVE_CONFIG_H
 
25
# include "config.h"
 
26
#endif
 
27
 
 
28
#include <vlc_common.h>
 
29
 
 
30
#include <stdio.h>
24
31
#include <stdlib.h>
25
 
#include <vlc/vlc.h>
26
 
#include <vlc/input.h>
27
32
 
28
33
#include "input_internal.h"
29
 
#include "vlc_playlist.h"
30
34
 
31
35
 
32
36
static void UpdateBookmarksOption( input_thread_t * );
33
 
static void NotifyPlaylist( input_thread_t * );
34
37
 
35
38
/****************************************************************************
36
39
 * input_Control
129
132
 
130
133
        case INPUT_ADD_INFO:
131
134
        {
132
 
            /* FIXME : Impossible to use vlc_input_item_AddInfo because of
 
135
            /* FIXME : Impossible to use input_item_AddInfo because of
133
136
             * the ... problem ? */
134
137
            char *psz_cat = (char *)va_arg( args, char * );
135
138
            char *psz_name = (char *)va_arg( args, char * );
139
142
            info_t *p_info;
140
143
            int i;
141
144
 
142
 
            vlc_mutex_lock( &p_input->input.p_item->lock );
143
 
            for( i = 0; i < p_input->input.p_item->i_categories; i++ )
 
145
            vlc_mutex_lock( &p_input->p->input.p_item->lock );
 
146
            for( i = 0; i < p_input->p->input.p_item->i_categories; i++ )
144
147
            {
145
 
                if( !strcmp( p_input->input.p_item->pp_categories[i]->psz_name,
 
148
                if( !strcmp( p_input->p->input.p_item->pp_categories[i]->psz_name,
146
149
                             psz_cat ) ) break;
147
150
            }
148
151
 
149
 
            if( i == p_input->input.p_item->i_categories )
 
152
            if( i == p_input->p->input.p_item->i_categories )
150
153
            {
151
154
                p_cat = malloc( sizeof( info_category_t ) );
152
155
                if( !p_cat )
153
156
                {
154
 
                    vlc_mutex_lock( &p_input->input.p_item->lock );
 
157
                    vlc_mutex_unlock( &p_input->p->input.p_item->lock );
155
158
                    return VLC_EGENERIC;
156
159
                }
157
160
                p_cat->psz_name = strdup( psz_cat );
158
161
                p_cat->i_infos = 0;
159
162
                p_cat->pp_infos = NULL;
160
 
                INSERT_ELEM( p_input->input.p_item->pp_categories,
161
 
                             p_input->input.p_item->i_categories,
162
 
                             p_input->input.p_item->i_categories, p_cat );
 
163
                INSERT_ELEM( p_input->p->input.p_item->pp_categories,
 
164
                             p_input->p->input.p_item->i_categories,
 
165
                             p_input->p->input.p_item->i_categories, p_cat );
163
166
            }
164
167
 
165
 
            p_cat = p_input->input.p_item->pp_categories[i];
 
168
            p_cat = p_input->p->input.p_item->pp_categories[i];
166
169
 
167
170
            for( i = 0; i < p_cat->i_infos; i++ )
168
171
            {
179
182
                p_info = malloc( sizeof( info_t ) );
180
183
                if( !p_info )
181
184
                {
182
 
                    vlc_mutex_lock( &p_input->input.p_item->lock );
 
185
                    vlc_mutex_unlock( &p_input->p->input.p_item->lock );
183
186
                    return VLC_EGENERIC;
184
187
                }
185
188
 
189
192
            }
190
193
 
191
194
            p_info = p_cat->pp_infos[i];
192
 
            vasprintf( &p_info->psz_value, psz_format, args );
193
 
 
194
 
            vlc_mutex_unlock( &p_input->input.p_item->lock );
195
 
 
196
 
            NotifyPlaylist( p_input );
 
195
            if( vasprintf( &p_info->psz_value, psz_format, args ) == -1 )
 
196
                p_info->psz_value = NULL;
 
197
 
 
198
            vlc_mutex_unlock( &p_input->p->input.p_item->lock );
 
199
 
 
200
            if( !p_input->b_preparsing )
 
201
            {
 
202
                vlc_event_t event;
 
203
                event.type = vlc_InputItemInfoChanged;
 
204
                vlc_event_send( &p_input->p->input.p_item->event_manager, &event );
 
205
            }
197
206
        }
198
207
        return VLC_SUCCESS;
199
208
 
203
212
            char *psz_name = (char *)va_arg( args, char * );
204
213
 
205
214
            info_category_t *p_cat = NULL;
 
215
            int i_cat;
206
216
            int i;
207
217
 
208
 
            vlc_mutex_lock( &p_input->input.p_item->lock );
209
 
            for( i = 0; i < p_input->input.p_item->i_categories; i++ )
 
218
            vlc_mutex_lock( &p_input->p->input.p_item->lock );
 
219
            for( i_cat = 0; i_cat < p_input->p->input.p_item->i_categories; i_cat++ )
210
220
            {
211
 
                if( !strcmp( p_input->input.p_item->pp_categories[i]->psz_name,
 
221
                if( !strcmp( p_input->p->input.p_item->pp_categories[i_cat]->psz_name,
212
222
                             psz_cat ) )
213
223
                {
214
 
                    p_cat = p_input->input.p_item->pp_categories[i];
 
224
                    p_cat = p_input->p->input.p_item->pp_categories[i_cat];
215
225
                    break;
216
226
                }
217
227
            }
218
228
            if( p_cat == NULL )
219
229
            {
220
 
                vlc_mutex_unlock( &p_input->input.p_item->lock );
 
230
                vlc_mutex_unlock( &p_input->p->input.p_item->lock );
221
231
                return VLC_EGENERIC;
222
232
            }
223
233
 
224
 
            for( i = 0; i < p_cat->i_infos; i++ )
225
 
            {
226
 
                if( !strcmp( p_cat->pp_infos[i]->psz_name, psz_name ) )
 
234
            if( psz_name )
 
235
            {
 
236
                /* Remove a specific info */
 
237
                for( i = 0; i < p_cat->i_infos; i++ )
 
238
                {
 
239
                    if( !strcmp( p_cat->pp_infos[i]->psz_name, psz_name ) )
 
240
                    {
 
241
                        free( p_cat->pp_infos[i]->psz_name );
 
242
                        if( p_cat->pp_infos[i]->psz_value )
 
243
                            free( p_cat->pp_infos[i]->psz_value );
 
244
                        free( p_cat->pp_infos[i] );
 
245
                        REMOVE_ELEM( p_cat->pp_infos, p_cat->i_infos, i );
 
246
                        break;
 
247
                    }
 
248
                }
 
249
                if( i >= p_cat->i_infos )
 
250
                {
 
251
                    vlc_mutex_unlock( &p_input->p->input.p_item->lock );
 
252
                    return VLC_EGENERIC;
 
253
                }
 
254
            }
 
255
            else
 
256
            {
 
257
                /* Remove the complete categorie */
 
258
                for( i = 0; i < p_cat->i_infos; i++ )
227
259
                {
228
260
                    free( p_cat->pp_infos[i]->psz_name );
229
261
                    if( p_cat->pp_infos[i]->psz_value )
230
262
                        free( p_cat->pp_infos[i]->psz_value );
231
263
                    free( p_cat->pp_infos[i] );
232
 
                    REMOVE_ELEM( p_cat->pp_infos, p_cat->i_infos, i );
233
 
                    break;
234
264
                }
235
 
            }
236
 
            vlc_mutex_unlock( &p_input->input.p_item->lock );
237
 
 
238
 
            if( i >= p_cat->i_infos )
239
 
                return VLC_EGENERIC;
240
 
 
241
 
            NotifyPlaylist( p_input );
 
265
                if( p_cat->pp_infos )
 
266
                    free( p_cat->pp_infos );
 
267
                REMOVE_ELEM( p_input->p->input.p_item->pp_categories, p_input->p->input.p_item->i_categories, i_cat );
 
268
            }
 
269
            vlc_mutex_unlock( &p_input->p->input.p_item->lock );
 
270
 
 
271
            if( !p_input->b_preparsing )
 
272
            {
 
273
                vlc_event_t event;
 
274
                event.type = vlc_InputItemInfoChanged;
 
275
                vlc_event_send( &p_input->p->input.p_item->event_manager, &event );
 
276
            }
 
277
            return VLC_SUCCESS;
242
278
        }
243
 
        return VLC_SUCCESS;
244
279
 
245
280
 
246
281
        case INPUT_GET_INFO:
251
286
            int i_ret = VLC_EGENERIC;
252
287
            *ppsz_value = NULL;
253
288
 
254
 
            *ppsz_value = vlc_input_item_GetInfo( p_input->input.p_item,
 
289
            *ppsz_value = input_item_GetInfo( p_input->p->input.p_item,
255
290
                                                  psz_cat, psz_name );
256
291
            return i_ret;
257
292
        }
262
297
 
263
298
            if( !psz_name ) return VLC_EGENERIC;
264
299
 
265
 
            vlc_mutex_lock( &p_input->input.p_item->lock );
266
 
            if( p_input->input.p_item->psz_name )
267
 
                free( p_input->input.p_item->psz_name );
268
 
            p_input->input.p_item->psz_name = strdup( psz_name );
269
 
            vlc_mutex_unlock( &p_input->input.p_item->lock );
270
 
 
271
 
            NotifyPlaylist( p_input );
272
 
 
 
300
            vlc_mutex_lock( &p_input->p->input.p_item->lock );
 
301
            if( p_input->p->input.p_item->psz_name )
 
302
                free( p_input->p->input.p_item->psz_name );
 
303
            p_input->p->input.p_item->psz_name = strdup( psz_name );
 
304
            vlc_mutex_unlock( &p_input->p->input.p_item->lock );
 
305
 
 
306
            if( !p_input->b_preparsing )
 
307
            {
 
308
                vlc_event_t event;
 
309
                event.type = vlc_InputItemNameChanged;
 
310
                event.u.input_item_name_changed.new_name = psz_name;
 
311
                vlc_event_send( &p_input->p->input.p_item->event_manager, &event );
 
312
            }
273
313
            return VLC_SUCCESS;
274
314
        }
275
315
 
277
317
            p_bkmk = (seekpoint_t *)va_arg( args, seekpoint_t * );
278
318
            p_bkmk = vlc_seekpoint_Duplicate( p_bkmk );
279
319
 
280
 
            vlc_mutex_lock( &p_input->input.p_item->lock );
 
320
            vlc_mutex_lock( &p_input->p->input.p_item->lock );
281
321
            if( !p_bkmk->psz_name )
282
322
            {
283
 
                 asprintf( &p_bkmk->psz_name, _("Bookmark %i"),
284
 
                           p_input->i_bookmark );
 
323
                 if( asprintf( &p_bkmk->psz_name, _("Bookmark %i"),
 
324
                               p_input->p->i_bookmark ) == -1 )
 
325
                     p_bkmk->psz_name = NULL;
285
326
            }
286
327
 
287
 
            TAB_APPEND( p_input->i_bookmark, p_input->bookmark, p_bkmk );
 
328
            TAB_APPEND( p_input->p->i_bookmark, p_input->p->bookmark, p_bkmk );
288
329
 
289
330
            /* Reflect the changes on the object var */
290
331
            var_Change( p_input, "bookmark", VLC_VAR_CLEARCHOICES, 0, 0 );
292
333
                vlc_value_t val, text;
293
334
                int i;
294
335
 
295
 
                for( i = 0; i < p_input->i_bookmark; i++ )
 
336
                for( i = 0; i < p_input->p->i_bookmark; i++ )
296
337
                {
297
338
                    val.i_int = i;
298
 
                    text.psz_string = p_input->bookmark[i]->psz_name;
 
339
                    text.psz_string = p_input->p->bookmark[i]->psz_name;
299
340
                    var_Change( p_input, "bookmark", VLC_VAR_ADDCHOICE,
300
341
                                &val, &text );
301
342
                }
302
343
            }
303
 
            vlc_mutex_unlock( &p_input->input.p_item->lock );
 
344
            vlc_mutex_unlock( &p_input->p->input.p_item->lock );
304
345
 
305
346
            UpdateBookmarksOption( p_input );
306
347
 
310
351
            p_bkmk = (seekpoint_t *)va_arg( args, seekpoint_t * );
311
352
            i_bkmk = (int)va_arg( args, int );
312
353
 
313
 
            vlc_mutex_lock( &p_input->input.p_item->lock );
314
 
            if( i_bkmk < p_input->i_bookmark )
 
354
            vlc_mutex_lock( &p_input->p->input.p_item->lock );
 
355
            if( i_bkmk < p_input->p->i_bookmark )
315
356
            {
316
357
                vlc_value_t val, text;
317
358
                int i;
318
359
 
319
 
                p_input->bookmark[i_bkmk] = p_bkmk;
 
360
                p_input->p->bookmark[i_bkmk] = p_bkmk;
320
361
 
321
362
                /* Reflect the changes on the object var */
322
363
                var_Change( p_input, "bookmark", VLC_VAR_CLEARCHOICES, 0, 0 );
323
 
                for( i = 0; i < p_input->i_bookmark; i++ )
 
364
                for( i = 0; i < p_input->p->i_bookmark; i++ )
324
365
                {
325
366
                    val.i_int = i;
326
 
                    text.psz_string = p_input->bookmark[i]->psz_name;
 
367
                    text.psz_string = p_input->p->bookmark[i]->psz_name;
327
368
                    var_Change( p_input, "bookmark", VLC_VAR_ADDCHOICE,
328
369
                                &val, &text );
329
370
                }
330
371
            }
331
 
            vlc_mutex_unlock( &p_input->input.p_item->lock );
 
372
            vlc_mutex_unlock( &p_input->p->input.p_item->lock );
332
373
 
333
374
            UpdateBookmarksOption( p_input );
334
375
 
337
378
        case INPUT_DEL_BOOKMARK:
338
379
            i_bkmk = (int)va_arg( args, int );
339
380
 
340
 
            vlc_mutex_lock( &p_input->input.p_item->lock );
341
 
            if( i_bkmk < p_input->i_bookmark )
 
381
            vlc_mutex_lock( &p_input->p->input.p_item->lock );
 
382
            if( i_bkmk < p_input->p->i_bookmark )
342
383
            {
343
384
                vlc_value_t val, text;
344
385
                int i;
345
386
 
346
 
                p_bkmk = p_input->bookmark[i_bkmk];
347
 
                TAB_REMOVE( p_input->i_bookmark, p_input->bookmark,
 
387
                p_bkmk = p_input->p->bookmark[i_bkmk];
 
388
                TAB_REMOVE( p_input->p->i_bookmark, p_input->p->bookmark,
348
389
                            p_bkmk );
349
390
                vlc_seekpoint_Delete( p_bkmk );
350
391
 
351
392
                /* Reflect the changes on the object var */
352
393
                var_Change( p_input, "bookmark", VLC_VAR_CLEARCHOICES, 0, 0 );
353
 
                for( i = 0; i < p_input->i_bookmark; i++ )
 
394
                for( i = 0; i < p_input->p->i_bookmark; i++ )
354
395
                {
355
396
                    val.i_int = i;
356
 
                    text.psz_string = p_input->bookmark[i]->psz_name;
 
397
                    text.psz_string = p_input->p->bookmark[i]->psz_name;
357
398
                    var_Change( p_input, "bookmark", VLC_VAR_ADDCHOICE,
358
399
                                &val, &text );
359
400
                }
360
 
                vlc_mutex_unlock( &p_input->input.p_item->lock );
 
401
                vlc_mutex_unlock( &p_input->p->input.p_item->lock );
361
402
 
362
403
                UpdateBookmarksOption( p_input );
363
404
 
364
405
                return VLC_SUCCESS;
365
406
            }
366
 
            vlc_mutex_unlock( &p_input->input.p_item->lock );
 
407
            vlc_mutex_unlock( &p_input->p->input.p_item->lock );
367
408
 
368
409
            return VLC_EGENERIC;
369
410
 
371
412
            ppp_bkmk = (seekpoint_t ***)va_arg( args, seekpoint_t *** );
372
413
            pi_bkmk = (int *)va_arg( args, int * );
373
414
 
374
 
            vlc_mutex_lock( &p_input->input.p_item->lock );
375
 
            if( p_input->i_bookmark )
 
415
            vlc_mutex_lock( &p_input->p->input.p_item->lock );
 
416
            if( p_input->p->i_bookmark )
376
417
            {
377
418
                int i;
378
419
 
379
 
                *pi_bkmk = p_input->i_bookmark;
 
420
                *pi_bkmk = p_input->p->i_bookmark;
380
421
                *ppp_bkmk = malloc( sizeof(seekpoint_t *) *
381
 
                                    p_input->i_bookmark );
382
 
                for( i = 0; i < p_input->i_bookmark; i++ )
 
422
                                    p_input->p->i_bookmark );
 
423
                for( i = 0; i < p_input->p->i_bookmark; i++ )
383
424
                {
384
425
                    (*ppp_bkmk)[i] =
385
 
                        vlc_seekpoint_Duplicate(p_input->bookmark[i]);
 
426
                        vlc_seekpoint_Duplicate(p_input->p->bookmark[i]);
386
427
                }
387
428
 
388
 
                vlc_mutex_unlock( &p_input->input.p_item->lock );
 
429
                vlc_mutex_unlock( &p_input->p->input.p_item->lock );
389
430
                return VLC_SUCCESS;
390
431
            }
391
432
            else
393
434
                *ppp_bkmk = NULL;
394
435
                *pi_bkmk = 0;
395
436
 
396
 
                vlc_mutex_unlock( &p_input->input.p_item->lock );
 
437
                vlc_mutex_unlock( &p_input->p->input.p_item->lock );
397
438
                return VLC_EGENERIC;
398
439
            }
399
440
            break;
400
441
 
401
442
        case INPUT_CLEAR_BOOKMARKS:
402
443
 
403
 
            vlc_mutex_lock( &p_input->input.p_item->lock );
404
 
            if( p_input->i_bookmark )
 
444
            vlc_mutex_lock( &p_input->p->input.p_item->lock );
 
445
            if( p_input->p->i_bookmark )
405
446
            {
406
447
                int i;
407
448
 
408
 
                for( i = p_input->i_bookmark - 1; i >= 0; i-- )
 
449
                for( i = p_input->p->i_bookmark - 1; i >= 0; i-- )
409
450
                {
410
 
                    p_bkmk = p_input->bookmark[i];
411
 
                    TAB_REMOVE( p_input->i_bookmark, p_input->bookmark,
 
451
                    p_bkmk = p_input->p->bookmark[i];
 
452
                    TAB_REMOVE( p_input->p->i_bookmark, p_input->p->bookmark,
412
453
                                p_bkmk );
413
454
                    vlc_seekpoint_Delete( p_bkmk );
414
455
                }
415
456
                var_Change( p_input, "bookmark", VLC_VAR_CLEARCHOICES, 0, 0 );
416
457
            }
417
 
            vlc_mutex_unlock( &p_input->input.p_item->lock );
 
458
            vlc_mutex_unlock( &p_input->p->input.p_item->lock );
418
459
 
419
460
            UpdateBookmarksOption( p_input );
420
461
 
423
464
        case INPUT_SET_BOOKMARK:
424
465
            i_bkmk = (int)va_arg( args, int );
425
466
 
426
 
            vlc_mutex_lock( &p_input->input.p_item->lock );
427
 
            if( i_bkmk >= 0 && i_bkmk < p_input->i_bookmark )
 
467
            vlc_mutex_lock( &p_input->p->input.p_item->lock );
 
468
            if( i_bkmk >= 0 && i_bkmk < p_input->p->i_bookmark )
428
469
            {
429
470
                vlc_value_t pos;
430
471
                int i_ret;
431
472
 
432
 
                if( p_input->bookmark[i_bkmk]->i_time_offset != -1 )
 
473
                if( p_input->p->bookmark[i_bkmk]->i_time_offset != -1 )
433
474
                {
434
 
                    pos.i_time = p_input->bookmark[i_bkmk]->i_time_offset;
 
475
                    pos.i_time = p_input->p->bookmark[i_bkmk]->i_time_offset;
435
476
                    i_ret = var_Set( p_input, "time", pos );
436
477
                }
437
 
                else if( p_input->bookmark[i_bkmk]->i_byte_offset != -1 )
 
478
                else if( p_input->p->bookmark[i_bkmk]->i_byte_offset != -1 )
438
479
                {
439
480
                    // don't crash on bookmarks in live streams
440
 
                    if( stream_Size( p_input->input.p_stream ) == 0 )
 
481
                    if( stream_Size( p_input->p->input.p_stream ) == 0 )
441
482
                    {
442
 
                        vlc_mutex_unlock( &p_input->input.p_item->lock );
 
483
                        vlc_mutex_unlock( &p_input->p->input.p_item->lock );
443
484
                        return VLC_EGENERIC;
444
485
                    }
445
 
                    pos.f_float = !p_input->input.p_stream ? 0 :
446
 
                        p_input->bookmark[i_bkmk]->i_byte_offset /
447
 
                        stream_Size( p_input->input.p_stream );
 
486
                    pos.f_float = !p_input->p->input.p_stream ? 0 :
 
487
                        p_input->p->bookmark[i_bkmk]->i_byte_offset /
 
488
                        stream_Size( p_input->p->input.p_stream );
448
489
                    i_ret = var_Set( p_input, "position", pos );
449
490
                }
450
491
                else
453
494
                    i_ret = var_Set( p_input, "position", pos );
454
495
                }
455
496
 
456
 
                vlc_mutex_unlock( &p_input->input.p_item->lock );
 
497
                vlc_mutex_unlock( &p_input->p->input.p_item->lock );
457
498
                return i_ret;
458
499
            }
459
500
            else
460
501
            {
461
 
                vlc_mutex_unlock( &p_input->input.p_item->lock );
 
502
                vlc_mutex_unlock( &p_input->p->input.p_item->lock );
462
503
                return VLC_EGENERIC;
463
504
            }
464
505
 
466
507
 
467
508
        case INPUT_ADD_OPTION:
468
509
        {
469
 
            char *psz_option = (char *)va_arg( args, char * );
470
 
            char *psz_value = (char *)va_arg( args, char * );
 
510
            const char *psz_option = va_arg( args, const char * );
 
511
            const char *psz_value = va_arg( args, const char * );
 
512
            char *str;
471
513
            int i;
472
514
 
473
 
            vlc_mutex_lock( &p_input->input.p_item->lock );
474
 
            /* Check if option already exists */
475
 
            for( i = 0; i < p_input->input.p_item->i_options; i++ )
476
 
            {
477
 
                if( !strncmp( p_input->input.p_item->ppsz_options[i],
478
 
                              psz_option, strlen( psz_option ) ) &&
479
 
                    p_input->input.p_item->ppsz_options[i][strlen(psz_option)]
480
 
                      == '=' )
481
 
                {
482
 
                    free( p_input->input.p_item->ppsz_options[i] );
483
 
                    break;
484
 
                }
485
 
            }
486
 
            if( i == p_input->input.p_item->i_options )
487
 
            {
488
 
                p_input->input.p_item->i_options++;
489
 
                p_input->input.p_item->ppsz_options =
490
 
                    realloc( p_input->input.p_item->ppsz_options,
491
 
                             p_input->input.p_item->i_options *
492
 
                             sizeof(char **) );
493
 
            }
494
 
 
495
 
            asprintf( &p_input->input.p_item->ppsz_options[i],
496
 
                      "%s=%s", psz_option, psz_value ) ;
497
 
            vlc_mutex_unlock( &p_input->input.p_item->lock );
498
 
 
499
 
            return VLC_SUCCESS;
 
515
            if( asprintf( &str, "%s=%s", psz_option, psz_value ) == -1 )
 
516
                return VLC_ENOMEM;
 
517
 
 
518
            i = input_item_AddOpt( p_input->p->input.p_item, str,
 
519
                                  VLC_INPUT_OPTION_UNIQUE );
 
520
            free( str );
 
521
            return i;
500
522
        }
501
523
 
502
524
        case INPUT_GET_BYTE_POSITION:
503
525
            pi_64 = (int64_t*)va_arg( args, int64_t * );
504
 
            *pi_64 = !p_input->input.p_stream ? 0 :
505
 
                stream_Tell( p_input->input.p_stream );
 
526
            *pi_64 = !p_input->p->input.p_stream ? 0 :
 
527
                stream_Tell( p_input->p->input.p_stream );
506
528
            return VLC_SUCCESS;
507
529
 
508
530
        case INPUT_SET_BYTE_SIZE:
509
531
            pi_64 = (int64_t*)va_arg( args, int64_t * );
510
 
            *pi_64 = !p_input->input.p_stream ? 0 :
511
 
                stream_Size( p_input->input.p_stream );
512
 
            return VLC_SUCCESS;
 
532
            *pi_64 = !p_input->p->input.p_stream ? 0 :
 
533
                stream_Size( p_input->p->input.p_stream );
 
534
            return VLC_SUCCESS;
 
535
 
 
536
        case INPUT_GET_VIDEO_FPS:
 
537
        {
 
538
            int i;
 
539
            pf = (double*)va_arg( args, double * );
 
540
            vlc_mutex_lock( &p_input->p->input.p_item->lock );
 
541
            *pf = p_input->p->input.f_fps;
 
542
            for( i = 0; i < p_input->p->i_slave && *pf <= 0.001; i++ )
 
543
                *pf = p_input->p->slave[i]->f_fps;
 
544
            vlc_mutex_unlock( &p_input->p->input.p_item->lock );
 
545
            return VLC_SUCCESS;
 
546
        }
513
547
 
514
548
        case INPUT_ADD_SLAVE:
515
549
            psz = (char*)va_arg( args, char * );
520
554
            }
521
555
            return VLC_SUCCESS;
522
556
 
 
557
        case INPUT_GET_ATTACHMENTS: /* arg1=input_attachment_t***, arg2=int*  res=can fail */
 
558
        {
 
559
            input_attachment_t ***ppp_attachment = (input_attachment_t***)va_arg( args, input_attachment_t *** );
 
560
            int *pi_attachment = (int*)va_arg( args, int * );
 
561
            int i;
 
562
 
 
563
            vlc_mutex_lock( &p_input->p->input.p_item->lock );
 
564
            if( p_input->p->i_attachment <= 0 )
 
565
            {
 
566
                vlc_mutex_unlock( &p_input->p->input.p_item->lock );
 
567
                *ppp_attachment = NULL;
 
568
                *pi_attachment = 0;
 
569
                return VLC_EGENERIC;
 
570
            }
 
571
            *pi_attachment = p_input->p->i_attachment;
 
572
            *ppp_attachment = malloc( sizeof(input_attachment_t**) * p_input->p->i_attachment );
 
573
            for( i = 0; i < p_input->p->i_attachment; i++ )
 
574
                (*ppp_attachment)[i] = vlc_input_attachment_Duplicate( p_input->p->attachment[i] );
 
575
 
 
576
            vlc_mutex_unlock( &p_input->p->input.p_item->lock );
 
577
            return VLC_SUCCESS;
 
578
        }
 
579
 
 
580
        case INPUT_GET_ATTACHMENT:  /* arg1=input_attachment_t**, arg2=char*  res=can fail */
 
581
        {
 
582
            input_attachment_t **pp_attachment = (input_attachment_t**)va_arg( args, input_attachment_t ** );
 
583
            const char *psz_name = (const char*)va_arg( args, const char * );
 
584
            int i;
 
585
 
 
586
            vlc_mutex_lock( &p_input->p->input.p_item->lock );
 
587
            for( i = 0; i < p_input->p->i_attachment; i++ )
 
588
            {
 
589
                if( !strcmp( p_input->p->attachment[i]->psz_name, psz_name ) )
 
590
                {
 
591
                    *pp_attachment = vlc_input_attachment_Duplicate( p_input->p->attachment[i] );
 
592
                    vlc_mutex_unlock( &p_input->p->input.p_item->lock );
 
593
                    return VLC_SUCCESS;
 
594
                }
 
595
            }
 
596
            *pp_attachment = NULL;
 
597
            vlc_mutex_unlock( &p_input->p->input.p_item->lock );
 
598
            return VLC_EGENERIC;
 
599
        }
 
600
 
 
601
 
523
602
        default:
524
603
            msg_Err( p_input, "unknown query in input_vaControl" );
525
604
            return VLC_EGENERIC;
526
605
    }
527
606
}
528
607
 
529
 
static void NotifyPlaylist( input_thread_t *p_input )
530
 
{
531
 
    playlist_t *p_playlist =
532
 
        (playlist_t *)vlc_object_find( p_input, VLC_OBJECT_PLAYLIST,
533
 
                                       FIND_PARENT );
534
 
    if( p_playlist )
535
 
    {
536
 
        var_SetInteger( p_playlist, "item-change",
537
 
                        p_input->input.p_item->i_id );
538
 
        vlc_object_release( p_playlist );
539
 
    }
540
 
}
541
 
 
542
608
static void UpdateBookmarksOption( input_thread_t *p_input )
543
609
{
544
610
    int i, i_len = 0;
545
611
    char *psz_value = NULL, *psz_next = NULL;
546
612
 
547
 
    vlc_mutex_lock( &p_input->input.p_item->lock );
548
 
    for( i = 0; i < p_input->i_bookmark; i++ )
549
 
    {
550
 
        asprintf( &psz_value, "{name=%s,bytes="I64Fd",time="I64Fd"}",
551
 
                  p_input->bookmark[i]->psz_name,
552
 
                  p_input->bookmark[i]->i_byte_offset,
553
 
                  p_input->bookmark[i]->i_time_offset/1000000 );
554
 
        i_len += strlen( psz_value );
555
 
        free( psz_value );
556
 
    }
557
 
    for( i = 0; i < p_input->i_bookmark; i++ )
558
 
    {
559
 
        if( !i ) psz_value = psz_next = malloc( i_len + p_input->i_bookmark );
560
 
 
561
 
        sprintf( psz_next, "{name=%s,bytes="I64Fd",time="I64Fd"}",
562
 
                 p_input->bookmark[i]->psz_name,
563
 
                 p_input->bookmark[i]->i_byte_offset,
564
 
                 p_input->bookmark[i]->i_time_offset/1000000 );
565
 
 
566
 
        psz_next += strlen( psz_next );
567
 
        if( i < p_input->i_bookmark - 1)
568
 
        {
569
 
            *psz_next = ','; psz_next++;
570
 
        }
571
 
    }
572
 
    vlc_mutex_unlock( &p_input->input.p_item->lock );
 
613
    vlc_mutex_lock( &p_input->p->input.p_item->lock );
 
614
    if( p_input->p->i_bookmark > 0 )
 
615
    {
 
616
        for( i = 0; i < p_input->p->i_bookmark; i++ )
 
617
        {
 
618
            i_len += snprintf( NULL, 0, "{name=%s,bytes=%"PRId64",time=%"PRId64"}",
 
619
                               p_input->p->bookmark[i]->psz_name,
 
620
                               p_input->p->bookmark[i]->i_byte_offset,
 
621
                               p_input->p->bookmark[i]->i_time_offset/1000000 );
 
622
        }
 
623
        psz_value = psz_next = malloc( i_len + p_input->p->i_bookmark );
 
624
 
 
625
        for( i = 0; i < p_input->p->i_bookmark; i++ )
 
626
        {
 
627
            sprintf( psz_next, "{name=%s,bytes=%"PRId64",time=%"PRId64"}",
 
628
                     p_input->p->bookmark[i]->psz_name,
 
629
                     p_input->p->bookmark[i]->i_byte_offset,
 
630
                     p_input->p->bookmark[i]->i_time_offset/1000000 );
 
631
 
 
632
            psz_next += strlen( psz_next );
 
633
            if( i < p_input->p->i_bookmark - 1)
 
634
                *psz_next = ','; psz_next++;
 
635
        }
 
636
    }
 
637
    vlc_mutex_unlock( &p_input->p->input.p_item->lock );
573
638
 
574
639
    input_Control( p_input, INPUT_ADD_OPTION, "bookmarks",
575
640
                   psz_value ? psz_value : "" );
 
641
    free( psz_value );
576
642
}
 
643