windows-server-2003/enduser/netmeeting/av/codecs/dec/dech261/h26x.c

/*
 * @DEC_COPYRIGHT@
 */
/*
 * HISTORY
 * $Log: h263.c,v $
 * $EndLog$
 */
/*
**++
** FACILITY:  Workstation Multimedia  (WMM)  v1.0
**
** FILE NAME:   h263.c
** MODULE NAME: h263.c
**
** MODULE DESCRIPTION:
**    H.263ICM driver
**
**    Microsoft file I/O functions
**	Implemented as functions:
**	H263Close
**	H263Compress
**	H263Decompress
**	H263DecompressEnd
**	H263DecompressGetPalette
**	H263DecompressGetSize
**	H263DecompressQuery
**	H263GetInfo
**	H263Info
**	H263Locate
**	H263Open
**	H263SendMessage
**
**    Private functions:
**
** DESIGN OVERVIEW:
**
**--
*/
/*-------------------------------------------------------------------------
**  Modification History: sc_mem.c
**      04-15-97  HWG          Added debug statements to help with checking
**                               for memory leaks
--------------------------------------------------------------------------*/

#include <stdlib.h>
#include <windows.h>
#include <mmsystem.h>
#include "h26x_int.h"

#ifdef _SLIBDEBUG_
#define _DEBUG_     0  /* detailed debuging statements */
#define _VERBOSE_   1  /* show progress */
#define _VERIFY_    1  /* verify correct operation */
#define _WARN_      1  /* warnings about strange behavior */
#define _MEMORY_    0  /* memory debugging */

dword scMemDump();
#endif


/* For shared mem */
static H26XINFO    *pValidHandles = NULL;
static int          NextH263Hic = 1;
static int          OpenCount = 0;
static HANDLE       InfoMutex = NULL;

#define InitInfoMutex()  if (InfoMutex==NULL) InfoMutex=CreateMutex(NULL, FALSE, NULL)
#define FreeInfoMutex()  if (InfoMutex!=NULL) \
                               CloseHandle(InfoMutex); InfoMutex=NULL
#define LockInfo()      WaitForSingleObject(InfoMutex, 5000);
#define ReleaseInfo()   ReleaseMutex(InfoMutex)

/*
 * Macros
 */
#define _ICH263CheckFlags(info, flag) ((info->openFlags & flag) ? TRUE : FALSE)
#define FREE_AND_CLEAR(s)      if (s) {ScFree(s); (s)=NULL;}
#define FREE_AND_CLEAR_PA(s)   if (s) {ScPaFree(s); (s)=NULL;}

/*
 *   Default LPBI format
 */
static BITMAPINFOHEADER __defaultDecompresslpbiOut =
{
   sizeof(BITMAPINFOHEADER),		// DWORD  biSize;
   0,					// LONG   biWidth;
   0, 					// LONG   biHeight;
   1,					// WORD   biPlanes;
   24,					// WORD   biBitCount
   BI_RGB,				// DWORD  biCompression;
   0,					// DWORD  biSizeImage;
   0,					// LONG   biXPelsPerMeter;
   0,					// LONG   biYPelsPerMeter;
   0,					// DWORD  biClrUsed;
   0					// DWORD  biClrImportant;
};

static BITMAPINFOHEADER __defaultCompresslpbiOut =
{
   sizeof(BITMAPINFOHEADER),		// DWORD  biSize;
   0,					// LONG   biWidth;
   0, 					// LONG   biHeight;
   1,					// WORD   biPlanes;
   24,					// WORD   biBitCount
#ifdef H261_SUPPORT
   VIDEO_FORMAT_DIGITAL_H261, // DWORD  biCompression;
#else
   VIDEO_FORMAT_DIGITAL_H263, // DWORD  biCompression;
#endif
   0,					// DWORD  biSizeImage;
   0,					// LONG   biXPelsPerMeter;
   0,					// LONG   biYPelsPerMeter;
   0,					// DWORD  biClrUsed;
   0					// DWORD  biClrImportant;
};

typedef struct SupportList_s {
  int   InFormat;   /* Input format */
  int   InBits;     /* Input number of bits */
  int   OutFormat;  /* Output format */
  int   OutBits;    /* Output number of bits */
} SupportList_t;

/*
** Input & Output Formats supported by H.261 Compression
*/
static SupportList_t _ICCompressionSupport[] = {
  BI_DECYUVDIB,        16, H26X_FOURCC,   24, /* YUV 4:2:2 Packed */
  BI_YUY2,             16, H26X_FOURCC,   24, /* YUV 4:2:2 Packed */
  BI_YU12SEP,          24, H26X_FOURCC,   24, /* YUV 4:1:1 Planar */
  BI_YVU9SEP,          24, H26X_FOURCC,   24, /* YUV 16:1:1 Planar */
  BI_RGB,              16, H26X_FOURCC,   24, /* RGB 16 */
  BI_RGB,              24, H26X_FOURCC,   24, /* RGB 24 */
  0, 0, 0, 0
};

/*
** Input & Output Formats supported by H.261 Decompression
*/
static SupportList_t _ICDecompressionSupport[] = {
  H26X_FOURCC,   24, BI_DECYUVDIB,        16, /* YUV 4:2:2 Packed */
  H26X_FOURCC,   24, BI_YUY2,             16, /* YUV 4:2:2 Packed */
  H26X_FOURCC,   24, BI_YU12SEP,          24, /* YUV 4:1:1 Planar */
  H26X_FOURCC,   24, BI_YVU9SEP,          24, /* YUV 16:1:1 Planar */
  H26X_FOURCC,   24, BI_BITFIELDS,        32, /* BITFIELDS */
  H26X_FOURCC,   24, BI_RGB,              16, /* RGB 16 */
  H26X_FOURCC,   24, BI_RGB,              24, /* RGB 24 */
  H26X_FOURCC,   24, BI_RGB,              32, /* RGB 32 */
  H26X_FOURCC,   24, BI_RGB,              8,  /* RGB 8 */
  0, 0, 0, 0
};


/*
** Name: IsSupported
** Desc: Lookup the a given input and output format to see if it
**       exists in a SupportList.
** Note: If OutFormat==-1 and OutBits==-1 then only input format
**          is checked for support.
**       If InFormat==-1 and InBits==-1 then only output format
**          is checked for support.
** Return: NULL       Formats not supported.
**         not NULL   A pointer to the list entry.
*/
static SupportList_t *IsSupported(SupportList_t *list,
                                  int InFormat, int InBits,
                                  int OutFormat, int OutBits)
{
  if (OutFormat==-1 && OutBits==-1) /* Looking up only the Input format */
  {
    while (list->InFormat || list->InBits)
      if (list->InFormat == InFormat && list->InBits==InBits)
        return(list);
      else
        list++;
    return(NULL);
  }
  if (InFormat==-1 && InBits==-1) /* Looking up only the Output format */
  {
    while (list->InFormat || list->InBits)
      if (list->OutFormat == OutFormat && list->OutBits==OutBits)
        return(list);
      else
        list++;
    return(NULL);
  }
  /* Looking up both Input and Output */
  while (list->InFormat || list->InBits)
    if (list->InFormat == InFormat && list->InBits==InBits &&
         list->OutFormat == OutFormat && list->OutBits==OutBits)
        return(list);
    else
      list++;
  return(NULL);
}

unsigned int CalcImageSize(unsigned int fourcc, int w, int h, int bits)
{
  if (h<0) h=-h;
  if (IsYUV411Sep(fourcc))
    return((w * h * 3) / 2);
  else if (IsYUV422Sep(fourcc) || IsYUV422Packed(fourcc))
    return(w * h * 2);
  else if (IsYUV1611Sep(fourcc))
    return((w * h * 9) / 8);
#ifdef BICOMP_DECXIMAGEDIB
  else if (fourcc==BICOMP_DECXIMAGEDIB)
    return(bits<=8 ? w * h : (w * h * 4));
#endif
  else /* RGB */
    return(w * h * (bits+7)/8);
}

