1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
|
// Copyright 2015 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "media/gpu/avda_shared_state.h"
#include "base/metrics/histogram_macros.h"
#include "base/time/time.h"
#include "media/gpu/avda_codec_image.h"
#include "ui/gl/android/surface_texture.h"
#include "ui/gl/gl_bindings.h"
#include "ui/gl/scoped_make_current.h"
namespace media {
// Handle OnFrameAvailable callbacks safely. Since they occur asynchronously,
// we take care that the object that wants them still exists. WeakPtrs cannot
// be used because OnFrameAvailable callbacks can occur on any thread. We also
// can't guarantee when the SurfaceTexture will quit sending callbacks to
// coordinate with the destruction of the AVDA and PictureBufferManager, so we
// have a separate object that the callback can own.
class AVDASharedState::OnFrameAvailableHandler
: public base::RefCountedThreadSafe<OnFrameAvailableHandler> {
public:
// We do not retain ownership of |listener|. It must remain valid until after
// ClearListener() is called. This will register with |surface_texture| to
// receive OnFrameAvailable callbacks.
OnFrameAvailableHandler(AVDASharedState* listener,
gl::SurfaceTexture* surface_texture)
: listener_(listener) {
surface_texture->SetFrameAvailableCallbackOnAnyThread(
base::Bind(&OnFrameAvailableHandler::OnFrameAvailable,
scoped_refptr<OnFrameAvailableHandler>(this)));
}
// Forget about |listener_|, which is required before one deletes it.
// No further callbacks will happen once this completes.
void ClearListener() {
base::AutoLock lock(lock_);
listener_ = nullptr;
}
// Notify the listener if there is one.
void OnFrameAvailable() {
base::AutoLock auto_lock(lock_);
if (listener_)
listener_->SignalFrameAvailable();
}
private:
friend class base::RefCountedThreadSafe<OnFrameAvailableHandler>;
~OnFrameAvailableHandler() { DCHECK(!listener_); }
// Protects changes to listener_.
base::Lock lock_;
// The AVDASharedState that wants the OnFrameAvailable callback.
AVDASharedState* listener_;
DISALLOW_COPY_AND_ASSIGN(OnFrameAvailableHandler);
};
AVDASharedState::AVDASharedState()
: surface_texture_service_id_(0),
frame_available_event_(base::WaitableEvent::ResetPolicy::AUTOMATIC,
base::WaitableEvent::InitialState::NOT_SIGNALED),
gl_matrix_{
1, 0, 0, 0, // Default to a sane guess just in case we can't get the
0, 1, 0, 0, // matrix on the first call. Will be Y-flipped later.
0, 0, 1, 0, //
0, 0, 0, 1, // Comment preserves 4x4 formatting.
} {}
AVDASharedState::~AVDASharedState() {
if (!surface_texture_service_id_)
return;
on_frame_available_handler_->ClearListener();
ui::ScopedMakeCurrent scoped_make_current(context_.get(), surface_.get());
if (scoped_make_current.Succeeded()) {
glDeleteTextures(1, &surface_texture_service_id_);
DCHECK_EQ(static_cast<GLenum>(GL_NO_ERROR), glGetError());
}
}
void AVDASharedState::SignalFrameAvailable() {
frame_available_event_.Signal();
}
void AVDASharedState::WaitForFrameAvailable() {
DCHECK(!release_time_.is_null());
// 5msec covers >99.9% of cases, so just wait for up to that much before
// giving up. If an error occurs, we might not ever get a notification.
const base::TimeDelta max_wait = base::TimeDelta::FromMilliseconds(5);
const base::TimeTicks call_time = base::TimeTicks::Now();
const base::TimeDelta elapsed = call_time - release_time_;
const base::TimeDelta remaining = max_wait - elapsed;
release_time_ = base::TimeTicks();
if (remaining <= base::TimeDelta()) {
if (!frame_available_event_.IsSignaled()) {
DVLOG(1) << "Deferred WaitForFrameAvailable() timed out, elapsed: "
<< elapsed.InMillisecondsF() << "ms";
}
return;
}
DCHECK_LE(remaining, max_wait);
SCOPED_UMA_HISTOGRAM_TIMER("Media.AvdaCodecImage.WaitTimeForFrame");
if (!frame_available_event_.TimedWait(remaining)) {
DVLOG(1) << "WaitForFrameAvailable() timed out, elapsed: "
<< elapsed.InMillisecondsF()
<< "ms, additionally waited: " << remaining.InMillisecondsF()
<< "ms, total: " << (elapsed + remaining).InMillisecondsF()
<< "ms";
}
}
void AVDASharedState::SetSurfaceTexture(
scoped_refptr<gl::SurfaceTexture> surface_texture,
GLuint attached_service_id) {
DCHECK(surface_texture);
DCHECK(attached_service_id);
surface_texture_ = surface_texture;
surface_texture_service_id_ = attached_service_id;
context_ = gl::GLContext::GetCurrent();
surface_ = gl::GLSurface::GetCurrent();
DCHECK(context_);
DCHECK(surface_);
on_frame_available_handler_ =
new OnFrameAvailableHandler(this, surface_texture_.get());
}
void AVDASharedState::RenderCodecBufferToSurfaceTexture(
MediaCodecBridge* codec,
int codec_buffer_index) {
if (!release_time_.is_null())
WaitForFrameAvailable();
codec->ReleaseOutputBuffer(codec_buffer_index, true);
release_time_ = base::TimeTicks::Now();
}
void AVDASharedState::UpdateTexImage() {
surface_texture_->UpdateTexImage();
// Helpfully, this is already column major.
surface_texture_->GetTransformMatrix(gl_matrix_);
}
void AVDASharedState::GetTransformMatrix(float matrix[16]) const {
memcpy(matrix, gl_matrix_, sizeof(gl_matrix_));
}
} // namespace media
|
