VlcWrapper.cpp 23.4 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.30 2003/05/07 14:49:19 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"
{
Stephan Assmus's avatar
   
Stephan Assmus committed
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
66
67
68
69
70
71
    if( p_input )
    {
        vlc_object_release( p_input );
    }
    if( p_playlist )
    {
        vlc_object_release( p_playlist );
    }
72
}
73

Eric Petit's avatar
Eric Petit committed
74
75
76
/* UpdateInput: updates p_input, returns true if the interface needs to
   be updated */
bool VlcWrapper::UpdateInput()
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
{
    if( p_input == NULL )
    {
        p_input = (input_thread_t *)vlc_object_find( p_intf, VLC_OBJECT_INPUT,
                                                     FIND_ANYWHERE );
    }
        
    if( p_input != NULL )
    {
        if( p_input->b_dead )
        {
            vlc_object_release( p_input );
            p_input = NULL;
        }
        return true;
    }
    return false;
}

96
97
98
99
100

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

101
102
bool VlcWrapper::HasInput()
{
103
    return ( p_input != NULL );
104
105
}

106
int VlcWrapper::InputStatus()
107
{
108
109
110
111
    if( !p_input )
    {
        return UNDEF_S;
    }
112
113
114
    return p_input->stream.control.i_status;
}

115
int VlcWrapper::InputRate()
116
{
117
118
119
120
    if( !p_input )
    {
        return DEFAULT_RATE;
    }
121
122
123
    return p_input->stream.control.i_rate;
}

124
void VlcWrapper::InputSlower()
125
{
126
127
128
129
    if( p_input != NULL )
    {
        input_SetStatus( p_input, INPUT_STATUS_SLOWER );
    }
130
131
}

132
void VlcWrapper::InputFaster()
133
{
134
135
136
137
    if( p_input != NULL )
    {
        input_SetStatus( p_input, INPUT_STATUS_FASTER );
    }
138
139
}

Eric Petit's avatar
Eric Petit committed
140
BList * VlcWrapper::GetChannels( int i_cat )
141
142
143
144
145
146
147
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
{
    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 );
185
        menuItem = new BMenuItem( _("None"), message );
186
187
188
189
190
191
192
193
194
195
        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
196
197
                if( !p_input->stream.pp_es[i]->psz_desc ||
                    !*p_input->stream.pp_es[i]->psz_desc )
198
                    trackName = _("<unknown>");
gbazin's avatar
   
gbazin committed
199
200
                else
                    trackName = strdup( p_input->stream.pp_es[i]->psz_desc );
201
202
203
204
205
206
207
208
209
210
211
212
                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;
213
214
}

215
void VlcWrapper::ToggleLanguage( int i_language )
216
{
217
218
    es_descriptor_t * p_es = NULL;
    es_descriptor_t * p_es_old = NULL;
219
220

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

249
void VlcWrapper::ToggleSubtitle( int i_subtitle )
250
{
251
252
    es_descriptor_t * p_es = NULL;
    es_descriptor_t * p_es_old = NULL;
253
254

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

Eric Petit's avatar
Eric Petit committed
283
const char * VlcWrapper::GetTimeAsString()
284
{
285
286
287
288
289
290
291
292
293
294
295
296
    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);
297
298
}

Eric Petit's avatar
Eric Petit committed
299
float VlcWrapper::GetTimeAsFloat()
300
{
301
302
303
    float f_time = 0.0;

    if( p_input != NULL )
304
    {
305
306
307
308
309
310
        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;
311
    }
312
    return( f_time );
313
314
}

Eric Petit's avatar
Eric Petit committed
315
void VlcWrapper::SetTimeAsFloat( float f_position )
316
{
317
    if( p_input != NULL )
318
    {
319
320
321
322
        input_Seek( p_input, 
                   (long long int)(p_input->stream.p_selected_area->i_size
                       * f_position / SEEKSLIDER_RANGE ), 
                   INPUT_SEEK_SET);
323
324
325
    }
}

326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
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;

}
350

Eric Petit's avatar
Eric Petit committed
351
352
353
354
/************
 * playlist *
 ************/

