Image.cpp

#include "Image.h"
#include <stdlib.h>
#include <stdio.h>
#include "Time.h"

namespace FCam {

    unsigned char *Image::Discard = (unsigned char *)(0);
    unsigned char *Image::AutoAllocate = (unsigned char *)(-1);

    Image::Image()
    : size(0, 0), type(UNKNOWN), data(Image::Discard), refCount(NULL), 
      mutex(NULL), weak(true), holdingLock(false) {     
    }
    
    Image::Image(int w, int h, ImageFormat f) 
    : size(w, h), type(f), data(NULL), refCount(NULL), mutex(NULL),
       weak(false), holdingLock(false) {
    setData(new unsigned char[w*h*bytesPerPixel(f)]);
    refCount = new unsigned;
    *refCount = 1; // only I know about this data
    }

    Image::Image(Size s, ImageFormat f) 
    : size(s), type(f), data(NULL), refCount(NULL), mutex(NULL), 
      weak(false), holdingLock(false) {
    setData(new unsigned char[s.width*s.height*bytesPerPixel(f)]);
    refCount = new unsigned;
    *refCount = 1; // only I know about this data
    }

    Image::Image(Size s, ImageFormat f, unsigned char *d) 
    : size(s), type(f), data(NULL), refCount(NULL), mutex(NULL), 
      weak(true), holdingLock(false) {
    setData(d);
    if (valid()) {
        refCount = new unsigned;
        *refCount = 2; // there's me, and then there's the real owner of this data
    }
    }
    
    Image::Image(int w, int h, ImageFormat f, unsigned char *d) 
    : size(w, h), type(f), data(NULL), refCount(NULL), mutex(NULL), 
      weak(true), holdingLock(false) {
    setData(d);
    if (valid()) {
        refCount = new unsigned;
        *refCount = 2; // there's me, and then there's the real owner of this data
    }
    }

    Image::~Image() {
    setData(NULL);  
    }

    Image::Image(const Image &other) 
    : size(other.size), type(other.type), data(other.data), refCount(other.refCount),
      mutex(other.mutex), weak(other.weak), holdingLock(false) {
    if (refCount) {
        (*refCount)++;
    }
    };

    const Image &Image::operator=(const Image &other) {
    if (this == &other) return (*this);
    if (refCount && refCount == other.refCount) return (*this);

    setData(NULL);

    // This and the copy constructor are the only places we're
    // allowed to set data
    *(const_cast<unsigned char **>(&data)) = other.data;       
    size = other.size;
    type = other.type;
    refCount = other.refCount;
    mutex = other.mutex;
    weak = other.weak;
    if (refCount) (*refCount)++;
    holdingLock = false;

    return (*this);
    }

    void Image::setData(unsigned char *d) {

    if (holdingLock) pthread_mutex_unlock(mutex);
    holdingLock = false;

    if (mutex && refCount && (*refCount == 0 || (weak && *refCount == 1))) {
        pthread_mutex_destroy(mutex);
        delete mutex;
        mutex = NULL;
    }

    if (refCount) {
        (*refCount)--;

        if (*refCount == 0) {
        delete refCount;
        delete[] data;
        }
        refCount = NULL;
        mutex = NULL;
    }

    // This and the assignment operator are the only places we're
    // allowed to set the data field
    *(const_cast<unsigned char **>(&data)) = d;
    
    if (valid()) {
        mutex = new pthread_mutex_t;
        pthread_mutex_init(mutex, NULL);
    }


    }

    bool Image::lock(int timeout) {
    if (holdingLock) {
        printf("ERROR: image reference trying to acquire lock it's already "
           "holding. Make a separate image reference per thread.\n");
    } else if (!mutex) {
        printf("ERROR: locking an image with no mutex\n");
        debug();
        holdingLock = false;
    } else if (timeout < 0) {
        pthread_mutex_lock(mutex);
        holdingLock = true;
    } else if (timeout == 0) {
        int ret = pthread_mutex_trylock(mutex);
        holdingLock = (ret == 0);
    } else {
        struct timespec t = (struct timespec)(Time::now() + timeout);
        int ret = pthread_mutex_timedlock(mutex, &t);
        holdingLock = (ret == 0);
    }

    return holdingLock;
    }

    void Image::unlock() {
    if (!holdingLock) {
        printf("ERROR: cannot unlock a lock not held by this image reference\n");
        return;
    }
    if (!mutex) {
        printf("ERROR: unlocking an image with no mutex\n");
        debug();
        return;
    }
    pthread_mutex_unlock(mutex);
    holdingLock = false;
    }

   
}

---