VlcWrapper.cpp 19.2 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.15 2003/01/08 02:09:15 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
extern "C" {
34
35
#include <audio_output.h>
#include <aout_internal.h>
36
}
37

38
#include "VlcWrapper.h"
39
#include "MsgVals.h"
40

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

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

/* UpdateInputAndAOut: updates p_input and p_aout, returns true if the
   interface needs to be updated */
70
bool VlcWrapper::UpdateInputAndAOut()
71
72
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
{
    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;
}

101
102
103
104
105

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

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

111
112
113
/* status (UNDEF_S, PLAYING_S, PAUSE_S, FORWARD_S, BACKWARD_S,
   REWIND_S, NOT_STARTED_S, START_S) */
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
132
/* tell: location in the current stream (in arbitrary units) */
int VlcWrapper::InputTell()
133
{
134
135
136
137
    if( !p_input )
    {
        return -1;
    }
138
139
140
    return p_input->stream.p_selected_area->i_tell;
}

141
142
/* size: total size of the current stream (in arbitrary units) */
int VlcWrapper::InputSize()
143
{
144
145
146
147
    if( !p_input )
    {
        return -1;
    }
148
149
150
    return p_input->stream.p_selected_area->i_size;
}

151
void VlcWrapper::InputSlower()
152
{
153
154
155
156
    if( p_input != NULL )
    {
        input_SetStatus( p_input, INPUT_STATUS_SLOWER );
    }
157
158
}

159
void VlcWrapper::InputFaster()
160
{
161
162
163
164
    if( p_input != NULL )
    {
        input_SetStatus( p_input, INPUT_STATUS_FASTER );
    }
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
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
}

BList * VlcWrapper::InputGetChannels( int i_cat )
{
    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;
239
240
}

241
void VlcWrapper::openFiles( BList* o_files, bool replace )
242
{
243
244
245
246
247
248
249
250
251
    BString *o_file;

    while( ( o_file = (BString *)o_files->LastItem() ) )
    {
        o_files->RemoveItem(o_files->CountItems() - 1);
        playlist_Add( p_playlist, o_file->String(),
                  PLAYLIST_APPEND | PLAYLIST_GO, PLAYLIST_END );
        delete o_file;
    }
252
253
}

254
void VlcWrapper::openDisc(BString o_type, BString o_device, int i_title, int i_chapter)
255
{
256
257
258
259
260
    BString o_source("");
    o_source << o_type << ":" << o_device ;

    playlist_Add( p_playlist, o_source.String(),
                  PLAYLIST_APPEND | PLAYLIST_GO, PLAYLIST_END );
261
262
}

263
264


265
void VlcWrapper::ToggleLanguage( int i_language )
266
{
267
268
    es_descriptor_t * p_es = NULL;
    es_descriptor_t * p_es_old = NULL;
269
270

    vlc_mutex_lock( &p_input->stream.stream_lock );
271
    for( unsigned int i = 0; i < p_input->stream.i_selected_es_number ; i++ )
272
    {
273
        if( p_input->stream.pp_selected_es[i]->i_cat == AUDIO_ES )
274
        {
275
            p_es_old = p_input->stream.pp_selected_es[i];
276
277
278
279
            break;
        }
    }
    vlc_mutex_unlock( &p_input->stream.stream_lock );
280
    
281
282
    if( i_language != -1 )
    {
283
        p_es = p_input->stream.pp_es[i_language];
284
    }
285
286
287
288
289
290
291
292
293
    if( p_es == p_es_old )
    {
        return;
    }
    if( p_es_old )
    {
        input_ToggleES( p_input, p_es_old, VLC_FALSE );
    }
    if( p_es )
294
    {
295
        input_ToggleES( p_input, p_es, VLC_TRUE );
296
297
298
    }
}

