音频队列实现录音和播音

最新推荐文章于 2021-04-30 10:10:48 发布
最新推荐文章于 2021-04-30 10:10:48 发布
阅读量2.8k 收藏
点赞数
分类专栏： 工作

使用AudioQueue来实现音频播放功能时最主要的步骤，可以更简练的归纳如下。

1. 打开播放音频文件

2. 取得播放音频文件的数据格式

3. 准备播放用的队列

4. 将缓冲中的数据移动到队列中

5. 开始播放

6. 在回调函数中进行队列处理

1.playAudio.h

声明了一个Objective-C类

1.playAudio.h

声明了一个Objective-C类

1.播放音乐


复制代码

 
//
//  playAudio.h
//  ffmpegPlayAudio
//
//  Created by infomedia  xuanyuanchen on 12-3-26.
//  Copyright (c) 2012年 xuanyuanchen. All rights reserved.
//

#import <Foundation/Foundation.h>
#import <AudioToolbox/AudioToolbox.h>
#import <AudioToolbox/AudioFile.h>
#define NUM_BUFFERS 3

@interface playAudio : NSObject{
    //播放音频文件ID
    AudioFileID audioFile;
    //音频流描述对象
    AudioStreamBasicDescription dataFormat;
    //音频队列
    AudioQueueRef queue;
    SInt64 packetIndex;
    UInt32 numPacketsToRead;
    UInt32 bufferByteSize;
    AudioStreamPacketDescription *packetDescs;
    AudioQueueBufferRef buffers[NUM_BUFFERS];
}

//定义队列为实例属性
@property AudioQueueRef queue;
//播放方法定义
-(id)initWithAudio:(NSString *) path;
//定义缓存数据读取方法
-(void) audioQueueOutputWithQueue:(AudioQueueRef)audioQueue
                      queueBuffer:(AudioQueueBufferRef)audioQueueBuffer;
-(UInt32)readPacketsIntoBuffer:(AudioQueueBufferRef)buffer;
//定义回调(Callback)函数
static void BufferCallack(void *inUserData,AudioQueueRef inAQ,
                          AudioQueueBufferRef buffer);

@end
复制代码

2.playAudio.m

playAudio的实现

复制代码 
//
//  playAudio.m
//  ffmpegPlayAudio
//
//  Created by infomedia  infomedia on 12-3-26.
//  Copyright (c) 2012年 infomedia. All rights reserved.
//

#import "playAudio.h"
//实际测试中发现，这个gBufferSizeBytes=0x10000;对于压缩的音频格式(mp3/aac等)没有任何问题，但是如果输入的音频文件格式是wav，会出现只播放几秒便暂停的现象；而手机又不可能去申请更大的内存去处理wav文件，不知到大家能有什么好的方法给点建议
static UInt32 gBufferSizeBytes=0x10000;//It muse be pow(2,x)
@implementation playAudio

@synthesize queue;

//回调函数(Callback)的实现
static void BufferCallback(void *inUserData,AudioQueueRef inAQ,
                           AudioQueueBufferRef buffer){
    playAudio* player=(__bridge playAudio*)inUserData;
    [player audioQueueOutputWithQueue:inAQ queueBuffer:buffer];
}


//缓存数据读取方法的实现
-(void) audioQueueOutputWithQueue:(AudioQueueRef)audioQueue queueBuffer:(AudioQueueBufferRef)audioQueueBuffer{
    OSStatus status;
    
    //读取包数据
    UInt32 numBytes;
    UInt32 numPackets=numPacketsToRead;
    status = AudioFileReadPackets(audioFile, NO, &numBytes, packetDescs, packetIndex,&numPackets, audioQueueBuffer->mAudioData);
    
    //成功读取时
    if (numPackets>0) {
        //将缓冲的容量设置为与读取的音频数据一样大小(确保内存空间)
        audioQueueBuffer->mAudioDataByteSize=numBytes;
        //完成给队列配置缓存的处理
        status = AudioQueueEnqueueBuffer(audioQueue, audioQueueBuffer, numPackets, packetDescs);
        //移动包的位置
        packetIndex += numPackets;
    }
}

