मल्टीप्पर कनेक्टिविटी का उपयोग करके डिवाइस से डिवाइस पर रिकॉर्ड और स्थानांतरण ध्वनि

शुभ दोपहर, प्रिय पाठक! कुछ समय पहले, मैंने डिवाइस से डिवाइस पर रिकॉर्ड की गई ध्वनि को रिकॉर्ड करने और स्थानांतरित करने का प्रयास करने का फैसला किया। रिकॉर्ड किए गए ध्वनि को प्रसारित करने के साधन के रूप में, विकल्प मल्टीप्केरोनिटिविटी फ्रेमवर्क पर गिर गया। इस लेख में मैं आपको बताऊंगा कि यह कैसे करना है।

सबसे पहले, हमें रिकॉर्डिंग और ध्वनि चलाने के लिए दो उपकरणों की आवश्यकता है। तदनुसार, हमें इन कार्यों को करने के लिए एक वर्ग लिखने की आवश्यकता है।

एक डिवाइस से वास्तविक समय ऑडियो रिकॉर्डिंग

रिकॉर्डिंग ऑडियो के लिए, सामान्य रूप से AVAudioEngine और AVAudioMixerNode का उपयोग किया जाता है, जिन्हें AVFounding ढांचे के साथ आपूर्ति की जाती है।

ऑडियो रिकॉर्डिंग उदाहरण:

final class Recorder { private let engine = AVAudioEngine() private let mixer = AVAudioMixerNode() var onRecordedAction: ((Data) -> Void)? init() { setupAudioSession() } private func setupAudioSession() { let audioSession = AVAudioSession.sharedInstance() do { try audioSession.setCategory(.record) try audioSession.setMode(.measurement) try audioSession.setActive(true) } catch { debugPrint(error.localizedDescription) } } func startRecording() { let input = engine.inputNode let inputFormat = input.outputFormat(forBus: 0) engine.attach(mixer) engine.connect(input, to: mixer, format: inputFormat) mixer.installTap(onBus: 0, bufferSize: 1024, format: mixer.outputFormat(forBus: 0)) { [weak self] buffer, _ in self?.onRecordedAction?(buffer.data) } engine.prepare() do { try engine.start() } catch { debugPrint(error.localizedDescription) } } func stopRecording() { engine.stop() } } 

सामान्य तौर पर, कुछ भी असामान्य नहीं है, एक मिक्सर की मदद से हम वास्तविक समय का डेटा प्राप्त करते हैं और इसे हमारे onRecodedAction फ़ंक्शन पर भेजते हैं। हमारे द्वारा रिकॉर्ड किए गए ऑडियो को और स्थानांतरित करने के लिए, हमें इसे डेटा में बदलने की आवश्यकता है। इसके लिए, मैंने अगला विस्तार तैयार किया।

PCMBuffer को डेटा में परिवर्तित करने का उदाहरण:

 extension AVAudioPCMBuffer { var data: Data { let channels = UnsafeBufferPointer(start: floatChannelData, count: 1) let data = Data(bytes: channels[0], count: Int(frameCapacity * format.streamDescription.pointee.mBytesPerFrame)) return data } } 

प्लेबैक को ऑडियो मिला

ऑडियो को चलाने के लिए एक ही फ्रेमवर्क का उपयोग किया जाता है, परिणामस्वरूप, कुछ भी जटिल नहीं है, संक्षेप में, हम सिर्फ एक नोड बनाते हैं और इसे इंजन को असाइन करते हैं, फिर अपने डेटा को पीसीएमबीफ़र में वापस कनवर्ट करते हैं और प्लेबैक के लिए हमारे नोड को देते हैं।

