kCVPixelFormatType_420YpCbCr8BiPlanarVideoRange = '420v', 
/* Bi-Planar Component Y'CbCr 8-bit 4:2:0, video-range (luma=[16,235] chroma=[16,240]).  baseAddr points to a big-endian CVPlanarPixelBufferInfo_YCbCrBiPlanar struct */
  
kCVPixelFormatType_420YpCbCr8BiPlanarFullRange  = '420f', 
/* Bi-Planar Component Y'CbCr 8-bit 4:2:0, full-range (luma=[0,255] chroma=[1,255]).  baseAddr points to a big-endian CVPlanarPixelBufferInfo_YCbCrBiPlanar struct */

// BT.601, which is the standard for SDTV.
GLfloat kColorConversion601Default[] = {
    1.164,  1.164, 1.164,
     0.0,  -0.392, 2.017,
    1.596, -0.813,  0.0,
};

// BT.601 full range 
GLfloat kColorConversion601FullRangeDefault[] = {
    1.0,   1.0,   1.0,
    0.0, -0.343, 1.765,
    1.4, -0.711,  0.0,
};

// BT.709, which is the standard for HDTV.
GLfloat kColorConversion709Default[] = {
    1.164,  1.164, 1.164,
     0.0,  -0.213, 2.112,
    1.793, -0.533,  0.0,
};

#import "BBAudioCapture.h"
#import <AVFoundation/AVFoundation.h>
#import "BBAudioConfig.h"
#import "BBAudioHardEncoder.h"
#import "BBAudioHardEncoder.h"

@interface BBAudioCapture ()
{
    AudioComponentInstance _outInstance;
}
@property (nonatomic, assign) AudioComponent        component;
@property (nonatomic, strong) AVAudioSession        *session;
@property (nonatomic, strong) BBAudioHardEncoder    *encoder;
@property (nonatomic, strong) NSFileHandle          *handle;
@end

@implementation BBAudioCapture

#pragma mark -- 对象销毁方法
- (void)dealloc{
    AudioComponentInstanceDispose(_outInstance);
}

#pragma mark -- 对外API（控制是否捕捉音频数据）
- (void)startRunning{
    AudioOutputUnitStart(_outInstance);
}

-(void)stopRunning{
    AudioOutputUnitStop(_outInstance);
}

#pragma mark -- 对外API（设置捕获音频数据配置项）
- (void)setConfig:(BBAudioConfig *)config{
    _config = config;
    [self private_setupAudioSession];
}

#pragma mark -- 私有API（初始化音频会话）
- (void)private_setupAudioSession{

    //0.初始化编码器
    self.encoder = [[BBAudioHardEncoder alloc] init];
    self.encoder.config = self.config;

    //1.获取音频会话实例
    self.session = [AVAudioSession sharedInstance];

    NSError *error = nil;
    [self.session setCategory:AVAudioSessionCategoryPlayAndRecord withOptions:AVAudioSessionCategoryOptionMixWithOthers | AVAudioSessionCategoryOptionDefaultToSpeaker error:&error];

    if (error) {
        NSLog(@"AVAudioSession setupError");
        error = nil;
        return;
    }

    //2.激活会话
    [self.session setActive:YES error:&error];

    if (error) {
        NSLog(@"AVAudioSession setActiveError");
        error = nil;
        return;
    }

    //3.设置模式
    [self.session setMode:AVAudioSessionModeVideoRecording error:&error];

    if (error) {
        NSLog(@"AVAudioSession setModeError");
        error = nil;
        return;
    }

    //4.设置音频单元
    AudioComponentDescription acd = {
        .componentType = kAudioUnitType_Output,
        .componentSubType = kAudioUnitSubType_RemoteIO,
        .componentManufacturer = kAudioUnitManufacturer_Apple,
        .componentFlags = 0,
        .componentFlagsMask = 0,
    };

    //5.查找音频单元
    self.component = AudioComponentFindNext(NULL, &acd);

    //6.获取音频单元实例
    OSStatus status = AudioComponentInstanceNew(self.component, &_outInstance);

    if (status != noErr) {
        NSLog(@"AudioSource new AudioComponent error");
        status = noErr;
        return;
    }

    //7.设置音频单元属性-->可读写 0-->不可读写 1-->可读写
    UInt32 flagOne = 1;
    AudioUnitSetProperty(_outInstance, kAudioOutputUnitProperty_EnableIO, kAudioUnitScope_Input, 1, &flagOne, sizeof(flagOne));

    //8.设置音频单元属性-->音频流
    AudioStreamBasicDescription asbd = {0};
    asbd.mSampleRate = self.config.sampleRate;//采样率
    asbd.mFormatID = kAudioFormatLinearPCM;//原始数据为PCM格式
    asbd.mFormatFlags = kAudioFormatFlagIsSignedInteger | kAudioFormatFlagsNativeEndian | kAudioFormatFlagIsPacked;
    asbd.mChannelsPerFrame = (UInt32)self.config.channels;//每帧的声道数量
    asbd.mFramesPerPacket = 1;//每个数据包多少帧
    asbd.mBitsPerChannel = 16;//16位
    asbd.mBytesPerFrame = asbd.mChannelsPerFrame * asbd.mBitsPerChannel / 8;//每帧多少字节 bytes -> bit / 8
    asbd.mBytesPerPacket = asbd.mFramesPerPacket * asbd.mBytesPerFrame;//每个包多少字节

    status = AudioUnitSetProperty(_outInstance, kAudioUnitProperty_StreamFormat, kAudioUnitScope_Output, 1, &asbd, sizeof(asbd));

    if (status != noErr) {
        NSLog(@"AudioUnitSetProperty StreamFormat error");
        status = noErr;
        return;
    }

    //9.设置回调函数
    AURenderCallbackStruct cb;
    cb.inputProcRefCon = (__bridge void *)self;
    cb.inputProc = audioBufferCallBack;

    status = AudioUnitSetProperty(_outInstance, kAudioOutputUnitProperty_SetInputCallback, kAudioUnitScope_Global, 1, &cb, sizeof(cb));

    if(status != noErr){
        NSLog(@"AudioUnitSetProperty StreamFormat InputCallback error");
        status = noErr;
        return;
    }

    //10.初始化音频单元
    status = AudioUnitInitialize(_outInstance);

    if (status != noErr) {
        NSLog(@"AudioUnitInitialize error");
        status = noErr;
        return;
    }

    //11.设置优先采样率
    [self.session setPreferredSampleRate:self.config.sampleRate error:&error];

    if (error) {
        NSLog(@"AudioSource setPreferredSampleRate error");
        error = nil;
        return;
    }

    //12.aac文件夹地址
    NSString *audioPath = [[NSSearchPathForDirectoriesInDomains(NSDocumentDirectory, NSUserDomainMask, YES) lastObject] stringByAppendingPathComponent:@"test.aac"];
    [[NSFileManager defaultManager] removeItemAtPath:audioPath error:nil];
    [[NSFileManager defaultManager] createFileAtPath:audioPath contents:nil attributes:nil];
    self.handle = [NSFileHandle fileHandleForWritingAtPath:audioPath];

}

