The Audio analyzer demo showcases how to use SciChart iOS charts in a scientific context.

Download the examples and enable your microphone to see this demo at work.

In this example we listen to the microphone on your iPad/iPhone device and create a waveform of the sound recorded in the top chart. This chart has data-points drawn in real-time on our High Performance charts. The example application then performs a Fourier Transform, creating a spectral / frequency analysis of the audio waveform and plots in the lower left chart. Finally, the histogram of the fourier transform, known as a spectrogram, is plotted in a SciChart iOS Heatmap control in the bottom right of the example.

If you are creating an app that needs to visualize scientific data from data-acquisition devices, audio spectra, or visualize radio frequency or spectral analysis choose SciChart to shortcut your development time & get to market faster with our well-tested, reliable iOS Chart library.

// AudioAnalyzerChartView.swift

//******************************************************************************
// SCICHART® Copyright SciChart Ltd. 2011-2020. All rights reserved.
//
// Web: http://www.scichart.com
// Support: support@scichart.com
// Sales:   sales@scichart.com
//
// AudioAnalyzerChartView.swift is part of the SCICHART® Examples. Permission is hereby granted
// to modify, create derivative works, distribute and publish any part of this source
// code whether for commercial, private or personal use.
//
// The SCICHART® examples are distributed in the hope that they will be useful, but
// without any warranty. It is provided "AS IS" without warranty of any kind, either
// expressed or implied.
//******************************************************************************

import Foundation
import RxSwift

class AudioAnalyzerChartView: SCDAudioAnalyzerLayout {
    
    private let AUDIO_STREAM_BUFFER_SIZE: Int = 500000
    private let MAX_FREQUENCY: Int = 10000
    private let minDB: Double = -30
    private let maxDB: Double = 70
    
    private var bufferSize: Int {
        return dataProvider.bufferSize
    }
    
    private var sampleRate: Int {
        return dataProvider.sampleRate
    }
    
    private var hzPerDataPoint: Int {
        return sampleRate / bufferSize
    }
    
    private var fftCount: Int {
        return AUDIO_STREAM_BUFFER_SIZE / bufferSize
    }
    
    private var fftSize: Int {
        return MAX_FREQUENCY / hzPerDataPoint
    }
    
    private var fftValuesCount: Int {
        return fftSize * fftCount
    }
    
    private var dataProvider: IAudioAnalyzerDataProvider!
    private var audioDS: SCIXyDataSeries!
    private var fftDS: SCIXyDataSeries!
    private var spectrogramDS: SCIUniformHeatmapDataSeries!
    private var spectogramValues: SCDSpectogramItems!
    private var disposable: Disposable?
        
    deinit {
        disposable?.dispose()
    }
    
    override func initExample() {
        AVAudioSession.sharedInstance().requestRecordPermission { [weak self] granted in
            guard let self = self else { return }
            
            if granted {
                self.dataProvider = DefaultAudioAnalyzerDataProvider()
            } else {
                self.dataProvider = StubAudioAnalyzerDataProvider()
            }
            DispatchQueue.main.async {
                self.proceedWithInit()
            }
        }
    }
    
    private func proceedWithInit() {
        audioDS = SCIXyDataSeries(xType: .long, yType: .int)
        fftDS = SCIXyDataSeries(xType: .double, yType: .float)
        spectrogramDS = SCIUniformHeatmapDataSeries(xType: .long, yType: .long, zType: .float, xSize: fftSize, ySize: fftCount)
        
        initAudioStreamChart()
        initFFTChart()
        initSpectrogramChart()
            
        disposable = dataProvider
            .getData()
            .do(onNext: { [weak self] audioData in
                guard let self = self else { return }
                
                self.audioDS.append(x: audioData.xData, y: audioData.yData)
                
                let fftData = audioData.fftData
                fftData.count = self.fftSize
                self.fftDS.update(y: fftData, at: 0)
                
                self.spectogramValues.replace(withNewItems: fftData)
                self.spectrogramDS.update(z: self.spectogramValues.values)
            })
            .subscribe()
    }
    
