VlcWrapper.cpp 23.6 KB
Newer Older
1
/*****************************************************************************
2
 * VlcWrapper.cpp: BeOS plugin for vlc (derived from MacOS X port)
3
4
 *****************************************************************************
 * Copyright (C) 2001 VideoLAN
Eric Petit's avatar
Eric Petit committed
5
 * $Id: VlcWrapper.cpp,v 1.34 2003/06/08 16:04:30 titer Exp $
6
7
8
9
 *
 * Authors: Florian G. Pflug <fgp@phlo.org>
 *          Jon Lech Johansen <jon-vl@nanocrew.net>
 *          Tony Casltey <tony@castley.net>
10
 *          Stephan Aßmus <stippi@yellowbites.com>
11
 *          Eric Petit <titer@videolan.org>
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
 *
 * This program is free software{} you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation{} either version 2 of the License, or
 * (at your option) any later version.
 * 
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY{} without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program{} if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111, USA.
 *****************************************************************************/
27
28
#include <AppKit.h>
#include <InterfaceKit.h>
29
30
31
32
#include <SupportKit.h>

#include <vlc/vlc.h>
#include <vlc/intf.h>
33
34
35
#include <vlc/vout.h>
extern "C"
{
36
  #include <input_ext-plugins.h> // needed here when compiling without plugins
37
38
  #include <audio_output.h>
  #include <aout_internal.h>
39
}
40

41
#include "VlcWrapper.h"
42
#include "MsgVals.h"
43

44
45
const char * _AddEllipsis( char * string )
{
46
47
48
49
    char * temp;
    temp = (char*) calloc( strlen( string ) + 4, 1 );
    sprintf( temp, "%s%s", string, B_UTF8_ELLIPSIS );
    return temp;
50
51
}

52
/* constructor */
53
VlcWrapper::VlcWrapper( intf_thread_t *p_interface )
54
{
55
    p_intf = p_interface;
56
57
58
    p_input = NULL;
    p_playlist = (playlist_t *)vlc_object_find( p_intf, VLC_OBJECT_PLAYLIST,
                                                FIND_ANYWHERE );
59
60
}

61
/* destructor */
62
VlcWrapper::~VlcWrapper()
63
{
64
65
    if( p_input )
        vlc_object_release( p_input );
66

67
68
    if( p_playlist )
        vlc_object_release( p_playlist );
69
}
70

71
72
/* UpdateInput: updates p_input */
void VlcWrapper::UpdateInput()
73
{
74
    if( !p_input )
75
76
77
        p_input = (input_thread_t *)vlc_object_find( p_intf, VLC_OBJECT_INPUT,
                                                     FIND_ANYWHERE );
        
78
    if( p_input )
79
80
81
82
83
84
85
        if( p_input->b_dead )
        {
            vlc_object_release( p_input );
            p_input = NULL;
        }
}

86
87
88
89
90

/***************************
 * input infos and control *
 ***************************/

91
92
bool VlcWrapper::HasInput()
{
93
    return ( p_input != NULL );
94
95
}

96
int VlcWrapper::InputStatus()
97
{
98
99
    if( !p_input )
        return UNDEF_S;
100
    
101
102
103
    return p_input->stream.control.i_status;
}

104
int VlcWrapper::InputRate()
105
{
106
107
    if( !p_input )
        return DEFAULT_RATE;
108
    
109
110
111
    return p_input->stream.control.i_rate;
}

112
void VlcWrapper::InputSetRate( int rate )
113
{
114
115
116
    if( !p_input )
        return;

117
    input_SetRate( p_input, rate );
118
119
}

