src/third_party/webrtc/modules/video_coding/main/source/timing.h

   1 /*
   2  *  Copyright (c) 2011 The WebRTC project authors. All Rights Reserved.
   3  *
   4  *  Use of this source code is governed by a BSD-style license
   5  *  that can be found in the LICENSE file in the root of the source
   6  *  tree. An additional intellectual property rights grant can be found
   7  *  in the file PATENTS.  All contributing project authors may
   8  *  be found in the AUTHORS file in the root of the source tree.
   9  */
  10
  11 #ifndef WEBRTC_MODULES_VIDEO_CODING_MAIN_SOURCE_TIMING_H_
  12 #define WEBRTC_MODULES_VIDEO_CODING_MAIN_SOURCE_TIMING_H_
  13
  14 #include "webrtc/modules/video_coding/main/source/codec_timer.h"
  15 #include "webrtc/system_wrappers/interface/critical_section_wrapper.h"
  16 #include "webrtc/typedefs.h"
  17
  18 namespace webrtc {
  19
  20 class Clock;
  21 class TimestampExtrapolator;
  22
  23 class VCMTiming {
  24  public:
  25   // The primary timing component should be passed
  26   // if this is the dual timing component.
  27   VCMTiming(Clock* clock,
  28             VCMTiming* master_timing = NULL);
  29   ~VCMTiming();
  30
  31   // Resets the timing to the initial state.
  32   void Reset();
  33   void ResetDecodeTime();
  34
  35   // Set the amount of time needed to render an image. Defaults to 10 ms.
  36   void set_render_delay(uint32_t render_delay_ms);
  37
  38   // Set the minimum time the video must be delayed on the receiver to
  39   // get the desired jitter buffer level.
  40   void SetJitterDelay(uint32_t required_delay_ms);
  41
  42   // Set the minimum playout delay required to sync video with audio.
  43   void set_min_playout_delay(uint32_t min_playout_delay);
  44
  45   // Increases or decreases the current delay to get closer to the target delay.
  46   // Calculates how long it has been since the previous call to this function,
  47   // and increases/decreases the delay in proportion to the time difference.
  48   void UpdateCurrentDelay(uint32_t frame_timestamp);
  49
  50   // Increases or decreases the current delay to get closer to the target delay.
  51   // Given the actual decode time in ms and the render time in ms for a frame,
  52   // this function calculates how late the frame is and increases the delay
  53   // accordingly.
  54   void UpdateCurrentDelay(int64_t render_time_ms,
  55                           int64_t actual_decode_time_ms);
  56
  57   // Stops the decoder timer, should be called when the decoder returns a frame
  58   // or when the decoded frame callback is called.
  59   int32_t StopDecodeTimer(uint32_t time_stamp,
  60                           int64_t start_time_ms,
  61                           int64_t now_ms);
  62
  63   // Used to report that a frame is passed to decoding. Updates the timestamp
  64   // filter which is used to map between timestamps and receiver system time.
  65   void IncomingTimestamp(uint32_t time_stamp, int64_t last_packet_time_ms);
  66   // Returns the receiver system time when the frame with timestamp
  67   // frame_timestamp should be rendered, assuming that the system time currently
  68   // is now_ms.
  69   int64_t RenderTimeMs(uint32_t frame_timestamp, int64_t now_ms) const;
  70
  71   // Returns the maximum time in ms that we can wait for a frame to become
  72   // complete before we must pass it to the decoder.
  73   uint32_t MaxWaitingTime(int64_t render_time_ms, int64_t now_ms) const;
  74
  75   // Returns the current target delay which is required delay + decode time +
  76   // render delay.
  77   uint32_t TargetVideoDelay() const;
  78
  79   // Calculates whether or not there is enough time to decode a frame given a
  80   // certain amount of processing time.
  81   bool EnoughTimeToDecode(uint32_t available_processing_time_ms) const;
  82
  83   // Return current timing information.
  84   void GetTimings(int* decode_ms,
  85                   int* max_decode_ms,
  86                   int* current_delay_ms,
  87                   int* target_delay_ms,
  88                   int* jitter_buffer_ms,
  89                   int* min_playout_delay_ms,
  90                   int* render_delay_ms) const;
  91
  92   enum { kDefaultRenderDelayMs = 10 };
  93   enum { kDelayMaxChangeMsPerS = 100 };
  94
  95  protected:
  96   int32_t MaxDecodeTimeMs(FrameType frame_type = kVideoFrameDelta) const;
  97   int64_t RenderTimeMsInternal(uint32_t frame_timestamp, int64_t now_ms) const;
  98   uint32_t TargetDelayInternal() const;
  99
 100  private:
 101   CriticalSectionWrapper* crit_sect_;
 102   Clock* clock_;
 103   bool master_;
 104   TimestampExtrapolator* ts_extrapolator_;
 105   VCMCodecTimer codec_timer_;
 106   uint32_t render_delay_ms_;
 107   uint32_t min_playout_delay_ms_;
 108   uint32_t jitter_delay_ms_;
 109   uint32_t current_delay_ms_;
 110   int last_decode_ms_;
 111   uint32_t prev_frame_timestamp_;
 112 };
 113 }  // namespace webrtc
 114
 115 #endif  // WEBRTC_MODULES_VIDEO_CODING_MAIN_SOURCE_TIMING_H_