remotecap_core.h-Dateireferenz

#include "remotecap.h"

Include-Abhängigkeitsdiagramm für remotecap_core.h:

Dieser Graph zeigt, welche Datei direkt oder indirekt diese Datei enthält:

gehe zum Quellcode dieser Datei

Makrodefinitionen
#define	REMOTECAP_CHUNK_STATUS_ERROR   0
#define	REMOTECAP_CHUNK_STATUS_MORE   1
#define	REMOTECAP_CHUNK_STATUS_LAST   2
#define	REMOTECAP_FWT_CHUNK_STATUS_MORE   1
#define	REMOTECAP_FWT_CHUNK_STATUS_LAST   2
#define	REMOTECAP_FWT_CHUNK_STATUS_SESS_LAST   3

Funktionen
void	remotecap_is_ready (int *available_type, int *image_num)
void	remotecap_raw_available (char *rawadr)
void	remotecap_fwt_jpeg_available (void)
void	remotecap_fwt_craw_available (void)
int	remotecap_get_data_chunk (int fmt, char **addr, unsigned int *size, int *pos)
int	remotecap_send_complete (int rcgd_status, int type)
void	remotecap_fwt_chunks_done (void)
void	remotecap_fwt_file_complete (void)

Makro-Dokumentation

#define REMOTECAP_CHUNK_STATUS_ERROR   0

Definiert in Zeile 24 der Datei remotecap_core.h.

#define REMOTECAP_CHUNK_STATUS_LAST   2

Definiert in Zeile 26 der Datei remotecap_core.h.

#define REMOTECAP_CHUNK_STATUS_MORE   1

Definiert in Zeile 25 der Datei remotecap_core.h.

#define REMOTECAP_FWT_CHUNK_STATUS_LAST   2

Definiert in Zeile 30 der Datei remotecap_core.h.

#define REMOTECAP_FWT_CHUNK_STATUS_MORE   1

Definiert in Zeile 29 der Datei remotecap_core.h.

#define REMOTECAP_FWT_CHUNK_STATUS_SESS_LAST   3

Definiert in Zeile 31 der Datei remotecap_core.h.

Dokumentation der Funktionen

void remotecap_fwt_chunks_done

(

void

)

void remotecap_fwt_craw_available

(

void

)

void remotecap_fwt_file_complete

(

void

)

void remotecap_fwt_jpeg_available

(

void

)

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;
}

void remotecap_is_ready	(	int *	available_type,
		int *	image_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();
}

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;
}