SFBDoPDecoder.m

//
// SPDX-FileCopyrightText: 2014 Stephen F. Booth <contact@sbooth.dev>
// SPDX-License-Identifier: MIT
//
// Part of https://github.com/sbooth/SFBAudioEngine
//

#import "SFBDoPDecoder.h"

#import "SFBAudioDecoder+Internal.h"
#import "SFBDSDDecoder.h"
#import "SFBLocalizedNameForURL.h"

#import <os/log.h>

#import <stdint.h>

#define DSD_PACKETS_PER_DOP_FRAME (16 / kSFBPCMFramesPerDSDPacket)
#define BUFFER_SIZE_PACKETS 4096

// Bit reversal lookup table from http://graphics.stanford.edu/~seander/bithacks.html#BitReverseTable
static const unsigned char sBitReverseTable256[256] = {
#define R2(n) n, n + 2 * 64, n + 1 * 64, n + 3 * 64
#define R4(n) R2(n), R2(n + 2 * 16), R2(n + 1 * 16), R2(n + 3 * 16)
#define R6(n) R4(n), R4(n + 2 * 4), R4(n + 1 * 4), R4(n + 3 * 4)
        R6(0), R6(2), R6(1), R6(3)};

// Support DSD64, DSD128, and DSD256 (64x, 128x, and 256x the CD sample rate of 44.1 kHz)
// as well as the 48.0 kHz variants 6.144 MHz and 12.288 MHz
static BOOL IsSupportedDoPSampleRate(Float64 sampleRate) {
    switch ((uint32_t)sampleRate) {
    case kSFBSampleRateDSD64:
    case kSFBSampleRateDSD128:
    case kSFBSampleRateDSD256:
    case kSFBSampleRateDSD128Variant:
    case kSFBSampleRateDSD256Variant:
        return YES;
    default:
        return NO;
    }
}

@interface SFBDoPDecoder () {
  @private
    AVAudioCompressedBuffer *_buffer;
    unsigned char _marker;
    BOOL _reverseBits;
}
@end

@implementation SFBDoPDecoder

@synthesize processingFormat = _processingFormat;

- (instancetype)initWithURL:(NSURL *)url error:(NSError **)error {
    NSParameterAssert(url != nil);

    SFBInputSource *inputSource = [SFBInputSource inputSourceForURL:url flags:0 error:error];
    if (!inputSource) {
        return nil;
    }
    return [self initWithInputSource:inputSource error:error];
}

- (instancetype)initWithInputSource:(SFBInputSource *)inputSource error:(NSError **)error {
    NSParameterAssert(inputSource != nil);

    SFBDSDDecoder *decoder = [[SFBDSDDecoder alloc] initWithInputSource:inputSource error:error];
    if (!decoder) {
        return nil;
    }

    return [self initWithDecoder:decoder error:error];
}

- (instancetype)initWithDecoder:(id<SFBDSDDecoding>)decoder error:(NSError **)error {
    NSParameterAssert(decoder != nil);

    if ((self = [super init])) {
        _decoder = decoder;
        _marker = 0x05;
    }
    return self;
}

- (SFBInputSource *)inputSource {
    return _decoder.inputSource;
}

- (AVAudioFormat *)sourceFormat {
    return _decoder.sourceFormat;
}

- (BOOL)decodingIsLossless {
    return _decoder.decodingIsLossless;
}

- (NSDictionary *)properties {
    return _decoder.properties;
}

