• Home
  • History
  • Annotate
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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 #include "webrtc/modules/video_render/video_render_frames.h"
12 
13 #include <assert.h>
14 
15 #include "webrtc/common_video/interface/texture_video_frame.h"
16 #include "webrtc/modules/interface/module_common_types.h"
17 #include "webrtc/system_wrappers/interface/tick_util.h"
18 #include "webrtc/system_wrappers/interface/trace.h"
19 
20 namespace webrtc {
21 
22 const uint32_t KEventMaxWaitTimeMs = 200;
23 const uint32_t kMinRenderDelayMs = 10;
24 const uint32_t kMaxRenderDelayMs= 500;
25 
VideoRenderFrames()26 VideoRenderFrames::VideoRenderFrames()
27     : render_delay_ms_(10) {
28 }
29 
~VideoRenderFrames()30 VideoRenderFrames::~VideoRenderFrames() {
31   ReleaseAllFrames();
32 }
33 
AddFrame(I420VideoFrame * new_frame)34 int32_t VideoRenderFrames::AddFrame(I420VideoFrame* new_frame) {
35   const int64_t time_now = TickTime::MillisecondTimestamp();
36 
37   // Drop old frames only when there are other frames in the queue, otherwise, a
38   // really slow system never renders any frames.
39   if (!incoming_frames_.empty() &&
40       new_frame->render_time_ms() + KOldRenderTimestampMS < time_now) {
41     WEBRTC_TRACE(kTraceWarning,
42                  kTraceVideoRenderer,
43                  -1,
44                  "%s: too old frame, timestamp=%u.",
45                  __FUNCTION__,
46                  new_frame->timestamp());
47     return -1;
48   }
49 
50   if (new_frame->render_time_ms() > time_now + KFutureRenderTimestampMS) {
51     WEBRTC_TRACE(kTraceWarning, kTraceVideoRenderer, -1,
52                  "%s: frame too long into the future, timestamp=%u.",
53                  __FUNCTION__, new_frame->timestamp());
54     return -1;
55   }
56 
57   if (new_frame->native_handle() != NULL) {
58     incoming_frames_.push_back(new_frame->CloneFrame());
59     return static_cast<int32_t>(incoming_frames_.size());
60   }
61 
62   // Get an empty frame
63   I420VideoFrame* frame_to_add = NULL;
64   if (!empty_frames_.empty()) {
65     frame_to_add = empty_frames_.front();
66     empty_frames_.pop_front();
67   }
68   if (!frame_to_add) {
69     if (empty_frames_.size() + incoming_frames_.size() >
70         KMaxNumberOfFrames) {
71       // Already allocated too many frames.
72       WEBRTC_TRACE(kTraceWarning, kTraceVideoRenderer,
73                    -1, "%s: too many frames, timestamp=%u, limit=%d",
74                    __FUNCTION__, new_frame->timestamp(), KMaxNumberOfFrames);
75       return -1;
76     }
77 
78     // Allocate new memory.
79     WEBRTC_TRACE(kTraceMemory, kTraceVideoRenderer, -1,
80                  "%s: allocating buffer %d", __FUNCTION__,
81                  empty_frames_.size() + incoming_frames_.size());
82 
83     frame_to_add = new I420VideoFrame();
84     if (!frame_to_add) {
85       WEBRTC_TRACE(kTraceError, kTraceVideoRenderer, -1,
86                    "%s: could not create new frame for", __FUNCTION__);
87       return -1;
88     }
89   }
90 
91   frame_to_add->CreateEmptyFrame(new_frame->width(), new_frame->height(),
92                                  new_frame->stride(kYPlane),
93                                  new_frame->stride(kUPlane),
94                                  new_frame->stride(kVPlane));
95   // TODO(mflodman) Change this!
96   // Remove const ness. Copying will be costly.
97   frame_to_add->SwapFrame(new_frame);
98   incoming_frames_.push_back(frame_to_add);
99 
100   return static_cast<int32_t>(incoming_frames_.size());
101 }
102 
FrameToRender()103 I420VideoFrame* VideoRenderFrames::FrameToRender() {
104   I420VideoFrame* render_frame = NULL;
105   FrameList::iterator iter = incoming_frames_.begin();
106   while(iter != incoming_frames_.end()) {
107     I420VideoFrame* oldest_frame_in_list = *iter;
108     if (oldest_frame_in_list->render_time_ms() <=
109         TickTime::MillisecondTimestamp() + render_delay_ms_) {
110       // This is the oldest one so far and it's OK to render.
111       if (render_frame) {
112         // This one is older than the newly found frame, remove this one.
113         ReturnFrame(render_frame);
114       }
115       render_frame = oldest_frame_in_list;
116       iter = incoming_frames_.erase(iter);
117     } else {
118       // We can't release this one yet, we're done here.
119       break;
120     }
121   }
122   return render_frame;
123 }
124 
ReturnFrame(I420VideoFrame * old_frame)125 int32_t VideoRenderFrames::ReturnFrame(I420VideoFrame* old_frame) {
126   // No need to reuse texture frames because they do not allocate memory.
127   if (old_frame->native_handle() == NULL) {
128     old_frame->ResetSize();
129     old_frame->set_timestamp(0);
130     old_frame->set_render_time_ms(0);
131     empty_frames_.push_back(old_frame);
132   } else {
133     delete old_frame;
134   }
135   return 0;
136 }
137 
ReleaseAllFrames()138 int32_t VideoRenderFrames::ReleaseAllFrames() {
139   for (FrameList::iterator iter = incoming_frames_.begin();
140        iter != incoming_frames_.end(); ++iter) {
141       delete *iter;
142   }
143   incoming_frames_.clear();
144 
145   for (FrameList::iterator iter = empty_frames_.begin();
146        iter != empty_frames_.end(); ++iter) {
147       delete *iter;
148   }
149   empty_frames_.clear();
150   return 0;
151 }
152 
TimeToNextFrameRelease()153 uint32_t VideoRenderFrames::TimeToNextFrameRelease() {
154   if (incoming_frames_.empty()) {
155     return KEventMaxWaitTimeMs;
156   }
157   I420VideoFrame* oldest_frame = incoming_frames_.front();
158   int64_t time_to_release = oldest_frame->render_time_ms() - render_delay_ms_
159       - TickTime::MillisecondTimestamp();
160   if (time_to_release < 0) {
161     time_to_release = 0;
162   }
163   return static_cast<uint32_t>(time_to_release);
164 }
165 
SetRenderDelay(const uint32_t render_delay)166 int32_t VideoRenderFrames::SetRenderDelay(
167     const uint32_t render_delay) {
168   if (render_delay < kMinRenderDelayMs ||
169       render_delay > kMaxRenderDelayMs) {
170     WEBRTC_TRACE(kTraceWarning, kTraceVideoRenderer,
171                  -1, "%s(%d): Invalid argument.", __FUNCTION__,
172                  render_delay);
173     return -1;
174   }
175 
176   render_delay_ms_ = render_delay;
177   return 0;
178 }
179 
180 }  // namespace webrtc
181