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
9 * Authors: Pierre d'Herbemont <pdherbemont # videolan.org>
10 * Faustion Osuna <enrique.osuna # gmail.com>
11 * Felix Paul Kühne <fkuehne # videolan.org>
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.
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.
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 *****************************************************************************/
28 #import "VLCLibrary.h"
29 #import "VLCMediaPlayer.h"
30 #import "VLCEventManager.h"
31 #import "VLCLibVLCBridging.h"
32 #import "VLCVideoView.h"
37 /* prevent system sleep */
38 #import <CoreServices/CoreServices.h>
39 /* FIXME: Ugly hack! */
41 #import <CoreServices/../Frameworks/OSServices.framework/Headers/Power.h>
46 /* Notification Messages */
47 NSString * VLCMediaPlayerTimeChanged = @"VLCMediaPlayerTimeChanged";
48 NSString * VLCMediaPlayerStateChanged = @"VLCMediaPlayerStateChanged";
50 NSString * VLCMediaPlayerStateToString(VLCMediaPlayerState state)
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"
61 return stateToStrings[state];
64 /* libvlc event callback */
65 static void HandleMediaInstanceVolumeChanged(const libvlc_event_t * event, void * self)
67 [[VLCEventManager sharedManager] callOnMainThreadDelegateOfObject:self
68 withDelegateMethod:@selector(mediaPlayerVolumeChanged:)
69 withNotificationName:VLCMediaPlayerVolumeChanged];
72 static void HandleMediaTimeChanged(const libvlc_event_t * event, void * self)
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]];
79 [[VLCEventManager sharedManager] callOnMainThreadDelegateOfObject:self
80 withDelegateMethod:@selector(mediaPlayerTimeChanged:)
81 withNotificationName:VLCMediaPlayerTimeChanged];
85 static void HandleMediaPositionChanged(const libvlc_event_t * event, void * self)
87 NSAutoreleasePool * pool = [[NSAutoreleasePool alloc] init];
89 [[VLCEventManager sharedManager] callOnMainThreadObject:self
90 withMethod:@selector(mediaPlayerPositionChanged:)
91 withArgumentAsObject:[NSNumber numberWithFloat:event->u.media_player_position_changed.new_position]];
95 static void HandleMediaInstanceStateChanged(const libvlc_event_t * event, void * self)
97 VLCMediaPlayerState newState;
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;
109 NSLog(@"%s: Unknown event", __FUNCTION__);
113 NSAutoreleasePool * pool = [[NSAutoreleasePool alloc] init];
115 [[VLCEventManager sharedManager] callOnMainThreadObject:self
116 withMethod:@selector(mediaPlayerStateChanged:)
117 withArgumentAsObject:[NSNumber numberWithInt:newState]];
119 [[VLCEventManager sharedManager] callOnMainThreadDelegateOfObject:self
120 withDelegateMethod:@selector(mediaPlayerStateChanged:)
121 withNotificationName:VLCMediaPlayerStateChanged];
127 static void HandleMediaPlayerMediaChanged(const libvlc_event_t * event, void * self)
129 NSAutoreleasePool * pool = [[NSAutoreleasePool alloc] init];
131 [[VLCEventManager sharedManager] callOnMainThreadObject:self
132 withMethod:@selector(mediaPlayerMediaChanged:)
133 withArgumentAsObject:[VLCMedia mediaWithLibVLCMediaDescriptor:event->u.media_player_media_changed.new_media]];
140 // TODO: Documentation
141 @interface VLCMediaPlayer (Private)
142 - (id)initWithDrawable:(id)aDrawable;
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;
152 @implementation VLCMediaPlayer
155 + (NSSet *)keyPathsForValuesAffectingValueForKey:(NSString *)key
157 static NSDictionary * dict = nil;
158 NSSet * superKeyPaths;
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",
168 if( (superKeyPaths = [super keyPathsForValuesAffectingValueForKey: key]) )
170 NSMutableSet * ret = [NSMutableSet setWithSet:[dict objectForKey: key]];
171 [ret unionSet:superKeyPaths];
174 return [dict objectForKey: key];
180 return [self initWithDrawable:nil];
183 - (id)initWithVideoView:(VLCVideoView *)aVideoView
185 return [self initWithDrawable: aVideoView];
188 - (id)initWithVideoLayer:(VLCVideoLayer *)aVideoLayer
190 return [self initWithDrawable: aVideoLayer];
197 if([self retainCount] <= 1)
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];
210 NSAssert(libvlc_media_player_get_state(instance) == libvlc_Stopped, @"You released the media player before ensuring that it is stopped");
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?
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);
221 libvlc_media_player_release(instance);
223 // Get rid of everything else
225 [cachedTime release];
226 [cachedRemainingTime release];
233 - (void)setDelegate:(id)value
243 - (void)setVideoView:(VLCVideoView *)aVideoView
245 [self setDrawable: aVideoView];
248 - (void)setVideoLayer:(VLCVideoLayer *)aVideoLayer
250 [self setDrawable: aVideoLayer];
253 - (void)setDrawable:(id)aDrawable
255 // Make sure that this instance has been associated with the drawing canvas.
256 libvlc_media_player_set_nsobject(instance, aDrawable);
261 return libvlc_media_player_get_nsobject(instance);
267 audio = [[VLCAudio alloc] initWithMediaPlayer:self];
272 #pragma mark Subtitles
274 - (void)setCurrentVideoSubTitleIndex:(NSUInteger)index
276 libvlc_video_set_spu(instance, (int)index);
279 - (NSUInteger)currentVideoSubTitleIndex
281 NSInteger count = libvlc_video_get_spu_count(instance);
286 return libvlc_video_get_spu(instance);
289 - (BOOL)openVideoSubTitlesFromFile:(NSString *)path
291 return libvlc_video_set_subtitle_file(instance, [path UTF8String]);
294 - (NSArray *)videoSubTitles
296 libvlc_track_description_t *currentTrack = libvlc_video_get_spu_description(instance);
298 NSMutableArray *tempArray = [NSMutableArray array];
299 while (currentTrack) {
300 [tempArray addObject:[NSString stringWithUTF8String:currentTrack->psz_name]];
301 currentTrack = currentTrack->p_next;
303 libvlc_track_description_release(currentTrack);
304 return [NSArray arrayWithArray: tempArray];
309 #pragma mark Video Crop geometry
311 - (void)setVideoCropGeometry:(char *)value
313 libvlc_video_set_crop_geometry(instance, value);
316 - (char *)videoCropGeometry
318 char * result = libvlc_video_get_crop_geometry(instance);
322 - (void)setVideoAspectRatio:(char *)value
324 libvlc_video_set_aspect_ratio( instance, value );
327 - (char *)videoAspectRatio
329 char * result = libvlc_video_get_aspect_ratio( instance );
333 - (void)saveVideoSnapshotAt:(NSString *)path withWidth:(NSUInteger)width andHeight:(NSUInteger)height
335 int failure = libvlc_video_take_snapshot(instance, 0, [path UTF8String], width, height);
337 [[NSException exceptionWithName:@"Can't take a video snapshot" reason:@"No video output" userInfo:nil] raise];
340 - (void)setDeinterlaceFilter:(NSString *)name
342 libvlc_video_set_deinterlace(instance, [name UTF8String]);
345 - (void)setRate:(float)value
347 libvlc_media_player_set_rate(instance, value);
352 return libvlc_media_player_get_rate(instance);
357 unsigned height = 0, width = 0;
358 int failure = libvlc_video_get_size(instance, 0, &width, &height);
360 [[NSException exceptionWithName:@"Can't get video size" reason:@"No video output" userInfo:nil] raise];
361 return NSMakeSize(width, height);
366 return libvlc_media_player_has_vout(instance);
369 - (float)framesPerSecond
371 return libvlc_media_player_get_fps(instance);
374 - (void)setTime:(VLCTime *)value
376 // Time is managed in seconds, while duration is managed in microseconds
377 // TODO: Redo VLCTime to provide value numberAsMilliseconds, numberAsMicroseconds, numberAsSeconds, numberAsMinutes, numberAsHours
378 libvlc_media_player_set_time(instance, value ? [[value numberValue] longLongValue] : 0);
386 - (VLCTime *)remainingTime
388 return cachedRemainingTime;
393 return libvlc_media_player_get_fps(instance);
397 #pragma mark Chapters
398 - (void)setCurrentChapterIndex:(NSUInteger)value;
400 libvlc_media_player_set_chapter(instance, value);
403 - (NSUInteger)currentChapterIndex
405 NSInteger count = libvlc_media_player_get_chapter_count(instance);
408 NSUInteger result = libvlc_media_player_get_chapter(instance);
414 libvlc_media_player_next_chapter(instance);
417 - (void)previousChapter
419 libvlc_media_player_previous_chapter(instance);
422 - (NSArray *)chaptersForTitleIndex:(NSUInteger)title
424 NSInteger count = libvlc_media_player_get_chapter_count(instance);
426 return [NSArray array];
428 libvlc_track_description_t *tracks = libvlc_video_get_chapter_description(instance, title);
429 NSMutableArray *tempArray = [NSMutableArray array];
431 for (i = 0; i < count ; i++)
433 [tempArray addObject:[NSString stringWithUTF8String:tracks->psz_name]];
434 tracks = tracks->p_next;
436 libvlc_track_description_release(tracks);
437 return [NSArray arrayWithArray:tempArray];
443 - (void)setCurrentTitleIndex:(NSUInteger)value
445 libvlc_media_player_set_title(instance, value);
448 - (NSUInteger)currentTitleIndex
450 NSInteger count = libvlc_media_player_get_title_count(instance);
454 return libvlc_media_player_get_title(instance);
457 - (NSUInteger)countOfTitles
459 NSUInteger result = libvlc_media_player_get_title_count(instance);
465 libvlc_track_description_t *tracks = libvlc_video_get_title_description(instance);
466 NSMutableArray *tempArray = [NSMutableArray array];
468 for (i = 0; i < [self countOfTitles] ; i++)
470 [tempArray addObject:[NSString stringWithUTF8String: tracks->psz_name]];
471 tracks = tracks->p_next;
473 libvlc_track_description_release(tracks);
474 return [NSArray arrayWithArray: tempArray];
478 #pragma mark Audio tracks
479 - (void)setCurrentAudioTrackIndex:(NSUInteger)value
481 libvlc_audio_set_track( instance, (int)value);
484 - (NSUInteger)currentAudioTrackIndex
486 NSInteger count = libvlc_audio_get_track_count(instance);
490 NSUInteger result = libvlc_audio_get_track(instance);
494 - (NSArray *)audioTracks
496 NSInteger count = libvlc_audio_get_track_count(instance);
498 return [NSArray array];
500 libvlc_track_description_t *tracks = libvlc_audio_get_track_description(instance);
501 NSMutableArray *tempArray = [NSMutableArray array];
503 for (i = 0; i < count ; i++)
505 [tempArray addObject:[NSString stringWithUTF8String: tracks->psz_name]];
506 tracks = tracks->p_next;
508 libvlc_track_description_release(tracks);
510 return [NSArray arrayWithArray: tempArray];
513 - (void)setAudioChannel:(NSInteger)value
515 libvlc_audio_set_channel(instance, value);
518 - (NSInteger)audioChannel
520 return libvlc_audio_get_channel(instance);
523 - (void)setMedia:(VLCMedia *)value
527 if (media && [media compare:value] == NSOrderedSame)
531 media = [value retain];
533 libvlc_media_player_set_media(instance, [media libVLCMediaDescriptor]);
544 libvlc_media_player_play(instance);
550 if( [NSThread isMainThread] )
552 /* Hack because we create a dead lock here, when the vout is stopped
553 * and tries to recontact us on the main thread */
554 /* FIXME: to do this properly we need to do some locking. We may want
555 * to move that to libvlc */
556 [self performSelectorInBackground:@selector(pause) withObject:nil];
561 libvlc_media_player_pause(instance);
566 libvlc_media_player_stop(instance);
569 - (void)gotoNextFrame
571 libvlc_media_player_next_frame(instance);
577 [self fastForwardAtRate: 2.0];
580 - (void)fastForwardAtRate:(float)rate
587 [self rewindAtRate: 2.0];
590 - (void)rewindAtRate:(float)rate
592 [self setRate: -rate];
595 - (void)jumpBackward:(NSInteger)interval
597 if( [self isSeekable] )
599 interval = interval * 1000;
600 [self setTime: [VLCTime timeWithInt: ([[self time] intValue] - interval)]];
604 - (void)jumpForward:(NSInteger)interval
606 if( [self isSeekable] )
608 interval = interval * 1000;
609 [self setTime: [VLCTime timeWithInt: ([[self time] intValue] + interval)]];
613 - (void)extraShortJumpBackward
615 [self jumpBackward:3];
618 - (void)extraShortJumpForward
620 [self jumpForward:3];
623 - (void)shortJumpBackward
625 [self jumpBackward:10];
628 - (void)shortJumpForward
630 [self jumpForward:10];
633 - (void)mediumJumpBackward
635 [self jumpBackward:60];
638 - (void)mediumJumpForward
640 [self jumpForward:60];
643 - (void)longJumpBackward
645 [self jumpBackward:300];
648 - (void)longJumpForward
650 [self jumpForward:300];
653 + (NSSet *)keyPathsForValuesAffectingIsPlaying
655 return [NSSet setWithObjects:@"state", nil];
660 VLCMediaPlayerState state = [self state];
661 return ((state == VLCMediaPlayerStateOpening) || (state == VLCMediaPlayerStateBuffering) ||
662 (state == VLCMediaPlayerStatePlaying));
667 return libvlc_media_player_will_play(instance);
670 static const VLCMediaPlayerState libvlc_to_local_state[] =
672 [libvlc_Stopped] = VLCMediaPlayerStateStopped,
673 [libvlc_Opening] = VLCMediaPlayerStateOpening,
674 [libvlc_Buffering] = VLCMediaPlayerStateBuffering,
675 [libvlc_Playing] = VLCMediaPlayerStatePlaying,
676 [libvlc_Paused] = VLCMediaPlayerStatePaused,
677 [libvlc_Ended] = VLCMediaPlayerStateEnded,
678 [libvlc_Error] = VLCMediaPlayerStateError
681 - (VLCMediaPlayerState)state
691 - (void)setPosition:(float)newPosition
693 libvlc_media_player_set_position(instance, newPosition);
698 return libvlc_media_player_is_seekable(instance);
703 return libvlc_media_player_can_pause(instance);
706 - (void *)libVLCMediaPlayer
712 @implementation VLCMediaPlayer (Private)
713 - (id)initWithDrawable:(id)aDrawable
715 if (self = [super init])
719 cachedTime = [[VLCTime nullTime] retain];
720 cachedRemainingTime = [[VLCTime nullTime] retain];
722 cachedState = VLCMediaPlayerStateStopped;
724 // Create a media instance, it doesn't matter what library we start off with
725 // it will change depending on the media descriptor provided to the media
727 libvlc_exception_t ex;
728 libvlc_exception_init( &ex );
729 instance = libvlc_media_player_new([VLCLibrary sharedInstance]);
730 catch_exception( &ex );
732 [self registerObservers];
734 [self setDrawable:aDrawable];
739 - (void)registerObservers
741 // Attach event observers into the media instance
742 libvlc_event_manager_t * p_em = libvlc_media_player_event_manager(instance);
743 libvlc_event_attach(p_em, libvlc_MediaPlayerPlaying, HandleMediaInstanceStateChanged, self);
744 libvlc_event_attach(p_em, libvlc_MediaPlayerPaused, HandleMediaInstanceStateChanged, self);
745 libvlc_event_attach(p_em, libvlc_MediaPlayerEncounteredError, HandleMediaInstanceStateChanged, self);
746 libvlc_event_attach(p_em, libvlc_MediaPlayerEndReached, HandleMediaInstanceStateChanged, self);
747 /* FIXME: We may want to turn that off when none is interested by that */
748 libvlc_event_attach(p_em, libvlc_MediaPlayerPositionChanged, HandleMediaPositionChanged, self);
749 libvlc_event_attach(p_em, libvlc_MediaPlayerTimeChanged, HandleMediaTimeChanged, self);
750 libvlc_event_attach(p_em, libvlc_MediaPlayerMediaChanged, HandleMediaPlayerMediaChanged, self);
753 - (void)unregisterObservers
755 libvlc_event_manager_t * p_em = libvlc_media_player_event_manager(instance);
756 libvlc_event_detach(p_em, libvlc_MediaPlayerPlaying, HandleMediaInstanceStateChanged, self);
757 libvlc_event_detach(p_em, libvlc_MediaPlayerPaused, HandleMediaInstanceStateChanged, self);
758 libvlc_event_detach(p_em, libvlc_MediaPlayerEncounteredError, HandleMediaInstanceStateChanged, self);
759 libvlc_event_detach(p_em, libvlc_MediaPlayerEndReached, HandleMediaInstanceStateChanged, self);
760 libvlc_event_detach(p_em, libvlc_MediaPlayerPositionChanged, HandleMediaPositionChanged, self);
761 libvlc_event_detach(p_em, libvlc_MediaPlayerTimeChanged, HandleMediaTimeChanged, self);
762 libvlc_event_detach(p_em, libvlc_MediaPlayerMediaChanged, HandleMediaPlayerMediaChanged, self);
765 - (void)mediaPlayerTimeChanged:(NSNumber *)newTime
767 [self willChangeValueForKey:@"time"];
768 [self willChangeValueForKey:@"remainingTime"];
769 [cachedTime release];
770 cachedTime = [[VLCTime timeWithNumber:newTime] retain];
771 [cachedRemainingTime release];
772 double currentTime = [[cachedTime numberValue] doubleValue];
773 double remaining = currentTime / position * (1 - position);
774 cachedRemainingTime = [[VLCTime timeWithNumber:[NSNumber numberWithDouble:-remaining]] retain];
775 [self didChangeValueForKey:@"remainingTime"];
776 [self didChangeValueForKey:@"time"];
781 UpdateSystemActivity(UsrActivity);
784 - (void)mediaPlayerPositionChanged:(NSNumber *)newPosition
786 // This seems to be the most relevant place to delay sleeping and screen saver.
789 [self willChangeValueForKey:@"position"];
790 position = [newPosition floatValue];
791 [self didChangeValueForKey:@"position"];
794 - (void)mediaPlayerStateChanged:(NSNumber *)newState
796 [self willChangeValueForKey:@"state"];
797 cachedState = [newState intValue];
798 [self didChangeValueForKey:@"state"];
801 - (void)mediaPlayerMediaChanged:(VLCMedia *)newMedia
803 [self willChangeValueForKey:@"media"];
804 if (media != newMedia)
807 media = [newMedia retain];
809 [self didChangeValueForKey:@"media"];