cog/Audio/AudioPlayer.m

464 lines
11 KiB
Matlab
Raw Normal View History

// AudioController.m
// Cog
//
// Created by Vincent Spader on 8/7/05.
// Copyright 2005 Vincent Spader. All rights reserved.
//
#import "AudioPlayer.h"
#import "BufferChain.h"
#import "OutputNode.h"
#import "Status.h"
#import "Helper.h"
#import "PluginController.h"
#import "Logging.h"
@implementation AudioPlayer
- (id)init
{
self = [super init];
if (self)
{
output = NULL;
bufferChain = nil;
outputLaunched = NO;
endOfInputReached = NO;
chainQueue = [[NSMutableArray alloc] init];
}
return self;
}
- (void)setDelegate:(id)d
{
delegate = d;
}
- (id)delegate {
return delegate;
}
- (void)play:(NSURL *)url
{
2013-10-13 02:16:47 +00:00
[self play:url withUserInfo:nil withRGInfo:nil startPaused:NO];
}
- (void)play:(NSURL *)url withUserInfo:(id)userInfo withRGInfo:(NSDictionary *)rgi
2013-10-13 02:16:47 +00:00
{
[self play:url withUserInfo:userInfo withRGInfo:rgi startPaused:NO];
}
- (void)play:(NSURL *)url withUserInfo:(id)userInfo withRGInfo:(NSDictionary *)rgi startPaused:(BOOL)paused
{
output = [[OutputNode alloc] initWithController:self previous:nil];
[output setup];
[output setVolume: volume];
2007-10-13 08:14:05 +00:00
@synchronized(chainQueue) {
for (id anObject in chainQueue)
2007-10-13 08:14:05 +00:00
{
[anObject setShouldContinue:NO];
}
[chainQueue removeAllObjects];
endOfInputReached = NO;
2007-10-13 08:14:05 +00:00
if (bufferChain)
{
[bufferChain setShouldContinue:NO];
bufferChain = nil;
2007-10-13 08:14:05 +00:00
}
}
bufferChain = [[BufferChain alloc] initWithController:self];
[self notifyStreamChanged:userInfo];
while (![bufferChain open:url withOutputFormat:[output format] withRGInfo:rgi])
{
bufferChain = nil;
[self requestNextStream: userInfo];
url = nextStream;
if (url == nil)
{
return;
}
userInfo = nextStreamUserInfo;
rgi = nextStreamRGInfo;
[self notifyStreamChanged:userInfo];
bufferChain = [[BufferChain alloc] initWithController:self];
}
[bufferChain setUserInfo:userInfo];
[self setShouldContinue:YES];
outputLaunched = NO;
2013-10-13 02:16:47 +00:00
startedPaused = paused;
initialBufferFilled = NO;
2007-07-11 01:20:32 +00:00
[bufferChain launchThreads];
2013-10-13 02:16:47 +00:00
if (paused)
[self setPlaybackStatus:kCogStatusPaused waitUntilDone:YES];
}
- (void)stop
{
//Set shouldoContinue to NO on allll things
[self setShouldContinue:NO];
[self setPlaybackStatus:kCogStatusStopped waitUntilDone:YES];
}
- (void)pause
{
[output pause];
[self setPlaybackStatus:kCogStatusPaused waitUntilDone:YES];
}
- (void)resume
{
2013-10-13 02:16:47 +00:00
if (startedPaused)
{
startedPaused = NO;
if (initialBufferFilled)
[self launchOutputThread];
}
[output resume];
[self setPlaybackStatus:kCogStatusPlaying waitUntilDone:YES];
}
- (void)seekToTime:(double)time
{
//Need to reset everything's buffers, and then seek?
/*HACK TO TEST HOW WELL THIS WOULD WORK*/
[output seek:time];
2007-05-26 22:13:11 +00:00
[bufferChain seek:time];
/*END HACK*/
}
- (void)setVolume:(double)v
{
volume = v;
[output setVolume:v];
}
- (double)volume
{
return volume;
}
2007-10-11 11:31:36 +00:00
//This is called by the delegate DURING a requestNextStream request.
- (void)setNextStream:(NSURL *)url
{
[self setNextStream:url withUserInfo:nil withRGInfo:nil];
}
- (void)setNextStream:(NSURL *)url withUserInfo:(id)userInfo withRGInfo:(NSDictionary *)rgi
{
nextStream = url;
nextStreamUserInfo = userInfo;
nextStreamRGInfo = rgi;
}
// Called when the playlist changed before we actually started playing a requested stream. We will re-request.
- (void)resetNextStreams
{
@synchronized (chainQueue) {
for (id anObject in chainQueue) {
[anObject setShouldContinue:NO];
}
[chainQueue removeAllObjects];
2009-03-01 06:02:26 +00:00
if (endOfInputReached) {
[self endOfInputReached:bufferChain];
2009-03-01 06:02:26 +00:00
}
}
}
- (void)setShouldContinue:(BOOL)s
{
2007-10-13 08:25:44 +00:00
if (bufferChain)
[bufferChain setShouldContinue:s];
if (output)
[output setShouldContinue:s];
}
- (double)amountPlayed
{
return [output amountPlayed];
}
- (void)launchOutputThread
{
2013-10-13 02:16:47 +00:00
initialBufferFilled = YES;
if (outputLaunched == NO && startedPaused == NO) {
[self setPlaybackStatus:kCogStatusPlaying];
[output launchThread];
outputLaunched = YES;
}
}
- (void)requestNextStream:(id)userInfo
{
[self sendDelegateMethod:@selector(audioPlayer:willEndStream:) withObject:userInfo waitUntilDone:YES];
}
- (void)notifyStreamChanged:(id)userInfo
{
[self sendDelegateMethod:@selector(audioPlayer:didBeginStream:) withObject:userInfo waitUntilDone:YES];
}
- (void)addChainToQueue:(BufferChain *)newChain
{
[newChain setUserInfo: nextStreamUserInfo];
[newChain setShouldContinue:YES];
[newChain launchThreads];
[chainQueue insertObject:newChain atIndex:[chainQueue count]];
}
- (BOOL)endOfInputReached:(BufferChain *)sender //Sender is a BufferChain
{
2007-10-20 03:24:27 +00:00
@synchronized (chainQueue) {
// No point in constructing new chain for the next playlist entry
// if there's already one at the head of chainQueue... r-r-right?
for (BufferChain *chain in chainQueue)
{
if ([chain isRunning])
{
return YES;
}
}
if ([chainQueue count] >= 5)
{
return YES;
}
BufferChain *newChain = nil;
nextStreamUserInfo = [sender userInfo];
nextStreamRGInfo = [sender rgInfo];
[self requestNextStream: nextStreamUserInfo];
2015-02-11 05:42:36 +00:00
if (!nextStream)
return YES;
newChain = [[BufferChain alloc] initWithController:self];
endOfInputReached = YES;
2007-10-20 03:24:27 +00:00
BufferChain *lastChain = [chainQueue lastObject];
if (lastChain == nil) {
lastChain = bufferChain;
}
2007-10-20 03:24:27 +00:00
if ([[nextStream scheme] isEqualToString:[[lastChain streamURL] scheme]]
&& [[nextStream host] isEqualToString:[[lastChain streamURL] host]]
&& [[nextStream path] isEqualToString:[[lastChain streamURL] path]])
{
2007-10-20 03:24:27 +00:00
if ([lastChain setTrack:nextStream]
&& [newChain openWithInput:[lastChain inputNode] withOutputFormat:[output format] withRGInfo:nextStreamRGInfo])
2007-10-20 03:24:27 +00:00
{
[newChain setStreamURL:nextStream];
[newChain setUserInfo:nextStreamUserInfo];
[self addChainToQueue:newChain];
DLog(@"TRACK SET!!! %@", newChain);
2007-10-20 03:24:27 +00:00
//Keep on-playin
newChain = nil;
2007-10-20 03:24:27 +00:00
return NO;
}
}
lastChain = nil;
while (![newChain open:nextStream withOutputFormat:[output format] withRGInfo:nextStreamRGInfo])
2007-10-20 03:24:27 +00:00
{
if (nextStream == nil)
{
newChain = nil;
2007-10-20 03:24:27 +00:00
return YES;
}
newChain = nil;
2007-10-20 03:24:27 +00:00
[self requestNextStream: nextStreamUserInfo];
2007-10-20 03:24:27 +00:00
newChain = [[BufferChain alloc] initWithController:self];
}
[self addChainToQueue:newChain];
newChain = nil;
// I'm stupid and can't hold too much stuff in my head all at once, so writing it here.
//
// Once we get here:
// - buffer chain for previous stream finished reading
// - there are (probably) some bytes of the previous stream in the output buffer which haven't been played
// (by output node) yet
// - self.bufferChain == previous playlist entry's buffer chain
// - self.nextStream == next playlist entry's URL
// - self.nextStreamUserInfo == next playlist entry
// - head of chainQueue is the buffer chain for the next entry (which has launched its threads already)
}
return YES;
}
- (void)endOfInputPlayed
{
// Once we get here:
// - the buffer chain for the next playlist entry (started in endOfInputReached) have been working for some time
// already, so that there is some decoded and converted data to play
// - the buffer chain for the next entry is the first item in chainQueue
2007-10-20 03:24:27 +00:00
@synchronized(chainQueue) {
2009-03-01 06:02:26 +00:00
endOfInputReached = NO;
2007-10-20 03:24:27 +00:00
if ([chainQueue count] <= 0)
{
//End of playlist
[self stop];
bufferChain = nil;
return;
}
bufferChain = nil;
bufferChain = [chainQueue objectAtIndex:0];
[chainQueue removeObjectAtIndex:0];
DLog(@"New!!! %@ %@", bufferChain, [[bufferChain inputNode] decoder]);
2007-10-13 08:14:05 +00:00
}
[self notifyStreamChanged:[bufferChain userInfo]];
[output setEndOfStream:NO];
}
- (void)sendDelegateMethod:(SEL)selector withObject:(id)obj waitUntilDone:(BOOL)wait
{
NSInvocation *invocation = [NSInvocation invocationWithMethodSignature:[delegate methodSignatureForSelector:selector]];
[invocation setTarget:delegate];
[invocation setSelector:selector];
[invocation setArgument:&self atIndex:2];
[invocation setArgument:&obj atIndex:3];
[invocation retainArguments];
[invocation performSelectorOnMainThread:@selector(invoke) withObject:nil waitUntilDone:wait];
}
- (void)sendDelegateMethod:(SEL)selector withObject:(id)obj withObject:(id)obj2 waitUntilDone:(BOOL)wait
{
NSInvocation *invocation = [NSInvocation invocationWithMethodSignature:[delegate methodSignatureForSelector:selector]];
[invocation setTarget:delegate];
[invocation setSelector:selector];
[invocation setArgument:&self atIndex:2];
[invocation setArgument:&obj atIndex:3];
[invocation setArgument:&obj2 atIndex:4];
[invocation retainArguments];
[invocation performSelectorOnMainThread:@selector(invoke) withObject:nil waitUntilDone:wait];
}
- (void)setPlaybackStatus:(int)status waitUntilDone:(BOOL)wait
{
[self sendDelegateMethod:@selector(audioPlayer:didChangeStatus:userInfo:) withObject:[NSNumber numberWithInt:status] withObject:[bufferChain userInfo] waitUntilDone:wait];
}
- (void)setPlaybackStatus:(int)status
{
[self setPlaybackStatus:status waitUntilDone:NO];
}
- (BufferChain *)bufferChain
{
return bufferChain;
}
- (OutputNode *) output
{
return output;
}
+ (NSArray *)containerTypes
{
return [[[PluginController sharedPluginController] containers] allKeys];
}
+ (NSArray *)fileTypes
{
PluginController *pluginController = [PluginController sharedPluginController];
NSArray *containerTypes = [[pluginController containers] allKeys];
2007-10-14 18:12:15 +00:00
NSArray *decoderTypes = [[pluginController decodersByExtension] allKeys];
NSArray *metdataReaderTypes = [[pluginController metadataReaders] allKeys];
2007-10-14 18:12:15 +00:00
NSArray *propertiesReaderTypes = [[pluginController propertiesReadersByExtension] allKeys];
NSMutableSet *types = [NSMutableSet set];
[types addObjectsFromArray:containerTypes];
[types addObjectsFromArray:decoderTypes];
[types addObjectsFromArray:metdataReaderTypes];
[types addObjectsFromArray:propertiesReaderTypes];
return [types allObjects];
}
+ (NSArray *)schemes
{
PluginController *pluginController = [PluginController sharedPluginController];
return [[pluginController sources] allKeys];
}
- (double)volumeUp:(double)amount
{
double newVolume = linearToLogarithmic(logarithmicToLinear(volume + amount));
if (newVolume > MAX_VOLUME)
newVolume = MAX_VOLUME;
[self setVolume:newVolume];
// the playbackController needs to know the new volume, so it can update the
// volumeSlider accordingly.
return newVolume;
}
- (double)volumeDown:(double)amount
{
double newVolume;
if (amount > volume)
newVolume = 0.0;
else
newVolume = linearToLogarithmic(logarithmicToLinear(volume - amount));
[self setVolume:newVolume];
return newVolume;
}
@end