Base screenshare layers on TemporalReferences.

webrtc/modules/video_coding/codecs/vp8/temporal_layers.h

 /* Copyright (c) 2011 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.
 */
 /*
 * This file defines the interface for doing temporal layers with VP8.
 */
 #ifndef WEBRTC_MODULES_VIDEO_CODING_CODECS_VP8_TEMPORAL_LAYERS_H_
 #define WEBRTC_MODULES_VIDEO_CODING_CODECS_VP8_TEMPORAL_LAYERS_H_
 
 #include <vector>
 
 #include "webrtc/common_video/include/video_image.h"
 #include "webrtc/typedefs.h"
 
 struct vpx_codec_enc_cfg;
 typedef struct vpx_codec_enc_cfg vpx_codec_enc_cfg_t;
 
 namespace webrtc {
 
 struct CodecSpecificInfoVP8;
 
+enum TemporalBufferUsage {
+  kNone = 0,
+  kReference = 1,
+  kUpdate = 2,
+  kReferenceAndUpdate = kReference | kUpdate,
+};
+
+enum TemporalFlags { kLayerSync = 1, kFreezeEntropy = 2 };
+
+struct TemporalReferences {
+  TemporalReferences(TemporalBufferUsage last,
+                     TemporalBufferUsage golden,
+                     TemporalBufferUsage arf);
+  TemporalReferences(TemporalBufferUsage last,
+                     TemporalBufferUsage golden,
+                     TemporalBufferUsage arf,
+                     int extra_flags);
+
+  const bool drop_frame;
+  const bool reference_last;
+  const bool update_last;
+  const bool reference_golden;
+  const bool update_golden;
+  const bool reference_arf;
+  const bool update_arf;

[sprang_webrtc, 2017/03/26 12:20:08]

Would it make sense to only store TemporalBufferUsage instead, and have getter
methods for these if the convenience is worth it? Feel like we have some
unnecessary redundancy in the flags are represented.

[pbos-webrtc, 2017/03/27 16:31:07]

Yes, since they can be checked as a bitmask we have the same thing. Done.

+
+  // TODO(pbos): Consider breaking these out of here and returning only a
+  // pattern index that needs to be returned to fill CodecSpecificInfoVP8 or
+  // EncodeFlags.
+  const bool layer_sync;
+  const bool freeze_entropy;
+
+ private:
+  TemporalReferences(TemporalBufferUsage last,
+                     TemporalBufferUsage golden,
+                     TemporalBufferUsage arf,
+                     bool layer_sync,
+                     bool freeze_entropy);
+};
+
 class TemporalLayers {
  public:
   // Factory for TemporalLayer strategy. Default behavior is a fixed pattern
   // of temporal layers. See default_temporal_layers.cc
   virtual ~TemporalLayers() {}
 
   // Returns the recommended VP8 encode flags needed. May refresh the decoder
   // and/or update the reference buffers.
-  virtual int EncodeFlags(uint32_t timestamp) = 0;
+  virtual TemporalReferences GetLayerConfig(uint32_t timestamp) = 0;
+
+  int EncodeFlags(uint32_t timestamp);
 
   // Update state based on new bitrate target and incoming framerate.
   // Returns the bitrate allocation for the active temporal layers.
   virtual std::vector<uint32_t> OnRatesUpdated(int bitrate_kbps,
                                                int max_bitrate_kbps,
                                                int framerate) = 0;
 
   // Update the encoder configuration with target bitrates or other parameters.
   // Returns true iff the configuration was actually modified.
   virtual bool UpdateConfiguration(vpx_codec_enc_cfg_t* cfg) = 0;
 
-  virtual void PopulateCodecSpecific(bool base_layer_sync,
+  virtual void PopulateCodecSpecific(bool is_keyframe,
                                      CodecSpecificInfoVP8* vp8_info,
                                      uint32_t timestamp) = 0;
 
-  virtual void FrameEncoded(unsigned int size, uint32_t timestamp, int qp) = 0;
+  virtual void FrameEncoded(unsigned int size, int qp) = 0;
 
   virtual int CurrentLayerId() const = 0;
 };
 
 class TemporalLayersListener;
 class TemporalLayersFactory {
  public:
   TemporalLayersFactory() : listener_(nullptr) {}
   virtual ~TemporalLayersFactory() {}
   virtual TemporalLayers* Create(int simulcast_id,
@@ skipping 19 matching lines @@
  public:
   TemporalLayersListener() {}
   virtual ~TemporalLayersListener() {}
 
   virtual void OnTemporalLayersCreated(int simulcast_id,
                                        TemporalLayers* layers) = 0;
 };
 
 }  // namespace webrtc
 #endif  // WEBRTC_MODULES_VIDEO_CODING_CODECS_VP8_TEMPORAL_LAYERS_H_