kode54
/
cog
2
1
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
cog/Plugins/Flac/FlacDecoder.m

520 lines
16 KiB
Objective-C
Raw Blame History

//
// FlacDecoder.m
// zyVorbis
//
// Created by Vincent Spader on 1/25/05.
// Copyright 2005 Vincent Spader All rights reserved.
//
#import "FlacDecoder.h"
#import "Logging.h"
#import "HTTPSource.h"
#import "NSDictionary+Merge.h"
extern void grabbag__cuesheet_emit(NSString **out, const FLAC__StreamMetadata *cuesheet, const char *file_reference);
@implementation FlacDecoder
FLAC__StreamDecoderReadStatus ReadCallback(const FLAC__StreamDecoder *decoder, FLAC__byte blockBuffer[], size_t *bytes, void *client_data) {
FlacDecoder *flacDecoder = (__bridge FlacDecoder *)client_data;
long bytesRead = [[flacDecoder source] read:blockBuffer amount:*bytes];
if(bytesRead < 0) {
*bytes = 0;
return FLAC__STREAM_DECODER_READ_STATUS_ABORT;
} else if(bytesRead == 0) {
*bytes = 0;
[flacDecoder setEndOfStream:YES];
return FLAC__STREAM_DECODER_READ_STATUS_END_OF_STREAM;
} else {
*bytes = bytesRead;
return FLAC__STREAM_DECODER_READ_STATUS_CONTINUE;
}
}
FLAC__StreamDecoderSeekStatus SeekCallback(const FLAC__StreamDecoder *decoder, FLAC__uint64 absolute_byte_offset, void *client_data) {
FlacDecoder *flacDecoder = (__bridge FlacDecoder *)client_data;
if(![[flacDecoder source] seek:absolute_byte_offset whence:SEEK_SET])
return FLAC__STREAM_DECODER_SEEK_STATUS_ERROR;
else
return FLAC__STREAM_DECODER_SEEK_STATUS_OK;
}
FLAC__StreamDecoderTellStatus TellCallback(const FLAC__StreamDecoder *decoder, FLAC__uint64 *absolute_byte_offset, void *client_data) {
FlacDecoder *flacDecoder = (__bridge FlacDecoder *)client_data;
off_t pos;
if((pos = [[flacDecoder source] tell]) < 0)
return FLAC__STREAM_DECODER_TELL_STATUS_ERROR;
else {
*absolute_byte_offset = (FLAC__uint64)pos;
return FLAC__STREAM_DECODER_TELL_STATUS_OK;
}
}
FLAC__bool EOFCallback(const FLAC__StreamDecoder *decoder, void *client_data) {
FlacDecoder *flacDecoder = (__bridge FlacDecoder *)client_data;
return (FLAC__bool)[flacDecoder endOfStream];
}
FLAC__StreamDecoderLengthStatus LengthCallback(const FLAC__StreamDecoder *decoder, FLAC__uint64 *stream_length, void *client_data) {
FlacDecoder *flacDecoder = (__bridge FlacDecoder *)client_data;
if([[flacDecoder source] seekable]) {
long currentPos = [[flacDecoder source] tell];
[[flacDecoder source] seek:0 whence:SEEK_END];
*stream_length = [[flacDecoder source] tell];
[[flacDecoder source] seek:currentPos whence:SEEK_SET];
return FLAC__STREAM_DECODER_LENGTH_STATUS_OK;
} else {
*stream_length = 0;
return FLAC__STREAM_DECODER_LENGTH_STATUS_ERROR;
}
}
FLAC__StreamDecoderWriteStatus WriteCallback(const FLAC__StreamDecoder *decoder, const FLAC__Frame *frame, const FLAC__int32 *const sampleblockBuffer[], void *client_data) {
FlacDecoder *flacDecoder = (__bridge FlacDecoder *)client_data;
if(flacDecoder->abortFlag)
return FLAC__STREAM_DECODER_WRITE_STATUS_ABORT;
uint32_t channels = frame->header.channels;
uint32_t bitsPerSample = frame->header.bits_per_sample;
uint32_t frequency = frame->header.sample_rate;
if(channels != flacDecoder->channels ||
bitsPerSample != flacDecoder->bitsPerSample ||
frequency != flacDecoder->frequency) {
if(channels != flacDecoder->channels) {
flacDecoder->channelConfig = 0;
}
flacDecoder->channels = channels;
flacDecoder->bitsPerSample = bitsPerSample;
flacDecoder->frequency = frequency;
[flacDecoder willChangeValueForKey:@"properties"];
[flacDecoder didChangeValueForKey:@"properties"];
}
void *blockBuffer = [flacDecoder blockBuffer];
int8_t *alias8;
int16_t *alias16;
int32_t *alias32;
int sample, channel;
int32_t audioSample;
switch(frame->header.bits_per_sample) {
case 8:
// Interleave the audio (no need for byte swapping)
alias8 = blockBuffer;
for(sample = 0; sample < frame->header.blocksize; ++sample) {
for(channel = 0; channel < frame->header.channels; ++channel) {
*alias8++ = (int8_t)sampleblockBuffer[channel][sample];
}
}
break;
case 16:
// Interleave the audio, converting to big endian byte order
alias16 = blockBuffer;
for(sample = 0; sample < frame->header.blocksize; ++sample) {
for(channel = 0; channel < frame->header.channels; ++channel) {
*alias16++ = (int16_t)OSSwapHostToBigInt16((int16_t)sampleblockBuffer[channel][sample]);
}
}
break;
case 24:
// Interleave the audio (no need for byte swapping)
alias8 = blockBuffer;
for(sample = 0; sample < frame->header.blocksize; ++sample) {
for(channel = 0; channel < frame->header.channels; ++channel) {
audioSample = sampleblockBuffer[channel][sample];
*alias8++ = (int8_t)(audioSample >> 16);
*alias8++ = (int8_t)(audioSample >> 8);
*alias8++ = (int8_t)audioSample;
}
}
break;
case 32:
// Interleave the audio, converting to big endian byte order
alias32 = blockBuffer;
for(sample = 0; sample < frame->header.blocksize; ++sample) {
for(channel = 0; channel < frame->header.channels; ++channel) {
*alias32++ = OSSwapHostToBigInt32(sampleblockBuffer[channel][sample]);
}
}
default:
// Time for some nearest byte padding up to 32
alias8 = blockBuffer;
int sampleSize = frame->header.bits_per_sample;
int sampleBit;
for(sample = 0; sample < frame->header.blocksize; ++sample) {
for(channel = 0; channel < frame->header.channels; ++channel) {
int32_t sampleExtended = sampleblockBuffer[channel][sample];
for(sampleBit = sampleSize - 8; sampleBit >= -8; sampleBit -= 8) {
if(sampleBit >= 0)
*alias8++ = (uint8_t)((sampleExtended >> sampleBit) & 0xFF);
else
*alias8++ = (uint8_t)((sampleExtended << -sampleBit) & 0xFF);
}
}
}
break;
}
[flacDecoder setBlockBufferFrames:frame->header.blocksize];
return FLAC__STREAM_DECODER_WRITE_STATUS_CONTINUE;
}
static void setDictionary(NSMutableDictionary *dict, NSString *tag, NSString *value) {
NSMutableArray *array = [dict valueForKey:tag];
if(!array) {
array = [[NSMutableArray alloc] init];
[dict setObject:array forKey:tag];
}
[array addObject:value];
}
// This callback is only called for STREAMINFO blocks
void MetadataCallback(const FLAC__StreamDecoder *decoder, const FLAC__StreamMetadata *metadata, void *client_data) {
// Some flacs observed in the wild have multiple STREAMINFO metadata blocks,
// of which only first one has sane values, so only use values from the first STREAMINFO
// to determine stream format (this seems to be consistent with flac spec: http://flac.sourceforge.net/format.html)
FlacDecoder *flacDecoder = (__bridge FlacDecoder *)client_data;
if(!flacDecoder->hasStreamInfo && metadata->type == FLAC__METADATA_TYPE_STREAMINFO) {
flacDecoder->channels = metadata->data.stream_info.channels;
flacDecoder->channelConfig = 0;
flacDecoder->frequency = metadata->data.stream_info.sample_rate;
flacDecoder->bitsPerSample = metadata->data.stream_info.bits_per_sample;
flacDecoder->totalFrames = metadata->data.stream_info.total_samples;
flacDecoder->hasStreamInfo = YES;
}
if(metadata->type == FLAC__METADATA_TYPE_CUESHEET && !flacDecoder->cuesheetFound) {
flacDecoder->cuesheetFound = YES;
NSString *_cuesheet;
grabbag__cuesheet_emit(&_cuesheet, metadata, [[NSString stringWithFormat:@"\"%@\"", [[[flacDecoder->source url] path] lastPathComponent]] UTF8String]);
if(![_cuesheet isEqual:flacDecoder->cuesheet]) {
flacDecoder->cuesheet = _cuesheet;
if(![flacDecoder->source seekable]) {
[flacDecoder willChangeValueForKey:@"metadata"];
[flacDecoder didChangeValueForKey:@"metadata"];
}
}
}
if(metadata->type == FLAC__METADATA_TYPE_PICTURE) {
NSData *_albumArt = [NSData dataWithBytes:metadata->data.picture.data length:metadata->data.picture.data_length];
if(![_albumArt isEqual:flacDecoder->albumArt]) {
flacDecoder->albumArt = _albumArt;
if(![flacDecoder->source seekable]) {
[flacDecoder willChangeValueForKey:@"metadata"];
[flacDecoder didChangeValueForKey:@"metadata"];
}
}
}
if(metadata->type == FLAC__METADATA_TYPE_VORBIS_COMMENT) {
NSMutableDictionary *_metaDict = [[NSMutableDictionary alloc] init];
NSString *_cuesheet = flacDecoder->cuesheet;
const FLAC__StreamMetadata_VorbisComment *vorbis_comment = &metadata->data.vorbis_comment;
for(int i = 0; i < vorbis_comment->num_comments; ++i) {
char *_name;
char *_value;
if(FLAC__metadata_object_vorbiscomment_entry_to_name_value_pair(vorbis_comment->comments[i], &_name, &_value)) {
NSString *name = guess_encoding_of_string(_name);
NSString *value = guess_encoding_of_string(_value);
free(_name);
free(_value);
name = [name lowercaseString];
if([name isEqualToString:@"cuesheet"]) {
_cuesheet = value;
flacDecoder->cuesheetFound = YES;
} else if([name isEqualToString:@"waveformatextensible_channel_mask"]) {
if([value hasPrefix:@"0x"]) {
char *end;
const char *_value = [value UTF8String] + 2;
flacDecoder->channelConfig = (uint32_t)strtoul(_value, &end, 16);
}
} else {
setDictionary(_metaDict, name, value);
}
}
}
if(![_metaDict isEqualToDictionary:flacDecoder->metaDict] ||
![_cuesheet isEqualToString:flacDecoder->cuesheet]) {
flacDecoder->metaDict = _metaDict;
flacDecoder->cuesheet = _cuesheet;
if(![flacDecoder->source seekable]) {
[flacDecoder willChangeValueForKey:@"metadata"];
[flacDecoder didChangeValueForKey:@"metadata"];
}
}
}
}
void ErrorCallback(const FLAC__StreamDecoder *decoder, FLAC__StreamDecoderErrorStatus status, void *client_data) {
FlacDecoder *flacDecoder = (__bridge FlacDecoder *)client_data;
if(status != FLAC__STREAM_DECODER_ERROR_STATUS_LOST_SYNC)
flacDecoder->abortFlag = YES;
}
- (BOOL)open:(id<CogSource>)s {
[self setSource:s];
[self setSize:0];
if([s seekable]) {
[s seek:0 whence:SEEK_END];
[self setSize:[s tell]];
[s seek:0 whence:SEEK_SET];
}
// Must peek at stream! HTTP reader supports seeking within its buffer
BOOL isOggFlac = NO;
uint8_t buffer[4];
[s read:buffer amount:4];
[s seek:0 whence:SEEK_SET];
if(memcmp(buffer, "OggS", 4) == 0) {
isOggFlac = YES;
}
metaDict = [NSDictionary dictionary];
icyMetaDict = [NSDictionary dictionary];
albumArt = [NSData data];
cuesheetFound = NO;
cuesheet = @"";
decoder = FLAC__stream_decoder_new();
if(decoder == NULL)
return NO;
if(![source seekable]) {
FLAC__stream_decoder_set_md5_checking(decoder, false);
}
FLAC__stream_decoder_set_metadata_ignore_all(decoder);
FLAC__stream_decoder_set_metadata_respond(decoder, FLAC__METADATA_TYPE_STREAMINFO);
FLAC__stream_decoder_set_metadata_respond(decoder, FLAC__METADATA_TYPE_VORBIS_COMMENT);
FLAC__stream_decoder_set_metadata_respond(decoder, FLAC__METADATA_TYPE_PICTURE);
FLAC__stream_decoder_set_metadata_respond(decoder, FLAC__METADATA_TYPE_CUESHEET);
abortFlag = NO;
FLAC__StreamDecoderInitStatus ret;
if(isOggFlac) {
ret = FLAC__stream_decoder_init_ogg_stream(decoder,
ReadCallback,
([source seekable] ? SeekCallback : NULL),
([source seekable] ? TellCallback : NULL),
([source seekable] ? LengthCallback : NULL),
([source seekable] ? EOFCallback : NULL),
WriteCallback,
MetadataCallback,
ErrorCallback,
(__bridge void *)(self));
} else {
ret = FLAC__stream_decoder_init_stream(decoder,
ReadCallback,
([source seekable] ? SeekCallback : NULL),
([source seekable] ? TellCallback : NULL),
([source seekable] ? LengthCallback : NULL),
([source seekable] ? EOFCallback : NULL),
WriteCallback,
MetadataCallback,
ErrorCallback,
(__bridge void *)(self));
}
if(ret != FLAC__STREAM_DECODER_INIT_STATUS_OK) {
return NO;
}
FLAC__stream_decoder_process_until_end_of_metadata(decoder);
if(hasStreamInfo) {
[self willChangeValueForKey:@"properties"];
[self didChangeValueForKey:@"properties"];
}
blockBuffer = malloc(SAMPLE_blockBuffer_SIZE);
return YES;
}
- (AudioChunk *)readAudio {
id audioChunkClass = NSClassFromString(@"AudioChunk");
AudioChunk *chunk = nil;
while (blockBufferFrames <= 0) {
if(FLAC__stream_decoder_get_state(decoder) == FLAC__STREAM_DECODER_END_OF_STREAM) {
return nil;
}
if(!FLAC__stream_decoder_process_single(decoder)) {
return nil;
}
}
if(blockBufferFrames > 0) {
chunk = [[audioChunkClass alloc] initWithProperties:[self properties]];
[chunk assignSamples:blockBuffer frameCount:blockBufferFrames];
blockBufferFrames = 0;
}
if(![source seekable]) {
Class sourceClass = [source class];
if([sourceClass isEqual:NSClassFromString(@"HTTPSource")]) {
HTTPSource *httpSource = (HTTPSource *)source;
NSMutableDictionary *_icyMetaDict = [[NSMutableDictionary alloc] init];
if([httpSource hasMetadata]) {
NSDictionary *metadata = [httpSource metadata];
NSString *_genre = [metadata valueForKey:@"genre"];
NSString *_album = [metadata valueForKey:@"album"];
NSString *_artist = [metadata valueForKey:@"artist"];
NSString *_title = [metadata valueForKey:@"title"];
if(_genre && [_genre length]) {
setDictionary(_icyMetaDict, @"genre", _genre);
}
if(_album && [_album length]) {
setDictionary(_icyMetaDict, @"album", _album);
}
if(_artist && [_artist length]) {
setDictionary(_icyMetaDict, @"artist", _artist);
}
if(_title && [_title length]) {
setDictionary(_icyMetaDict, @"title", _title);
}
if(![_icyMetaDict isEqualToDictionary:icyMetaDict]) {
icyMetaDict = _icyMetaDict;
[self willChangeValueForKey:@"metadata"];
[self didChangeValueForKey:@"metadata"];
}
}
}
}
return chunk;
}
- (void)close {
if(decoder) {
FLAC__stream_decoder_finish(decoder);
FLAC__stream_decoder_delete(decoder);
}
if(blockBuffer) {
free(blockBuffer);
}
decoder = NULL;
blockBuffer = NULL;
}
- (void)dealloc {
[self close];
}
- (long)seek:(long)sample {
if(!FLAC__stream_decoder_seek_absolute(decoder, sample))
return -1;
return sample;
}
// bs methods
- (char *)blockBuffer {
return blockBuffer;
}
- (int)blockBufferFrames {
return blockBufferFrames;
}
- (void)setBlockBufferFrames:(int)frames {
blockBufferFrames = frames;
}
- (FLAC__StreamDecoder *)decoder {
return decoder;
}
- (void)setSource:(id<CogSource>)s {
source = s;
}
- (id<CogSource>)source {
return source;
}
- (void)setEndOfStream:(BOOL)eos {
endOfStream = eos;
}
- (BOOL)endOfStream {
return endOfStream;
}
- (void)setSize:(long)size {
fileSize = size;
}
- (NSDictionary *)properties {
return @{ @"channels": @(channels),
@"channelConfig": @(channelConfig),
@"bitsPerSample": @(bitsPerSample),
@"sampleRate": @(frequency),
@"totalFrames": @(totalFrames),
@"seekable": @([source seekable]),
@"bitrate": @(fileSize ? (fileSize * 8 / ((totalFrames + (frequency / 2)) / frequency)) / 1000 : 0),
@"codec": @"FLAC",
@"endian": @"big",
@"encoding": @"lossless" };
}
- (NSDictionary *)metadata {
NSDictionary *dict1 = @{ @"albumArt": albumArt, @"cuesheet": cuesheet };
NSDictionary *dict2 = [dict1 dictionaryByMergingWith:metaDict];
NSDictionary *dict3 = [dict2 dictionaryByMergingWith:icyMetaDict];
return dict3;
}
+ (NSArray *)fileTypes {
return @[@"flac"];
}
+ (NSArray *)mimeTypes {
return @[@"audio/x-flac", @"application/ogg", @"audio/ogg"];
}
+ (float)priority {
return 2.0;
}
+ (NSArray *)fileTypeAssociations {
return @[
@[@"FLAC Audio File", @"flac.icns", @"flac"]
];
}
@end
Reference in New Issue View Git Blame Copy Permalink