MediaCodec中的AHandler、ALooper和AMessage机制简单分析

一、 前言:
Android媒体通路中,大量充斥着AHandler、ALooper和AMessage的消息机制,之前简单分析了一下java层的消息机制,而native层的消息机制同java层原理类似,但又有一些区别,所以单独拿来分析一下,在nuplayer和mediacodec中随处可见这种异步机制。
三者的简单概括:
AMessage:我们要发送的消息,类似于一个“包裹”,“邮件”;
AHandler:消息处理者,与java层消息机制不同的是,这里的hanlder不会有发送message的功能,每个handler都有一个唯一的标识符ID;
ALooper:消息分发的控制者,实际上通过一个“小弟”ALooperRoster来协调控制message与handler;

下面我们将以mediacodec中一条消息的发送为例,来看下一条message是如何被打包、发送再到处理的,进而结合源码,对整个native层的AHandler、ALooper和AMessage有一个全面的了解。
相关代码路径(Android5.1):

AHandler、ALooper和AMessage相关源码路径:
frameworks\av\media\libstagefright\foundation
mediacodec代码路径:
frameworks\av\media\libstagefright

二、示例分析:

  1. 消息机制的建立:
    消息机制的建立首先是ALooper的实例化:
    mediacodec的java接口通过JNI会调入到android_media_MediaCodec.cpp文件中,在native层,会先去实例化一个JMediaCodec:
JMediaCodec::JMediaCodec(
        JNIEnv *env, jobject thiz,
        const char *name, bool nameIsType, bool encoder)
    : mClass(NULL),
      mObject(NULL) {
      ...
    /* 1.实例化一个Alooper */
    mLooper = new ALooper;
    mLooper->setName("MediaCodec_looper");

	/* 2.开启looper的start */
    mLooper->start(
            false,      // runOnCallingThread
            true,       // canCallJava
            PRIORITY_FOREGROUND);
        if (nameIsType) {
        if (mDebug) {
            ALOGI("CreateByType(%s, encoder:%s)", name, encoder?"true":"false");
            mIsVideo = !strncasecmp(name, "video/", 6);
        }
        /* 3.实例化mediacodec */
        mCodec = MediaCodec::CreateByType(mLooper, name, encoder, &mInitStatus);
    } else {
        if (mDebug) {
            ALOGI("CreateByComponentName(%s)", name);
            AString nameString = AString(name);
            nameString.trim();
            if (nameString.find("video", 0) >= 0) {
                mIsVideo = true;
            }
        }
        mCodec = MediaCodec::CreateByComponentName(mLooper, name, &mInitStatus);
    }
    ...
}

截取了该函数中关键部分代码,首先是实例化ALooper,然后是设置当前线程中looper的名字,注意,native层代码中将不再限制一个线程只有一个looper:


ALooper::ALooper()
    : mRunningLocally(false) {
	/* 每个looper会维护一个全局变量ALooperRoster,也就是前文说的“小弟” */
    gLooperRoster.unregisterStaleHandlers();
}

void ALooper::setName(const char *name) {
    mName = name;
}

从构造函数可以看出来,ALooper是单例设计模式,每个ALooper只有一个ALooperRoster,ALooper很多重要的工作都是交由ALooperRoster来完成的。
回到JMediaCodec看第二步,start函数:

status_t ALooper::start(
        bool runOnCallingThread, bool canCallJava, int32_t priority) {
    if (runOnCallingThread) {
        {
            Mutex::Autolock autoLock(mLock);

            if (mThread != NULL || mRunningLocally) {
                return INVALID_OPERATION;
            }

            mRunningLocally = true;
        }

        do {
        } while (loop());

        return OK;
    }

    Mutex::Autolock autoLock(mLock);

    if (mThread != NULL || mRunningLocally) {
        return INVALID_OPERATION;
    }
	/* 创建了一个thread给looper处理 */
    mThread = new LooperThread(this, canCallJava);
	/* 调用run方法让thread转起来 */
    status_t err = mThread->run(
            mName.empty() ? "ALooper" : mName.c_str(), priority);
    if (err != OK) {
        mThread.clear();
    }

    return err;
}

实际上,我们可以把looper看成是一个thread来操作;
JMediaCodec的第三步就是去实例化mediacodec了:

sp<MediaCodec> MediaCodec::CreateByType(
        const sp<ALooper> &looper, const char *mime, bool encoder, status_t *err) {
    /* 实例化mediacodec */
    sp<MediaCodec> codec = new MediaCodec(looper);
	
	/* 执行init操作 */
    const status_t ret = codec->init(mime, true /* nameIsType */, encoder);
    if (err != NULL) {
        *err = ret;
    }
    return ret == OK ? codec : NULL; // NULL deallocates codec.
}
MediaCodec::MediaCodec(const sp<ALooper> &looper)
    : mState(UNINITIALIZED),
      mLooper(looper),
      mCodec(NULL),
      mReplyID(0),
      mFlags(0),
      mStickyError(OK),
      mSoftRenderer(NULL),
      mBatteryStatNotified(false),
      mIsVideo(false),
      mDequeueInputTimeoutGeneration(0),
      mDequeueInputReplyID(0),
      mDequeueOutputTimeoutGeneration(0),
      mDequeueOutputReplyID(0),
      mHaveInputSurface(false) {
    mStats = false;
    mBufferCounter = 0;
    char value[PROPERTY_VALUE_MAX];
    if (property_get("service.media.codec.stats", value, NULL)
        && (!strcasecmp("true", value))) {
        mStats = true;
    }
}

mediacodec构造中关键的一点就是把JMediaCodec实例化的looper给传过来了;
再看一下init函数,有点长,我们也只截取部分:

status_t MediaCodec::init(const AString &name, bool nameIsType, bool encoder) {
	...
	
	/* 1.实例化ACodec */
	mCodec = new ACodec;
    bool needDedicatedLooper = false;
    if (nameIsType && !strncasecmp(name.c_str(), "video/", 6)) {
        needDedicatedLooper = true;
    } else {
        AString tmp = name;
        if (tmp.endsWith(".secure")) {
            tmp.erase(tmp.size() - 7, 7);
        }
        const sp<IMediaCodecList> mcl = MediaCodecList::getInstance();
        ssize_t codecIdx = mcl->findCodecByName(tmp.c_str());
        if (codecIdx >= 0) {
            const sp<MediaCodecInfo> info = mcl->getCodecInfo(codecIdx);
            Vector<AString> mimes;
            info->getSupportedMimes(&mimes);
            for (size_t i = 0; i < mimes.size(); i++) {
                if (mimes[i].startsWith("video/")) {
                    needDedicatedLooper = true;
                    break;
                }
            }
        }
    }

    if (needDedicatedLooper) {
        if (mCodecLooper == NULL) {
        /* 2.mediacodec再创建一个looper */
            mCodecLooper = new ALooper;
            mCodecLooper->setName("CodecLooper");
            mCodecLooper->start(false, false, ANDROID_PRIORITY_AUDIO);
        }
		/* 3.将ACodec注册到mediacodec的looper中 */
        mCodecLooper->registerHandler(mCodec);
    } else {
        mLooper->registerHandler(mCodec);
    }
	
	/* 4.将mediacodec注册到JMediaCodec的looper中 */
    mLooper->registerHandler(this);
    ...
}

init函数会去实例化ACodec,它与OMX进行交互,并且,在mediacodec中又创建了一个looper,然后就是调用registerHandler来将handler注册到looper中,这里需要点一下,mediacodec和acodec都是继承自handler,每个looper可以有多个handler,但是,每个handler只能被注册到一个looper中,看一下注册函数:

ALooper::handler_id ALooper::registerHandler(const sp<AHandler> &handler) {
    return gLooperRoster.registerHandler(this, handler);
}

转交ALooperRoster来处理:

ALooper::handler_id ALooperRoster::registerHandler(
        const sp<ALooper> looper, const sp<AHandler> &handler) {
    Mutex::Autolock autoLock(mLock);

	/* handler构造时默认id为0,如果不为0,说明该handler已经被注册 */
    if (handler->id() != 0) {
        CHECK(!"A handler must only be registered once.");
        return INVALID_OPERATION;
    }

    HandlerInfo info;			//打包handler
    info.mLooper = looper;		//记录当前looper
    info.mHandler = handler;	//记录注册handler
    /* 分配一个id */
    ALooper::handler_id handlerID = mNextHandlerID++;
    /* 这是一个KeyedVector,记录每个handlerinfo与id */
    mHandlers.add(handlerID, info);
	
	/* 将分配的id设置到handler中 */
    handler->setID(handlerID);

    return handlerID;
}