Eric Petit's avatar
Eric Petit committed
120
BList * VlcWrapper::GetChannels( int i_cat )
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
{
    if( p_input )
    {
        unsigned int i;
        uint32 what;
        const char* fieldName;

        switch( i_cat )
        {
            case AUDIO_ES:
            {
                what = SELECT_CHANNEL;
                fieldName = "channel";
                break;
            }
            case SPU_ES:
            {
                what = SELECT_SUBTITLE;
                fieldName = "subtitle";
                break;
            }
            default:
            return NULL;
       }

        vlc_mutex_lock( &p_input->stream.stream_lock );
      
        /* find which track is currently playing */
        es_descriptor_t *p_es = NULL;
        for( i = 0; i < p_input->stream.i_selected_es_number; i++ )
        {
            if( p_input->stream.pp_selected_es[i]->i_cat == i_cat )
                p_es = p_input->stream.pp_selected_es[i];
        }
        
        /* build a list of all tracks */
        BList *list = new BList( p_input->stream.i_es_number );
        BMenuItem *menuItem;
        BMessage *message;
        char *trackName;
        
        /* "None" */
        message = new BMessage( what );
        message->AddInt32( fieldName, -1 );
165
        menuItem = new BMenuItem( _("None"), message );
166
167
168
169
170
171
172
173
174
175
        if( !p_es )
            menuItem->SetMarked( true );
        list->AddItem( menuItem );
        
        for( i = 0; i < p_input->stream.i_es_number; i++ )
        {
            if( p_input->stream.pp_es[i]->i_cat == i_cat )
            {
                message = new BMessage( what );
                message->AddInt32( fieldName, i );
gbazin's avatar
   
gbazin committed
176
177
                if( !p_input->stream.pp_es[i]->psz_desc ||
                    !*p_input->stream.pp_es[i]->psz_desc )
178
                    trackName = _("<unknown>");
gbazin's avatar
   
gbazin committed
179
180
                else
                    trackName = strdup( p_input->stream.pp_es[i]->psz_desc );
181
182
183
184
185
186
187
188
189
190
191
192
                menuItem = new BMenuItem( trackName, message );
                if( p_input->stream.pp_es[i] == p_es )
                    menuItem->SetMarked( true );
                list->AddItem( menuItem );
            }
        }
        
        vlc_mutex_unlock( &p_input->stream.stream_lock );

        return list;
    }
    return NULL;
193
194
}

195
void VlcWrapper::ToggleLanguage( int i_language )
196
{
197
198
    es_descriptor_t * p_es = NULL;
    es_descriptor_t * p_es_old = NULL;
199
200

    vlc_mutex_lock( &p_input->stream.stream_lock );
201
    for( unsigned int i = 0; i < p_input->stream.i_selected_es_number ; i++ )
202
    {
203
        if( p_input->stream.pp_selected_es[i]->i_cat == AUDIO_ES )
204
        {
205
            p_es_old = p_input->stream.pp_selected_es[i];
206
207
208
209
            break;
        }
    }
    vlc_mutex_unlock( &p_input->stream.stream_lock );
210
    
211
212
    if( i_language != -1 )
    {
213
        p_es = p_input->stream.pp_es[i_language];
214
    }
215
216
217
218
219
220
221
222
223
    if( p_es == p_es_old )
    {
        return;
    }
    if( p_es_old )
    {
        input_ToggleES( p_input, p_es_old, VLC_FALSE );
    }
    if( p_es )
224
    {
225
        input_ToggleES( p_input, p_es, VLC_TRUE );
226
227
228
    }
}

229
void VlcWrapper::ToggleSubtitle( int i_subtitle )
230
{
231
232
    es_descriptor_t * p_es = NULL;
    es_descriptor_t * p_es_old = NULL;
233
234

    vlc_mutex_lock( &p_input->stream.stream_lock );
235
    for( unsigned int i = 0; i < p_input->stream.i_selected_es_number ; i++ )
236
    {
237
        if( p_input->stream.pp_selected_es[i]->i_cat == SPU_ES )
238
        {
239
            p_es_old = p_input->stream.pp_selected_es[i];
240
241
242
243
244
245
246
            break;
        }
    }
    vlc_mutex_unlock( &p_input->stream.stream_lock );
    
    if( i_subtitle != -1 )
    {
247
        p_es = p_input->stream.pp_es[i_subtitle];
248
    }
249
250
251
252
253
    if( p_es == p_es_old )
    {
        return;
    }
    if( p_es_old )
254
    {
255
256
257
258
259
        input_ToggleES( p_input, p_es_old, VLC_FALSE );
    }
    if( p_es )
    {
        input_ToggleES( p_input, p_es, VLC_TRUE );
260
261
262
    }
}