    private func initAudioStreamChart() {
        let xAxis = SCINumericAxis()
        xAxis.autoRange = .always
        xAxis.drawLabels = false
        xAxis.drawMinorTicks = false
        xAxis.drawMajorTicks = false
        xAxis.drawMajorBands = false
        xAxis.drawMinorGridLines = false
        xAxis.drawMajorGridLines = false
        
        let yAxis = SCINumericAxis()
        yAxis.visibleRange = SCIDoubleRange(min: Double(Int32.min), max: Double(Int32.max))
        yAxis.drawLabels = false
        yAxis.drawMinorTicks = false
        yAxis.drawMajorTicks = false
        yAxis.drawMajorBands = false
        yAxis.drawMinorGridLines = false
        yAxis.drawMajorGridLines = false
        
        audioDS.fifoCapacity = AUDIO_STREAM_BUFFER_SIZE
        
        let rs = SCIFastLineRenderableSeries()
        rs.dataSeries = audioDS
        rs.strokeStyle = SCISolidPenStyle(color: .gray, thickness: 1.0)
        
        SCIUpdateSuspender.usingWith(audioStreamChart) {
            self.audioStreamChart.xAxes.add(items: xAxis)
            self.audioStreamChart.yAxes.add(items: yAxis)
            self.audioStreamChart.renderableSeries.add(items: rs)
        }
    }
    
    private func initFFTChart() {
        let xAxis = SCINumericAxis()
        xAxis.drawMajorBands = false
        xAxis.drawMinorGridLines = false
        xAxis.maxAutoTicks = 5
        xAxis.axisTitle = "Hz"
        xAxis.axisTitlePlacement = .right
        xAxis.axisTitleOrientation = .horizontal
        
        let yAxis = SCINumericAxis()
        yAxis.axisAlignment = .left
        yAxis.visibleRange = SCIDoubleRange(min: minDB, max: maxDB)
        yAxis.growBy = SCIDoubleRange(min: 0.1, max: 0.1)
        yAxis.drawMinorTicks = false
        yAxis.drawMinorGridLines = false
        yAxis.drawMajorBands = false
        yAxis.axisTitle = "dB"
        yAxis.axisTitlePlacement = .top
        yAxis.axisTitleOrientation = .horizontal
        
        fftDS.fifoCapacity = fftSize
        for i in 0 ..< fftSize {
            fftDS.append(x: i * Int(hzPerDataPoint), y: Float.nan)
        }
        
        let rs = SCIFastColumnRenderableSeries()
        rs.dataSeries = fftDS
        rs.zeroLineY = minDB
        rs.paletteProvider = FFTPaletteProvider()
        
        SCIUpdateSuspender.usingWith(fftChart) {
            self.fftChart.xAxes.add(items: xAxis)
            self.fftChart.yAxes.add(items: yAxis)
            self.fftChart.renderableSeries.add(rs)
        }
    }
    
    private func initSpectrogramChart() {
        
        spectogramValues = SCDSpectogramItems(capacity: fftValuesCount)
        
        let xAxis = SCINumericAxis()
        xAxis.autoRange = .always
        xAxis.drawLabels = false
        xAxis.drawMinorTicks = false
        xAxis.drawMajorTicks = false
        xAxis.drawMajorBands = false
        xAxis.drawMinorGridLines = false
        xAxis.drawMajorGridLines = false
        xAxis.axisAlignment = .left
        xAxis.flipCoordinates = true
        
        let yAxis = SCINumericAxis()
        yAxis.autoRange = .always
        yAxis.drawLabels = false
        yAxis.drawMinorTicks = false
        yAxis.drawMajorTicks = false
        yAxis.drawMajorBands = false
        yAxis.drawMinorGridLines = false
        yAxis.drawMajorGridLines = false
        yAxis.axisAlignment = .bottom
        
        let rs = SCIFastUniformHeatmapRenderableSeries()
        rs.dataSeries = spectrogramDS
        rs.minimum = minDB
        rs.maximum = maxDB
        
        rs.colorMap = SCIColorMap(colors: [.clear, UIColor.fromARGBColorCode(0xFF00008B), .purple, .red, .yellow, .white], andStops: [0, 0.0001, 0.25, 0.50, 0.75, 1])
        
        SCIUpdateSuspender.usingWith(spectrogramChart) {
            self.spectrogramChart.xAxes.add(xAxis)
            self.spectrogramChart.yAxes.add(yAxis)
            self.spectrogramChart.renderableSeries.add(rs)
        }
    }
}

