2013-10-05 09:01:33 +00:00
|
|
|
//
|
|
|
|
// OpusDecoder.m
|
|
|
|
// Opus
|
|
|
|
//
|
|
|
|
// Created by Christopher Snowhill on 10/4/13.
|
|
|
|
// Copyright 2013 __NoWork, Inc__. All rights reserved.
|
|
|
|
//
|
|
|
|
|
2013-10-05 21:15:09 +00:00
|
|
|
#import "Plugin.h"
|
|
|
|
|
2013-10-05 09:01:33 +00:00
|
|
|
#import "OpusDecoder.h"
|
|
|
|
|
2013-10-11 12:03:55 +00:00
|
|
|
#import "Logging.h"
|
2013-10-05 09:01:33 +00:00
|
|
|
|
2022-02-09 21:44:50 +00:00
|
|
|
#import "HTTPSource.h"
|
|
|
|
|
2022-06-17 17:27:17 +00:00
|
|
|
#import "NSDictionary+Merge.h"
|
|
|
|
|
2022-07-08 13:26:28 +00:00
|
|
|
#import <FLAC/metadata.h>
|
|
|
|
|
2013-10-05 09:01:33 +00:00
|
|
|
@implementation OpusFile
|
|
|
|
|
2021-12-28 08:54:28 +00:00
|
|
|
static const int MAXCHANNELS = 8;
|
|
|
|
static const int chmap[MAXCHANNELS][MAXCHANNELS] = {
|
2022-02-07 05:49:27 +00:00
|
|
|
{
|
|
|
|
0,
|
|
|
|
}, // mono
|
|
|
|
{
|
|
|
|
0,
|
|
|
|
1,
|
|
|
|
}, // l, r
|
|
|
|
{
|
|
|
|
0,
|
|
|
|
2,
|
|
|
|
1,
|
|
|
|
}, // l, c, r -> l, r, c
|
|
|
|
{
|
|
|
|
0,
|
|
|
|
1,
|
|
|
|
2,
|
|
|
|
3,
|
|
|
|
}, // l, r, bl, br
|
|
|
|
{
|
|
|
|
0,
|
|
|
|
2,
|
|
|
|
1,
|
|
|
|
3,
|
|
|
|
4,
|
|
|
|
}, // l, c, r, bl, br -> l, r, c, bl, br
|
|
|
|
{ 0, 2, 1, 5, 3, 4 }, // l, c, r, bl, br, lfe -> l, r, c, lfe, bl, br
|
|
|
|
{ 0, 2, 1, 6, 5, 3, 4 }, // l, c, r, sl, sr, bc, lfe -> l, r, c, lfe, bc, sl, sr
|
|
|
|
{ 0, 2, 1, 7, 5, 6, 3, 4 } // l, c, r, sl, sr, bl, br, lfe -> l, r, c, lfe, bl, br, sl, sr
|
2021-12-28 08:54:28 +00:00
|
|
|
};
|
|
|
|
|
2022-02-07 05:49:27 +00:00
|
|
|
int sourceRead(void *_stream, unsigned char *_ptr, int _nbytes) {
|
2016-06-19 19:57:18 +00:00
|
|
|
id source = (__bridge id)_stream;
|
2013-10-05 09:01:33 +00:00
|
|
|
|
2022-02-07 05:49:27 +00:00
|
|
|
return (int)[source read:_ptr amount:_nbytes];
|
2013-10-05 09:01:33 +00:00
|
|
|
}
|
|
|
|
|
2022-02-07 05:49:27 +00:00
|
|
|
int sourceSeek(void *_stream, opus_int64 _offset, int _whence) {
|
2016-06-19 19:57:18 +00:00
|
|
|
id source = (__bridge id)_stream;
|
2013-10-05 09:01:33 +00:00
|
|
|
return ([source seek:_offset whence:_whence] ? 0 : -1);
|
|
|
|
}
|
|
|
|
|
2022-02-07 05:49:27 +00:00
|
|
|
int sourceClose(void *_stream) {
|
2013-10-05 09:01:33 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2022-02-07 05:49:27 +00:00
|
|
|
opus_int64 sourceTell(void *_stream) {
|
2016-06-19 19:57:18 +00:00
|
|
|
id source = (__bridge id)_stream;
|
2013-10-05 09:01:33 +00:00
|
|
|
|
|
|
|
return [source tell];
|
|
|
|
}
|
|
|
|
|
2022-02-07 05:49:27 +00:00
|
|
|
- (id)init {
|
|
|
|
self = [super init];
|
|
|
|
if(self) {
|
|
|
|
opusRef = NULL;
|
|
|
|
}
|
|
|
|
return self;
|
2013-10-05 09:01:33 +00:00
|
|
|
}
|
|
|
|
|
2022-02-07 05:49:27 +00:00
|
|
|
- (BOOL)open:(id<CogSource>)s {
|
2016-06-19 19:57:18 +00:00
|
|
|
source = s;
|
2022-02-07 05:49:27 +00:00
|
|
|
|
2013-10-05 09:01:33 +00:00
|
|
|
OpusFileCallbacks callbacks = {
|
2022-02-07 05:49:27 +00:00
|
|
|
.read = sourceRead,
|
|
|
|
.seek = sourceSeek,
|
|
|
|
.close = sourceClose,
|
|
|
|
.tell = sourceTell
|
2013-10-05 09:01:33 +00:00
|
|
|
};
|
2022-02-07 05:49:27 +00:00
|
|
|
|
|
|
|
int error;
|
|
|
|
opusRef = op_open_callbacks((__bridge void *)source, &callbacks, NULL, 0, &error);
|
|
|
|
|
|
|
|
if(!opusRef) {
|
2013-10-11 12:03:55 +00:00
|
|
|
DLog(@"FAILED TO OPEN OPUS FILE");
|
2013-10-05 09:01:33 +00:00
|
|
|
return NO;
|
|
|
|
}
|
|
|
|
|
2022-02-07 05:49:27 +00:00
|
|
|
currentSection = lastSection = op_current_link(opusRef);
|
|
|
|
|
|
|
|
bitrate = (op_bitrate(opusRef, currentSection) / 1000.0);
|
|
|
|
channels = op_channel_count(opusRef, currentSection);
|
|
|
|
|
2013-10-05 09:01:33 +00:00
|
|
|
seekable = op_seekable(opusRef);
|
2022-02-07 05:49:27 +00:00
|
|
|
|
2013-10-05 09:01:33 +00:00
|
|
|
totalFrames = op_pcm_total(opusRef, -1);
|
2022-02-07 05:49:27 +00:00
|
|
|
|
2022-02-10 05:27:33 +00:00
|
|
|
const OpusHead *head = op_head(opusRef, -1);
|
|
|
|
const OpusTags *tags = op_tags(opusRef, -1);
|
|
|
|
|
|
|
|
int _track_gain = 0;
|
|
|
|
|
|
|
|
opus_tags_get_track_gain(tags, &_track_gain);
|
|
|
|
|
2022-02-12 15:16:59 +00:00
|
|
|
replayGainAlbumGain = ((double)head->output_gain / 256.0) + 5.0;
|
|
|
|
replayGainTrackGain = ((double)_track_gain / 256.0) + replayGainAlbumGain;
|
2022-02-10 05:27:33 +00:00
|
|
|
|
|
|
|
op_set_gain_offset(opusRef, OP_ABSOLUTE_GAIN, 0);
|
2013-10-05 09:01:33 +00:00
|
|
|
|
|
|
|
[self willChangeValueForKey:@"properties"];
|
|
|
|
[self didChangeValueForKey:@"properties"];
|
2022-02-07 05:49:27 +00:00
|
|
|
|
2022-07-08 13:26:28 +00:00
|
|
|
metaDict = [NSDictionary dictionary];
|
|
|
|
icyMetaDict = [NSDictionary dictionary];
|
2022-02-12 15:16:59 +00:00
|
|
|
albumArt = [NSData data];
|
2022-07-08 13:26:28 +00:00
|
|
|
|
2022-02-09 21:44:50 +00:00
|
|
|
[self updateMetadata];
|
|
|
|
|
2013-10-05 09:01:33 +00:00
|
|
|
return YES;
|
|
|
|
}
|
|
|
|
|
2022-07-08 13:26:28 +00:00
|
|
|
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];
|
2022-02-12 15:16:59 +00:00
|
|
|
}
|
2022-07-08 13:26:28 +00:00
|
|
|
[array addObject:value];
|
2022-02-12 15:16:59 +00:00
|
|
|
}
|
|
|
|
|
2022-02-09 21:44:50 +00:00
|
|
|
- (void)updateMetadata {
|
2022-07-08 13:26:28 +00:00
|
|
|
const struct OpusTags *tags = op_tags(opusRef, -1);
|
|
|
|
NSMutableDictionary *_metaDict = [[NSMutableDictionary alloc] init];
|
|
|
|
NSData *_albumArt = albumArt;
|
2022-02-12 15:16:59 +00:00
|
|
|
|
|
|
|
if(tags) {
|
2022-07-08 13:26:28 +00:00
|
|
|
for(int i = 0; i < tags->comments; ++i) {
|
|
|
|
FLAC__StreamMetadata_VorbisComment_Entry entry = { .entry = (FLAC__byte *)tags->user_comments[i], .length = tags->comment_lengths[i] };
|
|
|
|
char *name, *value;
|
|
|
|
if(FLAC__metadata_object_vorbiscomment_entry_to_name_value_pair(entry, &name, &value)) {
|
|
|
|
NSString *tagName = guess_encoding_of_string(name);
|
|
|
|
NSString *tagValue = guess_encoding_of_string(value);
|
|
|
|
free(name);
|
|
|
|
free(value);
|
|
|
|
|
|
|
|
tagName = [tagName lowercaseString];
|
|
|
|
|
|
|
|
if([tagName isEqualToString:@"metadata_block_picture"]) {
|
|
|
|
OpusPictureTag _pic = { 0 };
|
|
|
|
if(opus_picture_tag_parse(&_pic, [tagValue UTF8String]) >= 0) {
|
|
|
|
if(_pic.format == OP_PIC_FORMAT_PNG ||
|
|
|
|
_pic.format == OP_PIC_FORMAT_JPEG ||
|
|
|
|
_pic.format == OP_PIC_FORMAT_GIF) {
|
|
|
|
_albumArt = [NSData dataWithBytes:_pic.data length:_pic.data_length];
|
|
|
|
}
|
|
|
|
opus_picture_tag_clear(&_pic);
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
setDictionary(_metaDict, tagName, tagValue);
|
2022-02-09 21:44:50 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2022-07-08 13:26:28 +00:00
|
|
|
if(![_albumArt isEqualToData:albumArt] ||
|
|
|
|
![_metaDict isEqualToDictionary:metaDict]) {
|
|
|
|
metaDict = _metaDict;
|
2022-02-12 15:16:59 +00:00
|
|
|
albumArt = _albumArt;
|
|
|
|
|
2022-02-09 21:44:50 +00:00
|
|
|
[self willChangeValueForKey:@"metadata"];
|
|
|
|
[self didChangeValueForKey:@"metadata"];
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
- (void)updateIcyMetadata {
|
2022-02-09 23:04:49 +00:00
|
|
|
if([source seekable]) return;
|
|
|
|
|
2022-07-08 13:26:28 +00:00
|
|
|
NSMutableDictionary *_icyMetaDict = [[NSMutableDictionary alloc] init];
|
2022-02-09 21:44:50 +00:00
|
|
|
|
|
|
|
Class sourceClass = [source class];
|
|
|
|
if([sourceClass isEqual:NSClassFromString(@"HTTPSource")]) {
|
|
|
|
HTTPSource *httpSource = (HTTPSource *)source;
|
|
|
|
if([httpSource hasMetadata]) {
|
|
|
|
NSDictionary *metadata = [httpSource metadata];
|
2022-07-08 13:26:28 +00:00
|
|
|
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);
|
|
|
|
}
|
2022-02-09 21:44:50 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2022-07-08 13:26:28 +00:00
|
|
|
if(![_icyMetaDict isEqualToDictionary:icyMetaDict]) {
|
|
|
|
icyMetaDict = _icyMetaDict;
|
2022-02-09 21:44:50 +00:00
|
|
|
[self willChangeValueForKey:@"metadata"];
|
|
|
|
[self didChangeValueForKey:@"metadata"];
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2022-02-07 05:49:27 +00:00
|
|
|
- (int)readAudio:(void *)buf frames:(UInt32)frames {
|
2013-10-05 09:01:33 +00:00
|
|
|
int numread;
|
|
|
|
int total = 0;
|
2022-02-07 05:49:27 +00:00
|
|
|
|
|
|
|
if(currentSection != lastSection) {
|
|
|
|
bitrate = (op_bitrate(opusRef, currentSection) / 1000.0);
|
2013-10-05 09:01:33 +00:00
|
|
|
channels = op_channel_count(opusRef, currentSection);
|
2022-02-07 05:49:27 +00:00
|
|
|
|
2013-10-05 09:01:33 +00:00
|
|
|
[self willChangeValueForKey:@"properties"];
|
|
|
|
[self didChangeValueForKey:@"properties"];
|
2022-02-09 21:44:50 +00:00
|
|
|
|
|
|
|
[self updateMetadata];
|
2013-10-05 09:01:33 +00:00
|
|
|
}
|
2022-02-07 05:49:27 +00:00
|
|
|
|
|
|
|
int size = frames * channels;
|
|
|
|
|
|
|
|
do {
|
|
|
|
float *out = ((float *)buf) + total;
|
|
|
|
float tempbuf[512 * channels];
|
2013-10-05 09:01:33 +00:00
|
|
|
lastSection = currentSection;
|
2022-02-07 05:49:27 +00:00
|
|
|
int toread = size - total;
|
|
|
|
if(toread > 512) toread = 512;
|
|
|
|
numread = op_read_float(opusRef, (channels < MAXCHANNELS) ? tempbuf : out, toread, NULL);
|
|
|
|
if(numread > 0 && channels <= MAXCHANNELS) {
|
|
|
|
for(int i = 0; i < numread; ++i) {
|
|
|
|
for(int j = 0; j < channels; ++j) {
|
|
|
|
out[i * channels + j] = tempbuf[i * channels + chmap[channels - 1][j]];
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
currentSection = op_current_link(opusRef);
|
|
|
|
if(numread > 0) {
|
2013-10-05 21:15:09 +00:00
|
|
|
total += numread * channels;
|
2013-10-05 09:01:33 +00:00
|
|
|
}
|
2022-02-07 05:49:27 +00:00
|
|
|
|
|
|
|
if(currentSection != lastSection) {
|
2013-10-05 09:01:33 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2022-02-07 05:49:27 +00:00
|
|
|
} while(total != size && numread != 0);
|
|
|
|
|
2022-02-09 21:44:50 +00:00
|
|
|
[self updateIcyMetadata];
|
|
|
|
|
2022-02-07 05:49:27 +00:00
|
|
|
return total / channels;
|
2013-10-05 09:01:33 +00:00
|
|
|
}
|
|
|
|
|
2022-02-07 05:49:27 +00:00
|
|
|
- (void)close {
|
|
|
|
op_free(opusRef);
|
|
|
|
opusRef = NULL;
|
2016-06-19 19:57:18 +00:00
|
|
|
}
|
|
|
|
|
2022-02-07 05:49:27 +00:00
|
|
|
- (void)dealloc {
|
|
|
|
[self close];
|
2013-10-05 09:01:33 +00:00
|
|
|
}
|
|
|
|
|
2022-02-07 05:49:27 +00:00
|
|
|
- (long)seek:(long)frame {
|
|
|
|
op_pcm_seek(opusRef, frame);
|
|
|
|
|
2013-10-05 09:01:33 +00:00
|
|
|
return frame;
|
|
|
|
}
|
|
|
|
|
2022-02-07 05:49:27 +00:00
|
|
|
- (NSDictionary *)properties {
|
2022-06-17 13:39:02 +00:00
|
|
|
return @{ @"channels": @(channels),
|
|
|
|
@"bitsPerSample": @(32),
|
|
|
|
@"floatingPoint": @(YES),
|
|
|
|
@"sampleRate": @(48000),
|
|
|
|
@"totalFrames": @(totalFrames),
|
|
|
|
@"bitrate": @(bitrate),
|
|
|
|
@"seekable": @([source seekable] && seekable),
|
2022-07-08 13:26:28 +00:00
|
|
|
@"replaygain_album_gain": @(replayGainAlbumGain),
|
|
|
|
@"replaygain_track_gain": @(replayGainTrackGain),
|
2022-02-10 05:27:33 +00:00
|
|
|
@"codec": @"Opus",
|
|
|
|
@"endian": @"host",
|
|
|
|
@"encoding": @"lossy" };
|
2013-10-05 09:01:33 +00:00
|
|
|
}
|
|
|
|
|
2022-02-09 03:56:39 +00:00
|
|
|
- (NSDictionary *)metadata {
|
2022-07-08 13:26:28 +00:00
|
|
|
NSDictionary *dict1 = @{ @"albumArt": albumArt };
|
|
|
|
NSDictionary *dict2 = [dict1 dictionaryByMergingWith:metaDict];
|
|
|
|
NSDictionary *dict3 = [dict2 dictionaryByMergingWith:icyMetaDict];
|
|
|
|
return dict3;
|
2022-02-09 03:56:39 +00:00
|
|
|
}
|
|
|
|
|
2022-02-07 05:49:27 +00:00
|
|
|
+ (NSArray *)fileTypes {
|
|
|
|
return @[@"opus", @"ogg"];
|
2013-10-05 09:01:33 +00:00
|
|
|
}
|
|
|
|
|
2022-02-07 05:49:27 +00:00
|
|
|
+ (NSArray *)mimeTypes {
|
2022-01-19 02:12:57 +00:00
|
|
|
return @[@"audio/x-opus+ogg", @"application/ogg"];
|
2013-10-05 09:01:33 +00:00
|
|
|
}
|
|
|
|
|
2022-02-07 05:49:27 +00:00
|
|
|
+ (float)priority {
|
|
|
|
return 1.0;
|
Implemented support for multiple decoders per file name extension, with a floating point priority control per interface. In the event that more than one input is registered to a given extension, and we match that extension, it will be passed off to an instance of the multi-decoder wrapper, which will try opening the file with all of the decoders in order of priority, until either one of them accepts it, or all of them have failed. This paves the way for adding a VGMSTREAM input, so I can give it a very low priority, since it has several formats that are verified by file name extension only. All current inputs have been given a priority of 1.0, except for CoreAudio, which was given a priority of 0.5, because it contains an MP3 and AC3 decoders that I'd rather not use if I don't have to.
2013-10-21 17:54:11 +00:00
|
|
|
}
|
|
|
|
|
2022-02-07 05:49:27 +00:00
|
|
|
+ (NSArray *)fileTypeAssociations {
|
|
|
|
return @[
|
|
|
|
@[@"Opus Audio File", @"ogg.icns", @"opus"],
|
|
|
|
@[@"Ogg Audio File", @"ogg.icns", @"ogg"]
|
|
|
|
];
|
2022-01-18 11:06:03 +00:00
|
|
|
}
|
|
|
|
|
2013-10-05 09:01:33 +00:00
|
|
|
@end
|