經(jīng)過幾天的努力現(xiàn)在可以總結(jié)下這幾天對ijkplayer的改造。
1、在GitHub上clone ijkplayer源碼，切換分支到0.8.8

$cd ~/file/ijkfile //目錄可能不存在 ，需要自己創(chuàng)建
$git clone https://github.com/Bilibili/ijkplayer.git ijkplayer-ios
//進(jìn)入ijkplayer-ios
$cd ijkplayer-ios
//切換分支
$git checkout -B latest k0.8.8

2、添加RTSP和HTTPS支持（以module-lite.sh為例）

開啟支持RTSP和HTTPS
開啟支持RTSP,默認(rèn)不支持RTSP,需要修改module-lite.sh內(nèi)容,新增對應(yīng)的協(xié)議,module-lite.sh是在config目錄下
目錄：~/config/module-lite.sh 將這一行：
export COMMON_FF_CFG_FLAGS="$COMMON_FF_CFG_FLAGS --disable-protocol=rtp"
修改為：
export COMMON_FF_CFG_FLAGS="$COMMON_FF_CFG_FLAGS --enable-protocol=rtp"

export COMMON_FF_CFG_FLAGS="$COMMON_FF_CFG_FLAGS --enable-demuxer=rtsp"
export COMMON_FF_CFG_FLAGS="$COMMON_FF_CFG_FLAGS --enable-protocol=tcp"
export COMMON_FF_CFG_FLAGS="$COMMON_FF_CFG_FLAGS --enable-decoder=mjpeg"
export COMMON_FF_CFG_FLAGS="$COMMON_FF_CFG_FLAGS --enable-demuxer=mjpeg"
export COMMON_FF_CFG_FLAGS="$COMMON_FF_CFG_FLAGS --enable-openssl"

3、編譯文件設(shè)置
注：可根據(jù)具體情況加載模塊：
偏好更多的解碼器/視頻格式支持, 則鏈接module-default.sh
偏好打包出來的庫體積更小 (默認(rèn)格式支持), 則鏈接module-lite.sh
偏好打包出來的庫體積更小 (包含HEVC支持), 則鏈接module-lite-hevc.sh

//進(jìn)入ijkplayer/config 目錄
$ cd config
//移除module.sh文件
$ rm module.sh
//替換模塊
$ ln -s module-lite.sh module.sh

4、修改

//ff_play.h
int ffp_start_recording_l(FFPlayer *ffp,const char *file_name);
int ffp_record_isfinished_l(FFPlayer *ffp);
int ffp_stop_recording_l(FFPlayer *ffp);

//ff_ffplay_def.h
...
    int render_wait_start;
    AVFormatContext *m_ofmt_ctx;        // 用于輸出的AVFormatContext結(jié)構(gòu)體
    AVOutputFormat *m_ofmt;
    pthread_mutex_t record_mutex;       // 鎖
    int is_record;                      // 是否在錄制
    int record_error;
    
    int is_first;                       // 第一幀數(shù)據(jù)
    int64_t start_pts;                  // 開始錄制時pts
    int64_t start_dts;                  // 開始錄制時dts
...
} FFPlayer;

