1 /*****************************************************************************
2 * npolibvlc.cpp: official Javascript APIs
3 *****************************************************************************
4 * Copyright (C) 2002-2009 the VideoLAN team
6 * Authors: Damien Fouilleul <Damien.Fouilleul@laposte.net>
7 * JP Dinger <jpd@m2x.nl>
9 * This program is free software; you can redistribute it and/or modify
10 * it under the terms of the GNU General Public License as published by
11 * the Free Software Foundation; either version 2 of the License, or
12 * (at your option) any later version.
14 * This program is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 * GNU General Public License for more details.
19 * You should have received a copy of the GNU General Public License
20 * along with this program; if not, write to the Free Software
21 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
22 *****************************************************************************/
31 #ifdef HAVE_MOZILLA_CONFIG_H
32 # include <mozilla-config.h>
35 #include "vlcplugin.h"
36 #include "npolibvlc.h"
39 ** Local helper macros and function
41 #define COUNTNAMES(a,b,c) const int a::b = sizeof(a::c)/sizeof(NPUTF8 *)
42 #define RETURN_ON_EXCEPTION(this,ex) \
43 do { if( libvlc_exception_raised(&ex) ) \
45 NPN_SetException(this, libvlc_exception_get_message(&ex)); \
46 libvlc_exception_clear(&ex); \
47 return INVOKERESULT_GENERIC_ERROR; \
51 ** implementation of libvlc root object
54 LibvlcRootNPObject::~LibvlcRootNPObject()
57 ** When the plugin is destroyed, firefox takes it upon itself to
58 ** destroy all 'live' script objects and ignores refcounting.
59 ** Therefore we cannot safely assume that refcounting will control
60 ** lifespan of objects. Hence they are only lazily created on
61 ** request, so that firefox can take ownership, and are not released
62 ** when the plugin is destroyed.
66 if( audioObj ) NPN_ReleaseObject(audioObj);
67 if( inputObj ) NPN_ReleaseObject(inputObj);
68 if( playlistObj ) NPN_ReleaseObject(playlistObj);
69 if( videoObj ) NPN_ReleaseObject(videoObj);
73 const NPUTF8 * const LibvlcRootNPObject::propertyNames[] =
82 COUNTNAMES(LibvlcRootNPObject,propertyCount,propertyNames);
84 enum LibvlcRootNPObjectPropertyIds
94 RuntimeNPObject::InvokeResult
95 LibvlcRootNPObject::getProperty(int index, NPVariant &result)
97 /* is plugin still running */
98 if( isPluginRunning() )
103 // create child object in lazyman fashion to avoid
104 // ownership problem with firefox
106 audioObj = NPN_CreateObject(_instance,
107 RuntimeNPClass<LibvlcAudioNPObject>::getClass());
108 OBJECT_TO_NPVARIANT(NPN_RetainObject(audioObj), result);
109 return INVOKERESULT_NO_ERROR;
111 // create child object in lazyman fashion to avoid
112 // ownership problem with firefox
114 inputObj = NPN_CreateObject(_instance,
115 RuntimeNPClass<LibvlcInputNPObject>::getClass());
116 OBJECT_TO_NPVARIANT(NPN_RetainObject(inputObj), result);
117 return INVOKERESULT_NO_ERROR;
118 case ID_root_playlist:
119 // create child object in lazyman fashion to avoid
120 // ownership problem with firefox
122 playlistObj = NPN_CreateObject(_instance,
123 RuntimeNPClass<LibvlcPlaylistNPObject>::getClass());
124 OBJECT_TO_NPVARIANT(NPN_RetainObject(playlistObj), result);
125 return INVOKERESULT_NO_ERROR;
126 case ID_root_subtitle:
127 // create child object in lazyman fashion to avoid
128 // ownership problem with firefox
130 subtitleObj = NPN_CreateObject(_instance,
131 RuntimeNPClass<LibvlcSubtitleNPObject>::getClass());
132 OBJECT_TO_NPVARIANT(NPN_RetainObject(subtitleObj), result);
133 return INVOKERESULT_NO_ERROR;
135 // create child object in lazyman fashion to avoid
136 // ownership problem with firefox
138 videoObj = NPN_CreateObject(_instance,
139 RuntimeNPClass<LibvlcVideoNPObject>::getClass());
140 OBJECT_TO_NPVARIANT(NPN_RetainObject(videoObj), result);
141 return INVOKERESULT_NO_ERROR;
142 case ID_root_VersionInfo:
143 return invokeResultString(libvlc_get_version(),result);
148 return INVOKERESULT_GENERIC_ERROR;
151 const NPUTF8 * const LibvlcRootNPObject::methodNames[] =
155 COUNTNAMES(LibvlcRootNPObject,methodCount,methodNames);
157 enum LibvlcRootNPObjectMethodIds
162 RuntimeNPObject::InvokeResult LibvlcRootNPObject::invoke(int index,
163 const NPVariant *args, uint32_t argCount, NPVariant &result)
165 /* is plugin still running */
166 if( isPluginRunning() )
168 libvlc_exception_t ex;
169 libvlc_exception_init(&ex);
173 case ID_root_versionInfo:
175 return INVOKERESULT_NO_SUCH_METHOD;
176 return invokeResultString(libvlc_get_version(),result);
181 return INVOKERESULT_GENERIC_ERROR;
185 ** implementation of libvlc audio object
188 const NPUTF8 * const LibvlcAudioNPObject::propertyNames[] =
196 COUNTNAMES(LibvlcAudioNPObject,propertyCount,propertyNames);
198 enum LibvlcAudioNPObjectPropertyIds
207 RuntimeNPObject::InvokeResult
208 LibvlcAudioNPObject::getProperty(int index, NPVariant &result)
210 /* is plugin still running */
211 if( isPluginRunning() )
213 VlcPlugin* p_plugin = getPrivate<VlcPlugin>();
214 libvlc_exception_t ex;
215 libvlc_exception_init(&ex);
221 bool muted = libvlc_audio_get_mute(p_plugin->getVLC(), &ex);
222 RETURN_ON_EXCEPTION(this,ex);
223 BOOLEAN_TO_NPVARIANT(muted, result);
224 return INVOKERESULT_NO_ERROR;
226 case ID_audio_volume:
228 int volume = libvlc_audio_get_volume(p_plugin->getVLC(), &ex);
229 RETURN_ON_EXCEPTION(this,ex);
230 INT32_TO_NPVARIANT(volume, result);
231 return INVOKERESULT_NO_ERROR;
235 libvlc_media_player_t *p_md = p_plugin->getMD(&ex);
236 RETURN_ON_EXCEPTION(this,ex);
237 int track = libvlc_audio_get_track(p_md, &ex);
238 RETURN_ON_EXCEPTION(this,ex);
239 INT32_TO_NPVARIANT(track, result);
240 return INVOKERESULT_NO_ERROR;
244 libvlc_media_player_t *p_md = p_plugin->getMD(&ex);
245 RETURN_ON_EXCEPTION(this,ex);
246 // get the number of audio track available
247 int i_track = libvlc_audio_get_track_count(p_md, &ex);
248 RETURN_ON_EXCEPTION(this,ex);
250 INT32_TO_NPVARIANT(i_track, result);
251 return INVOKERESULT_NO_ERROR;
253 case ID_audio_channel:
255 int channel = libvlc_audio_get_channel(p_plugin->getVLC(), &ex);
256 RETURN_ON_EXCEPTION(this,ex);
257 INT32_TO_NPVARIANT(channel, result);
258 return INVOKERESULT_NO_ERROR;
264 return INVOKERESULT_GENERIC_ERROR;
267 RuntimeNPObject::InvokeResult
268 LibvlcAudioNPObject::setProperty(int index, const NPVariant &value)
270 /* is plugin still running */
271 if( isPluginRunning() )
273 VlcPlugin* p_plugin = getPrivate<VlcPlugin>();
274 libvlc_exception_t ex;
275 libvlc_exception_init(&ex);
280 if( NPVARIANT_IS_BOOLEAN(value) )
282 libvlc_audio_set_mute(p_plugin->getVLC(),
283 NPVARIANT_TO_BOOLEAN(value), &ex);
284 RETURN_ON_EXCEPTION(this,ex);
285 return INVOKERESULT_NO_ERROR;
287 return INVOKERESULT_INVALID_VALUE;
288 case ID_audio_volume:
289 if( isNumberValue(value) )
291 libvlc_audio_set_volume(p_plugin->getVLC(),
292 numberValue(value), &ex);
293 RETURN_ON_EXCEPTION(this,ex);
294 return INVOKERESULT_NO_ERROR;
296 return INVOKERESULT_INVALID_VALUE;
298 if( isNumberValue(value) )
300 libvlc_media_player_t *p_md = p_plugin->getMD(&ex);
301 RETURN_ON_EXCEPTION(this,ex);
302 libvlc_audio_set_track(p_md, numberValue(value), &ex);
303 RETURN_ON_EXCEPTION(this,ex);
304 return INVOKERESULT_NO_ERROR;
306 return INVOKERESULT_INVALID_VALUE;
307 case ID_audio_channel:
308 if( isNumberValue(value) )
310 libvlc_audio_set_channel(p_plugin->getVLC(),
311 numberValue(value), &ex);
312 RETURN_ON_EXCEPTION(this,ex);
313 return INVOKERESULT_NO_ERROR;
315 return INVOKERESULT_INVALID_VALUE;
320 return INVOKERESULT_GENERIC_ERROR;
323 const NPUTF8 * const LibvlcAudioNPObject::methodNames[] =
328 COUNTNAMES(LibvlcAudioNPObject,methodCount,methodNames);
330 enum LibvlcAudioNPObjectMethodIds
333 ID_audio_description,
336 RuntimeNPObject::InvokeResult
337 LibvlcAudioNPObject::invoke(int index, const NPVariant *args,
338 uint32_t argCount, NPVariant &result)
340 /* is plugin still running */
341 if( isPluginRunning() )
343 VlcPlugin* p_plugin = getPrivate<VlcPlugin>();
344 libvlc_exception_t ex;
345 libvlc_exception_init(&ex);
349 case ID_audio_togglemute:
352 libvlc_audio_toggle_mute(p_plugin->getVLC(), &ex);
353 RETURN_ON_EXCEPTION(this,ex);
354 VOID_TO_NPVARIANT(result);
355 return INVOKERESULT_NO_ERROR;
357 return INVOKERESULT_NO_SUCH_METHOD;
358 case ID_audio_description:
363 int i_trackID, i_limit, i;
364 libvlc_track_description_t *p_trackDesc;
366 libvlc_media_player_t *p_md = p_plugin->getMD(&ex);
367 RETURN_ON_EXCEPTION(this,ex);
369 /* get tracks description */
370 p_trackDesc = libvlc_audio_get_track_description(p_md, &ex);
371 RETURN_ON_EXCEPTION(this,ex);
373 return INVOKERESULT_GENERIC_ERROR;
375 /* get the number of track available */
376 i_limit = libvlc_audio_get_track_count(p_md, &ex);
377 RETURN_ON_EXCEPTION(this,ex);
379 /* check if a number is given by the user
380 * and get the track number */
381 if( isNumberValue(args[0]) )
382 i_trackID = numberValue(args[0]);
384 return INVOKERESULT_INVALID_VALUE;
386 /* if bad number is given return invalid value */
387 if ( ( i_trackID > ( i_limit - 1 ) ) || ( i_trackID < 0 ) )
388 return INVOKERESULT_INVALID_VALUE;
390 /* get the good trackDesc */
391 for( i = 0 ; i < i_trackID ; i++ )
393 p_trackDesc = p_trackDesc->p_next;
395 psz_name = p_trackDesc->psz_name;
397 /* display the name of the track chosen */
398 return invokeResultString( psz_name, result );
400 return INVOKERESULT_NO_SUCH_METHOD;
406 return INVOKERESULT_GENERIC_ERROR;
410 ** implementation of libvlc input object
413 const NPUTF8 * const LibvlcInputNPObject::propertyNames[] =
423 COUNTNAMES(LibvlcInputNPObject,propertyCount,propertyNames);
425 enum LibvlcInputNPObjectPropertyIds
436 RuntimeNPObject::InvokeResult
437 LibvlcInputNPObject::getProperty(int index, NPVariant &result)
439 /* is plugin still running */
440 if( isPluginRunning() )
442 VlcPlugin* p_plugin = getPrivate<VlcPlugin>();
443 libvlc_exception_t ex;
444 libvlc_exception_init(&ex);
446 libvlc_media_player_t *p_md = p_plugin->getMD(&ex);
447 if( libvlc_exception_raised(&ex) )
449 if( index != ID_input_state )
451 NPN_SetException(this, libvlc_exception_get_message(&ex));
452 libvlc_exception_clear(&ex);
453 return INVOKERESULT_GENERIC_ERROR;
457 /* for input state, return CLOSED rather than an exception */
458 INT32_TO_NPVARIANT(0, result);
459 libvlc_exception_clear(&ex);
460 return INVOKERESULT_NO_ERROR;
466 case ID_input_length:
468 double val = (double)libvlc_media_player_get_length(p_md, &ex);
469 RETURN_ON_EXCEPTION(this,ex);
470 DOUBLE_TO_NPVARIANT(val, result);
471 return INVOKERESULT_NO_ERROR;
473 case ID_input_position:
475 double val = libvlc_media_player_get_position(p_md, &ex);
476 RETURN_ON_EXCEPTION(this,ex);
477 DOUBLE_TO_NPVARIANT(val, result);
478 return INVOKERESULT_NO_ERROR;
482 double val = (double)libvlc_media_player_get_time(p_md, &ex);
483 RETURN_ON_EXCEPTION(this,ex);
484 DOUBLE_TO_NPVARIANT(val, result);
485 return INVOKERESULT_NO_ERROR;
489 int val = libvlc_media_player_get_state(p_md, &ex);
490 RETURN_ON_EXCEPTION(this,ex);
491 INT32_TO_NPVARIANT(val, result);
492 return INVOKERESULT_NO_ERROR;
496 float val = libvlc_media_player_get_rate(p_md, &ex);
497 RETURN_ON_EXCEPTION(this,ex);
498 DOUBLE_TO_NPVARIANT(val, result);
499 return INVOKERESULT_NO_ERROR;
503 double val = libvlc_media_player_get_fps(p_md, &ex);
504 RETURN_ON_EXCEPTION(this,ex);
505 DOUBLE_TO_NPVARIANT(val, result);
506 return INVOKERESULT_NO_ERROR;
508 case ID_input_hasvout:
510 bool val = p_plugin->player_has_vout(&ex);
511 RETURN_ON_EXCEPTION(this,ex);
512 BOOLEAN_TO_NPVARIANT(val, result);
513 return INVOKERESULT_NO_ERROR;
519 return INVOKERESULT_GENERIC_ERROR;
522 RuntimeNPObject::InvokeResult
523 LibvlcInputNPObject::setProperty(int index, const NPVariant &value)
525 /* is plugin still running */
526 if( isPluginRunning() )
528 VlcPlugin* p_plugin = getPrivate<VlcPlugin>();
529 libvlc_exception_t ex;
530 libvlc_exception_init(&ex);
532 libvlc_media_player_t *p_md = p_plugin->getMD(&ex);
533 RETURN_ON_EXCEPTION(this,ex);
537 case ID_input_position:
539 if( ! NPVARIANT_IS_DOUBLE(value) )
541 return INVOKERESULT_INVALID_VALUE;
544 float val = (float)NPVARIANT_TO_DOUBLE(value);
545 libvlc_media_player_set_position(p_md, val, &ex);
546 RETURN_ON_EXCEPTION(this,ex);
547 return INVOKERESULT_NO_ERROR;
552 if( NPVARIANT_IS_INT32(value) )
553 val = (int64_t)NPVARIANT_TO_INT32(value);
554 else if( NPVARIANT_IS_DOUBLE(value) )
555 val = (int64_t)NPVARIANT_TO_DOUBLE(value);
558 return INVOKERESULT_INVALID_VALUE;
561 libvlc_media_player_set_time(p_md, val, &ex);
562 RETURN_ON_EXCEPTION(this,ex);
563 return INVOKERESULT_NO_ERROR;
568 if( NPVARIANT_IS_INT32(value) )
569 val = (float)NPVARIANT_TO_INT32(value);
570 else if( NPVARIANT_IS_DOUBLE(value) )
571 val = (float)NPVARIANT_TO_DOUBLE(value);
574 return INVOKERESULT_INVALID_VALUE;
577 libvlc_media_player_set_rate(p_md, val, &ex);
578 RETURN_ON_EXCEPTION(this,ex);
579 return INVOKERESULT_NO_ERROR;
585 return INVOKERESULT_GENERIC_ERROR;
588 const NPUTF8 * const LibvlcInputNPObject::methodNames[] =
593 COUNTNAMES(LibvlcInputNPObject,methodCount,methodNames);
595 enum LibvlcInputNPObjectMethodIds
600 RuntimeNPObject::InvokeResult
601 LibvlcInputNPObject::invoke(int index, const NPVariant *args,
602 uint32_t argCount, NPVariant &result)
604 /* is plugin still running */
605 if( isPluginRunning() )
610 return INVOKERESULT_NO_SUCH_METHOD;
615 return INVOKERESULT_GENERIC_ERROR;
619 ** implementation of libvlc playlist items object
622 const NPUTF8 * const LibvlcPlaylistItemsNPObject::propertyNames[] =
626 COUNTNAMES(LibvlcPlaylistItemsNPObject,propertyCount,propertyNames);
628 enum LibvlcPlaylistItemsNPObjectPropertyIds
630 ID_playlistitems_count,
633 RuntimeNPObject::InvokeResult
634 LibvlcPlaylistItemsNPObject::getProperty(int index, NPVariant &result)
636 /* is plugin still running */
637 if( isPluginRunning() )
639 VlcPlugin* p_plugin = getPrivate<VlcPlugin>();
640 libvlc_exception_t ex;
641 libvlc_exception_init(&ex);
645 case ID_playlistitems_count:
647 int val = p_plugin->playlist_count(&ex);
648 RETURN_ON_EXCEPTION(this,ex);
649 INT32_TO_NPVARIANT(val, result);
650 return INVOKERESULT_NO_ERROR;
656 return INVOKERESULT_GENERIC_ERROR;
659 const NPUTF8 * const LibvlcPlaylistItemsNPObject::methodNames[] =
664 COUNTNAMES(LibvlcPlaylistItemsNPObject,methodCount,methodNames);
666 enum LibvlcPlaylistItemsNPObjectMethodIds
668 ID_playlistitems_clear,
669 ID_playlistitems_remove,
672 RuntimeNPObject::InvokeResult
673 LibvlcPlaylistItemsNPObject::invoke(int index, const NPVariant *args,
674 uint32_t argCount, NPVariant &result)
676 /* is plugin still running */
677 if( isPluginRunning() )
679 VlcPlugin* p_plugin = getPrivate<VlcPlugin>();
680 libvlc_exception_t ex;
681 libvlc_exception_init(&ex);
685 case ID_playlistitems_clear:
688 p_plugin->playlist_clear(&ex);
689 RETURN_ON_EXCEPTION(this,ex);
690 VOID_TO_NPVARIANT(result);
691 return INVOKERESULT_NO_ERROR;
693 return INVOKERESULT_NO_SUCH_METHOD;
694 case ID_playlistitems_remove:
695 if( (argCount == 1) && isNumberValue(args[0]) )
697 p_plugin->playlist_delete_item(numberValue(args[0]),&ex);
698 RETURN_ON_EXCEPTION(this,ex);
699 VOID_TO_NPVARIANT(result);
700 return INVOKERESULT_NO_ERROR;
702 return INVOKERESULT_NO_SUCH_METHOD;
707 return INVOKERESULT_GENERIC_ERROR;
711 ** implementation of libvlc playlist object
714 LibvlcPlaylistNPObject::~LibvlcPlaylistNPObject()
716 // Why the isValid()?
717 if( isValid() && playlistItemsObj )
718 NPN_ReleaseObject(playlistItemsObj);
721 const NPUTF8 * const LibvlcPlaylistNPObject::propertyNames[] =
723 "itemCount", /* deprecated */
727 COUNTNAMES(LibvlcPlaylistNPObject,propertyCount,propertyNames);
729 enum LibvlcPlaylistNPObjectPropertyIds
731 ID_playlist_itemcount,
732 ID_playlist_isplaying,
736 RuntimeNPObject::InvokeResult
737 LibvlcPlaylistNPObject::getProperty(int index, NPVariant &result)
739 /* is plugin still running */
740 if( isPluginRunning() )
742 VlcPlugin* p_plugin = getPrivate<VlcPlugin>();
743 libvlc_exception_t ex;
744 libvlc_exception_init(&ex);
748 case ID_playlist_itemcount: /* deprecated */
750 int val = p_plugin->playlist_count(&ex);
751 RETURN_ON_EXCEPTION(this,ex);
752 INT32_TO_NPVARIANT(val, result);
753 return INVOKERESULT_NO_ERROR;
755 case ID_playlist_isplaying:
757 int val = p_plugin->playlist_isplaying(&ex);
758 RETURN_ON_EXCEPTION(this,ex);
759 BOOLEAN_TO_NPVARIANT(val, result);
760 return INVOKERESULT_NO_ERROR;
762 case ID_playlist_items:
764 // create child object in lazyman fashion to avoid
765 // ownership problem with firefox
766 if( ! playlistItemsObj )
768 NPN_CreateObject(_instance, RuntimeNPClass<
769 LibvlcPlaylistItemsNPObject>::getClass());
770 OBJECT_TO_NPVARIANT(NPN_RetainObject(playlistItemsObj), result);
771 return INVOKERESULT_NO_ERROR;
777 return INVOKERESULT_GENERIC_ERROR;
780 const NPUTF8 * const LibvlcPlaylistNPObject::methodNames[] =
789 "clear", /* deprecated */
790 "removeItem", /* deprecated */
792 COUNTNAMES(LibvlcPlaylistNPObject,methodCount,methodNames);
794 enum LibvlcPlaylistNPObjectMethodIds
798 ID_playlist_playItem,
799 ID_playlist_togglepause,
804 ID_playlist_removeitem
807 RuntimeNPObject::InvokeResult
808 LibvlcPlaylistNPObject::invoke(int index, const NPVariant *args,
809 uint32_t argCount, NPVariant &result)
811 /* is plugin still running */
812 if( isPluginRunning() )
814 VlcPlugin* p_plugin = getPrivate<VlcPlugin>();
815 libvlc_exception_t ex;
816 libvlc_exception_init(&ex);
820 // XXX FIXME this needs squashing into something much smaller
821 case ID_playlist_add:
823 if( (argCount < 1) || (argCount > 3) )
824 return INVOKERESULT_NO_SUCH_METHOD;
825 if( !NPVARIANT_IS_STRING(args[0]) )
826 return INVOKERESULT_NO_SUCH_METHOD;
829 if( NPVARIANT_IS_NULL(args[0]) )
830 return INVOKERESULT_NO_SUCH_METHOD;
832 char *s = stringValue(NPVARIANT_TO_STRING(args[0]));
834 return INVOKERESULT_OUT_OF_MEMORY;
836 char *url = p_plugin->getAbsoluteURL(s);
840 // problem with combining url, use argument
845 // grab name if available
848 if( NPVARIANT_IS_NULL(args[1]) )
852 else if( NPVARIANT_IS_STRING(args[1]) )
854 name = stringValue(NPVARIANT_TO_STRING(args[1]));
859 return INVOKERESULT_INVALID_VALUE;
864 char** ppsz_options = NULL;
866 // grab options if available
869 if( NPVARIANT_IS_NULL(args[2]) )
873 else if( NPVARIANT_IS_STRING(args[2]) )
875 parseOptions(NPVARIANT_TO_STRING(args[2]),
876 &i_options, &ppsz_options);
879 else if( NPVARIANT_IS_OBJECT(args[2]) )
881 parseOptions(NPVARIANT_TO_OBJECT(args[2]),
882 &i_options, &ppsz_options);
888 return INVOKERESULT_INVALID_VALUE;
892 int item = p_plugin->playlist_add_extended_untrusted(url, name,
893 i_options, const_cast<const char **>(ppsz_options), &ex);
896 for( int i=0; i< i_options; ++i )
898 free(ppsz_options[i]);
902 RETURN_ON_EXCEPTION(this,ex);
903 INT32_TO_NPVARIANT(item, result);
904 return INVOKERESULT_NO_ERROR;
906 case ID_playlist_play:
909 p_plugin->playlist_play(&ex);
910 RETURN_ON_EXCEPTION(this,ex);
911 VOID_TO_NPVARIANT(result);
912 return INVOKERESULT_NO_ERROR;
914 return INVOKERESULT_NO_SUCH_METHOD;
915 case ID_playlist_playItem:
916 if( (argCount == 1) && isNumberValue(args[0]) )
918 p_plugin->playlist_play_item(numberValue(args[0]),&ex);
919 RETURN_ON_EXCEPTION(this,ex);
920 VOID_TO_NPVARIANT(result);
921 return INVOKERESULT_NO_ERROR;
923 return INVOKERESULT_NO_SUCH_METHOD;
924 case ID_playlist_togglepause:
927 p_plugin->playlist_pause(&ex);
928 RETURN_ON_EXCEPTION(this,ex);
929 VOID_TO_NPVARIANT(result);
930 return INVOKERESULT_NO_ERROR;
932 return INVOKERESULT_NO_SUCH_METHOD;
933 case ID_playlist_stop:
936 p_plugin->playlist_stop(&ex);
937 RETURN_ON_EXCEPTION(this,ex);
938 VOID_TO_NPVARIANT(result);
939 return INVOKERESULT_NO_ERROR;
941 return INVOKERESULT_NO_SUCH_METHOD;
942 case ID_playlist_next:
945 p_plugin->playlist_next(&ex);
946 RETURN_ON_EXCEPTION(this,ex);
947 VOID_TO_NPVARIANT(result);
948 return INVOKERESULT_NO_ERROR;
950 return INVOKERESULT_NO_SUCH_METHOD;
951 case ID_playlist_prev:
954 p_plugin->playlist_prev(&ex);
955 RETURN_ON_EXCEPTION(this,ex);
956 VOID_TO_NPVARIANT(result);
957 return INVOKERESULT_NO_ERROR;
959 return INVOKERESULT_NO_SUCH_METHOD;
960 case ID_playlist_clear: /* deprecated */
963 p_plugin->playlist_clear(&ex);
964 RETURN_ON_EXCEPTION(this,ex);
965 VOID_TO_NPVARIANT(result);
966 return INVOKERESULT_NO_ERROR;
968 return INVOKERESULT_NO_SUCH_METHOD;
969 case ID_playlist_removeitem: /* deprecated */
970 if( (argCount == 1) && isNumberValue(args[0]) )
972 p_plugin->playlist_delete_item(numberValue(args[0]), &ex);
973 RETURN_ON_EXCEPTION(this,ex);
974 VOID_TO_NPVARIANT(result);
975 return INVOKERESULT_NO_ERROR;
977 return INVOKERESULT_NO_SUCH_METHOD;
982 return INVOKERESULT_GENERIC_ERROR;
985 // XXX FIXME The new playlist_add creates a media instance and feeds it
986 // XXX FIXME these options one at a time, so this hunk of code does lots
987 // XXX FIXME of unnecessairy work. Break out something that can do one
988 // XXX FIXME option at a time and doesn't need to realloc().
989 // XXX FIXME Same for the other version of parseOptions.
991 void LibvlcPlaylistNPObject::parseOptions(const NPString &nps,
992 int *i_options, char*** ppsz_options)
996 char *s = stringValue(nps);
1001 char **options = (char **)malloc(capacity*sizeof(char *));
1006 char *end = val + nps.utf8length;
1009 // skip leading blanks
1011 && ((*val == ' ' ) || (*val == '\t')) )
1015 // skip till we get a blank character
1021 if( ('\'' == c) || ('"' == c) )
1023 // skip till end of string
1024 while( (val < end) && (*(val++) != c ) );
1030 if( nOptions == capacity )
1033 char **moreOptions = (char **)realloc(options, capacity*sizeof(char*));
1036 /* failed to allocate more memory */
1038 /* return what we got so far */
1039 *i_options = nOptions;
1040 *ppsz_options = options;
1043 options = moreOptions;
1046 options[nOptions++] = strdup(start);
1049 // must be end of string
1052 *i_options = nOptions;
1053 *ppsz_options = options;
1060 // XXX FIXME See comment at the other parseOptions variant.
1061 void LibvlcPlaylistNPObject::parseOptions(NPObject *obj, int *i_options,
1062 char*** ppsz_options)
1064 /* WARNING: Safari does not implement NPN_HasProperty/NPN_HasMethod */
1068 /* we are expecting to have a Javascript Array object */
1069 NPIdentifier propId = NPN_GetStringIdentifier("length");
1070 if( NPN_GetProperty(_instance, obj, propId, &value) )
1072 int count = numberValue(value);
1073 NPN_ReleaseVariantValue(&value);
1078 char **options = (char **)malloc(capacity*sizeof(char *));
1083 while( nOptions < count )
1085 propId = NPN_GetIntIdentifier(nOptions);
1086 if( ! NPN_GetProperty(_instance, obj, propId, &value) )
1087 /* return what we got so far */
1090 if( ! NPVARIANT_IS_STRING(value) )
1092 /* return what we got so far */
1093 NPN_ReleaseVariantValue(&value);
1097 if( nOptions == capacity )
1100 char **moreOptions = (char **)realloc(options, capacity*sizeof(char*));
1103 /* failed to allocate more memory */
1104 NPN_ReleaseVariantValue(&value);
1105 /* return what we got so far */
1106 *i_options = nOptions;
1107 *ppsz_options = options;
1110 options = moreOptions;
1113 options[nOptions++] = stringValue(value);
1114 NPN_ReleaseVariantValue(&value);
1116 *i_options = nOptions;
1117 *ppsz_options = options;
1124 ** implementation of libvlc subtitle object
1127 const NPUTF8 * const LibvlcSubtitleNPObject::propertyNames[] =
1133 enum LibvlcSubtitleNPObjectPropertyIds
1138 COUNTNAMES(LibvlcSubtitleNPObject,propertyCount,propertyNames);
1140 RuntimeNPObject::InvokeResult
1141 LibvlcSubtitleNPObject::getProperty(int index, NPVariant &result)
1143 /* is plugin still running */
1144 if( isPluginRunning() )
1146 VlcPlugin* p_plugin = getPrivate<VlcPlugin>();
1147 libvlc_exception_t ex;
1148 libvlc_exception_init(&ex);
1150 libvlc_media_player_t *p_md = p_plugin->getMD(&ex);
1151 RETURN_ON_EXCEPTION(this,ex);
1155 case ID_subtitle_track:
1157 /* get the current subtitle ID */
1158 int i_spu = libvlc_video_get_spu(p_md, &ex);
1159 RETURN_ON_EXCEPTION(this,ex);
1161 INT32_TO_NPVARIANT(i_spu, result);
1162 return INVOKERESULT_NO_ERROR;
1164 case ID_subtitle_count:
1166 /* get the number of subtitles available */
1167 int i_spu = libvlc_video_get_spu_count(p_md, &ex);
1168 RETURN_ON_EXCEPTION(this,ex);
1170 INT32_TO_NPVARIANT(i_spu, result);
1171 return INVOKERESULT_NO_ERROR;
1175 return INVOKERESULT_GENERIC_ERROR;
1178 RuntimeNPObject::InvokeResult
1179 LibvlcSubtitleNPObject::setProperty(int index, const NPVariant &value)
1181 /* is plugin still running */
1182 if( isPluginRunning() )
1184 VlcPlugin* p_plugin = getPrivate<VlcPlugin>();
1185 libvlc_exception_t ex;
1186 libvlc_exception_init(&ex);
1188 libvlc_media_player_t *p_md = p_plugin->getMD(&ex);
1189 RETURN_ON_EXCEPTION(this,ex);
1193 case ID_subtitle_track:
1195 if( isNumberValue(value) )
1197 /* set the new subtitle track to show */
1198 libvlc_video_set_spu(p_md, numberValue(value), &ex);
1199 RETURN_ON_EXCEPTION(this,ex);
1201 return INVOKERESULT_NO_ERROR;
1203 return INVOKERESULT_INVALID_VALUE;
1207 return INVOKERESULT_GENERIC_ERROR;
1210 const NPUTF8 * const LibvlcSubtitleNPObject::methodNames[] =
1214 COUNTNAMES(LibvlcSubtitleNPObject,methodCount,methodNames);
1216 enum LibvlcSubtitleNPObjectMethodIds
1218 ID_subtitle_description
1221 RuntimeNPObject::InvokeResult
1222 LibvlcSubtitleNPObject::invoke(int index, const NPVariant *args,
1223 uint32_t argCount, NPVariant &result)
1225 /* is plugin still running */
1226 if( isPluginRunning() )
1228 VlcPlugin* p_plugin = getPrivate<VlcPlugin>();
1229 libvlc_exception_t ex;
1230 libvlc_exception_init(&ex);
1232 libvlc_media_player_t *p_md = p_plugin->getMD(&ex);
1233 RETURN_ON_EXCEPTION(this,ex);
1237 case ID_subtitle_description:
1242 int i_spuID, i_limit, i;
1243 libvlc_track_description_t *p_spuDesc;
1245 /* get subtitles description */
1246 p_spuDesc = libvlc_video_get_spu_description(p_md, &ex);
1247 RETURN_ON_EXCEPTION(this,ex);
1249 return INVOKERESULT_GENERIC_ERROR;
1251 /* get the number of subtitle available */
1252 i_limit = libvlc_video_get_spu_count(p_md, &ex);
1253 RETURN_ON_EXCEPTION(this,ex);
1255 /* check if a number is given by the user
1256 * and get the subtitle number */
1257 if( isNumberValue(args[0]) )
1258 i_spuID = numberValue(args[0]);
1260 return INVOKERESULT_INVALID_VALUE;
1262 /* if bad number is given return invalid value */
1263 if ( ( i_spuID > ( i_limit -1 ) ) || ( i_spuID < 0 ) )
1264 return INVOKERESULT_INVALID_VALUE;
1266 /* get the good spuDesc */
1267 for( i = 0 ; i < i_spuID ; i++ )
1269 p_spuDesc = p_spuDesc->p_next;
1271 psz_name = p_spuDesc->psz_name;
1273 /* return the name of the track chosen */
1274 return invokeResultString(psz_name, result);
1276 return INVOKERESULT_NO_SUCH_METHOD;
1279 return INVOKERESULT_NO_SUCH_METHOD;
1282 return INVOKERESULT_GENERIC_ERROR;
1286 ** implementation of libvlc video object
1289 const NPUTF8 * const LibvlcVideoNPObject::propertyNames[] =
1301 enum LibvlcVideoNPObjectPropertyIds
1303 ID_video_fullscreen,
1306 ID_video_aspectratio,
1312 COUNTNAMES(LibvlcVideoNPObject,propertyCount,propertyNames);
1314 RuntimeNPObject::InvokeResult
1315 LibvlcVideoNPObject::getProperty(int index, NPVariant &result)
1317 /* is plugin still running */
1318 if( isPluginRunning() )
1320 VlcPlugin* p_plugin = getPrivate<VlcPlugin>();
1321 libvlc_exception_t ex;
1322 libvlc_exception_init(&ex);
1324 libvlc_media_player_t *p_md = p_plugin->getMD(&ex);
1325 RETURN_ON_EXCEPTION(this,ex);
1329 case ID_video_fullscreen:
1331 int val = p_plugin->get_fullscreen(&ex);
1332 RETURN_ON_EXCEPTION(this,ex);
1333 BOOLEAN_TO_NPVARIANT(val, result);
1334 return INVOKERESULT_NO_ERROR;
1336 case ID_video_height:
1338 int val = libvlc_video_get_height(p_md, &ex);
1339 RETURN_ON_EXCEPTION(this,ex);
1340 INT32_TO_NPVARIANT(val, result);
1341 return INVOKERESULT_NO_ERROR;
1343 case ID_video_width:
1345 int val = libvlc_video_get_width(p_md, &ex);
1346 RETURN_ON_EXCEPTION(this,ex);
1347 INT32_TO_NPVARIANT(val, result);
1348 return INVOKERESULT_NO_ERROR;
1350 case ID_video_aspectratio:
1352 NPUTF8 *psz_aspect = libvlc_video_get_aspect_ratio(p_md, &ex);
1353 RETURN_ON_EXCEPTION(this,ex);
1355 return INVOKERESULT_GENERIC_ERROR;
1357 STRINGZ_TO_NPVARIANT(psz_aspect, result);
1358 return INVOKERESULT_NO_ERROR;
1360 case ID_video_subtitle:
1362 int i_spu = libvlc_video_get_spu(p_md, &ex);
1363 RETURN_ON_EXCEPTION(this,ex);
1364 INT32_TO_NPVARIANT(i_spu, result);
1365 return INVOKERESULT_NO_ERROR;
1369 NPUTF8 *psz_geometry = libvlc_video_get_crop_geometry(p_md, &ex);
1370 RETURN_ON_EXCEPTION(this,ex);
1372 return INVOKERESULT_GENERIC_ERROR;
1374 STRINGZ_TO_NPVARIANT(psz_geometry, result);
1375 return INVOKERESULT_NO_ERROR;
1377 case ID_video_teletext:
1379 int i_page = libvlc_video_get_teletext(p_md, &ex);
1380 RETURN_ON_EXCEPTION(this,ex);
1381 INT32_TO_NPVARIANT(i_page, result);
1382 return INVOKERESULT_NO_ERROR;
1384 case ID_video_marquee:
1387 marqueeObj = NPN_CreateObject(_instance,
1388 RuntimeNPClass<LibvlcMarqueeNPObject>::getClass());
1389 OBJECT_TO_NPVARIANT(NPN_RetainObject(marqueeObj), result);
1390 return INVOKERESULT_NO_ERROR;
1394 return INVOKERESULT_GENERIC_ERROR;
1397 RuntimeNPObject::InvokeResult
1398 LibvlcVideoNPObject::setProperty(int index, const NPVariant &value)
1400 /* is plugin still running */
1401 if( isPluginRunning() )
1403 VlcPlugin* p_plugin = getPrivate<VlcPlugin>();
1404 libvlc_exception_t ex;
1405 libvlc_exception_init(&ex);
1407 libvlc_media_player_t *p_md = p_plugin->getMD(&ex);
1408 RETURN_ON_EXCEPTION(this,ex);
1412 case ID_video_fullscreen:
1414 if( ! NPVARIANT_IS_BOOLEAN(value) )
1416 return INVOKERESULT_INVALID_VALUE;
1419 int val = NPVARIANT_TO_BOOLEAN(value);
1420 p_plugin->set_fullscreen(val, &ex);
1421 RETURN_ON_EXCEPTION(this,ex);
1422 return INVOKERESULT_NO_ERROR;
1424 case ID_video_aspectratio:
1426 char *psz_aspect = NULL;
1428 if( ! NPVARIANT_IS_STRING(value) )
1430 return INVOKERESULT_INVALID_VALUE;
1433 psz_aspect = stringValue(NPVARIANT_TO_STRING(value));
1436 return INVOKERESULT_GENERIC_ERROR;
1439 libvlc_video_set_aspect_ratio(p_md, psz_aspect, &ex);
1441 RETURN_ON_EXCEPTION(this,ex);
1443 return INVOKERESULT_NO_ERROR;
1445 case ID_video_subtitle:
1447 if( isNumberValue(value) )
1449 libvlc_video_set_spu(p_md, numberValue(value), &ex);
1450 RETURN_ON_EXCEPTION(this,ex);
1452 return INVOKERESULT_NO_ERROR;
1454 return INVOKERESULT_INVALID_VALUE;
1458 char *psz_geometry = NULL;
1460 if( ! NPVARIANT_IS_STRING(value) )
1462 return INVOKERESULT_INVALID_VALUE;
1465 psz_geometry = stringValue(NPVARIANT_TO_STRING(value));
1468 return INVOKERESULT_GENERIC_ERROR;
1471 libvlc_video_set_crop_geometry(p_md, psz_geometry, &ex);
1473 RETURN_ON_EXCEPTION(this,ex);
1475 return INVOKERESULT_NO_ERROR;
1477 case ID_video_teletext:
1479 if( isNumberValue(value) )
1481 libvlc_video_set_teletext(p_md, numberValue(value), &ex);
1482 RETURN_ON_EXCEPTION(this,ex);
1484 return INVOKERESULT_NO_ERROR;
1486 return INVOKERESULT_INVALID_VALUE;
1490 return INVOKERESULT_GENERIC_ERROR;
1493 const NPUTF8 * const LibvlcVideoNPObject::methodNames[] =
1497 "deinterlaceEnable",
1498 "deinterlaceDisable"
1500 COUNTNAMES(LibvlcVideoNPObject,methodCount,methodNames);
1502 enum LibvlcVideoNPObjectMethodIds
1504 ID_video_togglefullscreen,
1505 ID_video_toggleteletext,
1506 ID_video_deinterlaceenable,
1507 ID_video_deinterlacedisable
1510 RuntimeNPObject::InvokeResult
1511 LibvlcVideoNPObject::invoke(int index, const NPVariant *args,
1512 uint32_t argCount, NPVariant &result)
1514 /* is plugin still running */
1515 if( isPluginRunning() )
1517 VlcPlugin* p_plugin = getPrivate<VlcPlugin>();
1518 libvlc_exception_t ex;
1519 libvlc_exception_init(&ex);
1521 libvlc_media_player_t *p_md = p_plugin->getMD(&ex);
1522 RETURN_ON_EXCEPTION(this,ex);
1526 case ID_video_togglefullscreen:
1530 p_plugin->toggle_fullscreen(&ex);
1531 RETURN_ON_EXCEPTION(this,ex);
1532 VOID_TO_NPVARIANT(result);
1533 return INVOKERESULT_NO_ERROR;
1535 return INVOKERESULT_NO_SUCH_METHOD;
1537 case ID_video_toggleteletext:
1541 libvlc_toggle_teletext(p_md, &ex);
1542 RETURN_ON_EXCEPTION(this,ex);
1543 VOID_TO_NPVARIANT(result);
1544 return INVOKERESULT_NO_ERROR;
1546 return INVOKERESULT_NO_SUCH_METHOD;
1548 case ID_video_deinterlacedisable:
1550 libvlc_video_set_deinterlace(p_md, 0, "", &ex);
1551 RETURN_ON_EXCEPTION(this,ex);
1552 return INVOKERESULT_NO_ERROR;
1554 case ID_video_deinterlaceenable:
1558 if( NPVARIANT_IS_STRING( args[0] ) )
1560 /* get deinterlace mode from the user */
1561 char *psz_mode = stringValue( NPVARIANT_TO_STRING( args[0] ) );
1562 /* enable deinterlace filter if possible */
1563 libvlc_video_set_deinterlace(p_md, 1, psz_mode, &ex);
1565 RETURN_ON_EXCEPTION(this,ex);
1566 return INVOKERESULT_NO_ERROR;
1570 return INVOKERESULT_INVALID_VALUE;
1575 return INVOKERESULT_NO_SUCH_METHOD;
1578 return INVOKERESULT_GENERIC_ERROR;
1582 ** implementation of libvlc marquee object
1585 const NPUTF8 * const LibvlcMarqueeNPObject::propertyNames[] =
1589 enum LibvlcMarqueeNPObjectPropertyIds
1592 COUNTNAMES(LibvlcMarqueeNPObject,propertyCount,propertyNames);
1594 RuntimeNPObject::InvokeResult
1595 LibvlcMarqueeNPObject::getProperty(int index, NPVariant &result)
1597 /* is plugin still running */
1598 if( isPluginRunning() )
1600 VlcPlugin* p_plugin = getPrivate<VlcPlugin>();
1601 libvlc_exception_t ex;
1602 libvlc_exception_init(&ex);
1604 libvlc_media_player_t *p_md = p_plugin->getMD(&ex);
1605 RETURN_ON_EXCEPTION(this,ex);
1611 return INVOKERESULT_GENERIC_ERROR;
1614 RuntimeNPObject::InvokeResult
1615 LibvlcMarqueeNPObject::setProperty(int index, const NPVariant &value)
1617 /* is plugin still running */
1618 if( isPluginRunning() )
1620 VlcPlugin* p_plugin = getPrivate<VlcPlugin>();
1621 libvlc_exception_t ex;
1622 libvlc_exception_init(&ex);
1624 libvlc_media_player_t *p_md = p_plugin->getMD(&ex);
1625 RETURN_ON_EXCEPTION(this,ex);
1631 return INVOKERESULT_GENERIC_ERROR;
1634 const NPUTF8 * const LibvlcMarqueeNPObject::methodNames[] =
1648 COUNTNAMES(LibvlcMarqueeNPObject,methodCount,methodNames);
1650 enum LibvlcMarqueeNPObjectMethodIds
1656 ID_marquee_position,
1665 RuntimeNPObject::InvokeResult
1666 LibvlcMarqueeNPObject::invoke(int index, const NPVariant *args,
1667 uint32_t argCount, NPVariant &result)
1669 /* is plugin still running */
1670 if( isPluginRunning() )
1672 VlcPlugin* p_plugin = getPrivate<VlcPlugin>();
1673 libvlc_exception_t ex;
1674 libvlc_exception_init(&ex);
1676 libvlc_media_player_t *p_md = p_plugin->getMD(&ex);
1677 RETURN_ON_EXCEPTION(this,ex);
1681 case ID_marquee_enable:
1683 libvlc_video_set_marquee_option_as_int(p_md, libvlc_marquee_Enabled, true, &ex);
1684 RETURN_ON_EXCEPTION(this,ex);
1685 return INVOKERESULT_NO_ERROR;
1687 case ID_marquee_disable:
1689 libvlc_video_set_marquee_option_as_int(p_md, libvlc_marquee_Enabled, false, &ex);
1690 RETURN_ON_EXCEPTION(this,ex);
1691 return INVOKERESULT_NO_ERROR;
1693 case ID_marquee_color:
1697 if( NPVARIANT_IS_INT32( args[0] ) )
1699 int i_color = NPVARIANT_TO_INT32( args[0] );
1700 libvlc_video_set_marquee_option_as_int(p_md, libvlc_marquee_Color, i_color, &ex);
1701 RETURN_ON_EXCEPTION(this,ex);
1702 return INVOKERESULT_NO_ERROR;
1705 return INVOKERESULT_GENERIC_ERROR;
1707 return INVOKERESULT_NO_SUCH_METHOD;
1709 case ID_marquee_opacity:
1713 if( NPVARIANT_IS_INT32( args[0] ) )
1715 int i_opacity = NPVARIANT_TO_INT32( args[0] );
1716 libvlc_video_set_marquee_option_as_int(p_md, libvlc_marquee_Opacity, i_opacity, &ex);
1717 RETURN_ON_EXCEPTION(this,ex);
1718 return INVOKERESULT_NO_ERROR;
1721 return INVOKERESULT_GENERIC_ERROR;
1723 return INVOKERESULT_NO_SUCH_METHOD;
1725 case ID_marquee_position:
1729 if( NPVARIANT_IS_INT32( args[0] ) )
1731 int i_position = NPVARIANT_TO_INT32( args[0] );
1732 libvlc_video_set_marquee_option_as_int(p_md, libvlc_marquee_Position, i_position, &ex);
1733 RETURN_ON_EXCEPTION(this,ex);
1734 return INVOKERESULT_NO_ERROR;
1737 return INVOKERESULT_GENERIC_ERROR;
1739 return INVOKERESULT_NO_SUCH_METHOD;
1741 case ID_marquee_refresh:
1745 if( NPVARIANT_IS_INT32( args[0] ) )
1747 int i_refresh = NPVARIANT_TO_INT32( args[0] );
1748 libvlc_video_set_marquee_option_as_int(p_md, libvlc_marquee_Refresh, i_refresh, &ex);
1749 RETURN_ON_EXCEPTION(this,ex);
1750 return INVOKERESULT_NO_ERROR;
1753 return INVOKERESULT_GENERIC_ERROR;
1755 return INVOKERESULT_NO_SUCH_METHOD;
1757 case ID_marquee_size:
1761 if( NPVARIANT_IS_INT32( args[0] ) )
1763 int i_size = NPVARIANT_TO_INT32( args[0] );
1764 libvlc_video_set_marquee_option_as_int(p_md, libvlc_marquee_Size, i_size, &ex);
1765 RETURN_ON_EXCEPTION(this,ex);
1766 return INVOKERESULT_NO_ERROR;
1769 return INVOKERESULT_GENERIC_ERROR;
1771 return INVOKERESULT_NO_SUCH_METHOD;
1773 case ID_marquee_text:
1777 if( NPVARIANT_IS_STRING( args[0] ) )
1779 char *psz_text = stringValue( NPVARIANT_TO_STRING( args[0] ) );
1780 libvlc_video_set_marquee_option_as_string(p_md, libvlc_marquee_Text, psz_text, &ex);
1781 RETURN_ON_EXCEPTION(this,ex);
1783 return INVOKERESULT_NO_ERROR;
1786 return INVOKERESULT_GENERIC_ERROR;
1788 return INVOKERESULT_NO_SUCH_METHOD;
1790 case ID_marquee_timeout:
1794 if( NPVARIANT_IS_INT32( args[0] ) )
1796 int i_timeout = NPVARIANT_TO_INT32( args[0] );
1797 libvlc_video_set_marquee_option_as_int(p_md, libvlc_marquee_Timeout, i_timeout, &ex);
1798 RETURN_ON_EXCEPTION(this,ex);
1799 return INVOKERESULT_NO_ERROR;
1802 return INVOKERESULT_GENERIC_ERROR;
1804 return INVOKERESULT_NO_SUCH_METHOD;
1810 if( NPVARIANT_IS_INT32( args[0] ) )
1812 int i_x = NPVARIANT_TO_INT32( args[0] );
1813 libvlc_video_set_marquee_option_as_int(p_md, libvlc_marquee_X, i_x, &ex);
1814 RETURN_ON_EXCEPTION(this,ex);
1815 return INVOKERESULT_NO_ERROR;
1818 return INVOKERESULT_GENERIC_ERROR;
1820 return INVOKERESULT_NO_SUCH_METHOD;
1826 if( NPVARIANT_IS_INT32( args[0] ) )
1828 int i_y = NPVARIANT_TO_INT32( args[0] );
1829 libvlc_video_set_marquee_option_as_int(p_md, libvlc_marquee_Y, i_y, &ex);
1830 RETURN_ON_EXCEPTION(this,ex);
1831 return INVOKERESULT_NO_ERROR;
1834 return INVOKERESULT_GENERIC_ERROR;
1836 return INVOKERESULT_NO_SUCH_METHOD;
1839 return INVOKERESULT_NO_SUCH_METHOD;
1842 return INVOKERESULT_GENERIC_ERROR;