// AudioRecorder.m

//******************************************************************************
// SCICHART® Copyright SciChart Ltd. 2011-2020. All rights reserved.
//
// Web: http://www.scichart.com
// Support: support@scichart.com
// Sales:   sales@scichart.com
//
// AudioRecorder.m is part of the SCICHART® Examples. Permission is hereby granted
// to modify, create derivative works, distribute and publish any part of this source
// code whether for commercial, private or personal use.
//
// The SCICHART® examples are distributed in the hope that they will be useful, but
// without any warranty. It is provided "AS IS" without warranty of any kind, either
// expressed or implied.
//******************************************************************************

#import "AudioRecorder.h"
#import <Accelerate/Accelerate.h>

#define AUDIO_DATA_TYPE_FORMAT int

@implementation AudioRecorder {
    FFTSetup fftSetup;
    unsigned int length;
    float _max;
    float _min;
}

void *refToSelf;

void AudioInputCallback(void *inUserData,
                        AudioQueueRef inAQ,
                        AudioQueueBufferRef inBuffer,
                        const AudioTimeStamp *inStartTime,
                        unsigned int inNumberPacketDescriptions,
                        const AudioStreamPacketDescription *inPacketDescs) {
    __weak AudioRecorder *rec = (__bridge AudioRecorder *)refToSelf;
    RecordState *recordState = (RecordState *)inUserData;
    
    if (!recordState->recording) return;
    
    AudioQueueEnqueueBuffer(recordState->queue, inBuffer, 0, NULL);
    
    int *samples = (AUDIO_DATA_TYPE_FORMAT *)inBuffer->mAudioData;
    if (inNumberPacketDescriptions != 2048) return;
    
    [rec formSamplesToEngine:inNumberPacketDescriptions samples:samples];
}

- (instancetype)init {
    self = [super init];
    if (self) {
        refToSelf = (__bridge void *)(self);
        _max = 0.0f;
        _min = 0.0f;
    }
    return self;
}

- (void)startRecording:(int)sampleRate andMinBufferSize:(int)minBufferSize {
    [self setupAudioFormat:&recordState.dataFormat withSampleRate:sampleRate];
    recordState.currentPacket = 0;
    
    OSStatus status = AudioQueueNewInput(&recordState.dataFormat, AudioInputCallback, &recordState, CFRunLoopGetCurrent(), kCFRunLoopCommonModes, 0, &recordState.queue);
    if (status == 0) {
        for (int i = 0; i < NUM_BUFFERS; i++) {
            AudioQueueAllocateBuffer(recordState.queue, minBufferSize * recordState.dataFormat.mBytesPerFrame, &recordState.buffers[i]);
            AudioQueueEnqueueBuffer(recordState.queue, recordState.buffers[i], 0, nil);
        }
    }
    
    recordState.recording = true;
    status = AudioQueueStart(recordState.queue, NULL);
    length = (unsigned int)floor(log2(minBufferSize));
    fftSetup = vDSP_create_fftsetup(length, kFFTRadix2);
}

- (void)setupAudioFormat:(AudioStreamBasicDescription *)format withSampleRate:(int)sampleRate {
    format->mSampleRate       = sampleRate;
    format->mFormatID         = kAudioFormatLinearPCM;
    format->mFormatFlags      = kAudioFormatFlagIsSignedInteger;
    format->mFramesPerPacket  = 1;
    format->mChannelsPerFrame = 1;
    format->mBytesPerFrame    = sizeof(AUDIO_DATA_TYPE_FORMAT);
    format->mBytesPerPacket   = sizeof(AUDIO_DATA_TYPE_FORMAT);
    format->mBitsPerChannel   = sizeof(AUDIO_DATA_TYPE_FORMAT) * 8;
}

- (void)stopRecording {
    recordState.recording = false;
    
    vDSP_destroy_fftsetup(fftSetup);
    AudioQueueStop(recordState.queue, true);
    
    for (int i = 0; i < NUM_BUFFERS; i++) {
        AudioQueueFreeBuffer(recordState.queue, recordState.buffers[i]);
    }
    
    AudioQueueDispose(recordState.queue, true);
    AudioFileClose(recordState.audioFile);
}