299
void VlcWrapper::ToggleSubtitle( int i_subtitle )
300
{
301
302
    es_descriptor_t * p_es = NULL;
    es_descriptor_t * p_es_old = NULL;
303
304

    vlc_mutex_lock( &p_input->stream.stream_lock );
305
    for( unsigned int i = 0; i < p_input->stream.i_selected_es_number ; i++ )
306
    {
307
        if( p_input->stream.pp_selected_es[i]->i_cat == SPU_ES )
308
        {
309
            p_es_old = p_input->stream.pp_selected_es[i];
310
311
312
313
314
315
316
            break;
        }
    }
    vlc_mutex_unlock( &p_input->stream.stream_lock );
    
    if( i_subtitle != -1 )
    {
317
        p_es = p_input->stream.pp_es[i_subtitle];
318
    }
319
320
321
322
323
    if( p_es == p_es_old )
    {
        return;
    }
    if( p_es_old )
324
    {
325
326
327
328
329
        input_ToggleES( p_input, p_es_old, VLC_FALSE );
    }
    if( p_es )
    {
        input_ToggleES( p_input, p_es, VLC_TRUE );
330
331
332
    }
}

333
const char*  VlcWrapper::getTimeAsString()
334
{
335
336
337
338
339
340
341
342
343
344
345
346
    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);
347
348
}

349
float  VlcWrapper::getTimeAsFloat()
350
{
351
352
353
    float f_time = 0.0;

    if( p_input != NULL )
354
    {
355
356
357
358
359
360
        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;
361
    }
362
    return( f_time );
363
364
}

365
void VlcWrapper::setTimeAsFloat(float f_position)
366
{
367
    if( p_input != NULL )
368
    {
369
370
371
372
        input_Seek( p_input, 
                   (long long int)(p_input->stream.p_selected_area->i_size
                       * f_position / SEEKSLIDER_RANGE ), 
                   INPUT_SEEK_SET);
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
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;

}
400
401
402
403
404

/******************************
 * playlist infos and control *
 ******************************/
int VlcWrapper::PlaylistSize()
405
406
{
    vlc_mutex_lock( &p_playlist->object_lock );
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
    int i_size = p_playlist->i_size;
    vlc_mutex_unlock( &p_playlist->object_lock );
    return i_size;
}

char *VlcWrapper::PlaylistItemName( int i )
{
   return p_playlist->pp_items[i]->psz_name;
}

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

int  VlcWrapper::PlaylistStatus()
{
    return p_playlist->i_status;
}

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

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

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

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

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

459
void VlcWrapper::PlaylistSkip( int i )
460
461
462
463
{
    playlist_Skip( p_playlist, i );
}

464
void VlcWrapper::PlaylistGoto( int i )
465
466
467
468
{
    playlist_Goto( p_playlist, i );
}

469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
void VlcWrapper::PlaylistLoop()
{
    if ( p_intf->p_sys->b_loop )
    {
        playlist_Delete( p_playlist, p_playlist->i_size - 1 );
    }
    else
    {
        playlist_Add( p_playlist, "vlc:loop",
                      PLAYLIST_APPEND | PLAYLIST_GO,
                      PLAYLIST_END );
    }
    p_intf->p_sys->b_loop = !p_intf->p_sys->b_loop;
}

BList * VlcWrapper::PlaylistAsArray()
{ 
    int i;
    BList* p_list = new BList(p_playlist->i_size);
    
    vlc_mutex_lock( &p_playlist->object_lock );

    for( i = 0; i < p_playlist->i_size; i++ )
    {
        p_list->AddItem(new BString(p_playlist->pp_items[i]->psz_name));
    }

    vlc_mutex_unlock( &p_playlist->object_lock );
    return( p_list );
}

void VlcWrapper::getPlaylistInfo( int32& currentIndex, int32& maxIndex )
{
	currentIndex = -1;
	maxIndex = -1;
	if ( p_playlist )
	{
		maxIndex = p_playlist->i_size;
		if ( maxIndex > 0 )
			currentIndex = p_playlist->i_index + 1;
		else
			maxIndex = -1;
	}
}


void VlcWrapper::PlaylistJumpTo( int pos )
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
{
#if 0
	// sanity checks
	if ( pos < 0 )
		pos = 0;
	int size = playlistSize();
	if (pos >= size)
		pos = size - 1;
	// weird hack
    if( p_input_bank->pp_input[0] != NULL )
		pos--;
	// stop current stream
	playlistStop();
	// modify current position in playlist
	playlistLock();
	p_main->p_playlist->i_index = pos;
	playlistUnlock();
	// start playing
	playlistPlay();
#endif
}

538
void VlcWrapper::getNavCapabilities( bool *canSkipPrev, bool *canSkipNext )
539
540
541
542
543
544
545
{
	if ( canSkipPrev && canSkipNext )
	{
		// init the parameters
		*canSkipPrev = false;
		*canSkipNext = false;
		// get playlist info
546
547
		int pos = PlaylistCurrent();
		int size = PlaylistSize();
548
549

		// see if we have got a stream going		
550
		if ( p_input )
551
		{
552
			vlc_mutex_lock( &p_input->stream.stream_lock );
553

554
555
			bool hasTitles = p_input->stream.i_area_nb > 1;
			int numChapters = p_input->stream.p_selected_area->i_part_nb;
556
557
558
559
			bool hasChapters = numChapters > 1;
			// first, look for chapters
			if ( hasChapters )
			{
560
561
562
				*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;
563
564
565
566
			}
			// if one of the skip capabilities is false,
			// make it depend on titles instead
			if ( !*canSkipPrev && hasTitles )
567
				*canSkipPrev = p_input->stream.p_selected_area->i_id > 1;
568
			if ( !*canSkipNext && hasTitles )
569
570
				*canSkipNext = p_input->stream.p_selected_area->i_id <
				                   p_input->stream.i_area_nb - 1;
571

572
			vlc_mutex_unlock( &p_input->stream.stream_lock );
573
574
575
576
577
578
579
580
581
		}
		// last but not least, make capabilities depend on playlist
		if ( !*canSkipPrev )
			*canSkipPrev = pos > 0;
		if ( !*canSkipNext )
			*canSkipNext = pos < size - 1;
	}
}

582
void VlcWrapper::navigatePrev()
583
584
585
586
{
	bool hasSkiped = false;

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

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

599
		vlc_mutex_unlock( &p_input->stream.stream_lock );
600
601
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

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

			if ( currentChapter >= 0 )
			{
				toggleChapter( currentChapter );
				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 )
			{
				toggleTitle(currentTitle);
				hasSkiped = true;
			}
		}

	}
	// last but not least, skip to previous file
	if ( !hasSkiped )
