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_VIDEO_ENGINE_VIE_RENDERER_H_
12#define WEBRTC_VIDEO_ENGINE_VIE_RENDERER_H_
13
14#include "webrtc/modules/video_render/include/video_render_defines.h"
15#include "webrtc/system_wrappers/interface/scoped_ptr.h"
16#include "webrtc/video_engine/include/vie_render.h"
17#include "webrtc/video_engine/vie_frame_provider_base.h"
18
19namespace webrtc {
20
21class VideoRender;
22class VideoRenderCallback;
23class ViERenderManager;
24
25class ViEExternalRendererImpl : public VideoRenderCallback {
26 public:
27  ViEExternalRendererImpl();
28  virtual ~ViEExternalRendererImpl() {}
29
30  int SetViEExternalRenderer(ExternalRenderer* external_renderer,
31                             RawVideoType video_input_format);
32
33  // Implements VideoRenderCallback.
34  virtual int32_t RenderFrame(const uint32_t stream_id,
35                              I420VideoFrame& video_frame);
36
37 private:
38  void NotifyFrameSizeChange(const uint32_t stream_id,
39                             I420VideoFrame& video_frame);
40  ExternalRenderer* external_renderer_;
41  RawVideoType external_renderer_format_;
42  int external_renderer_width_;
43  int external_renderer_height_;
44  // Converted_frame_ in color format specified by render_format_.
45  scoped_ptr<VideoFrame> converted_frame_;
46};
47
48class ViERenderer: public ViEFrameCallback {
49 public:
50  static ViERenderer* CreateViERenderer(const int32_t render_id,
51                                        const int32_t engine_id,
52                                        VideoRender& render_module,
53                                        ViERenderManager& render_manager,
54                                        const uint32_t z_order,
55                                        const float left,
56                                        const float top,
57                                        const float right,
58                                        const float bottom);
59  ~ViERenderer(void);
60
61  int32_t StartRender();
62  int32_t StopRender();
63
64  int32_t GetLastRenderedFrame(const int32_t renderID,
65                               I420VideoFrame& video_frame);
66
67  int SetExpectedRenderDelay(int render_delay);
68
69  int32_t ConfigureRenderer(const unsigned int z_order,
70                            const float left,
71                            const float top,
72                            const float right,
73                            const float bottom);
74
75  VideoRender& RenderModule();
76
77  int32_t EnableMirroring(const int32_t render_id,
78                          const bool enable,
79                          const bool mirror_xaxis,
80                          const bool mirror_yaxis);
81
82  int32_t SetTimeoutImage(const I420VideoFrame& timeout_image,
83                          const int32_t timeout_value);
84  int32_t SetRenderStartImage(const I420VideoFrame& start_image);
85  int32_t SetExternalRenderer(const int32_t render_id,
86                              RawVideoType video_input_format,
87                              ExternalRenderer* external_renderer);
88
89  int32_t SetVideoRenderCallback(const int32_t render_id,
90                                 VideoRenderCallback* callback);
91
92 private:
93  ViERenderer(const int32_t render_id, const int32_t engine_id,
94                VideoRender& render_module,
95                ViERenderManager& render_manager);
96
97  int32_t Init(const uint32_t z_order,
98               const float left,
99               const float top,
100               const float right,
101               const float bottom);
102
103  // Implement ViEFrameCallback
104  virtual void DeliverFrame(int id,
105                            I420VideoFrame* video_frame,
106                            int num_csrcs = 0,
107                            const uint32_t CSRC[kRtpCsrcSize] = NULL);
108  virtual void DelayChanged(int id, int frame_delay);
109  virtual int GetPreferedFrameSettings(int* width,
110                                       int* height,
111                                       int* frame_rate);
112  virtual void ProviderDestroyed(int id);
113
114  uint32_t render_id_;
115  VideoRender& render_module_;
116  ViERenderManager& render_manager_;
117  VideoRenderCallback* render_callback_;
118  ViEExternalRendererImpl* incoming_external_callback_;
119};
120
121}  // namespace webrtc
122
123#endif  // WEBRTC_VIDEO_ENGINE_VIE_RENDERER_H_
124