Eric Petit's avatar
Eric Petit committed
263
const char * VlcWrapper::GetTimeAsString()
264
{
265
266
267
268
269
270
271
272
273
274
275
276
    static char psz_currenttime[ OFFSETTOTIME_MAX_SIZE ];
        
    if( p_input == NULL )
    {
        return ("-:--:--");
    }     
   
    input_OffsetToTime( p_input, 
                        psz_currenttime, 
                        p_input->stream.p_selected_area->i_tell );        

    return(psz_currenttime);
277
278
}

Eric Petit's avatar
Eric Petit committed
279
float VlcWrapper::GetTimeAsFloat()
280
{
281
282
283
    float f_time = 0.0;

    if( p_input != NULL )
284
    {
285
286
287
288
289
290
        f_time = (float)p_input->stream.p_selected_area->i_tell / 
                 (float)p_input->stream.p_selected_area->i_size;
    }    
    else
    {
        f_time = 0.0;
291
    }
292
    return( f_time );
293
294
}

Eric Petit's avatar
Eric Petit committed
295
void VlcWrapper::SetTimeAsFloat( float f_position )
296
{
297
    if( p_input != NULL )
298
    {
299
        input_Seek( p_input, 
300
                   (long long)(p_input->stream.p_selected_area->i_size
301
                       * f_position / SEEKSLIDER_RANGE ), 
302
                   INPUT_SEEK_SET );
303
304
305
    }
}

306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
bool VlcWrapper::IsPlaying()
{

	bool playing = false;
	if ( p_input )
	{
		switch ( p_input->stream.control.i_status )
		{
			case PLAYING_S:
			case FORWARD_S:
			case BACKWARD_S:
			case START_S:
				playing = true;
	            break;
			case PAUSE_S:
			case UNDEF_S:
			case NOT_STARTED_S:
			default:
				break;
		}
	}
	return playing;

}
330

Eric Petit's avatar
Eric Petit committed
331
332
333
334
/************
 * playlist *
 ************/

335
void VlcWrapper::OpenFiles( BList* o_files, bool replace, int32 index )
Eric Petit's avatar
Eric Petit committed
336
{
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
	if ( o_files && o_files->CountItems() > 0)
	{
	    int size = PlaylistSize();
		bool wasEmpty = ( size < 1 );
		if ( index == -1 )
			index = PLAYLIST_END;
		int mode = index == PLAYLIST_END ? PLAYLIST_APPEND : PLAYLIST_INSERT;
	
	    /* delete current playlist */
	    if( replace )
	    {
	        for( int i = 0; i < size; i++ )
	        {
	            playlist_Delete( p_playlist, 0 );
	        }
	    }
	
	    /* insert files */
	    int32 count = o_files->CountItems();
	    for ( int32 i = count - 1; i >= 0; i-- )
	    {
	    	if ( BString* o_file = (BString *)o_files->RemoveItem( i ) )
	    	{
		        playlist_Add( p_playlist, o_file->String(),
		                      mode, index );
		        if ( mode == PLAYLIST_INSERT )
		        	index++;
		        delete o_file;
	    	}
	    }
	    // TODO: implement a user setting
	    // if to start automatically
	    /* eventually restart playing */
	    if( replace || wasEmpty )
	    {
	        playlist_Stop( p_playlist );
	        playlist_Play( p_playlist );
	    }
	}
Eric Petit's avatar
Eric Petit committed
376
377
378
379
}
 
void VlcWrapper::OpenDisc(BString o_type, BString o_device, int i_title, int i_chapter)
{
380
381
    if( config_GetInt( p_intf, "beos-dvdmenus" ) )
        o_device.Prepend( "dvdplay:" );
382
    else
Eric Petit's avatar
Eric Petit committed
383
384
385
386
387
        o_device.Prepend( "dvdold:" );
    playlist_Add( p_playlist, o_device.String(),
                  PLAYLIST_APPEND | PLAYLIST_GO, PLAYLIST_END );
}

388
int VlcWrapper::PlaylistSize()
389
390
{
    vlc_mutex_lock( &p_playlist->object_lock );
391
392
393
394
395
    int i_size = p_playlist->i_size;
    vlc_mutex_unlock( &p_playlist->object_lock );
    return i_size;
}

Eric Petit's avatar
Eric Petit committed
396
char * VlcWrapper::PlaylistItemName( int i )
397
398
399
400
401
402
403
404
405
406
407
408
{
   return p_playlist->pp_items[i]->psz_name;
}

