Android 13 - Media框架（11）- MediaCodec（一）

已于 2024-10-19 22:39:57 修改
阅读量2.2k 收藏 7
点赞数 1
分类专栏： Android Media学习笔记 文章标签： android framework 音视频 视频编解码
于 2023-10-17 19:26:13 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41828351/article/details/133151311
版权

全新系列文章已更新：

MediaCodec 是 Android 平台上音视频编解码的标准接口，无论是使用软解还是硬解都要通过调用 MediaCodec来完成，是学习 Android 音视频不可跳过的重要部分。MediaCodec 部分的代码有几千行，光是头文件就有几百行，对于我这样的新手来说，简直就劝退了，又或者是硬着头皮往下看，一行一行阅读，看到里面的各种状态各种变量，很容易就晕了。我们这一篇笔记旨在从设计思路的角度了解 MediaCodec，不仅仅是粘贴代码流程，力求更好地帮助理解 MediaCodec 的原理。
ps：由于本人水平有限，MediaCodec 中的部分内容也没有理解，如果有错误还恳请指正。

1、准备工作

MediaCodec 中有一些类我们暂时可以不用看，例如 ResourceManagerServiceProxy，大概是用于资源管理的，我们碰到可以跳过；还有一个类 Histogram，应该是做 decoder 性能统计用的，阅读过程中碰到同样跳过。

目前我只阅读了 ACodec，所以文中设计 CCodec 的部分暂时跳过，另外关于 ACodec 我们只要了解有什么接口就行，不必深入了解它的内部实现。

MediaCodec 使用异步消息处理机制（AMessage/ALooper/AHandler），不是很了解的同学可以阅读之前的文章 Android 13 - Media框架 - 异步消息机制。

观察 MediaCodec 对外开放的接口可以发现，很多接口使用的是消息的同步处理方法，例如 configure、setCallback、queueInputBuffer、dequeueInputBuffer 等等都是调用的 AMessage 的 postAndAwaitResponse 方法，为什么这里不直接在函数体中实现功能，非要使用消息同步消息机制处理呢？原因我们在之前的笔记中已经提到过了，异步消息处理机制可以帮我们实现线程同步，避免异常状态的出现。ACodec 会频繁向 MediaCodec 上抛消息，如果接口调用过程中有一些事件发送，很容易就出现异常了，使用异步消息机制将上层命令和底层回调放到同一个线程中处理，就会井井有条了。

可能有人还会问，为什么MediaCodec 部分对外接口不用异步处理呢？有些接口不太适宜异步调用，比如上面提到的queueInputBuffer 等，设计为异步的会增加外层的设计难度；其他的我也不是很了解，但是我觉得 MediaCodec 的外层 NuPlayerDecoder 已经使用了异步处理，如果 MediaCodec 也使用异步，异步套异步的情况下需要考虑的状态反而会变的更多，可能会得不偿失。

接下来我们就正式去看 MediaCodec 的实现。

2、MediaCodec的创建

    static sp<MediaCodec> CreateByType(
            const sp<ALooper> &looper, const AString &mime, bool encoder, status_t *err = NULL,
            pid_t pid = kNoPid, uid_t uid = kNoUid);

    static sp<MediaCodec> CreateByType(
            const sp<ALooper> &looper, const AString &mime, bool encoder, status_t *err,
            pid_t pid, uid_t uid, sp<AMessage> format);

    static sp<MediaCodec> CreateByComponentName(
            const sp<ALooper> &looper, const AString &name, status_t *err = NULL,
            pid_t pid = kNoPid, uid_t uid = kNoUid);

MediaCodec 隐藏了自己的构造函数，对外提供了三个静态函数用于创建自身实例，ps：这算不算建造者模式？。

  • CreateByType 会根据媒体类型（mime type）来选择合适的编解码组件（component），使用时需要指定创建解码器（decoder）还是编码器（encoder）；要注意的是第二个CreateByType会传递 format 参数，这里传递的参数并不会用于 configure，仅仅用于编解码组件的选择；
  • CreateByComponentName 是由使用者指定要创建的编解码组件；

这三个方法最终会调用 MediaCodec 构造函数，并且调用 init 方法将 component name 传递给 MediaCodec。