/*
**++
**  FUNCTIONAL_NAME: InitBitmapinfo
**
**  FUNCTIONAL_DESCRIPTION:
**	Allocate and copy our local copies of the input and output
**      BITMAPINFOHEADERs
**
**  FORMAL PARAMETERS:
**	info        pointer to the driver handle
**      lpbiIn      pointer to the input BITMAPINFOHEADER
**      lpbiOut     pointer to the output BITMAPINFOHEADER
**
**  RETURN VALUE:
**
**      ICERR_OK        Success
**      ICERR_MEMORY    Malloc failed
**
**  COMMENTS:
**
**  DESIGN:
**
**/

static MMRESULT InitBitmapinfo(H26XINFO *info,
			       LPBITMAPINFOHEADER lpbiIn,
			       LPBITMAPINFOHEADER lpbiOut)
{
    _SlibDebug(_DEBUG_,
		ScDebugPrintf("In InitBitmapinfo(), IN: 0x%x, OUT: 0x%x\n", lpbiIn, lpbiOut));

    if (info->lpbiIn == NULL)
    {
        if ((info->lpbiIn = (VOID *)ScAlloc(lpbiIn->biSize)) == NULL)
            return(unsigned int)(ICERR_MEMORY);
    }
    bcopy(lpbiIn, info->lpbiIn, lpbiIn->biSize);

    if (info->lpbiOut == NULL)
    {
        if ((info->lpbiOut = (VOID *)ScAlloc(lpbiOut->biSize)) == NULL)
	    return(unsigned int)(ICERR_MEMORY);
    }
    bcopy(lpbiOut, info->lpbiOut, lpbiOut->biSize);

    _SlibDebug(_DEBUG_, ScDebugPrintf("Out InitBitmapinfo()\n"));
    return(ICERR_OK);
}

/*
**++
**  FUNCTIONAL_NAME: ICclient2info
**
**  FUNCTIONAL_DESCRIPTION:
**	Translate the client pointer to an H26XINFO pointer
**
**  FORMAL PARAMETERS:
**	client  the client ptr to look up
**
**  RETURN VALUE:
**
**      pointer to the H26XINFO structure or NULL
**
**  COMMENTS:
**
**  DESIGN:
**
**/

H26XINFO *ICclient2info(void *client)
{
   return (H26XINFO *) NULL;
}


/*
**++
**  FUNCTIONAL_NAME: IChic2info
**
**  FUNCTIONAL_DESCRIPTION:
**	Translate the HIC integer to an H26XINFO pointer
**
**  FORMAL PARAMETERS:
**	hic     the hic managed by icm.c
**
**  RETURN VALUE:
**
**      pointer to the H26XINFO structure or NULL
**
**  COMMENTS:
**
**  DESIGN:
**
**/

H26XINFO *IChic2info(HIC hic)
{
  H26XINFO *retptr=NULL, *ptr;

  InitInfoMutex();
  LockInfo();

#ifdef HANDLE_EXCEPTIONS
  __try {
    /* pointers go wrong when driver closes */
#endif /* HANDLE_EXCEPTIONS */
  for (ptr = pValidHandles; ptr; ptr=ptr->next)
    if (ptr->hic == hic)
    {
      retptr=ptr;
      break;
    }
#ifdef HANDLE_EXCEPTIONS
  } __finally {
#endif /* HANDLE_EXCEPTIONS */
    ReleaseInfo();
#ifdef HANDLE_EXCEPTIONS
    return(retptr);
  } /* try..except */
#endif /* HANDLE_EXCEPTIONS */
  return(retptr);
}


/*
**++
**  FUNCTIONAL_NAME: ICHandle2hic
**
**  FUNCTIONAL_DESCRIPTION:
**	Translate the SLIB codec handle to an ICM HIC value
**
**  FORMAL PARAMETERS:
**	Sh     SLIB handle returned on the SlibOpen call
**
**  RETURN VALUE:
**
**      hic     the hic managed by icm.c
**
**  COMMENTS:
**
**  DESIGN:
**
**/
HIC ICHandle2hic(SlibHandle_t Sh)
{
    H26XINFO *ptr;

    InitInfoMutex();
    LockInfo();
    for (ptr = pValidHandles; ptr; ptr=ptr->next)
        if (ptr->Sh == Sh)
	    break;
    ReleaseInfo();

    return(ptr->hic);
}


/*
**++
**  FUNCTIONAL_NAME: ICclientGone
**
**  FUNCTIONAL_DESCRIPTION:
**	Sets the clientGone flag in client's H26XINFO
**
**  FORMAL PARAMETERS:
**	client  the client ptr to look up
**
**  RETURN VALUE:
**
**  COMMENTS:
**
**  DESIGN:
**
**/

BOOL ICclientGone(void *client)
{
    H26XINFO    *ptr;

    LockInfo();
    for (ptr = pValidHandles; ptr; ptr = ptr->next) {
        if (ptr->client == client)
	  ptr->clientGone = TRUE;
    }
    ReleaseInfo();
    return(ptr != NULL);
}


/*
**++
**  FUNCTIONAL_NAME: ICH263Open
**
**  FUNCTIONAL_DESCRIPTION:
**	Open the Software CODEC
**
**  FORMAL PARAMETERS:
**	client
**
**  RETURN VALUE:
**      driverHandle
**
**  COMMENTS:
**
**  DESIGN:
**
**/

HIC  ICH263Open(void *client)
{
  H26XINFO    *info;

  ICOPEN *icopen =(ICOPEN *) client;
  DWORD fccType = icopen->fccType;
  UINT  dwFlags = icopen->dwFlags;

  _SlibDebug(_VERBOSE_, ScDebugPrintf("ICH263Open()\n") );

  /*
   * fccType must be 'vidc'
   */
  if (fccType != ICTYPE_VIDEO)
    return(0);

  /*
   * We don't support draw operations.
   */
  if ( dwFlags & ICMODE_DRAW )
    return 0;

  /*
   * We don't support compress and decompress
   * with the same handler.
   */
  if ( (dwFlags & ICMODE_COMPRESS) &&
       (dwFlags & ICMODE_DECOMPRESS) )
    return 0;

  /*
   * At least one of these flags must be set:
   * COMPRESS, DECOMPRESS or QUERY.
   */
  if ( !(dwFlags & ICMODE_COMPRESS) &&
       !(dwFlags & ICMODE_DECOMPRESS) &&
       !(dwFlags & ICMODE_QUERY) )
    return 0;
  info = (H26XINFO *) ScAlloc(sizeof(H26XINFO));
  if (info)
  {
    InitInfoMutex();
    LockInfo();
    OpenCount++;
    bzero(info, sizeof(H26XINFO));
    info->next = pValidHandles;
    pValidHandles = info;
    info->hic = (HANDLE) NextH263Hic++;  /* !!! check for used entry! */
    info->client = client;
    info->fFrameRate=H26X_DEFAULT_FRAMERATE;
    info->dwBitrate=H26X_DEFAULT_BITRATE;
    info->dwPacketSize=H26X_DEFAULT_PACKETSIZE;
    info->dwRTP=H26X_DEFAULT_RTP;

    info->dwQuality=H26X_DEFAULT_QUALITY;
    info->dwMaxQuality=H26X_DEFAULT_QUALITY;
    info->dwQi=H26X_DEFAULT_CIF_QI;
    info->dwQp=H26X_DEFAULT_CIF_QP;
    info->dwMaxQi=H26X_DEFAULT_CIF_QI;
    info->dwMaxQp=H26X_DEFAULT_CIF_QP;

    info->openFlags = dwFlags;
    _SlibDebug(_VERBOSE_, ScDebugPrintf("ICH263Open() info=%p hic=%d\n", info, info->hic) );
    ReleaseInfo();
    return(info->hic);
  }
  else
  {
    _SlibDebug(_VERBOSE_, ScDebugPrintf("ICH263Open() alloc failed\n") );
    return(NULL);
  }
}

/*
**++
**  FUNCTIONAL_NAME: H263Close
**
**  FUNCTIONAL_DESCRIPTION:
**	Close the Software CODEC
**
**  FORMAL PARAMETERS:
**	driverID
**
**  RETURN VALUE:
**
**  COMMENTS:
**	Does it's own post reply.
**
**  DESIGN:
**
**/

