osmozilla.cpp

一个用于智能手机的多媒体库适合S60 WinCE的跨平台开发库

	m_width = aWindow->width;
	m_height = aWindow->height;

	m_user.EventProc = Osmozilla_EventProc;
	
#ifdef XP_WIN
	m_user.os_window_handler = aWindow->window;
#endif

#ifdef XP_UNIX
	m_user.os_window_handler = aWindow->window;
	/*HACK - although we don't use the display in the X11 plugin, this is used to signal that 
	the user is mozilla and prevent some X11 calls crashing the browser in file playing mode 
	(eg, "firefox myfile.mp4" )*/
	m_user.os_display =((NPSetWindowCallbackStruct *)aWindow->ws_info)->display;
	XSynchronize((Display *) m_user.os_display, True);
	m_user.os_window_handler = aWindow->window;
#endif

 	m_prev_time = 0;
	m_url_changed = 0;
	SetOptions();
 
    /*setup 3D mode if requested*/
	if (m_szURL && (strstr(m_szURL, ".wrl") || strstr(m_szURL, ".x3d") || strstr(m_szURL, ".x3dv"))) {
		gf_cfg_set_key(m_user.config, "Rendering", "RendererName", "GPAC 3D Renderer");
	} else {
		gf_cfg_set_key(m_user.config, "Rendering", "RendererName", m_bUse3D ? "GPAC 3D Renderer" : "GPAC 2D Renderer");
	}
	m_term = gf_term_new(&m_user);
	if (! m_term) return FALSE;

	mInitialized = TRUE;
	
	/*stream not ready*/
	if (!m_szURL || !m_bAutoStart) return TRUE;

	/*connect from 0 and pause if not autoplay*/
	gf_term_connect(m_term, m_szURL);
	return TRUE;
}

void nsOsmozillaInstance::SetOptions()
{
	m_bLoop = 0;
	m_bAutoStart = 1;
	m_bUse3D = 0;		

	/*options sent from plugin*/
	for(int i=0;i<m_argc;i++) {   
		if (!stricmp(m_argn[i],"autostart") && (!stricmp(m_argv[i], "false") || !stricmp(m_argv[i], "no")) ) 
			m_bAutoStart = 0;

		else if (!stricmp(m_argn[i],"src") ) {
			if (m_szURL) free(m_szURL);
			m_szURL = strdup(m_argv[i]);
		}
		else if (!stricmp(m_argn[i],"use3d") && (!stricmp(m_argv[i], "true") || !stricmp(m_argv[i], "yes") ) ) {
			m_bUse3D = 1;
		}
		else if (!stricmp(m_argn[i],"loop") && (!stricmp(m_argv[i], "true") || !stricmp(m_argv[i], "yes") ) ) {
			m_bLoop = 1;
		}
		else if (!stricmp(m_argn[i],"aspectratio")) {
			u32 ar = GF_ASPECT_RATIO_KEEP;
			if (!stricmp(m_argv[i], "keep")) ar = GF_ASPECT_RATIO_KEEP;
			else if (!stricmp(m_argv[i], "16:9")) ar = GF_ASPECT_RATIO_16_9;
			else if (!stricmp(m_argv[i], "4:3")) ar = GF_ASPECT_RATIO_4_3;
			else if (!stricmp(m_argv[i], "fill")) ar = GF_ASPECT_RATIO_FILL_SCREEN;
			gf_term_set_option(m_term, GF_OPT_ASPECT_RATIO, ar);
		}
	}

	/*URL is not absolute, request new stream to mozilla - we don't pass absolute URLs since some may not be 
	handled by gecko */
	if (m_szURL) {
		Bool absolute_url = 0;
		if (strstr(m_szURL, "://")) absolute_url = 1;
		else if (m_szURL[0] == '/') {
			FILE *test = fopen(m_szURL, "rb");
			if (test) {	
				absolute_url = 1;
				fclose(test);
			}
		}
		else if ((m_szURL[1] == ':') && (m_szURL[2] == '\\')) absolute_url = 1;

		if (!absolute_url) {
			char *url = m_szURL;
			m_szURL = NULL;
			NPN_GetURL(mInstance, url, NULL);
			free(url);
		}
	}

}

