klx_teacher/KulexiuForTeacher/KulexiuForTeacher/Common/MediaMerge/AudioMerge/MergePlayer/KSMergeEnginePlayer.m

//
//  KSMergeEnginePlayer.m
//  MutiPlayDemo
//
//  Created by 王智 on 2024/6/17.
//

#import "KSMergeEnginePlayer.h"
#import <AVFoundation/AVFoundation.h>



@interface KSMergeEnginePlayer ()
/** 定时器 */
@property (nonatomic, strong) NSTimer *timer;

@property (nonatomic, strong) AVAudioEngine *audioEngine;

@property (nonatomic, strong) AVAudioPlayerNode *nodePlayer;

@property (nonatomic, strong) AVAudioFile *audioFile;
@property (nonatomic, strong) AVAudioFormat *audioFormat;

@property (nonatomic, strong) AVAudioFile *bgAudioFile;
@property (nonatomic, strong) AVAudioFormat *bgAudioFormat;

@property (nonatomic, assign) NSTimeInterval totalDuration;

@property (nonatomic, assign) NSInteger offsetTime; // 延迟时间

@property (nonatomic, assign) AVAudioFramePosition startPosition; // 开始位置

@property (nonatomic, strong) dispatch_queue_t sourceQueue;

@property (nonatomic, strong) AVAudioPCMBuffer *mixBuffer;

@property (nonatomic, strong) AVAudioPCMBuffer *bgBuffer;

@property (nonatomic, strong) AVAudioPCMBuffer *recordBuffer;

@property (nonatomic, assign) AVAudioFramePosition currentFrame;

@property (nonatomic, assign) double sampleRate;

@property (nonatomic, assign) BOOL stopMix; // 是否停止mix

@property (nonatomic, strong) dispatch_semaphore_t mixChangeSemaphore; // mix信号量

@property (nonatomic, assign) BOOL stopChangeVolume; // 是否停止音量修改循环

@property (nonatomic, strong) dispatch_semaphore_t volumeChangeSemaphore;

@property (nonatomic, assign) BOOL isInterrupt; // 是否被打断

@end


@implementation KSMergeEnginePlayer

- (instancetype)init {
    self = [super init];
    if (self) {
        [self configDefault];
    }
    return self;
}

- (void)configDefault {
    self.recordVolume = 1.0f;
    self.bgVolume = 1.0f;
    self.mixChangeSemaphore = dispatch_semaphore_create(1); // 初始化信号量
    self.volumeChangeSemaphore = dispatch_semaphore_create(1); // 初始化信号量，初始值为1
}

- (void)configEngine {
    [self setupAudioSession];
    
    self.audioEngine = [[AVAudioEngine alloc] init];
    self.nodePlayer = [[AVAudioPlayerNode alloc] init];
    
    // attach node
    [self.audioEngine attachNode:self.nodePlayer];
    
}

- (void)setupAudioSession {
    NSError *err = nil;
    AVAudioSession *audioSession = [AVAudioSession sharedInstance];
    
    @try {
        [audioSession setActive:YES error:&err];
    } @catch (NSException *exception) {
        
    } @finally {
        
    }
    
    [[NSNotificationCenter defaultCenter] addObserver:self selector:@selector(handleInterruption:) name:AVAudioSessionInterruptionNotification object:audioSession];
    [[NSNotificationCenter defaultCenter] addObserver:self selector:@selector(handleRouteChange:) name:AVAudioSessionRouteChangeNotification object:audioSession];
}


- (void)startEngine {
    // 启动engine
    NSError *error = nil;
    @try {
        [self.audioEngine startAndReturnError:&error];
    } @catch (NSException *exception) {
        NSLog(@"--------Exception: %@", exception);
    } @finally {
        if (error) {
            self.audioEngine = nil;
            // 错误回调
            [self sendInterruptError:error];
        }
    }
}

- (void)prepareNativeSongWithUrl:(NSURL *)recordAudioUrl bgMusic:(NSURL *)bgMusicUrl {
    [self loadAuidoFile:recordAudioUrl isBgm:NO];
    [self loadAuidoFile:bgMusicUrl isBgm:YES];
    self.sampleRate = self.audioFile.fileFormat.sampleRate;
    [self configEngine];
    
    AVAudioFormat *outputFormat = [self.audioEngine.mainMixerNode outputFormatForBus:0];
    [self.audioEngine connect:self.nodePlayer to:self.audioEngine.mainMixerNode format:outputFormat];
    [self startEngine];
    
    if (self.audioEngine && self.audioEngine.isRunning) {
        dispatch_async(self.sourceQueue, ^{
            [self prepareBufferFrame];
        });
    }
}