- (void)formSamplesToEngine: (int)capacity samples: (int*)samples {
    self.samples = samples;
    self.fftData = [self calculateFFT:samples size:capacity];
}

- (float *)calculateFFT:(int *)data size:(unsigned int)numSamples {
    float *dataFloat = malloc(sizeof(float) * numSamples);
    vDSP_vflt32(data, 1, dataFloat, 1, numSamples);
    
    DSPSplitComplex tempSplitComplex;
    tempSplitComplex.imagp = malloc(sizeof(float) * numSamples);
    tempSplitComplex.realp = malloc(sizeof(float) * numSamples);
    
    DSPComplex *audioBufferComplex = malloc(sizeof(DSPComplex) * numSamples);
    
    for (int i = 0; i < numSamples; i++) {
        audioBufferComplex[i].real = dataFloat[i];
        audioBufferComplex[i].imag = 0.0f;
    }
    
    vDSP_ctoz(audioBufferComplex, 2, &tempSplitComplex, 1, numSamples);
    vDSP_fft_zip(fftSetup, &tempSplitComplex, 1, length, FFT_FORWARD);
    
    float *result = malloc(sizeof(float) * numSamples);
    for (int i = 0 ; i < numSamples; i++) {
        float current = sqrt(tempSplitComplex.realp[i] * tempSplitComplex.realp[i] + tempSplitComplex.imagp[i] * tempSplitComplex.imagp[i]) * 0.000025;
        current = log10(current) * 10;
        result[i] = current;
    }
    
    free(dataFloat);
    free(audioBufferComplex);
    free(tempSplitComplex.imagp);
    free(tempSplitComplex.realp);
    
    return result;
}

@end

// DefaultAudioAnalyzerDataProvider.swift

//******************************************************************************
// SCICHART® Copyright SciChart Ltd. 2011-2020. All rights reserved.
//
// Web: http://www.scichart.com
// Support: support@scichart.com
// Sales:   sales@scichart.com
//
// DefaultAudioAnalyzerDataProvider.swift is part of the SCICHART® Examples. Permission is hereby granted
// to modify, create derivative works, distribute and publish any part of this source
// code whether for commercial, private or personal use.
//
// The SCICHART® examples are distributed in the hope that they will be useful, but
// without any warranty. It is provided "AS IS" without warranty of any kind, either
// expressed or implied.
//******************************************************************************

import Foundation

struct AudioData {
    let pointsCount: Int
    let xData: SCILongValues
    let yData: SCIIntegerValues
    let fftData: SCIFloatValues
    
    init(pointsCount: Int) {
        self.pointsCount = pointsCount
        self.xData = SCILongValues(capacity: pointsCount)
        self.yData = SCIIntegerValues(capacity: pointsCount)
        self.fftData = SCIFloatValues(capacity: pointsCount)
    }
}

protocol IAudioAnalyzerDataProvider where Self: DataProviderBase<AudioData> {
    var bufferSize: Int { get }
    var sampleRate: Int { get }
}

class DefaultAudioAnalyzerDataProvider: DataProviderBase<AudioData>, IAudioAnalyzerDataProvider {
    
    let bufferSize: Int
    let sampleRate: Int
    private var time = 0
    
    private lazy var audioData: AudioData = {
        return AudioData(pointsCount: bufferSize)
    }()
        
    private let audioRecorder: AudioRecorder = AudioRecorder()
    
    var samplesValues: samplesToEngine!
    var fftValues: samplesToEngineFloat!
    
    convenience init() {
        self.init(sampleRate: 44100, minBufferSize: 2048)
    }
    
    init(sampleRate: Int, minBufferSize: Int) {
        self.sampleRate = sampleRate
        self.bufferSize = minBufferSize

        super.init(dispatchTimeInterval: .milliseconds(sampleRate / minBufferSize))
    }
    
    override func onStart() {
        audioRecorder.startRecording(Int32(sampleRate), andMinBufferSize: Int32(bufferSize))
    }
    
