1 /*
2  *  Copyright (c) 2012 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_CODEC_DATABASE_H_
12 #define WEBRTC_MODULES_VIDEO_CODING_CODEC_DATABASE_H_
13 
14 #include <map>
15 #include <memory>
16 
17 #include "webrtc/modules/video_coding/include/video_codec_interface.h"
18 #include "webrtc/modules/video_coding/include/video_coding.h"
19 #include "webrtc/modules/video_coding/generic_decoder.h"
20 #include "webrtc/modules/video_coding/generic_encoder.h"
21 #include "webrtc/typedefs.h"
22 
23 namespace webrtc {
24 
25 struct VCMDecoderMapItem {
26  public:
27   VCMDecoderMapItem(VideoCodec* settings,
28                     int number_of_cores,
29                     bool require_key_frame);
30 
31   std::unique_ptr<VideoCodec> settings;
32   int number_of_cores;
33   bool require_key_frame;
34 };
35 
36 struct VCMExtDecoderMapItem {
37  public:
38   VCMExtDecoderMapItem(VideoDecoder* external_decoder_instance,
39                        uint8_t payload_type);
40 
41   uint8_t payload_type;
42   VideoDecoder* external_decoder_instance;
43 };
44 
45 class VCMCodecDataBase {
46  public:
47   explicit VCMCodecDataBase(VCMEncodedFrameCallback* encoded_frame_callback);
48   ~VCMCodecDataBase();
49 
50   // Sender Side
51   // Returns the default settings for the codec with type |codec_type|.
52   static void Codec(VideoCodecType codec_type, VideoCodec* settings);
53 
54   // Sets the sender side codec and initiates the desired codec given the
55   // VideoCodec struct.
56   // Returns true if the codec was successfully registered, false otherwise.
57   bool SetSendCodec(const VideoCodec* send_codec,
58                     int number_of_cores,
59                     size_t max_payload_size);
60 
61   // Gets the current send codec. Relevant for internal codecs only.
62   // Returns true if there is a send codec, false otherwise.
63   bool SendCodec(VideoCodec* current_send_codec) const;
64 
65   // Gets current send side codec type. Relevant for internal codecs only.
66   // Returns kVideoCodecUnknown if there is no send codec.
67   VideoCodecType SendCodec() const;
68 
69   // Registers and initializes an external encoder object.
70   // |internal_source| should be set to true if the codec has an internal
71   // video source and doesn't need the user to provide it with frames via
72   // the Encode() method.
73   void RegisterExternalEncoder(VideoEncoder* external_encoder,
74                                uint8_t payload_type,
75                                bool internal_source);
76 
77   // Deregisters an external encoder. Returns true if the encoder was
78   // found and deregistered, false otherwise. |was_send_codec| is set to true
79   // if the external encoder was the send codec before being deregistered.
80   bool DeregisterExternalEncoder(uint8_t payload_type, bool* was_send_codec);
81 
82   VCMGenericEncoder* GetEncoder();
83 
84   bool SetPeriodicKeyFrames(bool enable);
85 
86   // Deregisters an external decoder object specified by |payload_type|.
87   bool DeregisterExternalDecoder(uint8_t payload_type);
88 
89   // Registers an external decoder object to the payload type |payload_type|.
90   void RegisterExternalDecoder(VideoDecoder* external_decoder,
91                                uint8_t payload_type);
92 
93   bool DecoderRegistered() const;
94 
95   bool RegisterReceiveCodec(const VideoCodec* receive_codec,
96                             int number_of_cores,
97                             bool require_key_frame);
98 
99   bool DeregisterReceiveCodec(uint8_t payload_type);
100 
101   // Get current receive side codec. Relevant for internal codecs only.
102   bool ReceiveCodec(VideoCodec* current_receive_codec) const;
103 
104   // Get current receive side codec type. Relevant for internal codecs only.
105   VideoCodecType ReceiveCodec() const;
106 
107   // Returns a decoder specified by |payload_type|. The decoded frame callback
108   // of the encoder is set to |decoded_frame_callback|. If no such decoder
109   // already exists an instance will be created and initialized.
110   // NULL is returned if no encoder with the specified payload type was found
111   // and the function failed to create one.
112   VCMGenericDecoder* GetDecoder(
113       const VCMEncodedFrame& frame,
114       VCMDecodedFrameCallback* decoded_frame_callback);
115 
116   // Deletes the memory of the decoder instance |decoder|. Used to delete
117   // deep copies returned by CreateDecoderCopy().
118   void ReleaseDecoder(VCMGenericDecoder* decoder) const;
119 
120   // Returns true if the currently active decoder prefer to decode frames late.
121   // That means that frames must be decoded near the render times stamp.
122   bool PrefersLateDecoding() const;
123 
124   bool MatchesCurrentResolution(int width, int height) const;
125 
126  private:
127   typedef std::map<uint8_t, VCMDecoderMapItem*> DecoderMap;
128   typedef std::map<uint8_t, VCMExtDecoderMapItem*> ExternalDecoderMap;
129 
130   VCMGenericDecoder* CreateAndInitDecoder(const VCMEncodedFrame& frame,
131                                           VideoCodec* new_codec) const;
132 
133   // Determines whether a new codec has to be created or not.
134   // Checks every setting apart from maxFramerate and startBitrate.
135   bool RequiresEncoderReset(const VideoCodec& send_codec);
136 
137   void DeleteEncoder();
138 
139   // Create an internal Decoder given a codec type
140   VCMGenericDecoder* CreateDecoder(VideoCodecType type) const;
141 
142   const VCMDecoderMapItem* FindDecoderItem(uint8_t payload_type) const;
143 
144   const VCMExtDecoderMapItem* FindExternalDecoderItem(
145       uint8_t payload_type) const;
146 
147   int number_of_cores_;
148   size_t max_payload_size_;
149   bool periodic_key_frames_;
150   bool pending_encoder_reset_;
151   VideoCodec send_codec_;
152   VideoCodec receive_codec_;
153   uint8_t encoder_payload_type_;
154   VideoEncoder* external_encoder_;
155   bool internal_source_;
156   VCMEncodedFrameCallback* const encoded_frame_callback_;
157   std::unique_ptr<VCMGenericEncoder> ptr_encoder_;
158   VCMGenericDecoder* ptr_decoder_;
159   DecoderMap dec_map_;
160   ExternalDecoderMap dec_external_map_;
161 };  // VCMCodecDataBase
162 
163 }  // namespace webrtc
164 
165 #endif  // WEBRTC_MODULES_VIDEO_CODING_CODEC_DATABASE_H_
166