प्लेबैक उदाहरण:

 final class Player { private let engine = AVAudioEngine() private var playerNode = AVAudioPlayerNode() init() { setupAudioSession() } private func setupAudioSession() { let audioSession = AVAudioSession.sharedInstance() do { try audioSession.setCategory(.playback) try audioSession.setActive(true) } catch { debugPrint(error.localizedDescription) } } private func setupPlayer(buffer: AVAudioPCMBuffer) { engine.attach(playerNode) engine.connect(playerNode, to: engine.mainMixerNode, format: buffer.format) engine.prepare() } private func tryStartEngine() { do { try engine.start() } catch { debugPrint(error.localizedDescription) } } func addPacket(packet: Data) { guard let format = AVAudioFormat.common, let buffer = packet.pcmBuffer(format: format) else { debugPrint("Cannot convert buffer from Data") return } if !engine.isRunning { setupPlayer(buffer: buffer) tryStartEngine() playerNode.play() } playerNode.volume = 1 playerNode.scheduleBuffer(buffer, completionHandler: nil) } } 

PCMBuffer और हमारे AVAudioFormat को ऑडियो चलाने के लिए डेटा वापस अनुवाद करने के लिए उदाहरण एक्सटेंशन:

 private extension Data { func pcmBuffer(format: AVAudioFormat) -> AVAudioPCMBuffer? { let streamDesc = format.streamDescription.pointee let frameCapacity = UInt32(count) / streamDesc.mBytesPerFrame guard let buffer = AVAudioPCMBuffer(pcmFormat: format, frameCapacity: frameCapacity) else { return nil } buffer.frameLength = buffer.frameCapacity let audioBuffer = buffer.audioBufferList.pointee.mBuffers withUnsafeBytes { addr in guard let baseAddress = addr.baseAddress else { return } audioBuffer.mData?.copyMemory(from: baseAddress, byteCount: Int(audioBuffer.mDataByteSize)) } return buffer } } extension AVAudioFormat { static let common = AVAudioFormat(commonFormat: .pcmFormatFloat32, sampleRate: 44100, channels: 1, interleaved: false) } 

डिवाइस से डिवाइस में रिकॉर्ड किए गए ऑडियो ट्रांसफर करें

खैर, आखिरकार, हम सबसे महत्वपूर्ण बात पर आते हैं - मल्टीपियरकनेक्टिविटी का उपयोग करके डिवाइस से डिवाइस में रिकॉर्ड किए गए ऑडियो का स्थानांतरण । ऐसा करने के लिए, हमें एक MCPeerID ऑब्जेक्ट (हमारे डिवाइस को निर्धारित करना होगा) और क्लास MCNearbyServiceAdvertiser और MCNearbyServiceBrowser के दो इंस्टेंसेस बनाने की आवश्यकता है , जिनका उपयोग उपकरणों को खोजने के लिए किया जाएगा और ताकि अन्य डिवाइस हमें ढूंढ सकें (अन्य उपकरणों से कनेक्शन अनुरोध भी स्वीकार करें)। हम एक सत्र भी बनाते हैं जिसकी मदद से हम रिकॉर्ड किए गए ऑडियो को प्रसारित करेंगे और हमारे उपकरणों को "हेरफेर" करेंगे।

