remotecap.c-Dateireferenz

#include "ptp.h"
#include "platform.h"
#include "conf.h"
#include "remotecap_core.h"
#include "module_load.h"
#include "modules.h"
#include "raw.h"
#include "cachebit.h"

Include-Abhängigkeitsdiagramm für remotecap.c:

gehe zum Quellcode dieser Datei

Makrodefinitionen
#define	HOOK_WAIT_MAX_DEFAULT   3000

Funktionen
int	remotecap_get_target_support (void)
int	remotecap_get_target (void)
void	remotecap_set_timeout (int timeout)
void	remotecap_is_ready (int *available_type, int *file_num)
static void	remotecap_set_available_data_type (int type)
static void	remotecap_reset (void)
int	remotecap_set_target (int type, int lstart, int lcount)
int	remotecap_using_dng_module (void)
static int	remotecap_wait (int datatype)
static void	remotecap_type_complete (int type)
void	filewrite_set_discard_file (int state)
int	filewrite_get_file_chunk (char **addr, unsigned *size, unsigned n, int *pos)
void	remotecap_raw_available (char *rawadr)
int	remotecap_get_data_chunk (int fmt, char **addr, unsigned int *size, int *pos)
int	remotecap_send_complete (int rcgd_status, int type)

Variablen
static int	hook_wait_max =HOOK_WAIT_MAX_DEFAULT
static int	available_image_data =0
static int	pending_image_data =0
static int	remote_file_target =0
static int	target_file_num
static ptp_data_chunk	raw_chunk
static ptp_data_chunk	dng_hdr_chunk
static int	startline =0
static int	linecount =0

Makro-Dokumentation

#define HOOK_WAIT_MAX_DEFAULT   3000

Definiert in Zeile 10 der Datei remotecap.c.

Dokumentation der Funktionen

int filewrite_get_file_chunk	(	char **	addr,
		unsigned *	size,
		unsigned	n,
		int *	pos
	)

void filewrite_set_discard_file

(

int

state)

Definiert in Zeile 116 der Datei filewrite.c.

                                           {
    ignore_current_write = state;
}

int remotecap_get_data_chunk	(	int	fmt,
		char **	addr,
		unsigned int *	size,
		int *	pos
	)

Definiert in Zeile 292 der Datei remotecap.c.

{
    int status = REMOTECAP_CHUNK_STATUS_LAST; // default = no more chunks
    *pos = -1; // default = sequential
    
    switch (fmt & remotecap_get_target() & available_image_data)
    {
        case PTP_CHDK_CAPTURE_RAW: //raw
            *addr=(char*)raw_chunk.address;
            *size=raw_chunk.length;
            break;
#ifdef CAM_HAS_FILEWRITETASK_HOOK
        case PTP_CHDK_CAPTURE_CRAW: //canon raw
        case PTP_CHDK_CAPTURE_JPG: //jpeg
            fwt_last_status = filewrite_get_file_chunk(addr,size,fwt_curr_chunk,pos);
            fwt_curr_chunk+=1;
            if(fwt_last_status != REMOTECAP_FWT_CHUNK_STATUS_LAST) {
                status = REMOTECAP_CHUNK_STATUS_MORE;
            } 
#ifdef CAM_HAS_CANON_RAW
            else {
                fwt_curr_chunk=0;
            }
#endif
            break;
#endif
        case PTP_CHDK_CAPTURE_DNGHDR: // dng header
            *addr=(char*)dng_hdr_chunk.address;
            *size=dng_hdr_chunk.length;
            break;
        default:
            /*
             * attempting to get an unsupported, unavailable or not requested format
             * will free all hooks, deactiveate remotecap, and return error status
             */
            *addr=NULL;
            *size=0;
    }
    if(*addr == NULL) {
        remotecap_reset();
        status = REMOTECAP_CHUNK_STATUS_ERROR;
    }

    return status;
}

int remotecap_get_target

(

void

)

Definiert in Zeile 50 der Datei remotecap.c.

                               {
    return remote_file_target;
}

int remotecap_get_target_support

(

void

)

