mirrors/vlc
0
0
Fork 0
mirror of https://github.com/videolan/vlc.git synced 2024-11-28 20:34:12 +08:00
Code Issues Packages Projects Releases Wiki Activity

- the resurected mozilla plugin for Safari/Firefox on MacOS X

Browse Source
This commit is contained in:
Damien Fouilleul 2006-04-15 11:51:45 +00:00
parent 858ff0c446
commit 20defc2a2b
12 changed files with 1830 additions and 673 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

BIN
extras/MacOSX/plugin/English.lproj/InfoPlist.strings
View File

Binary file not shown.

6
extras/MacOSX/plugin/Info.plist
View File

@ -6,16 +6,22 @@
<string>English</string>
<key>CFBundleExecutable</key>
<string>VLC Plugin</string>
<key>CFBundleGetInfoString</key>
<string>Copyright 2002-2006 The VideoLAN Team. All Rights Reserved</string>
<key>CFBundleIdentifier</key>
<string>com.netscape.vlc</string>
<key>CFBundleInfoDictionaryVersion</key>
<string>6.0</string>
<key>CFBundleName</key>
<string>VideoLAN VLC Plug-in</string>
<key>CFBundlePackageType</key>
<string>BRPL</string>
<key>CFBundleSignature</key>
<string>MOSS</string>
<key>CFBundleVersion</key>
<string>0.12</string>
<key>CFBundleShortVersionString</key>
<string>0.12</string>
<key>CSResourcesFileMapped</key>
<true/>
</dict>

360
modules/gui/macosx/voutqt.m
View File