//ff_play.c
//插入錄制方法
int ffp_start_recording_l(FFPlayer *ffp,const char *file_name)
{
    assert(ffp);
    VideoState *is = ffp->is;
    
    ffp->m_ofmt_ctx = NULL;
    ffp->m_ofmt = NULL;
    ffp->is_record = 0;
    ffp->record_error = 0;
    
    if (!file_name || !strlen(file_name)) { // 沒有路徑
        av_log(ffp, AV_LOG_ERROR, "filename is invalid");
        goto end;
    }
    
    if (!is || !is->ic|| is->paused || is->abort_request) { // 沒有上下文，或者上下文已經(jīng)停止
        av_log(ffp, AV_LOG_ERROR, "is,is->ic,is->paused is invalid");
        goto end;
    }
    
    if (ffp->is_record) { // 已經(jīng)在錄制
        av_log(ffp, AV_LOG_ERROR, "recording has started");
        goto end;
    }
    
    // 初始化一個用于輸出的AVFormatContext結(jié)構(gòu)體
    avformat_alloc_output_context2(&ffp->m_ofmt_ctx, NULL, NULL, file_name);
    if (!ffp->m_ofmt_ctx) {
        av_log(ffp, AV_LOG_ERROR, "#ly# Could not create output context filename is %s\n", file_name);
        goto end;
    }
    ffp->m_ofmt = ffp->m_ofmt_ctx->oformat;
    
    for (int i = 0; i < is->ic->nb_streams; i++) {
        // 對照輸入流創(chuàng)建輸出流通道1
        AVStream *in_stream = is->ic->streams[i];
        AVStream *out_stream = avformat_new_stream(ffp->m_ofmt_ctx, in_stream->codec->codec);
        if (!out_stream) {
            av_log(ffp, AV_LOG_ERROR, "Failed allocating output stream\n");
            goto end;
        }
        
        // 將輸入視頻/音頻的參數(shù)拷貝至輸出視頻/音頻的AVCodecContext結(jié)構(gòu)體1
        av_log(ffp, AV_LOG_DEBUG, "in_stream->codec；%p\n", in_stream->codec);
        if (avcodec_copy_context(out_stream->codec, in_stream->codec) < 0) {
            av_log(ffp, AV_LOG_ERROR, "Failed to copy context from input to output stream codec context\n");
            goto end;
        }
        
        out_stream->codec->codec_tag = 0;
        if (ffp->m_ofmt_ctx->oformat->flags & AVFMT_GLOBALHEADER) {
            out_stream->codec->flags |= CODEC_FLAG_GLOBAL_HEADER;
        }
    }
    
    av_dump_format(ffp->m_ofmt_ctx, 0, file_name, 1);
    
    // 打開輸出文件
    if (!(ffp->m_ofmt->flags & AVFMT_NOFILE)) {
        if (avio_open(&ffp->m_ofmt_ctx->pb, file_name, AVIO_FLAG_WRITE) < 0) {
            av_log(ffp, AV_LOG_ERROR, "Could not open output file '%s'", file_name);
            goto end;
        }
    }
    
    // 寫視頻文件頭
    if (avformat_write_header(ffp->m_ofmt_ctx, NULL) < 0) {
        av_log(ffp, AV_LOG_ERROR, "Error occurred when opening output file\n");
        goto end;
    }
    
    ffp->is_record = 1;
    ffp->record_error = 0;
    pthread_mutex_init(&ffp->record_mutex, NULL);
    
    return 0;
end:
    ffp->record_error = 1;
    return -1;
}

int ffp_record_isfinished_l(FFPlayer *ffp)
{
    return 0;
}