int VlcWrapper::PlaylistCurrent()
{
    return p_playlist->i_index;
}

bool VlcWrapper::PlaylistPlay()
{
    if( PlaylistSize() )
409
410
411
412
413
414
    {
        playlist_Play( p_playlist );
    }
    return( true );
}

415
void VlcWrapper::PlaylistPause()
416
{
417
    if( p_input )
418
    {
419
        input_SetStatus( p_input, INPUT_STATUS_PAUSE );
420
    }
421
422
}

423
void VlcWrapper::PlaylistStop()
424
425
426
427
{
    playlist_Stop( p_playlist );
}

428
void VlcWrapper::PlaylistNext()
429
430
431
432
{
    playlist_Next( p_playlist );
}

433
void VlcWrapper::PlaylistPrev()
434
435
436
437
{
    playlist_Prev( p_playlist );
}

Eric Petit's avatar
Eric Petit committed
438
void VlcWrapper::GetPlaylistInfo( int32& currentIndex, int32& maxIndex )
439
440
441
442
443
{
	currentIndex = -1;
	maxIndex = -1;
	if ( p_playlist )
	{
444
445
	    vlc_mutex_lock( &p_playlist->object_lock );

446
447
		maxIndex = p_playlist->i_size;
		if ( maxIndex > 0 )
448
			currentIndex = p_playlist->i_index/* + 1 -> why?!?*/;
449
450
		else
			maxIndex = -1;
451
452

	    vlc_mutex_unlock( &p_playlist->object_lock );
453
454
455
456
	}
}

void VlcWrapper::PlaylistJumpTo( int pos )
457
{
Eric Petit's avatar
Eric Petit committed
458
459
460
461
    playlist_Goto( p_playlist, pos );
}

void VlcWrapper::GetNavCapabilities( bool *canSkipPrev, bool *canSkipNext )
462
463
464
465
466
467
468
{
	if ( canSkipPrev && canSkipNext )
	{
		// init the parameters
		*canSkipPrev = false;
		*canSkipNext = false;
		// get playlist info
469
470
		int pos = PlaylistCurrent();
		int size = PlaylistSize();
471
472

		// see if we have got a stream going		
473
		if ( p_input )
474
		{
475
			vlc_mutex_lock( &p_input->stream.stream_lock );
476

477
478
			bool hasTitles = p_input->stream.i_area_nb > 1;
			int numChapters = p_input->stream.p_selected_area->i_part_nb;
479
480
481
482
			bool hasChapters = numChapters > 1;
			// first, look for chapters
			if ( hasChapters )
			{
483
484
485
				*canSkipPrev = p_input->stream.p_selected_area->i_part > 0;
				*canSkipNext = p_input->stream.p_selected_area->i_part <
									 p_input->stream.p_selected_area->i_part_nb - 1;
486
487
488
489
			}
			// if one of the skip capabilities is false,
			// make it depend on titles instead
			if ( !*canSkipPrev && hasTitles )
490
				*canSkipPrev = p_input->stream.p_selected_area->i_id > 1;
491
			if ( !*canSkipNext && hasTitles )
492
493
				*canSkipNext = p_input->stream.p_selected_area->i_id <
				                   p_input->stream.i_area_nb - 1;
494

495
			vlc_mutex_unlock( &p_input->stream.stream_lock );
496
497
498
499
500
501
502
503
504
		}
		// last but not least, make capabilities depend on playlist
		if ( !*canSkipPrev )
			*canSkipPrev = pos > 0;
		if ( !*canSkipNext )
			*canSkipNext = pos < size - 1;
	}
}