void ICH263Close(H26XINFO *info, BOOL postreply)
{
    H26XINFO *ptr;
    int status;

    _SlibDebug(_VERBOSE_, ScDebugPrintf("ICH263Close() In: info=%p\n", info) );
    if (info==NULL)
      return;
    if (info->Sh)
    {
      _SlibDebug(_VERBOSE_, ScDebugPrintf("SlibClose()\n") );
      status=SlibClose(info->Sh);
      info->Sh = NULL;
      _SlibDebug(_VERBOSE_, ScDebugPrintf("SlibMemUsed = %ld (after SlibClose)\n", SlibMemUsed()) );
    }

    _SlibDebug(_VERBOSE_, ScDebugPrintf("Freeing memory\n") );
    FREE_AND_CLEAR(info->lpbiIn);
    FREE_AND_CLEAR(info->lpbiOut);
    LockInfo();
    if (pValidHandles == info)
        pValidHandles = info->next;
    else
    {
      for (ptr = pValidHandles; ptr && ptr->next; ptr = ptr->next)
        if (ptr->next == info) /* found info, remove from linked list */
        {
          ptr->next = info->next;
          break;
        }
    }
    OpenCount--;
    if (pValidHandles==NULL) /* all instances closed, reset driver ID */
    {
      NextH263Hic=1;
      ReleaseInfo();
      FreeInfoMutex();
    }
    else
    {
      ptr = pValidHandles;
      ReleaseInfo();
    }
    _SlibDebug(_VERBOSE_, ScDebugPrintf("DriverPostReply\n") );
    if (postreply &&  !info->clientGone)
    {
      _SlibDebug(_VERBOSE_, ScDebugPrintf("DriverPostReply\n") );
      DriverPostReply(info->client, ICERR_OK, 0);
    }
    ScFree(info);
    _SlibDebug(_MEMORY_, scMemDump() );
    _SlibDebug(_VERBOSE_, ScDebugPrintf("ICH263Close() Out\n") );
}


/*
**++
**  FUNCTIONAL_NAME: ICH263QueryConfigure
**
**  FUNCTIONAL_DESCRIPTION:
**	We don't do configure.  Say so.
**
**  FORMAL PARAMETERS:
**	Handle
**
**  RETURN VALUE:
**
**  COMMENTS:
**
**  DESIGN:
**
**/

BOOL     ICH263QueryConfigure(H26XINFO *info)
{
    return(FALSE);
}


/*
**++
**  FUNCTIONAL_NAME: ICH263Configure
**
**  FUNCTIONAL_DESCRIPTION:
**	Unsupported function
**
**  FORMAL PARAMETERS:
**	driverID
**
**  RETURN VALUE:
**
**  COMMENTS:
**
**  DESIGN:
**
**/

MMRESULT ICH263Configure(H26XINFO *info)
{
    return(MMRESULT)(ICERR_UNSUPPORTED);
}

MMRESULT ICH263CustomEncoder(H26XINFO *info, DWORD param1, DWORD param2)
{
  SlibHandle_t Sh;
  SlibStream_t stream=SLIB_STREAM_ALL;
  WORD task=HIWORD(param1);
  WORD control=LOWORD(param1);
  Sh = info->Sh;
  if (task==EC_SET_CURRENT)
  {
    switch (control)
    {
	  case EC_RTP_HEADER: /* Turn on/off RTP */
        info->dwRTP=param2;
        switch (info->dwRTP)
        {
          case EC_RTP_MODE_OFF:
		    SlibSetParamInt (Sh, stream, SLIB_PARAM_FORMATEXT, 0);
            break;
          default:
          case EC_RTP_MODE_A:
		    SlibSetParamInt (Sh, stream, SLIB_PARAM_FORMATEXT, PARAM_FORMATEXT_RTPA);
            break;
          case EC_RTP_MODE_B:
		    SlibSetParamInt (Sh, stream, SLIB_PARAM_FORMATEXT, PARAM_FORMATEXT_RTPB);
            break;
          case EC_RTP_MODE_C:
		    SlibSetParamInt (Sh, stream, SLIB_PARAM_FORMATEXT, PARAM_FORMATEXT_RTPC);
            break;
        }
		return (ICERR_OK);
	  case EC_PACKET_SIZE: /* Set Packet Size */
        info->dwPacketSize=param2;
 		SlibSetParamInt (Sh, stream, SLIB_PARAM_PACKETSIZE, info->dwPacketSize);
		return (ICERR_OK);
      case EC_BITRATE: /* Set Bitrate */
        info->dwBitrate=param2;
		SlibSetParamInt (Sh, stream, SLIB_PARAM_BITRATE, info->dwBitrate);
		return (ICERR_OK);
      case EC_BITRATE_CONTROL: /* Turn constant bitrate on/off */
        if (param2==0)
          info->dwBitrate=0;
        else if (info->dwBitrate)
          info->dwBitrate=H26X_DEFAULT_BITRATE;
		SlibSetParamInt (Sh, stream, SLIB_PARAM_BITRATE, info->dwBitrate);
		return (ICERR_OK);
    }
  }
  else if (task==EC_GET_CURRENT)
  {
    DWORD *pval=(DWORD *)param2;
    if (pval==NULL)
      return((MMRESULT)ICERR_BADPARAM);
    switch (control)
    {
	  case EC_RTP_HEADER:
        *pval=info->dwRTP;
		return (ICERR_OK);
	  case EC_PACKET_SIZE:
        *pval=info->dwPacketSize;
		return (ICERR_OK);
      case EC_BITRATE:
        *pval=info->dwBitrate;
		return (ICERR_OK);
      case EC_BITRATE_CONTROL: /* Turn constant bitrate on/off */
        *pval=info->dwBitrate?1:0;
		return (ICERR_OK);
    }
  }
  else if (task==EC_GET_FACTORY_DEFAULT)
  {
    DWORD *pval=(DWORD *)param2;
    if (pval==NULL)
      return((MMRESULT)ICERR_BADPARAM);
    *pval=0;
    return (ICERR_OK);
  }
  else if (task==EC_GET_FACTORY_LIMITS)
  {
    DWORD *pval=(DWORD *)param2;
    if (pval==NULL)
      return((MMRESULT)ICERR_BADPARAM);
    *pval=0;
    return (ICERR_OK);
  }
  else if (task==EC_RESET_TO_FACTORY_DEFAULTS)
  {
    return (ICERR_OK);
  }
  return((MMRESULT)ICERR_UNSUPPORTED);
}


/*
**++
**  FUNCTIONAL_NAME: ICH263QueryAbout
**
**  FUNCTIONAL_DESCRIPTION:
**	Tell 'em we don't do about
**
**  FORMAL PARAMETERS:
**	driverID
**
**  RETURN VALUE:
**
**  COMMENTS:
**
**  DESIGN:
**
**/

BOOL    ICH263QueryAbout(H26XINFO *info)
{
    return(FALSE);
}

/*
**++
**  FUNCTIONAL_NAME: ICH263About
**
**  FUNCTIONAL_DESCRIPTION:
**	About box
**
**  FORMAL PARAMETERS:
**	driverID
**
**  RETURN VALUE:
**
**  COMMENTS:
**
**  DESIGN:
**
**/

MMRESULT ICH263About (H26XINFO *info)
{
    return(MMRESULT)(ICERR_UNSUPPORTED);
}
/*
**++
**  FUNCTIONAL_NAME: ICH263GetInfo
**
**  FUNCTIONAL_DESCRIPTION:
**	Return info about codec
**
**  FORMAL PARAMETERS:
**	driverID
**
**  RETURN VALUE:
**
**  COMMENTS:
**
**  DESIGN:
**
**/

MMRESULT ICH263GetInfo(H26XINFO *info, ICINFO *icinfo, DWORD dwSize)
{
    _SlibDebug(_VERBOSE_, ScDebugPrintf("In H263GetInfo\n") );

    icinfo->dwSize = sizeof(ICINFO);
    icinfo->fccType = ICTYPE_VIDEO;
    icinfo->fccHandler = H26X_FOURCC;
    icinfo->dwFlags = VIDCF_QUALITY|VIDCF_CRUNCH|VIDCF_TEMPORAL|VIDCF_FASTTEMPORALC;

    icinfo->dwVersion = H26X_VERSION;
    icinfo->dwVersionICM = ICVERSION;

    wcscpy(icinfo->szDescription, H26X_DESCRIPTION);
    wcscpy(icinfo->szName, H26X_NAME);
#if 0
    /* we shouldn't change the szDriver field */
    wcscpy(icinfo->szDriver, _wgetenv(L"SystemRoot"));
    if( icinfo->szDriver[0] != 0 )
        wcscat(icinfo->szDriver, L"\\System32\\" );
    wcscat(icinfo->szDriver, H26X_DRIVER);
#endif
    return (dwSize);
}