#pragma mark -- 音频流回调函数
static OSStatus audioBufferCallBack(void *inRefCon,
AudioUnitRenderActionFlags *ioActionFlags,
const AudioTimeStamp *inTimeStamp,
UInt32 inBusNumber,
UInt32 inNumberFrames,
AudioBufferList *ioData) {
    @autoreleasepool {
        BBAudioCapture *capture = (__bridge BBAudioCapture *)inRefCon;
        if(!capture) return -1;

        AudioBuffer buffer;
        buffer.mData = NULL;
        buffer.mDataByteSize = 0;
        buffer.mNumberChannels = 1;

        AudioBufferList buffers;
        buffers.mNumberBuffers = 1;
        buffers.mBuffers[0] = buffer;

        OSStatus status = AudioUnitRender(capture->_outInstance,
        ioActionFlags,
        inTimeStamp,
        inBusNumber,
        inNumberFrames,
        &buffers);

        if(status == noErr) {
            [capture.encoder encodeWithBufferList:buffers completianBlock:^(NSData *encodedData, NSError *error) {
                if (error) {
                    NSLog(@"error:%@",error);
                    return;
                }

            NSLog(@"write to file!");
            [capture.handle writeData:encodedData];
            }];
        }
        return status;
    }
}

@end

#import "BBAudioHardEncoder.h"
#import "BBAudioConfig.h"

@interface BBAudioHardEncoder ()
@property (nonatomic, assign) AudioConverterRef converterRef;
@end
@implementation BBAudioHardEncoder

- (AudioConverterRef)converterRef{
    if (_converterRef == nil) {
        [self private_setupAudioConvert];
    }
    return _converterRef;
}

- (void)dealloc {
    AudioConverterDispose(_converterRef);
}

- (void)private_setupAudioConvert{

    //1.输入流
    AudioStreamBasicDescription inputFormat = {0};
    inputFormat.mSampleRate = self.config.sampleRate;//采样率
    inputFormat.mFormatID = kAudioFormatLinearPCM;//PCM采样
    inputFormat.mFormatFlags = kAudioFormatFlagIsSignedInteger | kAudioFormatFlagsNativeEndian | kAudioFormatFlagIsPacked;
    inputFormat.mChannelsPerFrame = (UInt32)self.config.channels;//每帧声道数
    inputFormat.mFramesPerPacket = 1;//每包帧数
    inputFormat.mBitsPerChannel = 16;//每声道位数
    inputFormat.mBytesPerFrame = inputFormat.mBitsPerChannel / 8 * inputFormat.mChannelsPerFrame;//每帧的字节数
    inputFormat.mBytesPerPacket = inputFormat.mBytesPerFrame * inputFormat.mFramesPerPacket;//每包字节数

    //2.输出流
    AudioStreamBasicDescription outputFormat;
    //2.1初始清零
    memset(&outputFormat, 0, sizeof(outputFormat));
    //2.2音频流，在正常播放情况下的帧率。如果是压缩的格式，这个属性表示解压缩后的帧率。帧率不能为0。
    outputFormat.mSampleRate       = inputFormat.mSampleRate;
    //2.3AAC编码 kAudioFormatMPEG4AAC kAudioFormatMPEG4AAC_HE_V2
    outputFormat.mFormatID         = kAudioFormatMPEG4AAC;
    //2.4无损编码，0则无
    outputFormat.mFormatFlags      = kMPEG4Object_AAC_LC;
    //2.5每一个packet的音频数据大小。如果的动态大小设置为0。动态大小的格式需要用AudioStreamPacketDescription来确定每个packet的大小。
    outputFormat.mBytesPerPacket   = 0;
    //2.6每帧的声道数
    outputFormat.mChannelsPerFrame = (UInt32)self.config.channels;
    //2.7每个packet的帧数。如果是未压缩的音频数据，值是1。动态帧率格式，这个值是一个较大的固定数字，比如说AAC的1024。如果是动态大小帧数（比如Ogg格式）设置为0。
    outputFormat.mFramesPerPacket  = 1024;
    //2.8每帧的bytes数，每帧的大小。每一帧的起始点到下一帧的起始点。如果是压缩格式，设置为0 。
    outputFormat.mBytesPerFrame = 0;
    //2.9语音每采样点占用位数 压缩格式设置为0
    outputFormat.mBitsPerChannel = 0;
    //2.10字节对齐，填0.
    outputFormat.mReserved = 0;

    //3.编码器参数
    const OSType subtype = kAudioFormatMPEG4AAC;
    AudioClassDescription requestedCodecs[2] = {
        {
            kAudioEncoderComponentType,
            subtype,
            kAppleSoftwareAudioCodecManufacturer
        },
        {
            kAudioEncoderComponentType,
            subtype,
            kAppleHardwareAudioCodecManufacturer
        }
    };

    //4.编码器
    OSStatus result = AudioConverterNewSpecific(&inputFormat, &outputFormat, 2, requestedCodecs, &_converterRef);

    if (result == noErr) {
        NSLog(@"creat convert success!");
    }else{
        NSLog(@"creat convert error!");
        _converterRef = nil;
    }

}