int ffp_record_file(FFPlayer *ffp, AVPacket *packet){
    assert(ffp);
    VideoState *is = ffp->is;
    int ret = 0;
    AVStream *in_stream;
    AVStream *out_stream;
    if (ffp->is_record) {
        if (packet == NULL) {
            ffp->record_error = 1;
            av_log(ffp, AV_LOG_ERROR, "packet == NULL");
            printf("ffp_record_file return null 1");
            return -1;
        }
        
        AVPacket *pkt = (AVPacket *)av_malloc(sizeof(AVPacket)); // 與看直播的 AVPacket分開，不然卡屏
        av_new_packet(pkt, 0);
        if (0 == av_packet_ref(pkt, packet)) {
            pthread_mutex_lock(&ffp->record_mutex);
            if (!ffp->is_first) { // 錄制的第一幀，時間從0開始
                ffp->is_first = 1;
                pkt->pts = 0;
                pkt->dts = 0;
            } else { // 之后的每一幀都要減去，點(diǎn)擊開始錄制時的值，這樣的時間才是正確的
                
                pkt->pts = llabs(pkt->pts - ffp->start_pts);
                pkt->dts = llabs(pkt->dts - ffp->start_dts);
                printf("AVMEDIA_TYPE_VIDEO pkt->pts == %lld pkt->dts == %lld\n",pkt->pts,pkt->dts);
            }
            
            in_stream  = is->ic->streams[pkt->stream_index];
            out_stream = ffp->m_ofmt_ctx->streams[pkt->stream_index];
            
            // 轉(zhuǎn)換PTS/DTS
            pkt->pts = av_rescale_q_rnd(pkt->pts, in_stream->time_base, out_stream->time_base, (AV_ROUND_NEAR_INF|AV_ROUND_PASS_MINMAX));
            pkt->dts = av_rescale_q_rnd(pkt->dts, in_stream->time_base, out_stream->time_base, (AV_ROUND_NEAR_INF|AV_ROUND_PASS_MINMAX));
            pkt->duration = av_rescale_q(pkt->duration, in_stream->time_base, out_stream->time_base);
            pkt->pos = -1;
            
            // 寫入一個AVPacket到輸出文件
            if ((ret = av_interleaved_write_frame(ffp->m_ofmt_ctx, pkt)) < 0) {
                av_log(ffp, AV_LOG_ERROR, "Error muxing packet\n");
            }
            
            av_packet_unref(pkt);
            pthread_mutex_unlock(&ffp->record_mutex);
        } else {
            av_log(ffp, AV_LOG_ERROR, "av_packet_ref == NULL");
            printf("ffp_record_file return null 2");
        }
    }
    printf("ffp_record_file return null 3 == %d\n",ret);
    return ret;
}


int ffp_stop_recording_l(FFPlayer *ffp){
    assert(ffp);
    if (ffp->is_record) {
        ffp->is_record = 0;
        pthread_mutex_lock(&ffp->record_mutex);
        if (ffp->m_ofmt_ctx != NULL) {
            av_write_trailer(ffp->m_ofmt_ctx);
            if (ffp->m_ofmt_ctx && !(ffp->m_ofmt->flags & AVFMT_NOFILE)) {
                avio_close(ffp->m_ofmt_ctx->pb);
            }
            avformat_free_context(ffp->m_ofmt_ctx);
            ffp->m_ofmt_ctx = NULL;
            ffp->is_first = 0;
        }
        pthread_mutex_unlock(&ffp->record_mutex);
        pthread_mutex_destroy(&ffp->record_mutex);
        av_log(ffp, AV_LOG_DEBUG, "stopRecord ok\n");
    } else {
        av_log(ffp, AV_LOG_ERROR, "don't need stopRecord\n");
    }
    return 0;
}


//上屏解碼處或緩沖解碼處(decoder_decode_frame、read_thread)
//decoder_decode_frame
...
}while (d->queue->serial != d->pkt_serial);
        if (!ffp->is_first && pkt.pts == pkt.dts) { // 獲取開始錄制前dts等于pts最后的值
            ffp->start_pts = pkt.pts;
            ffp->start_dts = pkt.dts;
        }
      #pragma  mark - 錄制插入
        if (ffp->is_record) { // 可以錄制時，寫入文件
            if (0 != ffp_record_file(ffp, &pkt)) {
                ffp->record_error = 1;
                ffp_stop_recording_l(ffp);
                printf("avcodec_send_packet stop\n");
            }
        }
