AudioFile.cpp

/*
   AudioFile.cpp

   Copyright (C) 2026 Free Software Foundation, Inc.

   Author: Gregory John Casamento <greg.casamento@gmail.com>
   Date: August 2026

   This file is part of the GNUstep AudioToolbox Library.

   This library is free software; you can redistribute it and/or
   modify it under the terms of the GNU Lesser General Public
   License as published by the Free Software Foundation; either
   version 2.1 of the License, or (at your option) any later version.

   This library is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   Lesser General Public License for more details.

   You should have received a copy of the GNU Lesser General Public
   License along with this library; see the file COPYING.LIB.
   If not, see <http://www.gnu.org/licenses/> or write to the
   Free Software Foundation, 51 Franklin Street, Fifth Floor,
   Boston, MA 02110-1301, USA.
*/

#include "AudioFile.h"

#include <stdlib.h>
#include <string.h>

struct OpaqueAudioFileID {
  void *clientData;
  AudioFile_ReadProc readProc;
  AudioFile_WriteProc writeProc;
  AudioFile_GetSizeProc getSizeProc;
  AudioFile_SetSizeProc setSizeProc;
  AudioFileTypeID fileType;
  AudioStreamBasicDescription dataFormat;
};

static UInt32 ATBytesPerPacket(AudioFileID file)
{
  if (!file || file->dataFormat.mBytesPerPacket == 0)
    return 1;
  return file->dataFormat.mBytesPerPacket;
}

OSStatus AudioFileOpenWithCallbacks(void *inClientData,
                                    AudioFile_ReadProc inReadFunc,
                                    AudioFile_WriteProc inWriteFunc,
                                    AudioFile_GetSizeProc inGetSizeFunc,
                                    AudioFile_SetSizeProc inSetSizeFunc,
                                    AudioFileTypeID inFileTypeHint,
                                    AudioFileID *outAudioFile)
{
  if (!outAudioFile || !inReadFunc)
    return kAudioToolboxErr_InvalidParameter;

  OpaqueAudioFileID *file = (OpaqueAudioFileID *)calloc(1, sizeof(OpaqueAudioFileID));
  if (!file)
    return kAudioToolboxErr_IOError;

  file->clientData = inClientData;
  file->readProc = inReadFunc;
  file->writeProc = inWriteFunc;
  file->getSizeProc = inGetSizeFunc;
  file->setSizeProc = inSetSizeFunc;
  file->fileType = inFileTypeHint;
  file->dataFormat.mFormatID = kAudioFormatLinearPCM;
  file->dataFormat.mFramesPerPacket = 1;
  file->dataFormat.mBytesPerPacket = 1;
  file->dataFormat.mBytesPerFrame = 1;
  *outAudioFile = file;
  return noErr;
}

OSStatus AudioFileInitializeWithCallbacks(void *inClientData,
                                          AudioFile_ReadProc inReadFunc,
                                          AudioFile_WriteProc inWriteFunc,
                                          AudioFile_GetSizeProc inGetSizeFunc,
                                          AudioFile_SetSizeProc inSetSizeFunc,
                                          AudioFileTypeID inFileType,
                                          const AudioStreamBasicDescription *inFormat,
                                          UInt32,
                                          AudioFileID *outAudioFile)
{
  if (!outAudioFile || !inWriteFunc || !inFormat)
    return kAudioToolboxErr_InvalidParameter;

  OSStatus err = AudioFileOpenWithCallbacks(inClientData, inReadFunc,
                                            inWriteFunc, inGetSizeFunc,
                                            inSetSizeFunc, inFileType,
                                            outAudioFile);
  if (err != noErr)
    return err;
  (*outAudioFile)->dataFormat = *inFormat;
  if (inSetSizeFunc)
    return inSetSizeFunc(inClientData, 0);
  return noErr;
}

OSStatus AudioFileOpenURL(CFURLRef, AudioFilePermissions, AudioFileTypeID, AudioFileID *outAudioFile)
{
  if (outAudioFile)
    *outAudioFile = NULL;
  return kAudioToolboxErr_Unimplemented;
}

OSStatus AudioFileCreateWithURL(CFURLRef, AudioFileTypeID,
                                const AudioStreamBasicDescription *,
                                UInt32, AudioFileID *outAudioFile)
{
  if (outAudioFile)
    *outAudioFile = NULL;
  return kAudioToolboxErr_Unimplemented;
}

OSStatus AudioFileClose(AudioFileID inAudioFile)
{
  if (!inAudioFile)
    return kAudioToolboxErr_InvalidParameter;
  free(inAudioFile);
  return noErr;
}

OSStatus AudioFileOptimize(AudioFileID inAudioFile)
{
  return inAudioFile ? noErr : kAudioToolboxErr_InvalidParameter;
}

OSStatus AudioFileReadBytes(AudioFileID inAudioFile, Boolean,
                            SInt64 inStartingByte, UInt32 *ioNumBytes,
                            void *outBuffer)
{
  if (!inAudioFile || !inAudioFile->readProc || !ioNumBytes || !outBuffer || inStartingByte < 0)
    return kAudioToolboxErr_InvalidParameter;
  return inAudioFile->readProc(inAudioFile->clientData, inStartingByte,
                               *ioNumBytes, outBuffer, ioNumBytes);
}

OSStatus AudioFileWriteBytes(AudioFileID inAudioFile, Boolean,
                             SInt64 inStartingByte, UInt32 *ioNumBytes,
                             const void *inBuffer)
{
  if (!inAudioFile || !inAudioFile->writeProc || !ioNumBytes || !inBuffer || inStartingByte < 0)
    return kAudioToolboxErr_InvalidParameter;
  return inAudioFile->writeProc(inAudioFile->clientData, inStartingByte,
                                *ioNumBytes, inBuffer, ioNumBytes);
}