Definiert in Zeile 39 der Datei remotecap.c.

                                       {
    int ret = (PTP_CHDK_CAPTURE_RAW | PTP_CHDK_CAPTURE_DNGHDR);
#ifdef CAM_HAS_FILEWRITETASK_HOOK
    ret |= PTP_CHDK_CAPTURE_JPG;
#ifdef CAM_HAS_CANON_RAW
    ret |= PTP_CHDK_CAPTURE_CRAW;
#endif
#endif
    return ret;
}

void remotecap_is_ready	(	int *	available_type,
		int *	file_num
	)

Definiert in Zeile 66 der Datei remotecap.c.

                                                           {
    if ( remotecap_get_target() ) {
        *available_type = available_image_data;
        if(available_image_data) {
            *file_num = target_file_num;
        } else {
            *file_num = 0;
        }
    }
    else {
        *available_type = PTP_CHDK_CAPTURE_NOTSET;
        *file_num = 0;
    }
}

void remotecap_raw_available

(

char *

rawadr)

Definiert in Zeile 168 der Datei remotecap.c.

                                           {
    // get file number as early as possible, before blocking
    // but don't set until after so it doesn't change value for remotecap_is_ready
    int next_file_num = get_target_file_num(); 
/*
ensure raw hook is blocked until any prevous remotecap shot is finished or times out
if prevous times out, remotecap settings will be cleared due to the time out, so no
remotecap will be done, although writes will still be skipped
wait == 0 timeout shouldn't get hit here unless the script is fiddling with the
timeout value, but it ensures that we don't block indefinitely.
*/
    int wait = hook_wait_max;
    while (wait && pending_image_data) {
        msleep(10);
        wait--;
    }
    if(wait == 0) {
        remotecap_reset();
    }
    pending_image_data = remote_file_target;
    target_file_num = next_file_num;
// TODO technically this could probably wait until after the raw stuff is done,
// provided the actual chunks are transmitted
// TODO this should probably just be noop if hook doesn't exist
#ifdef CAM_HAS_FILEWRITETASK_HOOK
    filewrite_set_discard_file(1);
    fwt_curr_chunk=0; //needs to be done here
#ifdef CAM_HAS_CANON_RAW
    if(shooting_get_canon_image_format() == (SHOOTING_CANON_FMT_RAW | SHOOTING_CANON_FMT_JPG)) {
        fwt_expect_file_count = 2;
    } else {
        fwt_expect_file_count = 1;
    }
#else
    fwt_expect_file_count = 1;
#endif
#endif //CAM_HAS_FILEWRITETASK_HOOK
    if (remote_file_target & PTP_CHDK_CAPTURE_DNGHDR) {
        started();
        libdng->create_dng_header_for_ptp(&dng_hdr_chunk);

        if(!remotecap_wait(PTP_CHDK_CAPTURE_DNGHDR)) {
            remotecap_reset();
        }
        libdng->free_dng_header_for_ptp();
        remotecap_type_complete(PTP_CHDK_CAPTURE_DNGHDR);
        finished();
    }

    if(!(remote_file_target & PTP_CHDK_CAPTURE_RAW)) {
        return;
    }

    started();
    
    raw_chunk.address=(unsigned int)ADR_TO_UNCACHED(rawadr+startline*CAM_RAW_ROWPIX*CAM_SENSOR_BITS_PER_PIXEL/8);
    raw_chunk.length=linecount*CAM_RAW_ROWPIX*CAM_SENSOR_BITS_PER_PIXEL/8;
  
    if(!remotecap_wait(PTP_CHDK_CAPTURE_RAW)) {
        remotecap_reset();
    }
    remotecap_type_complete(PTP_CHDK_CAPTURE_RAW);
    
    finished();
}

static void remotecap_reset ( void  )

static

Definiert in Zeile 88 der Datei remotecap.c.

                                  {
    remote_file_target=0;
    remotecap_set_available_data_type(0);
    pending_image_data=0;
    // TODO do we need remotecap_fwt_chunks_done() ?
}

int remotecap_send_complete	(	int	rcgd_status,
		int	type
	)

