tor-browser

The Tor Browser
git clone https://git.dasho.dev/tor-browser.git
Log | Files | Refs | README | LICENSE

AndroidDataEncoder.h (4632B)

      1 /* This Source Code Form is subject to the terms of the Mozilla Public
      2 * License, v. 2.0. If a copy of the MPL was not distributed with this
      3 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
      4 
      5 #ifndef DOM_MEDIA_PLATFORMS_ANDROID_ANDROIDDATAENCODER_H_
      6 #define DOM_MEDIA_PLATFORMS_ANDROID_ANDROIDDATAENCODER_H_
      7 
      8 #include "JavaCallbacksSupport.h"
      9 #include "MediaData.h"
     10 #include "PlatformEncoderModule.h"
     11 #include "mozilla/Maybe.h"
     12 #include "mozilla/Mutex.h"
     13 
     14 namespace mozilla {
     15 
     16 class AndroidDataEncoder final : public MediaDataEncoder {
     17 public:
     18  NS_INLINE_DECL_THREADSAFE_REFCOUNTING(AndroidDataEncoder, final);
     19 
     20  AndroidDataEncoder(const EncoderConfig& aConfig,
     21                     const RefPtr<TaskQueue>& aTaskQueue)
     22      : mConfig(aConfig), mTaskQueue(aTaskQueue) {
     23    MOZ_ASSERT(mConfig.mSize.width > 0 && mConfig.mSize.height > 0);
     24    MOZ_ASSERT(mTaskQueue);
     25  }
     26 
     27  RefPtr<InitPromise> Init() override;
     28  RefPtr<EncodePromise> Encode(const MediaData* aSample) override;
     29  RefPtr<EncodePromise> Encode(nsTArray<RefPtr<MediaData>>&& aSamples) override;
     30  RefPtr<EncodePromise> Drain() override;
     31  RefPtr<ShutdownPromise> Shutdown() override;
     32  RefPtr<GenericPromise> SetBitrate(uint32_t aBitsPerSec) override;
     33  RefPtr<ReconfigurationPromise> Reconfigure(
     34      const RefPtr<const EncoderConfigurationChangeList>& aConfigurationChanges)
     35      override {
     36    // General reconfiguration interface not implemented right now
     37    return MediaDataEncoder::ReconfigurationPromise::CreateAndReject(
     38        NS_ERROR_DOM_MEDIA_FATAL_ERR, __func__);
     39  };
     40 
     41  nsCString GetDescriptionName() const override { return "Android Encoder"_ns; }
     42 
     43 private:
     44  class CallbacksSupport final : public JavaCallbacksSupport {
     45   public:
     46    explicit CallbacksSupport(AndroidDataEncoder* aEncoder)
     47        : mMutex("AndroidDataEncoder::CallbacksSupport") {
     48      MutexAutoLock lock(mMutex);
     49      mEncoder = aEncoder;
     50    }
     51 
     52    ~CallbacksSupport() {
     53      MutexAutoLock lock(mMutex);
     54      mEncoder = nullptr;
     55    }
     56 
     57    void HandleInput(int64_t aTimestamp, bool aProcessed) override;
     58    void HandleOutput(java::Sample::Param aSample,
     59                      java::SampleBuffer::Param aBuffer) override;
     60    void HandleOutputFormatChanged(
     61        java::sdk::MediaFormat::Param aFormat) override;
     62    void HandleError(const MediaResult& aError) override;
     63 
     64   private:
     65    Mutex mMutex;
     66    AndroidDataEncoder* mEncoder MOZ_GUARDED_BY(mMutex);
     67  };
     68  friend class CallbacksSupport;
     69 
     70  ~AndroidDataEncoder() override { MOZ_ASSERT(!mJavaEncoder); }
     71 
     72  // Methods only called on mTaskQueue.
     73  RefPtr<InitPromise> ProcessInit();
     74  RefPtr<EncodePromise> ProcessEncode(nsTArray<RefPtr<MediaData>>&& aSamples);
     75  RefPtr<EncodePromise> ProcessDrain();
     76  RefPtr<ShutdownPromise> ProcessShutdown();
     77  void ProcessInput();
     78  void ProcessOutput(java::Sample::GlobalRef&& aSample,
     79                     java::SampleBuffer::GlobalRef&& aBuffer);
     80  RefPtr<MediaRawData> GetOutputData(java::SampleBuffer::Param aBuffer,
     81                                     const int32_t aOffset, const int32_t aSize,
     82                                     const bool aIsKeyFrame);
     83  RefPtr<MediaRawData> GetOutputDataH264(java::SampleBuffer::Param aBuffer,
     84                                         const int32_t aOffset,
     85                                         const int32_t aSize,
     86                                         const bool aIsKeyFrame);
     87  void Error(const MediaResult& aError);
     88 
     89  void AssertOnTaskQueue() const {
     90    MOZ_ASSERT(mTaskQueue->IsCurrentThreadIn());
     91  }
     92 
     93  EncoderConfig mConfig;
     94 
     95  RefPtr<TaskQueue> mTaskQueue;
     96 
     97  // Can be accessed on any thread, but only written on during init.
     98  bool mIsHardwareAccelerated = false;
     99 
    100  java::CodecProxy::GlobalRef mJavaEncoder;
    101  java::CodecProxy::NativeCallbacks::GlobalRef mJavaCallbacks;
    102  java::sdk::MediaFormat::GlobalRef mFormat;
    103  // Preallocated Java object used as a reusable storage for input buffer
    104  // information. Contents must be changed only on mTaskQueue.
    105  java::sdk::MediaCodec::BufferInfo::GlobalRef mInputBufferInfo;
    106 
    107  MozPromiseHolder<EncodePromise> mDrainPromise;
    108 
    109  // Accessed on mTaskqueue only.
    110  RefPtr<MediaByteBuffer> mYUVBuffer;
    111  EncodedData mEncodedData;
    112  // SPS/PPS NALUs for realtime usage, avcC otherwise.
    113  RefPtr<MediaByteBuffer> mConfigData;
    114  // Record the input sample duration because MediaCodec doesn’t provide it.
    115  media::TimeUnit mInputSampleDuration = media::TimeUnit::Invalid();
    116 
    117  enum class DrainState { DRAINABLE, DRAINING, DRAINED };
    118  DrainState mDrainState = DrainState::DRAINABLE;
    119 
    120  Maybe<MediaResult> mError;
    121 };
    122 
    123 }  // namespace mozilla
    124 
    125 #endif