MediaCodec 构造函数主要用于初始化成员变量，需要重点关注的是两个成员 mGetCodecBase 和 mGetCodecInfo，这是两个函数指针：

  • mGetCodecBase：根据 component name 创建对应的 CodecBase 对象（ACodec/CCodec）；
  • mGetCodecInfo：获取 component 所支援的媒体类型信息（MediaCodecInfo）；

如果我们没有指定这两个函数，MediaCodec 为我们提供了默认实现，我们这里暂时先不了解。init 方法主要完成了 MediaCodec 的初始化工作，内容如下：

status_t MediaCodec::init(const AString &name) {
    // save init parameters for reset
    mInitName = name;
    mCodecInfo.clear();

    bool secureCodec = false;
    const char *owner = "";
    if (!name.startsWith("android.filter.")) {
    	// 1、根据 component 获取 codecInfo
        err = mGetCodecInfo(name, &mCodecInfo);
        // 2、这里会做 double check
        if (err != OK) {
            mCodec = NULL;  // remove the codec.
            return err;
        }
        if (mCodecInfo == nullptr) {
            ALOGE("Getting codec info with name '%s' failed", name.c_str());
            return NAME_NOT_FOUND;
        }
        // 3、判断选择的是否是 secure component
        secureCodec = name.endsWith(".secure");
        Vector<AString> mediaTypes;
        // 4、获取当前的 codecInfo 中的 mediatype，判断创建的是什么组件
        mCodecInfo->getSupportedMediaTypes(&mediaTypes);
        for (size_t i = 0; i < mediaTypes.size(); ++i) {
            if (mediaTypes[i].startsWith("video/")) {
                mDomain = DOMAIN_VIDEO;
                break;
            } else if (mediaTypes[i].startsWith("audio/")) {
                mDomain = DOMAIN_AUDIO;
                break;
            } else if (mediaTypes[i].startsWith("image/")) {
                mDomain = DOMAIN_IMAGE;
                break;
            }
        }
        // 5、获取 component 隶属的架构
        owner = mCodecInfo->getOwnerName();
    }
	// 6、根据架构名和组件名创建CodecBase
    mCodec = mGetCodecBase(name, owner);
	// 7、如果是 video，则需要使用单独的 Looper
    if (mDomain == DOMAIN_VIDEO) {
        // video codec needs dedicated looper
        if (mCodecLooper == NULL) {
            status_t err = OK;
            mCodecLooper = new ALooper;
            mCodecLooper->setName("CodecLooper");
            err = mCodecLooper->start(false, false, ANDROID_PRIORITY_AUDIO);
        }

        mCodecLooper->registerHandler(mCodec);
    } else {
        mLooper->registerHandler(mCodec);
    }

    mLooper->registerHandler(this);
	// 8、创建 CodecCallback 和 BufferCallback
    mCodec->setCallback(
            std::unique_ptr<CodecBase::CodecCallback>(
                    new CodecCallback(new AMessage(kWhatCodecNotify, this))));
    mBufferChannel = mCodec->getBufferChannel();
    mBufferChannel->setCallback(
            std::unique_ptr<CodecBase::BufferCallback>(
                    new BufferCallback(new AMessage(kWhatCodecNotify, this))));
	// 9、涉及到 CodecBase 状态的调用，用消息处理
    sp<AMessage> msg = new AMessage(kWhatInit, this);
    if (mCodecInfo) {
        msg->setObject("codecInfo", mCodecInfo);
    }
    msg->setString("name", name);
    sp<AMessage> response;
    err = PostAndAwaitResponse(msg, &response);
    return err;
}
  1. 根据传入参数 component name 获取对应的 codec Info，再反向获取 component 所支持的 mime type；可能会有人问，我上面明明已经传入 mime type了，为什么这里还要费力再反向获取呢？我觉得这是为了 CreateByComponentName 服务的，有的时候我们指定了组件名称，但是 MediaCodec 并不知道它是 audio 组件还是 video 组件，也不知道该组件系统是否支持，所以这里做了一次判断，这个步骤对于 CreateByType 是多余的，因为调用 init 之前已经通过 MediaCodecList 获取了支持当前 mime 的组件明；
  2. 获取 component 隶属的架构，MediaCodec 当前串接有两个编解码框架，一个是老的 ACodec/OMX 架构，另一个是新的 CCodec 架构，owner name 就是用来区分 component 是哪个架构下的，之后会根据这个 name 创建对应的 CCodec；
  3. 调用 mGetCodecBase 函数，利用 owner name 和 component name 创建 CodecBase 对象，我们暂时只看 ACodec；
  4. 将 AHandler 注册到 ALooper 中，注意的是 Video Codec 将独享一个 looper，而 MediaCodec、Audio Codec 会共享上层传递的 looper；
  5. 给 ACodec 和 BufferChannel 注册回调消息；
  6. 发送消息，到 looper 线程中处理 kWhatInit 方法，调用 ACodec 的 initiateAllocateComponent 方法，这里我们要注意的是，发送消息调用的方法是 PostAndAwaitResponse，它内部封装的是 AMessage.postAndAwaitResponse，是阻塞处理消息。

