VlcWrapper.cpp 23.7 KB
Newer Older
1
/*****************************************************************************
2
 * VlcWrapper.cpp: BeOS plugin for vlc (derived from MacOS X port)
3
4
 *****************************************************************************
 * Copyright (C) 2001 VideoLAN
5
 * $Id: VlcWrapper.cpp,v 1.24 2003/02/01 12:01:11 stippi 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
36
37
#include <vlc/vout.h>
extern "C"
{
  #include <audio_output.h>
  #include <aout_internal.h>
38
}
39

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

43
/* constructor */
44
VlcWrapper::VlcWrapper( intf_thread_t *p_interface )
45
{
46
    p_intf = p_interface;
47
48
49
50
    p_input = NULL;
    p_aout = NULL;
    p_playlist = (playlist_t *)vlc_object_find( p_intf, VLC_OBJECT_PLAYLIST,
                                                FIND_ANYWHERE );
51
52
}

53
/* destructor */
54
VlcWrapper::~VlcWrapper()
55
{
56
57
58
59
60
61
62
63
64
65
66
67
    if( p_input )
    {
        vlc_object_release( p_input );
    }
    if( p_playlist )
    {
        vlc_object_release( p_playlist );
    }
    if( p_aout )
    {
        vlc_object_release( p_aout );
    }
68
}
69
70
71

/* UpdateInputAndAOut: updates p_input and p_aout, returns true if the
   interface needs to be updated */
72
bool VlcWrapper::UpdateInputAndAOut()
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
{
    if( p_input == NULL )
    {
        p_input = (input_thread_t *)vlc_object_find( p_intf, VLC_OBJECT_INPUT,
                                                     FIND_ANYWHERE );
    }
    if( p_aout == NULL )
    {
        p_aout = (aout_instance_t*)vlc_object_find( p_intf, VLC_OBJECT_AOUT,
                                                    FIND_ANYWHERE );
    }
        
    if( p_input != NULL )
    {
        if( p_input->b_dead )
        {
            vlc_object_release( p_input );
            p_input = NULL;
            
            if( p_aout )
            {
                vlc_object_release( p_aout );
                p_aout = NULL;
            }
        }
        return true;
    }
    return false;
}

103
104
105
106
107

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

108
109
bool VlcWrapper::HasInput()
{
110
    return ( p_input != NULL );
111
112
}

113
int VlcWrapper::InputStatus()
114
{
115
116
117
118
    if( !p_input )
    {
        return UNDEF_S;
    }
119
120
121
    return p_input->stream.control.i_status;
}

122
int VlcWrapper::InputRate()
123
{
124
125
126
127
    if( !p_input )
    {
        return DEFAULT_RATE;
    }
128
129
130
    return p_input->stream.control.i_rate;
}

131
void VlcWrapper::InputSlower()
132
{
133
134
135
136
    if( p_input != NULL )
    {
        input_SetStatus( p_input, INPUT_STATUS_SLOWER );
    }
137
138
}

139
void VlcWrapper::InputFaster()
140
{
141
142
143
144
    if( p_input != NULL )
    {
        input_SetStatus( p_input, INPUT_STATUS_FASTER );
    }
145
146
}

Eric Petit's avatar
Eric Petit committed
147
BList * VlcWrapper::GetChannels( int i_cat )
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
{
    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 );
        menuItem = new BMenuItem( "None", message );
        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 );
                if( strlen( p_input->stream.pp_es[i]->psz_desc ) )
                    trackName = strdup( p_input->stream.pp_es[i]->psz_desc );
                else
                    trackName = "<unknown>";
                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;
219
220
}

221
void VlcWrapper::ToggleLanguage( int i_language )
222
{
223
224
    es_descriptor_t * p_es = NULL;
    es_descriptor_t * p_es_old = NULL;
225
226

    vlc_mutex_lock( &p_input->stream.stream_lock );
227
    for( unsigned int i = 0; i < p_input->stream.i_selected_es_number ; i++ )
228
    {
229
        if( p_input->stream.pp_selected_es[i]->i_cat == AUDIO_ES )
230
        {
231
            p_es_old = p_input->stream.pp_selected_es[i];
232
233
234
235
            break;
        }
    }
    vlc_mutex_unlock( &p_input->stream.stream_lock );
236
    
237
238
    if( i_language != -1 )
    {
239
        p_es = p_input->stream.pp_es[i_language];
240
    }
241
242
243
244
245
246
247
248
249
    if( p_es == p_es_old )
    {
        return;
    }
    if( p_es_old )
    {
        input_ToggleES( p_input, p_es_old, VLC_FALSE );
    }
    if( p_es )
250
    {
251
        input_ToggleES( p_input, p_es, VLC_TRUE );
252
253
254
    }
}