    override func onStop() {
        audioRecorder.stopRecording()
    }
    
    override func onNext() -> AudioData {
        audioData.xData.clear()
        audioData.yData.clear()
        audioData.fftData.clear()
        
        if let samples = audioRecorder.samples {
            let sampleValues = Array(UnsafeBufferPointer(start: samples, count: bufferSize)).map { Int($0) }
            if !sampleValues.isEmpty {
                for _ in 0 ..< bufferSize {
                    time += 1
                    audioData.xData.add(Int64(time))
                }
                audioData.yData.add(values: sampleValues)
            }
        }
        
        if let fftData = audioRecorder.fftData {
            let fftValues = Array(UnsafeBufferPointer(start: fftData, count: bufferSize))
            audioData.fftData.add(values: fftValues)
        }
        return audioData
    }
}

// FFTPaletteProvider.swift

//******************************************************************************
// SCICHART® Copyright SciChart Ltd. 2011-2020. All rights reserved.
//
// Web: http://www.scichart.com
// Support: support@scichart.com
// Sales:   sales@scichart.com
//
// FFTPaletteProvider.swift is part of the SCICHART® Examples. Permission is hereby granted
// to modify, create derivative works, distribute and publish any part of this source
// code whether for commercial, private or personal use.
//
// The SCICHART® examples are distributed in the hope that they will be useful, but
// without any warranty. It is provided "AS IS" without warranty of any kind, either
// expressed or implied.
//******************************************************************************

import Foundation

class FFTPaletteProvider: SCIPaletteProviderBase<SCIFastColumnRenderableSeries>, ISCIFillPaletteProvider, ISCIStrokePaletteProvider {
    
    private struct Colors {
        static let minColor: UInt32 = 0xFF008000
        static let maxColor: UInt32 = 0xFFFF0000
        
        // RGB chanel values for min color
        static let minColorRed = UIColor.red(minColor)
        static let minColorGreen = UIColor.green(minColor)
        static let minColorBlue = UIColor.blue(minColor)
        
        // RGB chanel values for max color
        static let maxColorRed = UIColor.red(maxColor)
        static let maxColorGreen = UIColor.green(maxColor)
        static let maxColorBlue = UIColor.blue(maxColor)

        static let diffRed = Int(maxColorRed) - Int(minColorRed)
        static let diffGreen = Int(maxColorGreen) - Int(minColorGreen)
        static let diffBlue = Int(maxColorBlue) - Int(minColorBlue)
    }
    
    private let colors = SCIUnsignedIntegerValues()
    var fillColors: SCIUnsignedIntegerValues! { return colors }
    var strokeColors: SCIUnsignedIntegerValues! { return colors }
    
    init() {
        super.init(renderableSeriesType: SCIFastColumnRenderableSeries.self)
    }
    
    override func update() {
        let xyRenderPassData = renderableSeries!.currentRenderPassData as! SCIXyRenderPassData
        let yCalc = xyRenderPassData.yCoordinateCalculator!
        let min: Double = 0
        let max: Double = yCalc.maxAsDouble
        let diff = max - min
        
        let yValues = xyRenderPassData.yValues
        let size = xyRenderPassData.pointsCount
        colors.count = size
        
        for i in 0 ..< size {
            let yValue = yValues!.getValueAt(i)
            let fraction = (yValue - min) / diff
            
            let red = lerp(Colors.minColorRed, Colors.diffRed, fraction)
            let green = lerp(Colors.minColorGreen, Colors.diffGreen, fraction)
            let blue = lerp(Colors.minColorBlue, Colors.diffBlue, fraction)
            
            let color = UIColor(red: red, green: green, blue: blue, alpha: 1)
            colors.set(color.colorARGBCode(), at: i)
        }
    }
    
    private func lerp(_ minColor: UInt8, _ diffColor: Int, _ fraction: Double) -> CGFloat {
        let interpolatedValue = Double(minColor) + fraction * Double(diffColor)
        return interpolatedValue < 0 ? 0 : interpolatedValue > 255 ? 1 : CGFloat(interpolatedValue / 255)
    }
}

// SCDAudioAnalyzerLayout.m