- (void)encodeWithBufferList:(AudioBufferList)bufferList completianBlock:(void (^)(NSData *encodedData, NSError *error))completionBlock{
    if (!self.converterRef) {
        return;
    }
    int size = bufferList.mBuffers[0].mDataByteSize;

    if (size <= 0) {
        return;
    }

    char *aacBuf = malloc(size);

    //1.初始化一个输出缓冲列表
    AudioBufferList outBufferList;
    outBufferList.mNumberBuffers              = 1;
    outBufferList.mBuffers[0].mNumberChannels = bufferList.mBuffers[0].mNumberChannels;
    outBufferList.mBuffers[0].mDataByteSize   = bufferList.mBuffers[0].mDataByteSize; // 设置缓冲区大小
    outBufferList.mBuffers[0].mData           = aacBuf; // 设置AAC缓冲区
    UInt32 outputDataPacketSize               = 1;

    NSData *data = nil;
    NSError *error = nil;
    OSStatus status = AudioConverterFillComplexBuffer(_converterRef, inputDataProc, &bufferList, &outputDataPacketSize, &outBufferList, NULL);
    if (status == 0){
        NSData *rawAAC = [NSData dataWithBytes:outBufferList.mBuffers[0].mData length:outBufferList.mBuffers[0].mDataByteSize];
        NSData *adtsHeader = [self getADTSDataWithPacketLength:rawAAC.length];
        NSMutableData *fullData = [NSMutableData dataWithData:adtsHeader];
        [fullData appendData:rawAAC];
        data = fullData;
    }else{
        error = [NSError errorWithDomain:NSOSStatusErrorDomain code:status userInfo:nil];
        NSLog(@"音频编码失败");
        return;
    }

    if (completionBlock) {
        dispatch_async(dispatch_get_global_queue(0, 0), ^{
        completionBlock(data, error);
        });
    }
    free(aacBuf);
}

#pragma mark -- AudioCallBack
OSStatus inputDataProc(AudioConverterRef inConverter, UInt32 *ioNumberDataPackets, AudioBufferList *ioData,AudioStreamPacketDescription **outDataPacketDescription, void *inUserData) {
    //填充PCM到缓冲区
    AudioBufferList bufferList = *(AudioBufferList*)inUserData;
    ioData->mBuffers[0].mNumberChannels = 1;
    ioData->mBuffers[0].mData           = bufferList.mBuffers[0].mData;
    ioData->mBuffers[0].mDataByteSize   = bufferList.mBuffers[0].mDataByteSize;
    ioData->mNumberBuffers              = 1;
    return noErr;
}

/**
*  Add ADTS header at the beginning of each and every AAC packet.
*  This is needed as MediaCodec encoder generates a packet of raw
*  AAC data.
*
*  Note the packetLen must count in the ADTS header itself.
*  See: http://wiki.multimedia.cx/index.php?title=ADTS
*  Also: http://wiki.multimedia.cx/index.php?title=MPEG-4_Audio#Channel_Configurations
**/
- (NSData *)getADTSDataWithPacketLength:(NSInteger)packetLength {

    int adtsLength = 7;
    char *packet = malloc(sizeof(char) * adtsLength);
    // Variables Recycled by addADTStoPacket
    int profile = 2;  //AAC LC
    //39=MediaCodecInfo.CodecProfileLevel.AACObjectELD;
    int freqIdx = 4;  //44.1KHz
    int chanCfg = 1;  //MPEG-4 Audio Channel Configuration. 1 Channel front-center
    NSUInteger fullLength = adtsLength + packetLength;
    // fill in ADTS data
    packet[0] = (char)0xFF; // 11111111     = syncword
    packet[1] = (char)0xF9; // 1111 1 00 1  = syncword MPEG-2 Layer CRC
    packet[2] = (char)(((profile-1)<<6) + (freqIdx<<2) +(chanCfg>>2));
    packet[3] = (char)(((chanCfg&3)<<6) + (fullLength>>11));
    packet[4] = (char)((fullLength&0x7FF) >> 3);
    packet[5] = (char)(((fullLength&7)<<5) + 0x1F);
    packet[6] = (char)0xFC;
    NSData *data = [NSData dataWithBytesNoCopy:packet length:adtsLength freeWhenDone:YES];
    return data;
}
@end

#import <Foundation/Foundation.h>
#import <CoreMedia/CoreMedia.h>
@class BBVideoConfig;
@interface BBH264SoftEncoder : NSObject
/*
* 设置编码后文件的保存路径
*/
- (void)setFilePath:(NSString *)path;

/*
* 初始化编码配置
*/
- (void)setupEncodeWithConfig:(BBVideoConfig *)config;

/*
* 将CMSampleBufferRef格式的数据编码成h264并写入文件
*/
- (void)encoderToH264:(CMSampleBufferRef)sampleBuffer;

/*
* 释放资源
*/
- (void)freeX264Resource;
@end

#import "BBH264SoftEncoder.h"
#import "BBVideoConfig.h"

#ifdef __cplusplus
extern "C" {
#endif

#include <libavutil/opt.h>
#include <libavutil/imgutils.h>
#include <libavcodec/avcodec.h>
#include <libavformat/avformat.h>
#include <libswscale/swscale.h>

#ifdef __cplusplus
};
#endif

@implementation BBH264SoftEncoder
{
    AVFormatContext                     *pFormatCtx;
    AVOutputFormat                      *fmt;
    AVStream                            *video_st;
    AVCodecContext                      *pCodecCtx;
    AVCodec                             *pCodec;
    AVPacket                             pkt;
    uint8_t                             *picture_buf;
    AVFrame                             *pFrame;
    int                                  picture_size;
    int                                  y_size;
    int                                  framecnt;
    char                                *out_file;

    int                                  encoder_h264_frame_width; // 编码的图像宽度
    int                                  encoder_h264_frame_height; // 编码的图像高度
}

/*
* 设置编码后文件的文件名，保存路径
*/
- (void)setFilePath:(NSString *)path;
{
    out_file = [self nsstring2char:path];
}

/*
* 将路径转成C语言字符串(传入路径为C字符串)
*/
- (char*)nsstring2char:(NSString *)path
{

    NSUInteger len = [path length];
    char *filepath = (char*)malloc(sizeof(char) * (len + 1));

    [path getCString:filepath maxLength:len + 1 encoding:[NSString defaultCStringEncoding]];

    return filepath;
}