void nsOsmozillaInstance::ReloadTerminal()
{
	GF_Terminal *a_term;
	const char *rend;
	Bool needs_3d;
	if (!m_szURL || m_bUse3D) return;

	if (m_szURL && (strstr(m_szURL, ".wrl") || strstr(m_szURL, ".x3d") || strstr(m_szURL, ".x3dv"))) {
		needs_3d = 1;
	} else {
		needs_3d = 0;
	}
	rend = gf_cfg_get_key(m_user.config, "Rendering", "RendererName");
	if (strstr(rend, "3D") && needs_3d) return;
	if (strstr(rend, "2D") && !needs_3d) return;

	a_term = m_term;
	m_term = NULL;
	gf_term_del(a_term);
	gf_cfg_set_key(m_user.config, "Rendering", "RendererName", needs_3d ? "GPAC 3D Renderer" : "GPAC 2D Renderer");
	m_term = gf_term_new(&m_user);
}

NPError nsOsmozillaInstance::NewStream(NPMIMEType type, NPStream * stream,
				    NPBool seekable, uint16 * stype)
{
	if (m_szURL) free(m_szURL);
	m_szURL = strdup((const char *)stream->url);

	ReloadTerminal();
	/*connect from 0 and pause if not autoplay*/
	if (m_bAutoStart)
		gf_term_connect(m_term, m_szURL);

	/*we handle data fetching ourselves*/
    *stype = NP_SEEK;
    return NPERR_NO_ERROR;
}

NPError nsOsmozillaInstance::DestroyStream(NPStream * stream, NPError reason)
{
	if (m_szURL) {
		gf_term_disconnect(m_term);
		free(m_szURL);
		m_szURL = NULL;
	}
	return NPERR_NO_ERROR;
}

uint16 nsOsmozillaInstance::HandleEvent(void* event)
{
  return true;
}
 
void nsOsmozillaInstance::Pause()
{
	if (m_term) {
		if (gf_term_get_option(m_term, GF_OPT_PLAY_STATE) == GF_STATE_PAUSED) {
	        gf_term_set_option(m_term, GF_OPT_PLAY_STATE, GF_STATE_PLAYING);
		} else {
	        gf_term_set_option(m_term, GF_OPT_PLAY_STATE, GF_STATE_PAUSED);
		}
	}
}

void nsOsmozillaInstance::Play()
{
	if (!m_bIsConnected) {
		if (m_szURL) gf_term_connect(m_term, (const char *) m_szURL);
	} else {
		gf_term_set_option(m_term, GF_OPT_PLAY_STATE, GF_STATE_PLAYING);
	}
}

void nsOsmozillaInstance::Stop()
{
	gf_term_disconnect(m_term);
}

#ifdef XP_WIN
PBITMAPINFO CreateBitmapInfoStruct(GF_VideoSurface *pfb)
{ 
    PBITMAPINFO pbmi; 
    WORD    cClrBits; 

	cClrBits = 32;

    pbmi = (PBITMAPINFO) LocalAlloc(LPTR, 
                    sizeof(BITMAPINFOHEADER)); 

    pbmi->bmiHeader.biSize = sizeof(BITMAPINFOHEADER); 
	pbmi->bmiHeader.biWidth = pfb->width;
	pbmi->bmiHeader.biHeight = 1;
    pbmi->bmiHeader.biPlanes = 1; 
    pbmi->bmiHeader.biBitCount = cClrBits; 

    pbmi->bmiHeader.biCompression = BI_RGB; 
    pbmi->bmiHeader.biSizeImage = ((pbmi->bmiHeader.biWidth * cClrBits +31) & ~31) /8
                                  * pbmi->bmiHeader.biHeight; 
     pbmi->bmiHeader.biClrImportant = 0; 
     return pbmi; 
}
#endif

