Line data    Source code

       1             : /* Copyright (c) 2011 The WebRTC project authors. All Rights Reserved.
       2             : *
       3             : *  Use of this source code is governed by a BSD-style license
       4             : *  that can be found in the LICENSE file in the root of the source
       5             : *  tree. An additional intellectual property rights grant can be found
       6             : *  in the file PATENTS.  All contributing project authors may
       7             : *  be found in the AUTHORS file in the root of the source tree.
       8             : */
       9             : /*
      10             : * This file defines the interface for doing temporal layers with VP8.
      11             : */
      12             : #ifndef WEBRTC_MODULES_VIDEO_CODING_CODECS_VP8_TEMPORAL_LAYERS_H_
      13             : #define WEBRTC_MODULES_VIDEO_CODING_CODECS_VP8_TEMPORAL_LAYERS_H_
      14             : 
      15             : #include <vector>
      16             : 
      17             : #include "webrtc/common_video/include/video_image.h"
      18             : #include "webrtc/typedefs.h"
      19             : 
      20             : struct vpx_codec_enc_cfg;
      21             : typedef struct vpx_codec_enc_cfg vpx_codec_enc_cfg_t;
      22             : 
      23             : namespace webrtc {
      24             : 
      25             : struct CodecSpecificInfoVP8;
      26             : 
      27           0 : class TemporalLayers {
      28             :  public:
      29             :   // Factory for TemporalLayer strategy. Default behavior is a fixed pattern
      30             :   // of temporal layers. See default_temporal_layers.cc
      31           0 :   virtual ~TemporalLayers() {}
      32             : 
      33             :   // Returns the recommended VP8 encode flags needed. May refresh the decoder
      34             :   // and/or update the reference buffers.
      35             :   virtual int EncodeFlags(uint32_t timestamp) = 0;
      36             : 
      37             :   // Update state based on new bitrate target and incoming framerate.
      38             :   // Returns the bitrate allocation for the active temporal layers.
      39             :   virtual std::vector<uint32_t> OnRatesUpdated(int bitrate_kbps,
      40             :                                                int max_bitrate_kbps,
      41             :                                                int framerate) = 0;
      42             : 
      43             :   // Update the encoder configuration with target bitrates or other parameters.
      44             :   // Returns true iff the configuration was actually modified.
      45             :   virtual bool UpdateConfiguration(vpx_codec_enc_cfg_t* cfg) = 0;
      46             : 
      47             :   virtual void PopulateCodecSpecific(bool base_layer_sync,
      48             :                                      CodecSpecificInfoVP8* vp8_info,
      49             :                                      uint32_t timestamp) = 0;
      50             : 
      51             :   virtual void FrameEncoded(unsigned int size, uint32_t timestamp, int qp) = 0;
      52             : 
      53             :   virtual int CurrentLayerId() const = 0;
      54             : };
      55             : 
      56             : class TemporalLayersListener;
      57             : class TemporalLayersFactory {
      58             :  public:
      59           0 :   TemporalLayersFactory() : listener_(nullptr) {}
      60           0 :   virtual ~TemporalLayersFactory() {}
      61             :   virtual TemporalLayers* Create(int simulcast_id,
      62             :                                  int temporal_layers,
      63             :                                  uint8_t initial_tl0_pic_idx) const;
      64             :   void SetListener(TemporalLayersListener* listener);
      65             : 
      66             :  protected:
      67             :   TemporalLayersListener* listener_;
      68             : };
      69             : 
      70             : class ScreenshareTemporalLayersFactory : public webrtc::TemporalLayersFactory {
      71             :  public:
      72           0 :   ScreenshareTemporalLayersFactory() {}
      73           0 :   virtual ~ScreenshareTemporalLayersFactory() {}
      74             : 
      75             :   webrtc::TemporalLayers* Create(int simulcast_id,
      76             :                                  int num_temporal_layers,
      77             :                                  uint8_t initial_tl0_pic_idx) const override;
      78             : };
      79             : 
      80             : // Factory for a temporal layers strategy that adaptively changes the number of
      81             : // layers based on input frame rate so that the base layer has an acceptable
      82             : // frame rate. See realtime_temporal_layers.cc
      83             : class RealTimeTemporalLayersFactory : public TemporalLayersFactory {
      84             :  public:
      85           0 :   RealTimeTemporalLayersFactory() {}
      86           0 :   ~RealTimeTemporalLayersFactory() override {}
      87             :   TemporalLayers* Create(int simulcast_id,
      88             :                          int num_temporal_layers,
      89             :                          uint8_t initial_tl0_pic_idx) const override;
      90             : };
      91             : 
      92             : class TemporalLayersListener {
      93             :  public:
      94           0 :   TemporalLayersListener() {}
      95           0 :   virtual ~TemporalLayersListener() {}
      96             : 
      97             :   virtual void OnTemporalLayersCreated(int simulcast_id,
      98             :                                        TemporalLayers* layers) = 0;
      99             : };
     100             : 
     101             : }  // namespace webrtc
     102             : #endif  // WEBRTC_MODULES_VIDEO_CODING_CODECS_VP8_TEMPORAL_LAYERS_H_