]> git.sesse.net Git - vlc/blob - projects/macosx/framework/Sources/VLCMediaPlayer.m
d8e4243c4855fb0462c3cc1ee4ff4ffb105a14b7
[vlc] / projects / macosx / framework / Sources / VLCMediaPlayer.m
1 /*****************************************************************************
2  * VLCMediaPlayer.m: VLCKit.framework VLCMediaPlayer implementation
3  *****************************************************************************
4  * Copyright (C) 2007-2009 Pierre d'Herbemont
5  * Copyright (C) 2007-2009 the VideoLAN team
6  * Partial Copyright (C) 2009 Felix Paul Kühne
7  * $Id$
8  *
9  * Authors: Pierre d'Herbemont <pdherbemont # videolan.org>
10  *          Faustion Osuna <enrique.osuna # gmail.com>
11  *          Felix Paul Kühne <fkuehne # videolan.org>
12  *
13  * This program is free software; you can redistribute it and/or modify
14  * it under the terms of the GNU General Public License as published by
15  * the Free Software Foundation; either version 2 of the License, or
16  * (at your option) any later version.
17  *
18  * This program is distributed in the hope that it will be useful,
19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
21  * GNU General Public License for more details.
22  *
23  * You should have received a copy of the GNU General Public License
24  * along with this program; if not, write to the Free Software
25  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
26  *****************************************************************************/
27
28 #import "VLCLibrary.h"
29 #import "VLCMediaPlayer.h"
30 #import "VLCEventManager.h"
31 #import "VLCLibVLCBridging.h"
32 #import "VLCVideoView.h"
33 #ifdef HAVE_CONFIG_H
34 # include "config.h"
35 #endif
36
37 /* prevent system sleep */
38 #import <CoreServices/CoreServices.h>
39 /* FIXME: Ugly hack! */
40 #ifdef __x86_64__
41 #import <CoreServices/../Frameworks/OSServices.framework/Headers/Power.h>
42 #endif
43
44 #include <vlc/vlc.h>
45
46 /* Notification Messages */
47 NSString * VLCMediaPlayerTimeChanged    = @"VLCMediaPlayerTimeChanged";
48 NSString * VLCMediaPlayerStateChanged   = @"VLCMediaPlayerStateChanged";
49
50 NSString * VLCMediaPlayerStateToString(VLCMediaPlayerState state)
51 {
52     static NSString * stateToStrings[] = {
53         [VLCMediaPlayerStateStopped]      = @"VLCMediaPlayerStateStopped",
54         [VLCMediaPlayerStateOpening]      = @"VLCMediaPlayerStateOpening",
55         [VLCMediaPlayerStateBuffering]    = @"VLCMediaPlayerStateBuffering",
56         [VLCMediaPlayerStateEnded]        = @"VLCMediaPlayerStateEnded",
57         [VLCMediaPlayerStateError]        = @"VLCMediaPlayerStateError",
58         [VLCMediaPlayerStatePlaying]      = @"VLCMediaPlayerStatePlaying",
59         [VLCMediaPlayerStatePaused]       = @"VLCMediaPlayerStatePaused"
60     };
61     return stateToStrings[state];
62 }
63
64 /* libvlc event callback */
65 static void HandleMediaInstanceVolumeChanged(const libvlc_event_t * event, void * self)
66 {
67     [[VLCEventManager sharedManager] callOnMainThreadDelegateOfObject:self
68                                                    withDelegateMethod:@selector(mediaPlayerVolumeChanged:)
69                                                  withNotificationName:VLCMediaPlayerVolumeChanged];
70 }
71
72 static void HandleMediaTimeChanged(const libvlc_event_t * event, void * self)
73 {
74     NSAutoreleasePool * pool = [[NSAutoreleasePool alloc] init];
75     [[VLCEventManager sharedManager] callOnMainThreadObject:self
76                                                  withMethod:@selector(mediaPlayerTimeChanged:)
77                                        withArgumentAsObject:[NSNumber numberWithLongLong:event->u.media_player_time_changed.new_time]];
78
79     [[VLCEventManager sharedManager] callOnMainThreadDelegateOfObject:self
80                                                    withDelegateMethod:@selector(mediaPlayerTimeChanged:)
81                                                  withNotificationName:VLCMediaPlayerTimeChanged];
82     [pool release];
83 }
84
85 static void HandleMediaPositionChanged(const libvlc_event_t * event, void * self)
86 {
87     NSAutoreleasePool * pool = [[NSAutoreleasePool alloc] init];
88
89     [[VLCEventManager sharedManager] callOnMainThreadObject:self
90                                                  withMethod:@selector(mediaPlayerPositionChanged:)
91                                        withArgumentAsObject:[NSNumber numberWithFloat:event->u.media_player_position_changed.new_position]];
92     [pool release];
93 }
94
95 static void HandleMediaInstanceStateChanged(const libvlc_event_t * event, void * self)
96 {
97     VLCMediaPlayerState newState;
98
99     if( event->type == libvlc_MediaPlayerPlaying )
100         newState = VLCMediaPlayerStatePlaying;
101     else if( event->type == libvlc_MediaPlayerPaused )
102         newState = VLCMediaPlayerStatePaused;
103     else if( event->type == libvlc_MediaPlayerEndReached )
104         newState = VLCMediaPlayerStateStopped;
105     else if( event->type == libvlc_MediaPlayerEncounteredError )
106         newState = VLCMediaPlayerStateError;
107     else
108     {
109         NSLog(@"%s: Unknown event", __FUNCTION__);
110         return;
111     }
112
113     NSAutoreleasePool * pool = [[NSAutoreleasePool alloc] init];
114
115     [[VLCEventManager sharedManager] callOnMainThreadObject:self
116                                                  withMethod:@selector(mediaPlayerStateChanged:)
117                                        withArgumentAsObject:[NSNumber numberWithInt:newState]];
118
119     [[VLCEventManager sharedManager] callOnMainThreadDelegateOfObject:self
120                                                    withDelegateMethod:@selector(mediaPlayerStateChanged:)
121                                                  withNotificationName:VLCMediaPlayerStateChanged];
122
123     [pool release];
124
125 }
126
127 static void HandleMediaPlayerMediaChanged(const libvlc_event_t * event, void * self)
128 {
129     NSAutoreleasePool * pool = [[NSAutoreleasePool alloc] init];
130
131     [[VLCEventManager sharedManager] callOnMainThreadObject:self
132                                                  withMethod:@selector(mediaPlayerMediaChanged:)
133                                        withArgumentAsObject:[VLCMedia mediaWithLibVLCMediaDescriptor:event->u.media_player_media_changed.new_media]];
134
135     [pool release];
136
137 }
138
139
140 // TODO: Documentation
141 @interface VLCMediaPlayer (Private)
142 - (id)initWithDrawable:(id)aDrawable;
143
144 - (void)registerObservers;
145 - (void)unregisterObservers;
146 - (void)mediaPlayerTimeChanged:(NSNumber *)newTime;
147 - (void)mediaPlayerPositionChanged:(NSNumber *)newTime;
148 - (void)mediaPlayerStateChanged:(NSNumber *)newState;
149 - (void)mediaPlayerMediaChanged:(VLCMedia *)media;
150 @end
151
152 @implementation VLCMediaPlayer
153
154 /* Bindings */
155 + (NSSet *)keyPathsForValuesAffectingValueForKey:(NSString *)key
156 {
157     static NSDictionary * dict = nil;
158     NSSet * superKeyPaths;
159     if( !dict )
160     {
161         dict = [[NSDictionary dictionaryWithObjectsAndKeys:
162             [NSSet setWithObject:@"state"], @"playing",
163             [NSSet setWithObjects:@"state", @"media", nil], @"seekable",
164             [NSSet setWithObjects:@"state", @"media", nil], @"canPause",
165             [NSSet setWithObjects:@"state", @"media", nil], @"description",
166             nil] retain];
167     }
168     if( (superKeyPaths = [super keyPathsForValuesAffectingValueForKey: key]) )
169     {
170         NSMutableSet * ret = [NSMutableSet setWithSet:[dict objectForKey: key]];
171         [ret unionSet:superKeyPaths];
172         return ret;
173     }
174     return [dict objectForKey: key];
175 }
176
177 /* Contructor */
178 - (id)init
179 {
180     return [self initWithDrawable:nil];
181 }
182
183 - (id)initWithVideoView:(VLCVideoView *)aVideoView
184 {
185     return [self initWithDrawable: aVideoView];
186 }
187
188 - (id)initWithVideoLayer:(VLCVideoLayer *)aVideoLayer
189 {
190     return [self initWithDrawable: aVideoLayer];
191 }
192
193 - (void)release
194 {
195     @synchronized(self)
196     {
197         if([self retainCount] <= 1)
198         {
199             /* We must make sure we won't receive new event after an upcoming dealloc
200              * We also may receive a -retain in some event callback that may occcur
201              * Before libvlc_event_detach. So this can't happen in dealloc */
202             [self unregisterObservers];
203         }
204         [super release];
205     }
206 }
207
208 - (void)dealloc
209 {
210     NSAssert(libvlc_media_player_get_state(instance) == libvlc_Stopped, @"You released the media player before ensuring that it is stopped");
211
212     // Always get rid of the delegate first so we can stop sending messages to it
213     // TODO: Should we tell the delegate that we're shutting down?
214     delegate = nil;
215
216     // Clear our drawable as we are going to release it, we don't
217     // want the core to use it from this point. This won't happen as
218     // the media player must be stopped.
219     libvlc_media_player_set_nsobject(instance, nil);
220
221     libvlc_media_player_release(instance);
222
223     // Get rid of everything else
224     [media release];
225     [cachedTime release];
226     [cachedRemainingTime release];
227     [drawable release];
228
229     [super dealloc];
230 }
231
232 - (void)setDelegate:(id)value
233 {
234     delegate = value;
235 }
236
237 - (id)delegate
238 {
239     return delegate;
240 }
241
242 - (void)setVideoView:(VLCVideoView *)aVideoView
243 {
244     [self setDrawable: aVideoView];
245 }
246
247 - (void)setVideoLayer:(VLCVideoLayer *)aVideoLayer
248 {
249     [self setDrawable: aVideoLayer];
250 }
251
252 - (void)setDrawable:(id)aDrawable
253 {
254     // Make sure that this instance has been associated with the drawing canvas.
255     libvlc_media_player_set_nsobject(instance, aDrawable);
256 }
257
258 - (id)drawable
259 {
260     libvlc_exception_t ex;
261     libvlc_exception_init( &ex );
262     id ret = libvlc_media_player_get_nsobject(instance);
263     catch_exception( &ex );
264     return ret;
265 }
266
267 - (VLCAudio *)audio
268 {
269     return [[VLCLibrary sharedLibrary] audio];
270 }
271
272 #pragma mark -
273 #pragma mark Subtitles
274
275 - (void)setCurrentVideoSubTitleIndex:(NSUInteger)index
276 {
277     libvlc_exception_t ex;
278     libvlc_exception_init( &ex );
279     libvlc_video_set_spu( instance, (int)index, &ex );
280     catch_exception( &ex );
281 }
282
283 - (NSUInteger)currentVideoSubTitleIndex
284 {
285     libvlc_exception_t ex;
286     libvlc_exception_init( &ex );
287     NSInteger count = libvlc_video_get_spu_count( instance, &ex );
288     if (libvlc_exception_raised( &ex ))
289     {
290         libvlc_exception_clear( &ex );
291         return NSNotFound;
292     }
293     if (count <= 0)
294         return NSNotFound;
295     NSUInteger result = libvlc_video_get_spu( instance, &ex );
296     if (libvlc_exception_raised( &ex ))
297     {
298         libvlc_exception_clear( &ex );
299         return NSNotFound;
300     }
301     else
302         return result;
303 }
304
305 - (BOOL)openVideoSubTitlesFromFile:(NSString *)path
306 {
307     libvlc_exception_t ex;
308     libvlc_exception_init( &ex );
309     BOOL result = libvlc_video_set_subtitle_file( instance, [path UTF8String], &ex );
310     catch_exception( &ex );
311     return result;
312 }
313
314 - (NSArray *)videoSubTitles
315 {
316     libvlc_exception_t ex;
317     libvlc_exception_init( &ex );
318     libvlc_track_description_t *currentTrack = libvlc_video_get_spu_description( instance, &ex );
319     catch_exception( &ex );
320
321     NSMutableArray *tempArray = [NSMutableArray array];
322     while (currentTrack) {
323         [tempArray addObject:[NSString stringWithUTF8String:currentTrack->psz_name]];
324         free(currentTrack->psz_name);
325         libvlc_track_description_t *tofree = currentTrack;
326         currentTrack = currentTrack->p_next;
327         free(tofree);
328     }
329     return [NSArray arrayWithArray: tempArray];
330 }
331
332
333 #pragma mark -
334 #pragma mark Video Crop geometry
335
336 - (void)setVideoCropGeometry:(char *)value
337 {
338     libvlc_exception_t ex;
339     libvlc_exception_init( &ex );
340     libvlc_video_set_crop_geometry( instance, value, &ex );
341     catch_exception( &ex );
342 }
343
344 - (char *)videoCropGeometry
345 {
346     libvlc_exception_t ex;
347     libvlc_exception_init( &ex );
348     char * result = libvlc_video_get_crop_geometry( instance, &ex );
349     catch_exception( &ex );
350     return result;
351 }
352
353 - (void)setVideoAspectRatio:(char *)value
354 {
355     libvlc_exception_t ex;
356     libvlc_exception_init( &ex );
357     libvlc_video_set_aspect_ratio( instance, value, &ex );
358     catch_exception( &ex );
359 }
360
361 - (char *)videoAspectRatio
362 {
363     libvlc_exception_t ex;
364     libvlc_exception_init( &ex );
365     char * result = libvlc_video_get_aspect_ratio( instance, &ex );
366     catch_exception( &ex );
367     return result;
368 }
369
370 - (void)saveVideoSnapshotAt: (NSString *)path withWidth:(NSUInteger)width andHeight:(NSUInteger)height
371 {
372     libvlc_exception_t ex;
373     libvlc_exception_init( &ex );
374     libvlc_video_take_snapshot( instance, [path UTF8String], width, height, &ex );
375     catch_exception( &ex );
376 }
377
378 - (void)setDeinterlaceFilter: (NSString *)name enabled: (BOOL)enabled
379 {
380     libvlc_exception_t ex;
381     libvlc_exception_init( &ex );
382     libvlc_video_set_deinterlace( instance, (int)enabled , [name UTF8String], &ex );
383     catch_exception( &ex );
384 }
385
386 - (void)setRate:(float)value
387 {
388     libvlc_exception_t ex;
389     libvlc_exception_init( &ex );
390     libvlc_media_player_set_rate( instance, value, &ex );
391     catch_exception( &ex );
392 }
393
394 - (float)rate
395 {
396     libvlc_exception_t ex;
397     libvlc_exception_init( &ex );
398     float result = libvlc_media_player_get_rate( instance, &ex );
399     if (libvlc_exception_raised(&ex))
400     {
401         result = 1;
402         libvlc_exception_clear(&ex);
403     }
404     return result;
405 }
406
407 - (NSSize)videoSize
408 {
409     libvlc_exception_t ex;
410     libvlc_exception_init( &ex );
411     NSSize result = NSMakeSize(libvlc_video_get_height((libvlc_media_player_t *)instance, &ex),
412                                libvlc_video_get_width((libvlc_media_player_t *)instance, &ex));
413     catch_exception( &ex );
414     return result;
415 }
416
417 - (BOOL)hasVideoOut
418 {
419     libvlc_exception_t ex;
420     libvlc_exception_init( &ex );
421     BOOL result = libvlc_media_player_has_vout((libvlc_media_player_t *)instance, &ex);
422     if (libvlc_exception_raised( &ex ))
423     {
424         libvlc_exception_clear( &ex );
425         return NO;
426     }
427     else
428         return result;
429 }
430
431 - (float)framesPerSecond
432 {
433     libvlc_exception_t ex;
434     libvlc_exception_init( &ex );
435     float result = libvlc_media_player_get_fps( (libvlc_media_player_t *)instance, &ex );
436     catch_exception( &ex );
437     return result;
438 }
439
440 - (void)setTime:(VLCTime *)value
441 {
442     libvlc_exception_t ex;
443     libvlc_exception_init( &ex );
444     // Time is managed in seconds, while duration is managed in microseconds
445     // TODO: Redo VLCTime to provide value numberAsMilliseconds, numberAsMicroseconds, numberAsSeconds, numberAsMinutes, numberAsHours
446     libvlc_media_player_set_time( (libvlc_media_player_t *)instance,
447                                     (value ? [[value numberValue] longLongValue] : 0),
448                                     &ex );
449     catch_exception( &ex );
450 }
451
452 - (VLCTime *)time
453 {
454     return cachedTime;
455 }
456
457 - (VLCTime *)remainingTime
458 {
459     return cachedRemainingTime;
460 }
461
462 - (NSUInteger)fps
463 {
464     libvlc_exception_t ex;
465     libvlc_exception_init( &ex );
466     NSUInteger result = libvlc_media_player_get_fps( instance, &ex );
467     catch_exception( &ex );
468     return result;
469 }
470
471 #pragma mark -
472 #pragma mark Chapters
473 - (void)setCurrentChapterIndex:(NSUInteger)value;
474 {
475     libvlc_exception_t ex;
476     libvlc_exception_init( &ex );
477     libvlc_media_player_set_chapter( instance, value, &ex );
478     catch_exception( &ex );
479 }
480
481 - (NSUInteger)currentChapterIndex
482 {
483     libvlc_exception_t ex;
484     libvlc_exception_init( &ex );
485     NSInteger count = libvlc_media_player_get_chapter_count( instance, &ex );
486     catch_exception( &ex );
487     if (count <= 0)
488         return NSNotFound;
489     NSUInteger result = libvlc_media_player_get_chapter( instance, &ex );
490     catch_exception( &ex );
491     return result;
492 }
493
494 - (void)nextChapter
495 {
496     libvlc_exception_t ex;
497     libvlc_exception_init( &ex );
498     libvlc_media_player_next_chapter( instance, &ex );
499     catch_exception( &ex );
500 }
501
502 - (void)previousChapter
503 {
504     libvlc_exception_t ex;
505     libvlc_exception_init( &ex );
506     libvlc_media_player_previous_chapter( instance, &ex );
507     catch_exception( &ex );
508 }
509
510 - (NSArray *)chaptersForTitleIndex:(NSUInteger)title
511 {
512     libvlc_exception_t ex;
513     libvlc_exception_init( &ex );
514     NSInteger count = libvlc_media_player_get_chapter_count(instance, &ex);
515     if (count <= 0)
516         return [NSArray array];
517
518     libvlc_track_description_t *tracks = libvlc_video_get_chapter_description( instance, title, &ex );
519     NSMutableArray *tempArray = [NSMutableArray array];
520     NSInteger i;
521     for (i = 0; i < count ; i++)
522     {
523         [tempArray addObject:[NSString stringWithUTF8String: tracks->psz_name]];
524         tracks = tracks->p_next;
525     }
526     return [NSArray arrayWithArray: tempArray];
527 }
528
529 #pragma mark -
530 #pragma mark Titles
531
532 - (void)setCurrentTitleIndex:(NSUInteger)value
533 {
534     libvlc_exception_t ex;
535     libvlc_exception_init( &ex );
536     libvlc_media_player_set_title( instance, value, &ex );
537     catch_exception( &ex );
538 }
539
540 - (NSUInteger)currentTitleIndex
541 {
542     libvlc_exception_t ex;
543     libvlc_exception_init( &ex );
544
545     NSInteger count = libvlc_media_player_get_title_count( instance, &ex );
546     catch_exception( &ex );
547     if (count <= 0)
548         return NSNotFound;
549
550     NSUInteger result = libvlc_media_player_get_title( instance, &ex );
551     catch_exception( &ex );
552     return result;
553 }
554
555 - (NSUInteger)countOfTitles
556 {
557     libvlc_exception_t ex;
558     libvlc_exception_init( &ex );
559     NSUInteger result = libvlc_media_player_get_title_count( instance, &ex );
560     catch_exception( &ex );
561     return result;
562 }
563
564 - (NSArray *)titles
565 {
566     libvlc_exception_t ex;
567     libvlc_exception_init( &ex );
568     libvlc_track_description_t *tracks = libvlc_video_get_title_description( instance, &ex );
569     NSMutableArray *tempArray = [NSMutableArray array];
570     NSInteger i;
571     for (i = 0; i < [self countOfTitles] ; i++)
572     {
573         [tempArray addObject:[NSString stringWithUTF8String: tracks->psz_name]];
574         tracks = tracks->p_next;
575     }
576     return [NSArray arrayWithArray: tempArray];
577 }
578
579 #pragma mark -
580 #pragma mark Audio tracks
581 - (void)setCurrentAudioTrackIndex:(NSUInteger)value
582 {
583     libvlc_exception_t ex;
584     libvlc_exception_init( &ex );
585     libvlc_audio_set_track( instance, (int)value, &ex );
586     catch_exception( &ex );
587 }
588
589 - (NSUInteger)currentAudioTrackIndex
590 {
591     libvlc_exception_t ex;
592     libvlc_exception_init( &ex );
593     NSInteger count = libvlc_audio_get_track_count( instance, &ex );
594     catch_exception( &ex );
595     if (count <= 0)
596         return NSNotFound;
597
598     NSUInteger result = libvlc_audio_get_track( instance, &ex );
599     catch_exception( &ex );
600     return result;
601 }
602
603 - (NSArray *)audioTracks
604 {
605     libvlc_exception_t ex;
606     libvlc_exception_init( &ex );
607     NSInteger count = libvlc_audio_get_track_count( instance, &ex );
608     catch_exception( &ex );
609     if (count <= 0)
610         return [NSArray array];
611
612     libvlc_track_description_t *tracks = libvlc_audio_get_track_description( instance, &ex );
613     NSMutableArray *tempArray = [NSMutableArray array];
614     NSUInteger i;
615     for (i = 0; i < count ; i++)
616     {
617         [tempArray addObject:[NSString stringWithUTF8String: tracks->psz_name]];
618         tracks = tracks->p_next;
619     }
620
621     return [NSArray arrayWithArray: tempArray];
622 }
623
624 - (void)setAudioChannel:(NSInteger)value
625 {
626     libvlc_exception_t ex;
627     libvlc_exception_init( &ex );
628     libvlc_audio_set_channel( instance, value, &ex );
629     catch_exception( &ex );
630 }
631
632 - (NSInteger)audioChannel
633 {
634     libvlc_exception_t ex;
635     libvlc_exception_init( &ex );
636     NSInteger result = libvlc_audio_get_channel( instance, &ex );
637     catch_exception( &ex );
638     return result;
639 }
640
641 - (void)setMedia:(VLCMedia *)value
642 {
643     if (media != value)
644     {
645         if (media && [media compare:value] == NSOrderedSame)
646             return;
647
648         [media release];
649         media = [value retain];
650
651         libvlc_media_player_set_media(instance, [media libVLCMediaDescriptor]);
652     }
653 }
654
655 - (VLCMedia *)media
656 {
657     return media;
658 }
659
660 - (BOOL)play
661 {
662     libvlc_exception_t ex;
663     libvlc_exception_init( &ex );
664     libvlc_media_player_play( (libvlc_media_player_t *)instance, &ex );
665     catch_exception( &ex );
666     return YES;
667 }
668
669 - (void)pause
670 {
671     if( [NSThread isMainThread] )
672     {
673         /* Hack because we create a dead lock here, when the vout is stopped
674          * and tries to recontact us on the main thread */
675         /* FIXME: to do this properly we need to do some locking. We may want
676          * to move that to libvlc */
677         [self performSelectorInBackground:@selector(pause) withObject:nil];
678         return;
679     }
680
681     // Pause the stream
682     libvlc_exception_t ex;
683     libvlc_exception_init(&ex);
684     libvlc_media_player_pause(instance, &ex);
685
686     // fail gracefully
687     // in most cases, it's just EOF so let's stop
688     if (libvlc_exception_raised(&ex))
689         [self stop];
690
691     libvlc_exception_clear(&ex);
692 }
693
694 - (void)stop
695 {
696     libvlc_media_player_stop(instance);
697 }
698
699 - (void)gotoNextFrame
700 {
701     libvlc_exception_t e;
702     libvlc_exception_init(&e);
703     libvlc_media_player_next_frame(instance, &e);
704     catch_exception(&e);
705
706 }
707
708 - (void)fastForward
709 {
710     [self fastForwardAtRate: 2.0];
711 }
712
713 - (void)fastForwardAtRate:(float)rate
714 {
715     [self setRate:rate];
716 }
717
718 - (void)rewind
719 {
720     [self rewindAtRate: 2.0];
721 }
722
723 - (void)rewindAtRate:(float)rate
724 {
725     [self setRate: -rate];
726 }
727
728 - (void)jumpBackward:(NSInteger)interval
729 {
730     if( [self isSeekable] )
731     {
732         interval = interval * 1000;
733         [self setTime: [VLCTime timeWithInt: ([[self time] intValue] - interval)]];
734     }
735 }
736
737 - (void)jumpForward:(NSInteger)interval
738 {
739     if( [self isSeekable] )
740     {
741         interval = interval * 1000;
742         [self setTime: [VLCTime timeWithInt: ([[self time] intValue] + interval)]];
743     }
744 }
745
746 - (void)extraShortJumpBackward
747 {
748     [self jumpBackward:3];
749 }
750
751 - (void)extraShortJumpForward
752 {
753     [self jumpForward:3];
754 }
755
756 - (void)shortJumpBackward
757 {
758     [self jumpBackward:10];
759 }
760
761 - (void)shortJumpForward
762 {
763     [self jumpForward:10];
764 }
765
766 - (void)mediumJumpBackward
767 {
768     [self jumpBackward:60];
769 }
770
771 - (void)mediumJumpForward
772 {
773     [self jumpForward:60];
774 }
775
776 - (void)longJumpBackward
777 {
778     [self jumpBackward:300];
779 }
780
781 - (void)longJumpForward
782 {
783     [self jumpForward:300];
784 }
785
786 + (NSSet *)keyPathsForValuesAffectingIsPlaying
787 {
788     return [NSSet setWithObjects:@"state", nil];
789 }
790
791 - (BOOL)isPlaying
792 {
793     VLCMediaPlayerState state = [self state];
794     return ((state == VLCMediaPlayerStateOpening) || (state == VLCMediaPlayerStateBuffering) ||
795             (state == VLCMediaPlayerStatePlaying));
796 }
797
798 - (BOOL)willPlay
799 {
800     libvlc_exception_t ex;
801     libvlc_exception_init( &ex );
802     BOOL ret = libvlc_media_player_will_play( (libvlc_media_player_t *)instance, &ex );
803     if (libvlc_exception_raised(&ex))
804     {
805         libvlc_exception_clear(&ex);
806         return NO;
807     }
808     else
809         return ret;
810 }
811
812 static const VLCMediaPlayerState libvlc_to_local_state[] =
813 {
814     [libvlc_Stopped]    = VLCMediaPlayerStateStopped,
815     [libvlc_Opening]    = VLCMediaPlayerStateOpening,
816     [libvlc_Buffering]  = VLCMediaPlayerStateBuffering,
817     [libvlc_Playing]    = VLCMediaPlayerStatePlaying,
818     [libvlc_Paused]     = VLCMediaPlayerStatePaused,
819     [libvlc_Ended]      = VLCMediaPlayerStateEnded,
820     [libvlc_Error]      = VLCMediaPlayerStateError
821 };
822
823 - (VLCMediaPlayerState)state
824 {
825     return cachedState;
826 }
827
828 - (float)position
829 {
830     return position;
831 }
832
833 - (void)setPosition:(float)newPosition
834 {
835     libvlc_exception_t ex;
836     libvlc_exception_init( &ex );
837     libvlc_media_player_set_position( instance, newPosition, &ex );
838     catch_exception( &ex );
839 }
840
841 - (BOOL)isSeekable
842 {
843     libvlc_exception_t ex;
844     libvlc_exception_init( &ex );
845     BOOL ret = libvlc_media_player_is_seekable( instance, &ex );
846     catch_exception( &ex );
847     return ret;
848 }
849
850 - (BOOL)canPause
851 {
852     libvlc_exception_t ex;
853     libvlc_exception_init( &ex );
854     BOOL ret = libvlc_media_player_can_pause( instance, &ex );
855     catch_exception( &ex );
856     return ret;
857 }
858
859 - (void *)libVLCMediaPlayer
860 {
861     return instance;
862 }
863 @end
864
865 @implementation VLCMediaPlayer (Private)
866 - (id)initWithDrawable:(id)aDrawable
867 {
868     if (self = [super init])
869     {
870         delegate = nil;
871         media = nil;
872         cachedTime = [[VLCTime nullTime] retain];
873         cachedRemainingTime = [[VLCTime nullTime] retain];
874         position = 0.0f;
875         cachedState = VLCMediaPlayerStateStopped;
876
877         // Create a media instance, it doesn't matter what library we start off with
878         // it will change depending on the media descriptor provided to the media
879         // instance
880         libvlc_exception_t ex;
881         libvlc_exception_init( &ex );
882         instance = (void *)libvlc_media_player_new([VLCLibrary sharedInstance], &ex);
883         catch_exception( &ex );
884
885         [self registerObservers];
886
887         [self setDrawable:aDrawable];
888     }
889     return self;
890 }
891
892 - (void)registerObservers
893 {
894     // Attach event observers into the media instance
895     libvlc_event_manager_t * p_em = libvlc_media_player_event_manager(instance);
896     libvlc_event_attach(p_em, libvlc_MediaPlayerPlaying,          HandleMediaInstanceStateChanged, self);
897     libvlc_event_attach(p_em, libvlc_MediaPlayerPaused,           HandleMediaInstanceStateChanged, self);
898     libvlc_event_attach(p_em, libvlc_MediaPlayerEncounteredError, HandleMediaInstanceStateChanged, self);
899     libvlc_event_attach(p_em, libvlc_MediaPlayerEndReached,       HandleMediaInstanceStateChanged, self);
900     /* FIXME: We may want to turn that off when none is interested by that */
901     libvlc_event_attach(p_em, libvlc_MediaPlayerPositionChanged, HandleMediaPositionChanged,      self);
902     libvlc_event_attach(p_em, libvlc_MediaPlayerTimeChanged,     HandleMediaTimeChanged,          self);
903     libvlc_event_attach(p_em, libvlc_MediaPlayerMediaChanged,    HandleMediaPlayerMediaChanged,  self);
904 }
905
906 - (void)unregisterObservers
907 {
908     libvlc_event_manager_t * p_em = libvlc_media_player_event_manager(instance);
909     libvlc_event_detach(p_em, libvlc_MediaPlayerPlaying,          HandleMediaInstanceStateChanged, self);
910     libvlc_event_detach(p_em, libvlc_MediaPlayerPaused,           HandleMediaInstanceStateChanged, self);
911     libvlc_event_detach(p_em, libvlc_MediaPlayerEncounteredError, HandleMediaInstanceStateChanged, self);
912     libvlc_event_detach(p_em, libvlc_MediaPlayerEndReached,       HandleMediaInstanceStateChanged, self);
913     libvlc_event_detach(p_em, libvlc_MediaPlayerPositionChanged,  HandleMediaPositionChanged,      self);
914     libvlc_event_detach(p_em, libvlc_MediaPlayerTimeChanged,      HandleMediaTimeChanged,          self);
915     libvlc_event_detach(p_em, libvlc_MediaPlayerMediaChanged,     HandleMediaPlayerMediaChanged,   self);
916 }
917
918 - (void)mediaPlayerTimeChanged:(NSNumber *)newTime
919 {
920     [self willChangeValueForKey:@"time"];
921     [self willChangeValueForKey:@"remainingTime"];
922     [cachedTime release];
923     cachedTime = [[VLCTime timeWithNumber:newTime] retain];
924     [cachedRemainingTime release];
925     double currentTime = [[cachedTime numberValue] doubleValue];
926     double remaining = currentTime / position * (1 - position);
927     cachedRemainingTime = [[VLCTime timeWithNumber:[NSNumber numberWithDouble:-remaining]] retain];
928     [self didChangeValueForKey:@"remainingTime"];
929     [self didChangeValueForKey:@"time"];
930 }
931
932 - (void)delaySleep
933 {
934     UpdateSystemActivity(UsrActivity);
935 }
936
937 - (void)mediaPlayerPositionChanged:(NSNumber *)newPosition
938 {
939     // This seems to be the most relevant place to delay sleeping and screen saver.
940     [self delaySleep];
941
942     [self willChangeValueForKey:@"position"];
943     position = [newPosition floatValue];
944     [self didChangeValueForKey:@"position"];
945 }
946
947 - (void)mediaPlayerStateChanged:(NSNumber *)newState
948 {
949     [self willChangeValueForKey:@"state"];
950     cachedState = [newState intValue];
951     [self didChangeValueForKey:@"state"];
952 }
953
954 - (void)mediaPlayerMediaChanged:(VLCMedia *)newMedia
955 {
956     [self willChangeValueForKey:@"media"];
957     if (media != newMedia)
958     {
959         [media release];
960         media = [newMedia retain];
961     }
962     [self didChangeValueForKey:@"media"];
963 }
964
965 @end