@ -72,10 +72,12 @@ struct vout_sys_t
DecompressorComponent img_dc;
ImageDescriptionHandle h_img_descr;
/* video geometry in port */
int i_origx, i_origy;
int i_width, i_height;
/* Mozilla plugin-related variables */
vlc_bool_t b_embedded;
Rect clipping_rect;
int portx, porty;
RgnHandle clip_mask;
};
struct picture_sys_t
@ -98,6 +100,9 @@ static void DisplayVideo ( vout_thread_t *, picture_t * );
static int ControlVideo ( vout_thread_t *, int, va_list );
static int CoToggleFullscreen( vout_thread_t *p_vout );
static int DrawableRedraw( vlc_object_t *p_this, const char *psz_name,
vlc_value_t oval, vlc_value_t nval, void *param);
static void UpdateEmbeddedGeometry( vout_thread_t *p_vout );
static void QTScaleMatrix ( vout_thread_t * );
static int QTCreateSequence ( vout_thread_t * );
static void QTDestroySequence ( vout_thread_t * );
@ -201,39 +206,19 @@ int E_(OpenVideoQT) ( vlc_object_t *p_this )
return VLC_EGENERIC;
}
#define o_qtview p_vout->p_sys->o_qtview
o_qtview = [[VLCQTView alloc] initWithVout: p_vout];
[o_qtview autorelease];
if( p_vout->p_sys->b_embedded )
{
/* Zero the clipping rectangle */
p_vout->p_sys->clipping_rect.left = 0;
p_vout->p_sys->clipping_rect.right = 0;
p_vout->p_sys->clipping_rect.top = 0;
p_vout->p_sys->clipping_rect.bottom = 0;
}
else
if( p_vout->b_fullscreen || !p_vout->p_sys->b_embedded )
{
/* Spawn window */
#define o_qtview p_vout->p_sys->o_qtview
o_qtview = [[VLCQTView alloc] initWithVout: p_vout];
[o_qtview autorelease];
p_vout->p_sys->o_vout_view = [VLCVoutView getVoutView: p_vout
subView: o_qtview frame: nil];
if( !p_vout->p_sys->o_vout_view )
{
return VLC_EGENERIC;
}
}
/* Retrieve the QuickDraw port */
if( p_vout->p_sys->b_embedded )
{
/* Don't need (nor want) to lock the focus, since otherwise we crash
* (presumably because we don't own the window, but I'm not sure
* if this is the exact reason) -andrep */
p_vout->p_sys->p_qdport = [o_qtview qdPort];
}
else
{
[o_qtview lockFocus];
p_vout->p_sys->p_qdport = [o_qtview qdPort];
[o_qtview unlockFocus];
@ -251,7 +236,7 @@ void E_(CloseVideoQT) ( vlc_object_t *p_this )
NSAutoreleasePool *o_pool = [[NSAutoreleasePool alloc] init];
vout_thread_t * p_vout = (vout_thread_t *)p_this;
if( !p_vout->p_sys->b_embedded )
if( p_vout->b_fullscreen || !p_vout->p_sys->b_embedded )
[p_vout->p_sys->o_vout_view closeVout];
/* Clean Up Quicktime environment */
@ -280,17 +265,27 @@ static int InitVideo ( vout_thread_t *p_vout )
p_vout->output.i_height = p_vout->render.i_height;
p_vout->output.i_aspect = p_vout->render.i_aspect;
/* If we are embedded (e.g. running as a Mozilla plugin), use the pointer
* stored in the "drawable" value as the CGrafPtr for the QuickDraw
* graphics port */
if( p_vout->p_sys->b_embedded )
if( p_vout->b_fullscreen || !p_vout->p_sys->b_embedded )
{
vlc_value_t val;
var_Get( p_vout->p_vlc, "drawable", &val );
p_vout->p_sys->p_qdport = (CGrafPtr) val.i_int;
Rect s_rect;
p_vout->p_sys->clip_mask = NULL;
GetPortBounds( p_vout->p_sys->p_qdport, &s_rect );
p_vout->p_sys->i_origx = s_rect.left;
p_vout->p_sys->i_origy = s_rect.top;
p_vout->p_sys->i_width = s_rect.right - s_rect.left;
p_vout->p_sys->i_height = s_rect.bottom - s_rect.top;
}
else
{
/* As we are embedded (e.g. running as a Mozilla plugin), use the pointer
* stored in the "drawable" value as the CGrafPtr for the QuickDraw
* graphics port */
/* Create the clipping mask */
p_vout->p_sys->clip_mask = NewRgn();
UpdateEmbeddedGeometry(p_vout);
var_AddCallback(p_vout->p_vlc, "drawableredraw", DrawableRedraw, p_vout);
}
SetPort( p_vout->p_sys->p_qdport );
QTScaleMatrix( p_vout );
if( QTCreateSequence( p_vout ) )
@ -338,6 +333,12 @@ static void EndVideo( vout_thread_t *p_vout )
QTDestroySequence( p_vout );
if( !p_vout->b_fullscreen && p_vout->p_sys->b_embedded )
{
var_DelCallback(p_vout->p_vlc, "drawableredraw", DrawableRedraw, p_vout);
DisposeRgn(p_vout->p_sys->clip_mask);
}
/* Free the direct buffers we allocated */
for( i_index = I_OUTPUTPICTURES; i_index; )
{
@ -354,9 +355,6 @@ static void EndVideo( vout_thread_t *p_vout )
*****************************************************************************/
static int ManageVideo( vout_thread_t *p_vout )
{
vlc_value_t val;
var_Get( p_vout->p_vlc, "drawableredraw", &val );
if( p_vout->i_changes & VOUT_FULLSCREEN_CHANGE )
{
if( CoToggleFullscreen( p_vout ) )
@ -367,16 +365,25 @@ static int ManageVideo( vout_thread_t *p_vout )
p_vout->i_changes &= ~VOUT_FULLSCREEN_CHANGE;
}
if( p_vout->p_sys->b_embedded && val.i_int == 1 )
if( p_vout->i_changes & VOUT_SIZE_CHANGE )
{
/* If we're embedded, the application is expected to indicate a
* window change (move/resize/etc) via the "drawableredraw" value.
* If that's the case, set the VOUT_SIZE_CHANGE flag so we do
* actually handle the window change. */
val.i_int = 0;
var_Set( p_vout->p_vlc, "drawableredraw", val );
p_vout->i_changes |= VOUT_SIZE_CHANGE;
if( p_vout->b_fullscreen || !p_vout->p_sys->b_embedded )
{
/* get the geometry from NSQuickDrawView */
Rect s_rect;
GetPortBounds( p_vout->p_sys->p_qdport, &s_rect );
p_vout->p_sys->i_origx = s_rect.left;
p_vout->p_sys->i_origy = s_rect.top;
p_vout->p_sys->i_width = s_rect.right - s_rect.left;
p_vout->p_sys->i_height = s_rect.bottom - s_rect.top;
}
else
{
/* As we're embedded, get the geometry from Mozilla/Safari NPWindow object */
UpdateEmbeddedGeometry( p_vout );
SetDSequenceMask(p_vout->p_sys->i_seq,
p_vout->p_sys->clip_mask);
}
}
if( p_vout->i_changes & VOUT_SIZE_CHANGE ||
@ -394,6 +401,8 @@ static int ManageVideo( vout_thread_t *p_vout )
{
p_vout->i_changes &= ~VOUT_ASPECT_CHANGE;
}
// can be nil
[p_vout->p_sys->o_vout_view manage];
return( 0 );
@ -408,55 +417,34 @@ static void DisplayVideo( vout_thread_t *p_vout, picture_t *p_pic )
{
OSErr err;
CodecFlags flags;
Rect saved_rect;
RgnHandle saved_clip;
saved_clip = NewRgn();
if( p_vout->p_sys->b_embedded )
if( (NULL == p_vout->p_sys->clip_mask) || !EmptyRgn(p_vout->p_sys->clip_mask) )
{
/* In the Mozilla plugin, the browser also draws things in the windows.
* So, we have to update the origin and clipping rectangle for each
* picture. FIXME: The vout should probably lock something ... */
//CGrafPtr oldPort;
//Rect oldBounds;
/* Save the origin and clipping rectangle used by the host application
* (e.g. Mozilla), so we can restore it later */
GetPortBounds( p_vout->p_sys->p_qdport, &saved_rect );
GetClip( saved_clip );
/* The port gets unlocked at the end of this function */
LockPortBits( p_vout->p_sys->p_qdport );
/* Change the origin and clipping to the coordinates that the embedded
* window wants to draw at */
SetPort( p_vout->p_sys->p_qdport );
SetOrigin( p_vout->p_sys->portx , p_vout->p_sys->porty );
ClipRect( &p_vout->p_sys->clipping_rect );
}
if( ( err = DecompressSequenceFrameWhen(
p_vout->p_sys->i_seq,
p_pic->p_sys->p_data,
p_pic->p_sys->i_size,
codecFlagUseImageBuffer, &flags, NULL, NULL ) != noErr ) )
{
msg_Warn( p_vout, "QT failed to display the frame sequence: %d", err );
}
else
{
if( !p_vout->p_sys->b_embedded )
QDFlushPortBuffer( p_vout->p_sys->p_qdport, nil );
}
if( p_vout->p_sys->b_embedded )
{
/* Restore the origin and clipping rectangle to the settings used
* by the host application */
SetOrigin( saved_rect.left, saved_rect.top );
SetClip( saved_clip );
UnlockPortBits( p_vout->p_sys->p_qdport );
/* since there is not way to lock a QuickDraw port for exclusive use
there is a potential problem that the frame will be displayed
in the wrong place if other embedded plugins redraws as the port
origin may be changed */
//GetPort(&oldPort);
//GetPortBounds(p_vout->p_sys->p_qdport, &oldBounds);
SetPort(p_vout->p_sys->p_qdport);
SetOrigin(p_vout->p_sys->i_origx, p_vout->p_sys->i_origy);
if( ( err = DecompressSequenceFrameWhen(
p_vout->p_sys->i_seq,
p_pic->p_sys->p_data,
p_pic->p_sys->i_size,
codecFlagUseImageBuffer, &flags, NULL, NULL ) == noErr ) )
{
QDFlushPortBuffer( p_vout->p_sys->p_qdport, p_vout->p_sys->clip_mask );
//QDFlushPortBuffer( p_vout->p_sys->p_qdport, NULL );
}
else
{
msg_Warn( p_vout, "QT failed to display the frame sequence: %d", err );
}
//SetPortBounds(p_vout->p_sys->p_qdport, &oldBounds);
//SetPort(oldPort);
}
}
@ -494,40 +482,63 @@ static int CoToggleFullscreen( vout_thread_t *p_vout )
if( !p_vout->b_fullscreen )
{
/* Save window size and position */
p_vout->p_sys->s_frame.size =
[p_vout->p_sys->o_vout_view frame].size;
p_vout->p_sys->s_frame.origin =
[[p_vout->p_sys->o_vout_view getWindow] frame].origin;
p_vout->p_sys->b_saved_frame = VLC_TRUE;
if( !p_vout->p_sys->b_embedded )
{
/* Save window size and position */
p_vout->p_sys->s_frame.size =
[p_vout->p_sys->o_vout_view frame].size;
p_vout->p_sys->s_frame.origin =
[[p_vout->p_sys->o_vout_view getWindow] frame].origin;
p_vout->p_sys->b_saved_frame = VLC_TRUE;
}
else
{
var_DelCallback(p_vout->p_vlc, "drawableredraw", DrawableRedraw, p_vout);
DisposeRgn(p_vout->p_sys->clip_mask);
}
}
[p_vout->p_sys->o_vout_view closeVout];
p_vout->b_fullscreen = !p_vout->b_fullscreen;
#define o_qtview p_vout->p_sys->o_qtview
o_qtview = [[VLCQTView alloc] initWithVout: p_vout];
[o_qtview autorelease];
if( p_vout->p_sys->b_saved_frame )
if( p_vout->b_fullscreen || !p_vout->p_sys->b_embedded )
{
p_vout->p_sys->o_vout_view = [VLCVoutView getVoutView: p_vout
subView: o_qtview
frame: &p_vout->p_sys->s_frame];
Rect s_rect;
p_vout->p_sys->clip_mask = NULL;
#define o_qtview p_vout->p_sys->o_qtview
o_qtview = [[VLCQTView alloc] initWithVout: p_vout];
[o_qtview autorelease];
if( p_vout->p_sys->b_saved_frame )
{
p_vout->p_sys->o_vout_view = [VLCVoutView getVoutView: p_vout
subView: o_qtview
frame: &p_vout->p_sys->s_frame];
}
else
{
p_vout->p_sys->o_vout_view = [VLCVoutView getVoutView: p_vout
subView: o_qtview frame: nil];
}
/* Retrieve the QuickDraw port */
[o_qtview lockFocus];
p_vout->p_sys->p_qdport = [o_qtview qdPort];
[o_qtview unlockFocus];
#undef o_qtview
GetPortBounds( p_vout->p_sys->p_qdport, &s_rect );
p_vout->p_sys->i_origx = s_rect.left;
p_vout->p_sys->i_origy = s_rect.top;
p_vout->p_sys->i_width = s_rect.right - s_rect.left;
p_vout->p_sys->i_height = s_rect.bottom - s_rect.top;
}
else
{
p_vout->p_sys->o_vout_view = [VLCVoutView getVoutView: p_vout
subView: o_qtview frame: nil];
/* Create the clipping mask */
p_vout->p_sys->clip_mask = NewRgn();
UpdateEmbeddedGeometry(p_vout);
var_AddCallback(p_vout->p_vlc, "drawableredraw", DrawableRedraw, p_vout);
}
/* Retrieve the QuickDraw port */
[o_qtview lockFocus];
p_vout->p_sys->p_qdport = [o_qtview qdPort];
[o_qtview unlockFocus];
#undef o_qtview
SetPort( p_vout->p_sys->p_qdport );
QTScaleMatrix( p_vout );
if( QTCreateSequence( p_vout ) )
@ -540,55 +551,84 @@ static int CoToggleFullscreen( vout_thread_t *p_vout )
return 0;
}
/* If we're embedded, the application is expected to indicate a
* window change (move/resize/etc) via the "drawableredraw" value.
* If that's the case, set the VOUT_SIZE_CHANGE flag so we do
* actually handle the window change. */
static int DrawableRedraw( vlc_object_t *p_this, const char *psz_name,
vlc_value_t oval, vlc_value_t nval, void *param)
{
/* ignore changes until we are ready for them */
if( (oval.i_int != nval.i_int) && (nval.i_int == 1) )
{
vout_thread_t *p_vout = (vout_thread_t *)param;
/* prevent QT from rendering any more video until we have updated
the geometry */
SetEmptyRgn(p_vout->p_sys->clip_mask);
SetDSequenceMask(p_vout->p_sys->i_seq,
p_vout->p_sys->clip_mask);
p_vout->i_changes |= VOUT_SIZE_CHANGE;
}
return VLC_SUCCESS;
}
/* Embedded video get their drawing region from the host application
* by the drawable values here. Read those variables, and store them
* in the p_vout->p_sys structure so that other functions (such as
* DisplayVideo and ManageVideo) can use them later. */
static void UpdateEmbeddedGeometry( vout_thread_t *p_vout )
{
vlc_value_t val;
vlc_value_t valt, vall, valb, valr, valx, valy, valw, valh,
valportx, valporty;
var_Get( p_vout->p_vlc, "drawable", &val );
var_Get( p_vout->p_vlc, "drawablet", &valt );
var_Get( p_vout->p_vlc, "drawablel", &vall );
var_Get( p_vout->p_vlc, "drawableb", &valb );
var_Get( p_vout->p_vlc, "drawabler", &valr );
var_Get( p_vout->p_vlc, "drawablex", &valx );
var_Get( p_vout->p_vlc, "drawabley", &valy );
var_Get( p_vout->p_vlc, "drawablew", &valw );
var_Get( p_vout->p_vlc, "drawableh", &valh );
var_Get( p_vout->p_vlc, "drawableportx", &valportx );
var_Get( p_vout->p_vlc, "drawableporty", &valporty );
/* portx, porty contains values for SetOrigin() function
which isn't used, instead use QT Translate matrix */
p_vout->p_sys->i_origx = valportx.i_int;
p_vout->p_sys->i_origy = valporty.i_int;
p_vout->p_sys->p_qdport = (CGrafPtr) val.i_int;
p_vout->p_sys->i_width = valw.i_int;
p_vout->p_sys->i_height = valh.i_int;
/* update video clipping mask */
/*SetRectRgn( p_vout->p_sys->clip_mask , vall.i_int ,
valt.i_int, valr.i_int, valb.i_int );*/
SetRectRgn( p_vout->p_sys->clip_mask , vall.i_int + valportx.i_int ,
valt.i_int + valporty.i_int , valr.i_int + valportx.i_int ,
valb.i_int + valporty.i_int );
/* reset drawableredraw variable indicating we are ready
to take changes in video geometry */
val.i_int=0;
var_Set( p_vout->p_vlc, "drawableredraw", val );
}
/*****************************************************************************
* QTScaleMatrix: scale matrix
*****************************************************************************/
static void QTScaleMatrix( vout_thread_t *p_vout )
{
Rect s_rect;
vlc_value_t val;
unsigned int i_width, i_height;
Fixed factor_x, factor_y;
unsigned int i_offset_x = 0;
unsigned int i_offset_y = 0;
GetPortBounds( p_vout->p_sys->p_qdport, &s_rect );
i_width = s_rect.right - s_rect.left;
i_height = s_rect.bottom - s_rect.top;
if( p_vout->p_sys->b_embedded )
{
/* Embedded video get their drawing region from the host application
* by the drawable values here. Read those variables, and store them
* in the p_vout->p_sys structure so that other functions (such as
* DisplayVideo and ManageVideo) can use them later. */
vlc_value_t valt, vall, valb, valr, valx, valy, valw, valh,
valportx, valporty;
var_Get( p_vout->p_vlc, "drawable", &val );
var_Get( p_vout->p_vlc, "drawablet", &valt );
var_Get( p_vout->p_vlc, "drawablel", &vall );
var_Get( p_vout->p_vlc, "drawableb", &valb );
var_Get( p_vout->p_vlc, "drawabler", &valr );
var_Get( p_vout->p_vlc, "drawablex", &valx );
var_Get( p_vout->p_vlc, "drawabley", &valy );
var_Get( p_vout->p_vlc, "drawablew", &valw );
var_Get( p_vout->p_vlc, "drawableh", &valh );
var_Get( p_vout->p_vlc, "drawableportx", &valportx );
var_Get( p_vout->p_vlc, "drawableporty", &valporty );
p_vout->p_sys->portx = valportx.i_int;
p_vout->p_sys->porty = valporty.i_int;
p_vout->p_sys->p_qdport = (CGrafPtr) val.i_int;
i_width = valw.i_int;
i_height = valh.i_int;
p_vout->p_sys->clipping_rect.top = 0;
p_vout->p_sys->clipping_rect.left = 0;
p_vout->p_sys->clipping_rect.bottom = valb.i_int - valt.i_int;
p_vout->p_sys->clipping_rect.right = valr.i_int - vall.i_int;
}
int i_width = p_vout->p_sys->i_width;
int i_height = p_vout->p_sys->i_height;
var_Get( p_vout, "macosx-stretch", &val );
if( val.b_bool )
@ -679,7 +719,7 @@ static int QTCreateSequence( vout_thread_t *p_vout )
p_vout->p_sys->p_qdport,
NULL, NULL,
p_vout->p_sys->p_matrix,
srcCopy, NULL,
srcCopy, p_vout->p_sys->clip_mask,
codecFlagUseImageBuffer,
codecLosslessQuality,
bestSpeedCodec ) ) )

60
mozilla/Makefile.am
View File

@ -14,6 +14,8 @@ SOURCES_mozilla_common = \
vlcplugin.h \
vlcpeer.cpp \
vlcpeer.h \
vlcruntime.cpp \
vlcruntime.h \
support/classinfo.h
DIST_sources = $(SOURCES_mozilla_common) \
@ -70,21 +72,59 @@ CPPFLAGS_mozilla_EXTRA = -I. -I$(top_builddir) -I$(srcdir)/../include -c \
-DNO_X11=1 -DUSE_SYSTEM_CONSOLE=1 -pipe -fmessage-length=0 -g \
-include mozilla-config.h
LDFLAGS_npvlc = -arch ppc -bundle -read_only_relocs suppress \
$(LIBRARIES_libvlc) -dylib
$(LIBRARIES_libvlc) -dylib -headerpad_max_install_names
npvlc.rsrc: $(srcdir)/vlc.r
/Developer/Tools/Rez -useDF /Developer/Headers/FlatCarbon/Types.r $< -o $@
#
# Plugin uses shared libraries that are located relatively through @executable_path,
# which unfortunately references the path of the App using the Plugin, rather than the
# Plugin itself. Since this Plugin should always be installed in '/Library/Internet Plug-Ins',
# it is safer to force dylibs to locate dependants through a fixed path
#
define FIXEXECPATH
otool -L "$$dylib" | \
awk -v libdylib="$$dylib" ' \
/@executable_path/ { \
newpath=$$1 ; \
sub("@executable_path","/Library/Internet Plug-Ins/VLC Plugin.plugin/Contents/MacOS",newpath) ; \
print "install_name_tool -change \""$$1"\" \""newpath"\" \""libdylib"\"" ; \
}' | sh -x
endef
VLC\ Plugin.plugin: npvlc.rsrc npvlc.dylib
rm -rf "$@"
mkdir -p "./$@/Contents/MacOS"
cp npvlc.dylib "./$@/Contents/MacOS/VLC Plugin"
mkdir -p ./"$@"/Contents/Resources
cp npvlc.rsrc "./$@/Contents/Resources/VLC Plugin.rsrc"
cp -r $(top_srcdir)/extras/MacOSX/plugin/English.lproj "./$@/Contents/Resources/"
cp $(top_srcdir)/extras/MacOSX/plugin/Info.plist "./$@/Contents/Info.plist"
(cd $(top_builddir)/VLC.app/Contents/MacOS/; tar cf - modules)| \
(cd "./$@/Contents/MacOS"; tar xf -)
rm -Rf "$@"
$(INSTALL) -d "./$@/Contents/MacOS"
$(INSTALL) npvlc.dylib "./$@/Contents/MacOS/VLC Plugin"
dylib="./$@/Contents/MacOS/VLC Plugin"; $(FIXEXECPATH) ;
$(INSTALL) -d "./$@/Contents/Resources"
$(INSTALL) npvlc.rsrc "./$@/Contents/Resources/VLC Plugin.rsrc"
cp -r "$(top_srcdir)/extras/MacOSX/plugin/English.lproj" "./$@/Contents/Resources/"
$(INSTALL) "$(top_srcdir)/extras/MacOSX/plugin/Info.plist" "./$@/Contents/Info.plist"
$(INSTALL) -d "./$@/Contents/MacOS/modules"
for i in "" `$(VLC_CONFIG) --target plugin` ; do \
if test -n "$$i" ; then \
dylib="./$@/Contents/MacOS/modules/`basename $$i$(LIBEXT)`"; \
$(INSTALL) "$$i$(LIBEXT)" "$$dylib"; \
$(FIXEXECPATH) ; \
fi ; \
done
if test -d $(top_srcdir)/extras/contrib/vlc-lib; then \
$(INSTALL) -d "./$@/Contents/MacOS/lib"; \
for i in $(top_srcdir)/extras/contrib/vlc-lib/*.dylib ; do \
dylib="./$@/Contents/MacOS/lib/`basename $${i}`" ; \
$(INSTALL) -m 644 "$${i}" "$$dylib" ; \
$(FIXEXECPATH); \
done ; \
fi
if test -d "$(MOZILLA_SDK_PATH)/lib"; then \
for i in "$(MOZILLA_SDK_PATH)"/lib/*.dylib ; do \
dylib="./$@/Contents/MacOS/`basename $${i}`" ; \
$(INSTALL) -m 644 "$${i}" "$$dylib" ; \
$(FIXEXECPATH); \
done ; \
fi
else

1185
mozilla/support/npmac.cpp
View File

File diff suppressed because it is too large Load Diff

50
mozilla/vlc.r
View File

@ -4,13 +4,17 @@
/* Definitions of system resource types */
data 'carb' (0)
{
};
/* The first string in the array is a plugin description,
* the second is the plugin name */
resource 'STR#' (126)
{
{
"A VLC test plugin... hope it goes somewhere",
"VLC plugin"
"VideoLAN WWW: http://videolan.org"
"VLC multimedia plugin"
};
};
@ -18,7 +22,26 @@ resource 'STR#' (126)
resource 'STR#' (127)
{
{
"Invoke scriptable sample plugin"
"MPEG audio",
"MPEG audio",
"MPEG video",
"MPEG video",
"MPEG video",
"MPEG video",
"MPEG-4 video",
"MPEG-4 audio",
"MPEG-4 video",
"MPEG-4 video",
"AVI video",
"QuickTime video",
"Ogg stream",
"Ogg stream",
"VLC plugin",
"ASF stream",
"ASF stream",
"",
"",
"Google VLC Plugin"
};
};
@ -26,7 +49,26 @@ resource 'STR#' (127)
resource 'STR#' (128,"MIME Type")
{
{
"application/vlc-plugin", ""
"audio/mpeg", "mp2,mp3,mpga,mpega",
"audio/x-mpeg", "mp2,mp3,mpga,mpega",
"video/mpeg", "mpg,mpeg,mpe",
"video/x-mpeg", "mpg,mpeg,mpe",
"video/mpeg-system", "mpg,mpeg,vob",
"video/x-mpeg-system", "mpg,mpeg,vob",
"video/mpeg4", "mp4,mpg4",
"audio/mpeg4", "mp4,mpg4",
"application/mpeg4-iod", "mp4,mpg4",
"application/mpeg4-muxcodetable", "mp4,mpg4",
"video/x-msvideo", "avi",
"video/quicktime", "mov, qt",
"application/ogg", "ogg",
"application/x-ogg", "ogg",
"application/x-vlc-plugin", "vlc",
"video/x-ms-asf-plugin", "",
"video/x-ms-asf", "",
"application/x-mplayer2", "",
"video/x-ms-wmv", "",
"video/x-google-vlc-plugin", "",
};
};

3
mozilla/vlcpeer.h
View File

@ -20,6 +20,8 @@
* along with this program; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
*****************************************************************************/
#ifndef __VLCPEER_H__
#define __VLCPEER_H__
#include "vlcintf.h"
#include "support/classinfo.h"
@ -56,3 +58,4 @@ private:
VlcPlugin * p_plugin;
};
#endif