/*
*  设置X264
*/
- (void)setupEncodeWithConfig:(BBVideoConfig *)config
{
    // 1.默认从第0帧开始(记录当前的帧数)
    framecnt = 0;

    // 2.记录传入的宽度&高度
    encoder_h264_frame_width = config.videoSize.width;
    encoder_h264_frame_height = config.videoSize.height;

    // 3.注册FFmpeg所有编解码器(无论编码还是解码都需要该步骤)
    av_register_all();

    // 4.初始化AVFormatContext: 用作之后写入视频帧并编码成 h264，贯穿整个工程当中(释放资源时需要销毁)
    pFormatCtx = avformat_alloc_context();

    // 5.设置输出文件的路径，fmt初始化的时候根据传入的参数猜出video_codec、mime_type、extensions等等信息。
    fmt = av_guess_format(NULL, out_file, NULL);
    pFormatCtx->oformat = fmt;

    // 6.打开文件的缓冲区输入输出，flags 标识为  AVIO_FLAG_READ_WRITE ，可读写
    if (avio_open(&pFormatCtx->pb, out_file, AVIO_FLAG_READ_WRITE) < 0){
        printf("Failed to open output file! \n");
    }

    // 7.创建新的输出流, 用于写入文件
    video_st = avformat_new_stream(pFormatCtx, 0);

    if (video_st==NULL){ printf("Failed to setup stream! \n"); return; }

    // 8.pCodecCtx 用户存储编码所需的参数格式等等
    // 8.1.从媒体流中获取到编码结构体，他们是一一对应的关系，一个 AVStream 对应一个  AVCodecContext
    AVCodec *codec = avcodec_find_encoder(pFormatCtx->oformat->video_codec);
    pCodecCtx = avcodec_alloc_context3(codec);

    // 8.2.设置编码器的编码格式(是一个id)，每一个编码器都对应着自己的 id，例如 h264 的编码 id 就是 AV_CODEC_ID_H264
    pCodecCtx->codec_id = fmt->video_codec;

    // 8.3.设置编码类型为 视频编码
    pCodecCtx->codec_type = AVMEDIA_TYPE_VIDEO;

    // 8.4.设置像素格式为 yuv 格式
    pCodecCtx->pix_fmt = AV_PIX_FMT_YUV420P;

    // 8.5.设置视频的宽高
    pCodecCtx->width = encoder_h264_frame_width;
    pCodecCtx->height = encoder_h264_frame_height;

    // 8.6.设置帧率
    pCodecCtx->time_base.num = 1;
    pCodecCtx->time_base.den = 25;

    // 8.7.设置码率（比特率）
    pCodecCtx->bit_rate = config.bitrate;

    // 8.8.视频质量度量标准(常见qmin=10, qmax=51)
    pCodecCtx->qmin = 10;
    pCodecCtx->qmax = 51;

    // 8.9.设置图像组层的大小(GOP-->两个I帧之间的间隔)
    pCodecCtx->gop_size = 30;

    // 8.10.设置 B 帧最大的数量，B帧为视频图片空间的前后预测帧， B 帧相对于 I、P 帧来说，压缩率比较大，也就是说相同码率的情况下，
    // 越多 B 帧的视频，越清晰，现在很多打视频网站的高清视频，就是采用多编码 B 帧去提高清晰度，
    // 但同时对于编解码的复杂度比较高，比较消耗性能与时间
    pCodecCtx->max_b_frames = 5;

    // 9.可选设置
    AVDictionary *param = 0;
    // H.264
    if(pCodecCtx->codec_id == AV_CODEC_ID_H264) {
        // 通过--preset的参数调节编码速度和质量的平衡。
        av_dict_set(&param, "preset", "slow", 0);

        // 通过--tune的参数值指定片子的类型，是和视觉优化的参数，或有特别的情况。
        // zerolatency: 零延迟，用在需要非常低的延迟的情况下，比如视频直播的编码
        av_dict_set(&param, "tune", "zerolatency", 0);
    }

    // 10.输出打印信息，内部是通过printf函数输出（不需要输出可以注释掉）
    av_dump_format(pFormatCtx, 0, out_file, 1);

    // 11.通过 codec_id 找到对应的编码器
    pCodec = avcodec_find_encoder(pCodecCtx->codec_id);
    if (!pCodec) {
        printf("Can not find encoder! \n");
    }

    // 12.打开编码器，并设置参数 param
    if (avcodec_open2(pCodecCtx, pCodec,&param) < 0) {
        printf("Failed to open encoder! \n");
    }

    // 13.将AVCodecContext的成员复制到AVCodecParameters结构体
    avcodec_parameters_from_context(video_st->codecpar, pCodecCtx);

    // 14.真实帧率
    AVRational rational = {1, 25};
    av_stream_set_r_frame_rate(video_st, rational);

    // 15.初始化原始数据对象: AVFrame
    pFrame = av_frame_alloc();

    // 16.通过像素格式(这里为 YUV)获取图片的真实大小，例如将 480 * 720 转换成 int 类型
    av_image_fill_arrays(pFrame->data, pFrame->linesize, picture_buf, pCodecCtx->pix_fmt, pCodecCtx->width, pCodecCtx->height, 1);

    // 17.h264 封装格式的文件头部，基本上每种编码都有着自己的格式的头部。
    if (avformat_write_header(pFormatCtx, NULL) < 0) { printf("Failed to write! \n"); return; }

    // 18.创建编码后的数据 AVPacket 结构体来存储 AVFrame 编码后生成的数据
    av_new_packet(&pkt, picture_size);

    // 19.设置 yuv 数据中 y 图的宽高
    y_size = pCodecCtx->width * pCodecCtx->height;

}

