AudioConverter.cpp

/*
   AudioConverter.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 "AudioConverter.h"

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

struct OpaqueAudioConverter {
  AudioStreamBasicDescription source;
  AudioStreamBasicDescription destination;
};

static bool ATSamePCMFormat(const AudioStreamBasicDescription &a,
                            const AudioStreamBasicDescription &b)
{
  return a.mFormatID == kAudioFormatLinearPCM &&
         b.mFormatID == kAudioFormatLinearPCM &&
         a.mFormatFlags == b.mFormatFlags &&
         a.mBytesPerPacket == b.mBytesPerPacket &&
         a.mFramesPerPacket == b.mFramesPerPacket &&
         a.mBytesPerFrame == b.mBytesPerFrame &&
         a.mChannelsPerFrame == b.mChannelsPerFrame &&
         a.mBitsPerChannel == b.mBitsPerChannel;
}

OSStatus AudioConverterNew(const AudioStreamBasicDescription *inSourceFormat,
                           const AudioStreamBasicDescription *inDestinationFormat,
                           AudioConverterRef *outAudioConverter)
{
  if (!inSourceFormat || !inDestinationFormat || !outAudioConverter)
    return kAudioToolboxErr_InvalidParameter;

  OpaqueAudioConverter *converter =
    (OpaqueAudioConverter *)calloc(1, sizeof(OpaqueAudioConverter));
  if (!converter)
    return kAudioToolboxErr_IOError;

  converter->source = *inSourceFormat;
  converter->destination = *inDestinationFormat;
  *outAudioConverter = converter;
  return noErr;
}

OSStatus AudioConverterDispose(AudioConverterRef inAudioConverter)
{
  if (!inAudioConverter)
    return kAudioToolboxErr_InvalidParameter;
  free(inAudioConverter);
  return noErr;
}

OSStatus AudioConverterConvertBuffer(AudioConverterRef inAudioConverter,
                                     UInt32 inInputDataSize,
                                     const void *inInputData,
                                     UInt32 *ioOutputDataSize,
                                     void *outOutputData)
{
  if (!inAudioConverter || !inInputData || !ioOutputDataSize || !outOutputData)
    return kAudioToolboxErr_InvalidParameter;
  if (!ATSamePCMFormat(inAudioConverter->source, inAudioConverter->destination))
    return kAudioToolboxErr_UnsupportedDataFormat;
  if (*ioOutputDataSize < inInputDataSize)
    return kAudioToolboxErr_InvalidParameter;
  memcpy(outOutputData, inInputData, inInputDataSize);
  *ioOutputDataSize = inInputDataSize;
  return noErr;
}

OSStatus AudioConverterGetProperty(AudioConverterRef,
                                   UInt32,
                                   UInt32 *,
                                   void *)
{
  return kAudioToolboxErr_Unimplemented;
}

OSStatus AudioConverterSetProperty(AudioConverterRef,
                                   UInt32,
                                   UInt32,
                                   const void *)
{
  return kAudioToolboxErr_Unimplemented;
}