//音频播放的初始化、实现
//在ViewController中声明一个PlayAudio对象，并用下面的方法来初始化
//self.audio=[[playAudioalloc]initWithAudio:@"/Users/xuanyuanchen/audio/daolang.mp3"];


-(id) initWithAudio:(NSString *)path{
    if (!(self=[super init])) return nil;
    UInt32 size,maxPacketSize;
    char *cookie;
    int i;
    OSStatus status;
    
    //打开音频文件
    status=AudioFileOpenURL((CFURLRef)[NSURL fileURLWithPath:path], kAudioFileReadPermission, 0, &audioFile);
    if (status != noErr) {
        //错误处理
        NSLog(@"*** Error *** PlayAudio - play:Path: could not open audio file. Path given was: %@", path);
        return nil;
    }
    
    for (int i=0; i<NUM_BUFFERS; i++) {
        AudioQueueEnqueueBuffer(queue, buffers[i], 0, nil);
    }
    
    //取得音频数据格式
    size = sizeof(dataFormat);
    AudioFileGetProperty(audioFile, kAudioFilePropertyDataFormat, &size, &dataFormat);
    
    //创建播放用的音频队列
    AudioQueueNewOutput(&dataFormat, BufferCallback, self,
                        nil, nil, 0, &queue);
    //计算单位时间包含的包数
    if (dataFormat.mBytesPerPacket==0 || dataFormat.mFramesPerPacket==0) {
        size=sizeof(maxPacketSize);
        AudioFileGetProperty(audioFile, kAudioFilePropertyPacketSizeUpperBound, &size, &maxPacketSize);
        if (maxPacketSize > gBufferSizeBytes) {
            maxPacketSize= gBufferSizeBytes;
        }
        //算出单位时间内含有的包数
        numPacketsToRead = gBufferSizeBytes/maxPacketSize;
        packetDescs=malloc(sizeof(AudioStreamPacketDescription)*numPacketsToRead);
    }else {
        numPacketsToRead= gBufferSizeBytes/dataFormat.mBytesPerPacket;
        packetDescs=nil;
    }
    
    //设置Magic Cookie，参见第二十七章的相关介绍
    AudioFileGetProperty(audioFile, kAudioFilePropertyMagicCookieData, &size, nil);
    if (size >0) {
        cookie=malloc(sizeof(char)*size);
        AudioFileGetProperty(audioFile, kAudioFilePropertyMagicCookieData, &size, cookie);
        AudioQueueSetProperty(queue, kAudioQueueProperty_MagicCookie, cookie, size);
    }
    
    //创建并分配缓冲空间
    packetIndex=0;
    for (i=0; i<NUM_BUFFERS; i++) {
        AudioQueueAllocateBuffer(queue, gBufferSizeBytes, &buffers[i]);
        //读取包数据
        if ([self readPacketsIntoBuffer:buffers[i]]==1) {
            break;
        }
    }
    
    Float32 gain=1.0;
    //设置音量
    AudioQueueSetParameter(queue, kAudioQueueParam_Volume, gain);
    //队列处理开始，此后系统开始自动调用回调(Callback)函数
    AudioQueueStart(queue, nil);
    return self;
}

-(UInt32)readPacketsIntoBuffer:(AudioQueueBufferRef)buffer {
    UInt32 numBytes,numPackets;
    
    //从文件中接受数据并保存到缓存(buffer)中
    numPackets = numPacketsToRead;
    AudioFileReadPackets(audioFile, NO, &numBytes, packetDescs, packetIndex, &numPackets, buffer->mAudioData);
    if(numPackets >0){
        buffer->mAudioDataByteSize=numBytes;
        AudioQueueEnqueueBuffer(queue, buffer, (packetDescs ? numPackets : 0), packetDescs);
        packetIndex += numPackets;
    }
    else{
        return 1;//意味着我们没有读到任何的包
    }
    return 0;//0代表正常的退出
}
@end

2.录音

（1.）record.h

 

static const int kNumberBuffers = 3;

#import <AudioToolbox/AudioToolbox.h>
#import <Foundation/Foundation.h>
#import <AVFoundation/AVFoundation.h>

@interface Record : NSObject<AVAudioPlayerDelegate>

