#include "remotecap.h"

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

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

Makrodefinitionen
#define	REMOTECAP_CHUNK_STATUS_ERROR 0

#define	REMOTECAP_CHUNK_STATUS_MORE 1

#define	REMOTECAP_CHUNK_STATUS_LAST 2

#define	REMOTECAP_JPEG_CHUNK_STATUS_MORE 1

#define	REMOTECAP_JPEG_CHUNK_STATUS_LAST 2

#define	REMOTECAP_JPEG_CHUNK_STATUS_SESS_LAST 3

Funktionen
void	remotecap_is_ready (int available_type, int image_num)

void	remotecap_raw_available (char *rawadr)

void	remotecap_jpeg_available (void)

void	remotecap_type_complete (int type)

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_jpeg_chunks_done (void)

Makro-Dokumentation

#define REMOTECAP_CHUNK_STATUS_ERROR 0

Definiert in Zeile 22 der Datei remotecap_core.h.

#define REMOTECAP_CHUNK_STATUS_LAST 2

Definiert in Zeile 24 der Datei remotecap_core.h.

#define REMOTECAP_CHUNK_STATUS_MORE 1

Definiert in Zeile 23 der Datei remotecap_core.h.

#define REMOTECAP_JPEG_CHUNK_STATUS_LAST 2

Definiert in Zeile 28 der Datei remotecap_core.h.

#define REMOTECAP_JPEG_CHUNK_STATUS_MORE 1

Definiert in Zeile 27 der Datei remotecap_core.h.

#define REMOTECAP_JPEG_CHUNK_STATUS_SESS_LAST 3

Definiert in Zeile 29 der Datei remotecap_core.h.

Dokumentation der Funktionen

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

Definiert in Zeile 250 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_JPG: //jpeg
             jpeg_last_status = filewrite_get_jpeg_chunk(addr,size,jpeg_curr_chunk,pos);
             jpeg_curr_chunk+=1;
             if(jpeg_last_status != REMOTECAP_JPEG_CHUNK_STATUS_LAST) {
                 status = REMOTECAP_CHUNK_STATUS_MORE;
             }
             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 62 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_jpeg_available ( void )

void remotecap_jpeg_chunks_done ( void )

void remotecap_raw_available ( char * rawadr)

Definiert in Zeile 160 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, althouth 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_jpeg(1);
     jpeg_curr_chunk=0; //needs to be done here
 #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 290 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 && jpeg_last_status == REMOTECAP_JPEG_CHUNK_STATUS_SESS_LAST) {
         remotecap_jpeg_chunks_done(); // make jpeg_chunks NULL, immediately
         jpeg_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;
 }

void remotecap_type_complete ( int type)

Definiert in Zeile 153 der Datei remotecap.c.

                                        {
     pending_image_data = (pending_image_data & ~type);
 }

Makrodefinitionen

Funktionen

Makro-Dokumentation

Dokumentation der Funktionen