AsyncFile.cpp

#include "AsyncFile.h"
#include <errno.h>
#include "Frame.h"
#include "processing/JPEG.h"
#include "processing/DNG.h"
#include "processing/Dump.h"

#include <iostream>
using namespace std;

namespace FCam {
    void *launch_async_file_writer_thread_(void *arg) {
    AsyncFileWriter *d = (AsyncFileWriter *)arg;
    d->run();    
    d->running = false;    
    pthread_exit(NULL);
    return NULL;
    }


    AsyncFileWriter::AsyncFileWriter() {
    pthread_attr_t attr;
    struct sched_param param;

    pending = 0;
    
    // make the thread
    
    param.sched_priority = sched_get_priority_min(SCHED_OTHER);
    
    pthread_attr_init(&attr);

    running = false;
    stop = false;

    sem_init(&saveQueueSemaphore, 0, 0);
    pthread_mutex_init(&saveQueueMutex, NULL);

    if ((errno =
         -(pthread_attr_setschedparam(&attr, &param) ||
           pthread_attr_setschedpolicy(&attr, SCHED_OTHER) ||
           pthread_attr_setinheritsched(&attr, PTHREAD_EXPLICIT_SCHED) ||
           pthread_create(&thread, &attr, launch_async_file_writer_thread_, this)))) {
        perror("Error creating thread");
        return;
    } else {
        running = true;
    }   
    }

    AsyncFileWriter::~AsyncFileWriter() {
    stop = true;
    sem_post(&saveQueueSemaphore);
    if (running) {
        pthread_join(thread, NULL);
    }
    }

    void AsyncFileWriter::saveDNG(Frame::Ptr f, std::string filename, Lens *lens, Flash *flash) {
    pending++;
    SaveRequest r;
    r.frame = f;
    r.filename = filename;
    r.fileType = SaveRequest::DNG;
    r.quality = 0; // meaningless for DNG
    r.lens = lens;
    r.flash = flash;

    pthread_mutex_lock(&saveQueueMutex);
    saveQueue.push(r);
    pthread_mutex_unlock(&saveQueueMutex);
    sem_post(&saveQueueSemaphore);
    }

    void AsyncFileWriter::saveJPEG(Frame::Ptr f, std::string filename, 
                   int quality, Lens *lens, Flash *flash) {
    pending++;
    SaveRequest r;
    r.frame = f;
    r.filename = filename;
    r.quality = quality;
    r.fileType = SaveRequest::JPEG;
    r.lens = lens;
    r.flash = flash;

    pthread_mutex_lock(&saveQueueMutex);
    saveQueue.push(r);
    pthread_mutex_unlock(&saveQueueMutex);
    sem_post(&saveQueueSemaphore);
    }

    void AsyncFileWriter::saveDump(Frame::Ptr f, std::string filename) {
    pending++;
    SaveRequest r;
    r.frame = f;
    r.filename = filename;
    r.quality = 0;
    r.fileType = SaveRequest::Dump;
    r.lens = NULL;
    r.flash = NULL;

    pthread_mutex_lock(&saveQueueMutex);
    saveQueue.push(r);
    pthread_mutex_unlock(&saveQueueMutex);
    sem_post(&saveQueueSemaphore);
    }

    void AsyncFileWriter::cancel() {
    pthread_mutex_lock(&saveQueueMutex);
    while (saveQueue.size()) {
        saveQueue.pop();
    };
    pthread_mutex_unlock(&saveQueueMutex);
    }

    void AsyncFileWriter::run() {
    while (!stop) {
        sem_wait(&saveQueueSemaphore);
        if (stop) return;
        SaveRequest r;
        pthread_mutex_lock(&saveQueueMutex);
        r = saveQueue.front();
        saveQueue.pop();
        pthread_mutex_unlock(&saveQueueMutex);      
        switch (r.fileType) {
        case SaveRequest::DNG:          
        FCam::saveDNG(r.frame, r.filename, r.lens, r.flash);
        break;
        case SaveRequest::JPEG:
        FCam::saveJPEG(r.frame, r.filename, r.quality, r.lens, r.flash);
        break;
        case SaveRequest::Dump:
        FCam::saveDump(r.frame, r.filename);
        break;
        default:
        cerr << "Corrupted entry in async file writer save queue." << endl;
        }

        pending--;
    }
    }
}
    

---