- (BOOL)openReturningError:(NSError **)error {
    if (!_decoder.isOpen && ![_decoder openReturningError:error]) {
        return NO;
    }

    const AudioStreamBasicDescription *asbd = _decoder.processingFormat.streamDescription;

    if (asbd->mFormatID != kSFBAudioFormatDSD) {
        if (error) {
            NSMutableDictionary *userInfo = [NSMutableDictionary
                    dictionaryWithObject:NSLocalizedString(@"DSD over PCM requires DSD audio input.", @"")
                                  forKey:NSLocalizedRecoverySuggestionErrorKey];

            if (_decoder.inputSource.url != nil) {
                userInfo[NSLocalizedDescriptionKey] =
                        [NSString localizedStringWithFormat:NSLocalizedString(@"The file “%@” is not a DSD file.", @""),
                                                            SFBLocalizedNameForURL(_decoder.inputSource.url)];
                userInfo[NSURLErrorKey] = _decoder.inputSource.url;
            } else {
                userInfo[NSLocalizedDescriptionKey] = NSLocalizedString(@"The file is not a DSD file.", @"");
            }

            *error = [NSError errorWithDomain:SFBAudioDecoderErrorDomain
                                         code:SFBAudioDecoderErrorCodeInvalidFormat
                                     userInfo:userInfo];
        }
        return NO;
    }

    if (!IsSupportedDoPSampleRate(asbd->mSampleRate)) {
        os_log_error(gSFBAudioDecoderLog, "Unsupported DSD sample rate for DoP: %g", asbd->mSampleRate);
        if (error) {
            NSMutableDictionary *userInfo = [NSMutableDictionary
                    dictionaryWithObject:NSLocalizedString(@"The sample rate is not supported for DSD over PCM.", @"")
                                  forKey:NSLocalizedRecoverySuggestionErrorKey];

            if (_decoder.inputSource.url != nil) {
                userInfo[NSLocalizedDescriptionKey] = [NSString
                        localizedStringWithFormat:NSLocalizedString(@"The format of the file “%@” is not supported.",
                                                                    @""),
                                                  SFBLocalizedNameForURL(_decoder.inputSource.url)];
                userInfo[NSURLErrorKey] = _decoder.inputSource.url;
            } else {
                userInfo[NSLocalizedDescriptionKey] =
                        NSLocalizedString(@"The format of the file is not supported.", @"");
            }

            *error = [NSError errorWithDomain:SFBAudioDecoderErrorDomain
                                         code:SFBAudioDecoderErrorCodeInvalidFormat
                                     userInfo:userInfo];
        }
        return NO;
    }

    _reverseBits = (asbd->mFormatFlags & kAudioFormatFlagIsBigEndian) == 0;

    // Generate non-interleaved 24-bit big endian output
    AudioStreamBasicDescription processingStreamDescription = {0};

    processingStreamDescription.mFormatID = kAudioFormatLinearPCM /*kSFBAudioFormatDoP*/;
    processingStreamDescription.mFormatFlags = kAudioFormatFlagIsSignedInteger | kAudioFormatFlagIsPacked |
                                               kAudioFormatFlagIsNonInterleaved | kAudioFormatFlagIsBigEndian;

    processingStreamDescription.mSampleRate =
            asbd->mSampleRate / (kSFBPCMFramesPerDSDPacket * DSD_PACKETS_PER_DOP_FRAME);
    processingStreamDescription.mChannelsPerFrame = asbd->mChannelsPerFrame;
    processingStreamDescription.mBitsPerChannel = 24;

    processingStreamDescription.mBytesPerPacket = 3;
    processingStreamDescription.mFramesPerPacket = 1;
    processingStreamDescription.mBytesPerFrame =
            processingStreamDescription.mBytesPerPacket / processingStreamDescription.mFramesPerPacket;

    _processingFormat = [[AVAudioFormat alloc] initWithStreamDescription:&processingStreamDescription
                                                           channelLayout:_decoder.processingFormat.channelLayout];

    _buffer = [[AVAudioCompressedBuffer alloc]
               initWithFormat:_decoder.processingFormat
               packetCapacity:BUFFER_SIZE_PACKETS
            maximumPacketSize:(kSFBBytesPerDSDPacketPerChannel * _decoder.processingFormat.channelCount)];
    _buffer.packetCount = 0;

    return YES;
}

- (BOOL)closeReturningError:(NSError **)error {
    _buffer = nil;
    return [_decoder closeReturningError:error];
}