//******************************************************************************
// SCICHART® Copyright SciChart Ltd. 2011-2020. All rights reserved.
//
// Web: http://www.scichart.com
// Support: support@scichart.com
// Sales:   sales@scichart.com
//
// SCDAudioAnalyzerLayout.m is part of the SCICHART® Examples. Permission is hereby granted
// to modify, create derivative works, distribute and publish any part of this source
// code whether for commercial, private or personal use.
//
// The SCICHART® examples are distributed in the hope that they will be useful, but
// without any warranty. It is provided "AS IS" without warranty of any kind, either
// expressed or implied.
//******************************************************************************

#import "SCDAudioAnalyzerLayout.h"

@implementation SCDAudioAnalyzerLayout

- (Class)exampleViewType {
    return SCDAudioAnalyzerLayout.class;
}

@end

// SCDAudioAnalyzerLayout.xib

<?xml version="1.0" encoding="UTF-8"?>
<document type="com.apple.InterfaceBuilder3.CocoaTouch.XIB" version="3.0" toolsVersion="16096" targetRuntime="iOS.CocoaTouch" propertyAccessControl="none" useAutolayout="YES" useTraitCollections="YES" useSafeAreas="YES" colorMatched="YES">
    <device id="retina6_1" orientation="portrait" appearance="light"/>
    <dependencies>
        <deployment identifier="iOS"/>
        <plugIn identifier="com.apple.InterfaceBuilder.IBCocoaTouchPlugin" version="16086"/>
        <capability name="Safe area layout guides" minToolsVersion="9.0"/>
        <capability name="documents saved in the Xcode 8 format" minToolsVersion="8.0"/>
    </dependencies>
    <objects>
        <placeholder placeholderIdentifier="IBFilesOwner" id="-1" userLabel="File's Owner" customClass="SCDAudioAnalyzerLayout">
            <connections>
                <outlet property="audioStreamChart" destination="1bB-9j-w8w" id="j42-IQ-ffk"/>
                <outlet property="fftChart" destination="ZiO-xQ-akr" id="zjz-02-l4A"/>
                <outlet property="spectrogramChart" destination="S0T-ku-XoS" id="2Dz-nv-MUY"/>
            </connections>
        </placeholder>
        <placeholder placeholderIdentifier="IBFirstResponder" id="-2" customClass="UIResponder"/>
        <view contentMode="scaleToFill" id="iN0-l3-epB">
            <rect key="frame" x="0.0" y="0.0" width="414" height="896"/>
            <autoresizingMask key="autoresizingMask" widthSizable="YES" heightSizable="YES"/>
            <subviews>
                <view contentMode="scaleToFill" insetsLayoutMarginsFromSafeArea="NO" translatesAutoresizingMaskIntoConstraints="NO" id="1bB-9j-w8w" userLabel="audioStreamChart" customClass="SCIChartSurface">
                    <rect key="frame" x="0.0" y="44" width="414" height="313.5"/>
                    <color key="backgroundColor" white="1" alpha="1" colorSpace="calibratedWhite"/>
                </view>
                <stackView opaque="NO" contentMode="scaleToFill" distribution="fillEqually" translatesAutoresizingMaskIntoConstraints="NO" id="1Ms-Rg-xT1">
                    <rect key="frame" x="0.0" y="357.5" width="414" height="504.5"/>
                    <subviews>
                        <view contentMode="scaleToFill" insetsLayoutMarginsFromSafeArea="NO" translatesAutoresizingMaskIntoConstraints="NO" id="ZiO-xQ-akr" userLabel="fftChart" customClass="SCIChartSurface">
                            <rect key="frame" x="0.0" y="0.0" width="207" height="504.5"/>
                            <color key="backgroundColor" white="1" alpha="1" colorSpace="calibratedWhite"/>
                        </view>
                        <view contentMode="scaleToFill" insetsLayoutMarginsFromSafeArea="NO" translatesAutoresizingMaskIntoConstraints="NO" id="S0T-ku-XoS" userLabel="spectrogramChart" customClass="SCIChartSurface">
                            <rect key="frame" x="207" y="0.0" width="207" height="504.5"/>
                            <color key="backgroundColor" white="1" alpha="1" colorSpace="calibratedWhite"/>
                        </view>
                    </subviews>
                </stackView>
            </subviews>
            <color key="backgroundColor" red="0.10980392156862745" green="0.10980392156862745" blue="0.10980392156862745" alpha="1" colorSpace="custom" customColorSpace="sRGB"/>
            <constraints>
                <constraint firstItem="1bB-9j-w8w" firstAttribute="height" secondItem="iN0-l3-epB" secondAttribute="height" multiplier="0.35" id="1Z9-Gq-W8X"/>
                <constraint firstItem="1bB-9j-w8w" firstAttribute="leading" secondItem="iN0-l3-epB" secondAttribute="leading" id="65m-S2-Z2a"/>
                <constraint firstItem="1Ms-Rg-xT1" firstAttribute="leading" secondItem="iN0-l3-epB" secondAttribute="leading" id="OJU-S5-mLb"/>
                <constraint firstItem="1bB-9j-w8w" firstAttribute="trailing" secondItem="iN0-l3-epB" secondAttribute="trailing" id="Ow8-hv-1Zu"/>
                <constraint firstItem="vUN-kp-3ea" firstAttribute="bottom" secondItem="1Ms-Rg-xT1" secondAttribute="bottom" id="T5X-q2-PEe"/>
                <constraint firstItem="1Ms-Rg-xT1" firstAttribute="top" secondItem="1bB-9j-w8w" secondAttribute="bottom" id="dY9-qk-guC"/>
                <constraint firstItem="1Ms-Rg-xT1" firstAttribute="trailing" secondItem="iN0-l3-epB" secondAttribute="trailing" id="lfm-4T-x6w"/>
                <constraint firstItem="1bB-9j-w8w" firstAttribute="top" secondItem="vUN-kp-3ea" secondAttribute="top" id="rxP-3k-bT0"/>
            </constraints>
            <viewLayoutGuide key="safeArea" id="vUN-kp-3ea"/>
            <point key="canvasLocation" x="131.8840579710145" y="100.44642857142857"/>
        </view>
    </objects>