接下来我们一起来看 kWhatInit 是如何处理的：

        case kWhatInit:
        {
        	// 1、检查状态
            if (mState != UNINITIALIZED) {
                PostReplyWithError(msg, INVALID_OPERATION);
                break;
            }
			// 2、判断是否正在等待某个方法返回
            if (mReplyID) {
            	// 如果是就将消息先加入到容器中等待处理
                mDeferredMessages.push_back(msg);
                break;
            }
            sp<AReplyToken> replyID;
            CHECK(msg->senderAwaitsResponse(&replyID));

            mReplyID = replyID;
            // 3、设置新状态
            setState(INITIALIZING);

            sp<RefBase> codecInfo;
            (void)msg->findObject("codecInfo", &codecInfo);
            AString name;
            CHECK(msg->findString("name", &name));

            sp<AMessage> format = new AMessage;
            if (codecInfo) {
                format->setObject("codecInfo", codecInfo);
            }
            format->setString("componentName", name);
			// 4、调用 CodecBase 方法
            mCodec->initiateAllocateComponent(format);
            break;
        }
  1. 检查当前 MediaCodec 状态；我觉得 MediaCodec 的状态有两种作用，一个是检查当前的函数是否在合法状态下调用，另一个是当有事件需要处理时，根据当前的状态做出不同的反应，例如 callback 到达时根据当前状态做不同处理。
  2. MediaCodec 会有一些中间状态，例如这里的 INITIALIZING，表示正在处理 init 的过程中。这里有个DeferredMessages用于存储即将延时处理的消息，这个情况什么时候会出现？比如说我们当前正在处理上层调用的 flush 方法，调用 ACodec 的异步方法后会等待消息返回，这期间收到了 BufferChannel 发过来的消息，消息会进入到 looper 线程处理，但是我们要先等待 ACodec flush 处理完成，再去处理 BufferChannel 的消息，因为 flush 之后所有的 buffer 将被刷新。我觉得 DeferredMessages 是用来处理消息优先级的，如果当前有上层函数调用（命令），将会优先等待这些消息处理完成。
  3. 调用 setState 设置当前状态，我们要了解的是出了设置状态外，里面还会重置 flag 等内容，flag 具体有什么作用我们后面再看；
  4. 调用 CodecBase 的 initiateAllocateComponent 方法，从这里我们大致可以了解到，创建 Component 只需要传递 component name 一个参数即可。

从这里我们可知道，调用 initiateAllocateComponent 传入的 format 参数中必须要有两个内容：

  • codecInfo：组件所对应的 codecInfo，如果为 NULL，说明在 MediaCodecList 中没有找到组件对应的信息，这个组件是系统所不支援的；
  • componentName：组件名称，ACodec 会根据该组件创建 omx 组件。

关于 secure component 和 普通 component 的一些内容：我们平时创建的组件以普通组件为主，如果想要创建 secure 组件，一般是调用 CreateByComponentName 直接指定组件名，使用 CreateByType 似乎并不能指定创建 secure 还是 non-secure 组件。

ACodec 创建组件之后会调用 Callback 结束 MediaCodec 阻塞状态，具体有那些callback 参考 CodecBase::CodecCallback，这里调用的是 onComponentAllocated。