डेटा संचारित करने और प्राप्त करने के लिए उदाहरण वर्ग:

 private struct Constants { static var serviceType = "bn-radio" static var timeOut: Double = 10 } final class Connectivity: NSObject { private var advertiser: MCNearbyServiceAdvertiser? = nil private var browser: MCNearbyServiceBrowser? = nil private let peerID: MCPeerID private let session: MCSession private var invitationHandler: ((Bool, MCSession) -> Void)? = nil var onDeviceFoundedAction: ((MCPeerID) -> Void)? var onDeviceLostedAction: ((MCPeerID) -> Void)? var onInviteAction: ((MCPeerID) -> Void)? var onConnectingAction: (() -> Void)? var onConnectedAction: (() -> Void)? var onDisconnectedAction: (() -> Void)? var onPacketReceivedAction: ((Data) -> Void)? init(deviceID: String) { peerID = MCPeerID(displayName: deviceID) session = MCSession(peer: peerID, securityIdentity: nil, encryptionPreference: .none) super.init() session.delegate = self } func startHosting() { advertiser = MCNearbyServiceAdvertiser(peer: peerID, discoveryInfo: nil, serviceType: Constants.serviceType) advertiser?.delegate = self advertiser?.startAdvertisingPeer() } func findHost() { browser = MCNearbyServiceBrowser(peer: peerID, serviceType: Constants.serviceType) browser?.delegate = self browser?.startBrowsingForPeers() } func stop() { advertiser?.stopAdvertisingPeer() browser?.stopBrowsingForPeers() } func invite(peerID: MCPeerID) { browser?.invitePeer(peerID, to: session, withContext: nil, timeout: Constants.timeOut) } func handleInvitation(isAccepted: Bool) { invitationHandler?(isAccepted, session) } func send(data: Data) { try? self.session.send(data, toPeers: session.connectedPeers, with: .unreliable) } } extension Connectivity: MCSessionDelegate { func session(_ session: MCSession, peer peerID: MCPeerID, didChange state: MCSessionState) { switch state { case .connecting: onConnectingAction?() case .connected: onConnectedAction?() case .notConnected: onDisconnectedAction?() @unknown default: debugPrint("Error during session state changed on: \(state)") } } func session(_ session: MCSession, didReceive data: Data, fromPeer peerID: MCPeerID) { onPacketReceivedAction?(data) } func session(_ session: MCSession, didReceive stream: InputStream, withName streamName: String, fromPeer peerID: MCPeerID) { } func session(_ session: MCSession, didStartReceivingResourceWithName resourceName: String, fromPeer peerID: MCPeerID, with progress: Progress) { } func session(_ session: MCSession, didFinishReceivingResourceWithName resourceName: String, fromPeer peerID: MCPeerID, at localURL: URL?, withError error: Error?) { } func session(_ session: MCSession, didReceiveCertificate certificate: [Any]?, fromPeer peerID: MCPeerID, certificateHandler: @escaping (Bool) -> Void) { certificateHandler(true) } } extension Connectivity: MCNearbyServiceAdvertiserDelegate { func advertiser(_ advertiser: MCNearbyServiceAdvertiser, didReceiveInvitationFromPeer peerID: MCPeerID, withContext context: Data?, invitationHandler: @escaping (Bool, MCSession?) -> Void) { self.invitationHandler = invitationHandler onInviteAction?(peerID) } } extension Connectivity: MCNearbyServiceBrowserDelegate { func browser(_ browser: MCNearbyServiceBrowser, foundPeer peerID: MCPeerID, withDiscoveryInfo info: [String : String]?) { onDeviceFoundedAction?(peerID) } func browser(_ browser: MCNearbyServiceBrowser, lostPeer peerID: MCPeerID) { onDeviceLostedAction?(peerID) } } 

मैंने अपने आवेदन के सभी कोड को अपलोड नहीं करने का फैसला किया, क्योंकि मेरी राय में इसका उपयोग करने का बहुत सार पर्याप्त है, जैसा कि उदाहरण में दिखाया गया है। मैं इस बात से सहमत हूं कि कुछ चीजें हैं जिन्हें अलग तरीके से लागू किया जा सकता है, लेकिन मैंने इस मामले में जिस दृष्टिकोण की आवश्यकता थी, उसका उपयोग किया।

MultipeerConnectivity के उपयोग के दौरान, कुछ नकारात्मक पहलुओं की पहचान की गई थी, उदाहरण के लिए, कनेक्शन की दूरी, इसलिए मैं इस डेटा ट्रांसफर दृष्टिकोण का उपयोग करने की अनुशंसा नहीं करता हूं यदि आपको निरंतर आधार पर वास्तविक समय ऑडियो के समान कुछ प्रसारित करने की आवश्यकता है।