/*
* 将CMSampleBufferRef格式的数据编码成h264并写入文件
*
*/
- (void)encoderToH264:(CMSampleBufferRef)sampleBuffer
{
    // 1.通过CMSampleBufferRef对象获取CVPixelBufferRef对象
    CVPixelBufferRef imageBuffer = CMSampleBufferGetImageBuffer(sampleBuffer);

    // 2.锁定imageBuffer内存地址开始进行编码
    if (CVPixelBufferLockBaseAddress(imageBuffer, 0) == kCVReturnSuccess) {
        // 3.从CVPixelBufferRef读取YUV的值
        // NV12和NV21属于YUV格式，是一种two-plane模式，即Y和UV分为两个Plane，但是UV（CbCr）为交错存储，而不是分为三个plane
        // 3.1.获取Y分量的地址
        UInt8 *bufferPtr = (UInt8 *)CVPixelBufferGetBaseAddressOfPlane(imageBuffer,0);
        // 3.2.获取UV分量的地址
        UInt8 *bufferPtr1 = (UInt8 *)CVPixelBufferGetBaseAddressOfPlane(imageBuffer,1);

        // 3.3.根据像素获取图片的真实宽度&高度
        size_t width = CVPixelBufferGetWidth(imageBuffer);
        size_t height = CVPixelBufferGetHeight(imageBuffer);
        // 获取Y分量长度
        size_t bytesrow0 = CVPixelBufferGetBytesPerRowOfPlane(imageBuffer,0);
        size_t bytesrow1  = CVPixelBufferGetBytesPerRowOfPlane(imageBuffer,1);
        UInt8 *yuv420_data = (UInt8 *)malloc(width * height * 3 / 2);

        // 3.4.将NV12数据转成YUV420P(I420)数据
        UInt8 *pY = bufferPtr;
        UInt8 *pUV = bufferPtr1;
        UInt8 *pU = yuv420_data + width * height;
        UInt8 *pV = pU + width * height / 4;
        for(int i =0;i<height;i++)
        {
            memcpy(yuv420_data+i*width,pY+i*bytesrow0,width);
        }
        for(int j = 0;j<height/2;j++)
        {
            for(int i =0;i<width/2;i++)
            {
                *(pU++) = pUV[i<<1];
                *(pV++) = pUV[(i<<1) + 1];
            }
            pUV += bytesrow1;
        }

        // 3.5.分别读取YUV的数据
        picture_buf = yuv420_data;
        pFrame->data[0] = picture_buf;                   // Y
        pFrame->data[1] = picture_buf + y_size;          // U
        pFrame->data[2] = picture_buf + y_size * 5 / 4;  // V

        // 4.设置当前帧
        pFrame->pts = framecnt;

        // 4.设置宽度高度以及YUV格式
        pFrame->width = encoder_h264_frame_width;
        pFrame->height = encoder_h264_frame_height;
        pFrame->format = AV_PIX_FMT_YUV420P;

        // 5.对编码前的原始数据(AVFormat)利用编码器进行编码，将 pFrame 编码后的数据传入pkt 中
        int ret = avcodec_send_frame(pCodecCtx, pFrame);
        if (ret != 0) {
            printf("Failed to encode! \n");
            return;
        }

        while (avcodec_receive_packet(pCodecCtx, &pkt) == 0) {
            framecnt++;
            pkt.stream_index = video_st->index;
            //也可以使用C语言函数：fwrite()、fflush()写文件和清空文件写入缓冲区。
            ret = av_write_frame(pFormatCtx, &pkt);
            if (ret < 0) {
                printf("Failed write to file！\n");
            }
            //释放packet
            av_packet_unref(&pkt);
        }

        // 7.释放yuv数据
        free(yuv420_data);
    }

    CVPixelBufferUnlockBaseAddress(imageBuffer, 0);
}

/*
* 释放资源
*/
- (void)freeX264Resource
{

    // 1.将还未输出的AVPacket输出出来
    av_write_trailer(pFormatCtx);

    // 2.关闭资源
    avcodec_close(pCodecCtx);
    av_free(pFrame);

    avio_close(pFormatCtx->pb);
    avformat_free_context(pFormatCtx);
}
@end

Found yasm x.x.x.xxxx
Minimum version is yasm-x.x.x
If you really want to compile without asm, configure with --disable-asm.

Found nasm x.x.x.xxxx
Minimum version is nasm-x.x.x
If you really want to compile without asm, configure with --disable-asm.

命令：lipo -info libx264.a
结果：Architectures in the fat file: libx264.a are: armv7 armv7s i386 x86_64 arm64

To build everything://支持所有架构
./build-x264.sh

To build for arm64://只支持arm64
./build-x264.sh arm64

To build fat library for armv7 and x86_64 (64-bit simulator)://只支持armv7和x86_64
./build-x264.sh armv7 x86_64

To build fat library from separately built thin libraries://支持各架构独立库文件
./build-x264.sh lipo

- (void)setupEncodeWithConfig:(BBVideoConfig *)config{

    _config = config;

    pX264Param = (x264_param_t *)malloc(sizeof(x264_param_t));
    assert(pX264Param);
    /* 配置参数预设置
    * 主要是zerolatency该参数，即时编码。
    * static const char * const x264_tune_names[] = { "film", "animation", "grain", "stillimage", "psnr", "ssim", "fastdecode", "zerolatency", 0 };
    */
    x264_param_default_preset(pX264Param, "veryfast", "zerolatency");

    /* 设置Profile.使用Baseline profile
    * static const char * const x264_profile_names[] = { "baseline", "main", "high", "high10", "high422", "high444", 0 };
    */
    x264_param_apply_profile(pX264Param, "baseline");

    // cpuFlags
    pX264Param->i_threads = X264_SYNC_LOOKAHEAD_AUTO; // 取空缓冲区继续使用不死锁的保证

    // 视频宽高
    pX264Param->i_width   = config.videoSize.width; // 要编码的图像宽度.
    pX264Param->i_height  = config.videoSize.height; // 要编码的图像高度
    pX264Param->i_frame_total = 0; //编码总帧数，未知设置为0

    // 流参数
    pX264Param->b_cabac = 0; //支持利用基于上下文的自适应的算术编码 0为不支持
    pX264Param->i_bframe = 5;//两个参考帧之间B帧的数量
    pX264Param->b_interlaced = 0;//隔行扫描
    pX264Param->rc.i_rc_method = X264_RC_ABR; // 码率控制，CQP(恒定质量)，CRF(恒定码率)，ABR(平均码率)
    pX264Param->i_level_idc = 30; // 编码复杂度

    // 图像质量
    pX264Param->rc.f_rf_constant = 15; // rc.f_rf_constant是实际质量，越大图像越花，越小越清晰
    pX264Param->rc.f_rf_constant_max = 45; // param.rc.f_rf_constant_max ，图像质量的最大值。

    // 速率控制参数 通常为屏幕分辨率*3 （宽x高x3）
    pX264Param->rc.i_bitrate = config.bitrate / 1000; // 码率(比特率), x264使用的bitrate需要/1000。
    // pX264Param->rc.i_vbv_max_bitrate=(int)((m_bitRate * 1.2) / 1000) ; // 平均码率模式下，最大瞬时码率，默认0(与-B设置相同)
    pX264Param->rc.i_vbv_buffer_size = pX264Param->rc.i_vbv_max_bitrate = (int)((config.bitrate * 1.2) / 1000);
    pX264Param->rc.f_vbv_buffer_init = 0.9;//默认0.9


    // 使用实时视频传输时，需要实时发送sps,pps数据
    pX264Param->b_repeat_headers = 1;  // 重复SPS/PPS 放到关键帧前面。该参数设置是让每个I帧都附带sps/pps。

    // 帧率
    pX264Param->i_fps_num  = config.fps; // 帧率分子
    pX264Param->i_fps_den  = 1; // 帧率分母
    pX264Param->i_timebase_den = pX264Param->i_fps_num;
    pX264Param->i_timebase_num = pX264Param->i_fps_den;

    /* I帧间隔 GOP
    * 一般为帧率的整数倍，通常设置2倍，即 GOP = 帧率 * 2；
    */
    pX264Param->b_intra_refresh = 1;
    pX264Param->b_annexb = 1;
    pX264Param->i_keyint_max = config.fps * 2;


    // Log参数，打印编码信息
    pX264Param->i_log_level  = X264_LOG_DEBUG;

    // 编码需要的辅助变量
    iNal = 0;
    pNals = NULL;

    pPicIn = (x264_picture_t *)malloc(sizeof(x264_picture_t));
    memset(pPicIn, 0, sizeof(x264_picture_t));
    x264_picture_alloc(pPicIn, X264_CSP_I420, pX264Param->i_width, pX264Param->i_height);
    pPicIn->i_type = X264_TYPE_AUTO;
    pPicIn->img.i_plane = 3;

    pPicOut = (x264_picture_t *)malloc(sizeof(x264_picture_t));
    memset(pPicOut, 0, sizeof(x264_picture_t));
    x264_picture_init(pPicOut);

    // 打开编码器句柄,通过x264_encoder_parameters得到设置给X264
    // 的参数.通过x264_encoder_reconfig更新X264的参数
    pX264Handle = x264_encoder_open(pX264Param);
    assert(pX264Handle);

}

