ijkplayer源码---选择软解码还是硬解码

最新推荐文章于 2024-06-25 14:54:34 发布
最新推荐文章于 2024-06-25 14:54:34 发布
阅读量7.9k 收藏 2
点赞数
分类专栏： ijkPlayer 文章标签： ffmpeg ijkplayer 音视频
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_15255121/article/details/121975218
版权

一直有个疑问 ijk是如何选择硬解码还是软解码的？

我们一步一步来探讨

我们知道ijk打开流的函数是

static int stream_component_open(FFPlayer *ffp, int stream_index)
{
   ......
    
    switch (avctx->codec_type) {
        case AVMEDIA_TYPE_AUDIO:
        .....
        break;
        case AVMEDIA_TYPE_VIDEO:
        is->video_stream = stream_index;
        is->video_st = ic->streams[stream_index];

        if (ffp->async_init_decoder) {
            while (!is->initialized_decoder) {
                SDL_Delay(5);
            }
            当前是否有解码，如果有那么就配置，ffpipeline_config_video_decoder如果成功返回0，失败返回-1
            if (ffp->node_vdec) {
                is->viddec.avctx = avctx;
                ret = ffpipeline_config_video_decoder(ffp->pipeline, ffp);
            }
            
            如果上一步返回了-1或者node_vdec为null，那么我们就要重新创建
             
            if (ret || !ffp->node_vdec) {
                decoder_init(&is->viddec, avctx, &is->videoq, is->continue_read_thread);
                ffp->node_vdec = ffpipeline_open_video_decoder(ffp->pipeline, ffp);
                if (!ffp->node_vdec)
                    goto fail;
            }
        } else {
            decoder_init(&is->viddec, avctx, &is->videoq, is->continue_read_thread);
            ffp->node_vdec = ffpipeline_open_video_decoder(ffp->pipeline, ffp);
            if (!ffp->node_vdec)
                goto fail;
        }
        if ((ret = decoder_start(&is->viddec, video_thread, ffp, "ff_video_dec")) < 0)
            goto out;

      ......


}   



   ......
}

我们接下来看ffpipeline_open_video_decoder

IJKFF_Pipenode* ffpipeline_open_video_decoder(IJKFF_Pipeline *pipeline, FFPlayer *ffp)
{
    return pipeline->func_open_video_decoder(pipeline, ffp);
}

IJKFF_Pipeline *ffpipeline_create_from_android(FFPlayer *ffp)
{
    ALOGD("ffpipeline_create_from_android()\n");
    IJKFF_Pipeline *pipeline = ffpipeline_alloc(&g_pipeline_class, sizeof(IJKFF_Pipeline_Opaque));
    if (!pipeline)
        return pipeline;

    IJKFF_Pipeline_Opaque *opaque = pipeline->opaque;
    opaque->ffp                   = ffp;
    opaque->surface_mutex         = SDL_CreateMutex();
    opaque->left_volume           = 1.0f;
    opaque->right_volume          = 1.0f;
    if (!opaque->surface_mutex) {
        ALOGE("ffpipeline-android:create SDL_CreateMutex failed\n");
        goto fail;
    }

    pipeline->func_destroy              = func_destroy;
    pipeline->func_open_video_decoder   = func_open_video_decoder;
    pipeline->func_open_audio_output    = func_open_audio_output;
    pipeline->func_init_video_decoder   = func_init_video_decoder;
    pipeline->func_config_video_decoder = func_config_video_decoder;

    return pipeline;
fail:
    ffpipeline_free_p(&pipeline);
    return NULL;
}


static IJKFF_Pipenode *func_open_video_decoder(IJKFF_Pipeline *pipeline, FFPlayer *ffp)
{
    IJKFF_Pipeline_Opaque *opaque = pipeline->opaque;
    IJKFF_Pipenode        *node = NULL;

    if (ffp->mediacodec_all_videos || ffp->mediacodec_avc || ffp->mediacodec_hevc || ffp->mediacodec_mpeg2)
        node = ffpipenode_create_video_decoder_from_android_mediacodec(ffp, pipeline, opaque->weak_vout);
    if (!node) {
        node = ffpipenode_create_video_decoder_from_ffplay(ffp);
    }

    return node;
}