/*
**++
**  FUNCTIONAL_NAME: ICH263CompressQuery
**
**  FUNCTIONAL_DESCRIPTION:
**	Determine compression capability
**
**  FORMAL PARAMETERS:
**	driverID
**      lpbiIn          input BITMAPINFOHEADER
**      lpbiOut         output BITMAPINFOHEADER
**
**  RETURN VALUE:
**
**  COMMENTS:
**
**  DESIGN:
**
**/

MMRESULT ICH263CompressQuery(H26XINFO *info,
                             LPBITMAPINFOHEADER lpbiIn,
                             LPBITMAPINFOHEADER lpbiOut)
{
    _SlibDebug(_VERBOSE_, ScDebugPrintf("In ICH263CompressQuery\n") );

    if (
		(!_ICH263CheckFlags(info, ICMODE_QUERY)) &&
		(
		(!_ICH263CheckFlags(info, ICMODE_COMPRESS)) ||
		(!_ICH263CheckFlags(info, ICMODE_FASTCOMPRESS))
		)
	   )
	return (MMRESULT)ICERR_BADHANDLE;

    /*
     * Must query at least an input or an output format
     */
    if (!lpbiIn && !lpbiOut)
      return (MMRESULT)(ICERR_BADPARAM);

    if (!IsSupported(_ICCompressionSupport,
                    lpbiIn ? lpbiIn->biCompression : -1,
                    lpbiIn ? lpbiIn->biBitCount : -1,
                    lpbiOut ? lpbiOut->biCompression : -1,
                    lpbiOut ? lpbiOut->biBitCount : -1))
      return(MMRESULT)(ICERR_BADFORMAT);

    return ICERR_OK;
}


/*
**++
**  FUNCTIONAL_NAME: ICH263CompressBegin
**
**  FUNCTIONAL_DESCRIPTION:
**	Prepare to start a Compression operation
**
**  FORMAL PARAMETERS:
**	driverID
**      lpbiIn          input BITMAPINFOHEADER
**      lpbiOut         output BITMAPINFOHEADER
**
**  RETURN VALUE:
**
**  COMMENTS:
**
**  DESIGN:
**
**/

MMRESULT ICH263CompressBegin(H26XINFO *info,
                             LPBITMAPINFOHEADER lpbiIn,
                             LPBITMAPINFOHEADER lpbiOut)
{
    MMRESULT            status;
    SlibStatus_t        sstatus;
#ifdef H261_SUPPORT
	SlibType_t stype = SLIB_TYPE_H261;
#else
	SlibType_t stype = SLIB_TYPE_H263;
#endif
	SlibHandle_t Sh;

    _SlibDebug(_VERBOSE_, ScDebugPrintf("In ICH263CompressBegin\n") );

    if ((!_ICH263CheckFlags(info, ICMODE_COMPRESS)) || (!_ICH263CheckFlags(info, ICMODE_FASTCOMPRESS)))
      return (MMRESULT)ICERR_BADHANDLE;

    if (!lpbiIn || !lpbiOut)
      return (MMRESULT)(ICERR_BADPARAM);
    if ((status = ICH263CompressQuery(info, lpbiIn, lpbiOut)) != ICERR_OK)
      return status;
    if ((status = InitBitmapinfo(info, lpbiIn, lpbiOut)) != ICERR_OK)
      return status;
    info->bUsesCodec = TRUE;
    lpbiIn=info->lpbiIn;
    lpbiOut=info->lpbiOut;

    lpbiIn->biHeight=-lpbiIn->biHeight; /* SLIB assume first line is top */

    info->dwMaxQuality=H26X_DEFAULT_QUALITY;
    if (lpbiIn->biWidth<168) /* Sub-QCIF */
    {
      info->dwMaxQi=H26X_DEFAULT_SQCIF_QI;
      info->dwMaxQp=H26X_DEFAULT_SQCIF_QP;
    }
    if (lpbiIn->biWidth<300) /* QCIF */
    {
      info->dwMaxQi=H26X_DEFAULT_QCIF_QI;
      info->dwMaxQp=H26X_DEFAULT_QCIF_QP;
    }
    else /* CIF */
    {
      info->dwMaxQi=H26X_DEFAULT_CIF_QI;
      info->dwMaxQp=H26X_DEFAULT_CIF_QP;
    }
    info->lastFrameNum=0;
    info->lastCompBytes=0;
    /* Synchronized SLIB SYSTEMS calls */
    _SlibDebug(_VERBOSE_, ScDebugPrintf("SlibMemUsed = %ld (before SlibOpen)\n", SlibMemUsed()) );
	sstatus = SlibOpenSync (&Sh, SLIB_MODE_COMPRESS, &stype, NULL, 0);
    if (sstatus!=SlibErrorNone) return((MMRESULT)ICERR_BADPARAM);
	SlibSetParamInt(Sh, SLIB_STREAM_MAINVIDEO, SLIB_PARAM_WIDTH, lpbiIn->biWidth);
	SlibSetParamInt(Sh, SLIB_STREAM_MAINVIDEO, SLIB_PARAM_HEIGHT, lpbiIn->biHeight);
#if 0
	SlibSetParamInt(Sh, SLIB_STREAM_MAINVIDEO, SLIB_PARAM_VIDEOFORMAT, lpbiIn->biCompression);
	SlibSetParamInt(Sh, SLIB_STREAM_MAINVIDEO, SLIB_PARAM_VIDEOBITS, lpbiIn->biBitCount);
#else
	SlibSetParamStruct(Sh, SLIB_STREAM_MAINVIDEO, SLIB_PARAM_VIDEOFORMAT, lpbiIn, lpbiIn->biSize);
#endif
//    SlibSetParamInt(Sh, SLIB_STREAM_MAINVIDEO, SLIB_PARAM_VIDEOQUALITY, info->dwQuality/100);
    SlibSetParamInt(Sh, SLIB_STREAM_MAINVIDEO, SLIB_PARAM_QUANTI, info->dwQi);
    SlibSetParamInt(Sh, SLIB_STREAM_MAINVIDEO, SLIB_PARAM_QUANTP, info->dwQp);
    SlibSetParamInt(Sh, SLIB_STREAM_MAINVIDEO, SLIB_PARAM_BITRATE, info->dwBitrate);
    SlibSetParamInt(Sh, SLIB_STREAM_MAINVIDEO, SLIB_PARAM_PACKETSIZE, info->dwPacketSize);
    SlibSetParamInt(Sh, SLIB_STREAM_MAINVIDEO, SLIB_PARAM_ALGFLAGS, H26X_DEFAULT_MODE);
    SlibSetParamInt(Sh, SLIB_STREAM_MAINVIDEO, SLIB_PARAM_KEYSPACING, 132);
#ifdef H261_SUPPORT
    SlibSetParamInt(Sh, SLIB_STREAM_MAINVIDEO, SLIB_PARAM_MOTIONALG, 1);
#else
    SlibSetParamInt(Sh, SLIB_STREAM_MAINVIDEO, SLIB_PARAM_MOTIONALG, 2);
#endif
    SlibSetParamFloat(Sh, SLIB_STREAM_MAINVIDEO, SLIB_PARAM_FPS, info->fFrameRate);
    switch (info->dwRTP)
    {
      case EC_RTP_MODE_OFF:
            break;
      case EC_RTP_MODE_A:
	        SlibSetParamInt(Sh, SLIB_STREAM_ALL, SLIB_PARAM_FORMATEXT, PARAM_FORMATEXT_RTPA);
            break;
      case EC_RTP_MODE_B:
	        SlibSetParamInt(Sh, SLIB_STREAM_ALL, SLIB_PARAM_FORMATEXT, PARAM_FORMATEXT_RTPB);
            break;
      case EC_RTP_MODE_C:
	        SlibSetParamInt(Sh, SLIB_STREAM_ALL, SLIB_PARAM_FORMATEXT, PARAM_FORMATEXT_RTPC);
            break;
    }
	info->Sh = Sh;
	lpbiIn->biSizeImage = SlibGetParamInt (Sh, SLIB_STREAM_MAINVIDEO, SLIB_PARAM_IMAGESIZE);
    info->dwMaxCompBytes = ICH263CompressGetSize(lpbiIn);
    info->bCompressBegun = TRUE;

	return ICERR_OK;
}