Eric Petit's avatar
Eric Petit committed
505
void VlcWrapper::NavigatePrev()
506
507
508
509
{
	bool hasSkiped = false;

	// see if we have got a stream going		
510
	if ( p_input )
511
512
	{
		// get information from stream (lock it while looking at it)
513
		vlc_mutex_lock( &p_input->stream.stream_lock );
514

515
516
517
		int currentTitle = p_input->stream.p_selected_area->i_id;
		int currentChapter = p_input->stream.p_selected_area->i_part;
		int numTitles = p_input->stream.i_area_nb;
518
		bool hasTitles = numTitles > 1;
519
		int numChapters = p_input->stream.p_selected_area->i_part_nb;
520
521
		bool hasChapters = numChapters > 1;

522
		vlc_mutex_unlock( &p_input->stream.stream_lock );
523
524
525
526
527
528
529
530
531

		// first, look for chapters
		if ( hasChapters )
		{
			// skip to the previous chapter
			currentChapter--;

			if ( currentChapter >= 0 )
			{
Eric Petit's avatar
Eric Petit committed
532
				ToggleChapter( currentChapter );
533
534
535
536
537
538
539
540
541
542
543
				hasSkiped = true;
			}
		}
		// if we couldn't skip chapters, try titles instead
		if ( !hasSkiped && hasTitles )
		{
			// skip to the previous title
			currentTitle--;
			// disallow area 0 since it is used for video_ts.vob
			if( currentTitle > 0 )
			{
Eric Petit's avatar
Eric Petit committed
544
				ToggleTitle(currentTitle);
545
546
547
548
549
550
551
				hasSkiped = true;
			}
		}

	}
	// last but not least, skip to previous file
	if ( !hasSkiped )
552
		PlaylistPrev();
553
554
}

Eric Petit's avatar
Eric Petit committed
555
void VlcWrapper::NavigateNext()
556
557
558
559
{
	bool hasSkiped = false;

	// see if we have got a stream going		
560
	if ( p_input )
561
562
	{
		// get information from stream (lock it while looking at it)
563
		vlc_mutex_lock( &p_input->stream.stream_lock );
564

565
566
567
		int currentTitle = p_input->stream.p_selected_area->i_id;
		int currentChapter = p_input->stream.p_selected_area->i_part;
		int numTitles = p_input->stream.i_area_nb;
568
		bool hasTitles = numTitles > 1;
569
		int numChapters = p_input->stream.p_selected_area->i_part_nb;
570
571
		bool hasChapters = numChapters > 1;

572
		vlc_mutex_unlock( &p_input->stream.stream_lock );
573
574
575
576
577
578
579
580

		// first, look for chapters
		if ( hasChapters )
		{
			// skip to the next chapter
			currentChapter++;
			if ( currentChapter < numChapters )
			{
Eric Petit's avatar
Eric Petit committed
581
				ToggleChapter( currentChapter );
582
583
584
585
586
587
588
589
590
591
592
				hasSkiped = true;
			}
		}
		// if we couldn't skip chapters, try titles instead
		if ( !hasSkiped && hasTitles )
		{
			// skip to the next title
			currentTitle++;
			// disallow area 0 since it is used for video_ts.vob
			if ( currentTitle < numTitles - 1 )
			{
Eric Petit's avatar
Eric Petit committed
593
				ToggleTitle(currentTitle);
594
595
596
597
598
599
600
				hasSkiped = true;
			}
		}

	}
	// last but not least, skip to next file
	if ( !hasSkiped )
601
		PlaylistNext();
602
603
}

604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
/*************************
 * Playlist manipulation *
 *************************/

// PlaylistLock
bool
VlcWrapper::PlaylistLock() const
{
// TODO: search and destroy -> deadlock!
return true;
	if ( p_playlist )
	{
 		vlc_mutex_lock( &p_playlist->object_lock );
 		return true;
 	}
 	return false;
}

// PlaylistUnlock
void
VlcWrapper::PlaylistUnlock() const
{
// TODO: search and destroy -> deadlock!
return;
	vlc_mutex_unlock( &p_playlist->object_lock );
}

// PlaylistItemAt
void*
VlcWrapper::PlaylistItemAt( int index ) const
{
	playlist_item_t* item = NULL;
	if ( index >= 0 && index < p_playlist->i_size )
		item = p_playlist->pp_items[index];
	return (void*)item;
}

// PlaylistRemoveItem
void*
VlcWrapper::PlaylistRemoveItem( int index ) const
{
	playlist_item_t* copy = NULL;
	// check if item exists at the provided index
	if ( index >= 0 && index < p_playlist->i_size )
	{
		playlist_item_t* item = p_playlist->pp_items[index];
		if ( item )
		{
			// make a copy of the removed item
			copy = (playlist_item_t*)PlaylistCloneItem( (void*)item );
			// remove item from playlist (unfortunately, this frees it)
			playlist_Delete( p_playlist, index );
		}
	}
	return (void*)copy;
}

