libgphoto2/camlibs/mustek/core.c

/*
 * Copyright © 1999/2000 by Henning Zabel <henning@uni-paderborn.de>
 *
 * This program is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License as published by the
 * Free Software Foundation; either version 2 of the License, or (at your
 * option) any later version.
 *
 * This program 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 General Public License
 * for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software Foundation,
 * Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 */
 
/*
 * gphoto driver for the Mustek MDC800 Digital Camera. The driver 
 * supports rs232 and USB.
 */

#include <stdlib.h>
#include <string.h>

#include <gphoto2-library.h>
#include <gphoto2-result.h>

#include "core.h"
#include "print.h"

#ifdef ENABLE_NLS
#  include <libintl.h>
#  undef _
#  define _(String) dgettext (GETTEXT_PACKAGE, String)
#  ifdef gettext_noop
#    define N_(String) gettext_noop (String)
#  else
#    define _(String) (String)
#    define N_(String) (String)
#  endif
#else
#  define _(String) (String)
#  define N_(String) (String)
#endif

/*----------------------  Funktion for Communication ------------------------ */

/*
 * Send the Initial Command. If the device is rs232 this
 * function will probe for the baudrate.
 */
static int
mdc800_sendInitialCommand (Camera *camera, char* answer)
{
	int	baud_rates[3]={19200,57600,115200};
	int	rate,ret;
	char	command [8]={COMMAND_BEGIN,COMMAND_INIT_CONNECT,0,0,0,COMMAND_END,0,0};

	if (camera->port->type == GP_PORT_USB)
	    return mdc800_io_sendCommand_with_retry(camera->port,command,answer,8,1,1);
	for (rate=0;rate<3;rate++)
	{
	    GPPortSettings settings;

	    ret = gp_port_get_settings(camera->port,&settings);
	    if (ret != GP_OK) return ret;
	    settings.serial.speed = baud_rates[rate];
	    ret = gp_port_set_settings(camera->port, settings);
	    if (ret != GP_OK) return ret;
	    if (GP_OK==mdc800_io_sendCommand_with_retry(camera->port,command,answer,8,1,1)) {
		printCoreNote("RS232 Baudrate probed at %d.\n",baud_rates[rate]);
		return GP_OK;
	    }
	    printCoreError("Probing RS232 Baudrate with %d fails.\n",baud_rates[rate]);
	}
	printCoreError ("Probing failed completly.\n");
	return GP_ERROR_IO;
}

/*
 * Opens the Camera:
 *     (camera is already opened by gphoto2)
 * (1) send Initial command	
 */
int mdc800_openCamera (Camera *camera)
{
	char answer [8];
	int  i,ret;

	if (camera->port->type == GP_PORT_USB) {
		printCoreNote ("Device Registered as USB.\n");
	} else {
		printCoreNote ("Device Registered as RS232. \n");
	}

	camera->pl = malloc(sizeof(struct _CameraPrivateLibrary));
	if (!camera->pl)
	    return GP_ERROR_NO_MEMORY;
	camera->pl->system_flags_valid = 0;
	camera->pl->memory_source = -1;

	/* Send initial command */
	ret = mdc800_sendInitialCommand(camera,answer);
	if (ret != GP_OK)
	{
		printCoreError ("(mdc800_openCamera) can't send initial command.\n");
		return ret;
	}
	printCoreNote ("Firmware info (last 5 Bytes) : ");
	for (i=0; i<8; i++)
		printCoreNote ("%i ",(unsigned char) answer[i]);
	printCoreNote ("\n");
	camera->pl->system_flags_valid=0;
	camera->pl->memory_source=-1;
	ret = mdc800_setDefaultStorageSource(camera);
	if (ret != GP_OK) {
		printCoreError ("(mdc800_openCamera) can't set Storage Source.\n");
		return ret;
	}
	return GP_OK;
}

int mdc800_closeCamera (Camera *camera)
{
    if (camera->pl) {
	free(camera->pl);
	camera->pl = NULL;
    }
    return GP_OK;
}


/*
 * Sets the camera speed to the defined value: 
 * 0: 19200, 1:57600, 2: 115200
 */
