зеркало из https://github.com/mozilla/pjs.git
new. gif decoder. pnunn.
This commit is contained in:
pnunn%netscape.com
Родитель
a800a1ee88
Коммит
19844cb692
|
|
@ -0,0 +1,442 @@
|
|||
/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
|
||||
*
|
||||
* The contents of this file are subject to the Netscape Public License
|
||||
* Version 1.0 (the "NPL"); you may not use this file except in
|
||||
* compliance with the NPL. You may obtain a copy of the NPL at
|
||||
* http://www.mozilla.org/NPL/
|
||||
*
|
||||
* Software distributed under the NPL is distributed on an "AS IS" basis,
|
||||
* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
|
||||
* for the specific language governing rights and limitations under the
|
||||
* NPL.
|
||||
*
|
||||
* The Initial Developer of this code under the NPL is Netscape
|
||||
* Communications Corporation. Portions created by Netscape are
|
||||
* Copyright (C) 1998 Netscape Communications Corporation. All Rights
|
||||
* Reserved.
|
||||
*/
|
||||
/*
|
||||
* The purpose of this file is to help phase out XP_ library
|
||||
* from the image library. In general, XP_ data structures and
|
||||
* functions will be replaced with the PR_ or PL_ equivalents.
|
||||
* In cases where the PR_ or PL_ equivalents don't yet exist,
|
||||
* this file (and its header equivalent) will play the role
|
||||
* of the XP_ library.
|
||||
*/
|
||||
|
||||
/* This file has func's from
|
||||
xpcompat that are needed by
|
||||
the local dll. So far,
|
||||
1> Mac stuff.
|
||||
2> NET_BACat
|
||||
*/
|
||||
#include "prtypes.h"
|
||||
#include "prlog.h"
|
||||
#include "prmem.h"
|
||||
#include "xp_mcom.h"
|
||||
|
||||
PR_BEGIN_EXTERN_C
|
||||
int MK_UNABLE_TO_LOCATE_FILE = -1;
|
||||
int MK_OUT_OF_MEMORY = -2;
|
||||
|
||||
int XP_MSG_IMAGE_PIXELS = -7;
|
||||
int XP_MSG_IMAGE_NOT_FOUND = -8;
|
||||
int XP_MSG_XBIT_COLOR = -9;
|
||||
int XP_MSG_1BIT_MONO = -10;
|
||||
int XP_MSG_XBIT_GREYSCALE = -11;
|
||||
int XP_MSG_XBIT_RGB = -12;
|
||||
int XP_MSG_DECODED_SIZE = -13;
|
||||
int XP_MSG_WIDTH_HEIGHT = -14;
|
||||
int XP_MSG_SCALED_FROM = -15;
|
||||
int XP_MSG_IMAGE_DIM = -16;
|
||||
int XP_MSG_COLOR = -17;
|
||||
int XP_MSG_NB_COLORS = -18;
|
||||
int XP_MSG_NONE = -19;
|
||||
int XP_MSG_COLORMAP = -20;
|
||||
int XP_MSG_BCKDRP_VISIBLE = -21;
|
||||
int XP_MSG_SOLID_BKGND = -22;
|
||||
int XP_MSG_JUST_NO = -23;
|
||||
int XP_MSG_TRANSPARENCY = -24;
|
||||
int XP_MSG_COMMENT = -25;
|
||||
int XP_MSG_UNKNOWN = -26;
|
||||
int XP_MSG_COMPRESS_REMOVE = -27;
|
||||
PR_END_EXTERN_C
|
||||
|
||||
/* binary block Allocate and Concatenate
|
||||
*
|
||||
* destination_length is the length of the existing block
|
||||
* source_length is the length of the block being added to the
|
||||
* destination block
|
||||
*/
|
||||
char *
|
||||
NET_BACat (char **destination,
|
||||
size_t destination_length,
|
||||
const char *source,
|
||||
size_t source_length)
|
||||
{
|
||||
if (source)
|
||||
{
|
||||
if (*destination)
|
||||
{
|
||||
*destination = (char *) PR_REALLOC (*destination, destination_length + source_length);
|
||||
if (*destination == NULL)
|
||||
return(NULL);
|
||||
|
||||
XP_MEMMOVE (*destination + destination_length, source, source_length);
|
||||
|
||||
}
|
||||
else
|
||||
{
|
||||
*destination = (char *) PR_MALLOC (source_length);
|
||||
if (*destination == NULL)
|
||||
return(NULL);
|
||||
|
||||
XP_MEMCPY(*destination, source, source_length);
|
||||
}
|
||||
}
|
||||
|
||||
return *destination;
|
||||
}
|
||||
|
||||
|
||||
#if defined(XP_MAC)
|
||||
|
||||
/* prototypes for local routines */
|
||||
static void shortsort(char *lo, char *hi, unsigned width,
|
||||
int ( *comp)(const void *, const void *));
|
||||
static void swap(char *p, char *q, unsigned int width);
|
||||
|
||||
/* this parameter defines the cutoff between using quick sort and
|
||||
insertion sort for arrays; arrays with lengths shorter or equal to the
|
||||
below value use insertion sort */
|
||||
|
||||
#define CUTOFF 8 /* testing shows that this is good value */
|
||||
|
||||
|
||||
/***
|
||||
*XP_QSORT(base, num, wid, comp) - quicksort function for sorting arrays
|
||||
*
|
||||
*Purpose:
|
||||
* quicksort the array of elements
|
||||
* side effects: sorts in place
|
||||
*
|
||||
*Entry:
|
||||
* char *base = pointer to base of array
|
||||
* unsigned num = number of elements in the array
|
||||
* unsigned width = width in bytes of each array element
|
||||
* int (*comp)() = pointer to function returning analog of strcmp for
|
||||
* strings, but supplied by user for comparing the array elements.
|
||||
* it accepts 2 pointers to elements and returns neg if 1<2, 0 if
|
||||
* 1=2, pos if 1>2.
|
||||
*
|
||||
*Exit:
|
||||
* returns void
|
||||
*
|
||||
*Exceptions:
|
||||
*
|
||||
*******************************************************************************/
|
||||
|
||||
/* sort the array between lo and hi (inclusive) */
|
||||
|
||||
void XP_QSORT (
|
||||
void *base,
|
||||
size_t num,
|
||||
size_t width,
|
||||
int ( *comp)(const void *, const void *)
|
||||
)
|
||||
{
|
||||
char *lo, *hi; /* ends of sub-array currently sorting */
|
||||
char *mid; /* points to middle of subarray */
|
||||
char *loguy, *higuy; /* traveling pointers for partition step */
|
||||
unsigned size; /* size of the sub-array */
|
||||
char *lostk[30], *histk[30];
|
||||
int stkptr; /* stack for saving sub-array to be processed */
|
||||
|
||||
/* Note: the number of stack entries required is no more than
|
||||
1 + log2(size), so 30 is sufficient for any array */
|
||||
|
||||
if (num < 2 || width == 0)
|
||||
return; /* nothing to do */
|
||||
|
||||
stkptr = 0; /* initialize stack */
|
||||
|
||||
lo = (char*)base;
|
||||
hi = (char *)base + width * (num-1); /* initialize limits */
|
||||
|
||||
/* this entry point is for pseudo-recursion calling: setting
|
||||
lo and hi and jumping to here is like recursion, but stkptr is
|
||||
prserved, locals aren't, so we preserve stuff on the stack */
|
||||
recurse:
|
||||
|
||||
size = (hi - lo) / width + 1; /* number of el's to sort */
|
||||
|
||||
/* below a certain size, it is faster to use a O(n^2) sorting method */
|
||||
if (size <= CUTOFF) {
|
||||
shortsort(lo, hi, width, comp);
|
||||
}
|
||||
else {
|
||||
/* First we pick a partititioning element. The efficiency of the
|
||||
algorithm demands that we find one that is approximately the
|
||||
median of the values, but also that we select one fast. Using
|
||||
the first one produces bad performace if the array is already
|
||||
sorted, so we use the middle one, which would require a very
|
||||
wierdly arranged array for worst case performance. Testing shows
|
||||
that a median-of-three algorithm does not, in general, increase
|
||||
performance. */
|
||||
|
||||
mid = lo + (size / 2) * width; /* find middle element */
|
||||
swap(mid, lo, width); /* swap it to beginning of array */
|
||||
|
||||
/* We now wish to partition the array into three pieces, one
|
||||
consisiting of elements <= partition element, one of elements
|
||||
equal to the parition element, and one of element >= to it. This
|
||||
is done below; comments indicate conditions established at every
|
||||
step. */
|
||||
|
||||
loguy = lo;
|
||||
higuy = hi + width;
|
||||
|
||||
/* Note that higuy decreases and loguy increases on every iteration,
|
||||
so loop must terminate. */
|
||||
for (;;) {
|
||||
/* lo <= loguy < hi, lo < higuy <= hi + 1,
|
||||
A[i] <= A[lo] for lo <= i <= loguy,
|
||||
A[i] >= A[lo] for higuy <= i <= hi */
|
||||
|
||||
do {
|
||||
loguy += width;
|
||||
} while (loguy <= hi && comp(loguy, lo) <= 0);
|
||||
|
||||
/* lo < loguy <= hi+1, A[i] <= A[lo] for lo <= i < loguy,
|
||||
either loguy > hi or A[loguy] > A[lo] */
|
||||
|
||||
do {
|
||||
higuy -= width;
|
||||
} while (higuy > lo && comp(higuy, lo) >= 0);
|
||||
|
||||
/* lo-1 <= higuy <= hi, A[i] >= A[lo] for higuy < i <= hi,
|
||||
either higuy <= lo or A[higuy] < A[lo] */
|
||||
|
||||
if (higuy < loguy)
|
||||
break;
|
||||
|
||||
/* if loguy > hi or higuy <= lo, then we would have exited, so
|
||||
A[loguy] > A[lo], A[higuy] < A[lo],
|
||||
loguy < hi, highy > lo */
|
||||
|
||||
swap(loguy, higuy, width);
|
||||
|
||||
/* A[loguy] < A[lo], A[higuy] > A[lo]; so condition at top
|
||||
of loop is re-established */
|
||||
}
|
||||
|
||||
/* A[i] >= A[lo] for higuy < i <= hi,
|
||||
A[i] <= A[lo] for lo <= i < loguy,
|
||||
higuy < loguy, lo <= higuy <= hi
|
||||
implying:
|
||||
A[i] >= A[lo] for loguy <= i <= hi,
|
||||
A[i] <= A[lo] for lo <= i <= higuy,
|
||||
A[i] = A[lo] for higuy < i < loguy */
|
||||
|
||||
swap(lo, higuy, width); /* put partition element in place */
|
||||
|
||||
/* OK, now we have the following:
|
||||
A[i] >= A[higuy] for loguy <= i <= hi,
|
||||
A[i] <= A[higuy] for lo <= i < higuy
|
||||
A[i] = A[lo] for higuy <= i < loguy */
|
||||
|
||||
/* We've finished the partition, now we want to sort the subarrays
|
||||
[lo, higuy-1] and [loguy, hi].
|
||||
We do the smaller one first to minimize stack usage.
|
||||
We only sort arrays of length 2 or more.*/
|
||||
|
||||
if ( higuy - 1 - lo >= hi - loguy ) {
|
||||
if (lo + width < higuy) {
|
||||
lostk[stkptr] = lo;
|
||||
histk[stkptr] = higuy - width;
|
||||
++stkptr;
|
||||
} /* save big recursion for later */
|
||||
|
||||
if (loguy < hi) {
|
||||
lo = loguy;
|
||||
goto recurse; /* do small recursion */
|
||||
}
|
||||
}
|
||||
else {
|
||||
if (loguy < hi) {
|
||||
lostk[stkptr] = loguy;
|
||||
histk[stkptr] = hi;
|
||||
++stkptr; /* save big recursion for later */
|
||||
}
|
||||
|
||||
if (lo + width < higuy) {
|
||||
hi = higuy - width;
|
||||
goto recurse; /* do small recursion */
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/* We have sorted the array, except for any pending sorts on the stack.
|
||||
Check if there are any, and do them. */
|
||||
|
||||
--stkptr;
|
||||
if (stkptr >= 0) {
|
||||
lo = lostk[stkptr];
|
||||
hi = histk[stkptr];
|
||||
goto recurse; /* pop subarray from stack */
|
||||
}
|
||||
else
|
||||
return; /* all subarrays done */
|
||||
}
|
||||
|
||||
|
||||
/***
|
||||
*shortsort(hi, lo, width, comp) - insertion sort for sorting short arrays
|
||||
*
|
||||
*Purpose:
|
||||
* sorts the sub-array of elements between lo and hi (inclusive)
|
||||
* side effects: sorts in place
|
||||
* assumes that lo < hi
|
||||
*
|
||||
*Entry:
|
||||
* char *lo = pointer to low element to sort
|
||||
* char *hi = pointer to high element to sort
|
||||
* unsigned width = width in bytes of each array element
|
||||
* int (*comp)() = pointer to function returning analog of strcmp for
|
||||
* strings, but supplied by user for comparing the array elements.
|
||||
* it accepts 2 pointers to elements and returns neg if 1<2, 0 if
|
||||
* 1=2, pos if 1>2.
|
||||
*
|
||||
*Exit:
|
||||
* returns void
|
||||
*
|
||||
*Exceptions:
|
||||
*
|
||||
*******************************************************************************/
|
||||
|
||||
static void shortsort (
|
||||
char *lo,
|
||||
char *hi,
|
||||
unsigned width,
|
||||
int ( *comp)(const void *, const void *)
|
||||
)
|
||||
{
|
||||
char *p, *max;
|
||||
|
||||
/* Note: in assertions below, i and j are alway inside original bound of
|
||||
array to sort. */
|
||||
|
||||
while (hi > lo) {
|
||||
/* A[i] <= A[j] for i <= j, j > hi */
|
||||
max = lo;
|
||||
for (p = lo+width; p <= hi; p += width) {
|
||||
/* A[i] <= A[max] for lo <= i < p */
|
||||
if (comp(p, max) > 0) {
|
||||
max = p;
|
||||
}
|
||||
/* A[i] <= A[max] for lo <= i <= p */
|
||||
}
|
||||
|
||||
/* A[i] <= A[max] for lo <= i <= hi */
|
||||
|
||||
swap(max, hi, width);
|
||||
|
||||
/* A[i] <= A[hi] for i <= hi, so A[i] <= A[j] for i <= j, j >= hi */
|
||||
|
||||
hi -= width;
|
||||
|
||||
/* A[i] <= A[j] for i <= j, j > hi, loop top condition established */
|
||||
}
|
||||
/* A[i] <= A[j] for i <= j, j > lo, which implies A[i] <= A[j] for i < j,
|
||||
so array is sorted */
|
||||
}
|
||||
|
||||
|
||||
/***
|
||||
*swap(a, b, width) - swap two elements
|
||||
*
|
||||
*Purpose:
|
||||
* swaps the two array elements of size width
|
||||
*
|
||||
*Entry:
|
||||
* char *a, *b = pointer to two elements to swap
|
||||
* unsigned width = width in bytes of each array element
|
||||
*
|
||||
*Exit:
|
||||
* returns void
|
||||
*
|
||||
*Exceptions:
|
||||
*
|
||||
*******************************************************************************/
|
||||
|
||||
static void swap (
|
||||
char *a,
|
||||
char *b,
|
||||
unsigned width
|
||||
)
|
||||
{
|
||||
char tmp;
|
||||
|
||||
if ( a != b )
|
||||
/* Do the swap one character at a time to avoid potential alignment
|
||||
problems. */
|
||||
while ( width-- ) {
|
||||
tmp = *a;
|
||||
*a++ = *b;
|
||||
*b++ = tmp;
|
||||
}
|
||||
}
|
||||
|
||||
#endif /* XP_MAC */
|
||||
#ifdef XP_MAC
|
||||
#include <OSUtils.h>
|
||||
|
||||
static void MyReadLocation(MachineLocation * loc)
|
||||
{
|
||||
static MachineLocation storedLoc; // InsideMac, OSUtilities, page 4-20
|
||||
static Boolean didReadLocation = FALSE;
|
||||
if (!didReadLocation)
|
||||
{
|
||||
ReadLocation(&storedLoc);
|
||||
didReadLocation = TRUE;
|
||||
}
|
||||
*loc = storedLoc;
|
||||
}
|
||||
|
||||
// current local time = GMTDelta() + GMT
|
||||
// GMT = local time - GMTDelta()
|
||||
static long GMTDelta()
|
||||
{
|
||||
MachineLocation loc;
|
||||
long gmtDelta;
|
||||
|
||||
MyReadLocation(&loc);
|
||||
gmtDelta = loc.u.gmtDelta & 0x00FFFFFF;
|
||||
if ((gmtDelta & 0x00800000) != 0)
|
||||
gmtDelta |= 0xFF000000;
|
||||
return gmtDelta;
|
||||
}
|
||||
|
||||
// This routine simulates stdclib time(), time in seconds since 1.1.1970
|
||||
// The time is in GMT
|
||||
time_t GetTimeMac()
|
||||
{
|
||||
unsigned long maclocal;
|
||||
// Get Mac local time
|
||||
GetDateTime(&maclocal);
|
||||
// Get Mac GMT
|
||||
maclocal -= GMTDelta();
|
||||
// return unix GMT
|
||||
return (maclocal - UNIXMINUSMACTIME);
|
||||
}
|
||||
|
||||
// Returns the GMT times
|
||||
time_t Mactime(time_t *timer)
|
||||
{
|
||||
time_t t = GetTimeMac();
|
||||
if (timer != NULL)
|
||||
*timer = t;
|
||||
return t;
|
||||
}
|
||||
#endif /* XP_MAC */
|
||||
|
||||
Разница между файлами не показана из-за своего большого размера
Загрузить разницу
|
|
@ -0,0 +1,305 @@
|
|||
/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
|
||||
*
|
||||
* The contents of this file are subject to the Netscape Public License
|
||||
* Version 1.0 (the "NPL"); you may not use this file except in
|
||||
* compliance with the NPL. You may obtain a copy of the NPL at
|
||||
* http:/www.mozilla.org/NPL/
|
||||
*
|
||||
* Software distributed under the NPL is distributed on an "AS IS" basis,
|
||||
* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
|
||||
* for the specific language governing rights and limitations under the
|
||||
* NPL.
|
||||
*
|
||||
* The Initial Developer of this code under the NPL is Netscape
|
||||
* Communications Corporation. Portions created by Netscape are
|
||||
* Copyright (C) 1998 Netscape Communications Corporation. All Rights
|
||||
* Reserved.
|
||||
*/
|
||||
|
||||
/* -*- Mode: C; tab-width: 4 -*-
|
||||
* nsGIFDecoder.cpp --- interface to gif decoder
|
||||
*/
|
||||
|
||||
|
||||
#include "if_struct.h"
|
||||
#include "prmem.h"
|
||||
#include "merrors.h"
|
||||
|
||||
|
||||
#include "dllcompat.h"
|
||||
#include "gif.h"
|
||||
#include "nsGIFDecoder.h"
|
||||
#include "nsImgDecCID.h"
|
||||
#include "nsIImgDecoder.h" /* interface class */
|
||||
#include "nsImgDecoder.h" /* factory */
|
||||
#include "nscore.h"
|
||||
|
||||
/*--- needed for autoregistry ---*/
|
||||
#include "nsIComponentManager.h"
|
||||
#include "nsIServiceManager.h"
|
||||
#include "nsCOMPtr.h"
|
||||
|
||||
|
||||
PR_BEGIN_EXTERN_C
|
||||
extern int MK_OUT_OF_MEMORY;
|
||||
PR_END_EXTERN_C
|
||||
|
||||
|
||||
/*-----------class----------------*/
|
||||
class GIFDecoder : public nsIImgDecoder
|
||||
{
|
||||
public:
|
||||
GIFDecoder(il_container* aContainer);
|
||||
~GIFDecoder();
|
||||
|
||||
NS_DECL_ISUPPORTS
|
||||
|
||||
/* stream */
|
||||
NS_IMETHOD ImgDInit();
|
||||
|
||||
NS_IMETHOD ImgDWriteReady();
|
||||
NS_IMETHOD ImgDWrite(const unsigned char *buf, int32 len);
|
||||
NS_IMETHOD ImgDComplete();
|
||||
NS_IMETHOD ImgDAbort();
|
||||
|
||||
il_container *SetContainer(il_container *ic){mContainer = ic; return ic;}
|
||||
il_container *GetContainer() {return mContainer;}
|
||||
|
||||
|
||||
private:
|
||||
il_container* mContainer;
|
||||
};
|
||||
/*-------------------------------------------------*/
|
||||
|
||||
GIFDecoder::GIFDecoder(il_container* aContainer)
|
||||
{
|
||||
NS_INIT_REFCNT();
|
||||
mContainer = aContainer;
|
||||
};
|
||||
|
||||
|
||||
GIFDecoder::~GIFDecoder(void)
|
||||
{
|
||||
NS_ASSERTION(mRefCnt == 0, "non-zero refcnt at destruction");
|
||||
};
|
||||
|
||||
|
||||
NS_IMETHODIMP
|
||||
GIFDecoder::QueryInterface(const nsIID& aIID, void** aInstPtr)
|
||||
{
|
||||
if (NULL == aInstPtr) {
|
||||
return NS_ERROR_NULL_POINTER;
|
||||
}
|
||||
|
||||
if (aIID.Equals(kGIFDecoderIID) ||
|
||||
aIID.Equals(kImgDecoderIID) ||
|
||||
aIID.Equals(kISupportsIID)) {
|
||||
*aInstPtr = (void*) this;
|
||||
NS_INIT_REFCNT();
|
||||
return NS_OK;
|
||||
}
|
||||
return NS_NOINTERFACE;
|
||||
}
|
||||
|
||||
NS_IMETHODIMP
|
||||
GIFDecoder::AddRef()
|
||||
{
|
||||
NS_INIT_REFCNT();
|
||||
return NS_OK;
|
||||
}
|
||||
|
||||
NS_IMETHODIMP
|
||||
GIFDecoder::Release()
|
||||
{
|
||||
return NS_OK;
|
||||
}
|
||||
|
||||
/*-----------class----------------*/
|
||||
class nsGIFDecFactory : public nsIFactory
|
||||
{
|
||||
public:
|
||||
NS_DECL_ISUPPORTS
|
||||
|
||||
nsGIFDecFactory(const nsCID &aClass);
|
||||
~nsGIFDecFactory();
|
||||
|
||||
NS_IMETHOD CreateInstance(nsISupports *aOuter,
|
||||
REFNSIID aIID,
|
||||
void **aResult);
|
||||
|
||||
NS_IMETHOD LockFactory(PRBool aLock);
|
||||
|
||||
protected:
|
||||
|
||||
private:
|
||||
nsCID mClassID;
|
||||
il_container *mContainer;
|
||||
};
|
||||
|
||||
/*-----------------------------------------*/
|
||||
|
||||
nsGIFDecFactory* gFactory = NULL;
|
||||
NS_IMPL_ISUPPORTS(nsGIFDecFactory, kIFactoryIID);
|
||||
|
||||
|
||||
nsGIFDecFactory::nsGIFDecFactory(const nsCID &aClass)
|
||||
{
|
||||
NS_INIT_REFCNT();
|
||||
mClassID = aClass;
|
||||
}
|
||||
|
||||
nsGIFDecFactory::~nsGIFDecFactory(void)
|
||||
{
|
||||
NS_ASSERTION(mRefCnt == 0, "non-zero refcnt at destruction");
|
||||
}
|
||||
/*----------------------------------for autoregistration ----*/
|
||||
static NS_DEFINE_CID(kComponentManagerCID, NS_COMPONENTMANAGER_CID);
|
||||
|
||||
extern "C" NS_EXPORT nsresult
|
||||
NSRegisterSelf(nsISupports* aServMgr, const char *path)
|
||||
{
|
||||
nsresult rv;
|
||||
|
||||
nsCOMPtr<nsIServiceManager> servMgr(do_QueryInterface(aServMgr, &rv));
|
||||
if (NS_FAILED(rv)) return rv;
|
||||
|
||||
nsIComponentManager* compMgr;
|
||||
rv = servMgr->GetService(kComponentManagerCID,
|
||||
nsIComponentManager::GetIID(),
|
||||
(nsISupports**)&compMgr);
|
||||
if (NS_FAILED(rv)) return rv;
|
||||
|
||||
if ((rv = nsRepository::RegisterComponent(kGIFDecoderCID,
|
||||
"Netscape GIFDec",
|
||||
"component://netscape/image/decoder&type=image/gif", path, PR_TRUE, PR_TRUE)
|
||||
) != NS_OK) {
|
||||
return rv;
|
||||
}
|
||||
(void)servMgr->ReleaseService(kComponentManagerCID, compMgr);
|
||||
return rv;
|
||||
|
||||
}
|
||||
|
||||
extern "C" NS_EXPORT nsresult NSUnregisterSelf(nsISupports* aServMgr, const char *path)
|
||||
{
|
||||
nsresult rv;
|
||||
|
||||
nsCOMPtr<nsIServiceManager> servMgr(do_QueryInterface(aServMgr, &rv));
|
||||
if (NS_FAILED(rv)) return rv;
|
||||
|
||||
nsIComponentManager* compMgr;
|
||||
rv = servMgr->GetService(kComponentManagerCID,
|
||||
nsIComponentManager::GetIID(),
|
||||
(nsISupports**)&compMgr);
|
||||
if (NS_FAILED(rv)) return rv;
|
||||
|
||||
rv = compMgr->UnregisterFactory(kGIFDecoderCID, path);
|
||||
|
||||
(void)servMgr->ReleaseService(kComponentManagerCID, compMgr);
|
||||
return rv;
|
||||
}
|
||||
|
||||
/*--------------------*/
|
||||
NS_IMETHODIMP
|
||||
nsGIFDecFactory::CreateInstance(nsISupports *aOuter,
|
||||
const nsIID &aIID,
|
||||
void **ppv)
|
||||
{
|
||||
GIFDecoder *gifdec = NULL;
|
||||
*ppv = NULL;
|
||||
il_container* ic = NULL;
|
||||
|
||||
if (aOuter && !aIID.Equals(kISupportsIID))
|
||||
return NS_NOINTERFACE;
|
||||
ic = new il_container();
|
||||
|
||||
gifdec = new GIFDecoder(ic);
|
||||
nsresult res = gifdec->QueryInterface(aIID,(void**)ppv);
|
||||
//interface is other than nsISupports and gifdecoder
|
||||
|
||||
if (NS_FAILED(res)) {
|
||||
*ppv = NULL;
|
||||
delete gifdec;
|
||||
}
|
||||
return res;
|
||||
}
|
||||
|
||||
NS_METHOD
|
||||
nsGIFDecFactory::LockFactory(PRBool aLock)
|
||||
{
|
||||
return NS_OK;
|
||||
}
|
||||
|
||||
extern "C" NS_EXPORT nsresult
|
||||
NSGetFactory(nsISupports* serviceMgr,
|
||||
const nsCID &aClass,
|
||||
const char *aClassName,
|
||||
const char *aProgID,
|
||||
nsIFactory **aFactory)
|
||||
{
|
||||
if( !aClass.Equals(kGIFDecoderCID))
|
||||
return NS_ERROR_FACTORY_NOT_REGISTERED;
|
||||
if( gFactory == NULL){
|
||||
gFactory = new nsGIFDecFactory(aClass);
|
||||
if( gFactory == NULL)
|
||||
return NS_ERROR_OUT_OF_MEMORY;
|
||||
gFactory->AddRef(); //for global
|
||||
}
|
||||
gFactory->AddRef(); //for client
|
||||
*aFactory = gFactory;
|
||||
return NS_OK;
|
||||
}
|
||||
|
||||
|
||||
/*----------------------------------------------------*/
|
||||
// api functions
|
||||
/*------------------------------------------------------*/
|
||||
NS_IMETHODIMP
|
||||
GIFDecoder::ImgDInit()
|
||||
{
|
||||
if(mContainer != NULL) {
|
||||
return(il_gif_init(mContainer));
|
||||
}
|
||||
else {
|
||||
return nsnull;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
NS_IMETHODIMP
|
||||
GIFDecoder::ImgDWriteReady()
|
||||
{
|
||||
if(mContainer != NULL) {
|
||||
return(il_gif_write_ready(mContainer));
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
NS_IMETHODIMP
|
||||
GIFDecoder::ImgDWrite(const unsigned char *buf, int32 len)
|
||||
{
|
||||
if( mContainer != NULL ) {
|
||||
return(il_gif_write(mContainer, buf,len));
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
NS_IMETHODIMP
|
||||
GIFDecoder::ImgDComplete()
|
||||
{
|
||||
if( mContainer != NULL ) {
|
||||
il_gif_complete(mContainer);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
NS_IMETHODIMP
|
||||
GIFDecoder::ImgDAbort()
|
||||
{
|
||||
if( mContainer != NULL ) {
|
||||
il_gif_abort(mContainer);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
Загрузка…
Ссылка в новой задаче