629
		PlaylistPrev();
630
631
}

632
void VlcWrapper::navigateNext()
633
634
635
636
{
	bool hasSkiped = false;

	// see if we have got a stream going		
637
	if ( p_input )
638
639
	{
		// get information from stream (lock it while looking at it)
640
		vlc_mutex_lock( &p_input->stream.stream_lock );
641

642
643
644
		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;
645
		bool hasTitles = numTitles > 1;
646
		int numChapters = p_input->stream.p_selected_area->i_part_nb;
647
648
		bool hasChapters = numChapters > 1;

649
		vlc_mutex_unlock( &p_input->stream.stream_lock );
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

		// first, look for chapters
		if ( hasChapters )
		{
			// skip to the next chapter
			currentChapter++;
			if ( currentChapter < numChapters )
			{
				toggleChapter( currentChapter );
				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 )
			{
				toggleTitle(currentTitle);
				hasSkiped = true;
			}
		}

	}
	// last but not least, skip to next file
	if ( !hasSkiped )
678
		PlaylistNext();
679
680
681
}


682
683
684
/***************************
 * audio infos and control *
 ***************************/
685

686
687
688
689
690
691
692
693
694
695
696
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;
}

697
void VlcWrapper::SetVolume(int value)
698
{
699
    if( p_aout != NULL )
700
    {
701
702
703
704
		if ( p_intf->p_sys->b_mute )
		{
			p_intf->p_sys->b_mute = 0;
		}
705
        aout_VolumeSet( p_aout, value );
706
    }
707
}
708

709
void VlcWrapper::VolumeMute()
710
{
711
    if( p_aout != NULL )
712
   	{
713
714
715
716
   	    aout_VolumeGet( p_aout, &p_intf->p_sys->i_saved_volume );
	    aout_VolumeMute( p_aout, NULL );
	    p_intf->p_sys->b_mute = 1;
   	}
717
718
}

719
void VlcWrapper::VolumeRestore()
720
{
721
    if( p_aout != NULL )
722
723
724
   	{
        aout_VolumeSet( p_aout, p_intf->p_sys->i_saved_volume );
        p_intf->p_sys->b_mute = 0;
725
726
	}
}
727

728
bool VlcWrapper::IsMuted()
729
{
730
    return p_intf->p_sys->b_mute;
731
732
}

733
bool VlcWrapper::HasAudio()
734
{
735
    return( p_aout != NULL );
736
737
}

738
739
740
741
/*******
 * DVD *
 *******/
