rtffplin.cpp

linux下的一款播放器

/* ***** BEGIN LICENSE BLOCK *****
 * Source last modified: $Id: rtffplin.cpp,v 1.1.2.1 2004/07/09 01:50:34 hubbe Exp $
 * 
 * Portions Copyright (c) 1995-2004 RealNetworks, Inc. All Rights Reserved.
 * 
 * The contents of this file, and the files included with this file,
 * are subject to the current version of the RealNetworks Public
 * Source License (the "RPSL") available at
 * http://www.helixcommunity.org/content/rpsl unless you have licensed
 * the file under the current version of the RealNetworks Community
 * Source License (the "RCSL") available at
 * http://www.helixcommunity.org/content/rcsl, in which case the RCSL
 * will apply. You may also obtain the license terms directly from
 * RealNetworks.  You may not use this file except in compliance with
 * the RPSL or, if you have a valid RCSL with RealNetworks applicable
 * to this file, the RCSL.  Please see the applicable RPSL or RCSL for
 * the rights, obligations and limitations governing use of the
 * contents of the file.
 * 
 * Alternatively, the contents of this file may be used under the
 * terms of the GNU General Public License Version 2 or later (the
 * "GPL") in which case the provisions of the GPL are applicable
 * instead of those above. If you wish to allow use of your version of
 * this file only under the terms of the GPL, and not to allow others
 * to use your version of this file under the terms of either the RPSL
 * or RCSL, indicate your decision by deleting the provisions above
 * and replace them with the notice and other provisions required by
 * the GPL. If you do not delete the provisions above, a recipient may
 * use your version of this file under the terms of any one of the
 * RPSL, the RCSL or the GPL.
 * 
 * This file is part of the Helix DNA Technology. RealNetworks is the
 * developer of the Original Code and owns the copyrights in the
 * portions it created.
 * 
 * This file, and the files included with this file, is distributed
 * and made available on an 'AS IS' basis, WITHOUT WARRANTY OF ANY
 * KIND, EITHER EXPRESS OR IMPLIED, AND REALNETWORKS HEREBY DISCLAIMS
 * ALL SUCH WARRANTIES, INCLUDING WITHOUT LIMITATION, ANY WARRANTIES
 * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, QUIET
 * ENJOYMENT OR NON-INFRINGEMENT.
 * 
 * Technology Compatibility Kit Test Suite(s) Location:
 *    http://www.helixcommunity.org/content/tck
 * 
 * Contributor(s):
 * 
 * ***** END LICENSE BLOCK ***** */

/////////////////////////////////////////////////////////////////////////////
// 
//  rtffplin.cpp
// 
//  REALTEXT FILE FORMAT
//
//
//

#define HEADER_OFFSET		    0
#define MAX_HEADER_SIZE		    256 
#define MAX_PKT_HDR_SZ		    1024 
#define MAX_PACKET_SIZE		    500 
#define AVG_PACKET_SIZE		    493 
#define MIN_PACKET_SIZE		    256 
#define TIME_PER_PACKET		    1000
#define DEFAULT_PREROLL_MSEC	    0 
#define DEFAULT_DURATION_MSEC	    60000


#define INITGUID

#include "rtffplin.ver"

#include "hxtypes.h"
#include "hxcom.h"
#include "hxcomm.h"
#include "ihxpckts.h"
#include "hxfiles.h"
#include "hxformt.h"
#include "hxplugn.h"
#include "hxpends.h"
#include "hxmon.h"
#include "hxerror.h"
#include "hxxres.h"
#include "hxxrsmg.h"
#include "hxcore.h"
#include "hxvsrc.h"
#include "rtres.h"
#include "perplex.h"

#include "hxstack.h"
#include "hxslist.h"

#include "rt_types.h"
#include "rltxthdr.h"

#include "fontdefs.h"
#include "txtattrb.h"
#include "txtcntnr.h"
#include "textline.h"

#include "verutil.h" //for IsBeta1Player().

#ifdef _WINDOWS
#ifdef _WIN16
#include <windows.h>
#endif /* _WIN16 */
#endif /* _WINDOWS */

#include "txtwindw.h" //Added for class TextWindow.
#include "textprsr.h" //Added for base class TextParser.

#include "hxstrutl.h"  //for strncasecmp()

#include <string.h>
#include <stdio.h>  // For FILE (if defined _DEBUG && RT_OUTPUT_LOGFILE).

#include "hxengin.h"
#include "rtffplin.h"
#include "chxfgbuf.h"
#include "shadvsrc.h" /* CShadowViewSource */

#include "hxver.h"
#include "defslice.h"

#include "hxheap.h"
#ifdef _DEBUG
#undef HX_THIS_FILE		
static char HX_THIS_FILE[] = __FILE__;
#endif

#ifdef _AIX
#include "dllpath.h"
ENABLE_MULTILOAD_DLLACCESS_PATHS(Rtffplin);
#endif

INT32 g_nRefCount_rtff = 0;

//This is a rough estimate of the size of the stream divided by the size of
// the original rt data in the file, i.e., if the following is 1.XY, then
// the opaque headers added to each packet increase the packet size by
// about XY percent:
#define HEADER_OVERHEAD_FACTOR	1.2

