Deliver video frames on Android, on the decode thread.

webrtc/modules/video_coding/video_coding_impl.h

 /*
  *  Copyright (c) 2012 The WebRTC project authors. All Rights Reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
@@ skipping 17 matching lines @@
 #include "webrtc/modules/video_coding/receiver.h"
 #include "webrtc/modules/video_coding/timing.h"
 #include "webrtc/rtc_base/onetimeevent.h"
 #include "webrtc/rtc_base/sequenced_task_checker.h"
 #include "webrtc/rtc_base/thread_annotations.h"
 #include "webrtc/rtc_base/thread_checker.h"
 #include "webrtc/system_wrappers/include/clock.h"
 
 namespace webrtc {
 
+class ProcessThread;
 class VideoBitrateAllocator;
 class VideoBitrateAllocationObserver;
 
 namespace vcm {
 
 class VCMProcessTimer {
  public:
   static const int64_t kDefaultProcessIntervalMs = 1000;
 
   VCMProcessTimer(int64_t periodMs, Clock* clock)
@@ skipping 95 matching lines @@
 };
 
 class VideoReceiver : public Module {
  public:
   VideoReceiver(Clock* clock,
                 EventFactory* event_factory,
                 EncodedImageCallback* pre_decode_image_callback,
                 VCMTiming* timing,
                 NackSender* nack_sender = nullptr,
                 KeyFrameRequestSender* keyframe_request_sender = nullptr);
-  ~VideoReceiver();
+  ~VideoReceiver() override;
 
   int32_t RegisterReceiveCodec(const VideoCodec* receiveCodec,
                                int32_t numberOfCores,
                                bool requireKeyFrame);
 
   void RegisterExternalDecoder(VideoDecoder* externalDecoder,
                                uint8_t payloadType);
   int32_t RegisterReceiveCallback(VCMReceiveCallback* receiveCallback);
   int32_t RegisterReceiveStatisticsCallback(
       VCMReceiveStatisticsCallback* receiveStats);
   int32_t RegisterFrameTypeCallback(VCMFrameTypeCallback* frameTypeCallback);
   int32_t RegisterPacketRequestCallback(VCMPacketRequestCallback* callback);
 
   int32_t Decode(uint16_t maxWaitTimeMs);
 
   int32_t Decode(const webrtc::VCMEncodedFrame* frame);
 
-  // Called on the decoder thread when thread is exiting.
-  void DecodingStopped();
+#if defined(WEBRTC_ANDROID)
+  // See https://bugs.chromium.org/p/webrtc/issues/detail?id=7361
+  void PollDecodedFrames();
+#endif
 
   int32_t IncomingPacket(const uint8_t* incomingPayload,
                          size_t payloadLength,
                          const WebRtcRTPHeader& rtpInfo);
   int32_t SetMinimumPlayoutDelay(uint32_t minPlayoutDelayMs);
   int32_t SetRenderDelay(uint32_t timeMS);
   int32_t Delay() const;
 
   // DEPRECATED.
   int SetReceiverRobustnessMode(
       VideoCodingModule::ReceiverRobustness robustnessMode,
       VCMDecodeErrorMode errorMode);
 
   void SetNackSettings(size_t max_nack_list_size,
                        int max_packet_age_to_nack,
                        int max_incomplete_time_ms);
 
   void SetDecodeErrorMode(VCMDecodeErrorMode decode_error_mode);
   int SetMinReceiverDelay(int desired_delay_ms);
 
   int32_t SetReceiveChannelParameters(int64_t rtt);
   int32_t SetVideoProtection(VCMVideoProtection videoProtection, bool enable);
 
   int64_t TimeUntilNextProcess() override;
   void Process() override;
+  void ProcessThreadAttached(ProcessThread* process_thread) override;
 
   void TriggerDecoderShutdown();
+  void DecoderThreadStarting();
+  void DecoderThreadStopped();
 
  protected:
-  int32_t Decode(const webrtc::VCMEncodedFrame& frame)
-      EXCLUSIVE_LOCKS_REQUIRED(receive_crit_);
+  int32_t Decode(const webrtc::VCMEncodedFrame& frame);
   int32_t RequestKeyFrame();
 
  private:
+  // Used for DCHECKing thread correctness.
+  // In build where DCHECKs are enabled, will return false before
+  // DecoderThreadStarting is called, then true until DecoderThreadStopped
+  // is called.
+  // In builds where DCHECKs aren't enabled, it will return true.
+  bool IsDecoderThreadRunning();
+
   rtc::ThreadChecker construction_thread_;
+  rtc::ThreadChecker decoder_thread_;
+  rtc::ThreadChecker module_thread_;
   Clock* const clock_;
   rtc::CriticalSection process_crit_;
-  rtc::CriticalSection receive_crit_;
   VCMTiming* _timing;
   VCMReceiver _receiver;
   VCMDecodedFrameCallback _decodedFrameCallback;
-  VCMFrameTypeCallback* _frameTypeCallback GUARDED_BY(process_crit_);
-  VCMReceiveStatisticsCallback* _receiveStatsCallback GUARDED_BY(process_crit_);
-  VCMPacketRequestCallback* _packetRequestCallback GUARDED_BY(process_crit_);
 
-  VCMFrameBuffer _frameFromFile;
+  // These callbacks are set on the construction thread before being attached
+  // to the module thread or decoding started, so a lock is not required.
+  VCMFrameTypeCallback* _frameTypeCallback;
+  VCMReceiveStatisticsCallback* _receiveStatsCallback;
+  VCMPacketRequestCallback* _packetRequestCallback;
+
+  // Used on both the module and decoder thread.
   bool _scheduleKeyRequest GUARDED_BY(process_crit_);
   bool drop_frames_until_keyframe_ GUARDED_BY(process_crit_);
-  size_t max_nack_list_size_ GUARDED_BY(process_crit_);
 
-  VCMCodecDataBase _codecDataBase GUARDED_BY(receive_crit_);
-  EncodedImageCallback* pre_decode_image_callback_;
+  // Modified on the construction thread while not attached to the process
+  // thread.  Once attached to the process thread, its value is only read
+  // so a lock is not required.
+  size_t max_nack_list_size_;
 
-  VCMProcessTimer _receiveStatsTimer;
-  VCMProcessTimer _retransmissionTimer;
-  VCMProcessTimer _keyRequestTimer;
-  QpParser qp_parser_;
-  ThreadUnsafeOneTimeEvent first_frame_received_;
+  // Callbacks are set before the decoder thread starts.
+  // Once the decoder thread has been started, usage of |_codecDataBase| moves
+  // over to the decoder thread.
+  VCMCodecDataBase _codecDataBase;
+  EncodedImageCallback* const pre_decode_image_callback_;
+
+  VCMProcessTimer _receiveStatsTimer ACCESS_ON(module_thread_);
+  VCMProcessTimer _retransmissionTimer ACCESS_ON(module_thread_);
+  VCMProcessTimer _keyRequestTimer ACCESS_ON(module_thread_);
+  QpParser qp_parser_ ACCESS_ON(decoder_thread_);
+  ThreadUnsafeOneTimeEvent first_frame_received_ ACCESS_ON(decoder_thread_);
+  // Modified on the construction thread. Can be read without a lock and assumed
+  // to be non-null on the module and decoder threads.
+  ProcessThread* process_thread_ = nullptr;
+  bool is_attached_to_process_thread_ ACCESS_ON(construction_thread_) = false;
+#if RTC_DCHECK_IS_ON
+  bool decoder_thread_is_running_ = false;
+#endif
 };
 
 }  // namespace vcm
 }  // namespace webrtc
 #endif  // WEBRTC_MODULES_VIDEO_CODING_VIDEO_CODING_IMPL_H_