{
    AudioStreamBasicDescription  mDataFormat;                  
    AudioQueueRef                mQueue;                        
    AudioQueueBufferRef          mBuffers[kNumberBuffers];
    UInt32                       bufferByteSize;
    
    AVAudioPlayer *player;
    
}

@property(nonatomic,assign) bool   mIsRunning;
@property(nonatomic,retain) NSMutableData* recordData;



-(void)record;
-(void)stop;
-(void)play;
-(void)pause;

-(void)dealWithData:(NSData*)data;



@end


（2.）record.m

 

#import "Record.h"


@implementation Record

@synthesize mIsRunning = _mIsRunning;
@synthesize recordData =_recordData;

-(id)init
{
    self = [super init];
    if (self) {
        
        AudioSessionInitialize(NULL, NULL, NULL, (__bridge void*)self);
       // self.recordData =[NSMutableData data];
        self.mIsRunning=false;

    }
   return self;
}

static void HandleInputBuffer (
                               void                                 *inUserData,
                               AudioQueueRef                        inAQ,
                               AudioQueueBufferRef                  inBuffer,
                               const AudioTimeStamp                 *inStartTime,
                               UInt32                               inNumPackets,
                               const AudioStreamPacketDescription   *inPacketDesc
                               ) {
    
    Record *recorderPro = (__bridge Record *)inUserData;
    if (inNumPackets > 0 && recorderPro.mIsRunning){
        
        int pcmSize = inBuffer->mAudioDataByteSize;
        char *pcmData = (char *)inBuffer->mAudioData;
        NSData *data = [[NSData alloc] initWithBytes:pcmData length:pcmSize];
        [recorderPro dealWithData:data];
        
      //  [recorderPro.recordData appendData:data];
        AudioQueueEnqueueBuffer(inAQ, inBuffer, 0, NULL);
    }
}

void DeriveBufferSize (
                       AudioQueueRef                audioQueue,                  
                       AudioStreamBasicDescription  &ASBDescription,             
                       Float64                      seconds,                     
                       UInt32                       *outBufferSize               
                       ) {
    static const int maxBufferSize = 0x50000;                 
    
    int maxPacketSize = ASBDescription.mBytesPerPacket;       
    if (maxPacketSize == 0) {                                 
        UInt32 maxVBRPacketSize = sizeof(maxPacketSize);
        AudioQueueGetProperty (
                               audioQueue,
                               kAudioQueueProperty_MaximumOutputPacketSize,
                               &maxPacketSize,
                               &maxVBRPacketSize
                               );
    }
    
    Float64 numBytesForTime =
    ASBDescription.mSampleRate * maxPacketSize * seconds;
    *outBufferSize =
    UInt32 (numBytesForTime < maxBufferSize ?
            numBytesForTime : maxBufferSize);                    
}


-(void)dealWithData:(NSData*)data
{
    [self changeVoice:data];
}



-(void)changeVoice:(NSData*)audioData
{
    soundtouch::SoundTouch mSoundTouch;
    mSoundTouch.setSampleRate(16000);
    mSoundTouch.setChannels(1);
    mSoundTouch.setTempoChange(0.05);
    mSoundTouch.setPitchSemiTones(12);
    mSoundTouch.setRateChange(-0.7);
    mSoundTouch.setSetting(SETTING_SEQUENCE_MS, 40);
    mSoundTouch.setSetting(SETTING_SEEKWINDOW_MS, 16);
    mSoundTouch.setSetting(SETTING_OVERLAP_MS, 8);
    
    if (audioData != nil) {
        
        char *pcmData = (char *)audioData.bytes;
        int pcmSize = audioData.length;
        int nSamples = pcmSize / 2;
        mSoundTouch.putSamples((short *)pcmData, nSamples);
        short *samples = new short[pcmSize];
        int numSamples = 0;
        do {
            memset(samples, 0, pcmSize);
            numSamples = mSoundTouch.receiveSamples(samples, pcmSize);
            [self.recordData appendBytes:samples length:numSamples*2];
            
        } while (numSamples > 0);
        delete [] samples;
    }
    NSLog(@"-------recording%d",self.recordData.length);
}