int mdc800_changespeed (Camera *camera,int new)
{
	int baud_rate [3]={19200,57600,115200};
	GPPortSettings settings;
	int ret,oldrate;

	printFnkCall ("(mdc800_changespeed) called.\n");
	if (camera->port->type != GP_PORT_SERIAL) /* USB ... */
	    return GP_OK;

	gp_port_get_settings(camera->port,&settings);

	if (settings.serial.speed == baud_rate[new]) /* nothing to do */
	    return GP_OK;

	for (oldrate=0;oldrate<sizeof(baud_rate)/sizeof(baud_rate[0]);oldrate++)
	    if (baud_rate[oldrate] == settings.serial.speed)
		break;

	/* We did not find it? Can't happen? */
	if (oldrate == sizeof(baud_rate)/sizeof(baud_rate[0]))
	    return GP_ERROR_IO;

	/* Setting comunication speed */
	ret = mdc800_io_sendCommand(camera->port,COMMAND_CHANGE_RS232_BAUD_RATE,new,oldrate,0,0,0);
	if (ret != GP_OK)
	{
		printCoreError ("(mdc800_changespeed) can't send first command.\n");
		return GP_ERROR_IO;
	}
	settings.serial.speed = baud_rate[new];
	ret = gp_port_set_settings(camera->port,settings);
	if (ret != GP_OK)
	{
		printCoreError ("(mdc800_changespeed) Changing Baudrate fails.\n");
		return ret;
	}
	/* Second Command */
	ret = mdc800_io_sendCommand(camera->port,COMMAND_CHANGE_RS232_BAUD_RATE,new,new,0,0,0);
	if (ret != GP_OK)
	{
		printCoreError ("(mdc800_changespeed) can't send second command.\n");
		return ret;
	}
	printCoreNote ("Set Baudrate to %d\n", baud_rate[new]);
	return GP_OK;
}

/*
 * Get the current Bautrate
 */
int mdc800_getSpeed (Camera *camera, int *speed)
{
	int rate, ret, baud_rate [3]={19200,57600,115200};
	GPPortSettings settings;

	if (camera->port->type != GP_PORT_SERIAL)
	    return GP_ERROR_IO;

	ret = gp_port_get_settings(camera->port,&settings);
	if (ret!=GP_OK) return ret;

	for (rate=0;rate<3;rate++) 
	    if (settings.serial.speed == baud_rate[rate])
		break;
	if (rate == 3)
	    return GP_ERROR_IO;
	*speed = rate;
	return GP_OK;
}


/*
 * Sets Target
 * 1: image, 2:thumbnail, 3:video, 4:not setting
 */
int mdc800_setTarget (Camera *camera,int value)
{
	return mdc800_io_sendCommand(camera->port,COMMAND_SET_TARGET,value,0,0,0,0);
}


/*
 * Loads a thumbnail from the cam .
 */
int mdc800_getThumbnail (Camera *camera,int index, void **data, int *size)
{
	int ret;
	
	printFnkCall ("(mdc800_getThumbNail) called for %i . \n",index);
	
	*size = 4096;
	*data = malloc(4096);
	if (!*data)
	    return GP_ERROR_NO_MEMORY;
	ret = mdc800_io_sendCommand(camera->port,COMMAND_GET_THUMBNAIL,index/100,(index%100)/10,index%10,*data,4096);
	if (ret != GP_OK)
	{
		printCoreError ("(mdc800_getThumbNail) can't get Thumbnail.\n");
		return ret;
	}
	mdc800_correctImageData(*data,1,0,camera->pl->memory_source == 1);
	return GP_OK;
}



/*
 * Load an Image from the cam ..
 */