DWORD ICH263CompressGetSize(LPBITMAPINFOHEADER lpbiIn)
{
  if (lpbiIn==NULL)
    return(0);
  else if (lpbiIn->biWidth<=168)
    return(0x1800); /* Sub-QCIF */
  else if (lpbiIn->biWidth<=300)
    return(0x2000); /* QCIF */
  else
    return(0x8000); /* CIF */
}

/*
**++
**  FUNCTIONAL_NAME: ICH263CompressGetFormat
**
**  FUNCTIONAL_DESCRIPTION:
**	Get the format for compression
**
**  FORMAL PARAMETERS:
**	driverID
**      lpbiIn          input BITMAPINFOHEADER
**      lpbiOut         output BITMAPINFOHEADER
**
**  RETURN VALUE:
**
**  COMMENTS:
**
**  DESIGN:
**
**/

MMRESULT ICH263CompressGetFormat(H26XINFO *info,
                                          LPBITMAPINFOHEADER lpbiIn,
                                          LPBITMAPINFOHEADER lpbiOut)
{

    _SlibDebug(_DEBUG_, ScDebugPrintf("In ICH263CompressGetFormat\n") );

    if ((!_ICH263CheckFlags(info, ICMODE_COMPRESS)) &&
        (!_ICH263CheckFlags(info, ICMODE_FASTCOMPRESS)) &&
        (!_ICH263CheckFlags(info, ICMODE_QUERY)))

		return (MMRESULT)ICERR_BADHANDLE;

    if (lpbiIn == NULL)
	return (MMRESULT)ICERR_BADPARAM;

    if (lpbiOut == NULL)
        return (sizeof(BITMAPINFOHEADER));

    bcopy(&__defaultCompresslpbiOut, lpbiOut, sizeof(BITMAPINFOHEADER));
    lpbiOut->biWidth = lpbiIn->biWidth;
    lpbiOut->biHeight= lpbiIn->biHeight;
    lpbiOut->biSizeImage = ICH263CompressGetSize(lpbiIn);
    _SlibDebug(_DEBUG_, ScDebugPrintf(" lpbiOut filled: %s\n",
		                     BMHtoString(lpbiOut)) );
    return(ICERR_OK);
}





/*
**++
**  FUNCTIONAL_NAME: ICH263CompressEnd
**
**  FUNCTIONAL_DESCRIPTION:
**	Terminate the compression cycle
**
**  FORMAL PARAMETERS:
**	driverID
**
**  RETURN VALUE:
**
**  COMMENTS:
**
**  DESIGN:
**
**/

MMRESULT ICH263CompressEnd(H26XINFO *info)
{
  _SlibDebug(_VERBOSE_, ScDebugPrintf("In ICH263CompressEnd\n") );

  if ((!_ICH263CheckFlags(info, ICMODE_COMPRESS))
      || (!_ICH263CheckFlags(info, ICMODE_FASTCOMPRESS)))
    return (MMRESULT)ICERR_BADHANDLE;

  if (info->Sh)
  {
    _SlibDebug(_VERBOSE_, ScDebugPrintf("SlibClose()\n") );
    SlibClose (info->Sh);
    info->Sh=NULL;
    _SlibDebug(_VERBOSE_, ScDebugPrintf("SlibMemUsed = %ld (after SlibClose)\n", SlibMemUsed()) );
  }
  info->bCompressBegun = FALSE;
  return(ICERR_OK);
}


/*
**++
**  FUNCTIONAL_NAME: ICH263DecompressQuery
**
**  FUNCTIONAL_DESCRIPTION:
**	Query the codec to determine if it can decompress specified formats
**
**  FORMAL PARAMETERS:
**	driverID
**      lpbiIn          input BITMAPINFOHEADER
**      lpbiOut         output BITMAPINFOHEADER
**
**  RETURN VALUE:
**
**  COMMENTS:
**
**  DESIGN:
**
**/

MMRESULT ICH263DecompressQuery(H26XINFO *info,
                               LPBITMAPINFOHEADER lpbiIn,
                               LPBITMAPINFOHEADER lpbiOut)
{
    _SlibDebug(_VERBOSE_, ScDebugPrintf("In ICH263DecompressQuery\n") );

    if (!_ICH263CheckFlags(info, ICMODE_QUERY) &&
	!_ICH263CheckFlags(info, ICMODE_DECOMPRESS))
	return (MMRESULT)ICERR_BADHANDLE;

    /*
     * Must query at least an input or an output format
     */
    if (!lpbiIn && !lpbiOut)
      return (MMRESULT)(ICERR_BADPARAM);

    if (!IsSupported(_ICDecompressionSupport,
                    lpbiIn ? lpbiIn->biCompression : -1,
                    lpbiIn ? lpbiIn->biBitCount : -1,
                    lpbiOut ? lpbiOut->biCompression : -1,
                    lpbiOut ? lpbiOut->biBitCount : -1))
      return(MMRESULT)(ICERR_BADFORMAT);

    _SlibDebug(_VERBOSE_, ScDebugPrintf("Out ICH263DecompressQuery\n") );
    return ICERR_OK;
}



/*
**++
**  FUNCTIONAL_NAME: ICH263DecompressBegin
**
**  FUNCTIONAL_DESCRIPTION:
**	Begin the decompression process
**
**  FORMAL PARAMETERS:
**	driverID
**      lpbiIn          input BITMAPINFOHEADER
**      lpbiOut         output BITMAPINFOHEADER
**
**  RETURN VALUE:
**
**  ICERR_OK            No error
**  ICERR_MEMORY        Insufficient memory
**  ICERR_BADFORMAT     Invalid image format
**  ICERR_BADPARAM      Invalid image size
**
**  COMMENTS:
**
**
**  DESIGN:
**
**/

MMRESULT ICH263DecompressBegin(H26XINFO *info,
                               LPBITMAPINFOHEADER lpbiIn,
                               LPBITMAPINFOHEADER lpbiOut)
{
    MMRESULT            status;
    _SlibDebug(_VERBOSE_, ScDebugPrintf("In ICH263DecompressBegin\n") );

    if (!_ICH263CheckFlags(info, ICMODE_DECOMPRESS))
	  return (MMRESULT)ICERR_BADHANDLE;

	if ((status = ICH263DecompressQuery(info, lpbiIn, lpbiOut))
        != ICERR_OK)
       return status;

    if (lpbiIn && lpbiOut)
    {
      if ((status = InitBitmapinfo(info, lpbiIn, lpbiOut)) != ICERR_OK)
	    return status;

      info->bUsesCodec = TRUE;
      info->bUsesRender = ((lpbiOut->biBitCount == 8) &&
			     ((lpbiOut->biCompression == BI_DECXIMAGEDIB)||
			      (lpbiOut->biCompression == BI_DECGRAYDIB) ||
			      (lpbiOut->biCompression == BI_RGB)
			      )
			     );

      if (!info->bUsesCodec && !info->bUsesRender)
	    return (MMRESULT)ICERR_BADFORMAT;

      /* SLIB expects first pixel to be top line */
      info->lpbiOut->biHeight=-info->lpbiOut->biHeight;
    }
	info->bDecompressBegun = TRUE;
    _SlibDebug(_VERBOSE_, ScDebugPrintf("Out ICH263DecompressBegin\n") );
    return ICERR_OK;
}


/*
**++
**  FUNCTIONAL_NAME: ICH263DecompressGetFormat
**
**  FUNCTIONAL_DESCRIPTION:
**	Get the recommended decompressed format of the codec
**
**  FORMAL PARAMETERS:
**	driverID
**      lpbiIn          input BITMAPINFOHEADER
**      lpbiOut         output BITMAPINFOHEADER
**
**  RETURN VALUE:
**
**  COMMENTS:
**
**  DESIGN:
**
**/