- (void)loadAuidoFile:(NSURL *)audioFileUrl isBgm:(BOOL)isBgm {
    dispatch_sync(self.sourceQueue, ^{
        NSError *error = nil;
        AVAudioFile *audioFile = nil;
        AVAudioFormat *audioFormat = nil;
        @try {
            audioFile = [[AVAudioFile alloc] initForReading:audioFileUrl error:&error];
            audioFormat = audioFile.processingFormat;
            
        } @catch (NSException *exception) {
            audioFile = nil;
            audioFormat = nil;
        } @finally {
            if (error) {
                // 错误回调
            }
            else { // 加载成功
                if (isBgm) {
                    self.bgAudioFile = audioFile;
                    self.bgAudioFormat = audioFormat;
                }
                else {
                    self.audioFile = audioFile;
                    self.audioFormat = audioFormat;
                }
            }
        }
    });
}

- (void)prepareBufferFrame {
    AVAudioFrameCount minFrameCount = (AVAudioFrameCount)MIN(self.bgAudioFile.length, self.audioFile.length);
    // mixBuffer
    AVAudioFormat *outputFormat = [[AVAudioFormat alloc] initStandardFormatWithSampleRate:self.bgAudioFormat.sampleRate channels:2];
    self.mixBuffer = [[AVAudioPCMBuffer alloc] initWithPCMFormat:outputFormat frameCapacity:minFrameCount];
    self.mixBuffer.frameLength = minFrameCount;
    
    self.bgBuffer = [self loadAudioSegment:self.bgAudioFile startFrame:0 frameCount:minFrameCount];
    self.recordBuffer = [self loadAudioSegment:self.audioFile startFrame:0 frameCount:minFrameCount];
    
    if (self.delegate && [self.delegate respondsToSelector:@selector(enginePlayerIsReadyPlay:)]) {
        self.isReady = YES;
        [self.delegate enginePlayerIsReadyPlay:self];
    }
}

- (AVAudioPCMBuffer *)loadAudioSegment:(AVAudioFile *)audioFile startFrame:(AVAudioFramePosition)startFrame frameCount:(AVAudioFrameCount)frameCount {
    AVAudioFormat *audioFromat = audioFile.processingFormat;
    AVAudioFrameCount frameToRead = (AVAudioFrameCount)MIN(frameCount, (AVAudioFrameCount)audioFile.length - startFrame);
    if (startFrame > audioFile.length) {
        return nil;
    }
    AVAudioPCMBuffer *buffer = [[AVAudioPCMBuffer alloc] initWithPCMFormat:audioFromat frameCapacity:frameToRead];
    buffer.frameLength = frameToRead;
    
    audioFile.framePosition = startFrame;
    if (frameToRead > 0) {
        @try {
            [audioFile readIntoBuffer:buffer frameCount:frameToRead error:nil];
        } @catch (NSException *exception) {
            
        } @finally {
            
        }
    }
    return buffer;
}


- (void)mixBuffers:(AVAudioPCMBuffer *)bgBuffer bgBufferVolume:(float)bgBufferVolume withRecordBuffer:(AVAudioPCMBuffer *)recordBuffer recordVolume:(float)recordVolume offset:(NSInteger)offsetTime startPosition:(AVAudioFrameCount)startPosition {
    if (!bgBuffer && !recordBuffer) {
        return;
    }
    NSLog(@"------- start");
    
    AVAudioFrameCount minFrameCount = MIN(bgBuffer.frameLength, recordBuffer.frameLength);
    AVAudioFrameCount offsetFrame = labs(offsetTime)/1000.0 * recordBuffer.format.sampleRate;
    
    float *bgLeftChannel = bgBuffer.floatChannelData[0];
    float *bgRightChannel = bgBuffer.floatChannelData[1];
    // 录音文件未单声道
    float *recordLeftChannel = recordBuffer.floatChannelData[0];
    
    float *mixLeftChannel = self.mixBuffer.floatChannelData[0];
    float *mixRightChannel = self.mixBuffer.floatChannelData[1];
    
    for (int frame = 0; frame < minFrameCount; frame++) {
        if (self.stopMix) {
            NSLog(@"------- stop mix");
            dispatch_semaphore_signal(self.mixChangeSemaphore); // 释放信号量
            return;
        }
        int bgFrame = frame+startPosition;
        float leftChannel = (bgFrame < bgBuffer.frameLength) ? bgLeftChannel[bgFrame] : 0;
        float rightChannel = (bgFrame < bgBuffer.frameLength) ? bgRightChannel[bgFrame] : 0;
        
        int recordFrame = (offsetTime < 0) ? (bgFrame - offsetFrame) : (bgFrame + offsetFrame);
        
        float recordData = (recordFrame >= 0 && recordFrame < recordBuffer.frameLength) ? recordLeftChannel[recordFrame] : 0;
        
        
        float mixLeftData = [self mixChannelData:leftChannel bgVolume:bgBufferVolume recordData:recordData recordVolume:recordVolume];
        float mixRightData = [self mixChannelData:rightChannel bgVolume:bgBufferVolume recordData:recordData recordVolume:recordVolume];
        
        mixLeftChannel[frame] = MAX(-1.0, MIN(1.0, mixLeftData));
        mixRightChannel[frame] = MAX(-1.0, MIN(1.0, mixRightData));
    }
    NSLog(@"---------finish");
    
}

