292 lines
9.0 KiB
C
292 lines
9.0 KiB
C
/*
|
|
* @DEC_COPYRIGHT@
|
|
*/
|
|
/*
|
|
* HISTORY
|
|
* $Log: scon_api.c,v $
|
|
* $EndLog$
|
|
*/
|
|
/*****************************************************************************
|
|
** Copyright (c) Digital Equipment Corporation, 1997 **
|
|
** **
|
|
** All Rights Reserved. Unpublished rights reserved under the copyright **
|
|
** laws of the United States. **
|
|
** **
|
|
** The software contained on this media is proprietary to and embodies **
|
|
** the confidential technology of Digital Equipment Corporation. **
|
|
** Possession, use, duplication or dissemination of the software and **
|
|
** media is authorized only pursuant to a valid written license from **
|
|
** Digital Equipment Corporation. **
|
|
** **
|
|
** RESTRICTED RIGHTS LEGEND Use, duplication, or disclosure by the U.S. **
|
|
** Government is subject to restrictions as set forth in Subparagraph **
|
|
** (c)(1)(ii) of DFARS 252.227-7013, or in FAR 52.227-19, as applicable. **
|
|
******************************************************************************/
|
|
/*
|
|
* SLIB Conversion API
|
|
*/
|
|
|
|
/*
|
|
#define _SLIBDEBUG_
|
|
*/
|
|
|
|
#include "scon_int.h"
|
|
#include "SC_err.h"
|
|
#include "SC_conv.h"
|
|
|
|
#ifdef WIN32
|
|
#include <mmsystem.h>
|
|
#endif
|
|
|
|
#ifdef _SLIBDEBUG_
|
|
#include "sc_debug.h"
|
|
|
|
#define _DEBUG_ 1 /* detailed debuging statements */
|
|
#define _VERBOSE_ 1 /* show progress */
|
|
#define _VERIFY_ 1 /* verify correct operation */
|
|
#define _WARN_ 1 /* warnings about strange behavior */
|
|
#endif
|
|
|
|
|
|
static unsigned dword sconTranslateFourCC(unsigned dword FourCC)
|
|
{
|
|
switch (FourCC)
|
|
{
|
|
case BI_DECYUVDIB: /* YUV 4:2:2 Packed */
|
|
case BI_YUY2: /* YUV 4:2:2 Packed */
|
|
return(BI_YUY2);
|
|
case BI_YU16SEP: /* YUV 4:2:2 Planar */
|
|
case BI_DECSEPYUVDIB: /* YUV 4:2:2 Planar */
|
|
return(BI_YU16SEP);
|
|
case BI_YU12SEP: /* YUV 4:1:1 Planar */
|
|
case BI_RGB: /* RGB */
|
|
case BI_BITFIELDS: /* RGB masked */
|
|
#ifndef WIN32
|
|
case BI_DECXIMAGEDIB: /* Unix Ximage RGB */
|
|
#endif /* !WIN32 */
|
|
case BI_YVU9SEP: /* YUV 16:1:1 Planar */
|
|
default:
|
|
return(FourCC);
|
|
}
|
|
}
|
|
|
|
static void sconInitInfo(SconInfo_t *Info)
|
|
{
|
|
_SlibDebug(_DEBUG_, printf("sconInitInfo()\n") );
|
|
Info->Mode = SCON_MODE_NONE;
|
|
Info->InputInited = FALSE;
|
|
Info->OutputInited = FALSE;
|
|
Info->Flip = FALSE;
|
|
Info->SameFormat = TRUE;
|
|
Info->ScaleUp = FALSE;
|
|
Info->ScaleDown = FALSE;
|
|
Info->FImage = NULL;
|
|
Info->FImageSize = 0;
|
|
Info->SImage = NULL;
|
|
Info->SImageSize = 0;
|
|
Info->Table = NULL;
|
|
Info->TableSize = 0;
|
|
Info->dbg = NULL;
|
|
}
|
|
|
|
static void sconValidateInfo(SconInfo_t *Info)
|
|
{
|
|
if (Info->Mode==SCON_MODE_VIDEO)
|
|
{
|
|
if (Info->InputInited && Info->OutputInited)
|
|
{
|
|
SconVideoInfo_t *in_vinfo=&Info->Input.vinfo;
|
|
SconVideoInfo_t *out_vinfo=&Info->Output.vinfo;
|
|
Info->Flip=(in_vinfo->NegHeight!=out_vinfo->NegHeight)?TRUE:FALSE;
|
|
sconCalcImageSize(in_vinfo);
|
|
sconCalcImageSize(out_vinfo);
|
|
Info->ScaleDown=(in_vinfo->Pixels>out_vinfo->Pixels)?TRUE:FALSE;
|
|
Info->ScaleUp=(in_vinfo->Pixels<out_vinfo->Pixels)?TRUE:FALSE;
|
|
if (!Info->ScaleDown && !Info->ScaleUp && in_vinfo->Width>out_vinfo->Width)
|
|
Info->ScaleUp=TRUE;
|
|
in_vinfo->FourCC=sconTranslateFourCC(in_vinfo->FourCC);
|
|
out_vinfo->FourCC=sconTranslateFourCC(out_vinfo->FourCC);
|
|
if (in_vinfo->BPP==out_vinfo->BPP &&
|
|
in_vinfo->FourCC==out_vinfo->FourCC)
|
|
Info->SameFormat=TRUE;
|
|
else
|
|
Info->SameFormat=FALSE;
|
|
}
|
|
}
|
|
}
|
|
|
|
static void sconBMHtoVideoInfo(BITMAPINFOHEADER *bmh, SconVideoInfo_t *vinfo)
|
|
{
|
|
vinfo->Width=bmh->biWidth;
|
|
if (bmh->biHeight<0) /* height is negative */
|
|
{
|
|
vinfo->Height=-bmh->biHeight;
|
|
vinfo->NegHeight=TRUE;
|
|
}
|
|
else /* height is positive */
|
|
{
|
|
vinfo->Height=bmh->biHeight;
|
|
vinfo->NegHeight=FALSE;
|
|
}
|
|
vinfo->FourCC=bmh->biCompression;
|
|
vinfo->BPP=bmh->biBitCount;
|
|
vinfo->Stride=vinfo->Width*((vinfo->BPP+7)>>3);
|
|
/* RGB bit masks */
|
|
vinfo->Rmask=0;
|
|
vinfo->Gmask=0;
|
|
vinfo->Bmask=0;
|
|
vinfo->RGBmasks=0;
|
|
if (vinfo->FourCC==BI_BITFIELDS || vinfo->FourCC==BI_RGB ||
|
|
vinfo->FourCC==BI_DECXIMAGEDIB)
|
|
{
|
|
if (vinfo->BPP==32 || vinfo->BPP==24)
|
|
{
|
|
vinfo->Rmask=0xFF0000;
|
|
vinfo->Gmask=0x00FF00;
|
|
vinfo->Bmask=0x0000FF;
|
|
}
|
|
else if (vinfo->BPP==16) /* RGB 565 */
|
|
{
|
|
vinfo->Rmask=0xF800;
|
|
vinfo->Gmask=0x07E0;
|
|
vinfo->Bmask=0x001F;
|
|
}
|
|
if (vinfo->FourCC==BI_BITFIELDS &&
|
|
bmh->biSize>=sizeof(BITMAPINFOHEADER)+3*4)
|
|
{
|
|
DWORD *MaskPtr = (DWORD *)&bmh[1];
|
|
if (MaskPtr[0] && MaskPtr[1] && MaskPtr[2])
|
|
{
|
|
/* get bit masks */
|
|
vinfo->Rmask=MaskPtr[0];
|
|
vinfo->Gmask=MaskPtr[1];
|
|
vinfo->Bmask=MaskPtr[2];
|
|
}
|
|
}
|
|
if (vinfo->Rmask==0xF800 && vinfo->Gmask==0x07E0 && vinfo->Bmask==0x001F)
|
|
vinfo->RGBmasks=565;
|
|
else if (vinfo->Rmask==0x001F && vinfo->Gmask==0x07E0 && vinfo->Bmask==0xF800)
|
|
vinfo->RGBmasks=565;
|
|
else if (vinfo->Rmask==0x7C00 && vinfo->Gmask==0x03E0 && vinfo->Bmask==0x001F)
|
|
vinfo->RGBmasks=555;
|
|
else if (vinfo->Rmask==0x001F && vinfo->Gmask==0x03E0 && vinfo->Bmask==0x7C00)
|
|
vinfo->RGBmasks=555;
|
|
else if (vinfo->Rmask==0xFF0000 && vinfo->Gmask==0x00FF00 && vinfo->Bmask==0x0000FF)
|
|
vinfo->RGBmasks=888;
|
|
else if (vinfo->Rmask==0x0000FF && vinfo->Gmask==0x00FF00 && vinfo->Bmask==0xFF0000)
|
|
vinfo->RGBmasks=888;
|
|
}
|
|
}
|
|
|
|
SconStatus_t SconOpen(SconHandle_t *handle, SconMode_t smode,
|
|
void *informat, void *outformat)
|
|
{
|
|
SconInfo_t *Info;
|
|
if (smode==SCON_MODE_VIDEO)
|
|
{
|
|
if ((Info = (SconInfo_t *)ScAlloc(sizeof(SconInfo_t))) == NULL)
|
|
return(SconErrorMemory);
|
|
sconInitInfo(Info);
|
|
Info->Mode=smode;
|
|
if (informat)
|
|
{
|
|
sconBMHtoVideoInfo((BITMAPINFOHEADER *)informat, &Info->Input.vinfo);
|
|
Info->InputInited = TRUE;
|
|
}
|
|
if (outformat)
|
|
{
|
|
sconBMHtoVideoInfo((BITMAPINFOHEADER *)outformat, &Info->Output.vinfo);
|
|
Info->OutputInited = TRUE;
|
|
}
|
|
sconValidateInfo(Info);
|
|
*handle=(SconHandle_t)Info;
|
|
return(SconErrorNone);
|
|
}
|
|
else
|
|
return(SconErrorBadMode);
|
|
}
|
|
|
|
SconStatus_t SconClose(SconHandle_t handle)
|
|
{
|
|
SconInfo_t *Info=(SconInfo_t *)handle;
|
|
_SlibDebug(_VERBOSE_, printf("SconClose()\n") );
|
|
if (!handle)
|
|
return(SconErrorBadHandle);
|
|
if (Info->Table)
|
|
ScPaFree(Info->Table);
|
|
if (Info->FImage)
|
|
ScPaFree(Info->FImage);
|
|
if (Info->SImage)
|
|
ScPaFree(Info->SImage);
|
|
ScFree(Info);
|
|
return(SconErrorNone);
|
|
}
|
|
|
|
/*
|
|
** Name: SconIsSame
|
|
** Desc: Return true if input and output formats are identical.
|
|
** Return: TRUE input == output format
|
|
** FALSE input != out format
|
|
*/
|
|
SconBoolean_t SconIsSame(SconHandle_t handle)
|
|
{
|
|
if (handle)
|
|
{
|
|
SconInfo_t *Info=(SconInfo_t *)handle;
|
|
|
|
if (Info->Mode==SCON_MODE_VIDEO)
|
|
{
|
|
if (Info->SameFormat && !Info->Flip && !Info->ScaleUp && !Info->ScaleDown)
|
|
return(TRUE);
|
|
}
|
|
}
|
|
return(FALSE);
|
|
}
|
|
|
|
SconStatus_t SconConvert(SconHandle_t handle, void *inbuf, dword inbufsize,
|
|
void *outbuf, dword outbufsize)
|
|
{
|
|
SconInfo_t *Info=(SconInfo_t *)handle;
|
|
SconStatus_t status;
|
|
_SlibDebug(_VERBOSE_, printf("SconConvert()\n") );
|
|
if (!handle)
|
|
return(SconErrorBadHandle);
|
|
if (inbuf==NULL || outbuf==NULL)
|
|
return(SconErrorBadArgument);
|
|
if (Info->Mode==SCON_MODE_VIDEO)
|
|
status=sconConvertVideo(Info, inbuf, inbufsize, outbuf, outbufsize);
|
|
else
|
|
status=SconErrorBadMode;
|
|
return(status);
|
|
}
|
|
|
|
SconStatus_t SconSetParamInt(SconHandle_t handle, SconParamType_t ptype,
|
|
SconParameter_t param, long value)
|
|
{
|
|
SconInfo_t *Info=(SconInfo_t *)handle;
|
|
SconStatus_t status=SconErrorNone;
|
|
if (!handle)
|
|
return(SconErrorBadHandle);
|
|
_SlibDebug(_DEBUG_, printf("SconSetParamInt(stream=%d, param=%d, %d)\n",
|
|
stream, param, value) );
|
|
switch (param)
|
|
{
|
|
case SCON_PARAM_STRIDE:
|
|
_SlibDebug(_DEBUG_,
|
|
printf("SconSetParamInt(SCON_PARAM_STRIDE)\n") );
|
|
if (Info->Mode==SCON_MODE_VIDEO)
|
|
{
|
|
if (ptype==SCON_INPUT || ptype==SCON_INPUT_AND_OUTPUT)
|
|
Info->Input.vinfo.Stride=(long)value;
|
|
if (ptype==SCON_OUTPUT || ptype==SCON_INPUT_AND_OUTPUT)
|
|
Info->Output.vinfo.Stride=(long)value;
|
|
}
|
|
else
|
|
status=SconErrorBadMode;
|
|
break;
|
|
default:
|
|
return(SconErrorUnsupportedParam);
|
|
}
|
|
return(status);
|
|
}
|