// PlaylistRemoveItem
void*
VlcWrapper::PlaylistRemoveItem( void* item ) const
{
	playlist_item_t* copy = NULL;
	for ( int32 i = 0; i < p_playlist->i_size; i++ )
	{
		if ( p_playlist->pp_items[i] == item )
		{
			copy = (playlist_item_t*)PlaylistRemoveItem( i );
			break;
		}
	}
	return (void*)copy;
}

// PlaylistAddItem
bool
VlcWrapper::PlaylistAddItem( void* item, int index ) const
{
	if ( item )
	{
		playlist_AddItem( p_playlist, (playlist_item_t*)item,
						  PLAYLIST_INSERT, index );
	}
	// TODO: once playlist is returning useful info, return that instead
	return true;
}

// PlaylistCloneItem
void*
VlcWrapper::PlaylistCloneItem( void* castToItem ) const
{
	playlist_item_t* copy = NULL;
	playlist_item_t* item = (playlist_item_t*)castToItem;
	if ( item )
	{
		copy = (playlist_item_t*)malloc( sizeof( playlist_item_t ) );
		if ( copy )
		{
			// make a copy of the item at index
			copy->psz_name = strdup( item->psz_name );
			copy->psz_uri  = strdup( item->psz_uri );
			copy->i_type = item->i_type;
			copy->i_status = item->i_status;
			copy->b_autodeletion = item->b_autodeletion;
		}
	}
	return (void*)copy;
}

// Careful! You need to know what you're doing here!
// The reason for having it, is to be able to deal with
// the rather lame list implementation of the playlist.
// It is meant to help manipulate the playlist with the above
// methods while keeping it valid.
//
// PlaylistSetPlaying
void
VlcWrapper::PlaylistSetPlaying( int index ) const
{
	if ( index < 0 )
		index = 0;
	if ( index >= p_playlist->i_size )
		index = p_playlist->i_size - 1;
	p_playlist->i_index = index;
}

729

Eric Petit's avatar
Eric Petit committed
730
731
732
733
/*********
 * audio *
 *********/

734
735
unsigned short VlcWrapper::GetVolume()
{
Eric Petit's avatar
Eric Petit committed
736
737
738
    unsigned short i_volume;
    aout_VolumeGet( p_intf, (audio_volume_t*)&i_volume );
    return i_volume;
739
740
}

Eric Petit's avatar
Eric Petit committed
741
void VlcWrapper::SetVolume( int value )
742
{
Eric Petit's avatar
Eric Petit committed
743
    if ( p_intf->p_sys->b_mute )
744
    {
Eric Petit's avatar
Eric Petit committed
745
        p_intf->p_sys->b_mute = 0;
746
    }
Eric Petit's avatar
Eric Petit committed
747
    aout_VolumeSet( p_intf, value );
748
}
749

750
void VlcWrapper::VolumeMute()
751
{
Eric Petit's avatar
Eric Petit committed
752
753
754
   	aout_VolumeGet( p_intf, &p_intf->p_sys->i_saved_volume );
    aout_VolumeMute( p_intf, NULL );
    p_intf->p_sys->b_mute = 1;
755
756
}

757
void VlcWrapper::VolumeRestore()
758
{
Eric Petit's avatar
Eric Petit committed
759
760
    aout_VolumeSet( p_intf, p_intf->p_sys->i_saved_volume );
    p_intf->p_sys->b_mute = 0;
761
}
762

763
bool VlcWrapper::IsMuted()
764
{
765
    return p_intf->p_sys->b_mute;
766
767
}

768
769
770
/*******
 * DVD *
 *******/
Eric Petit's avatar
Eric Petit committed
771