- (float)mixChannelData:(float)bgData bgVolume:(float)bgVolume recordData:(float)recordData recordVolume:(float)recordVolume {
    return (bgData * bgVolume + recordData * recordVolume) / 2;
}

- (void)changeVolume:(float)bgVolume recordVolume:(float)recordVolume {
    
    NSLog(@"bg volume ---- %f,  record volume ---- %f", bgVolume, recordVolume);
    self.bgVolume = bgVolume;
    self.recordVolume = recordVolume;
    if (self.bgBuffer && self.recordBuffer) {
        self.stopChangeVolume = YES;
        // 停止上一次修改音量
        dispatch_async(self.sourceQueue, ^{
            // 等待上一次的操作完成
            dispatch_semaphore_wait(self.volumeChangeSemaphore, DISPATCH_TIME_FOREVER);
            self.stopChangeVolume = NO;
            // 开始新的音量修改操作
            AVAudioFramePosition startFrame = self.currentFrame;
            NSLog(@"----- current frame -----%lld", startFrame);
            [self modifyMixBuffer:self.bgBuffer bgBufferVolume:bgVolume withRecordBuffer:self.recordBuffer recordVolume:recordVolume offset:self.offsetTime startPosition:startFrame tagIndex:0];
            // 释放信号量，标记音量修改操作完成
            dispatch_semaphore_signal(self.volumeChangeSemaphore);
        });
    }
}


- (void)modifyMixBuffer:(AVAudioPCMBuffer *)bgBuffer bgBufferVolume:(float)bgBufferVolume withRecordBuffer:(AVAudioPCMBuffer *)recordBuffer recordVolume:(float)recordVolume offset:(NSInteger)offsetTime startPosition:(AVAudioFramePosition)startFrame tagIndex:(NSInteger)tagIndex {
    
    AVAudioFrameCount minFrameCount = MIN(bgBuffer.frameLength, recordBuffer.frameLength);
    AVAudioFrameCount offsetFrame = labs(offsetTime)/1000.0 * recordBuffer.format.sampleRate;
    
    float *bgLeftChannel = bgBuffer.floatChannelData[0];
    float *bgRightChannel = bgBuffer.floatChannelData[1];
    // 录音文件未单声道
    float *recordLeftChannel = recordBuffer.floatChannelData[0];
    
    float *mixLeftChannel = self.mixBuffer.floatChannelData[0];
    float *mixRightChannel = self.mixBuffer.floatChannelData[1];
    
    // 先处理后续播放的buffer
    NSLog(@"------- volume change start");
    for (int frame = (int)startFrame; frame < minFrameCount; frame++) {
        if (self.stopChangeVolume) {
            NSLog(@"------- stop volume change");
            dispatch_semaphore_signal(self.volumeChangeSemaphore); // 释放信号量
            return;
        }
        
        float leftChannel = bgLeftChannel[frame];
        float rightChannel = bgRightChannel[frame];
        
        int recordFrame = (offsetTime < 0) ? (frame - offsetFrame) : (frame + offsetFrame);
        float recordData = (recordFrame >= 0 && recordFrame < recordBuffer.frameLength) ? recordLeftChannel[recordFrame] : 0;
        
        float mixLeftData = [self mixChannelData:leftChannel bgVolume:bgBufferVolume recordData:recordData recordVolume:recordVolume];
        float mixRightData = [self mixChannelData:rightChannel bgVolume:bgBufferVolume recordData:recordData recordVolume:recordVolume];
        
        mixLeftChannel[frame-self.startPosition] = MAX(-1.0, MIN(1.0, mixLeftData));
        mixRightChannel[frame-self.startPosition] = MAX(-1.0, MIN(1.0, mixRightData));
    }
    NSLog(@"------- volume change end");
}