255
void VlcWrapper::ToggleSubtitle( int i_subtitle )
256
{
257
258
    es_descriptor_t * p_es = NULL;
    es_descriptor_t * p_es_old = NULL;
259
260

    vlc_mutex_lock( &p_input->stream.stream_lock );
261
    for( unsigned int i = 0; i < p_input->stream.i_selected_es_number ; i++ )
262
    {
263
        if( p_input->stream.pp_selected_es[i]->i_cat == SPU_ES )
264
        {
265
            p_es_old = p_input->stream.pp_selected_es[i];
266
267
268
269
270
271
272
            break;
        }
    }
    vlc_mutex_unlock( &p_input->stream.stream_lock );
    
    if( i_subtitle != -1 )
    {
273
        p_es = p_input->stream.pp_es[i_subtitle];
274
    }
275
276
277
278
279
    if( p_es == p_es_old )
    {
        return;
    }
    if( p_es_old )
280
    {
281
282
283
284
285
        input_ToggleES( p_input, p_es_old, VLC_FALSE );
    }
    if( p_es )
    {
        input_ToggleES( p_input, p_es, VLC_TRUE );
286
287
288
    }
}

Eric Petit's avatar
Eric Petit committed
289
const char * VlcWrapper::GetTimeAsString()
290
{
291
292
293
294
295
296
297
298
299
300
301
302
    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);
303
304
}

Eric Petit's avatar
Eric Petit committed
305
float VlcWrapper::GetTimeAsFloat()
306
{
307
308
309
    float f_time = 0.0;

    if( p_input != NULL )
310
    {
311
312
313
314
315
316
        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;
317
    }
318
    return( f_time );
319
320
}

Eric Petit's avatar
Eric Petit committed
321
void VlcWrapper::SetTimeAsFloat( float f_position )
322
{
323
    if( p_input != NULL )
324
    {
325
326
327
328
        input_Seek( p_input, 
                   (long long int)(p_input->stream.p_selected_area->i_size
                       * f_position / SEEKSLIDER_RANGE ), 
                   INPUT_SEEK_SET);
329
330
331
    }
}

332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
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;

}
356

Eric Petit's avatar
Eric Petit committed
357
358
359
360
/************
 * playlist *
 ************/

361
void VlcWrapper::OpenFiles( BList* o_files, bool replace, int32 index )
Eric Petit's avatar
Eric Petit committed
362
{
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
	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
402
403
404
405
}
 
void VlcWrapper::OpenDisc(BString o_type, BString o_device, int i_title, int i_chapter)
{
406
407
408
    if( p_intf->p_sys->b_dvdmenus )
        o_device.Prepend( "dvd:" );
    else
Eric Petit's avatar
Eric Petit committed
409
410
411
412
413
        o_device.Prepend( "dvdold:" );
    playlist_Add( p_playlist, o_device.String(),
                  PLAYLIST_APPEND | PLAYLIST_GO, PLAYLIST_END );
}

414
int VlcWrapper::PlaylistSize()
415
416
{
    vlc_mutex_lock( &p_playlist->object_lock );
417
418
419
420
421
    int i_size = p_playlist->i_size;
    vlc_mutex_unlock( &p_playlist->object_lock );
    return i_size;
}

Eric Petit's avatar
Eric Petit committed
422
char * VlcWrapper::PlaylistItemName( int i )
423
424
425
426
427
428
429
430
431
432
433
434
{
   return p_playlist->pp_items[i]->psz_name;
}

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

bool VlcWrapper::PlaylistPlay()
{
    if( PlaylistSize() )
435
436
437
438
439
440
    {
        playlist_Play( p_playlist );
    }
    return( true );
}

441
void VlcWrapper::PlaylistPause()
442
{
443
    if( p_input )
444
    {
445
        input_SetStatus( p_input, INPUT_STATUS_PAUSE );
446
    }
447
448
}

449
void VlcWrapper::PlaylistStop()
450
451
452
453
{
    playlist_Stop( p_playlist );
}

454
void VlcWrapper::PlaylistNext()
455
456
457
458
{
    playlist_Next( p_playlist );
}

459
void VlcWrapper::PlaylistPrev()
460
461
462
463
{
    playlist_Prev( p_playlist );
}

Eric Petit's avatar
Eric Petit committed
464
void VlcWrapper::GetPlaylistInfo( int32& currentIndex, int32& maxIndex )
465
466
467
468
469
{
	currentIndex = -1;
	maxIndex = -1;
	if ( p_playlist )
	{
470
471
	    vlc_mutex_lock( &p_playlist->object_lock );

472
473
		maxIndex = p_playlist->i_size;
		if ( maxIndex > 0 )
474
			currentIndex = p_playlist->i_index/* + 1 -> why?!?*/;
475
476
		else
			maxIndex = -1;
477
478

	    vlc_mutex_unlock( &p_playlist->object_lock );
479
480
481
482
	}
}

