webrtc android AndroidSource类的分析

今天我们重点分析一下AndroidSource这个类。

为什么要开始分析这个类呢？

在 webrtc android 视频帧 VideoFrame 的理解 —– 第二篇这篇文章中，我们分析到，java层会把数据封装为VideoFrame,最终传递到底层.

NativeCapturerObserver.java 文件

  @Override
  public void onFrameCaptured(VideoFrame frame) {
    int width = frame.getBuffer().getWidth();
    int height = frame.getBuffer().getHeight();
    int rotation = frame.getRotation();
    long timeNs = frame.getTimestampNs();
    VideoFrame.Buffer buffer = frame.getBuffer() ;

    nativeOnFrameCaptured(nativeSource, width , height , rotation, timeNs , buffer);
  }

而且AndroidSource是刚好是Track,Sink的桥梁，所以我们需要把这个类的功能整明白，弄明白它存在的意义.

PeerConnectionFactory类会提供创建各种类的方法:

  public VideoSource createVideoSource(boolean isScreencast) {
    return new VideoSource(nativeCreateVideoSource(nativeFactory, isScreencast));
  }

让我们看Source的类继承图:

这里写图片描述

最开始VideoTrackSourceProxyWithInternal是以宏定义的方式来生成类的.

////也就是说，这里我其实可以把宏定义替换为源码的
//BEGIN_PROXY_MAP(VideoTrackSource)
//PROXY_SIGNALING_THREAD_DESTRUCTOR()
//PROXY_CONSTMETHOD0(SourceState, state)
//PROXY_CONSTMETHOD0(bool, remote)
//PROXY_CONSTMETHOD0(bool, is_screencast)
//PROXY_CONSTMETHOD0(absl::optional<bool>, needs_denoising)
//PROXY_METHOD1(bool, GetStats, Stats*)
//PROXY_WORKER_METHOD2(void,
//                     AddOrUpdateSink,
//                     rtc::VideoSinkInterface<VideoFrame>*,
//                     const rtc::VideoSinkWants&)
//PROXY_WORKER_METHOD1(void, RemoveSink, rtc::VideoSinkInterface<VideoFrame>*)
//PROXY_METHOD1(void, RegisterObserver, ObserverInterface*)
//PROXY_METHOD1(void, UnregisterObserver, ObserverInterface*)
//END_PROXY_MAP()

为了方便，我把它恢复成了代码的方式，方便大家观看代码:

template <class INTERNAL_CLASS>
    class VideoTrackSourceProxyWithInternal;

    typedef VideoTrackSourceProxyWithInternal<VideoTrackSourceInterface> VideoTrackSourceProxy;

    template <class INTERNAL_CLASS>
    class VideoTrackSourceProxyWithInternal : public VideoTrackSourceInterface {
    protected:
        typedef VideoTrackSourceInterface C;

    public:
        const INTERNAL_CLASS* internal() const { return c_; }
        INTERNAL_CLASS* internal() { return c_; }

//#define WORKER_PROXY_MAP_BOILERPLATE(c)
    protected:
        VideoTrackSourceProxyWithInternal(rtc::Thread* signaling_thread,
                                          rtc::Thread* worker_thread, INTERNAL_CLASS* c)
                : signaling_thread_(signaling_thread),
                  worker_thread_(worker_thread),
                  c_(c) {}

    private:
        mutable rtc::Thread* signaling_thread_;
        mutable rtc::Thread* worker_thread_;


//#define REFCOUNTED_PROXY_MAP_BOILERPLATE(c)
    protected:
        ~VideoTrackSourceProxyWithInternal() {
            MethodCall0<VideoTrackSourceProxyWithInternal, void> call(
                    this, &VideoTrackSourceProxyWithInternal::DestroyInternal);
            call.Marshal(RTC_FROM_HERE, destructor_thread());
        }

    private:
        void DestroyInternal() { c_ = nullptr; }
        rtc::scoped_refptr<INTERNAL_CLASS> c_;

    public:
        static rtc::scoped_refptr<VideoTrackSourceProxyWithInternal> Create(
                rtc::Thread* signaling_thread, rtc::Thread* worker_thread,
                INTERNAL_CLASS* c) {
            return new rtc::RefCountedObject<VideoTrackSourceProxyWithInternal>(signaling_thread,
                                                                                worker_thread, c);
        }


//PROXY_SIGNALING_THREAD_DESTRUCTOR()
    private:
        rtc::Thread* destructor_thread() const { return signaling_thread_; }

    public:  // NOLINTNEXTLINE

//PROXY_CONSTMETHOD0(SourceState, state)
        SourceState state() const override {
            ConstMethodCall0<C, SourceState> call(c_, &C::state);
            return call.Marshal(RTC_FROM_HERE, signaling_thread_);
        }

//PROXY_CONSTMETHOD0(bool, remote)
        bool remote() const override {
            ConstMethodCall0<C, bool> call(c_, &C::remote);
            return call.Marshal(RTC_FROM_HERE, signaling_thread_);
        }

//PROXY_CONSTMETHOD0(bool, is_screencast)
        bool is_screencast() const override {
            ConstMethodCall0<C, bool> call(c_, &C::is_screencast);
            return call.Marshal(RTC_FROM_HERE, signaling_thread_);
        }

//PROXY_CONSTMETHOD0(absl::optional<bool>, needs_denoising)
        absl::optional<bool> needs_denoising() const override {
            ConstMethodCall0< C, absl::optional<bool> > call(c_, &C::needs_denoising);
            return call.Marshal(RTC_FROM_HERE, signaling_thread_);
        }

//PROXY_METHOD1(bool, GetStats, Stats*)
        bool GetStats(Stats* a1) override {
            MethodCall1<C, bool, Stats*> call(c_, &C::GetStats, std::move(a1));
            return call.Marshal(RTC_FROM_HERE, signaling_thread_);
        }


// PROXY_WORKER_METHOD2(void,
//                      AddOrUpdateSink,
//                      rtc::VideoSinkInterface<VideoFrame>*,
//                      const rtc::VideoSinkWants&)
        void AddOrUpdateSink(rtc::VideoSinkInterface<VideoFrame>* a1, const rtc::VideoSinkWants& a2) override {
            MethodCall2<C, void, rtc::VideoSinkInterface<VideoFrame>* , const rtc::VideoSinkWants& > call(c_, &C::AddOrUpdateSink, std::move(a1),
                                                                                                          std::move(a2));
            return call.Marshal(RTC_FROM_HERE, worker_thread_);
        }

//PROXY_WORKER_METHOD1(void, RemoveSink, rtc::VideoSinkInterface<VideoFrame>*)
        void RemoveSink(rtc::VideoSinkInterface<VideoFrame>* a1) override {
            MethodCall1<C, void, rtc::VideoSinkInterface<VideoFrame>*> call(c_, &C::RemoveSink, std::move(a1));
            return call.Marshal(RTC_FROM_HERE, worker_thread_);
        }

//PROXY_METHOD1(void, RegisterObserver, ObserverInterface*)
        void RegisterObserver(ObserverInterface* a1) override {
            MethodCall1<C, void, ObserverInterface* > call(c_, &C::RegisterObserver, std::move(a1));
            return call.Marshal(RTC_FROM_HERE, signaling_thread_);
        }

//PROXY_METHOD1(void, UnregisterObserver, ObserverInterface*)
        void UnregisterObserver(ObserverInterface* a1) override {
            MethodCall1<C, void, ObserverInterface*> call(c_, &C::UnregisterObserver, std::move(a1));
            return call.Marshal(RTC_FROM_HERE, signaling_thread_);
        }

//END_PROXY_MAP()
    };

webrtc android AndroidSource类的分析

猜你喜欢