FrameObject inherit from VCMEncodedFrame.

webrtc/modules/video_coding/frame_object.h

 /*
  *  Copyright (c) 2016 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.
  */
 
 #ifndef WEBRTC_MODULES_VIDEO_CODING_FRAME_OBJECT_H_
 #define WEBRTC_MODULES_VIDEO_CODING_FRAME_OBJECT_H_
 
 #include "webrtc/common_types.h"
 #include "webrtc/modules/include/module_common_types.h"
+#include "webrtc/modules/video_coding/encoded_frame.h"
 
 namespace webrtc {
 namespace video_coding {
 
-class FrameObject {
+class FrameObject : public webrtc::VCMEncodedFrame {

[stefan-webrtc, 2016/06/29 16:43:24]

What do you think of the option of adding a constructor to VCMEncodedFrame
instead which takes a FrameObject calls GetBitstream() on it to get a copy of
the bitstream, and initializes its members based on the public members of the
FrameObject? That way we don't need this inheritance.

Some of the things needed to fully initialize the VCMEncodedFrame isn't
available in the FrameObject, but either they may not be needed at all after the
jitter buffer, or they probably have to be added to FrameObject later anyway to
replace VCMEnocdedFrame, right?

[philipel, 2016/06/30 09:34:15]

Sounds reasonable but I don't think it makes much of a difference in regards to
the long-term goal (replacing VCMEncodedFrame with FrameObject). I think both
will be equally complex and require the same amount of work.
 
That's right, we don't need everything to be initialized after the jitter buffer
and things that are in the VCMEncodedFrame will have to be moved to the
FrameObject class as the VCMEncodedFrame is gradually remvoed.

  public:
   static const uint8_t kMaxFrameReferences = 5;
 
   FrameObject();
 
   virtual bool GetBitstream(uint8_t* destination) const = 0;
   virtual ~FrameObject() {}
 
   // The tuple (|picture_id|, |spatial_layer|) uniquely identifies a frame
   // object. For codec types that don't necessarily have picture ids they
@@ skipping 16 matching lines @@
   RtpFrameObject(PacketBuffer* packet_buffer,
                  uint16_t first_seq_num,
                  uint16_t last_seq_num,
                  size_t frame_size,
                  int times_nacked);
 
   ~RtpFrameObject();
   uint16_t first_seq_num() const;
   uint16_t last_seq_num() const;
   int times_nacked() const;
-  FrameType frame_type() const;
+  enum FrameType frame_type() const;
   VideoCodecType codec_type() const;
   bool GetBitstream(uint8_t* destination) const override;
   RTPVideoTypeHeader* GetCodecHeader() const;
 
  private:
   PacketBuffer* packet_buffer_;
-  FrameType frame_type_;
+  enum FrameType frame_type_;
   VideoCodecType codec_type_;
   uint16_t first_seq_num_;
   uint16_t last_seq_num_;
 
   // Equal to times nacked of the packet with the highet times nacked
   // belonging to this frame.
   int times_nacked_;
 };
 
 }  // namespace video_coding
 }  // namespace webrtc
 
 #endif  // WEBRTC_MODULES_VIDEO_CODING_FRAME_OBJECT_H_