34
mozilla/vlcplugin.cpp
View File

@ -41,7 +41,6 @@
#undef XP_UNIX
#endif
#include "vlcpeer.h"
#include "vlcplugin.h"
/*****************************************************************************
@ -96,36 +95,3 @@ VlcIntf* VlcPlugin::GetPeer()
return p_peer;
}
void VlcPlugin::SetFileName(const char * filename)
{
#if 0
FILE * fh;
fh = fopen(filename, "rb");
if(!fh)
{
fprintf(stderr, "Error while opening %s.\n", filename);
return;
}
fseek(fh, 0, SEEK_END);
m_lSize = ftell(fh);
m_szSound = (char*) malloc(m_lSize);
if(!m_szSound)
{
fprintf(stderr, "Error while allocating memory.\n");
fclose(fh);
return;
}
rewind(fh);
long pos = 0;
do
{
pos += fread(m_szSound + pos, 1, m_lSize - pos, fh);
fprintf(stderr, "pos = %d\n", pos);
}
while (pos < m_lSize -1);
fclose (fh);
fprintf(stderr, "File loaded\n");
#endif
return;
}

29
mozilla/vlcplugin.h
View File

@ -24,6 +24,32 @@
/*******************************************************************************
* Instance state information about the plugin.
******************************************************************************/
#ifndef __VLCPLUGIN_H__
#define __VLCPLUGIN_H__
#include "vlcpeer.h"
#if !defined(XP_MACOSX) && !defined(XP_UNIX) && !defined(XP_WIN)
#define XP_UNIX 1
#elif defined(XP_MACOSX)
#undef XP_UNIX
#endif
#ifdef XP_WIN
/* Windows stuff */
#endif
#ifdef XP_MACOSX
/* Mac OS X stuff */
# include <Quickdraw.h>
#endif
#ifdef XP_UNIX
/* X11 stuff */
# include <X11/Xlib.h>
# include <X11/Intrinsic.h>
# include <X11/StringDefs.h>
#endif
class VlcPlugin
{
@ -35,8 +61,6 @@ public:
NPP GetInstance();
VlcIntf* GetPeer();
void SetFileName( const char* );
/* Window settings */
NPWindow* p_npwin;
uint16 i_npmode;
@ -114,3 +138,4 @@ private:
"audio/wav::WAV audio" \
"audio/x-wav::WAV audio" \
#endif

358
mozilla/vlcruntime.cpp Executable file
View File

@ -0,0 +1,358 @@
#include "config.h"
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
/* vlc stuff */
#ifdef USE_LIBVLC
# include <vlc/vlc.h>
#endif
/* Mozilla stuff */
#ifdef HAVE_MOZILLA_CONFIG_H
# include <mozilla-config.h>
#endif
#include <nsISupports.h>
#include <nsMemory.h>
#include <npapi.h>
#include <npruntime.h>
#include "vlcplugin.h"
#include "vlcruntime.h"
/*
** utility functions
*/
static PRInt64 NPVariantToPRInt64(const NPVariant &v)
{
switch( v.type ) {
case NPVariantType_Bool:
return static_cast<PRInt64>(NPVARIANT_TO_BOOLEAN(v));
case NPVariantType_Int32:
return static_cast<PRInt64>(NPVARIANT_TO_INT32(v));
case NPVariantType_Double:
return static_cast<PRInt64>(NPVARIANT_TO_DOUBLE(v));
default:
return 0;
}
}
/*
** implementation root object
*/
const NPUTF8 * const VlcRuntimeRootObject::propertyNames[] = { };
const NPUTF8 * const VlcRuntimeRootObject::methodNames[] =
{
"play",
"pause",
"stop",
"fullscreen",
"set_volume",
"get_volume",
"mute",
"get_int_variable",
"set_int_variable",
"get_bool_variable",
"set_bool_variable",
"get_str_variable",
"set_str_variable",
"clear_playlist",
"add_item",
"next",
"previous",
"isplaying",
"get_length",
"get_position",
"get_time",
"seek",
};
enum VlcRuntimeRootObjectMethodIds
{
ID_play = 0,
ID_pause,
ID_stop,
ID_fullscreen,
ID_set_volume,
ID_get_volume,
ID_mute,
ID_get_int_variable,
ID_set_int_variable,
ID_get_bool_variable,
ID_set_bool_variable,
ID_get_str_variable,
ID_set_str_variable,
ID_clear_playlist,
ID_add_item,
ID_next,
ID_previous,
ID_isplaying,
ID_get_length,
ID_get_position,
ID_get_time,
ID_seek,
};
const int VlcRuntimeRootObject::propertyCount = sizeof(VlcRuntimeRootObject::propertyNames)/sizeof(NPUTF8 *);
const int VlcRuntimeRootObject::methodCount = sizeof(VlcRuntimeRootObject::methodNames)/sizeof(NPUTF8 *);
bool VlcRuntimeRootObject::getProperty(int index, NPVariant *result)
{
return false;
}
bool VlcRuntimeRootObject::setProperty(int index, const NPVariant *value)
{
return false;
}
bool VlcRuntimeRootObject::removeProperty(int index)
{
return false;
}
bool VlcRuntimeRootObject::invoke(int index, const NPVariant *args, uint32_t argCount, NPVariant *result)
{
VlcPlugin *plugin = (VlcPlugin *)(_instance->pdata);
if( plugin )
{
VlcIntf *peer = plugin->GetPeer();
switch( index )
{
case ID_play:
peer->Play();
VOID_TO_NPVARIANT(*result);
return true;
case ID_pause:
peer->Pause();
VOID_TO_NPVARIANT(*result);
return true;
case ID_stop:
peer->Stop();
VOID_TO_NPVARIANT(*result);
return true;
case ID_fullscreen:
peer->Fullscreen();
VOID_TO_NPVARIANT(*result);
return true;
case ID_set_volume:
if( argCount == 1 )
{
peer->Set_volume(NPVariantToPRInt64(args[0]));
VOID_TO_NPVARIANT(*result);
return true;
}
return false;
case ID_get_volume:
{
PRInt64 val;
peer->Get_volume(&val);
INT32_TO_NPVARIANT(val, *result);
return true;
}
case ID_mute:
peer->Mute();
VOID_TO_NPVARIANT(*result);
return true;
case ID_get_int_variable:
if( (argCount == 1)
&& NPVARIANT_IS_STRING(args[0]) )
{
const NPString &name = NPVARIANT_TO_STRING(args[0]);
NPUTF8 *s = new NPUTF8[name.utf8length+1];
if( s )
{
PRInt64 val;
strncpy(s, name.utf8characters, name.utf8length);
s[name.utf8length] = '\0';
peer->Get_int_variable(s, &val);
INT32_TO_NPVARIANT(val, *result);
delete s;
return true;
}
}
return false;
case ID_set_int_variable:
if( (argCount == 2)
&& NPVARIANT_IS_STRING(args[0]) )
{
const NPString &name = NPVARIANT_TO_STRING(args[0]);
NPUTF8 *s = new NPUTF8[name.utf8length+1];
if( s )
{
strncpy(s, name.utf8characters, name.utf8length);
s[name.utf8length] = '\0';
peer->Set_int_variable(s, NPVariantToPRInt64(args[1]));
delete s;
VOID_TO_NPVARIANT(*result);
return true;
}
}
return false;
case ID_get_bool_variable:
if( (argCount == 1)
&& NPVARIANT_IS_STRING(args[0]) )
{
const NPString &name = NPVARIANT_TO_STRING(args[0]);
NPUTF8 *s = new NPUTF8[name.utf8length+1];
if( s )
{
PRBool val;
strncpy(s, name.utf8characters, name.utf8length);
s[name.utf8length] = '\0';
peer->Get_bool_variable(s, &val);
BOOLEAN_TO_NPVARIANT(val, *result);
delete s;
return true;
}
}
return false;
case ID_set_bool_variable:
if( (argCount == 2)
&& NPVARIANT_IS_STRING(args[0])
&& NPVARIANT_IS_BOOLEAN(args[1]) )
{
const NPString &name = NPVARIANT_TO_STRING(args[0]);
NPUTF8 *s = new NPUTF8[name.utf8length+1];
if( s )
{
strncpy(s, name.utf8characters, name.utf8length);
s[name.utf8length] = '\0';
peer->Set_bool_variable(s, NPVARIANT_TO_BOOLEAN(args[1]));
delete s;
VOID_TO_NPVARIANT(*result);
return true;
}
}
return false;
case ID_get_str_variable:
if( (argCount == 1)
&& NPVARIANT_IS_STRING(args[0]) )
{
const NPString &name = NPVARIANT_TO_STRING(args[0]);
NPUTF8 *s = new NPUTF8[name.utf8length+1];
if( s )
{
char *val;
strncpy(s, name.utf8characters, name.utf8length);
s[name.utf8length] = '\0';
peer->Get_str_variable(s, &val);
delete s;
int len = strlen(val);
NPUTF8 *retval = (NPUTF8 *)NPN_MemAlloc(len);
if( retval )
{
memcpy(retval, val, len);
STRINGN_TO_NPVARIANT(retval, len, *result);
free(val);
return true;
}
free(val);
}
}
return false;
case ID_set_str_variable:
if( (argCount == 2)
&& NPVARIANT_IS_STRING(args[0])
&& NPVARIANT_IS_STRING(args[1]) )
{
const NPString &name = NPVARIANT_TO_STRING(args[0]);
NPUTF8 *s = new NPUTF8[name.utf8length+1];
if( s )
{
strncpy(s, name.utf8characters, name.utf8length);
s[name.utf8length] = '\0';
const NPString &val = NPVARIANT_TO_STRING(args[1]);
NPUTF8 *v = new NPUTF8[val.utf8length+1];
if( v )
{
strncpy(v, val.utf8characters, val.utf8length);
v[val.utf8length] = '\0';
peer->Set_str_variable(s, v);
delete s;
delete v;
VOID_TO_NPVARIANT(*result);
return true;
}
delete s;
}
}
return false;
case ID_clear_playlist:
peer->Clear_playlist();
VOID_TO_NPVARIANT(*result);
return true;
case ID_add_item:
if( (argCount == 1)
&& NPVARIANT_IS_STRING(args[0]) )
{
const NPString &name = NPVARIANT_TO_STRING(args[0]);
NPUTF8 *s = new NPUTF8[name.utf8length+1];
if( s )
{
strncpy(s, name.utf8characters, name.utf8length);
s[name.utf8length] = '\0';
peer->Add_item(s);
delete s;
return true;
}
}
return false;
case ID_next:
peer->Next();
VOID_TO_NPVARIANT(*result);
return true;
case ID_previous:
peer->Previous();
VOID_TO_NPVARIANT(*result);
return true;
case ID_isplaying:
{
PRBool val;
peer->Isplaying(&val);
BOOLEAN_TO_NPVARIANT(val, *result);
return true;
}
case ID_get_length:
{
PRInt64 val;
peer->Get_length(&val);
DOUBLE_TO_NPVARIANT(val, *result);
return true;
}
case ID_get_position:
{
PRInt64 val;
peer->Get_position(&val);
INT32_TO_NPVARIANT(val, *result);
return true;
}
case ID_get_time:
{
PRInt64 val;
peer->Get_time(&val);
INT32_TO_NPVARIANT(val, *result);
return true;
}
case ID_seek:
if( argCount == 2 )
{
peer->Seek(NPVariantToPRInt64(args[0]), NPVariantToPRInt64(args[1]));
VOID_TO_NPVARIANT(*result);
return true;
}
return false;
}
NS_RELEASE(peer);
}
return false;
}
bool VlcRuntimeRootObject::invokeDefault(const NPVariant *args, uint32_t argCount, NPVariant *result)
{
return false;
}

261
mozilla/vlcruntime.h Executable file
View File

@ -0,0 +1,261 @@
/*****************************************************************************
* vlcruntime.h: a VLC plugin for Mozilla
*****************************************************************************
* Copyright (C) 2002-2005 the VideoLAN team
* $Id: vlcruntime.h 14466 2006-02-22 23:34:54Z dionoea $
*
* Authors: Damien Fouilleul <damien.fouilleul@laposte.net>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
*****************************************************************************/
/*
** support framework for runtime script objects
*/
class VlcRuntimeObject : public NPObject
{
public:
VlcRuntimeObject(NPP instance, const NPClass *aClass) :
_instance(instance)
{
_class = const_cast<NPClass *>(aClass);
referenceCount = 1;
};
virtual ~VlcRuntimeObject() {};
virtual bool getProperty(int index, NPVariant *result) = 0;
virtual bool setProperty(int index, const NPVariant *value) = 0;
virtual bool removeProperty(int index) = 0;
virtual bool invoke(int index, const NPVariant *args, uint32_t argCount, NPVariant *result) = 0;
virtual bool invokeDefault(const NPVariant *args, uint32_t argCount, NPVariant *result) = 0;
NPP _instance;
};
template<class T> class VlcRuntimeClass : public NPClass
{
public:
VlcRuntimeClass();
virtual ~VlcRuntimeClass();
VlcRuntimeObject *create(NPP instance) const;
int indexOfMethod(NPIdentifier name) const;
int indexOfProperty(NPIdentifier name) const;
private:
NPIdentifier *propertyIdentifiers;
NPIdentifier *methodIdentifiers;
};
template<class T>
static NPObject *vlcRuntimeClassAllocate(NPP instance, NPClass *aClass)
{
const VlcRuntimeClass<T> *vClass = static_cast<VlcRuntimeClass<T> *>(aClass);
return (NPObject *)vClass->create(instance);
}
template<class T>
static void vlcRuntimeClassDeallocate(NPObject *npobj)
{
VlcRuntimeObject *vObj = static_cast<VlcRuntimeObject *>(npobj);
delete vObj;
}
template<class T>
static void vlcRuntimeClassInvalidate(NPObject *npobj)
{
VlcRuntimeObject *vObj = static_cast<VlcRuntimeObject *>(npobj);
vObj->_instance = NULL;
}
template<class T>
bool vlcRuntimeClassHasMethod(NPObject *npobj, NPIdentifier name)
{
const VlcRuntimeClass<T> *vClass = static_cast<VlcRuntimeClass<T> *>(npobj->_class);
return vClass->indexOfMethod(name) != -1;
}
template<class T>
bool vlcRuntimeClassHasProperty(NPObject *npobj, NPIdentifier name)
{
const VlcRuntimeClass<T> *vClass = static_cast<VlcRuntimeClass<T> *>(npobj->_class);
return vClass->indexOfProperty(name) != -1;
}
template<class T>
bool vlcRuntimeClassGetProperty(NPObject *npobj, NPIdentifier name, NPVariant *result)
{
const VlcRuntimeClass<T> *vClass = static_cast<VlcRuntimeClass<T> *>(npobj->_class);
int index = vClass->indexOfProperty(name);
if( index != -1 )
{
VlcRuntimeObject *vObj = static_cast<VlcRuntimeObject *>(npobj);
return vObj->getProperty(index, result);
}
return false;
}
template<class T>
bool vlcRuntimeClassSetProperty(NPObject *npobj, NPIdentifier name, const NPVariant *value)
{
const VlcRuntimeClass<T> *vClass = static_cast<VlcRuntimeClass<T> *>(npobj->_class);
int index = vClass->indexOfProperty(name);
if( index != -1 )
{
VlcRuntimeObject *vObj = static_cast<VlcRuntimeObject *>(npobj);
return vObj->setProperty(index, value);
}
return false;
}
template<class T>
bool vlcRuntimeClassRemoveProperty(NPObject *npobj, NPIdentifier name)
{
const VlcRuntimeClass<T> *vClass = static_cast<VlcRuntimeClass<T> *>(npobj->_class);
int index = vClass->indexOfProperty(name);
if( index != -1 )
{
VlcRuntimeObject *vObj = static_cast<VlcRuntimeObject *>(npobj);
return vObj->removeProperty(index);
}
return false;
}
template<class T>
static bool vlcRuntimeClassInvoke(NPObject *npobj, NPIdentifier name,
const NPVariant *args, uint32_t argCount,
NPVariant *result)
{
const VlcRuntimeClass<T> *vClass = static_cast<VlcRuntimeClass<T> *>(npobj->_class);
int index = vClass->indexOfMethod(name);
if( index != -1 )
{
VlcRuntimeObject *vObj = static_cast<VlcRuntimeObject *>(npobj);
return vObj->invoke(index, args, argCount, result);
}
return false;
}
template<class T>
static bool vlcRuntimeClassInvokeDefault(NPObject *npobj,
const NPVariant *args,
uint32_t argCount,
NPVariant *result)
{
VlcRuntimeObject *vObj = static_cast<VlcRuntimeObject *>(npobj);
return vObj->invokeDefault(args, argCount, result);
}
template<class T>
VlcRuntimeClass<T>::VlcRuntimeClass()
{
// retreive property identifiers from names
if( T::propertyCount > 0 )
{
propertyIdentifiers = new NPIdentifier[T::propertyCount];
if( propertyIdentifiers )
NPN_GetStringIdentifiers(const_cast<const NPUTF8**>(T::propertyNames),
T::propertyCount, propertyIdentifiers);
}
// retreive method identifiers from names
if( T::methodCount > 0 )
{
methodIdentifiers = new NPIdentifier[T::methodCount];
if( methodIdentifiers )
NPN_GetStringIdentifiers(const_cast<const NPUTF8**>(T::methodNames),
T::methodCount, methodIdentifiers);
}
// fill in NPClass structure
structVersion = NP_CLASS_STRUCT_VERSION;
allocate = vlcRuntimeClassAllocate<T>;
deallocate = vlcRuntimeClassDeallocate<T>;
invalidate = vlcRuntimeClassInvalidate<T>;
hasMethod = vlcRuntimeClassHasMethod<T>;
invoke = vlcRuntimeClassInvoke<T>;
invokeDefault = vlcRuntimeClassInvokeDefault<T>;
hasProperty = vlcRuntimeClassHasProperty<T>;
getProperty = vlcRuntimeClassGetProperty<T>;
setProperty = vlcRuntimeClassSetProperty<T>;
removeProperty = vlcRuntimeClassRemoveProperty<T>;
}
template<class T>
VlcRuntimeClass<T>::~VlcRuntimeClass()
{
delete propertyIdentifiers;
delete methodIdentifiers;
}
template<class T>
VlcRuntimeObject *VlcRuntimeClass<T>::create(NPP instance) const
{
return new T(instance, this);
}
template<class T>
int VlcRuntimeClass<T>::indexOfMethod(NPIdentifier name) const
{
if( methodIdentifiers )
{
for(int c=0; c< T::methodCount; ++c )
{
if( name == methodIdentifiers[c] )
return c;
}
}
return -1;
}
template<class T>
int VlcRuntimeClass<T>::indexOfProperty(NPIdentifier name) const
{
if( propertyIdentifiers )
{
for(int c=0; c< T::propertyCount; ++c )
{
if( name == propertyIdentifiers[c] )
return c;
}
}
return -1;
}
/*
** defined runtime script objects
*/
class VlcRuntimeRootObject: public VlcRuntimeObject
{
public:
VlcRuntimeRootObject(NPP instance, const NPClass *aClass) :
VlcRuntimeObject(instance, aClass) {};
virtual ~VlcRuntimeRootObject() {};
static const int propertyCount;
static const NPUTF8 * const propertyNames[];
static const int methodCount;
static const NPUTF8 * const methodNames[];
virtual bool getProperty(int index, NPVariant *result);
virtual bool setProperty(int index, const NPVariant *value);
virtual bool removeProperty(int index);
virtual bool invoke(int index, const NPVariant *args, uint32_t argCount, NPVariant *result);
virtual bool invokeDefault(const NPVariant *args, uint32_t argCount, NPVariant *result);
};

157
mozilla/vlcshell.cpp
View File

@ -45,36 +45,15 @@
#include <nsISupports.h>
#include <nsMemory.h>
#include <npapi.h>
#include <npruntime.h>
/* This is from mozilla java, do we really need it? */
#if 0
#include <jri.h>
#endif
#if !defined(XP_MACOSX) && !defined(XP_UNIX) && !defined(XP_WIN)
#define XP_UNIX 1
#elif defined(XP_MACOSX)
#undef XP_UNIX
#endif
#ifdef XP_WIN
/* Windows stuff */
#endif
#ifdef XP_MACOSX
/* Mac OS X stuff */
# include <Quickdraw.h>
#endif
#ifdef XP_UNIX
/* X11 stuff */
# include <X11/Xlib.h>
# include <X11/Intrinsic.h>
# include <X11/StringDefs.h>
#endif
#include "vlcpeer.h"
#include "vlcplugin.h"
#include "vlcruntime.h"
#if USE_LIBVLC
# define WINDOW_TEXT "(no picture)"
@ -103,8 +82,8 @@ static void Resize( Widget w, XtPointer closure, XEvent *event );
* MacOS-only declarations
******************************************************************************/
#ifdef XP_MACOSX
# define VOUT_PLUGINS "macosx"
# define AOUT_PLUGINS "macosx"
# define VOUT_PLUGINS "macosx,dummy"
# define AOUT_PLUGINS "auhal,macosx,dummy"
#endif
@ -181,6 +160,15 @@ NPError NPP_GetValue( NPP instance, NPPVariable variable, void *value )
**(nsIID**)value = nsid;
break;
case NPPVpluginScriptableNPObject:
static VlcRuntimeClass<VlcRuntimeRootObject> *rootClass = new VlcRuntimeClass<VlcRuntimeRootObject>;
*(NPObject**)value = NPN_CreateObject(instance, rootClass);
if( *(NPObject**)value == NULL )
{
return NPERR_OUT_OF_MEMORY_ERROR;
}
break;
default:
return NPERR_GENERIC_ERROR;
}
@ -194,26 +182,67 @@ NPError NPP_GetValue( NPP instance, NPPVariable variable, void *value )
#ifdef XP_MACOSX
int16 NPP_HandleEvent( NPP instance, void * event )
{
VlcPlugin *p_plugin = (VlcPlugin*)instance->pdata;
vlc_value_t value;
if( instance == NULL )
{
return false;
}
EventRecord *pouetEvent = (EventRecord*)event;
VlcPlugin *p_plugin = (VlcPlugin*)instance->pdata;
EventRecord *myEvent = (EventRecord*)event;
if (pouetEvent->what == 6)
switch( myEvent->what )
{
value.i_int = 1;
VLC_VariableSet( p_plugin->i_vlc, "drawableredraw", value );
return true;
case nullEvent:
break;
case mouseDown:
case mouseUp:
return true;
case keyUp:
case keyDown:
case autoKey:
return true;
case updateEvt:
{
NPWindow *npwindow = p_plugin->window;
NP_Port *npport = (NP_Port *)(npwindow->window);
SetPort( npport->port );
//SetOrigin( npport->portx , npport->porty);
/* draw the beautiful "No Picture" */
ForeColor(blackColor);
PenMode( patCopy );
Rect rect;
rect.left = 0;
rect.top = 0;
rect.right = npwindow->width;
rect.bottom = npwindow->height;
PaintRect( &rect );
ForeColor(whiteColor);
char *text = strdup( WINDOW_TEXT );
MoveTo( (npwindow->width-80)/ 2 , npwindow->height / 2 );
DrawText( text , 0 , strlen(text) );
free(text);
return true;
}
case activateEvt:
return false;
case NPEventType_GetFocusEvent:
case NPEventType_LoseFocusEvent:
return true;
case NPEventType_AdjustCursorEvent:
return false;
case NPEventType_ScrollingBeginsEvent:
case NPEventType_ScrollingEndsEvent:
return true;
default:
;
}
Boolean eventHandled = false;
return eventHandled;
return false;
}
#endif /* XP_MACOSX */
@ -287,20 +316,14 @@ NPError NPP_New( NPMIMEType pluginType, NPP instance, uint16 mode, int16 argc,
{
#ifdef XP_MACOSX
char *home_user;
char *directory;
char *plugin_path;
char *ppsz_argv[] = { "vlc", "--plugin-path", NULL };
home_user = strdup( getenv("HOME") );
directory = strdup( "/Library/Internet Plug-Ins/VLC Plugin.plugin/"
"Contents/MacOS/modules" );
plugin_path = (char *)malloc( strlen( directory ) + strlen( home_user ) );
memcpy( plugin_path , home_user , strlen(home_user) );
memcpy( plugin_path + strlen( home_user ) , directory ,
strlen( directory ) );
ppsz_argv[2] = plugin_path;
char *ppsz_argv[] =
{
"vlc",
"-vvvv",
"--plugin-path",
"/Library/Internet Plug-Ins/VLC Plugin.plugin/"
"Contents/MacOS/modules"
};
#elif defined(XP_WIN)
char *ppsz_argv[] = { NULL, "-vv" };
@ -328,7 +351,8 @@ NPError NPP_New( NPMIMEType pluginType, NPP instance, uint16 mode, int16 argc,
char *ppsz_argv[] =
{
"vlc"
/*, "--plugin-path", "/home/sam/videolan/vlc_MAIN/plugins"*/
"-vvvv"
/*, "--plugin-path", ""*/
};
#endif /* XP_MACOSX */
@ -350,11 +374,6 @@ NPError NPP_New( NPMIMEType pluginType, NPP instance, uint16 mode, int16 argc,
i_ret = VLC_Init( p_plugin->i_vlc, sizeof(ppsz_argv)/sizeof(char*),
ppsz_argv );
#ifdef XP_MACOSX
free( home_user );
free( directory );
free( plugin_path );
#endif /* XP_MACOSX */
}
if( i_ret )
@ -519,8 +538,7 @@ NPError NPP_SetWindow( NPP instance, NPWindow* window )
vlc_value_t valuer;
vlc_value_t valueportx;
vlc_value_t valueporty;
Rect black_rect;
char * text;
vlc_value_t valueredraw;
#endif /* XP_MACOSX */
if( instance == NULL )
@ -562,29 +580,14 @@ NPError NPP_SetWindow( NPP instance, NPWindow* window )
p_plugin->window = window;
/* draw the beautiful "No Picture" */
black_rect.top = valuet.i_int - valuey.i_int;
black_rect.left = valuel.i_int - valuex.i_int;
black_rect.bottom = valueb.i_int - valuey.i_int;
black_rect.right = valuer.i_int - valuex.i_int;
SetPort( (GrafPtr)value.i_int );
SetOrigin( valueportx.i_int , valueporty.i_int );
ForeColor(blackColor);
PenMode( patCopy );
PaintRect( &black_rect );
ForeColor(whiteColor);
text = strdup( WINDOW_TEXT );
MoveTo( valuew.i_int / 2 - 40 , valueh.i_int / 2 );
DrawText( text , 0 , strlen(text) );
free(text);
valueredraw.i_int = 1;
VLC_VariableSet( p_plugin->i_vlc, "drawableredraw", valueredraw );
#else /* XP_MACOSX */
/* FIXME: this cast sucks */
value.i_int = (int) (ptrdiff_t) (void *) window->window;
VLC_VariableSet( p_plugin->i_vlc, "drawable", value );
#endif /* XP_MACOSX */
#endif /* USE_LIBVLC */