src/vapiCameraSettings.c

Ir para a documentação deste ficheiro.

#include <stdio.h>
#include "vapiTypes.h"
#include "vapiAux.h"
#include "vapiCameraSettings.h"
#ifndef VAPI_OS_LINUX
#define VAPI_EXE "vapi.exe"
#else
#define VAPI_EXE "./vapi"
#endif

static vCameraSettings *GlobalCameraSettings;

/*
 * Funções definidas mais abaixo e utilizadas internamente:
 */
void vapiCameraSettingsResetCameraType (vCameraSettings * CameraSettings);

void vapiCameraSettingsFreeTypeRemoteIp (vCameraSettings * CameraSettings);

void
vapiGlobalCameraSettingsInit()
{
        GlobalCameraSettings = vapiCameraSettingsInit();
}

vCameraSettings *
vapiCameraSettingsRetrieveGlobal()
{
        return GlobalCameraSettings;
}

vCameraSettings *
vapiCameraSettingsInit ()
{
        vCameraSettings *CameraSettings = malloc (sizeof (vCameraSettings));
        CameraSettings->LocalCameraFirstCapture = vTRUE;
        CameraSettings->LocalCameraCapture = NULL;
        vapiCameraSettingsSetCalibrationConstant (CameraSettings, -1);
        CameraSettings->CameraType = vCameraNONE;
        CameraSettings->LocalCameraIndex = -2;
        CameraSettings->RemoteCameraIP = NULL;
        CameraSettings->RemoteCameraURL = NULL;
        CameraSettings->LocalFileName = NULL;
        return CameraSettings;
}

void
vapiCameraSettingsSetNoCapture (vCameraSettings * CameraSettings)
{
        if (!CameraSettings->LocalCameraFirstCapture)
        {
                cvReleaseCapture (&CameraSettings->LocalCameraCapture);
                CameraSettings->LocalCameraCapture = NULL;
        }
        CameraSettings->LocalCameraFirstCapture = vTRUE;
}

void
vapiCameraSettingsSetCapture (vCameraSettings * CameraSettings,
                              CvCapture * Capture)
{
        CameraSettings->LocalCameraFirstCapture = vFALSE;
        CameraSettings->LocalCameraCapture = Capture;
}

void
vapiCameraSettingsSetCalibrationConstant (vCameraSettings * CameraSettings,
                                          double Constant)
{
        CameraSettings->CalibrationConstant = Constant;
}

CvCapture *
vapiCameraSettingsGetCapture (vCameraSettings * CameraSettings)
{
        if (CameraSettings->LocalCameraFirstCapture)
        {
                return NULL;
        }
        return CameraSettings->LocalCameraCapture;
}

void
vapiCameraSettingsSetTypeLocal (vCameraSettings * CameraSettings,
                                int LocalCameraIndex)
{
        vapiCameraSettingsResetCameraType (CameraSettings);

        CameraSettings->CameraType = vCameraLocal;
        CameraSettings->LocalCameraIndex = LocalCameraIndex;
}

void
vapiCameraSettingsSetTypeLocalFile (vCameraSettings * CameraSettings,
                                    const char *LocalFileName)
{
        vapiCameraSettingsResetCameraType (CameraSettings);
        CameraSettings->LocalFileName =
                vapiReturnStringPointer (LocalFileName);
        CameraSettings->CameraType = vCameraLocalFile;

        if (strlen (LocalFileName) < 4)
        {
                CameraSettings->LocalFileName = NULL;
        }
        else
        {
                CameraSettings->LocalFileName =
                        vapiReturnStringPointer (LocalFileName);
        }
}

void
vapiCameraSettingsSetTypeRemoteIP (vCameraSettings * CameraSettings,
                                   const char *IPAddress, const char *URL)
{
        vapiCameraSettingsResetCameraType (CameraSettings);

        CameraSettings->CameraType = vCameraRemoteIP;
        CameraSettings->RemoteCameraIP = vapiReturnStringPointer (IPAddress);
        CameraSettings->RemoteCameraURL = vapiReturnStringPointer (URL);
}

int
vapiCameraSettingsGetType (vCameraSettings * CameraSettings)
{
        return CameraSettings->CameraType;
}

char *
vapiCameraSettingsGetLocalFilename (vCameraSettings * CameraSettings)
{
        if (vapiCameraSettingsGetType (CameraSettings) == vCameraLocalFile
            && CameraSettings->LocalFileName != NULL
            && vapiFileIsReadable (CameraSettings->LocalFileName))
        {
                return CameraSettings->LocalFileName;
        }
        else
        {

                return "./pixmaps/vapiErroDeCamara.png";

        }
}

void
vapiCameraSettingsResetCameraType (vCameraSettings * CameraSettings)
{
        if (CameraSettings->CameraType == vCameraRemoteIP)
        {
                vapiCameraSettingsFreeTypeRemoteIp (CameraSettings);
        }
        if (CameraSettings->CameraType == vCameraLocal)
        {
                vapiCameraSettingsSetNoCapture (CameraSettings);
                CameraSettings->LocalCameraIndex = -2;
        }
        if (CameraSettings->CameraType == vCameraLocalFile)
        {
                free (CameraSettings->LocalFileName);
                CameraSettings->LocalFileName = NULL;
        }
        CameraSettings->CameraType = vCameraNONE;
}

void
vapiCameraSettingsFreeTypeRemoteIp (vCameraSettings * CameraSettings)
{
        if (CameraSettings->RemoteCameraIP != NULL)
        {
                free (CameraSettings->RemoteCameraIP);
                CameraSettings->RemoteCameraIP = NULL;
        }
        if (CameraSettings->RemoteCameraURL != NULL)
        {
                free (CameraSettings->RemoteCameraURL);
                CameraSettings->RemoteCameraURL = NULL;
        }

}

/*
 * Não Actualizada.
 */
void
vCameraSettingsFree (vCameraSettings * vFree)
{
        vapiCameraSettingsResetCameraType (vFree);
        free (vFree);

}

int
vapiCameraSettingsGetLocalCameraNumber (vCameraSettings * CameraSettings)
{
        if (vapiCameraSettingsGetType (CameraSettings) == vCameraLocal)
        {
                return CameraSettings->LocalCameraIndex;
        }
        else
        {
                return -2;
        }
}

int
vapiCameraSettingsStartNewVapi (vCameraSettings * CameraSettings)
{
        char *VAPI_SYSTEM_CALL;

        switch (CameraSettings->CameraType)
        {
        case vCameraLocal:

                VAPI_SYSTEM_CALL = v_printf ("%s -lc %d &", VAPI_EXE,
                                             CameraSettings->
                                             LocalCameraIndex);
                v_debug (VAPI_SYSTEM_CALL);
                system (VAPI_SYSTEM_CALL);
                break;

        case vCameraLocalFile:
                VAPI_SYSTEM_CALL = v_printf ("%s -lf %s &", VAPI_EXE,
                                             CameraSettings->LocalFileName);
                v_debug (VAPI_SYSTEM_CALL);
                system (VAPI_SYSTEM_CALL);
                break;

        default:
                return 1;
                break;
        }
        free (VAPI_SYSTEM_CALL);
        return 0;
}

---