- (void)encoderToH264:(CMSampleBufferRef)sampleBuffer{

    CVImageBufferRef imageBuffer = CMSampleBufferGetImageBuffer(sampleBuffer);

    CVPixelBufferLockBaseAddress(imageBuffer, 0);

    UInt8 *bufferPtr = (UInt8 *)CVPixelBufferGetBaseAddressOfPlane(imageBuffer,0);
    UInt8 *bufferPtr1 = (UInt8 *)CVPixelBufferGetBaseAddressOfPlane(imageBuffer,1);

    size_t width = CVPixelBufferGetWidth(imageBuffer);
    size_t height = CVPixelBufferGetHeight(imageBuffer);

    size_t bytesrow0 = CVPixelBufferGetBytesPerRowOfPlane(imageBuffer,0);
    size_t bytesrow1  = CVPixelBufferGetBytesPerRowOfPlane(imageBuffer,1);

    UInt8 *yuv420_data = (UInt8 *)malloc(width * height *3/ 2);//buffer to store YUV with layout YYYYYYYYUUVV


    /* convert NV12 data to YUV420*/
    UInt8 *pY = bufferPtr ;
    UInt8 *pUV = bufferPtr1;
    UInt8 *pU = yuv420_data + width * height;
    UInt8 *pV = pU + width * height / 4;
    for(int i = 0; i < height; i++)
    {
        memcpy(yuv420_data + i * width, pY + i * bytesrow0, width);
    }
    for(int j = 0;j < height/2; j++)
    {
        for(int i = 0; i < width/2; i++)
        {
            *(pU++) = pUV[i<<1];
            *(pV++) = pUV[(i<<1) + 1];
        }
        pUV += bytesrow1;
    }

    // yuv420_data <==> pInFrame
    pPicIn->img.plane[0] = yuv420_data;
    pPicIn->img.plane[1] = pPicIn->img.plane[0] + (int)_config.videoSize.width * (int)_config.videoSize.height;
    pPicIn->img.plane[2] = pPicIn->img.plane[1] + (int)(_config.videoSize.width * _config.videoSize.height / 4);
    pPicIn->img.i_stride[0] = _config.videoSize.width;
    pPicIn->img.i_stride[1] = _config.videoSize.width / 2;
    pPicIn->img.i_stride[2] = _config.videoSize.width / 2;

    // 编码
    int frame_size = x264_encoder_encode(pX264Handle, &pNals, &iNal, pPicIn, pPicOut);

    // 将编码数据写入文件
    if(frame_size > 0) {

        for (int i = 0; i < iNal; ++i)
        {
            fwrite(pNals[i].p_payload, 1, pNals[i].i_payload, pFile);
        }

    }

    CVPixelBufferUnlockBaseAddress(imageBuffer, 0);
}
释放资源：
- (void)freeX264Resource{
    // 清除图像区域
    x264_picture_clean(pPicIn);
    // 关闭编码器句柄
    x264_encoder_close(pX264Handle);
    pX264Handle = NULL;
    free(pPicIn);
    pPicIn = NULL;
    free(pPicOut);
    pPicOut = NULL;
    free(pX264Param);
    pX264Param = NULL;
    fclose(pFile);
    pFile = NULL;
}

#import <UIKit/UIKit.h>
#import <VideoToolbox/VideoToolbox.h>

@interface BBH264Encoder : NSObject
- (void)encodeSampleBuffer:(CMSampleBufferRef)sampleBuffer;
- (void)endEncode;
@end

#import "BBH264Encoder.h"

@interface BBH264Encoder()
/** 记录当前的帧数 */
@property (nonatomic, assign) NSInteger frameID;

/** 编码会话 */
@property (nonatomic, assign) VTCompressionSessionRef compressionSessionRef;

/** 文件写入对象 */
@property (nonatomic, strong) NSFileHandle *fileHandle;
@end

@implementation BBH264Encoder

- (instancetype)init{
    if (self = [super init]) {
        // 1.初始化写入文件的对象(NSFileHandle用于写入二进制文件)
        [self setupFileHandle];

        // 2.初始化压缩编码的会话
        [self setupCompressionSession];

    }
    return self;
}

- (void)setupFileHandle {
    // 1.获取沙盒路径
    NSString *file = [[NSSearchPathForDirectoriesInDomains(NSDocumentDirectory, NSUserDomainMask, YES) lastObject] stringByAppendingPathComponent:@"test.h264"];

    // 2.如果原来有文件,则删除
    [[NSFileManager defaultManager] removeItemAtPath:file error:nil];
    [[NSFileManager defaultManager] createFileAtPath:file contents:nil attributes:nil];

    // 3.创建对象
    self.fileHandle = [NSFileHandle fileHandleForWritingAtPath:file];
}