</document>

// SCDSpectogramItems.m

//******************************************************************************
// SCICHART® Copyright SciChart Ltd. 2011-2020. All rights reserved.
//
// Web: http://www.scichart.com
// Support: support@scichart.com
// Sales:   sales@scichart.com
//
// SCDSpectogramItems.m is part of the SCICHART® Examples. Permission is hereby granted
// to modify, create derivative works, distribute and publish any part of this source
// code whether for commercial, private or personal use.
//
// The SCICHART® examples are distributed in the hope that they will be useful, but
// without any warranty. It is provided "AS IS" without warranty of any kind, either
// expressed or implied.
//******************************************************************************

#import "SCDSpectogramItems.h"

@implementation SCDSpectogramItems

@synthesize values = _values;

- (instancetype)initWithCapacity:(NSInteger)capacity {
    self = [super init];
    if (self) {
        _values = [[SCIFloatValues alloc] initWithCapacity:capacity];
        
        for (NSInteger i = 0; i < capacity; i++) {
            [_values add:0];
        }
    }
    return self;
}

- (void)replaceWithNewItems:(SCIFloatValues *)newItems {
    float *newItemsArray = newItems.itemsArray;
    float *itemsArray = _values.itemsArray;
    long remainingCount = _values.count - newItems.count;
    
    memcpy(itemsArray, itemsArray + newItems.count, sizeof(float) * remainingCount);
    memcpy(itemsArray + remainingCount, newItemsArray, sizeof(float) * newItems.count);
}

- (SCIFloatValues *)values {
    return _values;
}

@end

// StubAudioAnalyzerDataProvider.swift

//******************************************************************************
// SCICHART® Copyright SciChart Ltd. 2011-2020. All rights reserved.
//
// Web: http://www.scichart.com
// Support: support@scichart.com
// Sales:   sales@scichart.com
//
// StubAudioAnalyzerDataProvider.swift is part of the SCICHART® Examples. Permission is hereby granted
// to modify, create derivative works, distribute and publish any part of this source
// code whether for commercial, private or personal use.
//
// The SCICHART® examples are distributed in the hope that they will be useful, but
// without any warranty. It is provided "AS IS" without warranty of any kind, either
// expressed or implied.
//******************************************************************************

