Revert of 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/generic_encoder.h"
 #include "webrtc/modules/video_coding/jitter_buffer.h"
 #include "webrtc/modules/video_coding/media_optimization.h"
 #include "webrtc/modules/video_coding/qp_parser.h"
 #include "webrtc/modules/video_coding/receiver.h"
 #include "webrtc/modules/video_coding/timing.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() override;
+  ~VideoReceiver();
 
   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);
 
-#if defined(WEBRTC_ANDROID)
-  // See https://bugs.chromium.org/p/webrtc/issues/detail?id=7361
-  void PollDecodedFrames();
-#endif
+  // Called on the decoder thread when thread is exiting.
+  void DecodingStopped();
 
   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);
+  int32_t Decode(const webrtc::VCMEncodedFrame& frame)
+      EXCLUSIVE_LOCKS_REQUIRED(receive_crit_);
   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_);
 
-  // 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.
+  VCMFrameBuffer _frameFromFile;
   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_);
 
-  // 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_;
+  VCMCodecDataBase _codecDataBase GUARDED_BY(receive_crit_);
+  EncodedImageCallback* pre_decode_image_callback_;
 
-  // 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
+  VCMProcessTimer _receiveStatsTimer;
+  VCMProcessTimer _retransmissionTimer;
+  VCMProcessTimer _keyRequestTimer;
+  QpParser qp_parser_;
+  ThreadUnsafeOneTimeEvent first_frame_received_;
 };
 
 }  // namespace vcm
 }  // namespace webrtc
 #endif  // WEBRTC_MODULES_VIDEO_CODING_VIDEO_CODING_IMPL_H_