- (void)setupCompressionSession{

    //0.用于记录当前是第几帧数据(画面帧数非常多)
    _frameID = 0;

    //1.清空压缩上下文
    if (_compressionSessionRef) {
        VTCompressionSessionCompleteFrames(_compressionSessionRef, kCMTimeInvalid);
        VTCompressionSessionInvalidate(_compressionSessionRef);
        CFRelease(_compressionSessionRef);
        _compressionSessionRef = NULL;
    }

    //2.录制视频的宽度&高度
    int width = [UIScreen mainScreen].bounds.size.width;
    int height = [UIScreen mainScreen].bounds.size.height;

    //3.创建压缩会话
    OSStatus status = VTCompressionSessionCreate(NULL, width, height, kCMVideoCodecType_H264, NULL, NULL, NULL, bbCompressionSessionCallback, (__bridge void * _Nullable)(self), &_compressionSessionRef);

    //4.判断状态
    if (status != noErr) return;

    //5.设置参数
    //Profile_level,h264的协议等级，不同的清晰度使用不同的ProfileLevel
    VTSessionSetProperty(_compressionSessionRef, kVTCompressionPropertyKey_ProfileLevel, kVTProfileLevel_H264_Baseline_AutoLevel);

    // 关键帧最大间隔
    VTSessionSetProperty(_compressionSessionRef, kVTCompressionPropertyKey_MaxKeyFrameInterval, (__bridge CFTypeRef _Nullable)(@(30)));

    // 设置平均码率 单位是byte
    int bitRate = [self getResolution];
    CFNumberRef bitRateRef = CFNumberCreate(kCFAllocatorDefault, kCFNumberSInt32Type, &bitRate);
    VTSessionSetProperty(_compressionSessionRef, kVTCompressionPropertyKey_AverageBitRate, bitRateRef);

    // 码率上限 接收数组类型CFArray[CFNumber] [bytes,seconds,bytes,seconds...] 单位是bps
    VTSessionSetProperty(_compressionSessionRef, kVTCompressionPropertyKey_DataRateLimits, (__bridge CFArrayRef _Nullable)@[@(bitRate*1.5/8), @1]);

    // 设置期望帧率
    int fps = 30;
    CFNumberRef  fpsRef = CFNumberCreate(kCFAllocatorDefault, kCFNumberIntType, &fps);
    VTSessionSetProperty(_compressionSessionRef, kVTCompressionPropertyKey_ExpectedFrameRate, fpsRef);

    // 设置实时编码
    VTSessionSetProperty(_compressionSessionRef, kVTCompressionPropertyKey_RealTime, kCFBooleanTrue);

    // 关闭重排Frame
    VTSessionSetProperty(_compressionSessionRef, kVTCompressionPropertyKey_AllowFrameReordering, kCFBooleanFalse);

    // 设置比例16:9（分辨率宽高比）
    VTSessionSetProperty(_compressionSessionRef, kVTCompressionPropertyKey_AspectRatio16x9, kCFBooleanTrue);

    //6.准备编码
    VTCompressionSessionPrepareToEncodeFrames(_compressionSessionRef);

}

/**
编码回调
*/
static void bbCompressionSessionCallback(
void * CM_NULLABLE outputCallbackRefCon,
void * CM_NULLABLE sourceFrameRefCon,
OSStatus status,
VTEncodeInfoFlags infoFlags,
CM_NULLABLE CMSampleBufferRef sampleBuffer ){

    BBH264Encoder *encoder = (__bridge BBH264Encoder *)(outputCallbackRefCon);

    //1.判断状态是否为没有错误
    if (status != noErr) { return; }

    CFArrayRef attachments = CMSampleBufferGetSampleAttachmentsArray(sampleBuffer, false);
    BOOL isKeyframe = NO;
    if (attachments != NULL) {
        CFDictionaryRef attachment;
        CFBooleanRef dependsOnOthers;
        attachment = (CFDictionaryRef)CFArrayGetValueAtIndex(attachments, 0);
        dependsOnOthers = CFDictionaryGetValue(attachment, kCMSampleAttachmentKey_DependsOnOthers);
        dependsOnOthers == kCFBooleanFalse ? (isKeyframe = YES) : (isKeyframe = NO);
    }

    //2.是否为关键帧
    if (isKeyframe) {
    //SPS and PPS.
    CMFormatDescriptionRef format = CMSampleBufferGetFormatDescription(sampleBuffer);
    size_t spsSize, ppsSize;
    size_t parmCount;
    const uint8_t* sps, *pps;

    OSStatus status = CMVideoFormatDescriptionGetH264ParameterSetAtIndex(format, 0, &sps, &spsSize, &parmCount, NULL );
    //获取SPS无错误则继续获取PPS
    if (status == noErr) {
        CMVideoFormatDescriptionGetH264ParameterSetAtIndex(format, 1, &pps, &ppsSize, &parmCount, NULL );

        NSData *spsData = [NSData dataWithBytes:sps length:spsSize];
        NSData *ppsData = [NSData dataWithBytes:pps length:ppsSize];

        //写入文件
        [encoder gotSpsPps:spsData pps:ppsData];

    }else{
        return;
    }
}


    //3.前4个字节表示长度,后面的数据的长度
    // 除了关键帧,其它帧只有一个数据
    char  *buffer;
    size_t total;
    CMBlockBufferRef dataBuffer = CMSampleBufferGetDataBuffer(sampleBuffer);
    OSStatus statusCodeRet = CMBlockBufferGetDataPointer(dataBuffer, 0, NULL, &total, &buffer);

    if (statusCodeRet == noErr) {
        size_t offset = 0;
        //返回的nalu数据前四个字节不是0001的startcode，而是大端模式的帧长度length
        int const headerLenght = 4;

        //循环获取NAL unit数据
        while (offset < total - headerLenght) {
            int NALUnitLength = 0;
            // Read the NAL unit length
            memcpy(&NALUnitLength, buffer + offset, headerLenght);

            //从大端转系统端
            NALUnitLength = CFSwapInt32BigToHost(NALUnitLength);
            NSData *data = [NSData dataWithBytes:buffer + headerLenght + offset length:NALUnitLength];

            // Move to the next NAL unit in the block buffer
            offset += headerLenght + NALUnitLength;

            [encoder gotEncodedData:data isKeyFrame:isKeyframe];
        }
    }
}

