filewrite.c-Dateireferenz

#include "stdlib.h"
#include "remotecap_core.h"

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

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

gehe zum Quellcode dieser Datei

Funktionen
int	filewrite_get_file_chunk (char **addr, int *size, unsigned n, int *pos)
void	filewrite_set_discard_file (int state)
void	filewrite_main_hook (fwt_data_struct *fwt_data)
int	filewrite_file_complete (void)
int	fwt_after_close (int param)

Variablen
static int	ignore_current_write =0
static cam_ptp_data_chunk *	file_chunks

Dokumentation der Funktionen

int filewrite_file_complete

(

void

)

Definiert in Zeile 178 der Datei filewrite.c.

                                  {
    if(ignore_current_write) {
#ifdef CAM_DRYOS
#ifdef CAM_FILEWRITETASK_SEEKS
        if (fwt_bytes_written < file_full_size) {
            return 1;
        }
#elif defined(CAM_FILEWRITETASK_MULTIPASS)
        if (!file_last_session) {
            return 1;
        }
#endif // CAM_FILEWRITETASK_SEEKS, CAM_FILEWRITETASK_MULTIPASS
        current_write_ignored=0;
        fwt_bytes_written = 0;
#endif // CAM_DRYOS
        remotecap_fwt_file_complete();
        return 1;
    }
    return 0;
}

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

Definiert in Zeile 30 der Datei filewrite.c.

                                                                        {
    *pos=-1;
#if !defined(CAM_FILEWRITETASK_MULTIPASS)
    // TODO null should probably be an error
    if (n >= MAX_CHUNKS_FOR_FWT || file_chunks == NULL) {
        *addr=(char *)0xFFFFFFFF; // signals last chunk
        *size=0;
        return REMOTECAP_FWT_CHUNK_STATUS_LAST; // last chunk
    }
    *addr=(char *)file_chunks[n].address;
    *size=file_chunks[n].length;
    if (n < MAX_CHUNKS_FOR_FWT-1) {
        if (file_chunks[n+1].length==0) {
            return REMOTECAP_FWT_CHUNK_STATUS_LAST; // last chunk
        }
        return REMOTECAP_FWT_CHUNK_STATUS_MORE; // not last chunk
    }
    return REMOTECAP_FWT_CHUNK_STATUS_LAST; // last chunk
#else
    if ( file_chunks == NULL ) { //do we have a valid queue?
        int m=50;
        while (m>0) { //wait for at most 500ms
            _SleepTask(10);
            m--;
            if ( file_chunks != NULL ) break;
        }
        if ( file_chunks == NULL ) { //timeout, error
            *addr=(char *)0;
            *size=0;
            return REMOTECAP_FWT_CHUNK_STATUS_LAST;
        }
    }
    *addr=(char *)file_chunks[file_curr_session_chunk].address;
    *size=file_chunks[file_curr_session_chunk].length;
#ifdef CAM_FILEWRITETASK_SEEKS
    if ( n == 0 ) { // first chunk for this shot
        file_bytes_left = file_full_size;
    }
    file_bytes_left -= *size;
    if (file_curr_session_chunk == 0) {
        *pos=fwt_file_offset; //only post file offset for the first chunk in the current queue
    }
#else
    (void)n;
    if ((file_curr_session_chunk==0) && (file_last_session)) {
        *pos=0; //only post file offset for the first chunk in the last queue
    }
#endif
    file_curr_session_chunk++;
#ifdef CAM_FILEWRITETASK_SEEKS
    if (file_bytes_left>0) {
        if ( file_curr_session_chunk < MAX_CHUNKS_FOR_FWT ) {
            if (file_chunks[file_curr_session_chunk].length==0) { //last chunk of the current queue
                return REMOTECAP_FWT_CHUNK_STATUS_SESS_LAST;
            }
            return REMOTECAP_FWT_CHUNK_STATUS_MORE; //not last
        }
        else {
            return REMOTECAP_FWT_CHUNK_STATUS_SESS_LAST;
        }
    }
#else
    if ( file_curr_session_chunk < MAX_CHUNKS_FOR_FWT ) {
        if (file_chunks[file_curr_session_chunk].length==0) { //last chunk of the current queue
            if (file_last_session) {
                return REMOTECAP_FWT_CHUNK_STATUS_LAST;
            }
            else {
                return REMOTECAP_FWT_CHUNK_STATUS_SESS_LAST;
            }
        }
        return REMOTECAP_FWT_CHUNK_STATUS_MORE; //not last
    }
    else {
        if (file_last_session) {
            return REMOTECAP_FWT_CHUNK_STATUS_LAST;
        }
        else {
            return REMOTECAP_FWT_CHUNK_STATUS_SESS_LAST;
        }
    }
#endif
    return REMOTECAP_FWT_CHUNK_STATUS_LAST; //last
#endif //CAM_FILEWRITETASK_MULTIPASS
}

void filewrite_main_hook

(

fwt_data_struct *

fwt_data)

Definiert in Zeile 120 der Datei filewrite.c.

{
#ifdef CAM_FILEWRITETASK_MULTIPASS
    file_curr_session_chunk = 0;
#ifdef CAM_FILEWRITETASK_SEEKS
    // don't forget to #define FWT_SEEKMASK, FWT_MUSTSEEK
    /*
     * below information is only valid when this routine is called
     *
     * seek flag is at offset 0x50 for DryOS r50
     * 2: seek is needed
     * if not 2, seek is only performed when file_offset is not 0
     *
     * seek flag is at offset 0x4c for DryOS r51
     * if (seek_flag & 0x40) == 0x40 then seek is needed
     * otherwise, seek is only performed when file_offset is not 0
     */
    if ( ((fwt_data->seek_flag & FWT_SEEKMASK) == FWT_MUSTSEEK) || (fwt_data->file_offset != 0) ) {
        fwt_file_offset = fwt_data->file_offset;
    }
    else {
        fwt_file_offset = -1; // no seek needed
    }
    file_full_size = fwt_data->full_size;
#else
    /*
     * below information is only valid when this routine is called
     *
     * we need to watch the file open flags to determine whether the file data arrives in multiple passes
     * if the flag isn't there, it's the last (or only) pass
     */
    if (fwt_data->oflags & OFLAG_NOFLUSH) {
        file_last_session = 0;
    }
    else {
        file_last_session = 1;
    }
#endif // CAM_FILEWRITETASK_SEEKS
#endif // CAM_FILEWRITETASK_MULTIPASS

    file_chunks = &(fwt_data->pdc[0]);
#ifdef CAM_HAS_CANON_RAW
    // for raw enabled cameras, get format from extension
    // A/DCIM/100CANON/IMG_1234.CR2
    if(strcmp(".CR2",&(fwt_data->name[24])) == 0) {
        remotecap_fwt_craw_available();
    } else {
        remotecap_fwt_jpeg_available();
    }
#else
    remotecap_fwt_jpeg_available();
#endif
    file_chunks=NULL;
}

void filewrite_set_discard_file

(

int

state)

Definiert in Zeile 116 der Datei filewrite.c.

                                           {
    ignore_current_write = state;
}

int fwt_after_close

(

int

param)

Definiert in Zeile 246 der Datei filewrite.c.

                                {
//    imagesavecomplete=1;
    return param;
}

Variablen-Dokumentation

cam_ptp_data_chunk* file_chunks

static

Definiert in Zeile 15 der Datei filewrite.c.

int ignore_current_write =0

static

Definiert in Zeile 4 der Datei filewrite.c.