Skip to content

Commit f314cde

Browse files
xiaowei-guanxiaowei-guan
authored
Fix vsync not support engine group issue (#145)
* Fix vsync waiter not support engine group issue * Fix check fail issue * Rename some methods name * Make engine_ private and rename TdmValid to IsValid * Modify according to code review comments
1 parent 6280c13 commit f314cde

File tree

2 files changed

+99
-79
lines changed

2 files changed

+99
-79
lines changed

‎shell/platform/tizen/tizen_vsync_waiter.cc

Lines changed: 73 additions & 63 deletions
Original file line numberDiff line numberDiff line change
@@ -16,95 +16,107 @@ namespace flutter {
1616

1717
typedef struct {
1818
Eina_Thread_Queue_Msg head;
19-
int value;
19+
int event;
20+
intptr_t baton;
2021
} Msg;
2122

22-
static Eina_Thread_Queue* vblank_thread_queue{nullptr};
23-
2423
TizenVsyncWaiter::TizenVsyncWaiter(FlutterTizenEngine* engine)
2524
: engine_(engine) {
26-
if (!CreateTDMVblank()) {
27-
FT_LOGE("Failed to create TDM vblank");
28-
DestroyTDMVblank();
29-
} else {
30-
vblank_thread_queue = eina_thread_queue_new();
31-
vblank_thread_ =
32-
ecore_thread_feedback_run(RequestVblankLoop, NULL, VblankLoopFinish,
33-
VblankLoopFinish, this, EINA_TRUE);
34-
}
25+
vblank_thread_ = ecore_thread_feedback_run(RequestVblankLoop, nullptr,
26+
nullptr, nullptr, this, EINA_TRUE);
3527
}
3628

3729
TizenVsyncWaiter::~TizenVsyncWaiter() {
38-
SendMessage(kMessageQuit);
30+
Send(kMessageQuit, 0);
3931
if (vblank_thread_) {
4032
ecore_thread_cancel(vblank_thread_);
4133
vblank_thread_ = nullptr;
4234
}
43-
DestroyTDMVblank();
4435
}
4536

4637
void TizenVsyncWaiter::AsyncWaitForVsync(intptr_t baton) {
47-
baton_ = baton;
48-
if (TDMValid()) {
49-
SendMessage(kMessageRequestVblank);
50-
}
38+
Send(kMessageRequestVblank, baton);
5139
}
5240

53-
void TizenVsyncWaiter::SendMessage(int val) {
54-
if (!vblank_thread_queue || !vblank_thread_) {
55-
FT_LOGE("vblank thread or vblank thread queue not valid");
41+
void TizenVsyncWaiter::Send(int event, intptr_t baton) {
42+
if (!vblank_thread_ || ecore_thread_check(vblank_thread_)) {
43+
FT_LOGE("vblank thread not valid");
5644
return;
5745
}
46+
47+
if (!vblank_thread_queue_) {
48+
FT_LOGE("vblank thread queue not valid");
49+
return;
50+
}
51+
5852
Msg* msg;
5953
void* ref;
6054
msg = static_cast<Msg*>(
61-
eina_thread_queue_send(vblank_thread_queue, sizeof(Msg), &ref));
62-
msg->value = val;
63-
eina_thread_queue_send_done(vblank_thread_queue, ref);
55+
eina_thread_queue_send(vblank_thread_queue_, sizeof(Msg), &ref));
56+
msg->event = event;
57+
msg->baton = baton;
58+
eina_thread_queue_send_done(vblank_thread_queue_, ref);
6459
}
6560

6661
void TizenVsyncWaiter::RequestVblankLoop(void* data, Ecore_Thread* thread) {
6762
TizenVsyncWaiter* tizen_vsync_waiter =
6863
reinterpret_cast<TizenVsyncWaiter*>(data);
69-
void* ref;
70-
Msg* msg;
64+
TdmClient tdm_client(tizen_vsync_waiter->engine_);
65+
if (!tdm_client.IsValid()) {
66+
FT_LOGE("Tdm client not valid");
67+
ecore_thread_cancel(thread);
68+
return;
69+
}
70+
Eina_Thread_Queue* vblank_thread_queue = eina_thread_queue_new();
71+
if (!vblank_thread_queue) {
72+
FT_LOGE("Vblank thread queue is not valid");
73+
ecore_thread_cancel(thread);
74+
return;
75+
}
76+
77+
tizen_vsync_waiter->vblank_thread_queue_ = vblank_thread_queue;
7178
while (!ecore_thread_check(thread)) {
72-
if (!vblank_thread_queue) {
73-
FT_LOGE("Vblank thread queue is not valid");
74-
return;
75-
}
79+
void* ref;
80+
Msg* msg;
7681
msg = static_cast<Msg*>(eina_thread_queue_wait(vblank_thread_queue, &ref));
7782
if (msg) {
7883
eina_thread_queue_wait_done(vblank_thread_queue, ref);
7984
} else {
8085
FT_LOGE("Message is null");
8186
continue;
8287
}
83-
if (msg->value == kMessageQuit) {
84-
return;
88+
if (msg->event == kMessageQuit) {
89+
break;
8590
}
86-
if (!tizen_vsync_waiter->TDMValid()) {
87-
FT_LOGE("TDM not valid");
88-
return;
89-
}
90-
tdm_error error = tdm_client_vblank_wait(tizen_vsync_waiter->vblank_, 1,
91-
TdmClientVblankCallback, data);
92-
if (error != TDM_ERROR_NONE) {
93-
FT_LOGE("tdm_client_vblank_wait error %d", error);
94-
continue;
95-
}
96-
tdm_client_handle_events(tizen_vsync_waiter->client_);
91+
tdm_client.WaitVblank(msg->baton);
9792
}
98-
}
99-
100-
void TizenVsyncWaiter::VblankLoopFinish(void* data, Ecore_Thread* thread) {
10193
if (vblank_thread_queue) {
10294
eina_thread_queue_free(vblank_thread_queue);
103-
vblank_thread_queue = nullptr;
10495
}
10596
}
10697

107-
bool TizenVsyncWaiter::CreateTDMVblank() {
98+
TdmClient::TdmClient(FlutterTizenEngine* engine) {
99+
if (!CreateTdm()) {
100+
FT_LOGE("Create tdm client failed");
101+
}
102+
engine_ = engine;
103+
}
104+
105+
TdmClient::~TdmClient() {
106+
DestroyTdm();
107+
}
108+
109+
void TdmClient::WaitVblank(intptr_t baton) {
110+
baton_ = baton;
111+
tdm_error error = tdm_client_vblank_wait(vblank_, 1, VblankCallback, this);
112+
if (error != TDM_ERROR_NONE) {
113+
FT_LOGE("tdm client wait vblank error %d", error);
114+
return;
115+
}
116+
tdm_client_handle_events(client_);
117+
}
118+
119+
bool TdmClient::CreateTdm() {
108120
tdm_error ret;
109121
client_ = tdm_client_create(&ret);
110122
if (ret != TDM_ERROR_NONE && client_ != NULL) {
@@ -128,7 +140,7 @@ bool TizenVsyncWaiter::CreateTDMVblank() {
128140
return true;
129141
}
130142

131-
void TizenVsyncWaiter::DestroyTDMVblank() {
143+
void TdmClient::DestroyTdm() {
132144
if (vblank_) {
133145
tdm_client_vblank_destroy(vblank_);
134146
vblank_ = nullptr;
@@ -140,26 +152,24 @@ void TizenVsyncWaiter::DestroyTDMVblank() {
140152
}
141153
}
142154

143-
bool TizenVsyncWaiter::TDMValid() {
155+
bool TdmClient::IsValid() {
144156
return vblank_ && client_;
145157
}
146158

147-
void TizenVsyncWaiter::TdmClientVblankCallback(tdm_client_vblank* vblank,
148-
tdm_error error,
149-
unsigned int sequence,
150-
unsigned int tv_sec,
151-
unsigned int tv_usec,
152-
void* user_data) {
153-
TizenVsyncWaiter* tizen_vsync_waiter =
154-
reinterpret_cast<TizenVsyncWaiter*>(user_data);
155-
FT_ASSERT(tizen_vsync_waiter != nullptr);
156-
FT_ASSERT(tizen_vsync_waiter->engine_ != nullptr);
159+
void TdmClient::VblankCallback(tdm_client_vblank* vblank,
160+
tdm_error error,
161+
unsigned int sequence,
162+
unsigned int tv_sec,
163+
unsigned int tv_usec,
164+
void* user_data) {
165+
TdmClient* client = reinterpret_cast<TdmClient*>(user_data);
166+
FT_ASSERT(client != nullptr);
167+
FT_ASSERT(client->engine_ != nullptr);
157168

158169
uint64_t frame_start_time_nanos = tv_sec * 1e9 + tv_usec * 1e3;
159170
uint64_t frame_target_time_nanos = 16.6 * 1e6 + frame_start_time_nanos;
160-
tizen_vsync_waiter->engine_->OnVsync(tizen_vsync_waiter->baton_,
161-
frame_start_time_nanos,
162-
frame_target_time_nanos);
171+
client->engine_->OnVsync(client->baton_, frame_start_time_nanos,
172+
frame_target_time_nanos);
163173
}
164174

165175
} // namespace flutter

‎shell/platform/tizen/tizen_vsync_waiter.h

Lines changed: 26 additions & 16 deletions
Original file line numberDiff line numberDiff line change
@@ -14,31 +14,41 @@ namespace flutter {
1414

1515
class FlutterTizenEngine;
1616

17-
class TizenVsyncWaiter {
17+
class TdmClient {
1818
public:
19-
TizenVsyncWaiter(FlutterTizenEngine* engine);
20-
virtual ~TizenVsyncWaiter();
21-
void AsyncWaitForVsync(intptr_t baton);
19+
TdmClient(FlutterTizenEngine* engine);
20+
virtual ~TdmClient();
21+
bool CreateTdm();
22+
void DestroyTdm();
23+
bool IsValid();
24+
void WaitVblank(intptr_t baton);
25+
static void VblankCallback(tdm_client_vblank* vblank,
26+
tdm_error error,
27+
unsigned int sequence,
28+
unsigned int tv_sec,
29+
unsigned int tv_usec,
30+
void* user_data);
2231

2332
private:
24-
bool CreateTDMVblank();
25-
void DestroyTDMVblank();
26-
bool TDMValid();
27-
void SendMessage(int val);
28-
static void TdmClientVblankCallback(tdm_client_vblank* vblank,
29-
tdm_error error,
30-
unsigned int sequence,
31-
unsigned int tv_sec,
32-
unsigned int tv_usec,
33-
void* user_data);
34-
static void RequestVblankLoop(void* data, Ecore_Thread* thread);
35-
static void VblankLoopFinish(void* data, Ecore_Thread* thread);
3633
tdm_client* client_{nullptr};
3734
tdm_client_output* output_{nullptr};
3835
tdm_client_vblank* vblank_{nullptr};
3936
FlutterTizenEngine* engine_{nullptr};
4037
intptr_t baton_{0};
38+
};
39+
40+
class TizenVsyncWaiter {
41+
public:
42+
TizenVsyncWaiter(FlutterTizenEngine* engine);
43+
virtual ~TizenVsyncWaiter();
44+
void AsyncWaitForVsync(intptr_t baton);
45+
46+
private:
47+
void Send(int event, intptr_t baton);
48+
static void RequestVblankLoop(void* data, Ecore_Thread* thread);
4149
Ecore_Thread* vblank_thread_{nullptr};
50+
Eina_Thread_Queue* vblank_thread_queue_{nullptr};
51+
FlutterTizenEngine* engine_{nullptr};
4252
};
4353

4454
} // namespace flutter

0 commit comments

Comments
 (0)