MMRESULT ICH263DecompressGetFormat(H26XINFO *info,
                                            LPBITMAPINFOHEADER lpbiIn,
                                            LPBITMAPINFOHEADER lpbiOut)
{

    _SlibDebug(_DEBUG_, ScDebugPrintf("In ICH263DecompressGetFormat\n") );

    if (!_ICH263CheckFlags(info, ICMODE_DECOMPRESS) &&
        (!_ICH263CheckFlags(info, ICMODE_QUERY)))
      return((MMRESULT)ICERR_BADHANDLE);

    if (lpbiIn == NULL)
      return((MMRESULT)ICERR_BADPARAM);

    if (lpbiOut == NULL)
        return (sizeof(BITMAPINFOHEADER));

    _SlibDebug(_DEBUG_,
		ScDebugPrintf("lpbiOut is being filled in DecompressGetFormat\n") );
    bcopy(&__defaultDecompresslpbiOut, lpbiOut, sizeof(BITMAPINFOHEADER));
    lpbiOut->biWidth = lpbiIn->biWidth;
    lpbiOut->biHeight= lpbiIn->biHeight;
    /*
    ** Return biSizeImage = 1.5 * width * height to let application know
    ** how big the image buffers must be when passed to ICAddBuffer.
    ** Internal to the codec, they are used to first store a YUV image,
    ** then the ICM layer renders it (if rendered data is what's called for
    */
    lpbiOut->biSizeImage = CalcImageSize(lpbiOut->biCompression,
                           lpbiOut->biWidth, lpbiOut->biHeight, lpbiOut->biBitCount);
    if (lpbiOut->biCompression==BI_RGB && lpbiOut->biBitCount==8)
      lpbiOut->biClrUsed = 1<<lpbiOut->biBitCount;
    else
      lpbiOut->biClrUsed = 0;
    return(0);
}


/*
**++
**  FUNCTIONAL_NAME: ICH263DecompressGetSize
**
**  FUNCTIONAL_DESCRIPTION:
**
**
**  FORMAL PARAMETERS:
**	driverID
**      lpbiIn          input BITMAPINFOHEADER
**      lpbiOut         output BITMAPINFOHEADER
**
**  RETURN VALUE:
**
**  COMMENTS:
**
**  DESIGN:
**
**/

MMRESULT ICH263DecompressGetSize(H26XINFO *info,
                                 LPBITMAPINFOHEADER lpbiIn,
								 LPBITMAPINFOHEADER lpbiOut)
{
    return(MMRESULT)(ICERR_UNSUPPORTED);
}



/*
**++
**  FUNCTIONAL_NAME: ICH263DecompressEnd
**
**  FUNCTIONAL_DESCRIPTION:
**	End the decompression process
**
**  FORMAL PARAMETERS:
**	driverID
**
**  RETURN VALUE:
**
**  COMMENTS:
**
**  DESIGN:
**
**/

MMRESULT ICH263DecompressEnd(H26XINFO *info)
{
    _SlibDebug(_VERBOSE_, ScDebugPrintf("In ICH263DecompressEnd\n") );

    if (!_ICH263CheckFlags(info, ICMODE_DECOMPRESS))
	return (MMRESULT)ICERR_BADHANDLE;

	if (info->Sh)
    {
      _SlibDebug(_VERBOSE_, ScDebugPrintf("SlibClose()\n") );
	  SlibClose(info->Sh);
      info->Sh=NULL;
      _SlibDebug(_VERBOSE_, ScDebugPrintf("SlibMemUsed = %ld (after SlibClose)\n", SlibMemUsed()) );
    }
    info->bDecompressBegun = FALSE;
    return(ICERR_OK);
}



MMRESULT ICH263GetDefaultQuality(H26XINFO *info, DWORD * quality)
{
  *quality = H26X_DEFAULT_QUALITY;
  return((MMRESULT)ICERR_OK);
}

MMRESULT ICH263GetQuality(H26XINFO *info, DWORD * quality)
{
  *quality = info->dwQuality;
  return((MMRESULT)ICERR_OK);
}

MMRESULT ICH263SetQuality(H26XINFO *info, DWORD quality)
{
  if (quality>10000)
    info->dwQuality=10000;
  else
    info->dwQuality=quality;
  // SlibSetParamInt(info->Sh, SLIB_STREAM_MAINVIDEO, SLIB_PARAM_VIDEOQUALITY,
  //                info->dwQuality/100);
  return((MMRESULT)ICERR_OK);
}