Definiert in Zeile 338 der Datei remotecap.c.

                                                       {
    // timeout or canceled: the data type we were sending is no longer available
    int timeout_flag = (available_image_data != type);
    if(rcgd_status == REMOTECAP_CHUNK_STATUS_LAST) {
        // currently only one data type can be available at a time
        remotecap_set_available_data_type(0);
    }
#ifdef CAM_FILEWRITETASK_MULTIPASS
    else if(type == PTP_CHDK_CAPTURE_JPG && fwt_last_status == REMOTECAP_FWT_CHUNK_STATUS_SESS_LAST) {
        remotecap_fwt_chunks_done(); // make file_chunks NULL, immediately
        fwt_session_wait = 0;
    }
#endif
    if((rcgd_status == REMOTECAP_CHUNK_STATUS_ERROR) || timeout_flag) {
        return 0;
    }
    // else more chunks of current type, no action needed
    return 1;
}

static void remotecap_set_available_data_type ( int  type)

static

Definiert in Zeile 82 der Datei remotecap.c.

{
    available_image_data = type;
}

int remotecap_set_target	(	int	type,
		int	lstart,
		int	lcount
	)

Definiert in Zeile 96 der Datei remotecap.c.

{
    // fail if invalid / unsupported type requested,
    // or current mode cannot support requested types
    if ((type & ~remotecap_get_target_support()) 
        || !camera_info.state.mode_rec
        || ((type & PTP_CHDK_CAPTURE_RAW) && !is_raw_possible())
#ifdef CAM_HAS_CANON_RAW
        || ((type & PTP_CHDK_CAPTURE_CRAW) && !(shooting_get_canon_image_format() & SHOOTING_CANON_FMT_RAW))
        || ((type & PTP_CHDK_CAPTURE_JPG) && !(shooting_get_canon_image_format() & SHOOTING_CANON_FMT_JPG))
#endif
#if defined(CAM_FILEWRITETASK_MULTIPASS) && !defined(CAM_FILEWRITETASK_SEEKS)
    // other drive modes do not work on these cams currently
        || (shooting_get_drive_mode() != 0)
#endif
        ) {
        remotecap_reset();
        return 0;
    }
    // clear requested
    if(type==0) {
        remotecap_reset();
        return 1;
    }
    // invalid range, return error
    if(lstart<0 || lstart>CAM_RAW_ROWS-1 || lcount<0 || lcount+lstart>CAM_RAW_ROWS) {
        remotecap_reset();
        return 0;
    }
    // default lcount = to end of buffer
    if(lcount == 0) {
        lcount = CAM_RAW_ROWS - lstart;
    }
    remote_file_target=type;
    startline=lstart;
    linecount=lcount;
    return 1;
}

void remotecap_set_timeout

(

int

timeout)

Definiert in Zeile 57 der Datei remotecap.c.

{
    if(timeout <= 0) {
        hook_wait_max = HOOK_WAIT_MAX_DEFAULT;
    } else {
        hook_wait_max = timeout/10;
    }
}

static void remotecap_type_complete ( int  type)

static

Definiert in Zeile 161 der Datei remotecap.c.

                                              {
    pending_image_data = (pending_image_data & ~type);
}

int remotecap_using_dng_module

(

void

)

Definiert in Zeile 140 der Datei remotecap.c.

                                     {
    return (remote_file_target & PTP_CHDK_CAPTURE_DNGHDR) != 0;
}

static int remotecap_wait ( int  datatype)

static

Definiert in Zeile 148 der Datei remotecap.c.

                                        {
    int wait = hook_wait_max;

    remotecap_set_available_data_type(datatype);

    while (wait && (available_image_data & datatype)) {
        msleep(10);
        wait--;
    }
    return wait;
}

Variablen-Dokumentation

int available_image_data =0

static

Definiert in Zeile 13 der Datei remotecap.c.

ptp_data_chunk dng_hdr_chunk

static

Definiert in Zeile 22 der Datei remotecap.c.

int hook_wait_max =HOOK_WAIT_MAX_DEFAULT

static

Definiert in Zeile 11 der Datei remotecap.c.

int linecount =0

static

Definiert in Zeile 26 der Datei remotecap.c.

int pending_image_data =0

static

Definiert in Zeile 15 der Datei remotecap.c.

ptp_data_chunk raw_chunk

static

Definiert in Zeile 21 der Datei remotecap.c.

int remote_file_target =0

static

Definiert in Zeile 17 der Datei remotecap.c.

int startline =0

static

Definiert in Zeile 25 der Datei remotecap.c.

int target_file_num

static

Definiert in Zeile 19 der Datei remotecap.c.