void nsOsmozillaInstance::Print(NPPrint* printInfo)
{
	if (printInfo->mode == NP_EMBED)
	{
		NPEmbedPrint *ep = (NPEmbedPrint *)printInfo;
#ifdef XP_MACOS
		/*
		ep->platformPrint contains a THPrint reference on MacOS
		*/
		}
#endif  // XP_MACOS
#ifdef XP_UNIX
		/*
		ep->platformPrint  contains a NPPrintCallbackStruct on Unix and
		the plug-in location and size in the NPWindow are in page coordinates (720/ inch), but the printer requires point coordinates (72/inch)
		*/
#endif  // XP_UNIX
#ifdef XP_WIN
		/*
		The coordinates for the window rectangle are in TWIPS format. 
		This means that you need to convert the x-y coordinates using the Windows API call DPtoLP when you output text
		*/
		HDC pDC = (HDC)printInfo->print.embedPrint.platformPrint;
		GF_VideoSurface fb;
		u32 xsrc, ysrc;
		u16 src_16;
		char *src;
		/*lock the source buffer */
		gf_term_get_screen_buffer(m_term, &fb);
		BITMAPINFO	*infoSrc = CreateBitmapInfoStruct(&fb);
		float deltay = (float)printInfo->print.embedPrint.window.height/(float)fb.height;
		int	ysuiv = 0;
		char *ligne = (char *) LocalAlloc(GMEM_FIXED, fb.width*4);
		for (ysrc=0; ysrc<fb.height; ysrc++)
		{
			char *dst = (char*)ligne;
			src = fb.video_buffer + ysrc * fb.pitch;
			for (xsrc=0; xsrc<fb.width; xsrc++)
			{
				switch (fb.pixel_format) {
				case GF_PIXEL_RGB_32:
				case GF_PIXEL_ARGB:
					dst[0] = src[0];
					dst[1] = src[1];
					dst[2] = src[2];
					src+=4;
					break;
				case GF_PIXEL_BGR_32:
				case GF_PIXEL_RGBA:
					dst[0] = src[3];
					dst[1] = src[2];
					dst[2] = src[1];
					src+=4;
					break;
				case GF_PIXEL_RGB_24:
					dst[0] = src[2];
					dst[1] = src[1];
					dst[2] = src[0];
					src+=3;
					break;
				case GF_PIXEL_BGR_24:
					dst[0] = src[2];
					dst[1] = src[1];
					dst[2] = src[0];
					src+=3;
					break;
				case GF_PIXEL_RGB_565:
					src_16 = * ( (u16 *)src );
					dst[2] = (src_16 >> 8) & 0xf8;
					dst[2] += dst[2]>>5;
					dst[1] = (src_16 >> 3) & 0xfc;
					dst[1] += dst[1]>>6;
					dst[0] = (src_16 << 3) & 0xf8;
					dst[0] += dst[0]>>5;
					src+=2;
					break;
				case GF_PIXEL_RGB_555:
					src_16 = * (u16 *)src;
					dst[2] = (src_16 >> 7) & 0xf8;
					dst[2] += dst[2]>>5;
					dst[1] = (src_16 >> 2) & 0xf8;
					dst[1] += dst[1]>>5;
					dst[0] = (src_16 << 3) & 0xf8;
					dst[0] += dst[0]>>5;
					src+=2;
					break;
				}
				dst += 4;
			}
			int ycrt = ysuiv;
			ysuiv = (u32) ( ((float)ysrc+1.0)*deltay);
			int delta = ysuiv-ycrt;
			StretchDIBits(
				pDC, printInfo->print.embedPrint.window.x, ycrt+printInfo->print.embedPrint.window.y, printInfo->print.embedPrint.window.width, 
				delta, 
				0, 0, fb.width, 1,
				ligne, infoSrc, DIB_RGB_COLORS, SRCCOPY);
		}

		/*unlock GPAC frame buffer */
		gf_term_release_screen_buffer(m_term, &fb);
		/* free temporary  objects */
		GlobalFree(ligne);
		LocalFree(infoSrc);
#endif   // XP_WIN
	} else if (printInfo->mode == NP_FULL)
	{
		NPFullPrint *ep = (NPFullPrint *)printInfo;
		// TODO present the print dialog and manage the print
	}
}