/*
**++
**  FUNCTIONAL_NAME: ICH263Compress
**
**  FUNCTIONAL_DESCRIPTION:
**	Compress a frame
**
**  FORMAL PARAMETERS:
**	driverID
**      lpbiIn          input BITMAPINFOHEADER
**      lpbiOut         output BITMAPINFOHEADER
**
**  RETURN VALUE:
**
**  COMMENTS:
**
**  DESIGN:
**
**/
MMRESULT ICH263Compress(H26XINFO *info,
                            ICCOMPRESS  *icCompress,
                            DWORD   dwSize)
{
    MMRESULT            status;
    LPBITMAPINFOHEADER  lpbiIn;
    LPBITMAPINFOHEADER  lpbiOut;
    LPVOID              lpIn;
    LPVOID              lpOut;
	SlibHandle_t		Sh;
    int			        compBytes, reqBytes;
    DWORD               newQi, newQp;
    RTPTRAILER_t       *ptrail;
    BOOL                keyframe=icCompress->dwFlags&ICCOMPRESS_KEYFRAME;

    if (icCompress->dwFrameSize==0 || icCompress->dwFrameSize>64*1024)
      reqBytes = info->dwMaxCompBytes;
    else
      reqBytes = icCompress->dwFrameSize;

#ifdef H261_SUPPORT
    _SlibDebug(_VERBOSE_, ScDebugPrintf("ICH261Compress() FrameNum=%d FrameSize=%d Quality=%d reqBytes=%d\n",
                        icCompress->lFrameNum, icCompress->dwFrameSize, icCompress->dwQuality,
                        reqBytes) );
#else
    _SlibDebug(_VERBOSE_, ScDebugPrintf("ICH263Compress() FrameNum=%d FrameSize=%d Quality=%d reqBytes=%d\n",
                        icCompress->lFrameNum, icCompress->dwFrameSize, icCompress->dwQuality,
                        reqBytes) );
#endif

    if ((!_ICH263CheckFlags(info, ICMODE_COMPRESS))
		|| (!_ICH263CheckFlags(info, ICMODE_FASTCOMPRESS)))
      return (MMRESULT)ICERR_BADHANDLE;

    status = ICERR_OK;

    lpbiIn = icCompress->lpbiInput;
    lpbiOut = icCompress->lpbiOutput;
    lpIn = icCompress->lpInput;
    lpOut = icCompress->lpOutput;
    lpbiOut->biSizeImage = 0;

	
	/* Synchronized SLIB SYSTEMS calls */
	Sh = info->Sh;
compress_frame:
    newQi=newQp=(((10000-icCompress->dwQuality)*30)/10000)+1;
    if (info->dwRTP!=EC_RTP_MODE_OFF) /* if using RTP, check Quant limits */
    {
      if (newQi<info->dwMaxQi)
        newQi=info->dwMaxQi;
      if (newQp<info->dwMaxQp)
        newQp=info->dwMaxQp;
    }
    if (info->dwQi!=newQi)
    {
      SlibSetParamInt(Sh, SLIB_STREAM_MAINVIDEO, SLIB_PARAM_QUANTI, newQi);
      info->dwQi=newQi;
    }
    if (info->dwQp!=newQp)
    {
      SlibSetParamInt(Sh, SLIB_STREAM_MAINVIDEO, SLIB_PARAM_QUANTP, newQp);
      info->dwQp=newQp;
    }
	if (keyframe)
    {
      _SlibDebug(_VERBOSE_, ScDebugPrintf("ICH263Compress() I Frame: Qi=%d\n", newQi) );
      SlibSetParamInt(Sh, SLIB_STREAM_MAINVIDEO, SLIB_PARAM_FRAMETYPE, FRAME_TYPE_I);
    }
    else
    {
      _SlibDebug(_VERBOSE_, ScDebugPrintf("ICH263Compress() P Frame: Qp=%d\n", newQp) );
    }
#ifdef HANDLE_EXCEPTIONS
  __try {
#endif /* HANDLE_EXCEPTIONS */
      status=SlibErrorWriting; /* in case there's an exception */
	  status = SlibWriteVideo (Sh, SLIB_STREAM_MAINVIDEO, lpIn, lpbiIn->biSizeImage);
#ifdef HANDLE_EXCEPTIONS
    } __finally {
#endif /* HANDLE_EXCEPTIONS */
      if (status != SlibErrorNone)
      {
#if defined(EXCEPTION_MESSAGES) && defined(H263_SUPPORT)
        // MessageBox(NULL, "Error in H263 SlibWriteVideo", "Warning", MB_OK);
#elif defined(EXCEPTION_MESSAGES)
        // MessageBox(NULL, "Error in H261 SlibWriteVideo", "Warning", MB_OK);
#endif
        /* make the next frame a key */
        SlibSetParamInt(Sh, SLIB_STREAM_MAINVIDEO, SLIB_PARAM_FRAMETYPE, FRAME_TYPE_I);
        status=(MMRESULT)ICERR_INTERNAL;
	    goto bail;
      }
#ifdef HANDLE_EXCEPTIONS
    }
#endif /* HANDLE_EXCEPTIONS */
	info->lastFrameNum=icCompress->lFrameNum;
    compBytes=reqBytes;
	status = SlibReadData(Sh, SLIB_STREAM_ALL, &lpOut, &compBytes, NULL);
	if (status != SlibErrorNone)
    {
      info->lastCompBytes=0;
      status=(MMRESULT)ICERR_BADSIZE;
	  goto bail;
    }
    else /* check the amount of compressed data */
    {
      int extraBytes=0;
      /* query to see if any more data is left in the codec
       * if there is then the quant step was too high, reduce it and try again
       */
	  status = SlibReadData(Sh, SLIB_STREAM_ALL, NULL, &extraBytes, NULL);
      if (extraBytes)
      {
        _SlibDebug(_VERBOSE_, ScDebugPrintf("ICH263Compress() Too much data: extraBytes=%d\n",
                    extraBytes) );
        if (newQi==31 && newQp==31) /* can't compress to any fewer bytes */
          return((MMRESULT)ICERR_BADSIZE);
        info->dwMaxQi+=1+(newQi/4); /* decrease I frame quality */
        if (info->dwMaxQi>31) info->dwMaxQi=31;
        info->dwMaxQp+=1+(newQp/4); /* decrease P frame quality */
        if (info->dwMaxQp>31) info->dwMaxQp=31;
        /* empty out the compressed data */
        SlibSeekEx(Sh, SLIB_STREAM_ALL, SLIB_SEEK_RESET, 0, 0, NULL);
        /* try to compress again, but make it a key frame */
        keyframe=TRUE;
        goto compress_frame;
      }
      /* we have compressed data less than or equal to request size */
      info->lastCompBytes=compBytes;
      lpbiOut->biSizeImage = compBytes;
      status = ICERR_OK;
    }
    if (info->dwRTP!=EC_RTP_MODE_OFF) /* RTP is on */
    {
      ptrail=(RTPTRAILER_t *)((unsigned char *)lpOut+compBytes-sizeof(RTPTRAILER_t));
      /* check for valid RTP trailer */
      if (compBytes<sizeof(RTPTRAILER_t) || ptrail->dwUniqueCode!=H26X_FOURCC)
        return((MMRESULT)ICERR_INTERNAL);
    }
    if (icCompress->dwFlags&ICCOMPRESS_KEYFRAME) /* I frame */
    {
      if (compBytes>(reqBytes>>2))
      {
        info->dwMaxQi+=1+(newQi>>2); /* decrease quality */
        if (info->dwMaxQi>31) info->dwMaxQi=31;
      }
      else if (newQi==info->dwMaxQi && compBytes<=(reqBytes>>2) && info->dwMaxQi>0)
        info->dwMaxQi--;  /* increase quality */
    }
    else /* P frame */
    {
      if (compBytes>(reqBytes>>1))
      {
        info->dwMaxQp+=1+(newQp>>2); /* decrease max quality */
        if (info->dwMaxQp>31) info->dwMaxQp=31;
        /* also decrease I quality, since P limits are based on I limits */
        info->dwMaxQi+=1+(newQi>>2);
        if (info->dwMaxQi>31) info->dwMaxQi=31;
      }
      else if (newQp==info->dwMaxQp && compBytes<(reqBytes>>1)
                && info->dwMaxQp>(info->dwMaxQi+3)/2)
        info->dwMaxQp--;  /* increase max quality */
    }
#ifdef H261_SUPPORT
    _SlibDebug(_VERBOSE_||_WARN_,
      ScDebugPrintf("ICH261Compress(%c) lpOut=%p reqBytes=%d compBytes=%d Qi=%d Qp=%d MaxQi=%d MaxQp=%d\n",
                          (icCompress->dwFlags&ICCOMPRESS_KEYFRAME)?'I':'P',
                          lpOut, reqBytes, compBytes,
                          newQi, newQp, info->dwMaxQi, info->dwMaxQp) );
#else
    _SlibDebug(_VERBOSE_||_WARN_,
      ScDebugPrintf("ICH263Compress(%c) lpOut=%p reqBytes=%d compBytes=%d Qi=%d Qp=%d MaxQi=%d MaxQp=%d\n",
                          (icCompress->dwFlags&ICCOMPRESS_KEYFRAME)?'I':'P',
                          lpOut, reqBytes, compBytes,
                          newQi, newQp, info->dwMaxQi, info->dwMaxQp) );
#endif
    _SlibDebug(_DEBUG_,
    {
      RTPTRAILER_t *ptrail=(RTPTRAILER_t *)
        ((unsigned char *)lpOut+compBytes-sizeof(RTPTRAILER_t));
      ScDebugPrintf("  Trailer: \n"
                    "           dwVersion=%d\n"
                    "           dwFlags=0x%04X\n"
                    "           dwUniqueCode=%c%c%c%c\n"
                    "           dwCompressedSize=%d\n"
                    "           dwNumberOfPackets=%d\n"
                    "           SourceFormat=%d\n"
                    "           TR=%d TRB=%d DBQ=%d\n",
	                ptrail->dwVersion,
                    ptrail->dwFlags,
	                ptrail->dwUniqueCode&0xFF, (ptrail->dwUniqueCode>>8)&0xFF,
	                (ptrail->dwUniqueCode>>16)&0xFF, (ptrail->dwUniqueCode>>24)&0xFF,
	                 ptrail->dwCompressedSize,
	                 ptrail->dwNumberOfPackets,
	                 ptrail->SourceFormat,
	                 ptrail->TR,ptrail->TRB,ptrail->DBQ);
    }
    ); /* _SlibDebug */
#ifdef H261_SUPPORT
    _SlibDebug((_DEBUG_ || _WARN_) && (info->dwRTP!=EC_RTP_MODE_OFF),
      {
        RTPTRAILER_t *ptrail=(RTPTRAILER_t *)
              ((unsigned char *)lpOut+compBytes-sizeof(RTPTRAILER_t));
        SvH261BITSTREAM_INFO *pinfo;
        BOOL rtperror=FALSE;
        unsigned int i;
        pinfo=(SvH261BITSTREAM_INFO *)((unsigned char *)ptrail
                                    -(ptrail->dwNumberOfPackets*16));
        if (ptrail->dwNumberOfPackets==0 || pinfo[0].dwBitOffset!=0)
        {
          // MessageBox(NULL, "Critical Error in H.261", "Warning", MB_OK);
          rtperror=TRUE;
        }
        /* check for sequential BitOffsets */
        for (i=1; i<ptrail->dwNumberOfPackets; i++)
          if (pinfo[i-1].dwBitOffset>=pinfo[i].dwBitOffset)
          {
            // MessageBox(NULL, "Critical Error in H.261", "Warning", MB_OK);
            rtperror=TRUE;
            break;
          }
        if (pinfo[ptrail->dwNumberOfPackets-1].dwBitOffset>ptrail->dwCompressedSize*8)
        {
          // MessageBox(NULL, "Critical Error in H.261", "Warning", MB_OK);
          rtperror=TRUE;
        }
        if (_DEBUG_ || rtperror)
        {
          if (ptrail->dwNumberOfPackets>64*2)
            ptrail->dwNumberOfPackets=32;
          for (i=0; i<ptrail->dwNumberOfPackets; i++)
          {
            ScDebugPrintf("  H261 Packet %2d: dwFlag=0x%04X  dwBitOffset=%d\n"
                          "                   MBAP=%d Quant=%d\n"
                          "                   GOBN=%d HMV=%d VMV=%d\n",
                    i, pinfo[i].dwFlag, pinfo[i].dwBitOffset,
                       pinfo[i].MBAP, pinfo[i].Quant,
                       pinfo[i].GOBN, pinfo[i].HMV, pinfo[i].VMV);
          }
        }
      }
    ); /* _SlibDebug */
#else /* H263 */
    _SlibDebug((_DEBUG_ || _WARN_) && (info->dwRTP!=EC_RTP_MODE_OFF),
      {
        RTPTRAILER_t *ptrail=(RTPTRAILER_t *)
              ((unsigned char *)lpOut+compBytes-sizeof(RTPTRAILER_t));
        SvH263BITSTREAM_INFO *pinfo;
        BOOL rtperror=FALSE;
        unsigned int i;
        pinfo=(SvH263BITSTREAM_INFO *)((unsigned char *)ptrail
                                    -(ptrail->dwNumberOfPackets*16));
        if (ptrail->dwNumberOfPackets==0 || pinfo[0].dwBitOffset!=0)
        {
          // MessageBox(NULL, "Critical Error in H.263", "Warning", MB_OK);
          rtperror=TRUE;
        }
        /* check for sequential BitOffsets */
        for (i=1; i<ptrail->dwNumberOfPackets; i++)
          if (pinfo[i-1].dwBitOffset>=pinfo[i].dwBitOffset)
          {
            // MessageBox(NULL, "Critical Error in H.263", "Warning", MB_OK);
            rtperror=TRUE;
            break;
          }
        if (pinfo[ptrail->dwNumberOfPackets-1].dwBitOffset>ptrail->dwCompressedSize*8)
        {
          // MessageBox(NULL, "Critical Error in H.263", "Warning", MB_OK);
          rtperror=TRUE;
        }
        if (_DEBUG_ || rtperror)
        {
          if (ptrail->dwNumberOfPackets>64*2)
            ptrail->dwNumberOfPackets=32;
          for (i=0; i<ptrail->dwNumberOfPackets; i++)
          {
            ScDebugPrintf("  H263 Packet %2d: dwFlag=0x%04X  dwBitOffset=%d Mode=%d\n"
                          "                   MBA=%d Quant=%d\n"
                          "                   GOBN=%d HMV1=%d VMV1=%d HMV2=%d VMV2=%d\n",
                    i, pinfo[i].dwFlag, pinfo[i].dwBitOffset, pinfo[i].Mode,
                       pinfo[i].MBA, pinfo[i].Quant,
                       pinfo[i].GOBN, pinfo[i].HMV1, pinfo[i].VMV1,
                       pinfo[i].HMV2, pinfo[i].VMV2);
          }
        }
      }
    ); /* _SlibDebug */
#endif
bail:
    return status;
}
/*
**++
**  FUNCTIONAL_NAME: ICH263Decompress
**
**  FUNCTIONAL_DESCRIPTION:
**	Open the Software CODEC
**
**  FORMAL PARAMETERS:
**	driverID
**      lpbiIn          input BITMAPINFOHEADER
**      lpbiOut         output BITMAPINFOHEADER
**
**  RETURN VALUE:
**
**  COMMENTS:
**
**  DESIGN:
**
**/