- (void)scheduleBufferFromPosition:(AVAudioFramePosition)startPosition {
    
    self.stopMix = YES;
    self.startPosition = startPosition;
    dispatch_async(self.sourceQueue, ^{
        // 等待上一次的操作完成
        dispatch_semaphore_wait(self.mixChangeSemaphore, DISPATCH_TIME_FOREVER);
        self.stopMix = NO;
        
        [self mixBuffers:self.bgBuffer bgBufferVolume:self.bgVolume withRecordBuffer:self.recordBuffer recordVolume:self.recordVolume offset:self.offsetTime startPosition:(AVAudioFrameCount)startPosition];
        // 释放信号量，标记修改操作完成
        dispatch_semaphore_signal(self.mixChangeSemaphore);
        // 加载缓冲区
        [self.nodePlayer scheduleBuffer:self.mixBuffer atTime:nil options:AVAudioPlayerNodeBufferInterruptsAtLoop completionHandler:^{
            
        }];
    });
}



// 打断处理
- (void)handleInterruption:(NSNotification *)notification {
    NSDictionary *info = notification.userInfo;
    
    AVAudioSessionInterruptionType type = [info[AVAudioSessionInterruptionTypeKey] unsignedIntegerValue];
    if (type == AVAudioSessionInterruptionTypeBegan) {
        //Handle InterruptionBegan
        if (self.isInterrupt == NO) {
            // 停止播放
            if (self.nodePlayer.isPlaying) {
                [self.nodePlayer stop];
            }
            self.isInterrupt = YES;
            NSError *error = [[NSError alloc] initWithDomain:NSCocoaErrorDomain code:99999 userInfo:@{@"errorDesc" : @"播放被打断"}];
            [self sendInterruptError:error];
        }
    }
    else if (type == AVAudioSessionInterruptionTypeEnded) {
        AVAudioSessionInterruptionOptions options = [info[AVAudioSessionInterruptionOptionKey] unsignedIntegerValue];
        if (options == AVAudioSessionInterruptionOptionShouldResume && self.isInterrupt) {
            //Handle Resume
            NSError *error = nil;
            [[AVAudioSession sharedInstance] setActive:YES error:&error];
            if (error) {
                NSLog(@"------ error desc %@", error.description);
            }
            NSLog(@"---- 播放恢复");
            self.isInterrupt = NO;
        }
    }
}

- (void)handleRouteChange:(NSNotification *)notification {
    NSDictionary *info = notification.userInfo;
    AVAudioSessionRouteChangeReason reason = [info[AVAudioSessionRouteChangeReasonKey] unsignedIntegerValue];
    if (reason == AVAudioSessionRouteChangeReasonOldDeviceUnavailable) {
        // 耳机拔出时暂停音频
        if (self.nodePlayer.isPlaying) {
            NSError *error = nil;
            [self sendInterruptError:error];
        }
        
    } else if (reason == AVAudioSessionRouteChangeReasonNewDeviceAvailable) {
        // 耳机插入时恢复音频
        if (self.nodePlayer.isPlaying) {
            NSError *error = nil;
            [self sendInterruptError:error];
        }
    }
}

- (void)sendInterruptError:(NSError *)error {
    if (self.delegate && [self.delegate respondsToSelector:@selector(enginePlayerDidError:error:)]) {
        [self.delegate enginePlayerDidError:self error:error];
    }
}
#pragma mark ------ play action

- (void)changeRecordDelay:(NSInteger)delayMs {
    self.offsetTime = delayMs;
}

- (void)seekToTimePlay:(NSInteger)time {
    if (self.isInterrupt) {
        [self sendInterruptError:nil];
        return;
    }
    if (self.audioEngine.isRunning == NO) {
        [self startEngine];
    }
    if (self.audioEngine.isRunning) {
        [self seekAudioWithStartTime:time needPlay:YES];
    }
}

- (void)stopPlay {
    self.stopMix = YES;
    self.stopChangeVolume = YES;
    if (self.nodePlayer.isPlaying) {
        [self.nodePlayer stop];
    }
    [self stopTimer];
}

- (void)seekToTime:(NSInteger)time {
    if (self.isInterrupt) {
        [self sendInterruptError:nil];
        return;
    }
    if (self.audioEngine.isRunning == NO) {
        [self startEngine];
    }
    if (self.audioEngine.isRunning) {
        [self seekAudioWithStartTime:time needPlay:NO];
    }
}

