#include "exf1api.h"
char halfShutterPressed = FALSE;
char stillImageEnabled = TRUE;
char preRecordEnabled = FALSE;
char continousShutterEnabled = FALSE;
int init_camera(int device_num)
{
if (usbInit(device_num) == 0)
exit(1);
// Print out device info.
//exf1Cmd(CMD_GET_DEVICE_INFO);
exf1Cmd(CMD_OPEN_SESSION, SESSION_ID);
exf1Cmd(CMD_WRITE, ADDR_FUNCTIONALITY, DATA_FUNC_EXTENDED);
// Print out device info.
//exf1Cmd(CMD_GET_DEVICE_INFO);
// Print out info about all the supported properties.
// int i;
// for (i=0; i<deviceInfo.devicePropertiesSupported->noItems; i++) {
// printf("--\n");
// exf1Cmd(CMD_GET_PROP_DESC, deviceInfo.devicePropertiesSupported->data[i]);
// }
// usbRx();
start_config(TRUE, FALSE);
return 1;
}
void zoom(char zoomIn, char continousZoom) {
if (continousZoom) {
printf("> Press enter to stop zooming...");
if (zoomIn) {
exf1Cmd(CMD_CZ_PRESS, DATA_ZOOM_IN);
getchar();
exf1Cmd(CMD_CZ_RELEASE);
}
else {
exf1Cmd(CMD_CZ_PRESS, DATA_ZOOM_OUT);
getchar();
exf1Cmd(CMD_CZ_RELEASE);
}
}
else {
if (zoomIn)
exf1Cmd(CMD_ZOOM, DATA_ZOOM_IN);
else
exf1Cmd(CMD_ZOOM, DATA_ZOOM_OUT);
}
}
void focus(char focusIn, char continousFocus) {
if (continousFocus) {
printf("> Press enter to stop focusing...");
if (focusIn) {
exf1Cmd(CMD_CF_PRESS, DATA_FOCUS_IN);
getchar();
exf1Cmd(CMD_CF_RELEASE);
}
else {
exf1Cmd(CMD_CF_PRESS, DATA_FOCUS_OUT);
getchar();
exf1Cmd(CMD_CF_RELEASE);
}
}
else {
if (focusIn)
exf1Cmd(CMD_FOCUS, DATA_FOCUS_IN);
else
exf1Cmd(CMD_FOCUS, DATA_FOCUS_OUT);
}
}
void half_shutter(void)
{
if (halfShutterPressed == FALSE) {
exf1Cmd(CMD_HALF_PRESS);
halfShutterPressed = TRUE;
}
else {
exf1Cmd(CMD_HALF_RELEASE);
halfShutterPressed = FALSE;
}
}
void shutter(char *fileName, char *thumbNail, int delay)
{
printf("-1\n");
int i;
//char newFileName[255], newThumbNail[255];
if (continousShutterEnabled) {
exf1Cmd(CMD_CS_PRESS);
if (delay >= 0)
sleep(1 * delay);
else
printf("> Press enter to stop recording... "), getchar();
exf1Cmd(CMD_CS_RELEASE, preRecordEnabled);
}
else
exf1Cmd(CMD_SHUTTER);
printf("0\n");
exf1Cmd(CMD_GET_STILL_HANDLES);
if (continousShutterEnabled) {
for (i=0; i<objectHandles->noItems; i++) {
// Generate new file name.
/*
strncpy(newFileName, fileName, strlen(fileName)-4);
sprintf(newFileName, "%s-%04d.jpg", newFileName);
strncpy(newThumbNail, thumbNail, strlen(thumbNail)-4);
sprintf(newThumbNail, "%s-%04d.jpg", newThumbNail);
*/
printf("> Downloading %s and %s...\n", fileName, thumbNail);
exf1Cmd(CMD_GET_OBJECT_INFO, objectHandles->data[i]);
exf1Cmd(CMD_GET_OBJECT, TO_FILE, objectHandles->data[i], fileName);
exf1Cmd(CMD_GET_THUMBNAIL, TO_FILE, objectHandles->data[i], thumbNail);
}
}
else {
printf("1\n");
exf1Cmd(CMD_GET_OBJECT_INFO, objectHandles->data[0]);
printf("2\n");
exf1Cmd(CMD_GET_OBJECT, TO_FILE, objectHandles->data[0], fileName);
printf("3\n");
exf1Cmd(CMD_GET_THUMBNAIL, TO_FILE, objectHandles->data[0], thumbNail);
}
exf1Cmd(CMD_STILL_RESET);
}
void setup_shutter(SHUTTER_MODES shutterMode, char enablePreRecord)
{
stop_config();
switch(shutterMode) {
case SHUTTER_NORMAL:
exf1Cmd(CMD_WRITE, ADDR_CAPTURE_MODE, DATA_CAPTURE_NORMAL);
continousShutterEnabled = FALSE;
break;
case SHUTTER_CONTINOUS:
exf1Cmd(CMD_WRITE, ADDR_CAPTURE_MODE, DATA_CAPTURE_CS);
continousShutterEnabled = TRUE;
break;
case SHUTTER_PRERECORD:
exf1Cmd(CMD_WRITE, ADDR_CAPTURE_MODE, DATA_CAPTURE_PREREC);
continousShutterEnabled = TRUE;
break;
}
start_config(FALSE, enablePreRecord);
// Verify that ADDR_HS_SETTING is set to something valid?
//usbCmdGen(0x1015, TWO_READS, 4, (char[]){0x0D, 0xD0, 0x00, 0x00});
stop_config();
exf1Cmd(CMD_WRITE, ADDR_FOCUS, DATA_FOCUS_AF);
start_config(FALSE, enablePreRecord);
}
void setup_movie(MOVIE_MODES movieMode, char enablePreRecord)
{}
void setup_HS_movie(double ZOOM, double FOCUS) //čísla od 0 do 1 !!!
{
stop_config();
exf1Cmd(CMD_WRITE, ADDR_MOVIE_MODE, DATA_MOVIE_MODE_HS);
exf1Cmd(CMD_WRITE, ADDR_HS_SETTING, 0x0002); //mód 1200 snímků/s !!!
exf1Cmd(CMD_WRITE, ADDR_EXPOSURE, DATA_EXPOSURE_M); //manuální expozice, aby to poslouchalo nastavení iso, aperture, shutter
//!! možná by tam mělo být 0004 - shutter priority !!
exf1Cmd(CMD_WRITE, ADDR_APERTURE, DATA_APERTURE_F2_7); // DATA_APERTURE_F2_7); //fotí na malou díru DATA_APERTURE_F5 - DATA_APERTURE_F2_7
exf1Cmd(CMD_WRITE, ADDR_ISO, DATA_IS0_800); //maximální zesílení
exf1Cmd(CMD_WRITE, ADDR_EV, 0x0006); // 0.0EV
exf1Cmd(CMD_WRITE, ADDR_WHITE_BALANCE, 0x0004); // Daylight bílá barva
// exf1Cmd(CMD_WRITE, ADDR_FOCUS, DATA_FOCUS_MACRO); // nastaví focus nazacatek
exf1Cmd(CMD_WRITE, ADDR_FOCUS, DATA_FOCUS_MANUAL);
start_config(FALSE, FALSE);
//musi byt jinak to nebere 1/40000
stop_config();
/*0x0040 - 1/40000
0x003F - 1/32000
0x0001 - 1
*/
//!! znovu nastavení zaverky
exf1Cmd(CMD_WRITE, ADDR_SHUTTER_SPEED, 0x0040); //zaverka !! 0x0040
start_config(FALSE, FALSE);
int i;
if( ZOOM >= 0)
{
printf("zoom out\n");
exf1Cmd(CMD_CZ_PRESS, DATA_ZOOM_OUT);
sleep(10);
exf1Cmd(CMD_CZ_RELEASE); //najede na nulovou polohu
printf("zoom in %f\n", ZOOM);
exf1Cmd(CMD_CZ_PRESS, DATA_ZOOM_IN);
usleep(ZOOM*10*1e6); //nastavení zoomu (10s is maximal value)!!!!
exf1Cmd(CMD_CZ_RELEASE);
}
if( FOCUS >= 0)
{
printf("focus out\n");
exf1Cmd(CMD_CF_PRESS, DATA_FOCUS_OUT);
sleep(3);
exf1Cmd(CMD_CF_RELEASE);
printf("focus in %f\n", FOCUS);
exf1Cmd(CMD_CF_PRESS, DATA_FOCUS_IN);
usleep((1.0+FOCUS*2.2)*1e6); //nastavení ostření; musí být víc než cca 2s !!!
exf1Cmd(CMD_CF_RELEASE);
}
printf("DONE\n");
}
void setup_iso(WORD iso)
{
stop_config();
exf1Cmd(CMD_WRITE, ADDR_ISO, iso);
start_config(stillImageEnabled, preRecordEnabled);
}
void setup_aperture(WORD aperture)
{
stop_config();
exf1Cmd(CMD_WRITE, ADDR_APERTURE, aperture);
start_config(stillImageEnabled, preRecordEnabled);
}
void setup_exposure(WORD exposure)
{
stop_config();
exf1Cmd(CMD_WRITE, ADDR_EXPOSURE, exposure);
start_config(stillImageEnabled, preRecordEnabled);
}
void setup_focus(WORD focus)
{
stop_config();
exf1Cmd(CMD_WRITE, ADDR_FOCUS, focus);
start_config(stillImageEnabled, preRecordEnabled);
}
void stop_config()
{
if (stillImageEnabled)
exf1Cmd(CMD_STILL_STOP);
else
exf1Cmd(CMD_MOVIE_STOP);
}
void start_config(char enableStillImage, char enablePreRecord)
{
if (enableStillImage)
exf1Cmd(CMD_STILL_START);
else
exf1Cmd(CMD_MOVIE_START, enablePreRecord);
stillImageEnabled = enableStillImage;
preRecordEnabled = enablePreRecord;
}
void movie(char *fileName, int delay)
{
char bytes[2];
exf1Cmd(CMD_MOVIE_PRESS);
if (delay >= 0)
sleep(1 * delay);
else
printf("> Press enter to stop recording... "), getchar();
exf1Cmd(CMD_MOVIE_RELEASE, preRecordEnabled);
exf1Cmd(CMD_GET_MOVIE_HANDLES);
exf1Cmd(CMD_GET_OBJECT_INFO, objectHandles->data[0]);
exf1Cmd(CMD_GET_OBJECT, TO_FILE, objectHandles->data[0], fileName);
exf1Cmd(CMD_MOVIE_RESET, preRecordEnabled);
}
void setup_pc_monitor(void)
{
stop_config();
usbCmdGen(0x1016, ONE_READ, 6, (char[]){0x01, 0xD0, 0x00, 0x00, 0x02, 0x00});
start_config(stillImageEnabled, preRecordEnabled);
}
void setup_lcd_monitor(void)
{
stop_config();
usbCmdGen(0x1016, ONE_READ, 6, (char[]){0x01, 0xD0, 0x00, 0x00, 0x01, 0x00});
start_config(stillImageEnabled, preRecordEnabled);
}
void exit_camera(void)
{
/*
usb_bulk_read(dev, EP_IN, tmp, BUF_SIZE, TIME_OUT);
if (usb_interrupt_read(dev, EP_INT, tmp, 16, TIME_OUT) < 0)
printf("error: interrupt read 1 failed\n");
if (usb_interrupt_read(dev, EP_INT, tmp, 16, TIME_OUT) < 0)
printf("error: interrupt read 1 failed\n");
usbCmdGen(0x9002, NO_READS, 0, NULL);
if (usb_interrupt_read(dev, EP_INT, tmp, 16, TIME_OUT) < 0)
printf("error: interrupt read 1 failed\n");
if (usb_interrupt_read(dev, EP_INT, tmp, 16, TIME_OUT) < 0)
printf("error: interrupt read 1 failed\n");
usb_bulk_read(dev, EP_IN, tmp, BUF_SIZE, TIME_OUT);
usbCmdGen(0x1016, ONE_READ, 6, (char[]){0x01, 0xD0, 0x00, 0x00, 0x01, 0x00});
usbCmdGen(0x9001, ONE_READ, 4, (char[]){0x00, 0x00, 0x00, 0x00});
*/
printf("start exit\n");
stop_config();
exf1Cmd(CMD_WRITE, ADDR_FUNCTIONALITY, DATA_FUNC_BASIC);
exf1Cmd(CMD_CLOSE_SESSION);
printf("Exit done\n");
usb_release_interface(dev, 0);
usb_close(dev);
printf("Terminate done\n");
}
int grap_pc_monitor_frame(char *jpg_img)
{
int bytesRead = -1, bytesCopied = 0, frameNo = 0, jpgSize = -1;
// Not needed?
do {
bytesRead = usb_bulk_read(dev, EP_IN, img, IMG_BUF_SIZE, TIME_OUT);
//printf("1. Bytes read=%d\n", bytesRead);
} while (bytesRead < 0);
do {
frameNo = 0;
do {
bytesRead = usb_interrupt_read(dev, EP_INT, tmp, 16, TIME_OUT);
//printf("2. Bytes read=%d\n", bytesRead);
if (bytesRead == 8) {
frameNo = GET_DWORD(tmp);
//printf("Frame no.= %d\n", frameNo);
}
} while ((frameNo-1)%3 != 0);
printf("Get frame: %d!\n", frameNo);
usbCmdGen(0x9025, NO_READS, 4, (char[]){0x02, 0x00, 0x00, 0x10});
bytesRead = usb_bulk_read(dev, EP_IN, img, 512, TIME_OUT);
//printf("3. Bytes read=%d\n", bytesRead);
} while (bytesRead < 0);
memcpy(jpg_img, img+12, bytesRead-12);
bytesCopied = bytesRead;
jpgSize = GET_DWORD(img);
jpgSize -= 12;
//printf("JPG size = %d ", jpgSize);
if (jpgSize > 0) {
int bytesRemaining = jpgSize - bytesCopied + 12;
do {
bytesRead = usb_bulk_read(dev, EP_IN, jpg_img + bytesCopied - 12, 512 * ((int)(bytesRemaining/512)+1), TIME_OUT);
//printf("4. Bytes read=%d\n", bytesRead);
} while (bytesRead < 0);
bytesCopied += bytesRead;
bytesRemaining -= bytesRead;
//printf("bytesCopied=%d bytesRemaining=%d\n", bytesCopied, bytesRemaining);
} else
printf("Error: Negative JPG size!\n");
//printf("Done!\n");
return jpgSize;
}