我们看到了一个ffpipenode_init_decoder_from_android_mediacodec

IJKFF_Pipenode *ffpipenode_create_video_decoder_from_android_mediacodec(FFPlayer *ffp, IJKFF_Pipeline *pipeline, SDL_Vout *vout)
{
    ALOGD("ffpipenode_create_video_decoder_from_android_mediacodec()\n");
    if (SDL_Android_GetApiLevel() < IJK_API_16_JELLY_BEAN)
        return NULL;

    if (!ffp || !ffp->is)
        return NULL;

    IJKFF_Pipenode *node = ffpipenode_alloc(sizeof(IJKFF_Pipenode_Opaque));
    if (!node)
        return node;

    VideoState            *is     = ffp->is;
    IJKFF_Pipenode_Opaque *opaque = node->opaque;
    JNIEnv                *env    = NULL;
    int                    ret    = 0;
    jobject                jsurface = NULL;

    node->func_destroy  = func_destroy;
    if (ffp->mediacodec_sync) {
        node->func_run_sync = func_run_sync_loop;
    } else {
        node->func_run_sync = func_run_sync;
    }
    node->func_flush    = func_flush;
    opaque->pipeline    = pipeline;
    opaque->ffp         = ffp;
    opaque->decoder     = &is->viddec;
    opaque->weak_vout   = vout;

    opaque->codecpar = avcodec_parameters_alloc();
    if (!opaque->codecpar)
        goto fail;

    ret = avcodec_parameters_from_context(opaque->codecpar, opaque->decoder->avctx);
    if (ret)
        goto fail;

    switch (opaque->codecpar->codec_id) {
    case AV_CODEC_ID_H264:
        if (!ffp->mediacodec_avc && !ffp->mediacodec_all_videos) {
            ALOGE("%s: MediaCodec: AVC/H264 is disabled. codec_id:%d \n", __func__, opaque->codecpar->codec_id);
            goto fail;
        }
        switch (opaque->codecpar->profile) {
            case FF_PROFILE_H264_BASELINE:
                ALOGI("%s: MediaCodec: H264_BASELINE: enabled\n", __func__);
                break;
            case FF_PROFILE_H264_CONSTRAINED_BASELINE:
                ALOGI("%s: MediaCodec: H264_CONSTRAINED_BASELINE: enabled\n", __func__);
                break;
            case FF_PROFILE_H264_MAIN:
                ALOGI("%s: MediaCodec: H264_MAIN: enabled\n", __func__);
                break;
            case FF_PROFILE_H264_EXTENDED:
                ALOGI("%s: MediaCodec: H264_EXTENDED: enabled\n", __func__);
                break;
            case FF_PROFILE_H264_HIGH:
                ALOGI("%s: MediaCodec: H264_HIGH: enabled\n", __func__);
                break;
            case FF_PROFILE_H264_HIGH_10:
                ALOGW("%s: MediaCodec: H264_HIGH_10: disabled\n", __func__);
                goto fail;
            case FF_PROFILE_H264_HIGH_10_INTRA:
                ALOGW("%s: MediaCodec: H264_HIGH_10_INTRA: disabled\n", __func__);
                goto fail;
            case FF_PROFILE_H264_HIGH_422:
                ALOGW("%s: MediaCodec: H264_HIGH_10_422: disabled\n", __func__);
                goto fail;
            case FF_PROFILE_H264_HIGH_422_INTRA:
                ALOGW("%s: MediaCodec: H264_HIGH_10_INTRA: disabled\n", __func__);
                goto fail;
            case FF_PROFILE_H264_HIGH_444:
                ALOGW("%s: MediaCodec: H264_HIGH_10_444: disabled\n", __func__);
                goto fail;
            case FF_PROFILE_H264_HIGH_444_PREDICTIVE:
                ALOGW("%s: MediaCodec: H264_HIGH_444_PREDICTIVE: disabled\n", __func__);
                goto fail;
            case FF_PROFILE_H264_HIGH_444_INTRA:
                ALOGW("%s: MediaCodec: H264_HIGH_444_INTRA: disabled\n", __func__);
                goto fail;
            case FF_PROFILE_H264_CAVLC_444:
                ALOGW("%s: MediaCodec: H264_CAVLC_444: disabled\n", __func__);
                goto fail;
            default:
                ALOGW("%s: MediaCodec: (%d) unknown profile: disabled\n", __func__, opaque->codecpar->profile);
                goto fail;
        }
        strcpy(opaque->mcc.mime_type, SDL_AMIME_VIDEO_AVC);
        opaque->mcc.profile = opaque->codecpar->profile;
        opaque->mcc.level   = opaque->codecpar->level;
        break;
    case AV_CODEC_ID_HEVC:
        if (!ffp->mediacodec_hevc && !ffp->mediacodec_all_videos) {
            ALOGE("%s: MediaCodec/HEVC is disabled. codec_id:%d \n", __func__, opaque->codecpar->codec_id);
            goto fail;
        }
        strcpy(opaque->mcc.mime_type, SDL_AMIME_VIDEO_HEVC);
        opaque->mcc.profile = opaque->codecpar->profile;
        opaque->mcc.level   = opaque->codecpar->level;
        break;
    case AV_CODEC_ID_MPEG2VIDEO:
        if (!ffp->mediacodec_mpeg2 && !ffp->mediacodec_all_videos) {
            ALOGE("%s: MediaCodec/MPEG2VIDEO is disabled. codec_id:%d \n", __func__, opaque->codecpar->codec_id);
            goto fail;
        }
        strcpy(opaque->mcc.mime_type, SDL_AMIME_VIDEO_MPEG2VIDEO);
        opaque->mcc.profile = opaque->codecpar->profile;
        opaque->mcc.level   = opaque->codecpar->level;
        break;
    case AV_CODEC_ID_MPEG4:
        if (!ffp->mediacodec_mpeg4 && !ffp->mediacodec_all_videos) {
            ALOGE("%s: MediaCodec/MPEG4 is disabled. codec_id:%d \n", __func__, opaque->codecpar->codec_id);
            goto fail;
        }
        if ((opaque->codecpar->codec_tag & 0x0000FFFF) == 0x00005844) {
            ALOGE("%s: divx is not supported \n", __func__);
            goto fail;
        }
        strcpy(opaque->mcc.mime_type, SDL_AMIME_VIDEO_MPEG4);
        opaque->mcc.profile = opaque->codecpar->profile >= 0 ? opaque->codecpar->profile : 0;
        opaque->mcc.level   = opaque->codecpar->level >= 0 ? opaque->codecpar->level : 1;
        break;

    default:
        ALOGE("%s:create: not H264 or H265/HEVC, codec_id:%d \n", __func__, opaque->codecpar->codec_id);
        goto fail;
    }

    if (JNI_OK != SDL_JNI_SetupThreadEnv(&env)) {
        ALOGE("%s:create: SetupThreadEnv failed\n", __func__);
        goto fail;
    }

    opaque->acodec_mutex                      = SDL_CreateMutex();
    opaque->acodec_cond                       = SDL_CreateCond();
    opaque->acodec_first_dequeue_output_mutex = SDL_CreateMutex();
    opaque->acodec_first_dequeue_output_cond  = SDL_CreateCond();
    opaque->any_input_mutex                   = SDL_CreateMutex();
    opaque->any_input_cond                    = SDL_CreateCond();

    if (!opaque->acodec_cond || !opaque->acodec_cond || !opaque->acodec_first_dequeue_output_mutex || !opaque->acodec_first_dequeue_output_cond) {
        ALOGE("%s:open_video_decoder: SDL_CreateCond() failed\n", __func__);
        goto fail;
    }

    ret = recreate_format_l(env, node);
    if (ret) {
        ALOGE("amc: recreate_format_l failed\n");
        goto fail;
    }

    if (!ffpipeline_select_mediacodec_l(pipeline, &opaque->mcc) || !opaque->mcc.codec_name[0]) {
        ALOGE("amc: no suitable codec\n");
        goto fail;
    }

    jsurface = ffpipeline_get_surface_as_global_ref(env, pipeline);
    ret = reconfigure_codec_l(env, node, jsurface);
    J4A_DeleteGlobalRef__p(env, &jsurface);
    if (ret != 0)
        goto fail;

    ffp_set_video_codec_info(ffp, MEDIACODEC_MODULE_NAME, opaque->mcc.codec_name);

    opaque->off_buf_out = 0;
    if (opaque->n_buf_out) {
        int i;

        opaque->amc_buf_out = calloc(opaque->n_buf_out, sizeof(*opaque->amc_buf_out));
        assert(opaque->amc_buf_out != NULL);
        for (i = 0; i < opaque->n_buf_out; i++)
            opaque->amc_buf_out[i].pts = AV_NOPTS_VALUE;
    }

    SDL_SpeedSamplerReset(&opaque->sampler);
    ffp->stat.vdec_type = FFP_PROPV_DECODER_MEDIACODEC;
    return node;
fail:
    ffpipenode_free_p(&node);
    return NULL;
}

