Working with new and improved code from Aural Player v3.12.0

Author: kartik-venugopal

FFmpegPlayer/FFmpegPlayer.xcodeproj/project.pbxproj

@@ -10,8 +10,6 @@ class AppDelegate: NSObject, NSApplicationDelegate {
 
         super.init()
         configureLoggingToAFile()
-        
-//        let ctx = MetadataEditingContext(forFile: URL(fileURLWithPath: "/Users/kven/Music/TagEdit/Bourne.mp3"))
     }
 
     private func configureLoggingToAFile() {

FFmpegPlayer/FFmpegPlayer.xcodeproj/project.xcworkspace/xcuserdata/kven.xcuserdatad/UserInterfaceState.xcuserstate

@@ -1,12 +1,21 @@
+//
+//  FFmpegChannelLayoutsMapper.swift
+//  Aural
+//
+//  Copyright © 2021 Kartik Venugopal. All rights reserved.
+//
+//  This software is licensed under the MIT software license.
+//  See the file "LICENSE" in the project root directory for license terms.
+//
 import AVFoundation
 
 ///
-/// Helps map ffmpeg channel layout identifiers to their corresponding AVFoundation channel layout tags.
+/// Helps map ffmpeg channel layout identifiers to their corresponding **AVFoundation** channel layout tags.
 ///
 /// This is required when setting the format for an audio buffer that is to be scheduled for playback, so that
 /// upmixing / downmixing can be performed correctly.
 ///
-struct ChannelLayouts {
+struct FFmpegChannelLayoutsMapper {
 
     ///
     /// A comprehensive mapping of ffmpeg layout identifiers to their corresponding AVFoundation channel layout tags.
@@ -69,11 +78,9 @@ struct ChannelLayouts {
         // L R C LFE Rls Rrs Ls Rs
         CH_LAYOUT_7POINT1: kAudioChannelLayoutTag_WAVE_7_1,
 
-        // MARK: The following mappings are not exact, but the closest possible matches. ---------------------------------------
+        // MARK: The following mappings are not exact, but the closest possible matches.
         // NOTE - Some channels may be dropped entirely.
 
-        // TODO: Create custom AudioChannelLayouts and AVAudioChannelLayouts with exact channel mappings
-        
         // L R C Cs Ls Rs -> L R C Cs
         CH_LAYOUT_6POINT0: kAudioChannelLayoutTag_DVD_8,
 
@@ -121,74 +128,18 @@ struct ChannelLayouts {
     static func mapLayout(ffmpegLayout: Int) -> AVAudioChannelLayout? {
 
         if let layoutTag = layoutsMap[ffmpegLayout] {
-         
-            // NOTE - It's safe to force unwrap the optional AVAudioChannelLayout
-            // because we are using only valid pre-defined channel layout tags.
-            return AVAudioChannelLayout(layoutTag: layoutTag)!
+            return AVAudioChannelLayout(layoutTag: layoutTag)
         }
 
         return nil
     }
 
-    ///
-    /// Provides a human-readable string for a given channel layout.
-    ///
-    /// - Parameter channelLayout: The identifier for an ffmpeg channel layout.
-    ///
-    /// - Parameter channelCount:  The number of channels in **channelLayout**.
-    ///
-    /// - returns:                 A human-readable string describing the given channel layout.
-    ///
     static func readableString(for channelLayout: Int64, channelCount: Int32) -> String {
 
         let layoutStringPointer = UnsafeMutablePointer<Int8>.allocate(capacity: 100)
-        av_get_channel_layout_string(layoutStringPointer, 100, channelCount, UInt64(channelLayout))
-        
         defer {layoutStringPointer.deallocate()}
 
+        av_get_channel_layout_string(layoutStringPointer, 100, channelCount, UInt64(channelLayout))
         return String(cString: layoutStringPointer).replacingOccurrences(of: "(", with: " (").capitalized
     }
-    
-    // MARK: Debugging functions ------------------------------------------------------
-    
-    static func printLayouts() {
-        
-        for layout in layoutsMap.keys.sorted(by: {$0 < $1}).map({UInt64($0)}) {
-            printLayout(layout, av_get_channel_layout_nb_channels(layout))
-        }
-    }
-    
-    static func printLayout(_ layout: UInt64, _ channelCount: Int32) {
-        
-        let layoutString = UnsafeMutablePointer<Int8>.allocate(capacity: 100)
-        av_get_channel_layout_string(layoutString, 100, channelCount, layout)
-        
-        var channelNames: [String] = []
-        for index in 0..<channelCount {
-            channelNames.append(String(cString: av_get_channel_name(av_channel_layout_extract_channel(UInt64(layout), index))))
-        }
-        
-        let ls = String(cString: layoutString)
-        let ffLay = channelNames.joined(separator: " ")
-        let avfLay = AVFLayout(ffLay)
-        
-        print("\nLayout:", layout, ls, ffLay)
-        print("AVF Layout:", avfLay)
-    }
-    
-    static func AVFLayout(_ lyt: String) -> String {
-        
-        return lyt
-            .replacingOccurrences(of: "BL", with: "Rls")
-            .replacingOccurrences(of: "BR", with: "Rrs")
-            .replacingOccurrences(of: "BC", with: "Cs")
-            .replacingOccurrences(of: "SL", with: "Ls")
-            .replacingOccurrences(of: "SR", with: "Rs")
-            .replacingOccurrences(of: "FLC", with: "Lc")
-            .replacingOccurrences(of: "FRC", with: "Rc")
-            .replacingOccurrences(of: "FL", with: "L")
-            .replacingOccurrences(of: "FR", with: "R")
-            .replacingOccurrences(of: "FC", with: "C")
-        
-    }
 }

FFmpegPlayer/Sources/AppDelegate.swift

@@ -0,0 +1,101 @@
+//
+//  FFmpegSampleConverter.swift
+//  Aural
+//
+//  Copyright © 2021 Kartik Venugopal. All rights reserved.
+//
+//  This software is licensed under the MIT software license.
+//  See the file "LICENSE" in the project root directory for license terms.
+//
+import AVFoundation
+import Accelerate
+
+fileprivate let bytesInAFloat: Int = MemoryLayout<Float>.size / MemoryLayout<UInt8>.size
+
+///
+/// Performs conversion of PCM audio samples to the standard format suitable for playback in an **AVAudioEngine**,
+/// i.e. 32-bit floating point non-interleaved (aka planar).
+///
+/// Uses **libswresample** to do the actual conversion.
+///
+extension FFmpegDecoder {
+    
+    ///
+    /// Transfer the decoded samples into an audio buffer that the audio engine can schedule for playback.
+    ///
+    func transferSamplesToPCMBuffer(from frameBuffer: FFmpegFrameBuffer, outputFormat: AVAudioFormat) -> AVAudioPCMBuffer? {
+        
+        // Transfer the decoded samples into an audio buffer that the audio engine can schedule for playback.
+        guard let playbackBuffer = AVAudioPCMBuffer(pcmFormat: outputFormat,
+                                                    frameCapacity: AVAudioFrameCount(frameBuffer.sampleCount)) else {return nil}
+        
+        // The audio buffer will always be filled to capacity.
+        playbackBuffer.frameLength = playbackBuffer.frameCapacity
+        
+        if frameBuffer.needsFormatConversion {
+            convert(samplesIn: frameBuffer, andCopyTo: playbackBuffer)
+            
+        } else {
+            copy(samplesIn: frameBuffer, into: playbackBuffer)
+        }
+        
+        return playbackBuffer
+    }
+    
+    func copy(samplesIn frameBuffer: FFmpegFrameBuffer, into audioBuffer: AVAudioPCMBuffer) {
+        
+        guard let destPointers = audioBuffer.floatChannelData else {return}
+        
+        // Keeps track of how many samples have been copied over so far.
+        // This will be used as an offset when performing each copy operation.
+        var sampleCountSoFar: Int = 0
+        
+        for frame in frameBuffer.frames {
+            
+            let sampleCount = frame.sampleCount
+            let firstSampleIndex = Int(frame.firstSampleIndex)
+            
+            // NOTE - The following copy operation assumes a non-interleaved output format (i.e. the standard Core Audio format).
+            
+            // Temporarily bind the input sample buffers as floating point numbers, and perform the copy.
+            frame.dataPointers.withMemoryRebound(to: UnsafeMutablePointer<Float>.self, capacity: channelCount) {srcPointers in
+
+                // Iterate through all the channels.
+                for channelIndex in 0..<channelCount {
+
+                    // Use Accelerate to perform the copy optimally, starting at the given offset.
+                    cblas_scopy(sampleCount,
+                                srcPointers[channelIndex].advanced(by: firstSampleIndex), 1,
+                                destPointers[channelIndex].advanced(by: sampleCountSoFar), 1)
+                }
+            }
+            
+            sampleCountSoFar += frame.intSampleCount
+        }
+    }
+    
+    func convert(samplesIn frameBuffer: FFmpegFrameBuffer, andCopyTo audioBuffer: AVAudioPCMBuffer) {
+        
+        guard let resampleCtx = self.resampleCtx, let destPointers = audioBuffer.floatChannelData else {return}
+        
+        var sampleCountSoFar: Int = 0
+        let outputData: UnsafeMutablePointer<UnsafeMutablePointer<UInt8>?>! = .allocate(capacity: channelCount)
+        defer {outputData.deallocate()}
+        
+        destPointers.withMemoryRebound(to: UnsafeMutablePointer<UInt8>.self, capacity: channelCount) {outChannelPointers in
+            
+            // Convert one frame at a time.
+            for frame in frameBuffer.frames {
+                
+                let offset = sampleCountSoFar * bytesInAFloat
+                
+                for ch in 0..<channelCount {
+                    outputData[ch] = outChannelPointers[ch].advanced(by: offset)
+                }
+                
+                resampleCtx.convertFrame(frame, andStoreIn: outputData)
+                sampleCountSoFar += frame.intSampleCount
+            }
+        }
+    }
+}