#include <gpac/term_info.h>
void nsOsmozillaInstance::Update(const char *type, const char *commands)
{
	if (m_term) {
		GF_Err e = gf_term_scene_update(m_term, (char *) type, (char *) commands);
		if (e) {
			char szMsg[1024];
			sprintf((char *)szMsg, "GPAC: Error applying update (%s)", gf_error_to_string(e) );
			NPN_Status(mInstance, szMsg);
		}
	}
}


// Scriptability related code

nsOsmozillaPeer *nsOsmozillaInstance::getScriptablePeer()
{
    if (!mScriptablePeer) {
		mScriptablePeer = new nsOsmozillaPeer(this);
		if (!mScriptablePeer) return NULL;
		NS_ADDREF(mScriptablePeer);
    }
    NS_ADDREF(mScriptablePeer);
    return mScriptablePeer;
}

static NS_DEFINE_IID(kIZillaPluginIID, NS_IOSMOZILLA_IID);
static NS_DEFINE_IID(kIClassInfoIID, NS_ICLASSINFO_IID);
static NS_DEFINE_IID(kISupportsIID, NS_ISUPPORTS_IID);

nsOsmozillaPeer::nsOsmozillaPeer(nsOsmozillaInstance * aPlugin)
{
	mPlugin=aPlugin;
	mRefCnt = 0;
}

nsOsmozillaPeer::~nsOsmozillaPeer()
{
}
	// Notice that we expose our claim to implement nsIClassInfo.
//NS_IMPL_ISUPPORTS2(nsOsmozillaPeer, nsITestPlugin, nsIClassInfo)

	// the following method will be callable from JavaScript
NS_IMETHODIMP nsOsmozillaPeer::Pause() { mPlugin->Pause(); return NS_OK; }
NS_IMETHODIMP nsOsmozillaPeer::Play() { mPlugin->Play(); return NS_OK; }
NS_IMETHODIMP nsOsmozillaPeer::Stop() { mPlugin->Stop(); return NS_OK; }

NS_IMETHODIMP nsOsmozillaPeer::Update(const char *type, const char *commands) 
{
	mPlugin->Update(type, commands); 
	return NS_OK; 
}

void nsOsmozillaPeer::SetInstance(nsOsmozillaInstance * plugin)
{
    mPlugin = plugin;
}

NS_IMETHODIMP_(nsrefcnt) nsOsmozillaPeer::AddRef()
{
    ++mRefCnt;
    return mRefCnt;
}

NS_IMETHODIMP_(nsrefcnt) nsOsmozillaPeer::Release()
{
    --mRefCnt;
    if (mRefCnt == 0) {
		delete this;
		return 0;
    }
    return mRefCnt;
}

// here nsOsmozillaPeer should return three interfaces it can be asked for by their iid's
// static casts are necessary to ensure that correct pointer is returned
NS_IMETHODIMP nsOsmozillaPeer::QueryInterface(const nsIID & aIID,
					       void **aInstancePtr)
{
    if (!aInstancePtr)
		return NS_ERROR_NULL_POINTER;

    if (aIID.Equals(kIZillaPluginIID)) {
		*aInstancePtr = NS_STATIC_CAST(nsIOsmozilla *, this);
		AddRef();
		return NS_OK;
    }
    
	if (aIID.Equals(kIClassInfoIID)) {
		*aInstancePtr = NS_STATIC_CAST(nsIClassInfo *, this);
		AddRef();
		return NS_OK;
    }

    if (aIID.Equals(kISupportsIID)) {
		*aInstancePtr = NS_STATIC_CAST(nsISupports *, (NS_STATIC_CAST (nsIOsmozilla *, this)));
		AddRef();
		return NS_OK;
    }
    return NS_NOINTERFACE;
}