OSStatus AudioFileReadPacketData(AudioFileID inAudioFile, Boolean inUseCache,
                                 UInt32 *ioNumBytes,
                                 AudioStreamPacketDescription *,
                                 SInt64 inStartingPacket,
                                 UInt32 *ioNumPackets,
                                 void *outBuffer)
{
  if (!inAudioFile || !ioNumBytes || !ioNumPackets)
    return kAudioToolboxErr_InvalidParameter;
  UInt32 bytesPerPacket = ATBytesPerPacket(inAudioFile);
  UInt32 requestedBytes = (*ioNumPackets) * bytesPerPacket;
  if (*ioNumBytes < requestedBytes)
    requestedBytes = *ioNumBytes;
  OSStatus err = AudioFileReadBytes(inAudioFile, inUseCache,
                                    inStartingPacket * bytesPerPacket,
                                    &requestedBytes, outBuffer);
  *ioNumBytes = requestedBytes;
  *ioNumPackets = requestedBytes / bytesPerPacket;
  return err;
}

OSStatus AudioFileWritePackets(AudioFileID inAudioFile, Boolean inUseCache,
                               UInt32 inNumBytes,
                               const AudioStreamPacketDescription *,
                               SInt64 inStartingPacket,
                               UInt32 *ioNumPackets,
                               const void *inBuffer)
{
  if (!inAudioFile || !ioNumPackets)
    return kAudioToolboxErr_InvalidParameter;
  UInt32 bytesPerPacket = ATBytesPerPacket(inAudioFile);
  UInt32 byteCount = inNumBytes ? inNumBytes : (*ioNumPackets) * bytesPerPacket;
  OSStatus err = AudioFileWriteBytes(inAudioFile, inUseCache,
                                     inStartingPacket * bytesPerPacket,
                                     &byteCount, inBuffer);
  *ioNumPackets = byteCount / bytesPerPacket;
  return err;
}

OSStatus AudioFileGetPropertyInfo(AudioFileID inAudioFile,
                                  UInt32 inPropertyID,
                                  UInt32 *outDataSize,
                                  UInt32 *isWritable)
{
  if (!inAudioFile || !outDataSize)
    return kAudioToolboxErr_InvalidParameter;
  if (isWritable)
    *isWritable = (inPropertyID == kAudioFilePropertyDataFormat);
  switch (inPropertyID) {
    case kAudioFilePropertyFileFormat:
      *outDataSize = sizeof(AudioFileTypeID);
      return noErr;
    case kAudioFilePropertyDataFormat:
      *outDataSize = sizeof(AudioStreamBasicDescription);
      return noErr;
    case kAudioFilePropertyAudioDataByteCount:
    case kAudioFilePropertyAudioDataPacketCount:
      *outDataSize = sizeof(UInt64);
      return noErr;
    default:
      return kAudioToolboxErr_Unimplemented;
  }
}

OSStatus AudioFileGetProperty(AudioFileID inAudioFile,
                              UInt32 inPropertyID,
                              UInt32 *ioDataSize,
                              void *outPropertyData)
{
  if (!inAudioFile || !ioDataSize || !outPropertyData)
    return kAudioToolboxErr_InvalidParameter;

  switch (inPropertyID) {
    case kAudioFilePropertyFileFormat:
      if (*ioDataSize < sizeof(AudioFileTypeID))
        return kAudioToolboxErr_InvalidParameter;
      *(AudioFileTypeID *)outPropertyData = inAudioFile->fileType;
      *ioDataSize = sizeof(AudioFileTypeID);
      return noErr;

    case kAudioFilePropertyDataFormat:
      if (*ioDataSize < sizeof(AudioStreamBasicDescription))
        return kAudioToolboxErr_InvalidParameter;
      *(AudioStreamBasicDescription *)outPropertyData = inAudioFile->dataFormat;
      *ioDataSize = sizeof(AudioStreamBasicDescription);
      return noErr;

    case kAudioFilePropertyAudioDataByteCount: {
      if (*ioDataSize < sizeof(UInt64) || !inAudioFile->getSizeProc)
        return kAudioToolboxErr_InvalidParameter;
      SInt64 size = inAudioFile->getSizeProc(inAudioFile->clientData);
      *(UInt64 *)outPropertyData = size < 0 ? 0 : (UInt64)size;
      *ioDataSize = sizeof(UInt64);
      return noErr;
    }

    case kAudioFilePropertyAudioDataPacketCount: {
      if (*ioDataSize < sizeof(UInt64) || !inAudioFile->getSizeProc)
        return kAudioToolboxErr_InvalidParameter;
      SInt64 size = inAudioFile->getSizeProc(inAudioFile->clientData);
      *(UInt64 *)outPropertyData = size < 0 ? 0 : (UInt64)size / ATBytesPerPacket(inAudioFile);
      *ioDataSize = sizeof(UInt64);
      return noErr;
    }

    default:
      return kAudioToolboxErr_Unimplemented;
  }
}

OSStatus AudioFileSetProperty(AudioFileID inAudioFile,
                              UInt32 inPropertyID,
                              UInt32 inDataSize,
                              const void *inPropertyData)
{
  if (!inAudioFile || !inPropertyData)
    return kAudioToolboxErr_InvalidParameter;
  if (inPropertyID == kAudioFilePropertyDataFormat) {
    if (inDataSize != sizeof(AudioStreamBasicDescription))
      return kAudioToolboxErr_InvalidParameter;
    inAudioFile->dataFormat = *(const AudioStreamBasicDescription *)inPropertyData;
    return noErr;
  }
  return kAudioToolboxErr_Unimplemented;
}