AAC编解码

AAC编码可以使用faac

/**
 初始化
 
 @param sampleRate 音频采样率
 @param channels   通道数
 @param bitSize    音频采样精度 16
 */
- (void)initWithSampleRate:(int)sampleRate channels:(int)channels bitSize:(int)bitSize
{
    nSampleRate = sampleRate;
    nChannels = channels;
    nPCMBitSize = bitSize;
 
    hEncoder = faacEncOpen(nSampleRate,nChannels,&nInputSamples,&nMaxOutputBytes);
    if(hEncoder == NULL)
    {
        error = -;
    }
    int pcmBufSize = (int)(nInputSamples*(nPCMBitSize/)); // 固定计算方式
    pcmBuf = (unsigned char *)malloc(pcmBufSize * sizeof(unsigned char)); // pcmBufSize* 1个字节
    memset(pcmBuf,,pcmBufSize);
    aacBuf = (unsigned char *)malloc(nMaxOutputBytes * sizeof(unsigned char));
    memset(aacBuf,,nMaxOutputBytes);
 
    faacEncConfigurationPtr config = faacEncGetCurrentConfiguration(hEncoder);
    config->aacObjectType = LOW;            //LC编码 编码类型
    config->inputFormat = FAAC_INPUT_16BIT; //输入数据类型
    config->outputFormat = ;               //录制MP4文件时，0要用raw流; 1是ADTS
    int ret = faacEncSetConfiguration(hEncoder, config);
    if (ret < ) {
        error = -;
    }
}
/**
 编码
 
 @param data     pcm
 @param dataSize 长度
 */
-(void)encoderWithData:(unsigned char *)data dataSize:(int)dataSize
{
    if (error<) {
        return;
    }
 
    // 2048 4096
    int pcmBufSize = (int)(nInputSamples*(nPCMBitSize/)); // 固定计算方式
 
    if(data == NULL||dataSize<=|| dataSize > pcmBufSize){
        NSLog(@"error:dataSize大于填充大小");
        return;
    }
 
    int copyLength = ;
 
    if(remainBufSize > dataSize){
        copyLength = dataSize;
    }
    else{
        copyLength = remainBufSize;
    }
    memcpy((&pcmBuf[]) + remainWriteSize,data,copyLength);
 
    remainBufSize -= copyLength;
    remainWriteSize += copyLength;
 
    if(remainBufSize > ){
        return;
    }
    int ret  = faacEncEncode(hEncoder,(int*)(pcmBuf),(unsigned int)nInputSamples,aacBuf,(unsigned int)nMaxOutputBytes);
    if (ret<) {
        return;
    }
    if ([self.delegate respondsToSelector:@selector(AACEncoderData:dataSize:)]) {
        if (ret>) {
             [self.delegate AACEncoderData:aacBuf dataSize:ret];
        }
 
    }
 
    memset(pcmBuf, , pcmBufSize);
    remainWriteSize = ;
    remainBufSize = pcmBufSize;
    if((dataSize - copyLength) >  ){
        memcpy((&pcmBuf[]), data+copyLength, dataSize - copyLength);
        remainWriteSize = dataSize - copyLength;   // 已经填了多少
        remainBufSize = pcmBufSize - (dataSize - copyLength); // 还差多少填满 2048
    }
}

AAC解码可以使用faad

@implementation AACDecoder
- (instancetype)init
{
    self = [super init];
    if (self) {
        decoder = NeAACDecOpen();
        samplerate = ;
        channels = ;
        pcmData = NULL;
        size = ;
    }
    return self;
}
/**
 解码
 
 @param data     aac
 @param dataSize 长度
 */
-(void)decoderWithData:(unsigned char *)data dataSize:(int)dataSize
{
    if (!loaded) {
 
        if(getOneADTSFrame(data, dataSize, frame, &size)== )
        {
            NeAACDecInit(decoder, frame, size, &samplerate, &channels);
            printf("samplerate %lu, channels %d\n", samplerate, channels);
            loaded = YES;
        }
    }
    while(getOneADTSFrame(data,dataSize,frame,&size) == )
    {
        pcmData = (unsigned char*)NeAACDecDecode(decoder, &frameInfo,frame,size);
        if(frameInfo.error > )
        {
            printf("%s\n",NeAACDecGetErrorMessage(frameInfo.error));
 
        }
        else if(pcmData && frameInfo.samples > )
        {
            printf("frame info: bytesconsumed %lu, channels %d, header_type %d\
                   object_type %d, samples %lu, samplerate %lu\n",
                   frameInfo.bytesconsumed,
                   frameInfo.channels, frameInfo.header_type,
                   frameInfo.object_type, frameInfo.samples,
                   frameInfo.samplerate);
 
            if ([self.delegate respondsToSelector:@selector(AACDcoderData:dataSize:)]) {
                [self.delegate AACDcoderData:pcmData dataSize:(int)(frameInfo.samples * frameInfo.channels)];
            }
        }
        dataSize -= size;
        data += size;
    }
    if ([self.delegate respondsToSelector:@selector(AACDcoderEnd)]) {
        [self.delegate AACDcoderEnd];
    }
 
}
 
- (void)dealloc
{
    NeAACDecClose(decoder);
}
/**
 * fetch one ADTS frame  获取一个ADTS Frame
 */
int getOneADTSFrame(unsigned char* buffer, size_t buf_size, unsigned char* data ,size_t* data_size)
{
    size_t size = ;
 
    if(!buffer || !data || !data_size )
    {
        return -;
    }
 
    while()
    {
        if(buf_size  <  )
        {
            return -;
        }
 
        if((buffer[] == 0xff) && ((buffer[] & 0xf0) == 0xf0) )
        {
            size |= ((buffer[] & 0x03) <<);     //high 2 bit
            size |= buffer[]<<;                //middle 8 bit
            size |= ((buffer[] & 0xe0)>>);        //low 3bit
            break;
        }
        --buf_size;
        ++buffer;
    }
 
    if(buf_size < size)
    {
        return -;
    }
 
    memcpy(data, buffer, size);
    *data_size = size;
 
    return ;
}