772
773
774
775
776
bool VlcWrapper::IsUsingMenus()
{
    if( !p_input )
        return false;

Eric Petit's avatar
Eric Petit committed
777
778
779
780
781
782
783
784
785
786
787
    vlc_mutex_lock( &p_playlist->object_lock );
    if( p_playlist->i_index < 0 )
    {
        vlc_mutex_unlock( &p_playlist->object_lock );
        return false;
    }
    
    char * psz_name = p_playlist->pp_items[p_playlist->i_index]->psz_name;
    if( !strncmp( psz_name, "dvdplay:", 8 ) )
    {
        vlc_mutex_unlock( &p_playlist->object_lock );
788
        return true;
Eric Petit's avatar
Eric Petit committed
789
790
    }
    vlc_mutex_unlock( &p_playlist->object_lock );
791
792
793
794

    return false;
}

795
bool VlcWrapper::HasTitles()
796
{
797
798
    if( !p_input )
        return false;
799

800
    return ( p_input->stream.i_area_nb > 1 );
801
802
}

Eric Petit's avatar
Eric Petit committed
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
BList * VlcWrapper::GetTitles()
{
    if( p_input )
    {
        vlc_mutex_lock( &p_input->stream.stream_lock );
      
        BList *list = new BList( p_input->stream.i_area_nb );
        BMenuItem *menuItem;
        BMessage *message;
        
        for( unsigned int i = 1; i < p_input->stream.i_area_nb; i++ )
        {
            message = new BMessage( TOGGLE_TITLE );
            message->AddInt32( "index", i );
            BString helper( "" );
            helper << i;
            menuItem = new BMenuItem( helper.String(), message );
            menuItem->SetMarked( p_input->stream.p_selected_area->i_id == i );
            list->AddItem( menuItem );
        }
        
        vlc_mutex_unlock( &p_input->stream.stream_lock );

        return list;
    }
    return NULL;
}

831
void VlcWrapper::PrevTitle()
832
{
833
834
835
    int i_id;
    i_id = p_input->stream.p_selected_area->i_id - 1;
    if( i_id > 0 )
836
    {
Eric Petit's avatar
Eric Petit committed
837
        ToggleTitle(i_id);
838
839
840
    }
}

841
void VlcWrapper::NextTitle()
842
{
843
    unsigned int i_id;
844
845
    i_id = p_input->stream.p_selected_area->i_id + 1;
    if( i_id < p_input->stream.i_area_nb )
846
    {
Eric Petit's avatar
Eric Petit committed
847
848
849
850
851
852
853
854
855
856
857
858
859
860
        ToggleTitle(i_id);
    }
}

void VlcWrapper::ToggleTitle(int i_title)
{
    if( p_input != NULL )
    {
        input_ChangeArea( p_input,
                          p_input->stream.pp_areas[i_title] );

        vlc_mutex_lock( &p_input->stream.stream_lock );

        vlc_mutex_unlock( &p_input->stream.stream_lock );
861
862
863
    }
}

Eric Petit's avatar
Eric Petit committed
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
void VlcWrapper::TitleInfo( int32 &currentIndex, int32 &maxIndex )
{
	currentIndex = -1;
	maxIndex = -1;
	if ( p_input )
	{
		vlc_mutex_lock( &p_input->stream.stream_lock );

		maxIndex = p_input->stream.i_area_nb - 1;
		if ( maxIndex > 0)
			currentIndex = p_input->stream.p_selected_area->i_id;
		else
			maxIndex = -1;

		vlc_mutex_unlock( &p_input->stream.stream_lock );
	}
}

882
883
884
bool VlcWrapper::HasChapters()
{
    if( !p_input )
885
    {
886
        return false;
887
    }
888
889
    return ( p_input->stream.p_selected_area->i_part_nb > 1 );
}
890

Eric Petit's avatar
Eric Petit committed
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
BList * VlcWrapper::GetChapters()
{
    if( p_input )
    {
        vlc_mutex_lock( &p_input->stream.stream_lock );
      
        BList *list = new BList( p_input->stream.p_selected_area->i_part_nb );
        BMenuItem *menuItem;
        BMessage *message;
        
        for( unsigned int i = 1;
             i < p_input->stream.p_selected_area->i_part_nb + 1; i++ )
        {
            message = new BMessage( TOGGLE_CHAPTER );
            message->AddInt32( "index", i );
            BString helper( "" );
            helper << i;
            menuItem = new BMenuItem( helper.String(), message );
            menuItem->SetMarked( p_input->stream.p_selected_area->i_part == i );
            list->AddItem( menuItem );
        }
        
        vlc_mutex_unlock( &p_input->stream.stream_lock );

        return list;
    }
    return NULL;
}