if (pkt.data == flush_pkt.data) {
...

//read_thread
...
for(::){
 if (!ffp->is_first && pkt.pts == pkt.dts) { // 獲取開始錄制前dts等于pts最后的值
            ffp->start_pts = pkt.pts;
            ffp->start_dts = pkt.dts;
        }
        #pragma  mark - 錄制插入
        if (ffp->is_record) { // 可以錄制時，寫入文件
            if (0 != ffp_record_file(ffp, &pkt)) {
                ffp->record_error = 1;
                ffp_stop_recording_l(ffp);
                printf("avcodec_send_packet stop\n");
            }
        }
...
}
...

//ijkplayer.h
int ijkmp_start_recording(IjkMediaPlayer *mp,const char *filePath);
int ijkmp_stop_recording(IjkMediaPlayer *mp);;
int ijkmp_isRecording(IjkMediaPlayer *mp);

//ijkplayer.c
static int ijkmp_start_recording_l(IjkMediaPlayer *mp,const char *filePath)
{
    //  av_log(mp->ffplayer,AV_LOG_WARING,"cjz ijkmp_start_recording_l filePath %s",filePath);
    return ffp_start_recording_l(mp->ffplayer,filePath);
}

int ijkmp_start_recording(IjkMediaPlayer *mp,const char *filePath)
{
    assert(mp);
    pthread_mutex_lock(&mp->mutex);
    av_log(mp->ffplayer,AV_LOG_WARNING,"cjz ijkmp_start_recording");
    int retval = ijkmp_start_recording_l(mp,filePath);
    printf("ijkmp_start_recording return == %d\n",retval);
    pthread_mutex_unlock(&mp->mutex);
    return retval;
}

static int ijkmp_stop_recording_l(IjkMediaPlayer *mp)
{
    return ffp_stop_recording_l(mp->ffplayer);
}

int ijkmp_stop_recording(IjkMediaPlayer *mp)
{
    assert(mp);
    pthread_mutex_lock(&mp->mutex);
    av_log(mp->ffplayer,AV_LOG_WARNING,"cjz ijkmp_stop_recording");
    int retval = ijkmp_stop_recording_l(mp);
    pthread_mutex_unlock(&mp->mutex);
    return retval;
}

static int ijkmp_isRecordFinished_l(IjkMediaPlayer *mp)
{
    return ffp_record_isfinished_l(mp->ffplayer);
}

int ijkmp_isRecordFinished(IjkMediaPlayer *mp)
{
    assert(mp);
    pthread_mutex_lock(&mp->mutex);
    av_log(mp->ffplayer,AV_LOG_WARNING,"cjz ijkmp_isRecordFinished ");
    int retval = ijkmp_isRecordFinished_l(mp);
    pthread_mutex_unlock(&mp->mutex);
    return retval;
}

int ijkmp_isRecording(IjkMediaPlayer *mp) {
    return mp->ffplayer->is_record;
}

//IJKMediaPlayback.h
- (void)stopRecord;
- (void)startRecordWithFileName:(NSString *)fileName;

//IJKFFMoviePlayerController.m
- (void)stopRecord {
    ijkmp_stop_recording(_mediaPlayer);
    NSLog(@"stop record");
}

- (void)startRecordWithFileName:(NSString *)fileName {
    // 視頻存儲的路徑
    const char *path = [fileName cStringUsingEncoding:NSUTF8StringEncoding];
    ijkmp_start_recording (_mediaPlayer, path);
    
    NSLog(@"start record fileName %@",fileName);
}

- (BOOL)isRecording {
    return ijkmp_isRecording(_mediaPlayer);
}

3、編譯ijkplayer

//編譯iOS
$ ./init-ios.sh
$ ./init-ios-openssl.sh （不需要https請忽略openssl）

//編譯ffmpg (我這里只編譯arm64)
//可能執(zhí)行compile-ffmpeg.sh arm64會出錯，如果是架構(gòu)請檢查編譯器是否支持等。
$ cd ios 
$ ./compile-ffmpeg.sh clean
$ ./compile-openssl.sh arm64 （不需要https請忽略openssl）
$ ./compile-ffmpeg.sh arm64

4、編譯framework（稀松平常略過）
5、合并framework（如果只有arm64也不需要合并，只能真機(jī)使用）

準(zhǔn)備合并:
1、打開終端, 先cd到Products目錄下
2、然后執(zhí)行:lipo -create 真機(jī)framework路徑 模擬器framework路徑 -output 合并的文件路徑
例如：
lipo -create Release-iphoneos/IJKMediaFramework.framework/IJKMediaFramework Release-iphonesimulator/IJKMediaFramework.framework/IJKMediaFramework -output IJKMediaFramework

經(jīng)過幾天的踩坑，廣泛參考網(wǎng)上既有資料，加入了我需要用到的業(yè)務(wù)場景可完美錄屏（但存在錄屏?xí)r關(guān)鍵幀缺失會從下一個關(guān)鍵幀開始正常播放，看命吧）。