void VlcWrapper::PlaylistJumpTo( int pos )
483
{
Eric Petit's avatar
Eric Petit committed
484
485
486
487
    playlist_Goto( p_playlist, pos );
}

void VlcWrapper::GetNavCapabilities( bool *canSkipPrev, bool *canSkipNext )
488
489
490
491
492
493
494
{
	if ( canSkipPrev && canSkipNext )
	{
		// init the parameters
		*canSkipPrev = false;
		*canSkipNext = false;
		// get playlist info
495
496
		int pos = PlaylistCurrent();
		int size = PlaylistSize();
497
498

		// see if we have got a stream going		
499
		if ( p_input )
500
		{
501
			vlc_mutex_lock( &p_input->stream.stream_lock );
502

503
504
			bool hasTitles = p_input->stream.i_area_nb > 1;
			int numChapters = p_input->stream.p_selected_area->i_part_nb;
505
506
507
508
			bool hasChapters = numChapters > 1;
			// first, look for chapters
			if ( hasChapters )
			{
509
510
511
				*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;
512
513
514
515
			}
			// if one of the skip capabilities is false,
			// make it depend on titles instead
			if ( !*canSkipPrev && hasTitles )
516
				*canSkipPrev = p_input->stream.p_selected_area->i_id > 1;
517
			if ( !*canSkipNext && hasTitles )
518
519
				*canSkipNext = p_input->stream.p_selected_area->i_id <
				                   p_input->stream.i_area_nb - 1;
520

521
			vlc_mutex_unlock( &p_input->stream.stream_lock );
522
523
524
525
526
527
528
529
530
		}
		// 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
531
void VlcWrapper::NavigatePrev()
532
533
534
535
{
	bool hasSkiped = false;

	// see if we have got a stream going		
536
	if ( p_input )
537
538
	{
		// get information from stream (lock it while looking at it)
539
		vlc_mutex_lock( &p_input->stream.stream_lock );
540

541
542
543
		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;
544
		bool hasTitles = numTitles > 1;
545
		int numChapters = p_input->stream.p_selected_area->i_part_nb;
546
547
		bool hasChapters = numChapters > 1;

548
		vlc_mutex_unlock( &p_input->stream.stream_lock );
549
550
551
552
553
554
555
556
557

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

			if ( currentChapter >= 0 )
			{
Eric Petit's avatar
Eric Petit committed
558
				ToggleChapter( currentChapter );
559
560
561
562
563
564
565
566
567
568
569
				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
570
				ToggleTitle(currentTitle);
571
572
573
574
575
576
577
				hasSkiped = true;
			}
		}

	}
	// last but not least, skip to previous file
	if ( !hasSkiped )
578
		PlaylistPrev();
579
580
}

Eric Petit's avatar
Eric Petit committed
581
void VlcWrapper::NavigateNext()
582
583
584
585
{
	bool hasSkiped = false;

	// see if we have got a stream going		
586
	if ( p_input )
587
588
	{
		// get information from stream (lock it while looking at it)
589
		vlc_mutex_lock( &p_input->stream.stream_lock );
590

591
592
593
		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;
594
		bool hasTitles = numTitles > 1;
595
		int numChapters = p_input->stream.p_selected_area->i_part_nb;
596
597
		bool hasChapters = numChapters > 1;

598
		vlc_mutex_unlock( &p_input->stream.stream_lock );
599
600
601
602
603
604
605
606

		// first, look for chapters
		if ( hasChapters )
		{
			// skip to the next chapter
			currentChapter++;
			if ( currentChapter < numChapters )
			{
Eric Petit's avatar
Eric Petit committed
607
				ToggleChapter( currentChapter );
608
609
610
611
612
613
614
615
616
617
618
				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
619
				ToggleTitle(currentTitle);
620
621
622
623
624
625
626
				hasSkiped = true;
			}
		}

	}
	// last but not least, skip to next file
	if ( !hasSkiped )
627
		PlaylistNext();
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
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
/*************************
 * 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;
}

755

Eric Petit's avatar
Eric Petit committed
756
757
758
759
760
761
762
763
/*********
 * audio *
 *********/

bool VlcWrapper::HasAudio()
{
    return( p_aout != NULL );
}
764

765
766
767
768
769
770
771
772
773
774
775
unsigned short VlcWrapper::GetVolume()
{
    if( p_aout != NULL )
    {
        unsigned short i_volume;
        aout_VolumeGet( p_aout, (audio_volume_t*)&i_volume );
        return i_volume;
    }
    return 0;
}

776
void VlcWrapper::SetVolume(int value)
777
{
778
    if( p_aout != NULL )
779
    {
780
781
782
783
		if ( p_intf->p_sys->b_mute )
		{
			p_intf->p_sys->b_mute = 0;
		}
784
        aout_VolumeSet( p_aout, value );
785
    }
786
}
787

788
void VlcWrapper::VolumeMute()
789
{
790
    if( p_aout != NULL )
791
   	{
792
793
794
795
   	    aout_VolumeGet( p_aout, &p_intf->p_sys->i_saved_volume );
	    aout_VolumeMute( p_aout, NULL );
	    p_intf->p_sys->b_mute = 1;
   	}
796
797
}

798
void VlcWrapper::VolumeRestore()
799
{
800
    if( p_aout != NULL )
801
802
803
   	{
        aout_VolumeSet( p_aout, p_intf->p_sys->i_saved_volume );
        p_intf->p_sys->b_mute = 0;
804
805
	}
}
806

807
bool VlcWrapper::IsMuted()
808
{
809
    return p_intf->p_sys->b_mute;
810
811
}

812
813
814
/*******
 * DVD *
 *******/
Eric Petit's avatar
Eric Petit committed
815

816
bool VlcWrapper::HasTitles()
817
{
818
    if( !p_input )
819
    {
820
821
822
        return false;
    }
    return ( p_input->stream.i_area_nb > 1 );
823
824
}

Eric Petit's avatar
Eric Petit committed
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
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;
}

853
void VlcWrapper::PrevTitle()
854
{
855
856
857
    int i_id;
    i_id = p_input->stream.p_selected_area->i_id - 1;
    if( i_id > 0 )
858
    {
Eric Petit's avatar
Eric Petit committed
859
        ToggleTitle(i_id);
860
861
862
    }
}

863
void VlcWrapper::NextTitle()
864
{
865
    unsigned int i_id;
866
867
    i_id = p_input->stream.p_selected_area->i_id + 1;
    if( i_id < p_input->stream.i_area_nb )
868
    {
Eric Petit's avatar
Eric Petit committed
869
870
871
872
873
874
875
876
877
878
879
880
881
882
        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 );
883
884
885
    }
}