int mdc800_getImage (Camera *camera, int nr, void **data, int *size)
{
	unsigned char buffer[3];
	int imagequality=-1;
	int imagesize=0;
	int ret;

	printFnkCall ("(mdc800_getImage) called for %i . \n",nr);

	ret = mdc800_setTarget (camera,1);
	if (GP_OK != ret) {
		printCoreError ("(mdc800_getImage) can't set Target. \n");
		return ret;
	}
	ret = mdc800_io_sendCommand(camera->port,COMMAND_GET_IMAGE_SIZE,nr/100,(nr%100)/10,nr%10,buffer,3);
	if (ret != GP_OK)
	{
		printCoreError ("(mdc800_getImage) request for Imagesize of %i fails.\n",nr);
		return ret;
	}

	imagesize = buffer[0]*65536+buffer[1]*256+buffer[2];
	printCoreNote ("Imagesize of %i is %i ",nr,imagesize);
	switch (imagesize/1024)
	{
	case 48:
		imagequality=0; 
		printCoreNote ("(Economic Quality 506x384)\n");
		break;
	case 128:	
		imagequality=1; 
		printCoreNote ("(Standard Quality 1012x768)\n");
		break;
	case 320:  
		imagequality=2; 
		printCoreNote ("(High Quality 1012x768)\n");
		break;
	case 4:
		printCoreNote ("(ThumbNail ? 112x96)\n");
		imagequality=-1;
		break;
	default:
		printCoreNote ("(not detected)\n");
		return 0;
	}
	*size = imagesize;
	*data = malloc(imagesize);
	ret = mdc800_io_sendCommand(camera->port,COMMAND_GET_IMAGE,nr/100,(nr%100)/10,nr%10,*data,imagesize);
	if (ret != GP_OK) {
		printCoreError ("(mdc800_getImage) request fails for Image %i.\n",nr);
		return 0;
	}
	mdc800_correctImageData(*data,imagequality == -1,imagequality,camera->pl->memory_source == 1);
	return GP_OK;
}



//------	SystemStatus of the Camera ------------------------------------------/


// Load the Status from the camera if necessary
int mdc800_getSystemStatus (Camera *camera)
{
	int ret = GP_OK;
	int tries = 3;
	if (camera->pl->system_flags_valid)
		return GP_OK;
	fprintf(stderr,"mdc800_getSystemStatus entered...\n");
	while (tries--) {
	    ret = mdc800_io_sendCommand(camera->port,COMMAND_GET_SYSTEM_STATUS,0,0,0,camera->pl->system_flags,4);
	    if (ret == GP_OK)
		break;
	}
	if (ret!=GP_OK)
	{
		printCoreError ("(mdc800_getSystemStatus) request fails.\n");
		return ret;	
	}
	fprintf(stderr,"mdc800_getSystemStatus leaving.\n");
	camera->pl->system_flags_valid=1;
	return GP_OK;
}


int mdc800_isCFCardPresent(Camera *camera)
{
	mdc800_getSystemStatus(camera);
	if (camera->pl->system_flags_valid)
		return (((unsigned char)camera->pl->system_flags[0]&1) == 0);
	else
	{
		printCoreError ("(mdc800_isCFCardPresent) detection fails.\n");
		return 0;
	}
}


int mdc800_isBatteryOk(Camera *camera)
{
	mdc800_getSystemStatus(camera);
	return (((unsigned char)camera->pl->system_flags[0]&4) == 0)?1:0;
}


/*
 * Gets CamMode.
 * 0: Camera, 1: Playback, 2:VCam
 */
int mdc800_getMode(Camera *camera)
{
	mdc800_getSystemStatus(camera);
	if (((unsigned char)camera->pl->system_flags[1]&16) == 0)
		return (((unsigned char)camera->pl->system_flags[1]&32) == 0)?1:0;
	else
		return 2;
}


/*
 * Return status of Flashlight. The
 * answer is one of MDC800_FLASHLIGHT_ Mask.
 */
int mdc800_getFlashLightStatus(Camera *camera)
{
	mdc800_getSystemStatus(camera);
	return ((unsigned char)camera->pl->system_flags[3]&7);
}


int mdc800_isLCDEnabled(Camera *camera)
{
	mdc800_getSystemStatus(camera);
	return (((unsigned char)camera->pl->system_flags[1]&4) == 4);
}


int mdc800_isMenuOn(Camera *camera)
{
	mdc800_getSystemStatus(camera);
	return (((unsigned char)camera->pl->system_flags[1]&1) == 1);
}

int mdc800_isAutoOffEnabled(Camera *camera)
{
	mdc800_getSystemStatus(camera);
	return (((unsigned char)camera->pl->system_flags[1]&8) == 8);
}

//----- Other fine functions-------------------------------------------------/