- (void) setupAudioFormat:(UInt32) inFormatID SampleRate:(int) sampeleRate
{
    memset(&mDataFormat, 0, sizeof(mDataFormat));
    mDataFormat.mSampleRate = sampeleRate;
    
    //UInt32 size = sizeof(mDataFormat.mChannelsPerFrame);
    //AudioSessionGetProperty(kAudioSessionProperty_CurrentHardwareInputNumberChannels, &size, &mDataFormat.mChannelsPerFrame);
    mDataFormat.mChannelsPerFrame=1;
    mDataFormat.mFormatID = inFormatID;
    
    if (inFormatID == kAudioFormatLinearPCM){
        // if we want pcm, default to signed 16-bit little-endian
        mDataFormat.mFormatFlags = kLinearPCMFormatFlagIsSignedInteger | kLinearPCMFormatFlagIsPacked;
        mDataFormat.mBitsPerChannel = 16;
        mDataFormat.mBytesPerPacket = mDataFormat.mBytesPerFrame = (mDataFormat.mBitsPerChannel / 8) * mDataFormat.mChannelsPerFrame;
        mDataFormat.mFramesPerPacket = 1;
    }
}

-(void)record
{
    self.recordData = [NSMutableData data];
    
    AudioSessionSetActive(true);
    
    // category
    UInt32 category = kAudioSessionCategory_PlayAndRecord;
    AudioSessionSetProperty(kAudioSessionProperty_AudioCategory, sizeof(category), &category);
    
    // format
    [self setupAudioFormat:kAudioFormatLinearPCM SampleRate:16000];

    DeriveBufferSize (mQueue,mDataFormat,0.5,&bufferByteSize);
    
    // 设置回调函数
    AudioQueueNewInput(&mDataFormat, HandleInputBuffer, (__bridge void*)self, NULL, NULL, 0, &mQueue);
    
    for (int i = 0; i < kNumberBuffers; ++i) {           
        AudioQueueAllocateBuffer (mQueue,bufferByteSize,&mBuffers[i]);
        AudioQueueEnqueueBuffer (mQueue,mBuffers[i],0,NULL);
    }
    
    
    // 开始录音
    AudioQueueStart(mQueue, NULL);
    self. mIsRunning= YES;
}


-(void)stop
{
    
    AudioQueueFlush(mQueue);
    AudioQueueStop (mQueue,true);
    
    NSMutableData *wavDatas = [[NSMutableData alloc] init];
    int fileLength = self.recordData.length;
    void *header = createWaveHeader(fileLength, 1, 16000, 16);
    [wavDatas appendBytes:header length:44];
    [wavDatas appendData:self.recordData];
    self.recordData = wavDatas;
    
    
    NSLog(@"-------stop%d",self.recordData.length);
    
  //  NSString *path = [NSSearchPathForDirectoriesInDomains(NSDocumentDirectory, NSUserDomainMask, YES) objectAtIndex:0];
  //  NSString *filePath = [path stringByAppendingPathComponent:@"soundtouch.wav"];
  //  [wavDatas writeToFile:filePath atomically:YES];
    
    
    self.mIsRunning = false;
}

-(void)play
{
 
    NSError *playerError;
    
    
    
    player = [[AVAudioPlayer alloc] initWithData:self.recordData error:&playerError];
    
  //  NSString *path = [NSSearchPathForDirectoriesInDomains(NSDocumentDirectory, NSUserDomainMask, YES) objectAtIndex:0];
  //  NSString *filePath = [path stringByAppendingPathComponent:@"soundtouch.wav"];
    
    
    // player = [[AVAudioPlayer alloc] initWithContentsOfURL:recordedFile error:&playerError];
    //  player = [[AVAudioPlayer alloc] initWithContentsOfURL:[NSURL fileURLWithPath:filePath] error:&playerError];
    if (player == nil)
    {
        NSLog(@"ERror creating player: %@", [playerError description]);
    }
    player.delegate = self;

    if(![player isPlaying]) {
        [player play];
    }
}

-(void)pause
{
    if ([player isPlaying]) {
        [player pause];
    }
}