// / 64KB is more than too much to send from a single plain-text file in all
// but some really far-out edge cases.  We'll live with those problems, such
// as a text file referenced in a SMIL 2.0 file with wordwrap param set to
// false but CRs and LFs treated literally, you could have 200000 bytes in
// line one followed by other text that should have displayed on line two (and
// would had the following limit been > 200000).  For PR 78150:
#define MAX_ALLOWED_PLAINTEXT_CHARS_TO_SEND 65535 

/****************************************************************************
 * 
 *  Function:
 * 
 *	HXCreateInstance()
 * 
 *  Purpose:
 * 
 *	Function implemented by all plugin DLL's to create an instance of 
 *	any of the objects supported by the DLL. This method is similar to 
 *	Window's CoCreateInstance() in its purpose, except that it only 
 *	creates objects from this plugin DLL.
 *
 *	NOTE: Aggregation is never used. Therefore and outer unknown is
 *	not passed to this function, and you do not need to code for this
 *	situation.
 * 
 */
STDAPI ENTRYPOINT(HXCreateInstance)
(
    IUnknown**  /*OUT*/	ppIUnknown
)
{
    *ppIUnknown = (IUnknown*)(IHXPlugin*)new CRealTextFileFormat();
    if (*ppIUnknown)
    {
	(*ppIUnknown)->AddRef();
	return HXR_OK;
    }
    return HXR_OUTOFMEMORY;
}

/****************************************************************************
 * 
 *  Function:
 * 
 *	CanUnload()
 * 
 *  Purpose:
 * 
 *	Function implemented by all plugin DLL's if it returns HXR_OK 
 *	then the pluginhandler can unload the DLL
 *
 */
STDAPI ENTRYPOINT(CanUnload)(void)
{
    return (g_nRefCount_rtff? HXR_FAIL : HXR_OK);
}


const char* CRealTextFileFormat::zm_pDescription    = "Helix RealText File Format Plugin";
const char* CRealTextFileFormat::zm_pCopyright      = HXVER_COPYRIGHT;
const char* CRealTextFileFormat::zm_pMoreInfoURL    = HXVER_MOREINFO;

const char* CRealTextFileFormat::zm_pFileMimeTypes[]  = 
	{ "application/vnd.rn-realtext" /* <-- beta2 and beyond */,
	  "text/vnd.rn-realtext" /* for incoming only */,
	  "application/x-pn-realtext" /* <-- beta1 */,
          "text/plain",
          NULL};
const char* CRealTextFileFormat::zm_pFileExtensions[] = 
	{"rtx", "rt", "txt", NULL};  //+XXXEH- add htm and html here when ready.
///XXXEH- add *.txt as soon as it's correctly handled:
const char* CRealTextFileFormat::zm_pFileOpenNames[]  = 
	{"RealText File Format (*.rt)", NULL};


CRealTextFileFormat::CRealTextFileFormat()
    :	m_lRefCount(0)
    ,	m_pContext(NULL)
    ,	m_pRegistry(NULL)
    ,	m_pErrorMessages(NULL)
    ,	m_bRealTextLicensed(FALSE)
    ,	m_pFileObject(NULL)
    ,	m_pFFResponse(NULL)
    ,	m_bHeaderSent(FALSE)
    ,	m_ulCurrentTime(0)
    ,	m_state(Ready)
    ,	m_pRequest(NULL)
    ,	m_ulNextPacketSeekPoint(0)
    ,	m_ulSequenceNum(0)
    ,	m_ulCurPacketSize(0)
    ,	m_ulHeaderSize(MAX_HEADER_SIZE)
    ,	m_ulSizeOfNextReadAfterSeek(0L)
    ,	m_ulLastByteParsedInFile(0L)
    ,	TextParser(&m_txtWin)
    ,	m_pCurTextLine(NULL)
    ,	m_pSavedDataFromLastRead(NULL)
    ,	m_bCurPacketHasREQUIREDContents(FALSE)
    ,   m_ulStartTimeOfTextOfPriorPacket(0L)
    ,	m_pFileStatObj(NULL)
    ,	m_ulTotalFileSizeInBytes(0L)
    ,   m_pszFileMimeType(NULL)
    ,	m_bIsTextPlainStreamMimeType(FALSE)

#ifdef _DEBUG
#if defined(RT_OUTPUT_LOGFILE)
    ,	m_logfile(0)
#endif
#endif
{
    g_nRefCount_rtff++;
};


CRealTextFileFormat::~CRealTextFileFormat()
{
    g_nRefCount_rtff--;
    //Killed mem leak with this:
    m_txtWin.reset(); //flushes all lists and stacks.
    
    Close();
}


/************************************************************************
 *  Method:
 *    IHXPlugin::InitPlugin
 *  Purpose:
 *    Initializes the plugin for use. This interface must always be
 *    called before any other method is called. This is primarily needed 
 *    so that the plugin can have access to the context for creation of
 *    IHXBuffers and IMalloc.
 */