Eric Petit's avatar
Eric Petit committed
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
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 );
	}
}

904
905
906
bool VlcWrapper::HasChapters()
{
    if( !p_input )
907
    {
908
        return false;
909
    }
910
911
    return ( p_input->stream.p_selected_area->i_part_nb > 1 );
}
912

Eric Petit's avatar
Eric Petit committed
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
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;
}

942
943
944
945
946
947
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
948
        ToggleChapter(i_id);
949
    }
950
951
}

952
void VlcWrapper::NextChapter()
Eric Petit's avatar
Eric Petit committed
953
{
954
955
956
957
    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
958
        ToggleChapter(i_id);
959
    }
Eric Petit's avatar
Eric Petit committed
960
961
}

Eric Petit's avatar
Eric Petit committed
962
void VlcWrapper::ToggleChapter(int i_chapter)
Eric Petit's avatar
Eric Petit committed
963
{
Eric Petit's avatar
Eric Petit committed
964
965
966
967
968
    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
969

Eric Petit's avatar
Eric Petit committed
970
971
972
        vlc_mutex_lock( &p_input->stream.stream_lock );
        vlc_mutex_unlock( &p_input->stream.stream_lock );
    }
Eric Petit's avatar
Eric Petit committed
973
974
}

975
void VlcWrapper::ChapterInfo( int32 &currentIndex, int32 &maxIndex )
Eric Petit's avatar
Eric Petit committed
976
977
978
{
	currentIndex = -1;
	maxIndex = -1;
979
	if ( p_input )
Eric Petit's avatar
Eric Petit committed
980
	{
981
		vlc_mutex_lock( &p_input->stream.stream_lock );
Eric Petit's avatar
Eric Petit committed
982

983
		maxIndex = p_input->stream.p_selected_area->i_part_nb - 1;
Eric Petit's avatar
Eric Petit committed
984
		if ( maxIndex > 0)
985
			currentIndex = p_input->stream.p_selected_area->i_part;
Eric Petit's avatar
Eric Petit committed
986
987
988
		else
			maxIndex = -1;

989
		vlc_mutex_unlock( &p_input->stream.stream_lock );
Eric Petit's avatar
Eric Petit committed
990
991
992
	}
}

Eric Petit's avatar
Eric Petit committed
993
994
995
996
/****************
 * Miscellanous *
 ****************/
 
997
void VlcWrapper::LoadSubFile( const char * psz_file )
998
{
Eric Petit's avatar
Eric Petit committed
999
    config_PutPsz( p_intf, "sub-file", strdup( psz_file ) );
1000
}