- (void)seekAudioWithStartTime:(NSTimeInterval)startTime needPlay:(BOOL)needPlay {
    if (self.audioEngine.isRunning == NO) {
        [self startEngine];
    }
    if (self.audioEngine.isRunning) {
        if (self.nodePlayer.isPlaying) {
            [self.nodePlayer stop];
        }
    }
    
    // 停止修改音量循环
    self.stopChangeVolume = YES;
    
    AVAudioFramePosition startFrame = startTime / 1000.0 * self.audioFormat.sampleRate;
    // 跳转进度
    self.currentFrame = startFrame;
    [self scheduleBufferFromPosition:startFrame];

    if (needPlay) {
        [self.nodePlayer play];
        [self startTimer];
    }
}

// 调整偏移
- (void)seekOffsetTime:(NSInteger)offsetTime {
    self.offsetTime = offsetTime;
    NSTimeInterval currentTime = [self getCurrentPlayTime];
    [self seekToTimePlay:currentTime];
}

- (void)freePlayer {
    
    if (self.nodePlayer.isPlaying) {
        [self stopPlay];
    }
    [self.audioEngine stop];
}

- (void)startTimer {
    
    [self.timer setFireDate:[NSDate distantPast]];
}

- (void)stopTimer {
    
    [self.timer setFireDate:[NSDate distantFuture]];//暂停计时器
}

#pragma mark ---- lazying
- (dispatch_queue_t)sourceQueue {
    if (!_sourceQueue) {
        _sourceQueue = dispatch_queue_create("ks_MutilSourceQueue", DISPATCH_QUEUE_SERIAL);
    }
    return _sourceQueue;
}

- (NSTimer *)timer {
    
    if (!_timer) {
        __weak typeof(self)weakSelf = self;
        _timer = [NSTimer scheduledTimerWithTimeInterval:0.1 repeats:YES block:^(NSTimer * _Nonnull timer) {
            [weakSelf timeFunction];
        }];
        [[NSRunLoop currentRunLoop] addTimer:_timer forMode:NSRunLoopCommonModes];
        [_timer setFireDate:[NSDate distantFuture]];
    }
    return _timer;
}

- (void)timeFunction {
    self.totalDuration = [self getTotalTime];
    NSTimeInterval currentTime = [self getCurrentPlayTime];
    float progress = currentTime/self.totalDuration;
    NSDate *date = [NSDate date];
    NSTimeInterval inteveral = [date timeIntervalSince1970];
    if (currentTime > self.totalDuration) {
        if (self.delegate && [self.delegate respondsToSelector:@selector(enginePlayFinished:)]) {
            [self.delegate enginePlayFinished:self];
        }
    }
    else {
        if (self.delegate && [self.delegate respondsToSelector:@selector(updatePlayProgress:andTotalTime:andProgress:currentInterval:inPlayer:)]) {
            [self.delegate updatePlayProgress:currentTime andTotalTime:self.totalDuration andProgress:progress currentInterval:inteveral*1000 inPlayer:self];
        }
    }
    
}


- (NSTimeInterval)getCurrentPlayTime {
    AVAudioTime *nodeTime = [self.nodePlayer lastRenderTime];
    if (nodeTime && self.bgAudioFile) {
        AVAudioTime *playerTime = [self.nodePlayer playerTimeForNodeTime:nodeTime];
        AVAudioFramePosition currentFrame = self.currentFrame;
        
        if (playerTime) {
            self.sampleRate = [playerTime sampleRate];
            AVAudioFramePosition currentFrame = [playerTime sampleTime];
            if (currentFrame <= 0) {
                currentFrame = 0;
            }
            currentFrame += self.startPosition;
            self.currentFrame = currentFrame;
        }
        else {
            NSLog(@"播放已停止");
        }
        double elapsedSamples = (double)currentFrame;

        NSTimeInterval currentTime = elapsedSamples / self.sampleRate;
//        NSLog(@"当前时间----- %f",currentTime*1000);
        return currentTime*1000;
    }
    else {
        return 0;
    }
}

- (NSTimeInterval)getTotalTime {
    NSTimeInterval recordTotalDuration = (AVAudioFramePosition)self.audioFile.length * 1000.0 / self.audioFormat.sampleRate;
    return recordTotalDuration;
}

- (BOOL)isPlaying {
    if (self.nodePlayer) {
        return self.nodePlayer.isPlaying;
    }
    return NO;
}
@end