bool VlcWrapper::HasTitles()
742
{
743
    if( !p_input )
744
    {
745
746
747
        return false;
    }
    return ( p_input->stream.i_area_nb > 1 );
748
749
}

750
void VlcWrapper::PrevTitle()
751
{
752
753
754
    int i_id;
    i_id = p_input->stream.p_selected_area->i_id - 1;
    if( i_id > 0 )
755
    {
756
        toggleTitle(i_id);
757
758
759
    }
}

760
void VlcWrapper::NextTitle()
761
{
762
    unsigned int i_id;
763
764
    i_id = p_input->stream.p_selected_area->i_id + 1;
    if( i_id < p_input->stream.i_area_nb )
765
    {
766
        toggleTitle(i_id);
767
768
769
    }
}

770
771
772
bool VlcWrapper::HasChapters()
{
    if( !p_input )
773
    {
774
        return false;
775
    }
776
777
    return ( p_input->stream.p_selected_area->i_part_nb > 1 );
}
778

779
780
781
782
783
784
785
786
void VlcWrapper::PrevChapter()
{
    int i_id;
    i_id = p_input->stream.p_selected_area->i_part - 1;
    if( i_id >= 0 )
    {
        toggleChapter(i_id);
    }
787
788
}

789
void VlcWrapper::NextChapter()
Eric Petit's avatar
Eric Petit committed
790
{
791
792
793
794
795
796
    int i_id;
    i_id = p_input->stream.p_selected_area->i_part + 1;
    if( i_id >= 0 )
    {
        toggleChapter(i_id);
    }
Eric Petit's avatar
Eric Petit committed
797
798
}

799
void VlcWrapper::TitleInfo( int32 &currentIndex, int32 &maxIndex )
Eric Petit's avatar
Eric Petit committed
800
801
802
{
	currentIndex = -1;
	maxIndex = -1;
803
	if ( p_input )
Eric Petit's avatar
Eric Petit committed
804
	{
805
		vlc_mutex_lock( &p_input->stream.stream_lock );
Eric Petit's avatar
Eric Petit committed
806

807
		maxIndex = p_input->stream.i_area_nb - 1;
Eric Petit's avatar
Eric Petit committed
808
		if ( maxIndex > 0)
809
			currentIndex = p_input->stream.p_selected_area->i_id;
Eric Petit's avatar
Eric Petit committed
810
811
812
		else
			maxIndex = -1;

813
		vlc_mutex_unlock( &p_input->stream.stream_lock );
Eric Petit's avatar
Eric Petit committed
814
815
816
	}
}

817
void VlcWrapper::ChapterInfo( int32 &currentIndex, int32 &maxIndex )
Eric Petit's avatar
Eric Petit committed
818
819
820
{
	currentIndex = -1;
	maxIndex = -1;
821
	if ( p_input )
Eric Petit's avatar
Eric Petit committed
822
	{
823
		vlc_mutex_lock( &p_input->stream.stream_lock );
Eric Petit's avatar
Eric Petit committed
824

825
		maxIndex = p_input->stream.p_selected_area->i_part_nb - 1;
Eric Petit's avatar
Eric Petit committed
826
		if ( maxIndex > 0)
827
			currentIndex = p_input->stream.p_selected_area->i_part;
Eric Petit's avatar
Eric Petit committed
828
829
830
		else
			maxIndex = -1;

831
		vlc_mutex_unlock( &p_input->stream.stream_lock );
Eric Petit's avatar
Eric Petit committed
832
833
834
	}
}

835
void VlcWrapper::toggleTitle(int i_title)
836
{
837
    if( p_input != NULL )
838
    {
839
840
        input_ChangeArea( p_input,
                          p_input->stream.pp_areas[i_title] );
841

842
        vlc_mutex_lock( &p_input->stream.stream_lock );
843

844
        vlc_mutex_unlock( &p_input->stream.stream_lock );
845
846
847
    }
}

848
void VlcWrapper::toggleChapter(int i_chapter)
849
{
850
    if( p_input != NULL )
851
    {
852
853
854
        p_input->stream.p_selected_area->i_part = i_chapter;
        input_ChangeArea( p_input,
                          p_input->stream.p_selected_area );
855

856
857
        vlc_mutex_lock( &p_input->stream.stream_lock );
        vlc_mutex_unlock( &p_input->stream.stream_lock );
858
859
    }
}