MMRESULT ICH263Decompress(H26XINFO *info,
                          ICDECOMPRESS  *icDecompress,
                          DWORD dwSize)

{
  MMRESULT            result=(MMRESULT)ICERR_OK;
  LPBITMAPINFOHEADER  lpbiIn;
  LPBITMAPINFOHEADER  lpbiOut;
  LPVOID              lpIn;
  LPVOID              lpOut;
  SlibHandle_t		Sh;
  SlibStatus_t		status;
#ifdef H261_SUPPORT
  SlibType_t stype = SLIB_TYPE_H261;
#else
  SlibType_t stype = SLIB_TYPE_H263;
#endif

  _SlibDebug(_VERBOSE_, ScDebugPrintf("In ICH263Decompress lpIn is %d\n",lpIn) );

  if (!_ICH263CheckFlags(info, ICMODE_DECOMPRESS))
    return((MMRESULT)ICERR_BADHANDLE);

  lpIn = icDecompress->lpInput;
  lpOut = icDecompress->lpOutput;

  lpbiIn = icDecompress->lpbiInput;
  lpbiOut = icDecompress->lpbiOutput;
  if (!info->bDecompressBegun &&
	  (result = ICH263DecompressBegin(info, lpbiIn, lpbiOut))!=ICERR_OK)
    return(result);

  if (icDecompress->dwFlags & ICDECOMPRESS_HURRYUP)
    return((MMRESULT)ICERR_OK);

  info->lpbiIn->biSizeImage = lpbiIn->biSizeImage;
  info->lpbiOut->biClrImportant = lpbiOut->biClrImportant;
  info->lpbiOut->biSizeImage = lpbiOut->biSizeImage; // they don't set it

  lpbiIn=info->lpbiIn;
  lpbiOut=info->lpbiOut;
  if (!info->Sh)
  {
    _SlibDebug(_VERBOSE_, ScDebugPrintf("SlibMemUsed = %ld (before SlibOpen)\n", SlibMemUsed()) );
    status = SlibOpenSync (&Sh, SLIB_MODE_DECOMPRESS, &stype, lpIn, icDecompress->lpbiInput->biSizeImage);
    SlibSetParamInt (Sh, SLIB_STREAM_MAINVIDEO, SLIB_PARAM_HEIGHT, lpbiOut->biHeight);
    SlibSetParamInt (Sh, SLIB_STREAM_MAINVIDEO, SLIB_PARAM_WIDTH, lpbiOut->biWidth);
    SlibSetParamInt (Sh, SLIB_STREAM_MAINVIDEO, SLIB_PARAM_VIDEOFORMAT, lpbiOut->biCompression);
    SlibSetParamInt (Sh, SLIB_STREAM_MAINVIDEO, SLIB_PARAM_VIDEOBITS, lpbiOut->biBitCount);
    info->Sh = Sh;
    _SlibDebug(_WARN_ && status!=SlibErrorNone,
       ScDebugPrintf("ICH263Decompress() SlibOpenSync: %s\n", SlibGetErrorText(status)) );
  }
  else
  {
    DWORD dwPadding=0xFFFFFFFF;
	status=SlibAddBuffer (info->Sh, SLIB_DATA_COMPRESSED, lpIn, icDecompress->lpbiInput->biSizeImage);
    _SlibDebug(_WARN_ && status!=SlibErrorNone,
       ScDebugPrintf("ICH263Decompress() SlibAddBuffer(%p, %d): %s\n",
	       lpIn, lpbiIn->biSizeImage, SlibGetErrorText(status)) );
    /* Add some padding bits to the end because the codecs try to peek
     * forward past the very last bits of the buffer
     */
	status=SlibAddBuffer (info->Sh, SLIB_DATA_COMPRESSED, (char *)&dwPadding, sizeof(DWORD));
  }
  if (status==SlibErrorNone)
  {
#ifdef HANDLE_EXCEPTIONS
  __try {
#endif /* HANDLE_EXCEPTIONS */
    status = SlibErrorReading;  /* in case there's an exception */
    status = SlibReadVideo(info->Sh, SLIB_STREAM_MAINVIDEO, &lpOut, &lpbiOut->biSizeImage);
#ifdef HANDLE_EXCEPTIONS
    } __finally {
#endif /* HANDLE_EXCEPTIONS */
	  if (status!=SlibErrorNone)
      {
        _SlibDebug(_WARN_ && status!=SlibErrorNone,
         ScDebugPrintf("ICH263Decompress() SlibReadVideo: %s\n", SlibGetErrorText(status)) );
	    status=(MMRESULT)ICERR_BADFORMAT;
	  }
      else
        status=(MMRESULT)ICERR_OK;
      goto bail;
#ifdef HANDLE_EXCEPTIONS
    }
#endif /* HANDLE_EXCEPTIONS */
  }
  else
    status=(MMRESULT)ICERR_BADFORMAT;
bail:
  return(status);
}





/*
 * This routine just nulls out the pValidHandles
 * pointer so that no lingering threads will be
 * able to use it. It's only called at dll
 * shutdown on NT.
 */

int TerminateH263()
{
    pValidHandles = NULL;
	return 0;
}