registerHandler完成的事就是将该handler注册到对应的looper中.
到目前为止,我们必须明白以下几点:
①JMediaCodec和mediacodec各自创建了一个looper;
②JMediaCodec的looper中注册了两个handler,分别是JMediaCodec和mediacodec;
③mediacodec的looper中目前只注册了ACodec这一个handler;

2. start指令中的消息传递:
这里选用mediacodec的start指令来看下消息收发,经过java层,jni,最终调用到mediacodec的start函数中:

status_t MediaCodec::start() {
	/* 实例化一个Amessage */
    sp<AMessage> msg = new AMessage(kWhatStart, id());

	/* 投递出去并获取响应 */
    sp<AMessage> response;
    return PostAndAwaitResponse(msg, &response);
}

AMessage的实例化很简单:

AMessage::AMessage(uint32_t what, ALooper::handler_id target)
    : mWhat(what),
      mTarget(target),
      mNumItems(0) {
}

看一下下面的PostAndAwaitResponse函数:

status_t MediaCodec::PostAndAwaitResponse(
        const sp<AMessage> &msg, sp<AMessage> *response) {
     /* 调用AMessage的postAndAwaitResponse函数 */
    status_t err = msg->postAndAwaitResponse(response);

    if (err != OK) {
        return err;
    }

    if (!(*response)->findInt32("err", &err)) {
        err = OK;
    }

    return err;
}

还是得去看AMessage中的函数实现:

status_t AMessage::postAndAwaitResponse(sp<AMessage> *response) {
    return gLooperRoster.postAndAwaitResponse(this, response);
}

这个gLooperRoster很眼熟,没错,就是ALooper中的ALooperRoster,可以看下AMessage.h:

AMessage.cpp:
extern ALooperRoster gLooperRoster;

AMessage是通过外部引用的ALooper中的“小弟”ALooperRoster,所以,AMessage的操作最终还是让ALooperRoster来接管了:

status_t ALooperRoster::postAndAwaitResponse(
        const sp<AMessage> &msg, sp<AMessage> *response) {
    /* 1.通过handler id 来找到注册的looper */
    sp<ALooper> looper = findLooper(msg->target());

    if (looper == NULL) {
        ALOGW("failed to post message. "
                "Target handler %d still registered, but object gone.",
                msg->target());
        response->clear();
        return -ENOENT;
    }

    Mutex::Autolock autoLock(mLock);

    uint32_t replyID = mNextReplyID++;

    msg->setInt32("replyID", replyID);
	
	/* 2.调用Alooper将消息投递出去 */
    looper->post(msg, 0 /* delayUs */);

    ssize_t index;
    while ((index = mReplies.indexOfKey(replyID)) < 0) {
        mRepliesCondition.wait(mLock);
    }

    *response = mReplies.valueAt(index);
    mReplies.removeItemsAt(index);

    return OK;
}

这个函数着重分析两点,首先是通过handler找到对应的looper,因为前面我们说过了,每个handler只能被注册到一个looper中,所以,在前面的KeyedVector中通过搜寻键值对的方式可以找到looper,接下来,就是调用looper的post函数将消息投递到对应的looper中了,注意区别,java层中的消息投递,是由hanlder.sendMessage来完成的。
我们具体看下post函数:

void ALooper::post(const sp<AMessage> &msg, int64_t delayUs) {
    Mutex::Autolock autoLock(mLock);
	/* 1.计算投递时间 */
    int64_t whenUs;
    if (delayUs > 0) {
        whenUs = GetNowUs() + delayUs;
    } else {
        whenUs = GetNowUs();
    }

	/* 2.遍历链表,找到一个系统时间大于该事件的时间 */
    List<Event>::iterator it = mEventQueue.begin();
    while (it != mEventQueue.end() && (*it).mWhenUs <= whenUs) {
        ++it;
    }

	/* 3.将消息打包成event */
    Event event;
    event.mWhenUs = whenUs;
    event.mMessage = msg;

    if (it == mEventQueue.begin()) {
        mQueueChangedCondition.signal();
    }

	/* 4.插入到事件队列中 */
    mEventQueue.insert(it, event);
}

