FlashSender.h

//
// TFFlashLCSHMEM.h
// Touché
//
// Created by Georg Kaindl on 16/3/09.
//
//  Copyright (C) 2009 Georg Kaindl
//
//  This file is part of Touché.
//
//  Touché is free software: you can redistribute it and/or modify
//  it under the terms of the GNU Lesser General Public License as
//  published by the Free Software Foundation, either version 3 of
//  the License, or (at your option) any later version.
//
//  Touché is distributed in the hope that it will be useful,
//  but WITHOUT ANY WARRANTY; without even the implied warranty of
//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
//  GNU Lesser General Public License for more details.
//
//  You should have received a copy of the GNU Lesser General Public
//  License along with Touché. If not, see <http://www.gnu.org/licenses/>.


#if !defined(__TFFlashLCSHMEM_H__)
#define __TFFlashLCSHMEM_H__ 1

#ifdef __cplusplus
extern "C"
{
#endif /* __cplusplus */ 
    
#ifdef WIN32
#include <windows.h>
typedef DWORD u_int32_t;
#else
#include <sys/types.h>
#include <semaphore.h>
#endif
    
#define TFLCS_LISTENER_NAME_MAX_LEN     (64)
#define TFLCS_LISTENER_METHOD_MAX_LEN   (64)
    
    typedef struct TFLCSLocalConnection_t {
#ifdef WIN32
        HANDLE  semaphore;
        HANDLE  mapFile;
        LPVOID  mapAddress; 
#else
        int     shmid;
        sem_t*  semaphore;
#endif
        int     open;
        char*   data;
        char    listenerName[TFLCS_LISTENER_NAME_MAX_LEN];
        char    listenerMethod[TFLCS_LISTENER_METHOD_MAX_LEN];
    } TFLCSLocalConnection_t;
    
    typedef enum {
        TFLCSErrorSuccess                   = 0,
        TFLCSErrorInvalidArgument           = 1,
        TFLCSErrorShmemKeyNotFound          = 2,
        TFLCSErrorSemaphoreCreationFailed   = 3,
        TFLCSErrorShmemIDNotFound           = 4,
        TFLCSErrorShmemOpeningFailed        = 5,
        TFLCSErrorOutOfMemory               = 6
    } TFLCSError_t;
    
    // much like errno, this will hold the last error that happened
    extern TFLCSError_t TFLCSErrno;
    
    // connect to a Flash LocalConnection
    // returns pointer to structure on success, NULL otherwise
    // if the connection could not be opened right away (because Flash is not yet running),
    // a non-null pointer is returned, but the "open" member of the structure will be 0
    // and TFLCSErrno will be set accordingly. the connection is truly open once "open" is
    // non-zero.
    TFLCSLocalConnection_t* TFLCSConnect(const char* listenerName,
                                         const char* listenerMethod,
                                         void* shmemKey,
                                         void* semaphoreKey);
    
    // disconnect a Flash LocalConnection
    void TFLCSDisconnect(TFLCSLocalConnection_t* connection);
    
    // changes the connection listener name
    void TFLCSChangeListenerName(TFLCSLocalConnection_t* connection, const char* newListenerName);
    
    // changes the connection method name
    void TFLCSChangeMethodName(TFLCSLocalConnection_t* connection, const char* newMethodName);
    
    // returns non-zero if the given connection's Flash client is connected, 0 otherwise
    int TFLCSConnectionHasConnectedClient(TFLCSLocalConnection_t* connection);
    
    // tries to determine the key for the shared memory region used by the Flash LocalConnection
    // returns a pointer to static memory on success, NULL on error.
    void* TFLCSGuessShmemKey();
    
    // get the current tick count (milliseconds since the system was started)
    u_int32_t TFLCSGetTickCount();
    
    // write an AMF3-encoded integer into a buffer
    // returns the updated buffer position
    int TFLCSWriteAMF3Integer(char* buffer, int value, int pos);
    
    // write an AMF-encoded string into a buffer
    // returns the updated buffer position
    int TFLCSWriteAMFString(char* buffer, const char * str, int pos);
    
    // write an AMF3-encoded byte array into a buffer
    // returns the updated buffer position
    int TFLCSWriteAMF3ByteArray(char* buffer, const char* bytes, int pos, int len);
    
    // writes the AMF envelope header for an LC method call
    // returns the position in the buffer
    int TFLCSWriteLCAMFEnvelopeHeader(TFLCSLocalConnection_t* connection);
    
    // writes the AMF envelope trailer for an LC method call
    // returns the updated buffer position
    int TFLCSWriteLCAMFEnvelopeTrailer(TFLCSLocalConnection_t* connection, int pos);
    
    // sends the given data of length len over the given connection as a ByteArray
    // returns 1 on success, 0 otherwise
    int TFLCSSendByteArray(TFLCSLocalConnection_t* connection, const char* bytes, int len);
    
    // gets the (string) names of all connected LC connections
    // returns the number of found strings.
    int TFLCSGetConnectedConnectionNames(TFLCSLocalConnection_t* connection, char* dest, int destLen);
    
    // dumps a given buffer (size bytes starting at offset) to stdout in a nice hex/ascii format.
    // useful for debugging purposes.
    void TFLCSDumpMemory(char* buffer, int offset, int size);
    
#ifdef __cplusplus
}
#endif /* __cplusplus */        
#endif //__TFFlashLCSHMEM_H__

/*
 TUIO C++ Library
 Copyright (c) 2005-2017 Martin Kaltenbrunner <martin@tuio.org>
 
 This library is free software; you can redistribute it and/or
 modify it under the terms of the GNU Lesser General Public
 License as published by the Free Software Foundation; either
 version 3.0 of the License, or (at your option) any later version.
 
 This library is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
 Lesser General Public License for more details.
 
 You should have received a copy of the GNU Lesser General Public
 License along with this library.
*/

#ifndef INCLUDED_FLASHSENDER_H
#define INCLUDED_FLASHSENDER_H

#include "OscSender.h"

#define MAX_FLASH_SIZE (40976)
#define DEFAULT_LC_CONN_NAME    "_OscDataStream"
#define DEFAULT_LC_METH_NAME    "receiveOscData"

namespace TUIO {
    
    class LIBDECL FlashSender : public OscSender {
                
    public:

        FlashSender();

        FlashSender(const char *conn_name, const char *meth_name);
        
        virtual ~FlashSender();
        
        bool sendOscPacket (osc::OutboundPacketStream *bundle);

        bool isConnected ();
        
        const char* tuio_type() { return "TUIO/FLC"; }
        
    private:
        TFLCSLocalConnection_t* lcConnection;
    };
}
#endif /* INCLUDED_FLASHSENDER_H */