355
void VlcWrapper::OpenFiles( BList* o_files, bool replace, int32 index )
Eric Petit's avatar
Eric Petit committed
356
{
357
358
359
360
361
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
	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
396
397
398
399
}
 
void VlcWrapper::OpenDisc(BString o_type, BString o_device, int i_title, int i_chapter)
{
400
401
    if( config_GetInt( p_intf, "beos-dvdmenus" ) )
        o_device.Prepend( "dvdplay:" );
402
    else
Eric Petit's avatar
Eric Petit committed
403
404
405
406
407
        o_device.Prepend( "dvdold:" );
    playlist_Add( p_playlist, o_device.String(),
                  PLAYLIST_APPEND | PLAYLIST_GO, PLAYLIST_END );
}

408
int VlcWrapper::PlaylistSize()
409
410
{
    vlc_mutex_lock( &p_playlist->object_lock );
411
412
413
414
415
    int i_size = p_playlist->i_size;
    vlc_mutex_unlock( &p_playlist->object_lock );
    return i_size;
}

Eric Petit's avatar
Eric Petit committed
416
char * VlcWrapper::PlaylistItemName( int i )
417
418
419
420
421
422
423
424
425
426
427
428
{
   return p_playlist->pp_items[i]->psz_name;
}

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

bool VlcWrapper::PlaylistPlay()
{
    if( PlaylistSize() )
429
430
431
432
433
434
    {
        playlist_Play( p_playlist );
    }
    return( true );
}

435
void VlcWrapper::PlaylistPause()
436
{
437
    if( p_input )
438
    {
439
        input_SetStatus( p_input, INPUT_STATUS_PAUSE );
440
    }
441
442
}

443
void VlcWrapper::PlaylistStop()
444
445
446
447
{
    playlist_Stop( p_playlist );
}

448
void VlcWrapper::PlaylistNext()
449
450
451
452
{
    playlist_Next( p_playlist );
}

453
void VlcWrapper::PlaylistPrev()
454
455
456
457
{
    playlist_Prev( p_playlist );
}

Eric Petit's avatar
Eric Petit committed
458
void VlcWrapper::GetPlaylistInfo( int32& currentIndex, int32& maxIndex )
459
460
461
462
463
{
	currentIndex = -1;
	maxIndex = -1;
	if ( p_playlist )
	{
464
465
	    vlc_mutex_lock( &p_playlist->object_lock );

466
467
		maxIndex = p_playlist->i_size;
		if ( maxIndex > 0 )
468
			currentIndex = p_playlist->i_index/* + 1 -> why?!?*/;
469
470
		else
			maxIndex = -1;
471
472

	    vlc_mutex_unlock( &p_playlist->object_lock );
473
474
475
476
	}
}

void VlcWrapper::PlaylistJumpTo( int pos )
477
{
Eric Petit's avatar
Eric Petit committed
478
479
480
481
    playlist_Goto( p_playlist, pos );
}