post实现的逻辑很简单,就是将事件打包成event之后找一个合适的位置插入到事件链表中;
消息发送端的操作就分析完了,通过创建message所在的hanlder id,找到对应的looper,调用looper的post将消息投递出去
来看下接收端是何时建立并且如何处理消息的,还记得looper实例化之后调用的start函数吗?里面会去实例化一个thread:

...
    mThread = new LooperThread(this, canCallJava);

    status_t err = mThread->run(
            mName.empty() ? "ALooper" : mName.c_str(), priority);
    if (err != OK) {
        mThread.clear();
    }
...

LooperThread继承的是Android的thread基类,其构造函数中传入了looper对象:

    LooperThread(ALooper *looper, bool canCallJava)
        : Thread(canCallJava),
          mLooper(looper),
          mThreadId(NULL) {
    }

既然是继承自thread基类,那么必然覆写threadLoop方法,因为thread类中,threadLoop是一个纯虚函数,这里需要注意,threadLoop如果返回值为true,则会一直循环,具体的代码就不去分析了,扯了这么多,我们看一下LooperThread中threadLoop干的啥:

    virtual bool threadLoop() {
        return mLooper->loop();
    }

很简单,就去调用了ALooper中的loop函数,也就是说,如果mLooper->loop()返回值为true,那么该函数一直循环,因此,消息的取出就是在这里面做的了,看一下loop函数:

bool ALooper::loop() {
    Event event;

    {
        Mutex::Autolock autoLock(mLock);
        if (mThread == NULL && !mRunningLocally) {
            return false;
        }
        if (mEventQueue.empty()) {
            mQueueChangedCondition.wait(mLock);
            return true;
        }
        int64_t whenUs = (*mEventQueue.begin()).mWhenUs;
        int64_t nowUs = GetNowUs();

        if (whenUs > nowUs) {
            int64_t delayUs = whenUs - nowUs;
            mQueueChangedCondition.waitRelative(mLock, delayUs * 1000ll);

            return true;
        }

        event = *mEventQueue.begin();
        mEventQueue.erase(mEventQueue.begin());
    }
	/* 事件队列不为空,分发事件 */
    gLooperRoster.deliverMessage(event.mMessage);

    // NOTE: It's important to note that at this point our "ALooper" object
    // may no longer exist (its final reference may have gone away while
    // delivering the message). We have made sure, however, that loop()
    // won't be called again.

    return true;
}

果然代码中充斥着true,还是需要用到熟悉的ALooper“小弟”ALooperRoster,直接看关键函数deliverMessage:

void ALooperRoster::deliverMessage(const sp<AMessage> &msg) {
    sp<AHandler> handler;

    {
        Mutex::Autolock autoLock(mLock);

        ssize_t index = mHandlers.indexOfKey(msg->target());

        if (index < 0) {
            ALOGW("failed to deliver message. Target handler not registered.");
            return;
        }

        const HandlerInfo &info = mHandlers.valueAt(index);
        handler = info.mHandler.promote();

        if (handler == NULL) {
            ALOGW("failed to deliver message. "
                 "Target handler %d registered, but object gone.",
                 msg->target());

            mHandlers.removeItemsAt(index);
            return;
        }
    }
	/* 调用对应的handle处理消息 */
    handler->onMessageReceived(msg);
}

终于看到关键点了,onMessageReceived,这下你知道为什么每一个继承自AHandler的类中都要有onMessageReceived函数了吧,总算把消息投递到了“收件人”那里,至于start的消息具体干了啥,我们就不分析了,主要分析消息收发的过程。

三、总结:
给一张图总结一下JMediaCodec中三者间的关系:

在这里插入图片描述
①AMessage被封装成Event进行收发;
②每个AHandler只能被注册到一个ALooper中;
③Event投递最终是通过ALooper来的;
④ALooper实际是看成了一个线程来运行的,AHandler与Event的协调工作是通过ALooperRoster来完成的;

⑤JMediaCodec和MediaCodec这两个AHandler是注册在JMediaCodec实例化的ALooper中,而ACodec这个AHandler是注册在Mediacodec实例化多的ALooper中;

发布了36 篇原创文章 · 获赞 35 · 访问量 2816
展开阅读全文

没有更多推荐了,返回首页

©️2019 CSDN 皮肤主题: 书香水墨 设计师: CSDN官方博客

分享到微信朋友圈

×

扫一扫,手机浏览