import Foundation

class StubAudioAnalyzerDataProvider: DataProviderBase<AudioData>, IAudioAnalyzerDataProvider {
    
    let bufferSize: Int = 2048
    let sampleRate: Int = 44100
    private var time = 0
    
    init() {
        super.init(dispatchTimeInterval: .milliseconds(20))
    }
    
    private let audioRecorder: AudioRecorder = AudioRecorder()
    
    private lazy var audioData: AudioData = {
        return AudioData(pointsCount: bufferSize)
    }()
    
    private lazy var provider: IYValuesProvider = {
        let providers: [IYValuesProvider] = [
            FrequencySinewaveYValueProvider(amplitude: 8000, phase: 0, minFrequency: 0, maxFrequency: 1, step: 0.0000005),
            NoisySinewaveYValueProvider(amplitude: 8000, phase: 0, frequency: 0.000032, noiseAmplitude: 200),
            NoisySinewaveYValueProvider(amplitude: 6000, phase: 0, frequency: 0.000016, noiseAmplitude: 100),
            NoisySinewaveYValueProvider(amplitude: 4000, phase: 0, frequency: 0.000064, noiseAmplitude: 100)
        ]
        return AggregateYValueProvider(providers: providers)
    }()
    
    override func onNext() -> AudioData {
        audioData.xData.clear()
        audioData.yData.clear()
        audioData.fftData.clear()
        
        for _ in 0 ..< bufferSize {
            time += 1
            audioData.xData.add(Int64(time))
            audioData.yData.add(provider.getYValueForIndex(time))
        }
        
        audioData.fftData.add(values: calculateFFTData())
        return audioData
    }
    
    private func calculateFFTData() -> [Float] {
        let dataForFFT = audioData.yData.itemsArray.map { Int32($0) }
        let pointer: UnsafeMutablePointer<Int32> = UnsafeMutablePointer(mutating: dataForFFT)
        if let fftData = audioRecorder.calculateFFT(pointer, size: UInt32(bufferSize)) {
            return Array(UnsafeBufferPointer(start: fftData, count: bufferSize))
        }
        return []
    }
}

protocol IYValuesProvider {
    func getYValueForIndex(_ index: Int) -> Int32
}

class AggregateYValueProvider: IYValuesProvider {
    let providers: [IYValuesProvider]
    
    init(providers: [IYValuesProvider]) {
        self.providers = providers
    }
    
    func getYValueForIndex(_ index: Int) -> Int32 {
        var sum: Int32 = 0
        for provider in providers {
            sum += provider.getYValueForIndex(index) * 30000
        }
        return sum
    }
}

class FrequencySinewaveYValueProvider: IYValuesProvider {
    private let amplitude: Double
    private let phase: Double
    private let minFrequency: Double
    private let maxFrequency: Double
    private let step: Double
    
    private var frequency: Double
    
    init(amplitude: Double, phase: Double, minFrequency: Double, maxFrequency: Double, step: Double) {
        self.amplitude = amplitude
        self.phase = phase
        self.minFrequency = minFrequency
        self.maxFrequency = maxFrequency
        self.step = step
        
        self.frequency = minFrequency
    }
    
    func getYValueForIndex(_ index: Int) -> Int32 {
        frequency = frequency <= maxFrequency ? frequency + step : minFrequency
        let wn = 2 * Double.pi * frequency
        return Int32(amplitude * sin(Double(index) * wn + phase))
    }
}

class NoisySinewaveYValueProvider: IYValuesProvider {
    private let amplitude: Double
    private let phase: Double
    private let noiseAmplitude: Double
    private let wn: Double
    
    init(amplitude: Double, phase: Double, frequency: Double, noiseAmplitude: Double) {
        self.amplitude = amplitude
        self.phase = phase
        self.noiseAmplitude = noiseAmplitude
        self.wn = 2 * Double.pi * frequency
    }
    
    func getYValueForIndex(_ index: Int) -> Int32 {
        return Int32(amplitude * sin(Double(index) * wn + phase) + (Double.random(in: 0..<1) - 0.5) * noiseAmplitude)
    }
}

< BACK TO ALL IOS CHART CHART EXAMPLES