wine/dlls/gphoto2.ds/capability.c
Marcus Meissner 40e7ef3a1d gphoto.ds: Implemented a libgphoto2 import driver, based on the sane.ds driver.
Wrote a GUI import dialog.
With help from Aric Stewart.
2006-05-08 22:37:05 +02:00

554 lines
17 KiB
C

/*
* Copyright 2000 Corel Corporation
* Copyright 2006 Marcus Meissner
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
#define NONAMELESSUNION
#define NONAMELESSSTRUCT
#include "config.h"
#include <stdarg.h>
#include "windef.h"
#include "winbase.h"
#include "twain.h"
#include "gphoto2_i.h"
#include "wine/debug.h"
WINE_DEFAULT_DEBUG_CHANNEL(twain);
static TW_UINT16 GPHOTO2_ICAPXferMech (pTW_CAPABILITY,TW_UINT16);
static TW_UINT16 GPHOTO2_ICAPPixelType (pTW_CAPABILITY,TW_UINT16);
static TW_UINT16 GPHOTO2_ICAPPixelFlavor (pTW_CAPABILITY,TW_UINT16);
static TW_UINT16 GPHOTO2_ICAPBitDepth (pTW_CAPABILITY,TW_UINT16);
static TW_UINT16 GPHOTO2_ICAPUnits (pTW_CAPABILITY,TW_UINT16);
TW_UINT16 GPHOTO2_SaneCapability (pTW_CAPABILITY pCapability, TW_UINT16 action)
{
TW_UINT16 twCC = TWCC_SUCCESS;
TRACE("capability=%d action=%d\n", pCapability->Cap, action);
switch (pCapability->Cap)
{
case CAP_DEVICEEVENT:
case CAP_ALARMS:
case CAP_ALARMVOLUME:
case ACAP_AUDIOFILEFORMAT:
case ACAP_XFERMECH:
case ICAP_AUTOMATICBORDERDETECTION:
case ICAP_AUTOMATICDESKEW:
case ICAP_AUTODISCARDBLANKPAGES:
case ICAP_AUTOMATICROTATE:
case ICAP_FLIPROTATION:
case CAP_AUTOMATICCAPTURE:
case CAP_TIMEBEFOREFIRSTCAPTURE:
case CAP_TIMEBETWEENCAPTURES:
case CAP_AUTOSCAN:
case CAP_CLEARBUFFERS:
case CAP_MAXBATCHBUFFERS:
case ICAP_BARCODEDETECTIONENABLED:
case ICAP_SUPPORTEDBARCODETYPES:
case ICAP_BARCODEMAXSEARCHPRIORITIES:
case ICAP_BARCODESEARCHPRIORITIES:
case ICAP_BARCODESEARCHMODE:
case ICAP_BARCODEMAXRETRIES:
case ICAP_BARCODETIMEOUT:
case CAP_EXTENDEDCAPS:
case CAP_SUPPORTEDCAPS:
case ICAP_FILTER:
case ICAP_GAMMA:
case ICAP_PLANARCHUNKY:
case ICAP_BITORDERCODES:
case ICAP_CCITTKFACTOR:
case ICAP_JPEGPIXELTYPE:
/*case ICAP_JPEGQUALITY:*/
case ICAP_PIXELFLAVORCODES:
case ICAP_TIMEFILL:
case CAP_DEVICEONLINE:
case CAP_DEVICETIMEDATE:
case CAP_SERIALNUMBER:
case ICAP_EXPOSURETIME:
case ICAP_FLASHUSED2:
case ICAP_IMAGEFILTER:
case ICAP_LAMPSTATE:
case ICAP_LIGHTPATH:
case ICAP_NOISEFILTER:
case ICAP_OVERSCAN:
case ICAP_PHYSICALHEIGHT:
case ICAP_PHYSICALWIDTH:
case ICAP_ZOOMFACTOR:
case CAP_PRINTER:
case CAP_PRINTERENABLED:
case CAP_PRINTERINDEX:
case CAP_PRINTERMODE:
case CAP_PRINTERSTRING:
case CAP_PRINTERSUFFIX:
case CAP_AUTHOR:
case CAP_CAPTION:
case CAP_TIMEDATE:
case ICAP_AUTOBRIGHT:
case ICAP_BRIGHTNESS:
case ICAP_CONTRAST:
case ICAP_HIGHLIGHT:
case ICAP_ORIENTATION:
case ICAP_ROTATION:
case ICAP_SHADOW:
case ICAP_XSCALING:
case ICAP_YSCALING:
case ICAP_BITDEPTHREDUCTION:
case ICAP_BITORDER:
case ICAP_CUSTHALFTONE:
case ICAP_HALFTONES:
case ICAP_THRESHOLD:
case CAP_LANGUAGE:
case ICAP_FRAMES:
case ICAP_MAXFRAMES:
case ICAP_SUPPORTEDSIZES:
case CAP_AUTOFEED:
case CAP_CLEARPAGE:
case CAP_FEEDERALIGNMENT:
case CAP_FEEDERENABLED:
case CAP_FEEDERLOADED:
case CAP_FEEDERORDER:
case CAP_FEEDPAGE:
case CAP_PAPERBINDING:
case CAP_PAPERDETECTABLE:
case CAP_REACQUIREALLOWED:
case CAP_REWINDPAGE:
case ICAP_PATCHCODEDETECTIONENABLED:
case ICAP_SUPPORTEDPATCHCODETYPES:
case ICAP_PATCHCODEMAXSEARCHPRIORITIES:
case ICAP_PATCHCODESEARCHPRIORITIES:
case ICAP_PATCHCODESEARCHMODE:
case ICAP_PATCHCODEMAXRETRIES:
case ICAP_PATCHCODETIMEOUT:
case CAP_BATTERYMINUTES:
case CAP_BATTERYPERCENTAGE:
case CAP_POWERDOWNTIME:
case CAP_POWERSUPPLY:
case ICAP_XNATIVERESOLUTION:
case ICAP_XRESOLUTION:
case ICAP_YNATIVERESOLUTION:
case ICAP_YRESOLUTION:
twCC = TWCC_CAPUNSUPPORTED;
break;
case CAP_XFERCOUNT:
/* This is a required capability that every source need to
support but we haven't implemented yet. */
twCC = TWCC_SUCCESS;
break;
/*case ICAP_COMPRESSION:*/
case ICAP_IMAGEFILEFORMAT:
case ICAP_TILES:
twCC = TWCC_CAPUNSUPPORTED;
break;
case ICAP_XFERMECH:
twCC = GPHOTO2_ICAPXferMech (pCapability, action);
break;
case ICAP_PIXELTYPE:
twCC = GPHOTO2_ICAPPixelType (pCapability, action);
break;
case ICAP_PIXELFLAVOR:
twCC = GPHOTO2_ICAPPixelFlavor (pCapability, action);
break;
case ICAP_BITDEPTH:
twCC = GPHOTO2_ICAPBitDepth (pCapability, action);
break;
case ICAP_UNITS:
twCC = GPHOTO2_ICAPUnits (pCapability, action);
break;
case ICAP_UNDEFINEDIMAGESIZE:
case CAP_CAMERAPREVIEWUI:
case CAP_ENABLEDSUIONLY:
case CAP_INDICATORS:
case CAP_UICONTROLLABLE:
twCC = TWCC_CAPUNSUPPORTED;
break;
case ICAP_COMPRESSION:
twCC = TWCC_SUCCESS;
break;
default:
twCC = TWRC_FAILURE;
break;
}
return twCC;
}
static TW_BOOL GPHOTO2_OneValueSet32 (pTW_CAPABILITY pCapability, TW_UINT32 value)
{
pCapability->hContainer = (TW_HANDLE)GlobalAlloc (0, sizeof(TW_ONEVALUE));
TRACE("-> %ld\n", value);
if (pCapability->hContainer)
{
pTW_ONEVALUE pVal = GlobalLock ((HGLOBAL) pCapability->hContainer);
pVal->ItemType = TWTY_UINT32;
pVal->Item = value;
GlobalUnlock ((HGLOBAL) pCapability->hContainer);
pCapability->ConType = TWON_ONEVALUE;
return TRUE;
}
else
return FALSE;
}
static TW_BOOL GPHOTO2_OneValueSet16 (pTW_CAPABILITY pCapability, TW_UINT16 value)
{
pCapability->hContainer = (TW_HANDLE)GlobalAlloc (0, sizeof(TW_ONEVALUE));
TRACE("-> %d\n", value);
if (pCapability->hContainer)
{
pTW_ONEVALUE pVal = GlobalLock ((HGLOBAL) pCapability->hContainer);
pVal->ItemType = TWTY_UINT16;
pVal->Item = value;
GlobalUnlock ((HGLOBAL) pCapability->hContainer);
pCapability->ConType = TWON_ONEVALUE;
return TRUE;
}
else
return FALSE;
}
static TW_BOOL GPHOTO2_EnumSet16 (pTW_CAPABILITY pCapability, int nrofvalues, TW_UINT16 *values, int current, int def)
{
pTW_ENUMERATION pVal;
pCapability->hContainer = (TW_HANDLE)GlobalAlloc (0, sizeof(TW_ENUMERATION) + nrofvalues * sizeof(TW_UINT16));
if (!pCapability->hContainer)
return FALSE;
pVal = GlobalLock ((HGLOBAL) pCapability->hContainer);
pVal->ItemType = TWTY_UINT16;
pVal->NumItems = nrofvalues;
memcpy(pVal->ItemList, values, sizeof(TW_UINT16)*nrofvalues);
pVal->CurrentIndex = current;
pVal->DefaultIndex = def;
pCapability->ConType = TWON_ENUMERATION;
GlobalUnlock ((HGLOBAL) pCapability->hContainer);
return TRUE;
}
static TW_BOOL GPHOTO2_EnumGet16 (pTW_CAPABILITY pCapability, int *nrofvalues, TW_UINT16 **values)
{
pTW_ENUMERATION pVal = GlobalLock ((HGLOBAL) pCapability->hContainer);
if (!pVal)
return FALSE;
*nrofvalues = pVal->NumItems;
*values = HeapAlloc( GetProcessHeap(), 0, sizeof(TW_UINT16)*pVal->NumItems);
memcpy (*values, pVal->ItemList, sizeof(TW_UINT16)*(*nrofvalues));
FIXME("Current Index %ld, Default Index %ld\n", pVal->CurrentIndex, pVal->DefaultIndex);
GlobalUnlock ((HGLOBAL) pCapability->hContainer);
return TRUE;
}
static TW_BOOL GPHOTO2_OneValueGet32 (pTW_CAPABILITY pCapability, TW_UINT32 *pValue)
{
pTW_ONEVALUE pVal = GlobalLock ((HGLOBAL) pCapability->hContainer);
if (pVal)
{
*pValue = pVal->Item;
GlobalUnlock ((HGLOBAL) pCapability->hContainer);
return TRUE;
}
else
return FALSE;
}
static TW_BOOL GPHOTO2_OneValueGet16 (pTW_CAPABILITY pCapability, TW_UINT16 *pValue)
{
pTW_ONEVALUE pVal = GlobalLock ((HGLOBAL) pCapability->hContainer);
if (pVal)
{
*pValue = pVal->Item;
GlobalUnlock ((HGLOBAL) pCapability->hContainer);
return TRUE;
}
else
return FALSE;
}
/* ICAP_XFERMECH */
static TW_UINT16 GPHOTO2_ICAPXferMech (pTW_CAPABILITY pCapability, TW_UINT16 action)
{
TRACE("ICAP_XFERMECH, action %d\n", action);
switch (action)
{
case MSG_GET:
if (!GPHOTO2_OneValueSet32 (pCapability, activeDS.capXferMech))
return TWCC_LOWMEMORY;
return TWCC_SUCCESS;
case MSG_SET:
if (pCapability->ConType == TWON_ONEVALUE)
{
TW_UINT32 xfermechtemp = 0;
if (!GPHOTO2_OneValueGet32 (pCapability, &xfermechtemp))
return TWCC_LOWMEMORY;
activeDS.capXferMech = xfermechtemp;
TRACE("xfermech is %ld\n", xfermechtemp);
return TWCC_SUCCESS;
}
else if (pCapability->ConType == TWON_ENUMERATION)
{
}
FIXME("GET FAILED\n");
break;
case MSG_GETCURRENT:
if (!GPHOTO2_OneValueSet32 (pCapability, activeDS.capXferMech))
return TWCC_LOWMEMORY;
break;
case MSG_GETDEFAULT:
if (!GPHOTO2_OneValueSet32 (pCapability, TWSX_NATIVE))
return TWCC_LOWMEMORY;
break;
case MSG_RESET:
activeDS.capXferMech = TWSX_NATIVE;
break;
}
return TWCC_SUCCESS;
}
/* ICAP_PIXELTYPE */
static TW_UINT16 GPHOTO2_ICAPPixelType (pTW_CAPABILITY pCapability, TW_UINT16 action)
{
TRACE("Action %d\n", action);
switch (action)
{
case MSG_GET:
if ((pCapability->ConType == TWON_DONTCARE16) ||
(pCapability->ConType == TWON_ONEVALUE)
) {
if (!GPHOTO2_OneValueSet16 (pCapability, activeDS.pixeltype))
return TWCC_LOWMEMORY;
return TWCC_SUCCESS;
}
FIXME("Unknown container type %x in MSG_GET\n", pCapability->ConType);
return TWCC_CAPBADOPERATION;
case MSG_SET:
if (pCapability->ConType == TWON_ONEVALUE)
{
TW_UINT16 pixeltype = 0;
if (!GPHOTO2_OneValueGet16 (pCapability, &pixeltype))
return TWCC_LOWMEMORY;
activeDS.pixeltype = pixeltype;
FIXME("pixeltype changed to %d!\n", pixeltype);
return TWCC_SUCCESS;
}
FIXME("set not done\n");
if (pCapability->ConType == TWON_ENUMERATION) {
TW_UINT16 *values = NULL;
int i, nrofvalues = 0;
if (!GPHOTO2_EnumGet16 (pCapability, &nrofvalues, &values))
return TWCC_LOWMEMORY;
for (i=0;i<nrofvalues;i++)
FIXME("SET PixelType %d:%d\n", i, values[i]);
HeapFree (GetProcessHeap(), 0, values);
}
break;
case MSG_GETCURRENT:
if (!GPHOTO2_OneValueSet16 (pCapability, activeDS.pixeltype)) {
FIXME("Failed one value set in GETCURRENT, contype %d!\n", pCapability->ConType);
return TWCC_LOWMEMORY;
}
break;
case MSG_GETDEFAULT:
if (!GPHOTO2_OneValueSet16 (pCapability, TWPT_RGB)) {
FIXME("Failed onevalue set in GETDEFAULT!\n");
return TWCC_LOWMEMORY;
}
break;
case MSG_RESET:
activeDS.pixeltype = TWPT_RGB;
break;
}
return TWCC_SUCCESS;
}
/* ICAP_PIXELFLAVOR */
static TW_UINT16 GPHOTO2_ICAPPixelFlavor (pTW_CAPABILITY pCapability, TW_UINT16 action)
{
TRACE("Action %d\n", action);
switch (action)
{
case MSG_GET:
if ((pCapability->ConType == TWON_DONTCARE16) ||
(pCapability->ConType == TWON_ONEVALUE)
) {
if (!GPHOTO2_OneValueSet16 (pCapability, TWPF_CHOCOLATE))
return TWCC_LOWMEMORY;
return TWCC_SUCCESS;
}
if (!pCapability->ConType) {
TW_UINT16 arr[2];
arr[0] = TWPF_CHOCOLATE;
arr[1] = TWPF_VANILLA;
if (!GPHOTO2_EnumSet16 (pCapability, 2, arr, 1, 1))
return TWCC_LOWMEMORY;
return TWCC_SUCCESS;
}
FIXME("MSG_GET container type %x unhandled\n", pCapability->ConType);
return TWCC_BADVALUE;
case MSG_SET:
if (pCapability->ConType == TWON_ONEVALUE)
{
TW_UINT16 pixelflavor = 0;
if (!GPHOTO2_OneValueGet16 (pCapability, &pixelflavor))
return TWCC_LOWMEMORY;
activeDS.pixelflavor = pixelflavor;
FIXME("pixelflavor is %d\n", pixelflavor);
}
break;
case MSG_GETCURRENT:
if (!GPHOTO2_OneValueSet16 (pCapability, activeDS.pixelflavor))
return TWCC_LOWMEMORY;
break;
case MSG_GETDEFAULT:
if (!GPHOTO2_OneValueSet16 (pCapability, TWPF_CHOCOLATE))
return TWCC_LOWMEMORY;
break;
case MSG_RESET:
break;
}
return TWCC_SUCCESS;
}
/* ICAP_BITDEPTH */
static TW_UINT16 GPHOTO2_ICAPBitDepth (pTW_CAPABILITY pCapability, TW_UINT16 action)
{
TRACE("Action %d\n", action);
switch (action)
{
case MSG_GET:
if ((pCapability->ConType == TWON_DONTCARE16) ||
(pCapability->ConType == TWON_ONEVALUE)
) {
if (!GPHOTO2_OneValueSet16 (pCapability, 24))
return TWCC_LOWMEMORY;
return TWCC_SUCCESS;
}
FIXME("MSG_GET container type %x unhandled\n", pCapability->ConType);
return TWCC_SUCCESS;
case MSG_SET:
if (pCapability->ConType == TWON_ONEVALUE) {
TW_UINT16 bitdepth = 0;
if (!GPHOTO2_OneValueGet16 (pCapability, &bitdepth))
return TWCC_LOWMEMORY;
if (bitdepth != 24)
return TWCC_BADVALUE;
return TWCC_SUCCESS;
}
if (pCapability->ConType == TWON_ENUMERATION)
{
int i, nrofvalues = 0;
TW_UINT16 *values = NULL;
if (!GPHOTO2_EnumGet16 (pCapability, &nrofvalues, &values))
return TWCC_LOWMEMORY;
for (i=0;i<nrofvalues;i++)
FIXME("SET: enum element %d = %d\n", i, values[i]);
HeapFree (GetProcessHeap(), 0, values);
return TWCC_SUCCESS;
}
FIXME("Unhandled container type %d in MSG_SET\n", pCapability->ConType);
break;
case MSG_GETCURRENT:
if (!GPHOTO2_OneValueSet16 (pCapability, 24))
return TWCC_LOWMEMORY;
break;
case MSG_GETDEFAULT:
if (!GPHOTO2_OneValueSet16 (pCapability, 24))
return TWCC_LOWMEMORY;
break;
case MSG_RESET:
break;
}
return TWCC_SUCCESS;
}
/* ICAP_UNITS */
static TW_UINT16 GPHOTO2_ICAPUnits (pTW_CAPABILITY pCapability, TW_UINT16 action)
{
TRACE("Action %d\n", action);
switch (action)
{
case MSG_GET:
if ((pCapability->ConType == TWON_DONTCARE16) ||
(pCapability->ConType == TWON_ONEVALUE)
) {
if (!GPHOTO2_OneValueSet16 (pCapability, TWUN_PIXELS))
return TWCC_LOWMEMORY;
return TWCC_SUCCESS;
}
FIXME("MSG_GET container type %x unhandled\n", pCapability->ConType);
return TWCC_SUCCESS;
case MSG_SET:
if (pCapability->ConType == TWON_ONEVALUE) {
TW_UINT16 units = 0;
if (!GPHOTO2_OneValueGet16 (pCapability, &units))
return TWCC_LOWMEMORY;
FIXME("SET to type %d, stub.\n", units);
return TWCC_SUCCESS;
}
if (pCapability->ConType == TWON_ENUMERATION)
{
int i, nrofvalues = 0;
TW_UINT16 *values = NULL;
if (!GPHOTO2_EnumGet16 (pCapability, &nrofvalues, &values))
return TWCC_LOWMEMORY;
for (i=0;i<nrofvalues;i++)
FIXME("SET: enum element %d = %d\n", i, values[i]);
HeapFree (GetProcessHeap(), 0, values);
return TWCC_SUCCESS;
}
FIXME("Unhandled container type %d in MSG_SET\n", pCapability->ConType);
break;
case MSG_GETCURRENT:
if (!GPHOTO2_OneValueSet16 (pCapability, TWUN_INCHES))
return TWCC_LOWMEMORY;
break;
case MSG_GETDEFAULT:
if (!GPHOTO2_OneValueSet16 (pCapability, TWUN_PIXELS))
return TWCC_LOWMEMORY;
break;
case MSG_RESET:
break;
}
return TWCC_SUCCESS;
}