1 /*
2 * Copyright (c) 2010, 2013, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation. Oracle designates this
8 * particular file as subject to the "Classpath" exception as provided
9 * by Oracle in the LICENSE file that accompanied this code.
10 *
11 * This code is distributed in the hope that it will be useful, but WITHOUT
12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14 * version 2 for more details (a copy is included in the LICENSE file that
15 * accompanied this code).
16 *
17 * You should have received a copy of the GNU General Public License version
18 * 2 along with this work; if not, write to the Free Software Foundation,
19 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
20 *
21 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
22 * or visit www.oracle.com if you need additional information or have any
93 m_SendMarkerEventMethod = env->GetMethodID(klass, "sendMarkerEvent", "(Ljava/lang/String;D)V");
94 m_SendBufferProgressEventMethod = env->GetMethodID(klass, "sendBufferProgressEvent", "(DJJJ)V");
95 m_SendDurationUpdateEventMethod = env->GetMethodID(klass, "sendDurationUpdateEvent", "(D)V");
96 m_SendAudioSpectrumEventMethod = env->GetMethodID(klass, "sendAudioSpectrumEvent", "(DD)V");
97
98 env->DeleteLocalRef(klass);
99
100 areJMethodIDsInitialized = true;
101 }
102
103 LOWLEVELPERF_EXECTIMESTOP("CJavaPlayerEventDispatcher::Init()");
104 }
105
106 void CJavaPlayerEventDispatcher::Dispose()
107 {
108 LOWLEVELPERF_EXECTIMESTART("CJavaPlayerEventDispatcher::Dispose()");
109 CJavaEnvironment jenv(m_PlayerVM);
110 JNIEnv *pEnv = jenv.getEnvironment();
111 if (pEnv) {
112 pEnv->DeleteGlobalRef(m_PlayerInstance);
113 }
114
115 LOWLEVELPERF_EXECTIMESTOP("CJavaPlayerEventDispatcher::Dispose()");
116 }
117
118 void CJavaPlayerEventDispatcher::Warning(int warningCode, const char* warningMessage)
119 {
120 if (NULL == m_PlayerInstance)
121 return;
122
123 CJavaEnvironment jenv(m_PlayerVM);
124 JNIEnv *pEnv = jenv.getEnvironment();
125 if (pEnv) {
126 jstring jmessage = NULL;
127 if (warningMessage) {
128 jmessage = pEnv->NewStringUTF(warningMessage);
129 }
130 pEnv->CallVoidMethod(m_PlayerInstance, m_SendWarningMethod,
131 (jint)warningCode, jmessage);
132 if (jmessage) {
133 pEnv->DeleteLocalRef(jmessage);
134 }
135 }
136 }
137
138 bool CJavaPlayerEventDispatcher::SendPlayerMediaErrorEvent(int errorCode)
139 {
140 return SendToJava_PlayerMediaErrorEvent(errorCode);
141 }
142
143 bool CJavaPlayerEventDispatcher::SendPlayerHaltEvent(const char* message, double time)
144 {
145 return SendToJava_PlayerHaltEvent(message, time);
146 }
147
148 bool CJavaPlayerEventDispatcher::SendPlayerStateEvent(int newState, double presentTime)
149 {
150 long newJavaState;
151
152 switch(newState)
153 {
154 case CPipeline::Unknown:
155 newJavaState = com_sun_media_jfxmediaimpl_NativeMediaPlayer_eventPlayerUnknown;
156 break;
157 case CPipeline::Ready:
158 newJavaState = com_sun_media_jfxmediaimpl_NativeMediaPlayer_eventPlayerReady;
159 break;
160 case CPipeline::Playing:
161 newJavaState = com_sun_media_jfxmediaimpl_NativeMediaPlayer_eventPlayerPlaying;
162 break;
163 case CPipeline::Paused:
164 newJavaState = com_sun_media_jfxmediaimpl_NativeMediaPlayer_eventPlayerPaused;
165 break;
166 case CPipeline::Stopped:
167 newJavaState = com_sun_media_jfxmediaimpl_NativeMediaPlayer_eventPlayerStopped;
168 break;
169 case CPipeline::Stalled:
170 newJavaState = com_sun_media_jfxmediaimpl_NativeMediaPlayer_eventPlayerStalled;
171 break;
172 case CPipeline::Finished:
173 newJavaState = com_sun_media_jfxmediaimpl_NativeMediaPlayer_eventPlayerFinished;
174 break;
175 case CPipeline::Error:
176 newJavaState = com_sun_media_jfxmediaimpl_NativeMediaPlayer_eventPlayerError;
177 break;
178 default:
179 return false;
180 }
181
182 return SendToJava_PlayerStateEvent(newJavaState, presentTime);
183 }
184
185 bool CJavaPlayerEventDispatcher::SendNewFrameEvent(CVideoFrame* pVideoFrame)
186 {
187 return SendToJava_NewFrameEvent(pVideoFrame);
188 }
189
190 bool CJavaPlayerEventDispatcher::SendFrameSizeChangedEvent(int width, int height)
191 {
192 return SendToJava_FrameSizeChangedEvent(width, height);
193 }
194
195 bool CJavaPlayerEventDispatcher::SendAudioTrackEvent(CAudioTrack* pTrack)
196 {
197 return SendToJava_AudioTrackEvent(pTrack);
198 }
199
200 bool CJavaPlayerEventDispatcher::SendVideoTrackEvent(CVideoTrack* pTrack)
201 {
202 return SendToJava_VideoTrackEvent(pTrack);
203 }
204
205 bool CJavaPlayerEventDispatcher::SendSubtitleTrackEvent(CSubtitleTrack* pTrack)
206 {
207 return SendToJava_SubtitleTrackEvent(pTrack);
208 }
209
210 bool CJavaPlayerEventDispatcher::SendMarkerEvent(string name, double time)
211 {
212 return SendToJava_MarkerEvent(name, time);
213 }
214
215 bool CJavaPlayerEventDispatcher::SendBufferProgressEvent(double clipDuration, int64_t start, int64_t stop, int64_t position)
216 {
217 return SendToJava_BufferProgressEvent(clipDuration, start, stop, position);
218 }
219
220 bool CJavaPlayerEventDispatcher::SendDurationUpdateEvent(double time)
221 {
222 return SendToJava_DurationUpdateEvent(time);
223 }
224
225 bool CJavaPlayerEventDispatcher::SendAudioSpectrumEvent(double time, double duration)
226 {
227 return SendToJava_AudioSpectrumEvent(time, duration);
228 }
229 /*********************************************************************************
230 * SendToJava methods section
231 **********************************************************************************/
232 bool CJavaPlayerEventDispatcher::SendToJava_PlayerMediaErrorEvent(int errorCode)
233 {
234 if (NULL == m_PlayerInstance)
235 return false;
236
237 CJavaEnvironment jenv(m_PlayerVM);
238 JNIEnv *pEnv = jenv.getEnvironment();
239 if (pEnv) {
240 pEnv->CallVoidMethod(m_PlayerInstance, m_SendPlayerMediaErrorEventMethod, errorCode);
241 return !jenv.reportException();
242 }
243
244 return false;
245 }
246
247 bool CJavaPlayerEventDispatcher::SendToJava_PlayerHaltEvent(const char* message, double time)
248 {
249 if (NULL == m_PlayerInstance)
250 return false;
251
252 CJavaEnvironment jenv(m_PlayerVM);
253 JNIEnv *pEnv = jenv.getEnvironment();
254 if (pEnv) {
255 jstring jmessage = pEnv->NewStringUTF(message);
256 pEnv->CallVoidMethod(m_PlayerInstance, m_SendPlayerHaltEventMethod, jmessage, time);
257 pEnv->DeleteLocalRef(jmessage);
258 return !jenv.reportException();
259 }
260
261 return false;
262 }
263
264 bool CJavaPlayerEventDispatcher::SendToJava_PlayerStateEvent(long eventID, double presentTime)
265 {
266 if (NULL == m_PlayerInstance)
267 return false;
268
269 switch(eventID) {
270 case com_sun_media_jfxmediaimpl_NativeMediaPlayer_eventPlayerUnknown:
271 case com_sun_media_jfxmediaimpl_NativeMediaPlayer_eventPlayerReady:
272 case com_sun_media_jfxmediaimpl_NativeMediaPlayer_eventPlayerPlaying:
273 case com_sun_media_jfxmediaimpl_NativeMediaPlayer_eventPlayerPaused:
274 case com_sun_media_jfxmediaimpl_NativeMediaPlayer_eventPlayerStopped:
275 case com_sun_media_jfxmediaimpl_NativeMediaPlayer_eventPlayerFinished:
276 case com_sun_media_jfxmediaimpl_NativeMediaPlayer_eventPlayerStalled:
277 case com_sun_media_jfxmediaimpl_NativeMediaPlayer_eventPlayerError:
278 {
279 LOWLEVELPERF_EXECTIMESTOP("gstInitPlatformToSendToJavaPlayerStateEventPaused");
280 LOWLEVELPERF_EXECTIMESTOP("gstPauseToSendToJavaPlayerStateEventPaused");
281 LOWLEVELPERF_EXECTIMESTOP("gstStopToSendToJavaPlayerStateEventStopped");
282 LOWLEVELPERF_EXECTIMESTOP("gstPlayToSendToJavaPlayerStateEventPlaying");
283 // Send an event only if the ID is valid.
284 CJavaEnvironment jenv(m_PlayerVM);
285 JNIEnv *pEnv = jenv.getEnvironment();
286 if (pEnv) {
287 pEnv->CallVoidMethod(m_PlayerInstance, m_SendPlayerStateEventMethod, eventID, presentTime);
288 return !jenv.reportException();
289 }
290 break;
291 }
292 default:
293 break;
294 }
295
296 return false;
297 }
298
299 bool CJavaPlayerEventDispatcher::SendToJava_NewFrameEvent(CVideoFrame* pVideoFrame)
300 {
301 LOWLEVELPERF_EXECTIMESTART("CJavaPlayerEventDispatcher::SendToJava_NewFrameEvent()");
302 bool bSucceeded = false;
303
304 if (NULL == m_PlayerInstance)
305 return false;
306
307 CJavaEnvironment jenv(m_PlayerVM);
308 JNIEnv *pEnv = jenv.getEnvironment();
309 if (pEnv) {
310 // SendNewFrameEvent will create the NativeVideoBuffer wrapper for the java side
311 pEnv->CallVoidMethod(m_PlayerInstance, m_SendNewFrameEventMethod, ptr_to_jlong(pVideoFrame));
312 bSucceeded = !jenv.reportException();
313 }
314
315 LOWLEVELPERF_EXECTIMESTOP("CJavaPlayerEventDispatcher::SendToJava_NewFrameEvent()");
316
317 return bSucceeded;
318 }
319
320 bool CJavaPlayerEventDispatcher::SendToJava_FrameSizeChangedEvent(int width, int height)
321 {
322 if (NULL == m_PlayerInstance)
323 return false;
324
325 CJavaEnvironment jenv(m_PlayerVM);
326 JNIEnv *pEnv = jenv.getEnvironment();
327 if (pEnv) {
328 pEnv->CallVoidMethod(m_PlayerInstance, m_SendFrameSizeChangedEventMethod, (jint)width, (jint)height);
329 return !jenv.reportException();
330 }
331
332 return false;
333 }
334
335 bool CJavaPlayerEventDispatcher::SendToJava_AudioTrackEvent(CAudioTrack* pTrack)
336 {
337 if (NULL == m_PlayerInstance)
338 return false;
339
340 CJavaEnvironment jenv(m_PlayerVM);
341 JNIEnv *pEnv = jenv.getEnvironment();
342 if (pEnv) {
343 jstring name = pEnv->NewStringUTF(pTrack->GetName().c_str());
344 jstring language = pEnv->NewStringUTF(pTrack->GetLanguage().c_str());
345
346 // Translate channel mask bits from native values to Java values.
347 int nativeChannelMask = pTrack->GetChannelMask();
348 jint javaChannelMask = 0;
349 if (nativeChannelMask & CAudioTrack::UNKNOWN)
350 javaChannelMask |= com_sun_media_jfxmedia_track_AudioTrack_UNKNOWN;
351 if (nativeChannelMask & CAudioTrack::FRONT_LEFT)
352 javaChannelMask |= com_sun_media_jfxmedia_track_AudioTrack_FRONT_LEFT;
353 if (nativeChannelMask & CAudioTrack::FRONT_RIGHT)
354 javaChannelMask |= com_sun_media_jfxmedia_track_AudioTrack_FRONT_RIGHT;
355 if (nativeChannelMask & CAudioTrack::FRONT_CENTER)
356 javaChannelMask |= com_sun_media_jfxmedia_track_AudioTrack_FRONT_CENTER;
357 if (nativeChannelMask & CAudioTrack::REAR_LEFT)
358 javaChannelMask |= com_sun_media_jfxmedia_track_AudioTrack_REAR_LEFT;
359 if (nativeChannelMask & CAudioTrack::REAR_RIGHT)
360 javaChannelMask |= com_sun_media_jfxmedia_track_AudioTrack_REAR_RIGHT;
361 if (nativeChannelMask & CAudioTrack::REAR_CENTER)
362 javaChannelMask |= com_sun_media_jfxmedia_track_AudioTrack_REAR_CENTER;
363
364 pEnv->CallVoidMethod(m_PlayerInstance, m_SendAudioTrackEventMethod,
365 (jboolean)pTrack->isEnabled(), (jlong)pTrack->GetTrackID(), name, pTrack->GetEncoding(), language,
366 pTrack->GetNumChannels(), javaChannelMask, pTrack->GetSampleRate());
367
368 pEnv->DeleteLocalRef(name);
369 pEnv->DeleteLocalRef(language);
370 return !jenv.reportException();
371 }
372
373 return false;
374 }
375
376 bool CJavaPlayerEventDispatcher::SendToJava_VideoTrackEvent(CVideoTrack* pTrack)
377 {
378 if (NULL == m_PlayerInstance)
379 return false;
380
381 CJavaEnvironment jenv(m_PlayerVM);
382 JNIEnv *pEnv = jenv.getEnvironment();
383 if (pEnv) {
384 jstring name = pEnv->NewStringUTF(pTrack->GetName().c_str());
385 pEnv->CallVoidMethod(m_PlayerInstance, m_SendVideoTrackEventMethod,
386 (jboolean)pTrack->isEnabled(), (jlong)pTrack->GetTrackID(), name, pTrack->GetEncoding(),
387 pTrack->GetWidth(), pTrack->GetHeight(),
388 pTrack->GetFrameRate(), pTrack->HasAlphaChannel());
389 pEnv->DeleteLocalRef(name);
390 return !jenv.reportException();
391 }
392
393 return false;
394 }
395
396 bool CJavaPlayerEventDispatcher::SendToJava_SubtitleTrackEvent(CSubtitleTrack* pTrack)
397 {
398 if (NULL == m_PlayerInstance)
399 return false;
400
401 CJavaEnvironment jenv(m_PlayerVM);
402 JNIEnv *pEnv = jenv.getEnvironment();
403 if (pEnv) {
404 jstring name = pEnv->NewStringUTF(pTrack->GetName().c_str());
405 jstring language = pEnv->NewStringUTF(pTrack->GetLanguage().c_str());
406
407 pEnv->CallVoidMethod(m_PlayerInstance, m_SendSubtitleTrackEventMethod,
408 (jboolean)pTrack->isEnabled(), (jlong)pTrack->GetTrackID(),
409 name, pTrack->GetEncoding(), language);
410 pEnv->DeleteLocalRef(name);
411 pEnv->DeleteLocalRef(language);
412
413 return !jenv.reportException();
414 }
415
416 return false;
417 }
418
419 /******************************************************************************************
420 * Creates any object with any arguments
421 ******************************************************************************************/
422 jobject CJavaPlayerEventDispatcher::CreateObject(JNIEnv *env, jmethodID *cid,
423 const char* class_name, const char* signature,
424 jvalue* value)
425 {
426 jclass classe;
427 jobject result;
428
429 classe = env->FindClass(class_name);
430 if( classe == NULL )
431 return NULL; /* can't find/load the class, exception thrown */
432
433 if( *cid == NULL)
434 {
435 *cid = env->GetMethodID(classe, "<init>", signature);
436 if( *cid == NULL )
495 jclass durationClass = env->FindClass("javafx/util/Duration");
496 if (durationClass == NULL)
497 return NULL; /* can't find/load the class, exception thrown */
498
499 if (constructorID == NULL)
500 {
501 constructorID = env->GetMethodID(durationClass, "<init>", "(D)V");
502 if( constructorID == NULL )
503 {
504 env->DeleteLocalRef(durationClass);
505 return NULL; /* can't find/get the method, exception thrown */
506 }
507 }
508
509 jobject result = env->NewObject(durationClass, constructorID, millis);
510
511 env->DeleteLocalRef(durationClass);
512
513 return result;
514 }
515
516 bool CJavaPlayerEventDispatcher::SendToJava_MarkerEvent(string name, double time)
517 {
518 if (NULL == m_PlayerInstance)
519 return false;
520
521 CJavaEnvironment jenv(m_PlayerVM);
522 JNIEnv *pEnv = jenv.getEnvironment();
523 if (pEnv) {
524 jobject jname = pEnv->NewStringUTF(name.c_str());
525 pEnv->CallVoidMethod(m_PlayerInstance, m_SendMarkerEventMethod,
526 jname, time);
527 pEnv->DeleteLocalRef(jname);
528 return !jenv.reportException();
529 }
530
531 return false;
532 }
533
534 bool CJavaPlayerEventDispatcher::SendToJava_BufferProgressEvent(double clipDuration, int64_t start, int64_t stop, int64_t position)
535 {
536 if (NULL == m_PlayerInstance)
537 return false;
538
539 CJavaEnvironment jenv(m_PlayerVM);
540 JNIEnv *pEnv = jenv.getEnvironment();
541 if (pEnv) {
542 pEnv->CallVoidMethod(m_PlayerInstance, m_SendBufferProgressEventMethod, clipDuration, start, stop, position);
543 return !jenv.reportException();
544 }
545
546 return false;
547 }
548
549 bool CJavaPlayerEventDispatcher::SendToJava_DurationUpdateEvent(double time)
550 {
551 if (NULL == m_PlayerInstance)
552 return false;
553
554 CJavaEnvironment jenv(m_PlayerVM);
555 JNIEnv *pEnv = jenv.getEnvironment();
556 if (pEnv) {
557 pEnv->CallVoidMethod(m_PlayerInstance, m_SendDurationUpdateEventMethod,
558 (jdouble)time);
559 return !jenv.reportException();
560 }
561
562 return false;
563 }
564
565 bool CJavaPlayerEventDispatcher::SendToJava_AudioSpectrumEvent(double time, double duration)
566 {
567 if (NULL == m_PlayerInstance)
568 return false;
569
570 CJavaEnvironment jenv(m_PlayerVM);
571 JNIEnv *pEnv = jenv.getEnvironment();
572 if (pEnv) {
573 pEnv->CallVoidMethod(m_PlayerInstance, m_SendAudioSpectrumEventMethod, time, duration);
574 return !jenv.reportException();
575 }
576
577 return false;
578 }
|
1 /*
2 * Copyright (c) 2010, 2016, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation. Oracle designates this
8 * particular file as subject to the "Classpath" exception as provided
9 * by Oracle in the LICENSE file that accompanied this code.
10 *
11 * This code is distributed in the hope that it will be useful, but WITHOUT
12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14 * version 2 for more details (a copy is included in the LICENSE file that
15 * accompanied this code).
16 *
17 * You should have received a copy of the GNU General Public License version
18 * 2 along with this work; if not, write to the Free Software Foundation,
19 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
20 *
21 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
22 * or visit www.oracle.com if you need additional information or have any
93 m_SendMarkerEventMethod = env->GetMethodID(klass, "sendMarkerEvent", "(Ljava/lang/String;D)V");
94 m_SendBufferProgressEventMethod = env->GetMethodID(klass, "sendBufferProgressEvent", "(DJJJ)V");
95 m_SendDurationUpdateEventMethod = env->GetMethodID(klass, "sendDurationUpdateEvent", "(D)V");
96 m_SendAudioSpectrumEventMethod = env->GetMethodID(klass, "sendAudioSpectrumEvent", "(DD)V");
97
98 env->DeleteLocalRef(klass);
99
100 areJMethodIDsInitialized = true;
101 }
102
103 LOWLEVELPERF_EXECTIMESTOP("CJavaPlayerEventDispatcher::Init()");
104 }
105
106 void CJavaPlayerEventDispatcher::Dispose()
107 {
108 LOWLEVELPERF_EXECTIMESTART("CJavaPlayerEventDispatcher::Dispose()");
109 CJavaEnvironment jenv(m_PlayerVM);
110 JNIEnv *pEnv = jenv.getEnvironment();
111 if (pEnv) {
112 pEnv->DeleteGlobalRef(m_PlayerInstance);
113 m_PlayerInstance = NULL; // prevent further calls to this object
114 }
115
116 LOWLEVELPERF_EXECTIMESTOP("CJavaPlayerEventDispatcher::Dispose()");
117 }
118
119 void CJavaPlayerEventDispatcher::Warning(int warningCode, const char* warningMessage)
120 {
121 CJavaEnvironment jenv(m_PlayerVM);
122 JNIEnv *pEnv = jenv.getEnvironment();
123 if (pEnv) {
124 jobject localPlayer = pEnv->NewLocalRef(m_PlayerInstance);
125 if (localPlayer) {
126 jstring jmessage = NULL;
127 if (warningMessage) {
128 jmessage = pEnv->NewStringUTF(warningMessage);
129 }
130 pEnv->CallVoidMethod(localPlayer, m_SendWarningMethod,
131 (jint)warningCode, jmessage);
132 if (jmessage) {
133 pEnv->DeleteLocalRef(jmessage);
134 }
135 pEnv->DeleteLocalRef(localPlayer);
136 }
137 }
138 }
139
140 bool CJavaPlayerEventDispatcher::SendPlayerMediaErrorEvent(int errorCode)
141 {
142 bool bSucceeded = false;
143 CJavaEnvironment jenv(m_PlayerVM);
144 JNIEnv *pEnv = jenv.getEnvironment();
145 if (pEnv) {
146 jobject localPlayer = pEnv->NewLocalRef(m_PlayerInstance);
147 if (localPlayer) {
148 pEnv->CallVoidMethod(localPlayer, m_SendPlayerMediaErrorEventMethod, errorCode);
149 pEnv->DeleteLocalRef(localPlayer);
150
151 bSucceeded = !jenv.reportException();
152 }
153 }
154
155 return bSucceeded;
156 }
157
158 bool CJavaPlayerEventDispatcher::SendPlayerHaltEvent(const char* message, double time)
159 {
160 bool bSucceeded = false;
161 CJavaEnvironment jenv(m_PlayerVM);
162 JNIEnv *pEnv = jenv.getEnvironment();
163 if (pEnv) {
164 jobject localPlayer = pEnv->NewLocalRef(m_PlayerInstance);
165 if (localPlayer) {
166 jstring jmessage = pEnv->NewStringUTF(message);
167 pEnv->CallVoidMethod(localPlayer, m_SendPlayerHaltEventMethod, jmessage, time);
168 pEnv->DeleteLocalRef(jmessage);
169 pEnv->DeleteLocalRef(localPlayer);
170
171 bSucceeded = !jenv.reportException();
172 }
173 }
174
175 return bSucceeded;
176 }
177
178 bool CJavaPlayerEventDispatcher::SendPlayerStateEvent(int newState, double presentTime)
179 {
180 long newJavaState;
181
182 switch(newState) {
183 case CPipeline::Unknown:
184 newJavaState = com_sun_media_jfxmediaimpl_NativeMediaPlayer_eventPlayerUnknown;
185 break;
186 case CPipeline::Ready:
187 newJavaState = com_sun_media_jfxmediaimpl_NativeMediaPlayer_eventPlayerReady;
188 break;
189 case CPipeline::Playing:
190 newJavaState = com_sun_media_jfxmediaimpl_NativeMediaPlayer_eventPlayerPlaying;
191 break;
192 case CPipeline::Paused:
193 newJavaState = com_sun_media_jfxmediaimpl_NativeMediaPlayer_eventPlayerPaused;
194 break;
195 case CPipeline::Stopped:
196 newJavaState = com_sun_media_jfxmediaimpl_NativeMediaPlayer_eventPlayerStopped;
197 break;
198 case CPipeline::Stalled:
199 newJavaState = com_sun_media_jfxmediaimpl_NativeMediaPlayer_eventPlayerStalled;
200 break;
201 case CPipeline::Finished:
202 newJavaState = com_sun_media_jfxmediaimpl_NativeMediaPlayer_eventPlayerFinished;
203 break;
204 case CPipeline::Error:
205 newJavaState = com_sun_media_jfxmediaimpl_NativeMediaPlayer_eventPlayerError;
206 break;
207 default:
208 return false;
209 }
210
211 LOWLEVELPERF_EXECTIMESTOP("gstInitPlatformToSendToJavaPlayerStateEventPaused");
212 LOWLEVELPERF_EXECTIMESTOP("gstPauseToSendToJavaPlayerStateEventPaused");
213 LOWLEVELPERF_EXECTIMESTOP("gstStopToSendToJavaPlayerStateEventStopped");
214 LOWLEVELPERF_EXECTIMESTOP("gstPlayToSendToJavaPlayerStateEventPlaying");
215
216 bool bSucceeded = false;
217 CJavaEnvironment jenv(m_PlayerVM);
218 JNIEnv *pEnv = jenv.getEnvironment();
219 if (pEnv) {
220 jobject localPlayer = pEnv->NewLocalRef(m_PlayerInstance);
221 if (localPlayer) {
222 pEnv->CallVoidMethod(localPlayer, m_SendPlayerStateEventMethod, newJavaState, presentTime);
223 pEnv->DeleteLocalRef(localPlayer);
224
225 bSucceeded = !jenv.reportException();
226 }
227 }
228
229 return bSucceeded;
230 }
231
232 bool CJavaPlayerEventDispatcher::SendNewFrameEvent(CVideoFrame* pVideoFrame)
233 {
234 LOWLEVELPERF_EXECTIMESTART("CJavaPlayerEventDispatcher::SendNewFrameEvent()");
235 bool bSucceeded = false;
236
237 CJavaEnvironment jenv(m_PlayerVM);
238 JNIEnv *pEnv = jenv.getEnvironment();
239 if (pEnv) {
240 jobject localPlayer = pEnv->NewLocalRef(m_PlayerInstance);
241 if (localPlayer) {
242 // SendNewFrameEvent will create the NativeVideoBuffer wrapper for the java side
243 pEnv->CallVoidMethod(localPlayer, m_SendNewFrameEventMethod, ptr_to_jlong(pVideoFrame));
244 pEnv->DeleteLocalRef(localPlayer);
245
246 bSucceeded = !jenv.reportException();
247 }
248 }
249
250 LOWLEVELPERF_EXECTIMESTOP("CJavaPlayerEventDispatcher::SendNewFrameEvent()");
251
252 return bSucceeded;
253 }
254
255 bool CJavaPlayerEventDispatcher::SendFrameSizeChangedEvent(int width, int height)
256 {
257 bool bSucceeded = false;
258 CJavaEnvironment jenv(m_PlayerVM);
259 JNIEnv *pEnv = jenv.getEnvironment();
260 if (pEnv) {
261 jobject localPlayer = pEnv->NewLocalRef(m_PlayerInstance);
262 if (localPlayer) {
263 pEnv->CallVoidMethod(localPlayer, m_SendFrameSizeChangedEventMethod, (jint)width, (jint)height);
264 pEnv->DeleteLocalRef(localPlayer);
265
266 bSucceeded = !jenv.reportException();
267 }
268 }
269
270 return bSucceeded;
271 }
272
273 bool CJavaPlayerEventDispatcher::SendAudioTrackEvent(CAudioTrack* pTrack)
274 {
275 bool bSucceeded = false;
276 CJavaEnvironment jenv(m_PlayerVM);
277 JNIEnv *pEnv = jenv.getEnvironment();
278 if (pEnv) {
279 jobject localPlayer = pEnv->NewLocalRef(m_PlayerInstance);
280 if (localPlayer) {
281 jstring name = pEnv->NewStringUTF(pTrack->GetName().c_str());
282 jstring language = pEnv->NewStringUTF(pTrack->GetLanguage().c_str());
283
284 // Translate channel mask bits from native values to Java values.
285 int nativeChannelMask = pTrack->GetChannelMask();
286 jint javaChannelMask = 0;
287 if (nativeChannelMask & CAudioTrack::UNKNOWN)
288 javaChannelMask |= com_sun_media_jfxmedia_track_AudioTrack_UNKNOWN;
289 if (nativeChannelMask & CAudioTrack::FRONT_LEFT)
290 javaChannelMask |= com_sun_media_jfxmedia_track_AudioTrack_FRONT_LEFT;
291 if (nativeChannelMask & CAudioTrack::FRONT_RIGHT)
292 javaChannelMask |= com_sun_media_jfxmedia_track_AudioTrack_FRONT_RIGHT;
293 if (nativeChannelMask & CAudioTrack::FRONT_CENTER)
294 javaChannelMask |= com_sun_media_jfxmedia_track_AudioTrack_FRONT_CENTER;
295 if (nativeChannelMask & CAudioTrack::REAR_LEFT)
296 javaChannelMask |= com_sun_media_jfxmedia_track_AudioTrack_REAR_LEFT;
297 if (nativeChannelMask & CAudioTrack::REAR_RIGHT)
298 javaChannelMask |= com_sun_media_jfxmedia_track_AudioTrack_REAR_RIGHT;
299 if (nativeChannelMask & CAudioTrack::REAR_CENTER)
300 javaChannelMask |= com_sun_media_jfxmedia_track_AudioTrack_REAR_CENTER;
301
302 pEnv->CallVoidMethod(localPlayer,
303 m_SendAudioTrackEventMethod,
304 (jboolean)pTrack->isEnabled(),
305 (jlong)pTrack->GetTrackID(),
306 name,
307 pTrack->GetEncoding(),
308 language,
309 pTrack->GetNumChannels(),
310 javaChannelMask,
311 pTrack->GetSampleRate());
312
313 pEnv->DeleteLocalRef(name);
314 pEnv->DeleteLocalRef(language);
315 pEnv->DeleteLocalRef(localPlayer);
316
317 bSucceeded = !jenv.reportException();
318 }
319 }
320
321 return bSucceeded;
322 }
323
324 bool CJavaPlayerEventDispatcher::SendVideoTrackEvent(CVideoTrack* pTrack)
325 {
326 bool bSucceeded = false;
327 CJavaEnvironment jenv(m_PlayerVM);
328 JNIEnv *pEnv = jenv.getEnvironment();
329 if (pEnv) {
330 jobject localPlayer = pEnv->NewLocalRef(m_PlayerInstance);
331 if (localPlayer) {
332 jstring name = pEnv->NewStringUTF(pTrack->GetName().c_str());
333 pEnv->CallVoidMethod(localPlayer, m_SendVideoTrackEventMethod,
334 (jboolean)pTrack->isEnabled(), (jlong)pTrack->GetTrackID(), name, pTrack->GetEncoding(),
335 pTrack->GetWidth(), pTrack->GetHeight(),
336 pTrack->GetFrameRate(), pTrack->HasAlphaChannel());
337 pEnv->DeleteLocalRef(name);
338 pEnv->DeleteLocalRef(localPlayer);
339
340 bSucceeded = !jenv.reportException();
341 }
342 }
343
344 return bSucceeded;
345 }
346
347 bool CJavaPlayerEventDispatcher::SendSubtitleTrackEvent(CSubtitleTrack* pTrack)
348 {
349 bool bSucceeded = false;
350 CJavaEnvironment jenv(m_PlayerVM);
351 JNIEnv *pEnv = jenv.getEnvironment();
352 if (pEnv) {
353 jobject localPlayer = pEnv->NewLocalRef(m_PlayerInstance);
354 if (localPlayer) {
355 jstring name = pEnv->NewStringUTF(pTrack->GetName().c_str());
356 jstring language = pEnv->NewStringUTF(pTrack->GetLanguage().c_str());
357
358 pEnv->CallVoidMethod(localPlayer, m_SendSubtitleTrackEventMethod,
359 (jboolean)pTrack->isEnabled(), (jlong)pTrack->GetTrackID(),
360 name, pTrack->GetEncoding(), language);
361 pEnv->DeleteLocalRef(name);
362 pEnv->DeleteLocalRef(language);
363 pEnv->DeleteLocalRef(localPlayer);
364
365 bSucceeded = !jenv.reportException();
366 }
367 }
368
369 return bSucceeded;
370 }
371
372 bool CJavaPlayerEventDispatcher::SendMarkerEvent(string name, double time)
373 {
374 bool bSucceeded = false;
375 CJavaEnvironment jenv(m_PlayerVM);
376 JNIEnv *pEnv = jenv.getEnvironment();
377 if (pEnv) {
378 jobject localPlayer = pEnv->NewLocalRef(m_PlayerInstance);
379 if (localPlayer) {
380 jobject jname = pEnv->NewStringUTF(name.c_str());
381 pEnv->CallVoidMethod(localPlayer, m_SendMarkerEventMethod,
382 jname, time);
383 pEnv->DeleteLocalRef(jname);
384 pEnv->DeleteLocalRef(localPlayer);
385
386 bSucceeded = !jenv.reportException();
387 }
388 }
389
390 return bSucceeded;
391 }
392
393 bool CJavaPlayerEventDispatcher::SendBufferProgressEvent(double clipDuration, int64_t start, int64_t stop, int64_t position)
394 {
395 bool bSucceeded = false;
396 CJavaEnvironment jenv(m_PlayerVM);
397 JNIEnv *pEnv = jenv.getEnvironment();
398 if (pEnv) {
399 jobject localPlayer = pEnv->NewLocalRef(m_PlayerInstance);
400 if (localPlayer) {
401 pEnv->CallVoidMethod(localPlayer, m_SendBufferProgressEventMethod, clipDuration, start, stop, position);
402 pEnv->DeleteLocalRef(localPlayer);
403
404 bSucceeded = !jenv.reportException();
405 }
406 }
407
408 return bSucceeded;
409 }
410
411 bool CJavaPlayerEventDispatcher::SendDurationUpdateEvent(double time)
412 {
413 bool bSucceeded = false;
414 CJavaEnvironment jenv(m_PlayerVM);
415 JNIEnv *pEnv = jenv.getEnvironment();
416 if (pEnv) {
417 jobject localPlayer = pEnv->NewLocalRef(m_PlayerInstance);
418 if (localPlayer) {
419 pEnv->CallVoidMethod(localPlayer, m_SendDurationUpdateEventMethod,
420 (jdouble)time);
421 pEnv->DeleteLocalRef(localPlayer);
422
423 bSucceeded = !jenv.reportException();
424 }
425 }
426
427 return bSucceeded;
428 }
429
430 bool CJavaPlayerEventDispatcher::SendAudioSpectrumEvent(double time, double duration)
431 {
432 bool bSucceeded = false;
433 CJavaEnvironment jenv(m_PlayerVM);
434 JNIEnv *pEnv = jenv.getEnvironment();
435 if (pEnv) {
436 jobject localPlayer = pEnv->NewLocalRef(m_PlayerInstance);
437 if (localPlayer) {
438 pEnv->CallVoidMethod(localPlayer, m_SendAudioSpectrumEventMethod, time, duration);
439 pEnv->DeleteLocalRef(localPlayer);
440
441 bSucceeded = !jenv.reportException();
442 }
443 }
444
445 return bSucceeded;
446 }
447
448 /******************************************************************************************
449 * Creates any object with any arguments
450 ******************************************************************************************/
451 jobject CJavaPlayerEventDispatcher::CreateObject(JNIEnv *env, jmethodID *cid,
452 const char* class_name, const char* signature,
453 jvalue* value)
454 {
455 jclass classe;
456 jobject result;
457
458 classe = env->FindClass(class_name);
459 if( classe == NULL )
460 return NULL; /* can't find/load the class, exception thrown */
461
462 if( *cid == NULL)
463 {
464 *cid = env->GetMethodID(classe, "<init>", signature);
465 if( *cid == NULL )
524 jclass durationClass = env->FindClass("javafx/util/Duration");
525 if (durationClass == NULL)
526 return NULL; /* can't find/load the class, exception thrown */
527
528 if (constructorID == NULL)
529 {
530 constructorID = env->GetMethodID(durationClass, "<init>", "(D)V");
531 if( constructorID == NULL )
532 {
533 env->DeleteLocalRef(durationClass);
534 return NULL; /* can't find/get the method, exception thrown */
535 }
536 }
537
538 jobject result = env->NewObject(durationClass, constructorID, millis);
539
540 env->DeleteLocalRef(durationClass);
541
542 return result;
543 }
|