在看 onMessageReceived 方法时，我们要知道 AMessage.what 用于区分是什么模块发来的消息，AMessage 中的字段 what 用于区分是模块发来的具体消息内容。

                case kWhatComponentAllocated:
                {
                    if (mState == RELEASING || mState == UNINITIALIZED) {
                        // In case a kWhatError or kWhatRelease message came in and replied,
                        // we log a warning and ignore.
                        ALOGW("allocate interrupted by error or release, current state %d/%s",
                              mState, stateString(mState).c_str());
                        break;
                    }
                    // 检查当前状态并且设置新的状态，设置flag
                    CHECK_EQ(mState, INITIALIZING);
                    setState(INITIALIZED);
                    mFlags |= kFlagIsComponentAllocated;
					// 检查创建的组件名称
                    CHECK(msg->findString("componentName", &mComponentName));

                    const char *owner = mCodecInfo ? mCodecInfo->getOwnerName() : "";
                    if (mComponentName.startsWith("OMX.google.")
                            && strncmp(owner, "default", 8) == 0) {
                        mFlags |= kFlagUsesSoftwareRenderer;
                    } else {
                        mFlags &= ~kFlagUsesSoftwareRenderer;
                    }
                    mOwnerName = owner;

                    if (mComponentName.endsWith(".secure")) {
                        mFlags |= kFlagIsSecure;
                        mediametrics_setInt32(mMetricsHandle, kCodecSecure, 1);
                    } else {
                        mFlags &= ~kFlagIsSecure;
                        mediametrics_setInt32(mMetricsHandle, kCodecSecure, 0);
                    }
					// 结束阻塞并且处理被延迟的消息
                    postPendingRepliesAndDeferredMessages("kWhatComponentAllocated");
                    break;
                }

kWhatComponentAllocated 的处理比较简单，主要是更新状态，更新 MediaCodec flags，结束阻塞调用并处理被推迟的消息。

void MediaCodec::postPendingRepliesAndDeferredMessages(
        std::string origin, status_t err /* = OK */) {
    sp<AMessage> response{new AMessage};
    if (err != OK) {
        response->setInt32("err", err);
    }
    postPendingRepliesAndDeferredMessages(origin, response);
}

void MediaCodec::postPendingRepliesAndDeferredMessages(
        std::string origin, const sp<AMessage> &response) {
    LOG_ALWAYS_FATAL_IF(
            !mReplyID,
            "postPendingRepliesAndDeferredMessages: mReplyID == null, from %s following %s",
            origin.c_str(),
            mLastReplyOrigin.c_str());
    mLastReplyOrigin = origin;
    // 返回阻塞调用结果
    response->postReply(mReplyID);
    mReplyID.clear();
    ALOGV_IF(!mDeferredMessages.empty(),
            "posting %zu deferred messages", mDeferredMessages.size());
    // 将所有推迟的消息重新 post 出去处理
    for (sp<AMessage> msg : mDeferredMessages) {
        msg->post();
    }
    mDeferredMessages.clear();
}

3、configure

MediaCodec 提供了2个版本的 configure 方法：

    status_t configure(
            const sp<AMessage> &format,
            const sp<Surface> &nativeWindow,
            const sp<ICrypto> &crypto,
            uint32_t flags);

    status_t configure(
            const sp<AMessage> &format,
            const sp<Surface> &nativeWindow,
            const sp<ICrypto> &crypto,
            const sp<IDescrambler> &descrambler,
            uint32_t flags);
  • format：需要编码/解码数据的格式信息；
  • nativeWindow：用于显示的窗口（surface），如果在configure时没有设定，也可以调用setSurface方法来设定；如果起播时没有设置窗口，后续也可以再调用 setSurface 方法来设置显示窗口；
  • crypto、descrambler：用于处理加密视频和解扰播放的参数；
  • flags：目前有两个flag，CONFIGURE_FLAG_ENCODE（用于标记当前codec用于编码还是解码） 和 CONFIGURE_FLAG_USE_BLOCK_MODEL（目前还不太了解有什么用）。

先抛出一个问题，传递给 configure 方法的参数中需要包含什么信息呢？什么是必要的，什么是可选的？接下来我们就一起来看 configure 实现，我们将会暂时忽略 mediametrics 相关的内容。