/*
 * Sets Source of Images :
 * 0: FlashCard, 1: Internal Memory
 */
int mdc800_setStorageSource (Camera *camera,int flag)
{
	int ret;
	if (flag == camera->pl->memory_source)
		return GP_OK;
	
	/* Check wether FlashCard is present */
	if ((flag == 0) && mdc800_isCFCardPresent (camera))
	{
		printCoreNote ("There's is no FlashCard in the Camera !\n");
		return GP_OK;
	}
	printFnkCall ("(mdc800_setStorageSource) called with flag=%i\n",flag);
	ret=mdc800_io_sendCommand(camera->port,COMMAND_SET_STORAGE_SOURCE,flag,0,0,0,0);
	if (ret != GP_OK)
	{
		if (flag)
		{
			printCoreError ("Can't set InternalMemory as Input!\n");
		}
		else
		{
			printCoreError ("Can't set FlashCard as Input!\n");
		}
		return ret;
	}

	printCoreNote ("Storage Source set to ");
	if (flag) {
		printCoreNote ("Internal Memory.\n");
	} else {
		printCoreNote ("Compact Flash Card.\n");
	}
	camera->pl->system_flags_valid=0;
	camera->pl->memory_source=flag;
	return GP_OK;
}


/*
 * Sets the default storage source.
 * Default means, that if there's a FlashCard, the Flashcard
 * is used, else the InternalMemory
 *
 * If camera->pl->memory_source is set ( after driver has been closed ),
 * this value will be used.
 */
int mdc800_setDefaultStorageSource (Camera *camera)
{
	int ret,source;
	
	if (camera->pl->memory_source != -1)
	{
		source=camera->pl->memory_source;
		camera->pl->memory_source=-1;
	}
	else
	{
		source=mdc800_isCFCardPresent (camera)?0:1;
	}
	ret=mdc800_setStorageSource (camera,source);
	if (ret!=GP_OK)
	{
		printCoreError ("(mdc800_setDefaultStorageSource) Setting Storage Source fails\n");
		return ret;
	}
	return GP_OK;
}


/*
 *	Returns what StorageSource is selected by the driver
 * 0: FlashCard, 1: Internal
 */
int mdc800_getStorageSource(Camera *camera)
{
	if (camera->pl->memory_source == -1)
		mdc800_setDefaultStorageSource(camera);
	return camera->pl->memory_source;
}



/*
 * Sets Camera to Camera- or PlaybackMode
 * m: 0 Camera, 1 Playback, 2:VCam (USB)
 */
int mdc800_setMode (Camera *camera,int m)
{
	int last=mdc800_getMode (camera);
	int ret;
/*
	if (mdc800_getMode () == m)
		return 1;
*/
	switch (m)
	{
		case 0:
			ret = mdc800_io_sendCommand(camera->port,COMMAND_SET_CAMERA_MODE,0,0,0,0,0);
			if (ret != GP_OK)
			{
				printCoreError ("(mdc800_setMode) setting Camera Mode fails\n");
				return ret;
			}
			if (last != m)
				printCoreNote ("Mode set to Camera Mode.\n");
			break;
			
		case 1:
			ret = mdc800_io_sendCommand(camera->port,COMMAND_SET_PLAYBACK_MODE,0,0,0,0,0);
			if (ret != GP_OK)
			{
				printCoreError ("(mdc800_setMode) setting Playback Mode fails\n");
				return ret;
			}
			if (last != m)
				printCoreNote ("Mode set to Payback Mode.\n");
			break;
			
	}
	camera->pl->system_flags_valid=0;
	return GP_OK;
}


/*
 * Sets up Flashlight. The waitForCommit waits a long
 * time, to give the camera enough time to load the
 * flashlight.
 */