- (void)audioPlayerDidFinishPlaying:(AVAudioPlayer *)player successfully:(BOOL)flag
{
    NSLog(@"%@",@"audioPlayerDidFinishPlaying");
}

@end

Kingsley_Chen
关注
专栏目录
【SpringBoot】43、SpringBoot中整合RabbitMQ实现延时队列（延时插件篇）
Asurplus
02-21 21万+
一、介绍 1、什么是延时队列？ 延时队列即就是放置在该队列里面的消息是不需要立即消费的，而是等待一段时间之后取出消费 2、适用场景 （1）商城订单超时未支付，取消订单 （2）使用权限到期前十分钟提醒用户 （3）收益项目，投入后一段时间后产生收益 二、实现方式 从以上场景中，我们可以看出，延时队列的主要功能就是在指定的时间之后做指定的事情，那么，我们思考有哪些工具我们可以使用？ 1、Redis 监听过期 Key 可以参考我的博客【SpringBoot】三十五、SpringBoot整合Redis监听Ke
《数据结构初阶》用队列实现栈&&用栈实现队列的细致解析
m0_62171658的博客
03-29 4157
《数据结构初阶》用队列实现栈&&用栈实现队列的细致解析
Audio Queue示例Demo亲测可用Xcode9
08-29
iOS 网络音频加载方式使用audio queue services ，参考官方文档https://developer.apple.com/library/mac/#documentation/MusicAudio/Conceptual/AudioQueueProgrammingGuide/AboutAudioQueues/AboutAudioQueues.html#//apple_ref/doc/uid/TP40005343-CH5-SW1
iOS通过audio queue 进行录制和播放音频
07-24
通过audio queue 进行音频的录制和播放功能
AudioQueue 播放和录音
呆萌院长
08-12 2953
http://blog.sina.com.cn/s/blog_7e6698f401015b84.html 1.播放：（声明：转载自http://www.cnblogs.com/xuanyuanchen/） 最近在做iphone上的流媒体播放，需要用到播放音频流，参考了好多博客、网站，最终算是把这个比较难弄的问题解决了。 这篇文章是播放音频文件的，我会专门用一篇文章来介绍如
队列存储音频数据_数据结构 队列（链式存储，C实现）
weixin_34409903的博客
01-24 265
1. 概述在《数据结构·队列(顺序存储)》一文中，已详细讲解了队列的特性以及使用数组来实现队列的基本操作。队列也是属于线性表，因此，它也支持使用链表的方式来实现其先进先出(FIFO)特性。本文主要描述如何使用链式存储结构来模拟实现队列(包括循环队列链表)。使用链式存储结构的好处是，入队列节点元素不受客观约束限制，只要内存空间足够，就可以无限制的动态申请内存地址空间。但是它也存在缺点，比如...
音频队列播放(二)
流浪的三毛的博客
05-27 852
下面是我的一些总结:(这里只有播放音乐的部分) static const int kNumberBuffers = 3; // 1 typedef struct AQPlayerState { AudioStreamBasicDescription mDataFormat; // 2
iOS 音频队列录音
08-15
1. 在初始化方法中，设置音频会话、创建音频队列和配置格式。 2. 开始录音时，启动音频队列并打开录音文件。 3. 暂停录音时，保存当前缓冲区状态，并停止音频队列。 4. 恢复录音时，重新启动音频队列并继续写入文件...
利用栈和队列实现简单的四则运算
我是传奇
05-04 3575
一、介绍 简单的四则运算，只是包含整数和加减乘除和左右括号的运算。 利用队列先进先出的特性，存储整个运算公式各个元素。 利用栈后进先出的特性，存储数字和运算符 二、过程 1.整个运算公式的各个元素入队列。 2.队列中的元素出栈 1）如果是数字，进入数字栈，再次队伍元素出队。 这里插入左右括号的处理。 如果是左括号符号，该左括号入符号栈，再次队列元素出队。 如果是右括号符号，就需要不断将符号栈中的元...
C真正的实现录音功能
08-25
本文主要讲述了使用C#语言和DirectSound技术来实现录音功能的过程。录音功能是计算机多媒体应用中非常重要的一部分，它涉及到音频信号的采集、处理和存储等多方面的技术。 一、录音设备和缓冲区 要实现录音功能，...
vc 同时录音和播放录音的多线程程序
08-09
vc 同时录音和播放录音的多线程程序，对多线程、线程同步会有更好的理解！
iOS 音视频采集以及写入文件(swift)
glt_code的博客
07-16 1817
iOS音视频采集以及写入文件
实现KTV效果：播放歌曲，录音（存储录音文件），并同步播放录音 & 解释4.3以上audio与media资源冲突问题
duguju的博客
09-06 3301
很多唱歌类型的APP（比如唱吧），都在寻求实现好的用户体验，其中一个就是能够一边边播放歌曲一边唱（声音会被录下来），有人便想进一步实现播放录的声音（就像拿着麦克风唱歌的感觉，自己可以听见自己的声音）具体实现方案是：MediaPlayer播放音乐，MediaRecorder录音并保存； AudioTrack和AudioRecord两个配合实现实时语音流的记录和同步播放 但是唱吧并没有实现“可以听见自己唱歌的声音”的效果，经过尝试、研究发现，原来android4.3（API18）以上不支持MediaRecord
Audio Queue 音频处理
tianjiqcs的专栏
03-01 1227
Audio Queue来实时录音，边录音边转码,它是AudioToolbox库里的 一个音频服务队列Audio Queue有三部分组成： 三个缓冲器Buffers:每个缓冲器都是一个存储音频数据的临时仓库。 一个缓冲队列Buffer Queue:一个包含音频缓冲器的有序队列。 一个回调Callback:一个自定义的队列回调函数。 声音通过输
ios开发之使用AudioQueue进行音频的播放
成都IOS小牛的博客
10-16 2598
前几天钻研IOS音频技术的时候接触到了AudioUnit与AudioQueue两个系统的播放库,前面一个博客写了关于AudioUnit的使用方法，这次发一篇关于AudioQueue的使用方法，AudioQueue的使用相对于AudioUnit来说比较简单一点，可以直接定义目标buffer的大小，对于一般的音频数据的处理没有任何问题，下面贴出一个自己写的AudioQueue的播放器的代码
iOS音频播放 (五)：AudioQueue 转
热门推荐
孙启超
08-13 2万+
原文出处 ： http://msching.github.io/blog/2014/08/02/audio-in-ios-5/ 前言 在第三篇和第四篇中介绍了如何用AudioStreamFile和AudioFile解析音频数据格式、分离音频帧。下一步终于可以使用分离出来的音频帧进行播放了，本片中将来讲一讲如何使用AudioQueue播放音频数据。 AudioQ
iOS ogg音频播放 AudioQueue播放速度
cdp1992127的博客
04-30 1114
在iOS中播放音频一般情况下都是使用AVPlayer，很方便，也能满足大部分使用情况。但是如果需要播放的音频是ogg格式的，AVPlayer就基本没有办法播放，因为iOS目前是不支持直接播放ogg格式的音频的，想要播放需要靠AudioQueue的帮助。 我现在用的是IDZAQAudioPlayer，作者是基于AudioQueue实现的音频播放，具体代码可以去GitHub上搜索。虽然原作者有几个年头没有更新了，并且代码内部的判断逻辑也有个别地方不够严谨，不过我自己补充了一些判断逻辑之后，基本上满足了目前公司
Audio Queue录制 播放原理
weixin_33932129的博客
05-03 388
阅读前提: C语言基础 音视频基础 Core Audio基本数据结构 Audio Session Audio Queue Services是官方推荐的方式以一种直接的,低开销的方式在iOS与Mac OS X中完成录制与播放的操作.不像上层的API,它可以通过回调拿到音频帧数据,以完成更加精细的操作. 使用场景: 比上层API而言,可以直接获取每一帧音频数据,因此可以对音频帧做一些需要的处理. ...
栈和队列操作实现
"该资源是关于栈和队列的数据结构练习，包含C语言实现的代码，涉及栈的入栈、出栈以及队列的入队、出队等基本操作。" 在计算机科学中，栈（Stack）和队列（Queue）是两种基本的数据结构，它们在处理数据时遵循特定...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值