status_t MediaCodec::configure(
        const sp<AMessage> &format,
        const sp<Surface> &surface,
        const sp<ICrypto> &crypto,
        const sp<IDescrambler> &descrambler,
        uint32_t flags) {
    sp<AMessage> msg = new AMessage(kWhatConfigure, this);
    ...
    if (mIsVideo) {
    	format->findString("log-session-id", &mLogSessionId);
	    format->findInt32("width", &mVideoWidth);
	    format->findInt32("height", &mVideoHeight);
	    
        if (mVideoWidth < 0 || mVideoHeight < 0 ||
               (uint64_t)mVideoWidth * mVideoHeight > (uint64_t)INT32_MAX / 4) {
            ALOGE("Invalid size(s), width=%d, height=%d", mVideoWidth, mVideoHeight);
            return BAD_VALUE;
        }
    } else {
        if (nextMetricsHandle != 0) {
            int32_t channelCount;
            if (format->findInt32(KEY_CHANNEL_COUNT, &channelCount)) {
            }
            int32_t sampleRate;
            if (format->findInt32(KEY_SAMPLE_RATE, &sampleRate)) {
            }
        }
    }
    ......
    msg->setMessage("format", format);
    msg->setInt32("flags", flags);
    msg->setObject("surface", surface);

    if (crypto != NULL || descrambler != NULL) {
        if (crypto != NULL) {
            msg->setPointer("crypto", crypto.get());
        } else {
            msg->setPointer("descrambler", descrambler.get());
        }
    } 
    ......
}

可以看到，如果是用于解码video，那么必须要设置画面的宽高信息（可以先随意设置，但至少要有），如果没有那么 MediaCodec 会直接报错；audio可能需要channel count 和 sample rate信息，但是没有这里也不会报错。

原文阅读：
Android Media Framework（十二）NuPlayer::Renderer

扫描下方二维码，关注公众号《青山渺渺》阅读音视频开发内容。

