Add StereoCodecAdapter classes

This CL is the step 1 for adding alpha channel support over the wire in webrtc.
- Add the footprint for adapter classes that wraps actual codecs.
- This CL does not add a webrtc::VideoFrame container that can carry alpha to 
make the CL shorter for an easier review. Therefore, it exercises a code path
for when we receive no alpha input, just regular I420 frames.
- Unittest sends a video frame for encode/decode through these adapters and 
checks the output PSNR.
- See https://webrtc-review.googlesource.com/c/src/+/7800 for the experimental 
CL that gives an idea about how it will come together.
Design Doc: https://goo.gl/sFeSUT

Bug: webrtc:7671
Change-Id: I9d3be13647a0a958feceb8d7a9aa93852fc6a1fa
Reviewed-on: https://webrtc-review.googlesource.com/11841
Commit-Queue: Emircan Uysaler <emircan@webrtc.org>
Reviewed-by: Magnus Jedvert <magjed@webrtc.org>
Reviewed-by: Niklas Enbom <niklas.enbom@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#20490}

modules/video_coding/codecs/stereo/include/stereo_decoder_adapter.h

@@ -0,0 +1,72 @@
+/*
+ *  Copyright (c) 2017 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 MODULES_VIDEO_CODING_CODECS_STEREO_INCLUDE_STEREO_DECODER_ADAPTER_H_
+#define MODULES_VIDEO_CODING_CODECS_STEREO_INCLUDE_STEREO_DECODER_ADAPTER_H_
+
+#include <map>
+#include <memory>
+#include <vector>
+
+#include "api/video_codecs/video_decoder.h"
+#include "api/video_codecs/video_decoder_factory.h"
+#include "modules/video_coding/codecs/stereo/include/stereo_encoder_adapter.h"
+
+namespace webrtc {
+
+class StereoDecoderAdapter : public VideoDecoder {
+ public:
+  // |factory| is not owned and expected to outlive this class' lifetime.
+  explicit StereoDecoderAdapter(VideoDecoderFactory* factory);
+  virtual ~StereoDecoderAdapter();
+
+  // Implements VideoDecoder
+  int32_t InitDecode(const VideoCodec* codec_settings,
+                     int32_t number_of_cores) override;
+  int32_t Decode(const EncodedImage& input_image,
+                 bool missing_frames,
+                 const RTPFragmentationHeader* fragmentation,
+                 const CodecSpecificInfo* codec_specific_info,
+                 int64_t render_time_ms) override;
+  int32_t RegisterDecodeCompleteCallback(
+      DecodedImageCallback* callback) override;
+  int32_t Release() override;
+
+  void Decoded(AlphaCodecStream stream_idx,
+               VideoFrame* decoded_image,
+               rtc::Optional<int32_t> decode_time_ms,
+               rtc::Optional<uint8_t> qp);
+
+ private:
+  // Wrapper class that redirects Decoded() calls.
+  class AdapterDecodedImageCallback;
+
+  // Holds the decoded image output of a frame.
+  struct DecodedImageData;
+
+  void MergeAlphaImages(VideoFrame* decoded_image,
+                        const rtc::Optional<int32_t>& decode_time_ms,
+                        const rtc::Optional<uint8_t>& qp,
+                        VideoFrame* stereo_decoded_image,
+                        const rtc::Optional<int32_t>& stereo_decode_time_ms,
+                        const rtc::Optional<uint8_t>& stereo_qp);
+
+  VideoDecoderFactory* const factory_;
+  std::vector<std::unique_ptr<VideoDecoder>> decoders_;
+  std::vector<std::unique_ptr<AdapterDecodedImageCallback>> adapter_callbacks_;
+  DecodedImageCallback* decoded_complete_callback_;
+
+  // Holds YUV or AXX decode output of a frame that is identified by timestamp.
+  std::map<uint32_t /* timestamp */, DecodedImageData> decoded_data_;
+};
+
+}  // namespace webrtc
+
+#endif  // MODULES_VIDEO_CODING_CODECS_STEREO_INCLUDE_STEREO_DECODER_ADAPTER_H_

modules/video_coding/codecs/stereo/include/stereo_encoder_adapter.h

@@ -0,0 +1,73 @@
+/*
+ *  Copyright (c) 2017 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 MODULES_VIDEO_CODING_CODECS_STEREO_INCLUDE_STEREO_ENCODER_ADAPTER_H_
+#define MODULES_VIDEO_CODING_CODECS_STEREO_INCLUDE_STEREO_ENCODER_ADAPTER_H_
+
+#include <memory>
+#include <vector>
+
+#include "api/video_codecs/video_encoder.h"
+#include "api/video_codecs/video_encoder_factory.h"
+#include "modules/video_coding/include/video_codec_interface.h"
+
+namespace webrtc {
+
+enum AlphaCodecStream {
+  kYUVStream = 0,
+  kAXXStream = 1,
+  kAlphaCodecStreams = 2,
+};
+
+class StereoEncoderAdapter : public VideoEncoder {
+ public:
+  // |factory| is not owned and expected to outlive this class' lifetime.
+  explicit StereoEncoderAdapter(VideoEncoderFactory* factory);
+  virtual ~StereoEncoderAdapter();
+
+  // Implements VideoEncoder
+  int InitEncode(const VideoCodec* inst,
+                 int number_of_cores,
+                 size_t max_payload_size) override;
+  int Encode(const VideoFrame& input_image,
+             const CodecSpecificInfo* codec_specific_info,
+             const std::vector<FrameType>* frame_types) override;
+  int RegisterEncodeCompleteCallback(EncodedImageCallback* callback) override;
+  int SetChannelParameters(uint32_t packet_loss, int64_t rtt) override;
+  int SetRateAllocation(const BitrateAllocation& bitrate,
+                        uint32_t new_framerate) override;
+  int Release() override;
+  const char* ImplementationName() const override;
+
+  EncodedImageCallback::Result OnEncodedImage(
+      AlphaCodecStream stream_idx,
+      const EncodedImage& encodedImage,
+      const CodecSpecificInfo* codecSpecificInfo,
+      const RTPFragmentationHeader* fragmentation);
+
+ private:
+  // Wrapper class that redirects OnEncodedImage() calls.
+  class AdapterEncodedImageCallback;
+
+  // Holds the encoded image output of a frame.
+  struct EncodedImageData;
+
+  VideoEncoderFactory* const factory_;
+  std::vector<std::unique_ptr<VideoEncoder>> encoders_;
+  std::vector<std::unique_ptr<AdapterEncodedImageCallback>> adapter_callbacks_;
+  EncodedImageCallback* encoded_complete_callback_;
+
+  uint64_t picture_index_ = 0;
+  std::vector<uint8_t> stereo_dummy_planes_;
+};
+
+}  // namespace webrtc
+
+#endif  // MODULES_VIDEO_CODING_CODECS_STEREO_INCLUDE_STEREO_ENCODER_ADAPTER_H_