int mdc800_setFlashLight (Camera* camera,int value)
{
	int command=0,redeye_flag=0,ret;
	
	if (mdc800_getFlashLightStatus (camera) == value)
		return GP_OK;
	
	redeye_flag=(value&MDC800_FLASHLIGHT_REDEYE) != 0;
	
	if ((value&MDC800_FLASHLIGHT_ON) != 0)
		command=COMMAND_SET_FLASHMODE_ON;
	else if ((value&MDC800_FLASHLIGHT_OFF) != 0)
	{
		command=COMMAND_SET_FLASHMODE_OFF;
		redeye_flag=0;
	}
	else
		command=COMMAND_SET_FLASHMODE_AUTO;

	camera->pl->system_flags_valid=0;
	ret = mdc800_io_sendCommand(camera->port,command,redeye_flag,0,0,0,0);
	if (ret != GP_OK)
	{
		printCoreError ("(mdc800_setFlashLight) sending command fails.\n");
		return ret;
	}
	printCoreNote (mdc800_getFlashLightString(value));
	printCoreNote ("\n");
	return GP_OK;
}

/*
 * Gets a String with the Text of the Flashlight-Status
 * depending on value
 */
char* mdc800_getFlashLightString (int value)
{
	switch (value)
	{
		case ( MDC800_FLASHLIGHT_REDEYE | MDC800_FLASHLIGHT_AUTO ) :
			return _("FlashLight : Auto (RedEye Reduction)");
		case MDC800_FLASHLIGHT_AUTO :
			return _("FlashLight : Auto");
		case ( MDC800_FLASHLIGHT_REDEYE | MDC800_FLASHLIGHT_ON ) :
			return _("FlashLight : On (RedEye Reduction)");
		case MDC800_FLASHLIGHT_ON :
			return _("FlashLight : On");
		case MDC800_FLASHLIGHT_OFF :
			return _("FlashLight : Off");
	}
	return _("FlashLight : undefined");
}


/*
 * Enable/Disable the LCD
 */
int mdc800_enableLCD (Camera*camera,int enable)
{
	int ret,command;
	if (enable == mdc800_isLCDEnabled (camera))
		return GP_OK;
	
	if (enable) 
		command=COMMAND_SET_LCD_ON;
	else
		command=COMMAND_SET_LCD_OFF;

	camera->pl->system_flags_valid=0;	
	ret = mdc800_io_sendCommand (camera->port,command,0,0,0,0,0);
	if (ret!=GP_OK)
	{
		printCoreError ("(mdc800_enableLCD) can't enable/disable LCD\n");
		return ret;
	}
	if (enable)
	{
		printCoreNote ("LCD is enabled\n");
	}
	else
	{
		printCoreNote ("LCD is disabled\n");
	}
	return GP_OK;
}


/*
 * Shows the specified Image, the Camera has to
 * be in Playback Mode !
 */
int mdc800_playbackImage (Camera *camera,int nr )
{
	int ret;
	ret = mdc800_getMode (camera);
	if (ret != GP_OK)
	{
		printCoreError ("(mdc800_showImage) camera must be in Playback Mode !");
		return ret;
	}

	ret = mdc800_io_sendCommand (camera->port,COMMAND_PLAYBACK_IMAGE,nr/100,(nr%100)/10,nr%10,0,0);
	if (ret!=GP_OK)
	{
		printCoreError ("(mdc800_showImage) can't playback Image %i \n",nr);
		return ret;
	}
	return GP_OK;
}

/*
 * With ths function you can get information about, how many
 * pictures can be stored in the free memory of the camera.
 *
 * h: High Quality, s: Standard Quality, e: Economy Quality
 * If one of these Pointers are 0 the will be ignored.
 */
int mdc800_getRemainFreeImageCount (Camera *camera,int* h,int* s,int *e)
{
	unsigned char data [6];
	int ret;
	
	ret = mdc800_io_sendCommand (camera->port,COMMAND_GET_REMAIN_FREE_IMAGE_COUNT,0,0,0,(char*)data,6);
	if (ret != GP_OK)
	{
		printCoreError ("(mdc800_getRemainFreeImageCount) Error sending Command.\n");
		return ret;
	}
	
	if (h != 0)
		(*h)=(int)((data[0]/16)*1000)+((data[0]%16)*100)+((data[1]/16)*10)+(data[1]%16);
	if (s != 0)
		(*s)=(int)((data[2]/16)*1000)+((data[2]%16)*100)+((data[3]/16)*10)+(data[3]%16);
	if (e != 0)
		(*e)=(int)((data[4]/16)*1000)+((data[4]%16)*100)+((data[5]/16)*10)+(data[5]%16);
	return GP_OK;
}