青山渺渺
关注
专栏目录
Android 13 - Media框架（13）- OpenMax（一）
青山渺渺
11-01 1633
这里看到 ACodec 并没有获取 IOmx 服务，而是使用 OMXClient 封装了服务获取过程，接着再调用其 interface 接口返回获取的服务代理，不过这里有点要注意，返回代理的类型是。实现了服务相关的文件，那么就要开启进程启动服务了，相关的代码在 frameworks/av/services/mediacodec 下，阅读。位于 frameworks/av/media/libmedia/include/media/omx/1.0，可以看到它是继承于。
Android 13 - Media框架（15）- OpenMax（三）
青山渺渺
11-28 2588
上一节学习了 media.codec 服务中的部分内容，这一节我们将一起了解 OMX IL 层的 API 以及相关的结构体等内容。
手把手教你如何搭建一个自己的安卓快速开发框架之带你做自己的APP(三)
q2nAmor
04-10 7723
点击查看上一篇文章：手把手教你如何搭建一个自己的安卓快速开发框架之带你做自己的APP(二)继上一篇我们的进一步封装，包含 OkhttpRequest EventBus Json解析，基类数据封装 ButterKnife 那么，这一篇，我准备加入： BaseFragment 精美的仿微信底部菜单栏 网络请求失败时如何显示空View 继续来完善我们的快速开发框架。1、开门见山，看下Bas
Android MediaCodec简单总结
u013914309的博客
05-10 6066
#.MedaiCodec简介 MediaCodec是Android中提供的音视频编码、解码工具。它主要是完成上层接口的封装，提供给开发者使用，编解码功能实际是在native底层服务中完成的。 #.MediaCodec工作的宏观流程： ##.包换两个缓冲区队列 一个输入缓冲区队列，包含一组输入缓冲区(格式ByteBuffer)； 一个输出缓冲区队列，包含一组输出缓冲区(格式ByteBuffer)； ##.使用中，需要不断重复以下过程： 1.把原始数据放入输入缓冲区队列中一个..
Android系统编码MediaCodec
最新发布
轻口味的专栏
09-13 1273
除了使用MediaCodec进行编码之外，另外一种比较流行的方案就是使用ffmpeg+x264/openh264进行软编码，ffmpeg是用于一些视频帧的预处理。这里主要是使用x264/openh264作为视频的编码器。
Android Media (Audio) Framework Analyse
明伟的专栏
01-05 7234
Copyright：http://blog.csdn.net/myzhzygh/article/details/7429687 1 Android多媒体框架结构 Android 多媒体系统纵向跨越了Android系统的所有4个层次： Java应用程序层、Java框架层、本地代码层、Linux驱动层。多媒体本地代码层是多媒体系统的重点。 Android媒体播放器的模块结构如图1所示。
Android MediaCodec
liuning1985622的博客
05-06 1317
MediaCodec是Android音视频中相当重要的一个API。MediaCodec类可以用于使用一些基本的多媒体编解码器（音视频编解码组件），它是Android基本的多媒体支持基础架构的一部分通常和 MediaExtractor, MediaSync, MediaMuxer, MediaCrypto, MediaDrm, Image, Surface, and AudioTrack 一起使用。广义而言，编解码器处理输入数据以生成输出数据。它异步处理数据并使用一组输入和输出缓冲区。
Android-Intel-INDE-media-demo
05-19
3. **多媒体框架**：Android系统提供了一系列的多媒体API，如MediaPlayer、MediaCodec等，用于处理音频和视频。开发者需要了解如何使用这些API来播放、解码和编码多媒体文件。 4. **OpenGL ES**：为了实现更高级的...
av-android-4.2.2_r1.2-media-libstagefright-wifi-display
10-16
libstagefright是Android多媒体处理的核心库，主要由一系列组件构成，包括MediaExtractor（媒体提取器）、MediaCodec（媒体编解码器）和MediaPlayer等。这些组件协同工作，实现多媒体数据的解析、解码、编码以及...
Android - H.264 - MediaCodec硬编码
你的博客
07-25 801
int framerate = 5; int width = 640; int height = 480; NV21Convertor mConvertor; MediaCodec mMediaCodec; // 初始化/设置/开始执行 ---> 编码器 public static void initMediaCodec() { int dgree = getDgree(mContext); // bitrate 比特率 .
Android多媒体(一)--mediacodec剖析
zhuchengcheng1992的博客
03-17 449
sfaf
Android 采用MediaCodec实现Camera预览视频编解码
12-14
Android MediaCodec 实现Camera预览帧数据编解码并投射至另外的SurfaceView显示，另外附加Camera2的使用。
Android笔记--MediaCodec(一)
ljt2724960661的博客
03-30 1316
这一节主要来了解一下MediaCodec，Android MediaCodec 是...
Android 13 - Media框架（6）- NuPlayer
青山渺渺
08-22 4045
到这里 NuPlayer 的了解就告一段落，里面异步处理的思想 和 播放器的处理流程 还是要多多揣摩学习，回想起自己写的 Player 各种处理速度都不理想，还是太年轻了。startpauseresetAsync再对比下两个暂停的实现方式：pause 通过暂停 Source 送数据，暂停 Render 渲染数据来完成，Decoder 不需要暂停；flush 的暂停通过不给 Decoder 喂数据来实现，不需要暂停 Source。
Android 13 - Media框架（4）- MediaPlayerService
青山渺渺
08-18 4786
MediaPlayerService是android的多媒体框架的核心服务之一，该服务存储有android平台所支援的编解码器信息，管理所有通过MediaPlayer创建的播放器实例，起着承上启下的作用，这一节我们将了解MediaPlayerService中的内容。
Android 13 - Media框架（20）- ACodec（二）
青山渺渺
12-09 2195
这一节开始我们就来学习 ACodec 的实现。
1. Android MultiMedia框架完全解析 - 从开机到MediaServer的注册过程
吾皇的博客
03-31 8983
Android的App一般是用java写的，大致流程如下： MediaPlayer mediaPlayer = new MediaPlayer(); mediaPlayer.setOnCompletionListener(new OnCompletionListener() { @Override public void onCompletion(MediaPlayer mp){ mediaP...
Android 13 - Media框架（10）- NuPlayer::Renderer
青山渺渺
09-05 1930
这一节我们来了解 NuPlayer Renderer 是如何工作，avsync 机制是如何运行的。
Android 13 - Media框架（1）- 总览
青山渺渺
07-30 4495
开始学习前还有一些前备知识需要了解，包括智能指针、异步消息机制、以及binder框架，这三部分穿插于Android Media框架的各个角落，先了解他们会对看代码有些许帮助。我在学习Media框架之前已经提前学习了这部分的内容，也做了一些笔记，这里也贴出来让有需要的同学看看。为了加深对Android Media框架的理解，决定在这里记录下学习过程中碰到的问题以及一些个人思考。对于binder的学习可以不用很深入（我也不太会，笔记记录的乱起八糟），了解如何使用即可。
android中编解码框架中，MediaSource的功能是什么？ 它与mediacodec是什么关系
06-04
在 Android 中，MediaSource 是一个接口，用于表示媒体数据的来源。...因此，MediaSource 和 MediaCodec 是 Android 媒体框架中的两个不同组件，但它们通常一起使用，以完成对媒体数据的解码和播放。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

青山渺渺

感谢支持

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值