920
921
922
923
924
925
void VlcWrapper::PrevChapter()
{
    int i_id;
    i_id = p_input->stream.p_selected_area->i_part - 1;
    if( i_id >= 0 )
    {
Eric Petit's avatar
Eric Petit committed
926
        ToggleChapter(i_id);
927
    }
928
929
}

930
void VlcWrapper::NextChapter()
Eric Petit's avatar
Eric Petit committed
931
{
932
933
934
935
    int i_id;
    i_id = p_input->stream.p_selected_area->i_part + 1;
    if( i_id >= 0 )
    {
Eric Petit's avatar
Eric Petit committed
936
        ToggleChapter(i_id);
937
    }
Eric Petit's avatar
Eric Petit committed
938
939
}

Eric Petit's avatar
Eric Petit committed
940
void VlcWrapper::ToggleChapter(int i_chapter)
Eric Petit's avatar
Eric Petit committed
941
{
Eric Petit's avatar
Eric Petit committed
942
943
944
945
946
    if( p_input != NULL )
    {
        p_input->stream.p_selected_area->i_part = i_chapter;
        input_ChangeArea( p_input,
                          p_input->stream.p_selected_area );
Eric Petit's avatar
Eric Petit committed
947

Eric Petit's avatar
Eric Petit committed
948
949
950
        vlc_mutex_lock( &p_input->stream.stream_lock );
        vlc_mutex_unlock( &p_input->stream.stream_lock );
    }
Eric Petit's avatar
Eric Petit committed
951
952
}

953
void VlcWrapper::ChapterInfo( int32 &currentIndex, int32 &maxIndex )
Eric Petit's avatar
Eric Petit committed
954
955
956
{
	currentIndex = -1;
	maxIndex = -1;
957
	if ( p_input )
Eric Petit's avatar
Eric Petit committed
958
	{
959
		vlc_mutex_lock( &p_input->stream.stream_lock );
Eric Petit's avatar
Eric Petit committed
960

961
		maxIndex = p_input->stream.p_selected_area->i_part_nb - 1;
Eric Petit's avatar
Eric Petit committed
962
		if ( maxIndex > 0)
963
			currentIndex = p_input->stream.p_selected_area->i_part;
Eric Petit's avatar
Eric Petit committed
964
965
966
		else
			maxIndex = -1;

967
		vlc_mutex_unlock( &p_input->stream.stream_lock );
Eric Petit's avatar
Eric Petit committed
968
969
970
	}
}

Eric Petit's avatar
Eric Petit committed
971
972
973
974
/****************
 * Miscellanous *
 ****************/
 
975
void VlcWrapper::LoadSubFile( const char * psz_file )
976
{
Eric Petit's avatar
Eric Petit committed
977
    config_PutPsz( p_intf, "sub-file", strdup( psz_file ) );
978
}
979
980
981
982
983
984
985
986
987

void VlcWrapper::FilterChange()
{
    if( !p_input )
        return;
    
    vout_thread_t * p_vout;
    vlc_mutex_lock( &p_input->stream.stream_lock );

Stephan Assmus's avatar
   
Stephan Assmus committed
988
    // Warn the vout we are about to change the filter chain
989
990
991
992
993
994
995
996
    p_vout = (vout_thread_t*)vlc_object_find( p_intf, VLC_OBJECT_VOUT,
                                              FIND_ANYWHERE );
    if( p_vout )
    {
        p_vout->b_filter_change = VLC_TRUE;
        vlc_object_release( p_vout );
    }

Stephan Assmus's avatar
   
Stephan Assmus committed
997
    // restart all video stream
998
999
1000
1001
1002
1003
1004
1005
1006
1007
1008
    for( unsigned int i = 0; i < p_input->stream.i_es_number; i++ )
    {
        if( ( p_input->stream.pp_es[i]->i_cat == VIDEO_ES ) &&
            ( p_input->stream.pp_es[i]->p_decoder_fifo != NULL ) )
        {
            input_UnselectES( p_input, p_input->stream.pp_es[i] );
            input_SelectES( p_input, p_input->stream.pp_es[i] );
        }
    }
    vlc_mutex_unlock( &p_input->stream.stream_lock );
}