void VlcWrapper::GetNavCapabilities( bool *canSkipPrev, bool *canSkipNext )
482
483
484
485
486
487
488
{
	if ( canSkipPrev && canSkipNext )
	{
		// init the parameters
		*canSkipPrev = false;
		*canSkipNext = false;
		// get playlist info
489
490
		int pos = PlaylistCurrent();
		int size = PlaylistSize();
491
492

		// see if we have got a stream going		
493
		if ( p_input )
494
		{
495
			vlc_mutex_lock( &p_input->stream.stream_lock );
496

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

515
			vlc_mutex_unlock( &p_input->stream.stream_lock );
516
517
518
519
520
521
522
523
524
		}
		// 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
525
void VlcWrapper::NavigatePrev()
526
527
528
529
{
	bool hasSkiped = false;

	// see if we have got a stream going		
530
	if ( p_input )
531
532
	{
		// get information from stream (lock it while looking at it)
533
		vlc_mutex_lock( &p_input->stream.stream_lock );
534

535
536
537
		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;
538
		bool hasTitles = numTitles > 1;
539
		int numChapters = p_input->stream.p_selected_area->i_part_nb;
540
541
		bool hasChapters = numChapters > 1;

542
		vlc_mutex_unlock( &p_input->stream.stream_lock );
543
544
545
546
547
548
549
550
551

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

			if ( currentChapter >= 0 )
			{
Eric Petit's avatar
Eric Petit committed
552
				ToggleChapter( currentChapter );
553
554
555
556
557
558
559
560
561
562
563
				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
564
				ToggleTitle(currentTitle);
565
566
567
568
569
570
571
				hasSkiped = true;
			}
		}

	}
	// last but not least, skip to previous file
	if ( !hasSkiped )
572
		PlaylistPrev();
573
574
}

Eric Petit's avatar
Eric Petit committed
575
void VlcWrapper::NavigateNext()
576
577
578
579
{
	bool hasSkiped = false;

	// see if we have got a stream going		
580
	if ( p_input )
581
582
	{
		// get information from stream (lock it while looking at it)
583
		vlc_mutex_lock( &p_input->stream.stream_lock );
584

585
586
587
		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;
588
		bool hasTitles = numTitles > 1;
589
		int numChapters = p_input->stream.p_selected_area->i_part_nb;
590
591
		bool hasChapters = numChapters > 1;

592
		vlc_mutex_unlock( &p_input->stream.stream_lock );
593
594
595
596
597
598
599
600

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

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

749

Eric Petit's avatar
Eric Petit committed
750
751
752
753
/*********
 * audio *
 *********/

754
755
unsigned short VlcWrapper::GetVolume()
{
Eric Petit's avatar
Eric Petit committed
756
757
758
    unsigned short i_volume;
    aout_VolumeGet( p_intf, (audio_volume_t*)&i_volume );
    return i_volume;
759
760
}

Eric Petit's avatar
Eric Petit committed
761
void VlcWrapper::SetVolume( int value )
762
{
Eric Petit's avatar
Eric Petit committed
763
    if ( p_intf->p_sys->b_mute )
764
    {
Eric Petit's avatar
Eric Petit committed
765
        p_intf->p_sys->b_mute = 0;
766
    }
Eric Petit's avatar
Eric Petit committed
767
    aout_VolumeSet( p_intf, value );
768
}
769

770
void VlcWrapper::VolumeMute()
771
{
Eric Petit's avatar
Eric Petit committed
772
773
774
   	aout_VolumeGet( p_intf, &p_intf->p_sys->i_saved_volume );
    aout_VolumeMute( p_intf, NULL );
    p_intf->p_sys->b_mute = 1;
775
776
}

777
void VlcWrapper::VolumeRestore()
778
{
Eric Petit's avatar
Eric Petit committed
779
780
    aout_VolumeSet( p_intf, p_intf->p_sys->i_saved_volume );
    p_intf->p_sys->b_mute = 0;
781
}
782

783
bool VlcWrapper::IsMuted()
784
{
785
    return p_intf->p_sys->b_mute;
786
787
}

788
789
790
/*******
 * DVD *
 *******/
Eric Petit's avatar
Eric Petit committed
791

792
bool VlcWrapper::HasTitles()
793
{
794
    if( !p_input )
795
    {
796
797
798
        return false;
    }
    return ( p_input->stream.i_area_nb > 1 );
799
800
}

Eric Petit's avatar
Eric Petit committed
801
802
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
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;
}

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

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

Eric Petit's avatar
Eric Petit committed
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
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 );
	}
}

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

Eric Petit's avatar
Eric Petit committed
889
890
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
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;
}

918
919
920
921
922
923
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
924
        ToggleChapter(i_id);
925
    }
926
927
}

928
void VlcWrapper::NextChapter()
Eric Petit's avatar
Eric Petit committed
929
{
930
931
932
933
    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
934
        ToggleChapter(i_id);
935
    }
Eric Petit's avatar
Eric Petit committed
936
937
}

Eric Petit's avatar
Eric Petit committed
938
void VlcWrapper::ToggleChapter(int i_chapter)
Eric Petit's avatar
Eric Petit committed
939
{
Eric Petit's avatar
Eric Petit committed
940
941
942
943
944
    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
945

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

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

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

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

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

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
986
    // Warn the vout we are about to change the filter chain
987
988
989
990
991
992
993
994
    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
995
    // restart all video stream
996
997
998
999
1000
    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 ) )
        {