从这里我们可以看到 AV_CODEC_ID_H264(h264)     AV_CODEC_ID_HEVC(h265)  AV_CODEC_ID_MPEG2VIDEO   AV_CODEC_ID_MPEG4  选用硬解码，其余选择软解吗。

现在有个问题 

    if (ffp->mediacodec_all_videos || ffp->mediacodec_avc || ffp->mediacodec_hevc || ffp->mediacodec_mpeg2)

这些变量都在哪里设置的呢？我们下一节讨论。

原总破局
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
ijkplayer源码分析 音频解码流程
baiiu
01-21 872
前言 本文是流程分析的第三篇，分析ijkPlayer中的音频解码流程，在audio_thread中，如下流程图中所示。 音频帧是如何解码的、如何入队的 音频帧的解码操作是在audio_thread线程中，audio_thread从packet_queue中读取了音频packet，并软解码成音频帧，放入frame_queue中。 音频帧只有软解码，无硬解码。 static int stream_component_open(FFPlayer *ffp, int stream_index) { //
ffmpeg硬解码-jetson平台
05-14
软解码完全依赖CPU来完成解码工作，而硬解码则利用GPU或其他专用硬件单元来处理解码过程，尤其适用于处理高清和4K、8K等高分辨率视频。 在Jetson平台上实现FFmpeg的硬解码，首先需要确保FFmpeg源码支持相应的硬件...
ijkplayer降低延迟
最新发布
heli_huang的博客
06-25 150
【代码】ijkplayer降低延迟。
视频解码之软解与硬解
leigo
12-26 1万+
视频解码之软解与硬解 硬解：从字面意思上理解就是用硬件来进行解码，通过显卡的视频加速功能对高清视频进行解码，很明显就是一个专门的电路板(这样好理解...)来进行视频的解码，是依靠显卡GPU的。 软解：字面上理解就是用软件进行解码，这样理解也对，但是实际最终还是要硬件来支持的，这个硬件就是CPU。 既然有这两种不同的解码方式，我们在开发中该如何进行选择？哪个更好？ 硬解优
硬解码与软解码的选择
Zero
09-28 3万+
在上篇《快速集成一个视频直播功能》 中提到，“确定需求后进行了一堆调研，最后在B站的 ijkplayer 与 Google 的 ExoPlayer 中做出了选择”，当时毅然决然的选择 ExoPlayer 原因有很多，如有兴趣，可关注我的gitchat接下来要分享的内容，微信扫描二维码便可以进入报名，《如何更加安全、高效地选择开源项目》 ，会详细介绍如何更好的选择一个第三方开源。不多说，本篇先抛开稳定
视频解码硬解和软解的区别及如何选择
热门推荐
兰亭幽梦
09-03 4万+
视频解码硬解和软解的区别及如何选择
细解IJK
weixin_34304013的博客
12-14 620
当配置好ijkframework以后，就可以先抛开采集不说，讲讲播放了ijk初始化的时候需要两个参数1：url 2：optionurl就是视频播放地址 option就是硬件控制 //开启硬件解码 [options setPlayerOptionIntValue:1 forKey:@"videotoolbox"];...
商业编程-源码-GIF文件解码器类原代码.zip
06-21
总之，"商业编程-源码-GIF文件解码器类原代码.zip"提供了对GIF解码流程的直接洞察，有助于提升开发者在图像处理领域的专业能力。通过对源码的分析和学习，我们可以更好地应对复杂的图像处理任务，甚至扩展到其他类似...
fdk-aac android 编解码源码
06-10
**fdk-aac android 编解码源码详解** `fdk-aac`是由Fraunhofer IIS开发的一种高质量、低延迟的AAC音频编码器，广泛应用于移动设备和流媒体服务。它提供了高效的编码算法，能够以较小的比特率提供高质量的音频体验。...
openEAR-master_openEAR-master源码_ADS-B_SDR软件数字解码器_
10-02
多模数字解码器OpenEar最近已更新到1.6版。最新版本目前支持FM/AM、TETRA、DMR、Pocsag和ADS-B的解码。新功能包括可缩放的瀑布和其他GUI和功能改进。更改日志显示：6/4/2020版本1.6.0-wav（I/Q）加载（仅1024000采样...
易语言pdu解码源码-易语言
06-13
本篇将围绕易语言PDU解码源码，深入探讨PDU的结构、解码原理以及如何在易语言中实现解码功能。 PDU在不同层次的网络协议中有着不同的含义。在数据链路层，PDU被称为帧；在网络层，它被称为数据包；在传输层，对于...
Android视频播放软解与硬解的区别
Dawish的专栏
09-02 3万+
硬解，用自带播放器播放，android中的VideoView 软解，使用音视频解码库，比如FFmpeg 一、硬解码硬解：就是调用GPU的专门模块编码来解，减少CPU运算，对CPU等硬件要求也相对低点。软解需要CPU运算，变相加大CPU负担耗电增加很多。硬件解码是将原来全部交由CPU来处理的视频数据的一部分交由GPU来做，而GPU的并行运算能力要远远高于CPU，这样可以大大的降低对CPU的负载，CPU
IJKPLAYER源码分析-软解主结构
一个VA生的博客
04-18 467
本文主要分析IJKPLAYER源码软解主流程，硬解将另起一篇分析。
IJKPLAYER 解码流程讲解
u010029439的博客
03-08 2652
http://www.cnblogs.com/blackcatx/p/5832664.html
软解&硬解
软件
06-11 3263
软解：电影播放软件通过cpu的性能进行计算解码，cpu进程较高或满。 硬解：播放软件调度显卡内的优化引擎进行解码，由于gpu分担部分计算，此时cpu负荷较低。         所谓“软解”就是通过软件让CPU进行视频解码处理；而“硬解”是指不依赖于CPU，通过专用的设备（子卡）单独完成视频解码，比如曾经的VCD/DVD解压卡、视频压缩卡都被冠以“硬解”的称号。现在实
H.265编码视频在web网页实现无插件播放，应该通过软解码还是硬解码
liveweb视频汇聚平台
08-08 413
目前摄像头存在H.265和H.264两种编码格式，我们的摄像头已经支持H265编码视频的传输。H.264编码格式可以直接在web浏览器通过H5来进行视频解码来完成播放，但是对于H.265编码的视频，无法通过H5直接解码来进行视频播放，当前的方案是通过H5调用编解码组件来进行web直播。但当前播放的痛点在于：只能使用软解和单线程来进行视频播放处理。我们来测试一下H.265直播流解码播放。
深入剖析ijkplayer解码过程
Abe_liu的博客
08-04 2150
方法汇总 1.alloc 操作：初始化ffmpeg的配置参数,创建渲染所用的EGLView,获取音频播放权限，注册前后台切换通知等。 2.prepareToPlay操作：创建音频输出，调用stream_open方法 3.stream_open 操作: 创建音视频队列，创建read_thread线程 至此，后续的所以音视频相关操作都在read_thread方法中进行. 4.read_thread操作: 在读取方法中，进行了基本的ffmpeg 解码操作。 avformat_open_input 初始化avfo
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值