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 "npolibvlc.h"
\r
35 #include "vlcplugin.h"
\r
38 ** implementation of libvlc root object
\r
41 LibvlcRootNPObject::LibvlcRootNPObject(NPP instance, const NPClass *aClass) :
\r
42 RuntimeNPObject(instance, aClass)
\r
44 audioObj = NPN_CreateObject(instance, RuntimeNPClass<LibvlcAudioNPObject>::getClass());
\r
45 inputObj = NPN_CreateObject(instance, RuntimeNPClass<LibvlcInputNPObject>::getClass());
\r
46 logObj = NPN_CreateObject(instance, RuntimeNPClass<LibvlcLogNPObject>::getClass());
\r
47 playlistObj = NPN_CreateObject(instance, RuntimeNPClass<LibvlcPlaylistNPObject>::getClass());
\r
48 videoObj = NPN_CreateObject(instance,RuntimeNPClass<LibvlcVideoNPObject>::getClass());
\r
51 LibvlcRootNPObject::~LibvlcRootNPObject()
\r
53 NPN_ReleaseObject(audioObj);
\r
54 NPN_ReleaseObject(inputObj);
\r
55 NPN_ReleaseObject(logObj);
\r
56 NPN_ReleaseObject(playlistObj);
\r
57 NPN_ReleaseObject(videoObj);
\r
60 const NPUTF8 * const LibvlcRootNPObject::propertyNames[] =
\r
70 const int LibvlcRootNPObject::propertyCount = sizeof(LibvlcRootNPObject::propertyNames)/sizeof(NPUTF8 *);
\r
72 enum LibvlcRootNPObjectPropertyIds
\r
79 ID_root_VersionInfo,
\r
82 RuntimeNPObject::InvokeResult LibvlcRootNPObject::getProperty(int index, NPVariant &result)
\r
84 VlcPlugin *p_plugin = reinterpret_cast<VlcPlugin *>(_instance->pdata);
\r
90 OBJECT_TO_NPVARIANT(NPN_RetainObject(audioObj), result);
\r
91 return INVOKERESULT_NO_ERROR;
\r
93 OBJECT_TO_NPVARIANT(NPN_RetainObject(inputObj), result);
\r
94 return INVOKERESULT_NO_ERROR;
\r
96 OBJECT_TO_NPVARIANT(NPN_RetainObject(logObj), result);
\r
97 return INVOKERESULT_NO_ERROR;
\r
98 case ID_root_playlist:
\r
99 OBJECT_TO_NPVARIANT(NPN_RetainObject(playlistObj), result);
\r
100 return INVOKERESULT_NO_ERROR;
\r
101 case ID_root_video:
\r
102 OBJECT_TO_NPVARIANT(NPN_RetainObject(videoObj), result);
\r
103 return INVOKERESULT_NO_ERROR;
\r
104 case ID_root_VersionInfo:
\r
106 int len = strlen(VLC_Version());
\r
107 NPUTF8 *retval =(NPUTF8*)NPN_MemAlloc(len);
\r
110 memcpy(retval, VLC_Version(), len);
\r
111 STRINGN_TO_NPVARIANT(retval, len, result);
\r
115 NULL_TO_NPVARIANT(result);
\r
117 return INVOKERESULT_NO_ERROR;
\r
123 return INVOKERESULT_GENERIC_ERROR;
\r
126 const NPUTF8 * const LibvlcRootNPObject::methodNames[] =
\r
131 const int LibvlcRootNPObject::methodCount = sizeof(LibvlcRootNPObject::methodNames)/sizeof(NPUTF8 *);
\r
133 enum LibvlcRootNPObjectMethodIds
\r
135 ID_root_versionInfo,
\r
138 RuntimeNPObject::InvokeResult LibvlcRootNPObject::invoke(int index, const NPVariant *args, uint32_t argCount, NPVariant &result)
\r
140 VlcPlugin *p_plugin = reinterpret_cast<VlcPlugin *>(_instance->pdata);
\r
143 libvlc_exception_t ex;
\r
144 libvlc_exception_init(&ex);
\r
148 case ID_root_versionInfo:
\r
149 if( argCount == 0 )
\r
151 int len = strlen(VLC_Version());
\r
152 NPUTF8 *retval =(NPUTF8*)NPN_MemAlloc(len);
\r
155 memcpy(retval, VLC_Version(), len);
\r
156 STRINGN_TO_NPVARIANT(retval, len, result);
\r
160 NULL_TO_NPVARIANT(result);
\r
162 return INVOKERESULT_NO_ERROR;
\r
164 return INVOKERESULT_NO_SUCH_METHOD;
\r
169 return INVOKERESULT_GENERIC_ERROR;
\r
173 ** implementation of libvlc audio object
\r
176 const NPUTF8 * const LibvlcAudioNPObject::propertyNames[] =
\r
184 const int LibvlcAudioNPObject::propertyCount = sizeof(LibvlcAudioNPObject::propertyNames)/sizeof(NPUTF8 *);
\r
186 enum LibvlcAudioNPObjectPropertyIds
\r
194 RuntimeNPObject::InvokeResult LibvlcAudioNPObject::getProperty(int index, NPVariant &result)
\r
196 VlcPlugin *p_plugin = reinterpret_cast<VlcPlugin *>(_instance->pdata);
\r
199 libvlc_exception_t ex;
\r
200 libvlc_exception_init(&ex);
\r
202 libvlc_input_t *p_input = libvlc_playlist_get_input(p_plugin->getVLC(), &ex);
\r
203 if( libvlc_exception_raised(&ex) )
\r
205 NPN_SetException(this, libvlc_exception_get_message(&ex));
\r
206 libvlc_exception_clear(&ex);
\r
207 return INVOKERESULT_GENERIC_ERROR;
\r
212 case ID_audio_mute:
\r
214 vlc_bool_t muted = libvlc_audio_get_mute(p_plugin->getVLC(), &ex);
\r
215 libvlc_input_free(p_input);
\r
216 if( libvlc_exception_raised(&ex) )
\r
218 NPN_SetException(this, libvlc_exception_get_message(&ex));
\r
219 libvlc_exception_clear(&ex);
\r
220 return INVOKERESULT_GENERIC_ERROR;
\r
222 BOOLEAN_TO_NPVARIANT(muted, result);
\r
223 return INVOKERESULT_NO_ERROR;
\r
225 case ID_audio_volume:
\r
227 int volume = libvlc_audio_get_volume(p_plugin->getVLC(), &ex);
\r
228 libvlc_input_free(p_input);
\r
229 if( libvlc_exception_raised(&ex) )
\r
231 NPN_SetException(this, libvlc_exception_get_message(&ex));
\r
232 libvlc_exception_clear(&ex);
\r
233 return INVOKERESULT_GENERIC_ERROR;
\r
235 INT32_TO_NPVARIANT(volume, result);
\r
236 return INVOKERESULT_NO_ERROR;
\r
238 case ID_audio_track:
\r
240 int track = libvlc_audio_get_track(p_input, &ex);
\r
241 libvlc_input_free(p_input);
\r
242 if( libvlc_exception_raised(&ex) )
\r
244 NPN_SetException(this, libvlc_exception_get_message(&ex));
\r
245 libvlc_exception_clear(&ex);
\r
246 return INVOKERESULT_GENERIC_ERROR;
\r
248 INT32_TO_NPVARIANT(track, result);
\r
249 return INVOKERESULT_NO_ERROR;
\r
251 case ID_audio_channel:
\r
253 NPUTF8 *psz_channel = libvlc_audio_get_channel(p_plugin->getVLC(), &ex);
\r
254 libvlc_input_free(p_input);
\r
255 if( libvlc_exception_raised(&ex) )
\r
257 NPN_SetException(this, libvlc_exception_get_message(&ex));
\r
258 libvlc_exception_clear(&ex);
\r
259 return INVOKERESULT_GENERIC_ERROR;
\r
262 return INVOKERESULT_GENERIC_ERROR;
\r
264 STRINGZ_TO_NPVARIANT(psz_channel, result);
\r
265 return INVOKERESULT_NO_ERROR;
\r
270 libvlc_input_free(p_input);
\r
272 return INVOKERESULT_GENERIC_ERROR;
\r
275 RuntimeNPObject::InvokeResult LibvlcAudioNPObject::setProperty(int index, const NPVariant &value)
\r
277 VlcPlugin *p_plugin = reinterpret_cast<VlcPlugin *>(_instance->pdata);
\r
280 libvlc_exception_t ex;
\r
281 libvlc_exception_init(&ex);
\r
283 libvlc_input_t *p_input = libvlc_playlist_get_input(p_plugin->getVLC(), &ex);
\r
284 if( libvlc_exception_raised(&ex) )
\r
286 NPN_SetException(this, libvlc_exception_get_message(&ex));
\r
287 libvlc_exception_clear(&ex);
\r
288 return INVOKERESULT_GENERIC_ERROR;
\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 libvlc_input_free(p_input);
\r
299 if( libvlc_exception_raised(&ex) )
\r
301 NPN_SetException(this, libvlc_exception_get_message(&ex));
\r
302 libvlc_exception_clear(&ex);
\r
303 return INVOKERESULT_GENERIC_ERROR;
\r
305 return INVOKERESULT_NO_ERROR;
\r
307 return INVOKERESULT_INVALID_VALUE;
\r
308 case ID_audio_volume:
\r
309 libvlc_input_free(p_input);
\r
310 if( isNumberValue(value) )
\r
312 libvlc_audio_set_volume(p_plugin->getVLC(),
\r
313 numberValue(value), &ex);
\r
314 if( libvlc_exception_raised(&ex) )
\r
316 NPN_SetException(this, libvlc_exception_get_message(&ex));
\r
317 libvlc_exception_clear(&ex);
\r
318 return INVOKERESULT_GENERIC_ERROR;
\r
320 return INVOKERESULT_NO_ERROR;
\r
322 return INVOKERESULT_INVALID_VALUE;
\r
323 case ID_audio_track:
\r
324 if( isNumberValue(value) )
\r
326 libvlc_audio_set_track(p_input,
\r
327 numberValue(value), &ex);
\r
328 libvlc_input_free(p_input);
\r
329 if( libvlc_exception_raised(&ex) )
\r
331 NPN_SetException(this, libvlc_exception_get_message(&ex));
\r
332 libvlc_exception_clear(&ex);
\r
333 return INVOKERESULT_GENERIC_ERROR;
\r
335 return INVOKERESULT_NO_ERROR;
\r
337 libvlc_input_free(p_input);
\r
338 return INVOKERESULT_INVALID_VALUE;
\r
339 case ID_audio_channel:
\r
341 char *psz_channel = NULL;
\r
343 libvlc_input_free(p_input);
\r
344 if( ! NPVARIANT_IS_STRING(value) )
\r
345 return INVOKERESULT_INVALID_VALUE;
\r
347 psz_channel = stringValue(NPVARIANT_TO_STRING(value));
\r
349 return INVOKERESULT_GENERIC_ERROR;
\r
351 libvlc_audio_set_channel(p_plugin->getVLC(), psz_channel, &ex);
\r
353 free( psz_channel );
\r
355 if( libvlc_exception_raised(&ex) )
\r
357 NPN_SetException(this, libvlc_exception_get_message(&ex));
\r
358 libvlc_exception_clear(&ex);
\r
359 return INVOKERESULT_GENERIC_ERROR;
\r
361 return INVOKERESULT_NO_ERROR;
\r
366 libvlc_input_free(p_input);
\r
368 return INVOKERESULT_GENERIC_ERROR;
\r
371 const NPUTF8 * const LibvlcAudioNPObject::methodNames[] =
\r
376 const int LibvlcAudioNPObject::methodCount = sizeof(LibvlcAudioNPObject::methodNames)/sizeof(NPUTF8 *);
\r
378 enum LibvlcAudioNPObjectMethodIds
\r
380 ID_audio_togglemute,
\r
383 RuntimeNPObject::InvokeResult LibvlcAudioNPObject::invoke(int index, const NPVariant *args, uint32_t argCount, NPVariant &result)
\r
385 VlcPlugin *p_plugin = reinterpret_cast<VlcPlugin *>(_instance->pdata);
\r
388 libvlc_exception_t ex;
\r
389 libvlc_exception_init(&ex);
\r
393 case ID_audio_togglemute:
\r
394 if( argCount == 0 )
\r
396 libvlc_audio_toggle_mute(p_plugin->getVLC(), &ex);
\r
397 if( libvlc_exception_raised(&ex) )
\r
399 NPN_SetException(this, libvlc_exception_get_message(&ex));
\r
400 libvlc_exception_clear(&ex);
\r
401 return INVOKERESULT_GENERIC_ERROR;
\r
405 VOID_TO_NPVARIANT(result);
\r
406 return INVOKERESULT_NO_ERROR;
\r
409 return INVOKERESULT_NO_SUCH_METHOD;
\r
414 return INVOKERESULT_GENERIC_ERROR;
\r
418 ** implementation of libvlc input object
\r
421 const NPUTF8 * const LibvlcInputNPObject::propertyNames[] =
\r
432 const int LibvlcInputNPObject::propertyCount = sizeof(LibvlcInputNPObject::propertyNames)/sizeof(NPUTF8 *);
\r
434 enum LibvlcInputNPObjectPropertyIds
\r
445 RuntimeNPObject::InvokeResult LibvlcInputNPObject::getProperty(int index, NPVariant &result)
\r
447 VlcPlugin *p_plugin = reinterpret_cast<VlcPlugin *>(_instance->pdata);
\r
450 libvlc_exception_t ex;
\r
451 libvlc_exception_init(&ex);
\r
453 libvlc_input_t *p_input = libvlc_playlist_get_input(p_plugin->getVLC(), &ex);
\r
454 if( libvlc_exception_raised(&ex) )
\r
456 if( index != ID_input_state )
\r
458 NPN_SetException(this, libvlc_exception_get_message(&ex));
\r
459 libvlc_exception_clear(&ex);
\r
460 return INVOKERESULT_GENERIC_ERROR;
\r
464 /* for input state, return CLOSED rather than an exception */
\r
465 INT32_TO_NPVARIANT(0, result);
\r
466 return INVOKERESULT_NO_ERROR;
\r
472 case ID_input_length:
\r
474 double val = (double)libvlc_input_get_length(p_input, &ex);
\r
475 libvlc_input_free(p_input);
\r
476 if( libvlc_exception_raised(&ex) )
\r
478 NPN_SetException(this, libvlc_exception_get_message(&ex));
\r
479 libvlc_exception_clear(&ex);
\r
480 return INVOKERESULT_GENERIC_ERROR;
\r
482 DOUBLE_TO_NPVARIANT(val, result);
\r
483 return INVOKERESULT_NO_ERROR;
\r
485 case ID_input_position:
\r
487 double val = libvlc_input_get_position(p_input, &ex);
\r
488 libvlc_input_free(p_input);
\r
489 if( libvlc_exception_raised(&ex) )
\r
491 NPN_SetException(this, libvlc_exception_get_message(&ex));
\r
492 libvlc_exception_clear(&ex);
\r
493 return INVOKERESULT_GENERIC_ERROR;
\r
495 DOUBLE_TO_NPVARIANT(val, result);
\r
496 return INVOKERESULT_NO_ERROR;
\r
498 case ID_input_time:
\r
500 double val = (double)libvlc_input_get_time(p_input, &ex);
\r
501 libvlc_input_free(p_input);
\r
502 if( libvlc_exception_raised(&ex) )
\r
504 NPN_SetException(this, libvlc_exception_get_message(&ex));
\r
505 libvlc_exception_clear(&ex);
\r
506 return INVOKERESULT_GENERIC_ERROR;
\r
508 DOUBLE_TO_NPVARIANT(val, result);
\r
509 return INVOKERESULT_NO_ERROR;
\r
511 case ID_input_state:
\r
513 int val = libvlc_input_get_state(p_input, &ex);
\r
514 libvlc_input_free(p_input);
\r
515 if( libvlc_exception_raised(&ex) )
\r
517 NPN_SetException(this, libvlc_exception_get_message(&ex));
\r
518 libvlc_exception_clear(&ex);
\r
519 return INVOKERESULT_GENERIC_ERROR;
\r
521 INT32_TO_NPVARIANT(val, result);
\r
522 return INVOKERESULT_NO_ERROR;
\r
524 case ID_input_rate:
\r
526 float val = libvlc_input_get_rate(p_input, &ex);
\r
527 libvlc_input_free(p_input);
\r
528 if( libvlc_exception_raised(&ex) )
\r
530 NPN_SetException(this, libvlc_exception_get_message(&ex));
\r
531 libvlc_exception_clear(&ex);
\r
532 return INVOKERESULT_GENERIC_ERROR;
\r
534 DOUBLE_TO_NPVARIANT(val, result);
\r
535 return INVOKERESULT_NO_ERROR;
\r
539 double val = libvlc_input_get_fps(p_input, &ex);
\r
540 libvlc_input_free(p_input);
\r
541 if( libvlc_exception_raised(&ex) )
\r
543 NPN_SetException(this, libvlc_exception_get_message(&ex));
\r
544 libvlc_exception_clear(&ex);
\r
545 return INVOKERESULT_GENERIC_ERROR;
\r
547 DOUBLE_TO_NPVARIANT(val, result);
\r
548 return INVOKERESULT_NO_ERROR;
\r
550 case ID_input_hasvout:
\r
552 vlc_bool_t val = libvlc_input_has_vout(p_input, &ex);
\r
553 libvlc_input_free(p_input);
\r
554 if( libvlc_exception_raised(&ex) )
\r
556 NPN_SetException(this, libvlc_exception_get_message(&ex));
\r
557 libvlc_exception_clear(&ex);
\r
558 return INVOKERESULT_GENERIC_ERROR;
\r
560 BOOLEAN_TO_NPVARIANT(val, result);
\r
561 return INVOKERESULT_NO_ERROR;
\r
566 libvlc_input_free(p_input);
\r
568 return INVOKERESULT_GENERIC_ERROR;
\r
571 RuntimeNPObject::InvokeResult LibvlcInputNPObject::setProperty(int index, const NPVariant &value)
\r
573 VlcPlugin *p_plugin = reinterpret_cast<VlcPlugin *>(_instance->pdata);
\r
576 libvlc_exception_t ex;
\r
577 libvlc_exception_init(&ex);
\r
579 libvlc_input_t *p_input = libvlc_playlist_get_input(p_plugin->getVLC(), &ex);
\r
580 if( libvlc_exception_raised(&ex) )
\r
582 NPN_SetException(this, libvlc_exception_get_message(&ex));
\r
583 libvlc_exception_clear(&ex);
\r
584 return INVOKERESULT_GENERIC_ERROR;
\r
589 case ID_input_position:
\r
591 if( ! NPVARIANT_IS_DOUBLE(value) )
\r
593 libvlc_input_free(p_input);
\r
594 return INVOKERESULT_INVALID_VALUE;
\r
597 float val = (float)NPVARIANT_TO_DOUBLE(value);
\r
598 libvlc_input_set_position(p_input, val, &ex);
\r
599 libvlc_input_free(p_input);
\r
600 if( libvlc_exception_raised(&ex) )
\r
602 NPN_SetException(this, libvlc_exception_get_message(&ex));
\r
603 libvlc_exception_clear(&ex);
\r
604 return INVOKERESULT_GENERIC_ERROR;
\r
606 return INVOKERESULT_NO_ERROR;
\r
608 case ID_input_time:
\r
611 if( NPVARIANT_IS_INT32(value) )
\r
612 val = (vlc_int64_t)NPVARIANT_TO_INT32(value);
\r
613 else if( NPVARIANT_IS_DOUBLE(value) )
\r
614 val = (vlc_int64_t)NPVARIANT_TO_DOUBLE(value);
\r
617 libvlc_input_free(p_input);
\r
618 return INVOKERESULT_INVALID_VALUE;
\r
621 libvlc_input_set_time(p_input, val, &ex);
\r
622 libvlc_input_free(p_input);
\r
623 if( libvlc_exception_raised(&ex) )
\r
625 NPN_SetException(this, libvlc_exception_get_message(&ex));
\r
626 libvlc_exception_clear(&ex);
\r
627 return INVOKERESULT_GENERIC_ERROR;
\r
629 return INVOKERESULT_NO_ERROR;
\r
631 case ID_input_rate:
\r
634 if( NPVARIANT_IS_INT32(value) )
\r
635 val = (float)NPVARIANT_TO_INT32(value);
\r
636 else if( NPVARIANT_IS_DOUBLE(value) )
\r
637 val = (float)NPVARIANT_TO_DOUBLE(value);
\r
640 libvlc_input_free(p_input);
\r
641 return INVOKERESULT_INVALID_VALUE;
\r
644 libvlc_input_set_rate(p_input, val, &ex);
\r
645 libvlc_input_free(p_input);
\r
646 if( libvlc_exception_raised(&ex) )
\r
648 NPN_SetException(this, libvlc_exception_get_message(&ex));
\r
649 libvlc_exception_clear(&ex);
\r
650 return INVOKERESULT_GENERIC_ERROR;
\r
652 return INVOKERESULT_NO_ERROR;
\r
657 libvlc_input_free(p_input);
\r
659 return INVOKERESULT_GENERIC_ERROR;
\r
662 const NPUTF8 * const LibvlcInputNPObject::methodNames[] =
\r
667 const int LibvlcInputNPObject::methodCount = sizeof(LibvlcInputNPObject::methodNames)/sizeof(NPUTF8 *);
\r
670 ** implementation of libvlc message object
\r
673 const NPUTF8 * const LibvlcMessageNPObject::propertyNames[] =
\r
682 const int LibvlcMessageNPObject::propertyCount = sizeof(LibvlcMessageNPObject::propertyNames)/sizeof(NPUTF8 *);
\r
684 enum LibvlcMessageNPObjectPropertyIds
\r
686 ID_message_severity,
\r
690 ID_message_message,
\r
693 RuntimeNPObject::InvokeResult LibvlcMessageNPObject::getProperty(int index, NPVariant &result)
\r
695 VlcPlugin *p_plugin = reinterpret_cast<VlcPlugin *>(_instance->pdata);
\r
700 case ID_message_severity:
\r
702 INT32_TO_NPVARIANT(_msg.i_severity, result);
\r
703 return INVOKERESULT_NO_ERROR;
\r
705 case ID_message_type:
\r
707 if( _msg.psz_type )
\r
709 int len = strlen(_msg.psz_type);
\r
710 NPUTF8* retval = (NPUTF8*)NPN_MemAlloc(len);
\r
713 memcpy(retval, _msg.psz_type, len);
\r
714 STRINGN_TO_NPVARIANT(retval, len, result);
\r
719 NULL_TO_NPVARIANT(result);
\r
721 return INVOKERESULT_NO_ERROR;
\r
723 case ID_message_name:
\r
725 if( _msg.psz_name )
\r
727 int len = strlen(_msg.psz_name);
\r
728 NPUTF8* retval = (NPUTF8*)NPN_MemAlloc(len);
\r
731 memcpy(retval, _msg.psz_name, len);
\r
732 STRINGN_TO_NPVARIANT(retval, len, result);
\r
737 NULL_TO_NPVARIANT(result);
\r
739 return INVOKERESULT_NO_ERROR;
\r
741 case ID_message_header:
\r
743 if( _msg.psz_header )
\r
745 int len = strlen(_msg.psz_header);
\r
746 NPUTF8* retval = (NPUTF8*)NPN_MemAlloc(len);
\r
749 memcpy(retval, _msg.psz_header, len);
\r
750 STRINGN_TO_NPVARIANT(retval, len, result);
\r
755 NULL_TO_NPVARIANT(result);
\r
757 return INVOKERESULT_NO_ERROR;
\r
759 case ID_message_message:
\r
761 if( _msg.psz_message )
\r
763 int len = strlen(_msg.psz_message);
\r
764 NPUTF8* retval = (NPUTF8*)NPN_MemAlloc(len);
\r
767 memcpy(retval, _msg.psz_message, len);
\r
768 STRINGN_TO_NPVARIANT(retval, len, result);
\r
773 NULL_TO_NPVARIANT(result);
\r
775 return INVOKERESULT_NO_ERROR;
\r
781 return INVOKERESULT_GENERIC_ERROR;
\r
784 const NPUTF8 * const LibvlcMessageNPObject::methodNames[] =
\r
789 const int LibvlcMessageNPObject::methodCount = sizeof(LibvlcMessageNPObject::methodNames)/sizeof(NPUTF8 *);
\r
792 ** implementation of libvlc message iterator object
\r
795 LibvlcMessageIteratorNPObject::LibvlcMessageIteratorNPObject(NPP instance, const NPClass *aClass) :
\r
796 RuntimeNPObject(instance, aClass),
\r
799 VlcPlugin *p_plugin = reinterpret_cast<VlcPlugin *>(_instance->pdata);
\r
802 libvlc_log_t *p_log = p_plugin->getLog();
\r
805 _p_iter = libvlc_log_get_iterator(p_log, NULL);
\r
810 LibvlcMessageIteratorNPObject::~LibvlcMessageIteratorNPObject()
\r
813 libvlc_log_iterator_free(_p_iter, NULL);
\r
816 const NPUTF8 * const LibvlcMessageIteratorNPObject::propertyNames[] =
\r
821 const int LibvlcMessageIteratorNPObject::propertyCount = sizeof(LibvlcMessageIteratorNPObject::propertyNames)/sizeof(NPUTF8 *);
\r
823 enum LibvlcMessageIteratorNPObjectPropertyIds
\r
825 ID_messageiterator_hasNext,
\r
828 RuntimeNPObject::InvokeResult LibvlcMessageIteratorNPObject::getProperty(int index, NPVariant &result)
\r
830 VlcPlugin *p_plugin = reinterpret_cast<VlcPlugin *>(_instance->pdata);
\r
835 case ID_messageiterator_hasNext:
\r
837 if( _p_iter && p_plugin->getLog() )
\r
839 libvlc_exception_t ex;
\r
840 libvlc_exception_init(&ex);
\r
842 BOOLEAN_TO_NPVARIANT(libvlc_log_iterator_has_next(_p_iter, &ex), result);
\r
843 if( libvlc_exception_raised(&ex) )
\r
845 NPN_SetException(this, libvlc_exception_get_message(&ex));
\r
846 libvlc_exception_clear(&ex);
\r
847 return INVOKERESULT_GENERIC_ERROR;
\r
852 BOOLEAN_TO_NPVARIANT(0, result);
\r
854 return INVOKERESULT_NO_ERROR;
\r
860 return INVOKERESULT_GENERIC_ERROR;
\r
863 const NPUTF8 * const LibvlcMessageIteratorNPObject::methodNames[] =
\r
868 const int LibvlcMessageIteratorNPObject::methodCount = sizeof(LibvlcMessageIteratorNPObject::methodNames)/sizeof(NPUTF8 *);
\r
870 enum LibvlcMessageIteratorNPObjectMethodIds
\r
872 ID_messageiterator_next,
\r
875 RuntimeNPObject::InvokeResult LibvlcMessageIteratorNPObject::invoke(int index, const NPVariant *args, uint32_t argCount, NPVariant &result)
\r
877 VlcPlugin *p_plugin = reinterpret_cast<VlcPlugin *>(_instance->pdata);
\r
880 libvlc_exception_t ex;
\r
881 libvlc_exception_init(&ex);
\r
885 case ID_messageiterator_next:
\r
886 if( argCount == 0 )
\r
888 if( _p_iter && p_plugin->getLog() )
\r
890 struct libvlc_log_message_t buffer;
\r
892 buffer.sizeof_msg = sizeof(buffer);
\r
894 libvlc_log_iterator_next(_p_iter, &buffer, &ex);
\r
895 if( libvlc_exception_raised(&ex) )
\r
897 NPN_SetException(this, libvlc_exception_get_message(&ex));
\r
898 libvlc_exception_clear(&ex);
\r
899 return INVOKERESULT_GENERIC_ERROR;
\r
903 LibvlcMessageNPObject* message =
\r
904 static_cast<LibvlcMessageNPObject*>(NPN_CreateObject(_instance, RuntimeNPClass<LibvlcMessageNPObject>::getClass()));
\r
907 message->setMessage(buffer);
\r
908 OBJECT_TO_NPVARIANT(message, result);
\r
909 return INVOKERESULT_NO_ERROR;
\r
911 return INVOKERESULT_OUT_OF_MEMORY;
\r
914 return INVOKERESULT_GENERIC_ERROR;
\r
916 return INVOKERESULT_NO_SUCH_METHOD;
\r
921 return INVOKERESULT_GENERIC_ERROR;
\r
925 ** implementation of libvlc message object
\r
928 const NPUTF8 * const LibvlcMessagesNPObject::propertyNames[] =
\r
933 const int LibvlcMessagesNPObject::propertyCount = sizeof(LibvlcMessagesNPObject::propertyNames)/sizeof(NPUTF8 *);
\r
935 enum LibvlcMessagesNPObjectPropertyIds
\r
940 RuntimeNPObject::InvokeResult LibvlcMessagesNPObject::getProperty(int index, NPVariant &result)
\r
942 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 VlcPlugin *p_plugin = reinterpret_cast<VlcPlugin *>(_instance->pdata);
\r
995 libvlc_exception_t ex;
\r
996 libvlc_exception_init(&ex);
\r
1000 case ID_messages_clear:
\r
1001 if( argCount == 0 )
\r
1003 libvlc_log_t *p_log = p_plugin->getLog();
\r
1006 libvlc_log_clear(p_log, &ex);
\r
1007 if( libvlc_exception_raised(&ex) )
\r
1009 NPN_SetException(this, libvlc_exception_get_message(&ex));
\r
1010 libvlc_exception_clear(&ex);
\r
1011 return INVOKERESULT_GENERIC_ERROR;
\r
1014 return INVOKERESULT_NO_ERROR;
\r
1016 return INVOKERESULT_NO_SUCH_METHOD;
\r
1018 case ID_messages_iterator:
\r
1019 if( argCount == 0 )
\r
1021 LibvlcMessageIteratorNPObject* iter =
\r
1022 static_cast<LibvlcMessageIteratorNPObject*>(NPN_CreateObject(_instance, RuntimeNPClass<LibvlcMessageIteratorNPObject>::getClass()));
\r
1025 OBJECT_TO_NPVARIANT(iter, result);
\r
1026 return INVOKERESULT_NO_ERROR;
\r
1028 return INVOKERESULT_OUT_OF_MEMORY;
\r
1030 return INVOKERESULT_NO_SUCH_METHOD;
\r
1036 return INVOKERESULT_GENERIC_ERROR;
\r
1041 ** implementation of libvlc message object
\r
1045 LibvlcLogNPObject::LibvlcLogNPObject(NPP instance, const NPClass *aClass) :
\r
1046 RuntimeNPObject(instance, aClass)
\r
1048 _p_vlcmessages = static_cast<LibvlcMessagesNPObject*>(NPN_CreateObject(instance, RuntimeNPClass<LibvlcMessagesNPObject>::getClass()));
\r
1051 LibvlcLogNPObject::~LibvlcLogNPObject()
\r
1053 NPN_ReleaseObject(_p_vlcmessages);
\r
1056 const NPUTF8 * const LibvlcLogNPObject::propertyNames[] =
\r
1062 const int LibvlcLogNPObject::propertyCount = sizeof(LibvlcLogNPObject::propertyNames)/sizeof(NPUTF8 *);
\r
1064 enum LibvlcLogNPObjectPropertyIds
\r
1070 RuntimeNPObject::InvokeResult LibvlcLogNPObject::getProperty(int index, NPVariant &result)
\r
1072 VlcPlugin *p_plugin = reinterpret_cast<VlcPlugin *>(_instance->pdata);
\r
1075 libvlc_exception_t ex;
\r
1076 libvlc_exception_init(&ex);
\r
1080 case ID_log_messages:
\r
1082 OBJECT_TO_NPVARIANT(NPN_RetainObject(_p_vlcmessages), result);
\r
1083 return INVOKERESULT_NO_ERROR;
\r
1085 case ID_log_verbosity:
\r
1087 if( p_plugin->getLog() )
\r
1089 INT32_TO_NPVARIANT(libvlc_get_log_verbosity(p_plugin->getVLC(),
\r
1091 if( libvlc_exception_raised(&ex) )
\r
1093 NPN_SetException(this, libvlc_exception_get_message(&ex));
\r
1094 libvlc_exception_clear(&ex);
\r
1095 return INVOKERESULT_GENERIC_ERROR;
\r
1100 /* log is not enabled, return -1 */
\r
1101 DOUBLE_TO_NPVARIANT(-1.0, result);
\r
1103 return INVOKERESULT_NO_ERROR;
\r
1109 return INVOKERESULT_GENERIC_ERROR;
\r
1112 RuntimeNPObject::InvokeResult LibvlcLogNPObject::setProperty(int index, const NPVariant &value)
\r
1114 VlcPlugin *p_plugin = reinterpret_cast<VlcPlugin *>(_instance->pdata);
\r
1117 libvlc_exception_t ex;
\r
1118 libvlc_exception_init(&ex);
\r
1122 case ID_log_verbosity:
\r
1123 if( isNumberValue(value) )
\r
1125 libvlc_instance_t* p_libvlc = p_plugin->getVLC();
\r
1126 libvlc_log_t *p_log = p_plugin->getLog();
\r
1127 int verbosity = numberValue(value);
\r
1128 if( verbosity >= 0 )
\r
1132 p_log = libvlc_log_open(p_libvlc, &ex);
\r
1133 if( libvlc_exception_raised(&ex) )
\r
1135 NPN_SetException(this, libvlc_exception_get_message(&ex));
\r
1136 libvlc_exception_clear(&ex);
\r
1137 return INVOKERESULT_GENERIC_ERROR;
\r
1139 p_plugin->setLog(p_log);
\r
1141 libvlc_set_log_verbosity(p_libvlc, (unsigned)verbosity, &ex);
\r
1142 if( libvlc_exception_raised(&ex) )
\r
1144 NPN_SetException(this, libvlc_exception_get_message(&ex));
\r
1145 libvlc_exception_clear(&ex);
\r
1146 return INVOKERESULT_GENERIC_ERROR;
\r
1151 /* close log when verbosity is set to -1 */
\r
1152 p_plugin->setLog(NULL);
\r
1153 libvlc_log_close(p_log, &ex);
\r
1154 if( libvlc_exception_raised(&ex) )
\r
1156 NPN_SetException(this, libvlc_exception_get_message(&ex));
\r
1157 libvlc_exception_clear(&ex);
\r
1158 return INVOKERESULT_GENERIC_ERROR;
\r
1161 return INVOKERESULT_NO_ERROR;
\r
1163 return INVOKERESULT_INVALID_VALUE;
\r
1168 return INVOKERESULT_GENERIC_ERROR;
\r
1171 const NPUTF8 * const LibvlcLogNPObject::methodNames[] =
\r
1176 const int LibvlcLogNPObject::methodCount = sizeof(LibvlcLogNPObject::methodNames)/sizeof(NPUTF8 *);
\r
1179 ** implementation of libvlc playlist items object
\r
1182 const NPUTF8 * const LibvlcPlaylistItemsNPObject::propertyNames[] =
\r
1187 const int LibvlcPlaylistItemsNPObject::propertyCount = sizeof(LibvlcPlaylistItemsNPObject::propertyNames)/sizeof(NPUTF8 *);
\r
1189 enum LibvlcPlaylistItemsNPObjectPropertyIds
\r
1191 ID_playlistitems_count,
\r
1194 RuntimeNPObject::InvokeResult LibvlcPlaylistItemsNPObject::getProperty(int index, NPVariant &result)
\r
1196 VlcPlugin *p_plugin = reinterpret_cast<VlcPlugin *>(_instance->pdata);
\r
1199 libvlc_exception_t ex;
\r
1200 libvlc_exception_init(&ex);
\r
1204 case ID_playlistitems_count:
\r
1206 int val = libvlc_playlist_items_count(p_plugin->getVLC(), &ex);
\r
1207 if( libvlc_exception_raised(&ex) )
\r
1209 NPN_SetException(this, libvlc_exception_get_message(&ex));
\r
1210 libvlc_exception_clear(&ex);
\r
1211 return INVOKERESULT_GENERIC_ERROR;
\r
1213 INT32_TO_NPVARIANT(val, result);
\r
1214 return INVOKERESULT_NO_ERROR;
\r
1220 return INVOKERESULT_GENERIC_ERROR;
\r
1223 const NPUTF8 * const LibvlcPlaylistItemsNPObject::methodNames[] =
\r
1229 const int LibvlcPlaylistItemsNPObject::methodCount = sizeof(LibvlcPlaylistItemsNPObject::methodNames)/sizeof(NPUTF8 *);
\r
1231 enum LibvlcPlaylistItemsNPObjectMethodIds
\r
1233 ID_playlistitems_clear,
\r
1234 ID_playlistitems_remove,
\r
1237 RuntimeNPObject::InvokeResult LibvlcPlaylistItemsNPObject::invoke(int index, const NPVariant *args, uint32_t argCount, NPVariant &result)
\r
1239 VlcPlugin *p_plugin = reinterpret_cast<VlcPlugin *>(_instance->pdata);
\r
1242 libvlc_exception_t ex;
\r
1243 libvlc_exception_init(&ex);
\r
1247 case ID_playlistitems_clear:
\r
1248 if( argCount == 0 )
\r
1250 libvlc_playlist_clear(p_plugin->getVLC(), &ex);
\r
1251 if( libvlc_exception_raised(&ex) )
\r
1253 NPN_SetException(this, libvlc_exception_get_message(&ex));
\r
1254 libvlc_exception_clear(&ex);
\r
1255 return INVOKERESULT_GENERIC_ERROR;
\r
1259 VOID_TO_NPVARIANT(result);
\r
1260 return INVOKERESULT_NO_ERROR;
\r
1263 return INVOKERESULT_NO_SUCH_METHOD;
\r
1264 case ID_playlistitems_remove:
\r
1265 if( (argCount == 1) && isNumberValue(args[0]) )
\r
1267 libvlc_playlist_delete_item(p_plugin->getVLC(), numberValue(args[0]), &ex);
\r
1268 if( libvlc_exception_raised(&ex) )
\r
1270 NPN_SetException(this, libvlc_exception_get_message(&ex));
\r
1271 libvlc_exception_clear(&ex);
\r
1272 return INVOKERESULT_GENERIC_ERROR;
\r
1276 VOID_TO_NPVARIANT(result);
\r
1277 return INVOKERESULT_NO_ERROR;
\r
1280 return INVOKERESULT_NO_SUCH_METHOD;
\r
1285 return INVOKERESULT_GENERIC_ERROR;
\r
1289 ** implementation of libvlc playlist object
\r
1293 LibvlcPlaylistNPObject::LibvlcPlaylistNPObject(NPP instance, const NPClass *aClass) :
\r
1294 RuntimeNPObject(instance, aClass)
\r
1296 _p_vlcplaylistitems = static_cast<LibvlcPlaylistItemsNPObject*>(NPN_CreateObject(instance, RuntimeNPClass<LibvlcPlaylistItemsNPObject>::getClass()));
\r
1299 LibvlcPlaylistNPObject::~LibvlcPlaylistNPObject()
\r
1301 NPN_ReleaseObject(_p_vlcplaylistitems);
\r
1304 const NPUTF8 * const LibvlcPlaylistNPObject::propertyNames[] =
\r
1306 "itemCount", /* deprecated */
\r
1311 const int LibvlcPlaylistNPObject::propertyCount = sizeof(LibvlcPlaylistNPObject::propertyNames)/sizeof(NPUTF8 *);
\r
1313 enum LibvlcPlaylistNPObjectPropertyIds
\r
1315 ID_playlist_itemcount,
\r
1316 ID_playlist_isplaying,
\r
1317 ID_playlist_items,
\r
1320 RuntimeNPObject::InvokeResult LibvlcPlaylistNPObject::getProperty(int index, NPVariant &result)
\r
1322 VlcPlugin *p_plugin = reinterpret_cast<VlcPlugin *>(_instance->pdata);
\r
1325 libvlc_exception_t ex;
\r
1326 libvlc_exception_init(&ex);
\r
1330 case ID_playlist_itemcount: /* deprecated */
\r
1332 int val = libvlc_playlist_items_count(p_plugin->getVLC(), &ex);
\r
1333 if( libvlc_exception_raised(&ex) )
\r
1335 NPN_SetException(this, libvlc_exception_get_message(&ex));
\r
1336 libvlc_exception_clear(&ex);
\r
1337 return INVOKERESULT_GENERIC_ERROR;
\r
1339 INT32_TO_NPVARIANT(val, result);
\r
1340 return INVOKERESULT_NO_ERROR;
\r
1342 case ID_playlist_isplaying:
\r
1344 int val = libvlc_playlist_isplaying(p_plugin->getVLC(), &ex);
\r
1345 if( libvlc_exception_raised(&ex) )
\r
1347 NPN_SetException(this, libvlc_exception_get_message(&ex));
\r
1348 libvlc_exception_clear(&ex);
\r
1349 return INVOKERESULT_GENERIC_ERROR;
\r
1351 BOOLEAN_TO_NPVARIANT(val, result);
\r
1352 return INVOKERESULT_NO_ERROR;
\r
1354 case ID_playlist_items:
\r
1356 OBJECT_TO_NPVARIANT(NPN_RetainObject(_p_vlcplaylistitems), result);
\r
1357 return INVOKERESULT_NO_ERROR;
\r
1363 return INVOKERESULT_GENERIC_ERROR;
\r
1366 const NPUTF8 * const LibvlcPlaylistNPObject::methodNames[] =
\r
1375 "clear", /* deprecated */
\r
1376 "removeItem", /* deprecated */
\r
1379 const int LibvlcPlaylistNPObject::methodCount = sizeof(LibvlcPlaylistNPObject::methodNames)/sizeof(NPUTF8 *);
\r
1381 enum LibvlcPlaylistNPObjectMethodIds
\r
1385 ID_playlist_playItem,
\r
1386 ID_playlist_togglepause,
\r
1390 ID_playlist_clear,
\r
1391 ID_playlist_removeitem
\r
1394 RuntimeNPObject::InvokeResult LibvlcPlaylistNPObject::invoke(int index, const NPVariant *args, uint32_t argCount, NPVariant &result)
\r
1396 VlcPlugin *p_plugin = reinterpret_cast<VlcPlugin *>(_instance->pdata);
\r
1399 libvlc_exception_t ex;
\r
1400 libvlc_exception_init(&ex);
\r
1404 case ID_playlist_add:
\r
1406 if( (argCount < 1) || (argCount > 3) )
\r
1407 return INVOKERESULT_NO_SUCH_METHOD;
\r
1412 if( NPVARIANT_IS_STRING(args[0]) )
\r
1414 char *s = stringValue(NPVARIANT_TO_STRING(args[0]));
\r
1417 url = p_plugin->getAbsoluteURL(s);
\r
1421 // problem with combining url, use argument
\r
1425 return INVOKERESULT_OUT_OF_MEMORY;
\r
1428 return INVOKERESULT_NO_SUCH_METHOD;
\r
1430 char *name = NULL;
\r
1432 // grab name if available
\r
1433 if( argCount > 1 )
\r
1435 if( NPVARIANT_IS_NULL(args[1]) )
\r
1439 else if( NPVARIANT_IS_STRING(args[1]) )
\r
1441 name = stringValue(NPVARIANT_TO_STRING(args[0]));
\r
1444 return INVOKERESULT_NO_SUCH_METHOD;
\r
1447 int i_options = 0;
\r
1448 char** ppsz_options = NULL;
\r
1450 // grab options if available
\r
1451 if( argCount > 2 )
\r
1453 if( NPVARIANT_IS_NULL(args[2]) )
\r
1457 else if( NPVARIANT_IS_STRING(args[2]) )
\r
1459 parseOptions(NPVARIANT_TO_STRING(args[2]), &i_options, &ppsz_options);
\r
1462 else if( NPVARIANT_IS_OBJECT(args[2]) )
\r
1464 parseOptions(NPVARIANT_TO_OBJECT(args[2]), &i_options, &ppsz_options);
\r
1468 int item = libvlc_playlist_add_extended(p_plugin->getVLC(),
\r
1472 const_cast<const char **>(ppsz_options),
\r
1476 for( int i=0; i< i_options; ++i )
\r
1478 if( ppsz_options[i] )
\r
1479 free(ppsz_options[i]);
\r
1481 if( ppsz_options )
\r
1482 free(ppsz_options);
\r
1483 if( libvlc_exception_raised(&ex) )
\r
1485 NPN_SetException(this, libvlc_exception_get_message(&ex));
\r
1486 libvlc_exception_clear(&ex);
\r
1487 return INVOKERESULT_GENERIC_ERROR;
\r
1491 INT32_TO_NPVARIANT(item, result);
\r
1492 return INVOKERESULT_NO_ERROR;
\r
1495 case ID_playlist_play:
\r
1496 if( argCount == 0 )
\r
1498 libvlc_playlist_play(p_plugin->getVLC(), -1, 0, NULL, &ex);
\r
1499 if( libvlc_exception_raised(&ex) )
\r
1501 NPN_SetException(this, libvlc_exception_get_message(&ex));
\r
1502 libvlc_exception_clear(&ex);
\r
1503 return INVOKERESULT_GENERIC_ERROR;
\r
1507 VOID_TO_NPVARIANT(result);
\r
1508 return INVOKERESULT_NO_ERROR;
\r
1511 return INVOKERESULT_NO_SUCH_METHOD;
\r
1512 case ID_playlist_playItem:
\r
1513 if( (argCount == 1) && isNumberValue(args[0]) )
\r
1515 libvlc_playlist_play(p_plugin->getVLC(), numberValue(args[0]), 0, NULL, &ex);
\r
1516 if( libvlc_exception_raised(&ex) )
\r
1518 NPN_SetException(this, libvlc_exception_get_message(&ex));
\r
1519 libvlc_exception_clear(&ex);
\r
1520 return INVOKERESULT_GENERIC_ERROR;
\r
1524 VOID_TO_NPVARIANT(result);
\r
1525 return INVOKERESULT_NO_ERROR;
\r
1528 return INVOKERESULT_NO_SUCH_METHOD;
\r
1529 case ID_playlist_togglepause:
\r
1530 if( argCount == 0 )
\r
1532 libvlc_playlist_pause(p_plugin->getVLC(), &ex);
\r
1533 if( libvlc_exception_raised(&ex) )
\r
1535 NPN_SetException(this, libvlc_exception_get_message(&ex));
\r
1536 libvlc_exception_clear(&ex);
\r
1537 return INVOKERESULT_GENERIC_ERROR;
\r
1541 VOID_TO_NPVARIANT(result);
\r
1542 return INVOKERESULT_NO_ERROR;
\r
1545 return INVOKERESULT_NO_SUCH_METHOD;
\r
1546 case ID_playlist_stop:
\r
1547 if( argCount == 0 )
\r
1549 libvlc_playlist_stop(p_plugin->getVLC(), &ex);
\r
1550 if( libvlc_exception_raised(&ex) )
\r
1552 NPN_SetException(this, libvlc_exception_get_message(&ex));
\r
1553 libvlc_exception_clear(&ex);
\r
1554 return INVOKERESULT_GENERIC_ERROR;
\r
1558 VOID_TO_NPVARIANT(result);
\r
1559 return INVOKERESULT_NO_ERROR;
\r
1562 return INVOKERESULT_NO_SUCH_METHOD;
\r
1563 case ID_playlist_next:
\r
1564 if( argCount == 0 )
\r
1566 libvlc_playlist_next(p_plugin->getVLC(), &ex);
\r
1567 if( libvlc_exception_raised(&ex) )
\r
1569 NPN_SetException(this, libvlc_exception_get_message(&ex));
\r
1570 libvlc_exception_clear(&ex);
\r
1571 return INVOKERESULT_GENERIC_ERROR;
\r
1575 VOID_TO_NPVARIANT(result);
\r
1576 return INVOKERESULT_NO_ERROR;
\r
1579 return INVOKERESULT_NO_SUCH_METHOD;
\r
1580 case ID_playlist_prev:
\r
1581 if( argCount == 0 )
\r
1583 libvlc_playlist_prev(p_plugin->getVLC(), &ex);
\r
1584 if( libvlc_exception_raised(&ex) )
\r
1586 NPN_SetException(this, libvlc_exception_get_message(&ex));
\r
1587 libvlc_exception_clear(&ex);
\r
1588 return INVOKERESULT_GENERIC_ERROR;
\r
1592 VOID_TO_NPVARIANT(result);
\r
1593 return INVOKERESULT_NO_ERROR;
\r
1596 return INVOKERESULT_NO_SUCH_METHOD;
\r
1597 case ID_playlist_clear: /* deprecated */
\r
1598 if( argCount == 0 )
\r
1600 libvlc_playlist_clear(p_plugin->getVLC(), &ex);
\r
1601 if( libvlc_exception_raised(&ex) )
\r
1603 NPN_SetException(this, libvlc_exception_get_message(&ex));
\r
1604 libvlc_exception_clear(&ex);
\r
1605 return INVOKERESULT_GENERIC_ERROR;
\r
1609 VOID_TO_NPVARIANT(result);
\r
1610 return INVOKERESULT_NO_ERROR;
\r
1613 return INVOKERESULT_NO_SUCH_METHOD;
\r
1614 case ID_playlist_removeitem: /* deprecated */
\r
1615 if( (argCount == 1) && isNumberValue(args[0]) )
\r
1617 libvlc_playlist_delete_item(p_plugin->getVLC(), numberValue(args[0]), &ex);
\r
1618 if( libvlc_exception_raised(&ex) )
\r
1620 NPN_SetException(this, libvlc_exception_get_message(&ex));
\r
1621 libvlc_exception_clear(&ex);
\r
1622 return INVOKERESULT_GENERIC_ERROR;
\r
1626 VOID_TO_NPVARIANT(result);
\r
1627 return INVOKERESULT_NO_ERROR;
\r
1630 return INVOKERESULT_NO_SUCH_METHOD;
\r
1635 return INVOKERESULT_GENERIC_ERROR;
\r
1638 void LibvlcPlaylistNPObject::parseOptions(const NPString &s, int *i_options, char*** ppsz_options)
\r
1640 if( s.utf8length )
\r
1642 char *val = stringValue(s);
\r
1645 long capacity = 16;
\r
1646 char **options = (char **)malloc(capacity*sizeof(char *));
\r
1651 char *end = val + s.utf8length;
\r
1652 while( val < end )
\r
1654 // skip leading blanks
\r
1655 while( (val < end)
\r
1656 && ((*val == ' ' ) || (*val == '\t')) )
\r
1659 char *start = val;
\r
1660 // skip till we get a blank character
\r
1661 while( (val < end)
\r
1663 && (*val != '\t') )
\r
1665 char c = *(val++);
\r
1666 if( ('\'' == c) || ('"' == c) )
\r
1668 // skip till end of string
\r
1669 while( (val < end) && (*(val++) != c ) );
\r
1675 if( nOptions == capacity )
\r
1678 char **moreOptions = (char **)realloc(options, capacity*sizeof(char*));
\r
1679 if( ! moreOptions )
\r
1681 /* failed to allocate more memory */
\r
1683 /* return what we got so far */
\r
1684 *i_options = nOptions;
\r
1685 *ppsz_options = options;
\r
1688 options = moreOptions;
\r
1691 options[nOptions++] = strdup(start);
\r
1694 // must be end of string
\r
1697 *i_options = nOptions;
\r
1698 *ppsz_options = options;
\r
1705 void LibvlcPlaylistNPObject::parseOptions(NPObject *obj, int *i_options, char*** ppsz_options)
\r
1707 /* WARNING: Safari does not implement NPN_HasProperty/NPN_HasMethod */
\r
1711 /* we are expecting to have a Javascript Array object */
\r
1712 NPIdentifier propId = NPN_GetStringIdentifier("length");
\r
1713 if( NPN_GetProperty(_instance, obj, propId, &value) )
\r
1715 int count = numberValue(value);
\r
1716 NPN_ReleaseVariantValue(&value);
\r
1720 long capacity = 16;
\r
1721 char **options = (char **)malloc(capacity*sizeof(char *));
\r
1726 while( nOptions < count )
\r
1728 propId = NPN_GetIntIdentifier(nOptions);
\r
1729 if( ! NPN_GetProperty(_instance, obj, propId, &value) )
\r
1730 /* return what we got so far */
\r
1733 if( ! NPVARIANT_IS_STRING(value) )
\r
1735 /* return what we got so far */
\r
1736 NPN_ReleaseVariantValue(&value);
\r
1740 if( nOptions == capacity )
\r
1743 char **moreOptions = (char **)realloc(options, capacity*sizeof(char*));
\r
1744 if( ! moreOptions )
\r
1746 /* failed to allocate more memory */
\r
1747 NPN_ReleaseVariantValue(&value);
\r
1748 /* return what we got so far */
\r
1749 *i_options = nOptions;
\r
1750 *ppsz_options = options;
\r
1753 options = moreOptions;
\r
1756 options[nOptions++] = stringValue(value);
\r
1758 *i_options = nOptions;
\r
1759 *ppsz_options = options;
\r
1766 ** implementation of libvlc video object
\r
1769 const NPUTF8 * const LibvlcVideoNPObject::propertyNames[] =
\r
1777 enum LibvlcVideoNPObjectPropertyIds
\r
1779 ID_video_fullscreen,
\r
1782 ID_video_aspectratio
\r
1785 const int LibvlcVideoNPObject::propertyCount = sizeof(LibvlcVideoNPObject::propertyNames)/sizeof(NPUTF8 *);
\r
1787 RuntimeNPObject::InvokeResult LibvlcVideoNPObject::getProperty(int index, NPVariant &result)
\r
1789 VlcPlugin *p_plugin = reinterpret_cast<VlcPlugin *>(_instance->pdata);
\r
1792 libvlc_exception_t ex;
\r
1793 libvlc_exception_init(&ex);
\r
1795 libvlc_input_t *p_input = libvlc_playlist_get_input(p_plugin->getVLC(), &ex);
\r
1796 if( libvlc_exception_raised(&ex) )
\r
1798 NPN_SetException(this, libvlc_exception_get_message(&ex));
\r
1799 libvlc_exception_clear(&ex);
\r
1800 return INVOKERESULT_GENERIC_ERROR;
\r
1805 case ID_video_fullscreen:
\r
1807 int val = libvlc_get_fullscreen(p_input, &ex);
\r
1808 libvlc_input_free(p_input);
\r
1809 if( libvlc_exception_raised(&ex) )
\r
1811 NPN_SetException(this, libvlc_exception_get_message(&ex));
\r
1812 libvlc_exception_clear(&ex);
\r
1813 return INVOKERESULT_GENERIC_ERROR;
\r
1815 BOOLEAN_TO_NPVARIANT(val, result);
\r
1816 return INVOKERESULT_NO_ERROR;
\r
1818 case ID_video_height:
\r
1820 int val = libvlc_video_get_height(p_input, &ex);
\r
1821 libvlc_input_free(p_input);
\r
1822 if( libvlc_exception_raised(&ex) )
\r
1824 NPN_SetException(this, libvlc_exception_get_message(&ex));
\r
1825 libvlc_exception_clear(&ex);
\r
1826 return INVOKERESULT_GENERIC_ERROR;
\r
1828 INT32_TO_NPVARIANT(val, result);
\r
1829 return INVOKERESULT_NO_ERROR;
\r
1831 case ID_video_width:
\r
1833 int val = libvlc_video_get_width(p_input, &ex);
\r
1834 libvlc_input_free(p_input);
\r
1835 if( libvlc_exception_raised(&ex) )
\r
1837 NPN_SetException(this, libvlc_exception_get_message(&ex));
\r
1838 libvlc_exception_clear(&ex);
\r
1839 return INVOKERESULT_GENERIC_ERROR;
\r
1841 INT32_TO_NPVARIANT(val, result);
\r
1842 return INVOKERESULT_NO_ERROR;
\r
1844 case ID_video_aspectratio:
\r
1846 NPUTF8 *psz_aspect = libvlc_video_get_aspect_ratio(p_input, &ex);
\r
1847 libvlc_input_free(p_input);
\r
1848 if( libvlc_exception_raised(&ex) )
\r
1850 NPN_SetException(this, libvlc_exception_get_message(&ex));
\r
1851 libvlc_exception_clear(&ex);
\r
1852 return INVOKERESULT_GENERIC_ERROR;
\r
1855 return INVOKERESULT_GENERIC_ERROR;
\r
1857 STRINGZ_TO_NPVARIANT(psz_aspect, result);
\r
1858 return INVOKERESULT_NO_ERROR;
\r
1861 libvlc_input_free(p_input);
\r
1863 return INVOKERESULT_GENERIC_ERROR;
\r
1866 RuntimeNPObject::InvokeResult LibvlcVideoNPObject::setProperty(int index, const NPVariant &value)
\r
1868 VlcPlugin *p_plugin = reinterpret_cast<VlcPlugin *>(_instance->pdata);
\r
1871 libvlc_exception_t ex;
\r
1872 libvlc_exception_init(&ex);
\r
1874 libvlc_input_t *p_input = libvlc_playlist_get_input(p_plugin->getVLC(), &ex);
\r
1875 if( libvlc_exception_raised(&ex) )
\r
1877 NPN_SetException(this, libvlc_exception_get_message(&ex));
\r
1878 libvlc_exception_clear(&ex);
\r
1879 return INVOKERESULT_GENERIC_ERROR;
\r
1884 case ID_video_fullscreen:
\r
1886 if( ! NPVARIANT_IS_BOOLEAN(value) )
\r
1888 libvlc_input_free(p_input);
\r
1889 return INVOKERESULT_INVALID_VALUE;
\r
1892 int val = NPVARIANT_TO_BOOLEAN(value);
\r
1893 libvlc_set_fullscreen(p_input, val, &ex);
\r
1894 libvlc_input_free(p_input);
\r
1895 if( libvlc_exception_raised(&ex) )
\r
1897 NPN_SetException(this, libvlc_exception_get_message(&ex));
\r
1898 libvlc_exception_clear(&ex);
\r
1899 return INVOKERESULT_GENERIC_ERROR;
\r
1901 return INVOKERESULT_NO_ERROR;
\r
1903 case ID_video_aspectratio:
\r
1905 char *psz_aspect = NULL;
\r
1907 if( ! NPVARIANT_IS_STRING(value) )
\r
1909 libvlc_input_free(p_input);
\r
1910 return INVOKERESULT_INVALID_VALUE;
\r
1913 psz_aspect = stringValue(NPVARIANT_TO_STRING(value));
\r
1916 libvlc_input_free(p_input);
\r
1917 return INVOKERESULT_GENERIC_ERROR;
\r
1920 libvlc_video_set_aspect_ratio(p_input, psz_aspect, &ex);
\r
1922 free(psz_aspect );
\r
1924 libvlc_input_free(p_input);
\r
1925 if( libvlc_exception_raised(&ex) )
\r
1927 NPN_SetException(this, libvlc_exception_get_message(&ex));
\r
1928 libvlc_exception_clear(&ex);
\r
1929 return INVOKERESULT_GENERIC_ERROR;
\r
1931 return INVOKERESULT_NO_ERROR;
\r
1934 libvlc_input_free(p_input);
\r
1936 return INVOKERESULT_GENERIC_ERROR;
\r
1939 const NPUTF8 * const LibvlcVideoNPObject::methodNames[] =
\r
1941 "toggleFullscreen",
\r
1944 enum LibvlcVideoNPObjectMethodIds
\r
1946 ID_video_togglefullscreen,
\r
1949 const int LibvlcVideoNPObject::methodCount = sizeof(LibvlcVideoNPObject::methodNames)/sizeof(NPUTF8 *);
\r
1951 RuntimeNPObject::InvokeResult LibvlcVideoNPObject::invoke(int index, const NPVariant *args, uint32_t argCount, NPVariant &result)
\r
1953 VlcPlugin *p_plugin = reinterpret_cast<VlcPlugin *>(_instance->pdata);
\r
1956 libvlc_exception_t ex;
\r
1957 libvlc_exception_init(&ex);
\r
1959 libvlc_input_t *p_input = libvlc_playlist_get_input(p_plugin->getVLC(), &ex);
\r
1960 if( libvlc_exception_raised(&ex) )
\r
1962 NPN_SetException(this, libvlc_exception_get_message(&ex));
\r
1963 libvlc_exception_clear(&ex);
\r
1964 return INVOKERESULT_GENERIC_ERROR;
\r
1969 case ID_video_togglefullscreen:
\r
1970 if( argCount == 0 )
\r
1972 libvlc_toggle_fullscreen(p_input, &ex);
\r
1973 libvlc_input_free(p_input);
\r
1974 if( libvlc_exception_raised(&ex) )
\r
1976 NPN_SetException(this, libvlc_exception_get_message(&ex));
\r
1977 libvlc_exception_clear(&ex);
\r
1978 return INVOKERESULT_GENERIC_ERROR;
\r
1982 VOID_TO_NPVARIANT(result);
\r
1983 return INVOKERESULT_NO_ERROR;
\r
1988 /* cannot get input, probably not playing */
\r
1989 if( libvlc_exception_raised(&ex) )
\r
1991 NPN_SetException(this, libvlc_exception_get_message(&ex));
\r
1992 libvlc_exception_clear(&ex);
\r
1994 return INVOKERESULT_GENERIC_ERROR;
\r
1996 return INVOKERESULT_NO_SUCH_METHOD;
\r
1998 return INVOKERESULT_NO_SUCH_METHOD;
\r
2001 return INVOKERESULT_GENERIC_ERROR;
\r