/**
获取屏幕分辨率
*/
- (int)getResolution{
    CGRect screenRect = [[UIScreen mainScreen] bounds];
    CGSize screenSize = screenRect.size;
    CGFloat scale = [UIScreen mainScreen].scale;
    CGFloat screenX = screenSize.width * scale;
    CGFloat screenY = screenSize.height * scale;
    return screenX * screenY;
}

- (void)gotSpsPps:(NSData*)sps pps:(NSData*)pps
{
    // 1.拼接NALU的header
    const char bytes[] = "\x00\x00\x00\x01";
    size_t length = (sizeof bytes) - 1;
    NSData *ByteHeader = [NSData dataWithBytes:bytes length:length];

    // 2.将NALU的头&NALU的体写入文件
    [self.fileHandle writeData:ByteHeader];
    [self.fileHandle writeData:sps];
    [self.fileHandle writeData:ByteHeader];
    [self.fileHandle writeData:pps];

}
- (void)gotEncodedData:(NSData*)data isKeyFrame:(BOOL)isKeyFrame
{
    NSLog(@"gotEncodedData %d", (int)[data length]);
    if (self.fileHandle != NULL)
    {
        const char bytes[] = "\x00\x00\x00\x01";
        size_t length = (sizeof bytes) - 1; //string literals have implicit trailing '\0'
        NSData *ByteHeader = [NSData dataWithBytes:bytes length:length];
        [self.fileHandle writeData:ByteHeader];
        [self.fileHandle writeData:data];
    }
}

- (void)encodeSampleBuffer:(CMSampleBufferRef)sampleBuffer {
    // 1.将sampleBuffer转成imageBuffer
    CVImageBufferRef imageBuffer = (CVImageBufferRef)CMSampleBufferGetImageBuffer(sampleBuffer);

    // 2.根据当前的帧数,创建CMTime的时间
    CMTime presentationTimeStamp = CMTimeMake(self.frameID++, 1000);
    VTEncodeInfoFlags flags;

    // 3.开始编码该帧数据
    OSStatus statusCode = VTCompressionSessionEncodeFrame(self.compressionSessionRef,
    imageBuffer,
    presentationTimeStamp,
    kCMTimeInvalid,
    NULL, (__bridge void * _Nullable)(self), &flags);
    if (statusCode == noErr) {
        NSLog(@"H264: VTCompressionSessionEncodeFrame Success");
    }
}

- (void)endEncode {
    VTCompressionSessionCompleteFrames(self.compressionSessionRef, kCMTimeInvalid);
    VTCompressionSessionInvalidate(self.compressionSessionRef);
    CFRelease(self.compressionSessionRef);
    self.compressionSessionRef = NULL;
    [self.fileHandle closeFile];
    self.fileHandle = NULL;
}
@end

#import <UIKit/UIKit.h>

@interface BBVideoCapture : NSObject

/**
开始捕获视频

@param preview 捕获视频显示的父控件
*/
- (void)startCapture:(UIView *)preview;

/**
结束捕获视频
*/
- (void)stopCapture;

@end

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

@interface BBVideoCapture () <AVCaptureVideoDataOutputSampleBufferDelegate>

/** 捕捉画面执行的线程队列 */
@property (nonatomic, strong) dispatch_queue_t captureQueue;

/** 捕捉会话*/
@property (nonatomic, weak) AVCaptureSession *captureSession;

/** 预览图层 */
@property (nonatomic, weak) AVCaptureVideoPreviewLayer *previewLayer;

@end

@implementation BBVideoCapture

- (void)startCapture:(UIView *)preview
{

    // 1.创建捕捉会话
    AVCaptureSession *session = [[AVCaptureSession alloc] init];
    session.sessionPreset = AVCaptureSessionPresetHigh;
    self.captureSession = session;

    // 2.设置输入设备
    AVCaptureDevice *device = [AVCaptureDevice defaultDeviceWithMediaType:AVMediaTypeVideo];
    // 2.1自动变焦
    if([device isFocusModeSupported:AVCaptureFocusModeContinuousAutoFocus]){
        if([device lockForConfiguration:nil]){
            device.focusMode = AVCaptureFocusModeContinuousAutoFocus;
        }
    }
    NSError *error = nil;
    AVCaptureDeviceInput *input = [[AVCaptureDeviceInput alloc] initWithDevice:device error:&error];
    if ([session canAddInput:input]) {
        [session addInput:input];
    }

    // 3.添加输出设备
    AVCaptureVideoDataOutput *output = [[AVCaptureVideoDataOutput alloc] init];
    self.captureQueue = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0);
    [output setSampleBufferDelegate:self queue:self.captureQueue];
    // 3.1kCVPixelFormatType_420YpCbCr8BiPlanarVideoRange 表示原始数据的格式为YUV420
    // 这里YUV420为后续编码设置，暂时可忽略，后续会写。
    NSDictionary *settings = [[NSDictionary alloc] initWithObjectsAndKeys:[NSNumber numberWithUnsignedInt:kCVPixelFormatType_420YpCbCr8BiPlanarVideoRange], kCVPixelBufferPixelFormatTypeKey, nil];
    output.videoSettings = settings;
    output.alwaysDiscardsLateVideoFrames = YES;
    if ([session canAddOutput:output]) {
        [session addOutput:output];
    }

    // 4.设置录制视频的方向
    AVCaptureConnection *connection = [output connectionWithMediaType:AVMediaTypeVideo];
    [connection setVideoOrientation:AVCaptureVideoOrientationPortrait];

    // 5.添加预览图层
    AVCaptureVideoPreviewLayer *previewLayer = [[AVCaptureVideoPreviewLayer alloc] initWithSession:session];
    previewLayer.frame = preview.bounds;
    [preview.layer insertSublayer:previewLayer atIndex:0];
    self.previewLayer = previewLayer;

    // 6.开始捕捉
    [self.captureSession startRunning];
}

- (void)stopCapture {
    [self.captureSession stopRunning];
    [self.previewLayer removeFromSuperlayer];
}

#pragma mark - 获取视频数据代理
- (void)captureOutput:(AVCaptureOutput *)captureOutput didOutputSampleBuffer:(CMSampleBufferRef)sampleBuffer fromConnection:(AVCaptureConnection *)connection {
    /**这里就是捕获到视频数据的地方，后续再这里实现视频编码*/
}

@end