The waveform is offset than actual.

[DamonChen117]

in the func

func process(_ samples: UnsafeMutablePointer<Int16>,
                         ofLength sampleLength: Int,
                         from assetReader: AVAssetReader,
                         downsampledTo targetSampleCount: Int) -> [Float] 

There is a line:
let samplesPerPixel = max(1, sampleCount(from: assetReader) / targetSampleCount)

samplesPerPixel is a Int, so it ignore Decimal, and it result there Is offset for waveform, and it accumulate the offset for each call to process.

[DamonChen117]

My work around is :

fileprivate func extract(samplesFrom assetReader: AVAssetReader, downsampledTo targetSampleCount: Int) -> [Float] {
        var outputSamples = [Float]()

        var processedSampleLength = 0 // <---
        assetReader.startReading()
        while assetReader.status == .reading {
            let trackOutput = assetReader.outputs.first!

            if let sampleBuffer = trackOutput.copyNextSampleBuffer(),
                let blockBuffer = CMSampleBufferGetDataBuffer(sampleBuffer) {
                let blockBufferLength = CMBlockBufferGetDataLength(blockBuffer)
                let sampleLength = CMSampleBufferGetNumSamples(sampleBuffer) * channelCount(from: assetReader)
                var data = Data(capacity: blockBufferLength)
                data.withUnsafeMutableBytes { (blockSamples: UnsafeMutablePointer<Int16>) in
                    CMBlockBufferCopyDataBytes(blockBuffer, atOffset: 0, dataLength: blockBufferLength, destination: blockSamples)
                    CMSampleBufferInvalidate(sampleBuffer)

                    let processedSamples = process(blockSamples,
                                                   ofLength: sampleLength,
                                                   from: assetReader,
                                                   downsampledTo: targetSampleCount)
                    
                    outputSamples += processedSamples

                    // start <---
                    processedSampleLength += sampleLength
                    
                    let samplesPerPixel:Float = max(1, Float(sampleCount(from: assetReader)) / Float(targetSampleCount))
                    let downSampledLength = Int(Float(processedSampleLength) / samplesPerPixel)
                    
                    let pad = outputSamples.last ?? -32
                    while outputSamples.count < downSampledLength
                    {
                        outputSamples.append(pad)
                    }
                    
                    while outputSamples.count >= downSampledLength
                    {
                        outputSamples.removeLast()
                    }
                    // end <---
                }
            }
        }
        var paddedSamples = [Float](repeating: silenceDbThreshold, count: targetSampleCount)
        paddedSamples.replaceSubrange(0..<min(targetSampleCount, outputSamples.count), with: outputSamples)

        return paddedSamples
    }

[dmrschmidt]

@DamonChen117 thanks for submitting this. You're totally right, the code is missing a hwole bunch of samples in bigger files especially. Working on a fix currently. Almost there.

I introduced a running buffer now, which makes sure all samples are getting processed. While your solution looks like it will "catch up" on the lost samples, it only fills them with 0. With the running buffer now it's ensured that all samples are weighted correctly.

Currently just missing to process the final samples from file end and once I added that it should be good to go.

As a side effect this also fixes #12 already.