1 /*****************************************************************************
\r
2 * npolibvlc.cpp: official Javascript APIs
\r
3 *****************************************************************************
\r
4 * Copyright (C) 2002-2006 the VideoLAN team
\r
6 * Authors: Damien Fouilleul <Damien.Fouilleul@laposte.net>
\r
8 * This program is free software; you can redistribute it and/or modify
\r
9 * it under the terms of the GNU General Public License as published by
\r
10 * the Free Software Foundation; either version 2 of the License, or
\r
11 * (at your option) any later version.
\r
13 * This program is distributed in the hope that it will be useful,
\r
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
\r
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
\r
16 * GNU General Public License for more details.
\r
18 * You should have received a copy of the GNU General Public License
\r
19 * along with this program; if not, write to the Free Software
\r
20 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
\r
21 *****************************************************************************/
\r
30 #ifdef HAVE_MOZILLA_CONFIG_H
\r
31 # include <mozilla-config.h>
\r
34 #include "vlcplugin.h"
\r
35 #include "npolibvlc.h"
\r
38 ** implementation of libvlc root object
\r
41 LibvlcRootNPObject::~LibvlcRootNPObject()
\r
44 ** when plugin is destroyed, firefox takes upon itself to destroy all 'live' script objects
\r
45 ** and ignores refcounting. Therefore we cannot safely assume that refcounting will control
\r
46 ** lifespan of objects. Hence they are only lazily created on request, so that firefox can
\r
47 ** take ownership, and are not released when plugin is being destroyed.
\r
51 if( audioObj ) NPN_ReleaseObject(audioObj);
\r
52 if( inputObj ) NPN_ReleaseObject(inputObj);
\r
53 if( logObj ) NPN_ReleaseObject(logObj);
\r
54 if( playlistObj ) NPN_ReleaseObject(playlistObj);
\r
55 if( videoObj ) NPN_ReleaseObject(videoObj);
\r
59 const NPUTF8 * const LibvlcRootNPObject::propertyNames[] =
\r
69 const int LibvlcRootNPObject::propertyCount = sizeof(LibvlcRootNPObject::propertyNames)/sizeof(NPUTF8 *);
\r
71 enum LibvlcRootNPObjectPropertyIds
\r
78 ID_root_VersionInfo,
\r
81 RuntimeNPObject::InvokeResult LibvlcRootNPObject::getProperty(int index, NPVariant &result)
\r
83 /* is plugin still running */
\r
84 if( _instance->pdata )
\r
89 // create child object in lazyman fashion to avoid ownership problem with firefox
\r
91 audioObj = NPN_CreateObject(_instance, RuntimeNPClass<LibvlcAudioNPObject>::getClass());
\r
92 OBJECT_TO_NPVARIANT(NPN_RetainObject(audioObj), result);
\r
93 return INVOKERESULT_NO_ERROR;
\r
95 // create child object in lazyman fashion to avoid ownership problem with firefox
\r
97 inputObj = NPN_CreateObject(_instance, RuntimeNPClass<LibvlcInputNPObject>::getClass());
\r
98 OBJECT_TO_NPVARIANT(NPN_RetainObject(inputObj), result);
\r
99 return INVOKERESULT_NO_ERROR;
\r
101 // create child object in lazyman fashion to avoid ownership problem with firefox
\r
103 logObj = NPN_CreateObject(_instance, RuntimeNPClass<LibvlcLogNPObject>::getClass());
\r
104 OBJECT_TO_NPVARIANT(NPN_RetainObject(logObj), result);
\r
105 return INVOKERESULT_NO_ERROR;
\r
106 case ID_root_playlist:
\r
107 // create child object in lazyman fashion to avoid ownership problem with firefox
\r
108 if( ! playlistObj )
\r
109 playlistObj = NPN_CreateObject(_instance, RuntimeNPClass<LibvlcPlaylistNPObject>::getClass());
\r
110 OBJECT_TO_NPVARIANT(NPN_RetainObject(playlistObj), result);
\r
111 return INVOKERESULT_NO_ERROR;
\r
112 case ID_root_video:
\r
113 // create child object in lazyman fashion to avoid ownership problem with firefox
\r
115 videoObj = NPN_CreateObject(_instance,RuntimeNPClass<LibvlcVideoNPObject>::getClass());
\r
116 OBJECT_TO_NPVARIANT(NPN_RetainObject(videoObj), result);
\r
117 return INVOKERESULT_NO_ERROR;
\r
118 case ID_root_VersionInfo:
\r
120 int len = strlen(VLC_Version());
\r
121 NPUTF8 *retval =(NPUTF8*)NPN_MemAlloc(len);
\r
124 memcpy(retval, VLC_Version(), len);
\r
125 STRINGN_TO_NPVARIANT(retval, len, result);
\r
129 NULL_TO_NPVARIANT(result);
\r
131 return INVOKERESULT_NO_ERROR;
\r
137 return INVOKERESULT_GENERIC_ERROR;
\r
140 const NPUTF8 * const LibvlcRootNPObject::methodNames[] =
\r
145 const int LibvlcRootNPObject::methodCount = sizeof(LibvlcRootNPObject::methodNames)/sizeof(NPUTF8 *);
\r
147 enum LibvlcRootNPObjectMethodIds
\r
149 ID_root_versionInfo,
\r
152 RuntimeNPObject::InvokeResult LibvlcRootNPObject::invoke(int index, const NPVariant *args, uint32_t argCount, NPVariant &result)
\r
154 /* is plugin still running */
\r
155 if( _instance->pdata )
\r
157 libvlc_exception_t ex;
\r
158 libvlc_exception_init(&ex);
\r
162 case ID_root_versionInfo:
\r
163 if( argCount == 0 )
\r
165 int len = strlen(VLC_Version());
\r
166 NPUTF8 *retval =(NPUTF8*)NPN_MemAlloc(len);
\r
169 memcpy(retval, VLC_Version(), len);
\r
170 STRINGN_TO_NPVARIANT(retval, len, result);
\r
174 NULL_TO_NPVARIANT(result);
\r
176 return INVOKERESULT_NO_ERROR;
\r
178 return INVOKERESULT_NO_SUCH_METHOD;
\r
183 return INVOKERESULT_GENERIC_ERROR;
\r
187 ** implementation of libvlc audio object
\r
190 const NPUTF8 * const LibvlcAudioNPObject::propertyNames[] =
\r
198 const int LibvlcAudioNPObject::propertyCount = sizeof(LibvlcAudioNPObject::propertyNames)/sizeof(NPUTF8 *);
\r
200 enum LibvlcAudioNPObjectPropertyIds
\r
208 RuntimeNPObject::InvokeResult LibvlcAudioNPObject::getProperty(int index, NPVariant &result)
\r
210 /* is plugin still running */
\r
211 if( _instance->pdata )
\r
213 VlcPlugin* p_plugin = reinterpret_cast<VlcPlugin*>(_instance->pdata);
\r
214 libvlc_exception_t ex;
\r
215 libvlc_exception_init(&ex);
\r
219 case ID_audio_mute:
\r
221 vlc_bool_t muted = libvlc_audio_get_mute(p_plugin->getVLC(), &ex);
\r
222 if( libvlc_exception_raised(&ex) )
\r
224 NPN_SetException(this, libvlc_exception_get_message(&ex));
\r
225 libvlc_exception_clear(&ex);
\r
226 return INVOKERESULT_GENERIC_ERROR;
\r
228 BOOLEAN_TO_NPVARIANT(muted, result);
\r
229 return INVOKERESULT_NO_ERROR;
\r
231 case ID_audio_volume:
\r
233 int volume = libvlc_audio_get_volume(p_plugin->getVLC(), &ex);
\r
234 if( libvlc_exception_raised(&ex) )
\r
236 NPN_SetException(this, libvlc_exception_get_message(&ex));
\r
237 libvlc_exception_clear(&ex);
\r
238 return INVOKERESULT_GENERIC_ERROR;
\r
240 INT32_TO_NPVARIANT(volume, result);
\r
241 return INVOKERESULT_NO_ERROR;
\r
243 case ID_audio_track:
\r
245 libvlc_media_player_t *p_md = libvlc_playlist_get_media_player(p_plugin->getVLC(), &ex);
\r
246 if( libvlc_exception_raised(&ex) )
\r
248 NPN_SetException(this, libvlc_exception_get_message(&ex));
\r
249 libvlc_exception_clear(&ex);
\r
250 return INVOKERESULT_GENERIC_ERROR;
\r
252 int track = libvlc_audio_get_track(p_md, &ex);
\r
253 libvlc_media_player_release(p_md);
\r
254 if( libvlc_exception_raised(&ex) )
\r
256 NPN_SetException(this, libvlc_exception_get_message(&ex));
\r
257 libvlc_exception_clear(&ex);
\r
258 return INVOKERESULT_GENERIC_ERROR;
\r
260 INT32_TO_NPVARIANT(track, result);
\r
261 return INVOKERESULT_NO_ERROR;
\r
263 case ID_audio_channel:
\r
265 int channel = libvlc_audio_get_channel(p_plugin->getVLC(), &ex);
\r
266 if( libvlc_exception_raised(&ex) )
\r
268 NPN_SetException(this, libvlc_exception_get_message(&ex));
\r
269 libvlc_exception_clear(&ex);
\r
270 return INVOKERESULT_GENERIC_ERROR;
\r
272 INT32_TO_NPVARIANT(channel, result);
\r
273 return INVOKERESULT_NO_ERROR;
\r
279 return INVOKERESULT_GENERIC_ERROR;
\r
282 RuntimeNPObject::InvokeResult LibvlcAudioNPObject::setProperty(int index, const NPVariant &value)
\r
284 /* is plugin still running */
\r
285 if( _instance->pdata )
\r
287 VlcPlugin* p_plugin = reinterpret_cast<VlcPlugin*>(_instance->pdata);
\r
288 libvlc_exception_t ex;
\r
289 libvlc_exception_init(&ex);
\r
293 case ID_audio_mute:
\r
294 if( NPVARIANT_IS_BOOLEAN(value) )
\r
296 libvlc_audio_set_mute(p_plugin->getVLC(),
\r
297 NPVARIANT_TO_BOOLEAN(value), &ex);
\r
298 if( libvlc_exception_raised(&ex) )
\r
300 NPN_SetException(this, libvlc_exception_get_message(&ex));
\r
301 libvlc_exception_clear(&ex);
\r
302 return INVOKERESULT_GENERIC_ERROR;
\r
304 return INVOKERESULT_NO_ERROR;
\r
306 return INVOKERESULT_INVALID_VALUE;
\r
307 case ID_audio_volume:
\r
308 if( isNumberValue(value) )
\r
310 libvlc_audio_set_volume(p_plugin->getVLC(),
\r
311 numberValue(value), &ex);
\r
312 if( libvlc_exception_raised(&ex) )
\r
314 NPN_SetException(this, libvlc_exception_get_message(&ex));
\r
315 libvlc_exception_clear(&ex);
\r
316 return INVOKERESULT_GENERIC_ERROR;
\r
318 return INVOKERESULT_NO_ERROR;
\r
320 return INVOKERESULT_INVALID_VALUE;
\r
321 case ID_audio_track:
\r
322 if( isNumberValue(value) )
\r
324 libvlc_media_player_t *p_md = libvlc_playlist_get_media_player(p_plugin->getVLC(), &ex);
\r
325 if( libvlc_exception_raised(&ex) )
\r
327 NPN_SetException(this, libvlc_exception_get_message(&ex));
\r
328 libvlc_exception_clear(&ex);
\r
329 return INVOKERESULT_GENERIC_ERROR;
\r
331 libvlc_audio_set_track(p_md,
\r
332 numberValue(value), &ex);
\r
333 libvlc_media_player_release(p_md);
\r
334 if( libvlc_exception_raised(&ex) )
\r
336 NPN_SetException(this, libvlc_exception_get_message(&ex));
\r
337 libvlc_exception_clear(&ex);
\r
338 return INVOKERESULT_GENERIC_ERROR;
\r
340 return INVOKERESULT_NO_ERROR;
\r
342 return INVOKERESULT_INVALID_VALUE;
\r
343 case ID_audio_channel:
\r
344 if( isNumberValue(value) )
\r
346 libvlc_audio_set_channel(p_plugin->getVLC(),
\r
347 numberValue(value), &ex);
\r
348 if( libvlc_exception_raised(&ex) )
\r
350 NPN_SetException(this, libvlc_exception_get_message(&ex));
\r
351 libvlc_exception_clear(&ex);
\r
352 return INVOKERESULT_GENERIC_ERROR;
\r
354 return INVOKERESULT_NO_ERROR;
\r
356 return INVOKERESULT_INVALID_VALUE;
\r
361 return INVOKERESULT_GENERIC_ERROR;
\r
364 const NPUTF8 * const LibvlcAudioNPObject::methodNames[] =
\r
369 const int LibvlcAudioNPObject::methodCount = sizeof(LibvlcAudioNPObject::methodNames)/sizeof(NPUTF8 *);
\r
371 enum LibvlcAudioNPObjectMethodIds
\r
373 ID_audio_togglemute,
\r
376 RuntimeNPObject::InvokeResult LibvlcAudioNPObject::invoke(int index, const NPVariant *args, uint32_t argCount, NPVariant &result)
\r
378 /* is plugin still running */
\r
379 if( _instance->pdata )
\r
381 VlcPlugin* p_plugin = reinterpret_cast<VlcPlugin*>(_instance->pdata);
\r
382 libvlc_exception_t ex;
\r
383 libvlc_exception_init(&ex);
\r
387 case ID_audio_togglemute:
\r
388 if( argCount == 0 )
\r
390 libvlc_audio_toggle_mute(p_plugin->getVLC(), &ex);
\r
391 if( libvlc_exception_raised(&ex) )
\r
393 NPN_SetException(this, libvlc_exception_get_message(&ex));
\r
394 libvlc_exception_clear(&ex);
\r
395 return INVOKERESULT_GENERIC_ERROR;
\r
399 VOID_TO_NPVARIANT(result);
\r
400 return INVOKERESULT_NO_ERROR;
\r
403 return INVOKERESULT_NO_SUCH_METHOD;
\r
408 return INVOKERESULT_GENERIC_ERROR;
\r
412 ** implementation of libvlc input object
\r
415 const NPUTF8 * const LibvlcInputNPObject::propertyNames[] =
\r
426 const int LibvlcInputNPObject::propertyCount = sizeof(LibvlcInputNPObject::propertyNames)/sizeof(NPUTF8 *);
\r
428 enum LibvlcInputNPObjectPropertyIds
\r
439 RuntimeNPObject::InvokeResult LibvlcInputNPObject::getProperty(int index, NPVariant &result)
\r
441 /* is plugin still running */
\r
442 if( _instance->pdata )
\r
444 VlcPlugin* p_plugin = reinterpret_cast<VlcPlugin*>(_instance->pdata);
\r
445 libvlc_exception_t ex;
\r
446 libvlc_exception_init(&ex);
\r
448 libvlc_media_player_t *p_md = libvlc_playlist_get_media_player(p_plugin->getVLC(), &ex);
\r
449 if( libvlc_exception_raised(&ex) )
\r
451 if( index != ID_input_state )
\r
453 NPN_SetException(this, libvlc_exception_get_message(&ex));
\r
454 libvlc_exception_clear(&ex);
\r
455 return INVOKERESULT_GENERIC_ERROR;
\r
459 /* for input state, return CLOSED rather than an exception */
\r
460 INT32_TO_NPVARIANT(0, result);
\r
461 return INVOKERESULT_NO_ERROR;
\r
467 case ID_input_length:
\r
469 double val = (double)libvlc_media_player_get_length(p_md, &ex);
\r
470 libvlc_media_player_release(p_md);
\r
471 if( libvlc_exception_raised(&ex) )
\r
473 NPN_SetException(this, libvlc_exception_get_message(&ex));
\r
474 libvlc_exception_clear(&ex);
\r
475 return INVOKERESULT_GENERIC_ERROR;
\r
477 DOUBLE_TO_NPVARIANT(val, result);
\r
478 return INVOKERESULT_NO_ERROR;
\r
480 case ID_input_position:
\r
482 double val = libvlc_media_player_get_position(p_md, &ex);
\r
483 libvlc_media_player_release(p_md);
\r
484 if( libvlc_exception_raised(&ex) )
\r
486 NPN_SetException(this, libvlc_exception_get_message(&ex));
\r
487 libvlc_exception_clear(&ex);
\r
488 return INVOKERESULT_GENERIC_ERROR;
\r
490 DOUBLE_TO_NPVARIANT(val, result);
\r
491 return INVOKERESULT_NO_ERROR;
\r
493 case ID_input_time:
\r
495 double val = (double)libvlc_media_player_get_time(p_md, &ex);
\r
496 libvlc_media_player_release(p_md);
\r
497 if( libvlc_exception_raised(&ex) )
\r
499 NPN_SetException(this, libvlc_exception_get_message(&ex));
\r
500 libvlc_exception_clear(&ex);
\r
501 return INVOKERESULT_GENERIC_ERROR;
\r
503 DOUBLE_TO_NPVARIANT(val, result);
\r
504 return INVOKERESULT_NO_ERROR;
\r
506 case ID_input_state:
\r
508 int val = libvlc_media_player_get_state(p_md, &ex);
\r
509 libvlc_media_player_release(p_md);
\r
510 if( libvlc_exception_raised(&ex) )
\r
512 NPN_SetException(this, libvlc_exception_get_message(&ex));
\r
513 libvlc_exception_clear(&ex);
\r
514 return INVOKERESULT_GENERIC_ERROR;
\r
516 INT32_TO_NPVARIANT(val, result);
\r
517 return INVOKERESULT_NO_ERROR;
\r
519 case ID_input_rate:
\r
521 float val = libvlc_media_player_get_rate(p_md, &ex);
\r
522 libvlc_media_player_release(p_md);
\r
523 if( libvlc_exception_raised(&ex) )
\r
525 NPN_SetException(this, libvlc_exception_get_message(&ex));
\r
526 libvlc_exception_clear(&ex);
\r
527 return INVOKERESULT_GENERIC_ERROR;
\r
529 DOUBLE_TO_NPVARIANT(val, result);
\r
530 return INVOKERESULT_NO_ERROR;
\r
534 double val = libvlc_media_player_get_fps(p_md, &ex);
\r
535 libvlc_media_player_release(p_md);
\r
536 if( libvlc_exception_raised(&ex) )
\r
538 NPN_SetException(this, libvlc_exception_get_message(&ex));
\r
539 libvlc_exception_clear(&ex);
\r
540 return INVOKERESULT_GENERIC_ERROR;
\r
542 DOUBLE_TO_NPVARIANT(val, result);
\r
543 return INVOKERESULT_NO_ERROR;
\r
545 case ID_input_hasvout:
\r
547 vlc_bool_t val = libvlc_media_player_has_vout(p_md, &ex);
\r
548 libvlc_media_player_release(p_md);
\r
549 if( libvlc_exception_raised(&ex) )
\r
551 NPN_SetException(this, libvlc_exception_get_message(&ex));
\r
552 libvlc_exception_clear(&ex);
\r
553 return INVOKERESULT_GENERIC_ERROR;
\r
555 BOOLEAN_TO_NPVARIANT(val, result);
\r
556 return INVOKERESULT_NO_ERROR;
\r
561 libvlc_media_player_release(p_md);
\r
563 return INVOKERESULT_GENERIC_ERROR;
\r
566 RuntimeNPObject::InvokeResult LibvlcInputNPObject::setProperty(int index, const NPVariant &value)
\r
568 /* is plugin still running */
\r
569 if( _instance->pdata )
\r
571 VlcPlugin* p_plugin = reinterpret_cast<VlcPlugin*>(_instance->pdata);
\r
572 libvlc_exception_t ex;
\r
573 libvlc_exception_init(&ex);
\r
575 libvlc_media_player_t *p_md = libvlc_playlist_get_media_player(p_plugin->getVLC(), &ex);
\r
576 if( libvlc_exception_raised(&ex) )
\r
578 NPN_SetException(this, libvlc_exception_get_message(&ex));
\r
579 libvlc_exception_clear(&ex);
\r
580 return INVOKERESULT_GENERIC_ERROR;
\r
585 case ID_input_position:
\r
587 if( ! NPVARIANT_IS_DOUBLE(value) )
\r
589 libvlc_media_player_release(p_md);
\r
590 return INVOKERESULT_INVALID_VALUE;
\r
593 float val = (float)NPVARIANT_TO_DOUBLE(value);
\r
594 libvlc_media_player_set_position(p_md, val, &ex);
\r
595 libvlc_media_player_release(p_md);
\r
596 if( libvlc_exception_raised(&ex) )
\r
598 NPN_SetException(this, libvlc_exception_get_message(&ex));
\r
599 libvlc_exception_clear(&ex);
\r
600 return INVOKERESULT_GENERIC_ERROR;
\r
602 return INVOKERESULT_NO_ERROR;
\r
604 case ID_input_time:
\r
607 if( NPVARIANT_IS_INT32(value) )
\r
608 val = (vlc_int64_t)NPVARIANT_TO_INT32(value);
\r
609 else if( NPVARIANT_IS_DOUBLE(value) )
\r
610 val = (vlc_int64_t)NPVARIANT_TO_DOUBLE(value);
\r
613 libvlc_media_player_release(p_md);
\r
614 return INVOKERESULT_INVALID_VALUE;
\r
617 libvlc_media_player_set_time(p_md, val, &ex);
\r
618 libvlc_media_player_release(p_md);
\r
619 if( libvlc_exception_raised(&ex) )
\r
621 NPN_SetException(this, libvlc_exception_get_message(&ex));
\r
622 libvlc_exception_clear(&ex);
\r
623 return INVOKERESULT_GENERIC_ERROR;
\r
625 return INVOKERESULT_NO_ERROR;
\r
627 case ID_input_rate:
\r
630 if( NPVARIANT_IS_INT32(value) )
\r
631 val = (float)NPVARIANT_TO_INT32(value);
\r
632 else if( NPVARIANT_IS_DOUBLE(value) )
\r
633 val = (float)NPVARIANT_TO_DOUBLE(value);
\r
636 libvlc_media_player_release(p_md);
\r
637 return INVOKERESULT_INVALID_VALUE;
\r
640 libvlc_media_player_set_rate(p_md, val, &ex);
\r
641 libvlc_media_player_release(p_md);
\r
642 if( libvlc_exception_raised(&ex) )
\r
644 NPN_SetException(this, libvlc_exception_get_message(&ex));
\r
645 libvlc_exception_clear(&ex);
\r
646 return INVOKERESULT_GENERIC_ERROR;
\r
648 return INVOKERESULT_NO_ERROR;
\r
653 libvlc_media_player_release(p_md);
\r
655 return INVOKERESULT_GENERIC_ERROR;
\r
658 const NPUTF8 * const LibvlcInputNPObject::methodNames[] =
\r
663 const int LibvlcInputNPObject::methodCount = sizeof(LibvlcInputNPObject::methodNames)/sizeof(NPUTF8 *);
\r
666 ** implementation of libvlc message object
\r
669 const NPUTF8 * const LibvlcMessageNPObject::propertyNames[] =
\r
678 const int LibvlcMessageNPObject::propertyCount = sizeof(LibvlcMessageNPObject::propertyNames)/sizeof(NPUTF8 *);
\r
680 enum LibvlcMessageNPObjectPropertyIds
\r
682 ID_message_severity,
\r
686 ID_message_message,
\r
689 RuntimeNPObject::InvokeResult LibvlcMessageNPObject::getProperty(int index, NPVariant &result)
\r
691 /* is plugin still running */
\r
692 if( _instance->pdata )
\r
696 case ID_message_severity:
\r
698 INT32_TO_NPVARIANT(_msg.i_severity, result);
\r
699 return INVOKERESULT_NO_ERROR;
\r
701 case ID_message_type:
\r
703 if( _msg.psz_type )
\r
705 int len = strlen(_msg.psz_type);
\r
706 NPUTF8* retval = (NPUTF8*)NPN_MemAlloc(len);
\r
709 memcpy(retval, _msg.psz_type, len);
\r
710 STRINGN_TO_NPVARIANT(retval, len, result);
\r
715 NULL_TO_NPVARIANT(result);
\r
717 return INVOKERESULT_NO_ERROR;
\r
719 case ID_message_name:
\r
721 if( _msg.psz_name )
\r
723 int len = strlen(_msg.psz_name);
\r
724 NPUTF8* retval = (NPUTF8*)NPN_MemAlloc(len);
\r
727 memcpy(retval, _msg.psz_name, len);
\r
728 STRINGN_TO_NPVARIANT(retval, len, result);
\r
733 NULL_TO_NPVARIANT(result);
\r
735 return INVOKERESULT_NO_ERROR;
\r
737 case ID_message_header:
\r
739 if( _msg.psz_header )
\r
741 int len = strlen(_msg.psz_header);
\r
742 NPUTF8* retval = (NPUTF8*)NPN_MemAlloc(len);
\r
745 memcpy(retval, _msg.psz_header, len);
\r
746 STRINGN_TO_NPVARIANT(retval, len, result);
\r
751 NULL_TO_NPVARIANT(result);
\r
753 return INVOKERESULT_NO_ERROR;
\r
755 case ID_message_message:
\r
757 if( _msg.psz_message )
\r
759 int len = strlen(_msg.psz_message);
\r
760 NPUTF8* retval = (NPUTF8*)NPN_MemAlloc(len);
\r
763 memcpy(retval, _msg.psz_message, len);
\r
764 STRINGN_TO_NPVARIANT(retval, len, result);
\r
769 NULL_TO_NPVARIANT(result);
\r
771 return INVOKERESULT_NO_ERROR;
\r
777 return INVOKERESULT_GENERIC_ERROR;
\r
780 const NPUTF8 * const LibvlcMessageNPObject::methodNames[] =
\r
785 const int LibvlcMessageNPObject::methodCount = sizeof(LibvlcMessageNPObject::methodNames)/sizeof(NPUTF8 *);
\r
788 ** implementation of libvlc message iterator object
\r
791 LibvlcMessageIteratorNPObject::LibvlcMessageIteratorNPObject(NPP instance, const NPClass *aClass) :
\r
792 RuntimeNPObject(instance, aClass),
\r
795 /* is plugin still running */
\r
796 if( instance->pdata )
\r
798 VlcPlugin* p_plugin = reinterpret_cast<VlcPlugin*>(instance->pdata);
\r
799 libvlc_log_t *p_log = p_plugin->getLog();
\r
802 _p_iter = libvlc_log_get_iterator(p_log, NULL);
\r
807 LibvlcMessageIteratorNPObject::~LibvlcMessageIteratorNPObject()
\r
810 libvlc_log_iterator_free(_p_iter, NULL);
\r
813 const NPUTF8 * const LibvlcMessageIteratorNPObject::propertyNames[] =
\r
818 const int LibvlcMessageIteratorNPObject::propertyCount = sizeof(LibvlcMessageIteratorNPObject::propertyNames)/sizeof(NPUTF8 *);
\r
820 enum LibvlcMessageIteratorNPObjectPropertyIds
\r
822 ID_messageiterator_hasNext,
\r
825 RuntimeNPObject::InvokeResult LibvlcMessageIteratorNPObject::getProperty(int index, NPVariant &result)
\r
827 /* is plugin still running */
\r
828 if( _instance->pdata )
\r
830 VlcPlugin* p_plugin = reinterpret_cast<VlcPlugin*>(_instance->pdata);
\r
833 case ID_messageiterator_hasNext:
\r
835 if( _p_iter && p_plugin->getLog() )
\r
837 libvlc_exception_t ex;
\r
838 libvlc_exception_init(&ex);
\r
840 BOOLEAN_TO_NPVARIANT(libvlc_log_iterator_has_next(_p_iter, &ex), result);
\r
841 if( libvlc_exception_raised(&ex) )
\r
843 NPN_SetException(this, libvlc_exception_get_message(&ex));
\r
844 libvlc_exception_clear(&ex);
\r
845 return INVOKERESULT_GENERIC_ERROR;
\r
850 BOOLEAN_TO_NPVARIANT(0, result);
\r
852 return INVOKERESULT_NO_ERROR;
\r
858 return INVOKERESULT_GENERIC_ERROR;
\r
861 const NPUTF8 * const LibvlcMessageIteratorNPObject::methodNames[] =
\r
866 const int LibvlcMessageIteratorNPObject::methodCount = sizeof(LibvlcMessageIteratorNPObject::methodNames)/sizeof(NPUTF8 *);
\r
868 enum LibvlcMessageIteratorNPObjectMethodIds
\r
870 ID_messageiterator_next,
\r
873 RuntimeNPObject::InvokeResult LibvlcMessageIteratorNPObject::invoke(int index, const NPVariant *args, uint32_t argCount, NPVariant &result)
\r
875 /* is plugin still running */
\r
876 if( _instance->pdata )
\r
878 VlcPlugin* p_plugin = reinterpret_cast<VlcPlugin*>(_instance->pdata);
\r
879 libvlc_exception_t ex;
\r
880 libvlc_exception_init(&ex);
\r
884 case ID_messageiterator_next:
\r
885 if( argCount == 0 )
\r
887 if( _p_iter && p_plugin->getLog() )
\r
889 struct libvlc_log_message_t buffer;
\r
891 buffer.sizeof_msg = sizeof(buffer);
\r
893 libvlc_log_iterator_next(_p_iter, &buffer, &ex);
\r
894 if( libvlc_exception_raised(&ex) )
\r
896 NPN_SetException(this, libvlc_exception_get_message(&ex));
\r
897 libvlc_exception_clear(&ex);
\r
898 return INVOKERESULT_GENERIC_ERROR;
\r
902 LibvlcMessageNPObject* message =
\r
903 static_cast<LibvlcMessageNPObject*>(NPN_CreateObject(_instance, RuntimeNPClass<LibvlcMessageNPObject>::getClass()));
\r
906 message->setMessage(buffer);
\r
907 OBJECT_TO_NPVARIANT(message, result);
\r
908 return INVOKERESULT_NO_ERROR;
\r
910 return INVOKERESULT_OUT_OF_MEMORY;
\r
913 return INVOKERESULT_GENERIC_ERROR;
\r
915 return INVOKERESULT_NO_SUCH_METHOD;
\r
920 return INVOKERESULT_GENERIC_ERROR;
\r
924 ** implementation of libvlc message object
\r
927 const NPUTF8 * const LibvlcMessagesNPObject::propertyNames[] =
\r
932 const int LibvlcMessagesNPObject::propertyCount = sizeof(LibvlcMessagesNPObject::propertyNames)/sizeof(NPUTF8 *);
\r
934 enum LibvlcMessagesNPObjectPropertyIds
\r
939 RuntimeNPObject::InvokeResult LibvlcMessagesNPObject::getProperty(int index, NPVariant &result)
\r
941 /* is plugin still running */
\r
942 if( _instance->pdata )
\r
944 VlcPlugin* p_plugin = reinterpret_cast<VlcPlugin*>(_instance->pdata);
\r
947 case ID_messages_count:
\r
949 libvlc_log_t *p_log = p_plugin->getLog();
\r
952 libvlc_exception_t ex;
\r
953 libvlc_exception_init(&ex);
\r
955 INT32_TO_NPVARIANT(libvlc_log_count(p_log, &ex), result);
\r
956 if( libvlc_exception_raised(&ex) )
\r
958 NPN_SetException(this, libvlc_exception_get_message(&ex));
\r
959 libvlc_exception_clear(&ex);
\r
960 return INVOKERESULT_GENERIC_ERROR;
\r
965 INT32_TO_NPVARIANT(0, result);
\r
967 return INVOKERESULT_NO_ERROR;
\r
973 return INVOKERESULT_GENERIC_ERROR;
\r
976 const NPUTF8 * const LibvlcMessagesNPObject::methodNames[] =
\r
982 const int LibvlcMessagesNPObject::methodCount = sizeof(LibvlcMessagesNPObject::methodNames)/sizeof(NPUTF8 *);
\r
984 enum LibvlcMessagesNPObjectMethodIds
\r
987 ID_messages_iterator,
\r
990 RuntimeNPObject::InvokeResult LibvlcMessagesNPObject::invoke(int index, const NPVariant *args, uint32_t argCount, NPVariant &result)
\r
992 /* is plugin still running */
\r
993 if( _instance->pdata )
\r
995 VlcPlugin* p_plugin = reinterpret_cast<VlcPlugin*>(_instance->pdata);
\r
996 libvlc_exception_t ex;
\r
997 libvlc_exception_init(&ex);
\r
1001 case ID_messages_clear:
\r
1002 if( argCount == 0 )
\r
1004 libvlc_log_t *p_log = p_plugin->getLog();
\r
1007 libvlc_log_clear(p_log, &ex);
\r
1008 if( libvlc_exception_raised(&ex) )
\r
1010 NPN_SetException(this, libvlc_exception_get_message(&ex));
\r
1011 libvlc_exception_clear(&ex);
\r
1012 return INVOKERESULT_GENERIC_ERROR;
\r
1015 return INVOKERESULT_NO_ERROR;
\r
1017 return INVOKERESULT_NO_SUCH_METHOD;
\r
1019 case ID_messages_iterator:
\r
1020 if( argCount == 0 )
\r
1022 LibvlcMessageIteratorNPObject* iter =
\r
1023 static_cast<LibvlcMessageIteratorNPObject*>(NPN_CreateObject(_instance, RuntimeNPClass<LibvlcMessageIteratorNPObject>::getClass()));
\r
1026 OBJECT_TO_NPVARIANT(iter, result);
\r
1027 return INVOKERESULT_NO_ERROR;
\r
1029 return INVOKERESULT_OUT_OF_MEMORY;
\r
1031 return INVOKERESULT_NO_SUCH_METHOD;
\r
1037 return INVOKERESULT_GENERIC_ERROR;
\r
1042 ** implementation of libvlc message object
\r
1046 LibvlcLogNPObject::~LibvlcLogNPObject()
\r
1050 if( messagesObj ) NPN_ReleaseObject(messagesObj);
\r
1054 const NPUTF8 * const LibvlcLogNPObject::propertyNames[] =
\r
1060 const int LibvlcLogNPObject::propertyCount = sizeof(LibvlcLogNPObject::propertyNames)/sizeof(NPUTF8 *);
\r
1062 enum LibvlcLogNPObjectPropertyIds
\r
1068 RuntimeNPObject::InvokeResult LibvlcLogNPObject::getProperty(int index, NPVariant &result)
\r
1070 /* is plugin still running */
\r
1071 if( _instance->pdata )
\r
1073 VlcPlugin* p_plugin = reinterpret_cast<VlcPlugin*>(_instance->pdata);
\r
1074 libvlc_exception_t ex;
\r
1075 libvlc_exception_init(&ex);
\r
1079 case ID_log_messages:
\r
1081 // create child object in lazyman fashion to avoid ownership problem with firefox
\r
1082 if( ! messagesObj )
\r
1083 messagesObj = NPN_CreateObject(_instance, RuntimeNPClass<LibvlcMessagesNPObject>::getClass());
\r
1084 OBJECT_TO_NPVARIANT(NPN_RetainObject(messagesObj), result);
\r
1085 return INVOKERESULT_NO_ERROR;
\r
1087 case ID_log_verbosity:
\r
1089 if( p_plugin->getLog() )
\r
1091 INT32_TO_NPVARIANT(libvlc_get_log_verbosity(p_plugin->getVLC(),
\r
1093 if( libvlc_exception_raised(&ex) )
\r
1095 NPN_SetException(this, libvlc_exception_get_message(&ex));
\r
1096 libvlc_exception_clear(&ex);
\r
1097 return INVOKERESULT_GENERIC_ERROR;
\r
1102 /* log is not enabled, return -1 */
\r
1103 DOUBLE_TO_NPVARIANT(-1.0, result);
\r
1105 return INVOKERESULT_NO_ERROR;
\r
1111 return INVOKERESULT_GENERIC_ERROR;
\r
1114 RuntimeNPObject::InvokeResult LibvlcLogNPObject::setProperty(int index, const NPVariant &value)
\r
1116 /* is plugin still running */
\r
1117 if( _instance->pdata )
\r
1119 VlcPlugin* p_plugin = reinterpret_cast<VlcPlugin*>(_instance->pdata);
\r
1120 libvlc_exception_t ex;
\r
1121 libvlc_exception_init(&ex);
\r
1125 case ID_log_verbosity:
\r
1126 if( isNumberValue(value) )
\r
1128 libvlc_instance_t* p_libvlc = p_plugin->getVLC();
\r
1129 libvlc_log_t *p_log = p_plugin->getLog();
\r
1130 int verbosity = numberValue(value);
\r
1131 if( verbosity >= 0 )
\r
1135 p_log = libvlc_log_open(p_libvlc, &ex);
\r
1136 if( libvlc_exception_raised(&ex) )
\r
1138 NPN_SetException(this, libvlc_exception_get_message(&ex));
\r
1139 libvlc_exception_clear(&ex);
\r
1140 return INVOKERESULT_GENERIC_ERROR;
\r
1142 p_plugin->setLog(p_log);
\r
1144 libvlc_set_log_verbosity(p_libvlc, (unsigned)verbosity, &ex);
\r
1145 if( libvlc_exception_raised(&ex) )
\r
1147 NPN_SetException(this, libvlc_exception_get_message(&ex));
\r
1148 libvlc_exception_clear(&ex);
\r
1149 return INVOKERESULT_GENERIC_ERROR;
\r
1154 /* close log when verbosity is set to -1 */
\r
1155 p_plugin->setLog(NULL);
\r
1156 libvlc_log_close(p_log, &ex);
\r
1157 if( libvlc_exception_raised(&ex) )
\r
1159 NPN_SetException(this, libvlc_exception_get_message(&ex));
\r
1160 libvlc_exception_clear(&ex);
\r
1161 return INVOKERESULT_GENERIC_ERROR;
\r
1164 return INVOKERESULT_NO_ERROR;
\r
1166 return INVOKERESULT_INVALID_VALUE;
\r
1171 return INVOKERESULT_GENERIC_ERROR;
\r
1174 const NPUTF8 * const LibvlcLogNPObject::methodNames[] =
\r
1179 const int LibvlcLogNPObject::methodCount = sizeof(LibvlcLogNPObject::methodNames)/sizeof(NPUTF8 *);
\r
1182 ** implementation of libvlc playlist items object
\r
1185 const NPUTF8 * const LibvlcPlaylistItemsNPObject::propertyNames[] =
\r
1190 const int LibvlcPlaylistItemsNPObject::propertyCount = sizeof(LibvlcPlaylistItemsNPObject::propertyNames)/sizeof(NPUTF8 *);
\r
1192 enum LibvlcPlaylistItemsNPObjectPropertyIds
\r
1194 ID_playlistitems_count,
\r
1197 RuntimeNPObject::InvokeResult LibvlcPlaylistItemsNPObject::getProperty(int index, NPVariant &result)
\r
1199 /* is plugin still running */
\r
1200 if( _instance->pdata )
\r
1202 VlcPlugin* p_plugin = reinterpret_cast<VlcPlugin*>(_instance->pdata);
\r
1203 libvlc_exception_t ex;
\r
1204 libvlc_exception_init(&ex);
\r
1208 case ID_playlistitems_count:
\r
1210 int val = libvlc_playlist_items_count(p_plugin->getVLC(), &ex);
\r
1211 if( libvlc_exception_raised(&ex) )
\r
1213 NPN_SetException(this, libvlc_exception_get_message(&ex));
\r
1214 libvlc_exception_clear(&ex);
\r
1215 return INVOKERESULT_GENERIC_ERROR;
\r
1217 INT32_TO_NPVARIANT(val, result);
\r
1218 return INVOKERESULT_NO_ERROR;
\r
1224 return INVOKERESULT_GENERIC_ERROR;
\r
1227 const NPUTF8 * const LibvlcPlaylistItemsNPObject::methodNames[] =
\r
1233 const int LibvlcPlaylistItemsNPObject::methodCount = sizeof(LibvlcPlaylistItemsNPObject::methodNames)/sizeof(NPUTF8 *);
\r
1235 enum LibvlcPlaylistItemsNPObjectMethodIds
\r
1237 ID_playlistitems_clear,
\r
1238 ID_playlistitems_remove,
\r
1241 RuntimeNPObject::InvokeResult LibvlcPlaylistItemsNPObject::invoke(int index, const NPVariant *args, uint32_t argCount, NPVariant &result)
\r
1243 /* is plugin still running */
\r
1244 if( _instance->pdata )
\r
1246 VlcPlugin* p_plugin = reinterpret_cast<VlcPlugin*>(_instance->pdata);
\r
1247 libvlc_exception_t ex;
\r
1248 libvlc_exception_init(&ex);
\r
1252 case ID_playlistitems_clear:
\r
1253 if( argCount == 0 )
\r
1255 libvlc_playlist_clear(p_plugin->getVLC(), &ex);
\r
1256 if( libvlc_exception_raised(&ex) )
\r
1258 NPN_SetException(this, libvlc_exception_get_message(&ex));
\r
1259 libvlc_exception_clear(&ex);
\r
1260 return INVOKERESULT_GENERIC_ERROR;
\r
1264 VOID_TO_NPVARIANT(result);
\r
1265 return INVOKERESULT_NO_ERROR;
\r
1268 return INVOKERESULT_NO_SUCH_METHOD;
\r
1269 case ID_playlistitems_remove:
\r
1270 if( (argCount == 1) && isNumberValue(args[0]) )
\r
1272 libvlc_playlist_delete_item(p_plugin->getVLC(), numberValue(args[0]), &ex);
\r
1273 if( libvlc_exception_raised(&ex) )
\r
1275 NPN_SetException(this, libvlc_exception_get_message(&ex));
\r
1276 libvlc_exception_clear(&ex);
\r
1277 return INVOKERESULT_GENERIC_ERROR;
\r
1281 VOID_TO_NPVARIANT(result);
\r
1282 return INVOKERESULT_NO_ERROR;
\r
1285 return INVOKERESULT_NO_SUCH_METHOD;
\r
1290 return INVOKERESULT_GENERIC_ERROR;
\r
1294 ** implementation of libvlc playlist object
\r
1298 LibvlcPlaylistNPObject::~LibvlcPlaylistNPObject()
\r
1302 if( playlistItemsObj ) NPN_ReleaseObject(playlistItemsObj);
\r
1306 const NPUTF8 * const LibvlcPlaylistNPObject::propertyNames[] =
\r
1308 "itemCount", /* deprecated */
\r
1313 const int LibvlcPlaylistNPObject::propertyCount = sizeof(LibvlcPlaylistNPObject::propertyNames)/sizeof(NPUTF8 *);
\r
1315 enum LibvlcPlaylistNPObjectPropertyIds
\r
1317 ID_playlist_itemcount,
\r
1318 ID_playlist_isplaying,
\r
1319 ID_playlist_items,
\r
1322 RuntimeNPObject::InvokeResult LibvlcPlaylistNPObject::getProperty(int index, NPVariant &result)
\r
1324 /* is plugin still running */
\r
1325 if( _instance->pdata )
\r
1327 VlcPlugin* p_plugin = reinterpret_cast<VlcPlugin*>(_instance->pdata);
\r
1328 libvlc_exception_t ex;
\r
1329 libvlc_exception_init(&ex);
\r
1333 case ID_playlist_itemcount: /* deprecated */
\r
1335 int val = libvlc_playlist_items_count(p_plugin->getVLC(), &ex);
\r
1336 if( libvlc_exception_raised(&ex) )
\r
1338 NPN_SetException(this, libvlc_exception_get_message(&ex));
\r
1339 libvlc_exception_clear(&ex);
\r
1340 return INVOKERESULT_GENERIC_ERROR;
\r
1342 INT32_TO_NPVARIANT(val, result);
\r
1343 return INVOKERESULT_NO_ERROR;
\r
1345 case ID_playlist_isplaying:
\r
1347 int val = libvlc_playlist_isplaying(p_plugin->getVLC(), &ex);
\r
1348 if( libvlc_exception_raised(&ex) )
\r
1350 NPN_SetException(this, libvlc_exception_get_message(&ex));
\r
1351 libvlc_exception_clear(&ex);
\r
1352 return INVOKERESULT_GENERIC_ERROR;
\r
1354 BOOLEAN_TO_NPVARIANT(val, result);
\r
1355 return INVOKERESULT_NO_ERROR;
\r
1357 case ID_playlist_items:
\r
1359 // create child object in lazyman fashion to avoid ownership problem with firefox
\r
1360 if( ! playlistItemsObj )
\r
1361 playlistItemsObj = NPN_CreateObject(_instance, RuntimeNPClass<LibvlcPlaylistItemsNPObject>::getClass());
\r
1362 OBJECT_TO_NPVARIANT(NPN_RetainObject(playlistItemsObj), result);
\r
1363 return INVOKERESULT_NO_ERROR;
\r
1369 return INVOKERESULT_GENERIC_ERROR;
\r
1372 const NPUTF8 * const LibvlcPlaylistNPObject::methodNames[] =
\r
1381 "clear", /* deprecated */
\r
1382 "removeItem", /* deprecated */
\r
1385 const int LibvlcPlaylistNPObject::methodCount = sizeof(LibvlcPlaylistNPObject::methodNames)/sizeof(NPUTF8 *);
\r
1387 enum LibvlcPlaylistNPObjectMethodIds
\r
1391 ID_playlist_playItem,
\r
1392 ID_playlist_togglepause,
\r
1396 ID_playlist_clear,
\r
1397 ID_playlist_removeitem
\r
1400 RuntimeNPObject::InvokeResult LibvlcPlaylistNPObject::invoke(int index, const NPVariant *args, uint32_t argCount, NPVariant &result)
\r
1402 /* is plugin still running */
\r
1403 if( _instance->pdata )
\r
1405 VlcPlugin* p_plugin = reinterpret_cast<VlcPlugin*>(_instance->pdata);
\r
1406 libvlc_exception_t ex;
\r
1407 libvlc_exception_init(&ex);
\r
1411 case ID_playlist_add:
\r
1413 if( (argCount < 1) || (argCount > 3) )
\r
1414 return INVOKERESULT_NO_SUCH_METHOD;
\r
1419 if( NPVARIANT_IS_STRING(args[0]) )
\r
1421 char *s = stringValue(NPVARIANT_TO_STRING(args[0]));
\r
1424 url = p_plugin->getAbsoluteURL(s);
\r
1428 // problem with combining url, use argument
\r
1432 return INVOKERESULT_OUT_OF_MEMORY;
\r
1435 return INVOKERESULT_NO_SUCH_METHOD;
\r
1437 char *name = NULL;
\r
1439 // grab name if available
\r
1440 if( argCount > 1 )
\r
1442 if( NPVARIANT_IS_NULL(args[1]) )
\r
1446 else if( NPVARIANT_IS_STRING(args[1]) )
\r
1448 name = stringValue(NPVARIANT_TO_STRING(args[1]));
\r
1453 return INVOKERESULT_INVALID_VALUE;
\r
1457 int i_options = 0;
\r
1458 char** ppsz_options = NULL;
\r
1460 // grab options if available
\r
1461 if( argCount > 2 )
\r
1463 if( NPVARIANT_IS_NULL(args[2]) )
\r
1467 else if( NPVARIANT_IS_STRING(args[2]) )
\r
1469 parseOptions(NPVARIANT_TO_STRING(args[2]), &i_options, &ppsz_options);
\r
1472 else if( NPVARIANT_IS_OBJECT(args[2]) )
\r
1474 parseOptions(NPVARIANT_TO_OBJECT(args[2]), &i_options, &ppsz_options);
\r
1480 return INVOKERESULT_INVALID_VALUE;
\r
1484 int item = libvlc_playlist_add_extended(p_plugin->getVLC(),
\r
1488 const_cast<const char **>(ppsz_options),
\r
1492 for( int i=0; i< i_options; ++i )
\r
1494 delete ppsz_options[i];
\r
1496 delete ppsz_options;
\r
1498 if( libvlc_exception_raised(&ex) )
\r
1500 NPN_SetException(this, libvlc_exception_get_message(&ex));
\r
1501 libvlc_exception_clear(&ex);
\r
1502 return INVOKERESULT_GENERIC_ERROR;
\r
1506 INT32_TO_NPVARIANT(item, result);
\r
1507 return INVOKERESULT_NO_ERROR;
\r
1510 case ID_playlist_play:
\r
1511 if( argCount == 0 )
\r
1513 libvlc_playlist_play(p_plugin->getVLC(), -1, 0, NULL, &ex);
\r
1514 if( libvlc_exception_raised(&ex) )
\r
1516 NPN_SetException(this, libvlc_exception_get_message(&ex));
\r
1517 libvlc_exception_clear(&ex);
\r
1518 return INVOKERESULT_GENERIC_ERROR;
\r
1522 VOID_TO_NPVARIANT(result);
\r
1523 return INVOKERESULT_NO_ERROR;
\r
1526 return INVOKERESULT_NO_SUCH_METHOD;
\r
1527 case ID_playlist_playItem:
\r
1528 if( (argCount == 1) && isNumberValue(args[0]) )
\r
1530 libvlc_playlist_play(p_plugin->getVLC(), numberValue(args[0]), 0, NULL, &ex);
\r
1531 if( libvlc_exception_raised(&ex) )
\r
1533 NPN_SetException(this, libvlc_exception_get_message(&ex));
\r
1534 libvlc_exception_clear(&ex);
\r
1535 return INVOKERESULT_GENERIC_ERROR;
\r
1539 VOID_TO_NPVARIANT(result);
\r
1540 return INVOKERESULT_NO_ERROR;
\r
1543 return INVOKERESULT_NO_SUCH_METHOD;
\r
1544 case ID_playlist_togglepause:
\r
1545 if( argCount == 0 )
\r
1547 libvlc_playlist_pause(p_plugin->getVLC(), &ex);
\r
1548 if( libvlc_exception_raised(&ex) )
\r
1550 NPN_SetException(this, libvlc_exception_get_message(&ex));
\r
1551 libvlc_exception_clear(&ex);
\r
1552 return INVOKERESULT_GENERIC_ERROR;
\r
1556 VOID_TO_NPVARIANT(result);
\r
1557 return INVOKERESULT_NO_ERROR;
\r
1560 return INVOKERESULT_NO_SUCH_METHOD;
\r
1561 case ID_playlist_stop:
\r
1562 if( argCount == 0 )
\r
1564 libvlc_playlist_stop(p_plugin->getVLC(), &ex);
\r
1565 if( libvlc_exception_raised(&ex) )
\r
1567 NPN_SetException(this, libvlc_exception_get_message(&ex));
\r
1568 libvlc_exception_clear(&ex);
\r
1569 return INVOKERESULT_GENERIC_ERROR;
\r
1573 VOID_TO_NPVARIANT(result);
\r
1574 return INVOKERESULT_NO_ERROR;
\r
1577 return INVOKERESULT_NO_SUCH_METHOD;
\r
1578 case ID_playlist_next:
\r
1579 if( argCount == 0 )
\r
1581 libvlc_playlist_next(p_plugin->getVLC(), &ex);
\r
1582 if( libvlc_exception_raised(&ex) )
\r
1584 NPN_SetException(this, libvlc_exception_get_message(&ex));
\r
1585 libvlc_exception_clear(&ex);
\r
1586 return INVOKERESULT_GENERIC_ERROR;
\r
1590 VOID_TO_NPVARIANT(result);
\r
1591 return INVOKERESULT_NO_ERROR;
\r
1594 return INVOKERESULT_NO_SUCH_METHOD;
\r
1595 case ID_playlist_prev:
\r
1596 if( argCount == 0 )
\r
1598 libvlc_playlist_prev(p_plugin->getVLC(), &ex);
\r
1599 if( libvlc_exception_raised(&ex) )
\r
1601 NPN_SetException(this, libvlc_exception_get_message(&ex));
\r
1602 libvlc_exception_clear(&ex);
\r
1603 return INVOKERESULT_GENERIC_ERROR;
\r
1607 VOID_TO_NPVARIANT(result);
\r
1608 return INVOKERESULT_NO_ERROR;
\r
1611 return INVOKERESULT_NO_SUCH_METHOD;
\r
1612 case ID_playlist_clear: /* deprecated */
\r
1613 if( argCount == 0 )
\r
1615 libvlc_playlist_clear(p_plugin->getVLC(), &ex);
\r
1616 if( libvlc_exception_raised(&ex) )
\r
1618 NPN_SetException(this, libvlc_exception_get_message(&ex));
\r
1619 libvlc_exception_clear(&ex);
\r
1620 return INVOKERESULT_GENERIC_ERROR;
\r
1624 VOID_TO_NPVARIANT(result);
\r
1625 return INVOKERESULT_NO_ERROR;
\r
1628 return INVOKERESULT_NO_SUCH_METHOD;
\r
1629 case ID_playlist_removeitem: /* deprecated */
\r
1630 if( (argCount == 1) && isNumberValue(args[0]) )
\r
1632 libvlc_playlist_delete_item(p_plugin->getVLC(), numberValue(args[0]), &ex);
\r
1633 if( libvlc_exception_raised(&ex) )
\r
1635 NPN_SetException(this, libvlc_exception_get_message(&ex));
\r
1636 libvlc_exception_clear(&ex);
\r
1637 return INVOKERESULT_GENERIC_ERROR;
\r
1641 VOID_TO_NPVARIANT(result);
\r
1642 return INVOKERESULT_NO_ERROR;
\r
1645 return INVOKERESULT_NO_SUCH_METHOD;
\r
1650 return INVOKERESULT_GENERIC_ERROR;
\r
1653 void LibvlcPlaylistNPObject::parseOptions(const NPString &nps, int *i_options, char*** ppsz_options)
\r
1655 if( nps.utf8length )
\r
1657 char *s = stringValue(nps);
\r
1661 long capacity = 16;
\r
1662 char **options = (char **)malloc(capacity*sizeof(char *));
\r
1667 char *end = val + nps.utf8length;
\r
1668 while( val < end )
\r
1670 // skip leading blanks
\r
1671 while( (val < end)
\r
1672 && ((*val == ' ' ) || (*val == '\t')) )
\r
1675 char *start = val;
\r
1676 // skip till we get a blank character
\r
1677 while( (val < end)
\r
1679 && (*val != '\t') )
\r
1681 char c = *(val++);
\r
1682 if( ('\'' == c) || ('"' == c) )
\r
1684 // skip till end of string
\r
1685 while( (val < end) && (*(val++) != c ) );
\r
1691 if( nOptions == capacity )
\r
1694 char **moreOptions = (char **)realloc(options, capacity*sizeof(char*));
\r
1695 if( ! moreOptions )
\r
1697 /* failed to allocate more memory */
\r
1699 /* return what we got so far */
\r
1700 *i_options = nOptions;
\r
1701 *ppsz_options = options;
\r
1704 options = moreOptions;
\r
1707 options[nOptions++] = strdup(start);
\r
1710 // must be end of string
\r
1713 *i_options = nOptions;
\r
1714 *ppsz_options = options;
\r
1721 void LibvlcPlaylistNPObject::parseOptions(NPObject *obj, int *i_options, char*** ppsz_options)
\r
1723 /* WARNING: Safari does not implement NPN_HasProperty/NPN_HasMethod */
\r
1727 /* we are expecting to have a Javascript Array object */
\r
1728 NPIdentifier propId = NPN_GetStringIdentifier("length");
\r
1729 if( NPN_GetProperty(_instance, obj, propId, &value) )
\r
1731 int count = numberValue(value);
\r
1732 NPN_ReleaseVariantValue(&value);
\r
1736 long capacity = 16;
\r
1737 char **options = (char **)malloc(capacity*sizeof(char *));
\r
1742 while( nOptions < count )
\r
1744 propId = NPN_GetIntIdentifier(nOptions);
\r
1745 if( ! NPN_GetProperty(_instance, obj, propId, &value) )
\r
1746 /* return what we got so far */
\r
1749 if( ! NPVARIANT_IS_STRING(value) )
\r
1751 /* return what we got so far */
\r
1752 NPN_ReleaseVariantValue(&value);
\r
1756 if( nOptions == capacity )
\r
1759 char **moreOptions = (char **)realloc(options, capacity*sizeof(char*));
\r
1760 if( ! moreOptions )
\r
1762 /* failed to allocate more memory */
\r
1763 NPN_ReleaseVariantValue(&value);
\r
1764 /* return what we got so far */
\r
1765 *i_options = nOptions;
\r
1766 *ppsz_options = options;
\r
1769 options = moreOptions;
\r
1772 options[nOptions++] = stringValue(value);
\r
1774 *i_options = nOptions;
\r
1775 *ppsz_options = options;
\r
1782 ** implementation of libvlc video object
\r
1785 const NPUTF8 * const LibvlcVideoNPObject::propertyNames[] =
\r
1796 enum LibvlcVideoNPObjectPropertyIds
\r
1798 ID_video_fullscreen,
\r
1801 ID_video_aspectratio,
\r
1802 ID_video_subtitle,
\r
1807 const int LibvlcVideoNPObject::propertyCount = sizeof(LibvlcVideoNPObject::propertyNames)/sizeof(NPUTF8 *);
\r
1809 RuntimeNPObject::InvokeResult LibvlcVideoNPObject::getProperty(int index, NPVariant &result)
\r
1811 /* is plugin still running */
\r
1812 if( _instance->pdata )
\r
1814 VlcPlugin* p_plugin = reinterpret_cast<VlcPlugin*>(_instance->pdata);
\r
1815 libvlc_exception_t ex;
\r
1816 libvlc_exception_init(&ex);
\r
1818 libvlc_media_player_t *p_md = libvlc_playlist_get_media_player(p_plugin->getVLC(), &ex);
\r
1819 if( libvlc_exception_raised(&ex) )
\r
1821 NPN_SetException(this, libvlc_exception_get_message(&ex));
\r
1822 libvlc_exception_clear(&ex);
\r
1823 return INVOKERESULT_GENERIC_ERROR;
\r
1828 case ID_video_fullscreen:
\r
1830 int val = libvlc_get_fullscreen(p_md, &ex);
\r
1831 libvlc_media_player_release(p_md);
\r
1832 if( libvlc_exception_raised(&ex) )
\r
1834 NPN_SetException(this, libvlc_exception_get_message(&ex));
\r
1835 libvlc_exception_clear(&ex);
\r
1836 return INVOKERESULT_GENERIC_ERROR;
\r
1838 BOOLEAN_TO_NPVARIANT(val, result);
\r
1839 return INVOKERESULT_NO_ERROR;
\r
1841 case ID_video_height:
\r
1843 int val = libvlc_video_get_height(p_md, &ex);
\r
1844 libvlc_media_player_release(p_md);
\r
1845 if( libvlc_exception_raised(&ex) )
\r
1847 NPN_SetException(this, libvlc_exception_get_message(&ex));
\r
1848 libvlc_exception_clear(&ex);
\r
1849 return INVOKERESULT_GENERIC_ERROR;
\r
1851 INT32_TO_NPVARIANT(val, result);
\r
1852 return INVOKERESULT_NO_ERROR;
\r
1854 case ID_video_width:
\r
1856 int val = libvlc_video_get_width(p_md, &ex);
\r
1857 libvlc_media_player_release(p_md);
\r
1858 if( libvlc_exception_raised(&ex) )
\r
1860 NPN_SetException(this, libvlc_exception_get_message(&ex));
\r
1861 libvlc_exception_clear(&ex);
\r
1862 return INVOKERESULT_GENERIC_ERROR;
\r
1864 INT32_TO_NPVARIANT(val, result);
\r
1865 return INVOKERESULT_NO_ERROR;
\r
1867 case ID_video_aspectratio:
\r
1869 NPUTF8 *psz_aspect = libvlc_video_get_aspect_ratio(p_md, &ex);
\r
1870 libvlc_media_player_release(p_md);
\r
1871 if( libvlc_exception_raised(&ex) )
\r
1873 NPN_SetException(this, libvlc_exception_get_message(&ex));
\r
1874 libvlc_exception_clear(&ex);
\r
1875 return INVOKERESULT_GENERIC_ERROR;
\r
1878 return INVOKERESULT_GENERIC_ERROR;
\r
1880 STRINGZ_TO_NPVARIANT(psz_aspect, result);
\r
1881 return INVOKERESULT_NO_ERROR;
\r
1883 case ID_video_subtitle:
\r
1885 int i_spu = libvlc_video_get_spu(p_md, &ex);
\r
1886 libvlc_media_player_release(p_md);
\r
1887 if( libvlc_exception_raised(&ex) )
\r
1889 NPN_SetException(this, libvlc_exception_get_message(&ex));
\r
1890 libvlc_exception_clear(&ex);
\r
1891 return INVOKERESULT_GENERIC_ERROR;
\r
1893 INT32_TO_NPVARIANT(i_spu, result);
\r
1894 return INVOKERESULT_NO_ERROR;
\r
1896 case ID_video_crop:
\r
1898 NPUTF8 *psz_geometry = libvlc_video_get_crop_geometry(p_md, &ex);
\r
1899 libvlc_media_player_release(p_md);
\r
1900 if( libvlc_exception_raised(&ex) )
\r
1902 NPN_SetException(this, libvlc_exception_get_message(&ex));
\r
1903 libvlc_exception_clear(&ex);
\r
1904 return INVOKERESULT_GENERIC_ERROR;
\r
1906 if( !psz_geometry )
\r
1907 return INVOKERESULT_GENERIC_ERROR;
\r
1909 STRINGZ_TO_NPVARIANT(psz_geometry, result);
\r
1910 return INVOKERESULT_NO_ERROR;
\r
1912 case ID_video_teletext:
\r
1914 int i_page = libvlc_video_get_teletext(p_md, &ex);
\r
1915 libvlc_media_player_release(p_md);
\r
1916 if( libvlc_exception_raised(&ex) )
\r
1918 NPN_SetException(this, libvlc_exception_get_message(&ex));
\r
1919 libvlc_exception_clear(&ex);
\r
1920 return INVOKERESULT_GENERIC_ERROR;
\r
1922 INT32_TO_NPVARIANT(i_page, result);
\r
1923 return INVOKERESULT_NO_ERROR;
\r
1926 libvlc_media_player_release(p_md);
\r
1928 return INVOKERESULT_GENERIC_ERROR;
\r
1931 RuntimeNPObject::InvokeResult LibvlcVideoNPObject::setProperty(int index, const NPVariant &value)
\r
1933 /* is plugin still running */
\r
1934 if( _instance->pdata )
\r
1936 VlcPlugin* p_plugin = reinterpret_cast<VlcPlugin*>(_instance->pdata);
\r
1937 libvlc_exception_t ex;
\r
1938 libvlc_exception_init(&ex);
\r
1940 libvlc_media_player_t *p_md = libvlc_playlist_get_media_player(p_plugin->getVLC(), &ex);
\r
1941 if( libvlc_exception_raised(&ex) )
\r
1943 NPN_SetException(this, libvlc_exception_get_message(&ex));
\r
1944 libvlc_exception_clear(&ex);
\r
1945 return INVOKERESULT_GENERIC_ERROR;
\r
1950 case ID_video_fullscreen:
\r
1952 if( ! NPVARIANT_IS_BOOLEAN(value) )
\r
1954 libvlc_media_player_release(p_md);
\r
1955 return INVOKERESULT_INVALID_VALUE;
\r
1958 int val = NPVARIANT_TO_BOOLEAN(value);
\r
1959 libvlc_set_fullscreen(p_md, val, &ex);
\r
1960 libvlc_media_player_release(p_md);
\r
1962 if( libvlc_exception_raised(&ex) )
\r
1964 NPN_SetException(this, libvlc_exception_get_message(&ex));
\r
1965 libvlc_exception_clear(&ex);
\r
1966 return INVOKERESULT_GENERIC_ERROR;
\r
1968 return INVOKERESULT_NO_ERROR;
\r
1970 case ID_video_aspectratio:
\r
1972 char *psz_aspect = NULL;
\r
1974 if( ! NPVARIANT_IS_STRING(value) )
\r
1976 libvlc_media_player_release(p_md);
\r
1977 return INVOKERESULT_INVALID_VALUE;
\r
1980 psz_aspect = stringValue(NPVARIANT_TO_STRING(value));
\r
1983 libvlc_media_player_release(p_md);
\r
1984 return INVOKERESULT_GENERIC_ERROR;
\r
1987 libvlc_video_set_aspect_ratio(p_md, psz_aspect, &ex);
\r
1988 delete psz_aspect;
\r
1989 libvlc_media_player_release(p_md);
\r
1991 if( libvlc_exception_raised(&ex) )
\r
1993 NPN_SetException(this, libvlc_exception_get_message(&ex));
\r
1994 libvlc_exception_clear(&ex);
\r
1995 return INVOKERESULT_GENERIC_ERROR;
\r
1997 return INVOKERESULT_NO_ERROR;
\r
1999 case ID_video_subtitle:
\r
2001 if( isNumberValue(value) )
\r
2003 libvlc_video_set_spu(p_md,
\r
2004 numberValue(value), &ex);
\r
2005 libvlc_media_player_release(p_md);
\r
2006 if( libvlc_exception_raised(&ex) )
\r
2008 NPN_SetException(this, libvlc_exception_get_message(&ex));
\r
2009 libvlc_exception_clear(&ex);
\r
2010 return INVOKERESULT_GENERIC_ERROR;
\r
2012 return INVOKERESULT_NO_ERROR;
\r
2014 libvlc_media_player_release(p_md);
\r
2015 return INVOKERESULT_INVALID_VALUE;
\r
2017 case ID_video_crop:
\r
2019 char *psz_geometry = NULL;
\r
2021 if( ! NPVARIANT_IS_STRING(value) )
\r
2023 libvlc_media_player_release(p_md);
\r
2024 return INVOKERESULT_INVALID_VALUE;
\r
2027 psz_geometry = stringValue(NPVARIANT_TO_STRING(value));
\r
2028 if( !psz_geometry )
\r
2030 libvlc_media_player_release(p_md);
\r
2031 return INVOKERESULT_GENERIC_ERROR;
\r
2034 libvlc_video_set_crop_geometry(p_md, psz_geometry, &ex);
\r
2035 delete psz_geometry;
\r
2036 libvlc_media_player_release(p_md);
\r
2038 if( libvlc_exception_raised(&ex) )
\r
2040 NPN_SetException(this, libvlc_exception_get_message(&ex));
\r
2041 libvlc_exception_clear(&ex);
\r
2042 return INVOKERESULT_GENERIC_ERROR;
\r
2044 return INVOKERESULT_NO_ERROR;
\r
2046 case ID_video_teletext:
\r
2048 if( isNumberValue(value) )
\r
2050 libvlc_video_set_teletext(p_md,
\r
2051 numberValue(value), &ex);
\r
2052 libvlc_media_player_release(p_md);
\r
2053 if( libvlc_exception_raised(&ex) )
\r
2055 NPN_SetException(this, libvlc_exception_get_message(&ex));
\r
2056 libvlc_exception_clear(&ex);
\r
2057 return INVOKERESULT_GENERIC_ERROR;
\r
2059 return INVOKERESULT_NO_ERROR;
\r
2061 libvlc_media_player_release(p_md);
\r
2062 return INVOKERESULT_INVALID_VALUE;
\r
2065 libvlc_media_player_release(p_md);
\r
2067 return INVOKERESULT_GENERIC_ERROR;
\r
2070 const NPUTF8 * const LibvlcVideoNPObject::methodNames[] =
\r
2072 "toggleFullscreen",
\r
2076 enum LibvlcVideoNPObjectMethodIds
\r
2078 ID_video_togglefullscreen,
\r
2079 ID_video_toggleteletext
\r
2082 const int LibvlcVideoNPObject::methodCount = sizeof(LibvlcVideoNPObject::methodNames)/sizeof(NPUTF8 *);
\r
2084 RuntimeNPObject::InvokeResult LibvlcVideoNPObject::invoke(int index, const NPVariant *args, uint32_t argCount, NPVariant &result)
\r
2086 /* is plugin still running */
\r
2087 if( _instance->pdata )
\r
2089 VlcPlugin* p_plugin = reinterpret_cast<VlcPlugin*>(_instance->pdata);
\r
2090 libvlc_exception_t ex;
\r
2091 libvlc_exception_init(&ex);
\r
2093 libvlc_media_player_t *p_md = libvlc_playlist_get_media_player(p_plugin->getVLC(), &ex);
\r
2094 if( libvlc_exception_raised(&ex) )
\r
2096 NPN_SetException(this, libvlc_exception_get_message(&ex));
\r
2097 libvlc_exception_clear(&ex);
\r
2098 return INVOKERESULT_GENERIC_ERROR;
\r
2103 case ID_video_togglefullscreen:
\r
2104 if( argCount == 0 )
\r
2106 libvlc_toggle_fullscreen(p_md, &ex);
\r
2107 libvlc_media_player_release(p_md);
\r
2108 if( libvlc_exception_raised(&ex) )
\r
2110 NPN_SetException(this, libvlc_exception_get_message(&ex));
\r
2111 libvlc_exception_clear(&ex);
\r
2112 return INVOKERESULT_GENERIC_ERROR;
\r
2116 VOID_TO_NPVARIANT(result);
\r
2117 return INVOKERESULT_NO_ERROR;
\r
2122 /* cannot get md, probably not playing */
\r
2123 if( libvlc_exception_raised(&ex) )
\r
2125 NPN_SetException(this, libvlc_exception_get_message(&ex));
\r
2126 libvlc_exception_clear(&ex);
\r
2128 return INVOKERESULT_GENERIC_ERROR;
\r
2130 return INVOKERESULT_NO_SUCH_METHOD;
\r
2131 case ID_video_toggleteletext:
\r
2132 if( argCount == 0 )
\r
2134 libvlc_toggle_teletext(p_md, &ex);
\r
2135 libvlc_media_player_release(p_md);
\r
2136 if( libvlc_exception_raised(&ex) )
\r
2138 NPN_SetException(this, libvlc_exception_get_message(&ex));
\r
2139 libvlc_exception_clear(&ex);
\r
2140 return INVOKERESULT_GENERIC_ERROR;
\r
2144 VOID_TO_NPVARIANT(result);
\r
2145 return INVOKERESULT_NO_ERROR;
\r
2150 /* cannot get md, probably not playing */
\r
2151 if( libvlc_exception_raised(&ex) )
\r
2153 NPN_SetException(this, libvlc_exception_get_message(&ex));
\r
2154 libvlc_exception_clear(&ex);
\r
2156 return INVOKERESULT_GENERIC_ERROR;
\r
2158 return INVOKERESULT_NO_SUCH_METHOD;
\r
2160 return INVOKERESULT_NO_SUCH_METHOD;
\r
2163 return INVOKERESULT_GENERIC_ERROR;
\r