STDMETHODIMP CRealTextFileFormat::InitPlugin(IUnknown* /*IN*/ pContext)
{
    INT32 nLicensed = 0;

    if (HXR_OK != pContext->QueryInterface(IID_IHXErrorMessages, 
				(void**)&m_pErrorMessages))
    {
	return HXR_UNEXPECTED;
    }

    if (HXR_OK != pContext->QueryInterface(IID_IHXRegistry, 
				(void**)&m_pRegistry))
    {
	return HXR_UNEXPECTED;
    }

    m_pContext = pContext;
    m_pContext->AddRef();

    // Figure out if RealText is licensed
    IHXPlayer* pPlayer = NULL;
    if (HXR_OK == m_pContext->QueryInterface(IID_IHXPlayer, (void**)&pPlayer))
    {
        // RealText is always licensed on the Player
        m_bRealTextLicensed = TRUE;
    }
    else
    {
        // On the Server, check the license section of the registry
        if (HXR_OK != m_pRegistry->GetIntByName(
            REGISTRY_REALTEXT_ENABLED, 
            nLicensed))
        {
	    nLicensed = LICENSE_REALTEXT_ENABLED;
        }      
	m_bRealTextLicensed = (nLicensed) ? (TRUE) : (FALSE);
    }
    HX_RELEASE(pPlayer);

    return HXR_OK;
}

/************************************************************************
 *  Method:
 *    IHXPlugin::GetPluginInfo
 *  Purpose:
 *    Returns the basic information about this plugin. Including:
 *
 *    bLoadMultiple	whether or not this plugin DLL can be loaded
 *			multiple times. All File Formats must set
 *			this value to TRUE.
 *    pDescription	which is used in about UIs (can be NULL)
 *    pCopyright	which is used in about UIs (can be NULL)
 *    pMoreInfoURL	which is used in about UIs (can be NULL)
 */
STDMETHODIMP CRealTextFileFormat::GetPluginInfo
(
    REF(BOOL)	    /*OUT*/ bLoadMultiple,
    REF(const char*)/*OUT*/ pDescription,
    REF(const char*)/*OUT*/ pCopyright,
    REF(const char*)/*OUT*/ pMoreInfoURL,
    REF(ULONG32)    /*OUT*/ ulVersionNumber
)
{
    bLoadMultiple = TRUE;   // Must be true for file formats.

    pDescription    = zm_pDescription;
    pCopyright	    = zm_pCopyright;
    pMoreInfoURL    = zm_pMoreInfoURL;
    ulVersionNumber = TARVER_ULONG32_VERSION;

    return HXR_OK;
}

/************************************************************************
 *  Method:
 *    IHXPlugin::GetObjFileFormatInfo
 *  Purpose:
 *    If this object is a file format object this method returns
 *    information vital to the instantiation of file format plugins.
 *    If this object is not a file format object, it should return
 *    HXR_UNEXPECTED.
 */
STDMETHODIMP CRealTextFileFormat::GetFileFormatInfo
(
    REF(const char**) /*OUT*/ pFileMimeTypes,
    REF(const char**) /*OUT*/ pFileExtensions,
    REF(const char**) /*OUT*/ pFileOpenNames
)
{
    pFileMimeTypes  = zm_pFileMimeTypes;
    pFileExtensions = zm_pFileExtensions;
    pFileOpenNames  = zm_pFileOpenNames;

    return HXR_OK;
}

// *** IUnknown methods ***

/////////////////////////////////////////////////////////////////////////
//  Method:
//	IUnknown::QueryInterface
//  Purpose:
//	Implement this to export the interfaces supported by your 
//	object.
//
STDMETHODIMP CRealTextFileFormat::QueryInterface(REFIID riid, void** ppvObj)
{
    if (IsEqualIID(riid, IID_IUnknown))
    {
	AddRef();
	*ppvObj = this;
	return HXR_OK;
    }
    else if (IsEqualIID(riid, IID_IHXPlugin))
    {
	AddRef();
	*ppvObj = (IHXPlugin*)this;
	return HXR_OK;
    }
    else if (IsEqualIID(riid, IID_IHXFileFormatObject))
    {
	AddRef();
	*ppvObj = (IHXFileFormatObject*)this;
	return HXR_OK;
    }
    else if (IsEqualIID(riid, IID_IHXFileResponse))
    {
	AddRef();
	*ppvObj = (IHXFileResponse*)this;
	return HXR_OK;
    }
    else if (IsEqualIID(riid, IID_IHXPendingStatus))
    {
	AddRef();
	*ppvObj = (IHXPendingStatus*)this;
	return HXR_OK;
    }
    else if (IsEqualIID(riid, IID_IHXInterruptSafe))
    {
	AddRef();
	*ppvObj = (IHXInterruptSafe*)this;
	return HXR_OK;
    }
    else if (IsEqualIID(riid, IID_IHXThreadSafeMethods))
    {
	AddRef();
	*ppvObj = (IHXThreadSafeMethods*)this;
	return HXR_OK;
    }
    else if (IsEqualIID(riid, IID_IHXFileMimeMapperResponse))
    {