/*
 * Get Image Quallity 
 * 0: Economic, 1:Standard, 2:High
 */
int mdc800_getImageQuality (Camera *camera, char *retval)
{
	int ret;
	ret = mdc800_io_sendCommand (camera->port,COMMAND_GET_IMAGE_QUALITY,0,0,0,retval,1);
	if (ret!=GP_OK)
	{
		printCoreError ("(mdc800_getImageQuality) fails.\n");
		return ret;
	}
	return GP_OK;
}


/*
 *	Set Image Quality, return GP_OK if ok.
 */
int mdc800_setImageQuality (Camera *camera,int v)
{
    return mdc800_io_sendCommand (camera->port,COMMAND_SET_IMAGE_QUALITY,v,0,0,0,0);
}



/*
 * Set the WhiteBalance value
 * 1:auto ,2:indoor, 4:indoor with flashlight, 8:outdoor
 */
int mdc800_setWB (Camera *camera, int v)
{
    return mdc800_io_sendCommand(camera->port,COMMAND_SET_WB,v,0,0,0,0);
}


/*
 * Return the Exposure settings and W.B.
 */
int mdc800_getWBandExposure (Camera *camera,int* exp, int* wb)
{
	char retval[2];
	int ret;
	
	/* What's that here is a real diffenrence between USB and RS232 */
	int toggle= (camera->port->type == GP_PORT_USB);
	
	ret = mdc800_io_sendCommand(camera->port,COMMAND_GET_WB_AND_EXPOSURE,0,0,0,retval,2);
	if (ret == GP_OK)
	{
		(*exp)=(unsigned char) retval[toggle]-2;
		(*wb)=(unsigned char) retval[1-toggle];
		return 1;
	}
	printCoreError ("(mdc800_getWBandExposure) fails.\n");
	return 0;
}


/*
 * Sets the Exposure Value
 */
int mdc800_setExposure (Camera *camera,int v)
{
	return mdc800_io_sendCommand(camera->port,COMMAND_SET_EXPOSURE,v+2,0,0,0,0);
}

/*
 * Sets the Exposure Mode 
 * 0: MTRX 1:CNTR
 */
int mdc800_setExposureMode (Camera *camera,int m)
{
	return mdc800_io_sendCommand (camera->port,COMMAND_SET_EXPOSURE_MODE,m,0,0,0,0);
}


/*
 * return the Exposure Mode or -1
 */
int mdc800_getExposureMode (Camera *camera,int *retval)
{
	unsigned char cretval;
	int ret;
	ret = mdc800_io_sendCommand (camera->port,COMMAND_GET_EXPOSURE_MODE,0,0,0,&cretval,1);
	if (ret == GP_OK)
	    *retval = cretval;
	return ret;
}

/*
 * Enable, Disable the Menu 
 */
int mdc800_enableMenu (Camera *camera,int enable)
{
	char command=enable?COMMAND_SET_MENU_ON:COMMAND_SET_MENU_OFF;
	
	if (enable == mdc800_isMenuOn (camera))
		return GP_OK;
	camera->pl->system_flags_valid=0;	
	return mdc800_io_sendCommand (camera->port,command,0,0,0,0,0);
}

int mdc800_number_of_pictures (Camera *camera, int *nrofpics)
{
	unsigned char answer [2];
	int ret;
	
	printFnkCall ("(mdc800_number_of_pictures) called.\n");
	
	ret= mdc800_setTarget (camera, 1);
	if (ret != GP_OK)
	{
		printAPIError ("(mdc800_number_of_pictures) can't set Target\n");
		return ret;
	}
	
/*
	if (!mdc800_setMode (1))
	{
		printError ("(mdc800_number_of_pictures) can't set Mode\n");
		mdc800_close ();
		return 0;
	}
*/

	ret = mdc800_io_sendCommand(camera->port,COMMAND_GET_NUM_IMAGES,0,0,0,(char*)answer,2);
	if (ret != GP_OK)
	{
		printAPIError ("(mdc800_getNumberOfImages) request Number of Pictures fails.\n");
		return ret;
	}
	*nrofpics=(int)answer[0]*256+answer [1];
	return GP_OK;
}