- (BOOL)isOpen {
    return _buffer != nil;
}

- (AVAudioFramePosition)framePosition {
    return _decoder.packetPosition / DSD_PACKETS_PER_DOP_FRAME;
}

- (AVAudioFramePosition)frameLength {
    return _decoder.packetCount / DSD_PACKETS_PER_DOP_FRAME;
}

- (BOOL)decodeIntoBuffer:(AVAudioBuffer *)buffer error:(NSError **)error {
    NSParameterAssert(buffer != nil);
    NSParameterAssert([buffer isKindOfClass:[AVAudioPCMBuffer class]]);
    return [self decodeIntoBuffer:(AVAudioPCMBuffer *)buffer
                      frameLength:((AVAudioPCMBuffer *)buffer).frameCapacity
                            error:error];
}

- (BOOL)decodeIntoBuffer:(AVAudioPCMBuffer *)buffer frameLength:(AVAudioFrameCount)frameLength error:(NSError **)error {
    NSParameterAssert(buffer != nil);
    NSParameterAssert([buffer.format isEqual:_processingFormat]);

    // Reset output buffer data size
    buffer.frameLength = 0;

    frameLength = MIN(frameLength, buffer.frameCapacity);
    if (frameLength == 0) {
        return YES;
    }

    AVAudioFrameCount framesRead = 0;

    for (;;) {
        AVAudioFrameCount framesRemaining = frameLength - framesRead;

        // Grab the DSD audio
        AVAudioPacketCount dsdPacketsRemaining = framesRemaining * DSD_PACKETS_PER_DOP_FRAME;
        if (![_decoder decodeIntoBuffer:_buffer
                            packetCount:MIN(_buffer.packetCapacity, dsdPacketsRemaining)
                                  error:error]) {
            return NO;
        }

        AVAudioPacketCount dsdPacketsDecoded = _buffer.packetCount;
        if (dsdPacketsDecoded == 0) {
            break;
        }

        // Convert to DoP
        // NB: Currently DSDIFFDecoder and DSFDecoder only produce interleaved output

        AVAudioFrameCount framesDecoded = dsdPacketsDecoded / DSD_PACKETS_PER_DOP_FRAME;

        unsigned char marker = _marker;
        AVAudioChannelCount channelCount = _processingFormat.channelCount;
        for (AVAudioChannelCount channel = 0; channel < channelCount; ++channel) {
            const unsigned char *input = (const unsigned char *)_buffer.data + channel;
            unsigned char *output = (unsigned char *)buffer.audioBufferList->mBuffers[channel].mData +
                                    buffer.audioBufferList->mBuffers[channel].mDataByteSize;

            // The DoP marker should match across channels
            marker = _marker;
            for (AVAudioFrameCount i = 0; i < framesDecoded; ++i) {
                // Insert the DoP marker
                *output++ = marker;

                // Copy the DSD bits
                *output++ = _reverseBits ? sBitReverseTable256[*input] : *input;
                input += channelCount;
                *output++ = _reverseBits ? sBitReverseTable256[*input] : *input;
                input += channelCount;

                marker = marker == 0x05 ? 0xfa : 0x05;
            }
        }

        _marker = marker;

        buffer.frameLength += framesDecoded;
        framesRead += framesDecoded;

        // All requested frames were read
        if (framesRead == frameLength) {
            break;
        }
    }

    return YES;
}

- (BOOL)supportsSeeking {
    return _decoder.supportsSeeking;
}

- (BOOL)seekToFrame:(AVAudioFramePosition)frame error:(NSError **)error {
    NSParameterAssert(frame >= 0);

    if (![_decoder seekToPacket:(frame * DSD_PACKETS_PER_DOP_FRAME) error:error]) {
        return NO;
    }

    _buffer.packetCount = 0;
    _buffer.byteLength = 0;

    return YES;
}

- (NSString *)description {
    return [NSString stringWithFormat:@"<%@ %p: %@>", [self class], (__bridge void *)self, _decoder];
}

@end