Lumenarium/foldhaus_sacn.h

#define NETWORKINTID_INVALID -1

#define DEFAULT_STREAMING_ACN_PORT 5568

#define IP_ADDRESS_BYTES 16
#define STARTCODE_DMX 0

/* 
 * a description of the address space being used
 */
#define PREAMBLE_SIZE_ADDR 0
#define POSTAMBLE_SIZE_ADDR 2
#define ACN_IDENTIFIER_ADDR 4
#define ROOT_FLAGS_AND_LENGTH_ADDR 16
#define ROOT_VECTOR_ADDR 18
#define CID_ADDR 22
#define FRAMING_FLAGS_AND_LENGTH_ADDR 38
#define FRAMING_VECTOR_ADDR 40
#define SOURCE_NAME_ADDR 44
#define PRIORITY_ADDR 108
#define RESERVED_ADDR 109
#define SEQ_NUM_ADDR 111
#define OPTIONS_ADDR 112
#define UNIVERSE_ADDR 113
#define DMP_FLAGS_AND_LENGTH_ADDR 115
#define DMP_VECTOR_ADDR 117
#define DMP_ADDRESS_AND_DATA_ADDR 118
#define FIRST_PROPERTY_ADDRESS_ADDR 119
#define ADDRESS_INC_ADDR 121
#define PROP_COUNT_ADDR 123
#define START_CODE_ADDR 125
#define PROP_VALUES_ADDR (START_CODE_ADDR + 1)

/*
 * common sizes
 */
#define STREAM_HEADER_SIZE 126
#define STREAM_BODY_SIZE 512

#define SOURCE_NAME_SIZE 64
#define RLP_PREAMBLE_SIZE 16
#define RLP_POSTAMBLE_SIZE 0
#define ACN_IDENTIFIER_SIZE 12

/*
 * data definitions
 */
#define ACN_IDENTIFIER "ASC-E1.17\0\0\0"	
#define ROOT_VECTOR 4
#define FRAMING_VECTOR 2
#define DMP_VECTOR 2
#define ADDRESS_AND_DATA_FORMAT 0xa1
#define ADDRESS_INC 1
#define DMP_FIRST_PROPERTY_ADDRESS_FORCE 0
#define RESERVED_VALUE 0

//for support of the early draft
#define DRAFT_STREAM_HEADER_SIZE 90
#define DRAFT_SOURCE_NAME_SIZE 32

//for support of the early draft
#define DRAFT_ROOT_VECTOR 3

const u32 VHD_MAXFLAGBYTES = 7;  //The maximum amount of bytes used to pack the flags, len, and vector
const u32 VHD_MAXLEN = 0x0fffff;  //The maximum packet length is 20 bytes long
const u32 VHD_MAXMINLENGTH = 4095;  //The highest length that will fit in the "smallest" length pack

//Defines for the VHD flags
const u8 VHD_L_FLAG = 0x80;
const u8 VHD_V_FLAG = 0x40;
const u8 VHD_H_FLAG = 0x20;
const u8 VHD_D_FLAG = 0x10;

#define CID_Bytes 16
struct cid
{
    u8 Bytes[CID_Bytes];
};

struct sacn_universe
{
    s16 Universe;
    
    u8* StartPositionInSendBuffer;
    s32 SizeInSendBuffer;
    s32 OffsetInSendBuffer;
    
    s32 BeginPixelCopyFromOffset;
    
    platform_network_address_handle SendAddress;
};

struct sacn_send_buffer
{
    u8* Memory;
    s32 Size;
    sacn_send_buffer* Next;
};

struct sacn_universe_buffer
{
    sacn_universe* Universes;
    s32 Used;
    s32 Max;
    sacn_universe_buffer* Next;
};

struct streaming_acn
{
    memory_arena Memory;
    
    // These get created and freed together
    sacn_universe_buffer* UniverseBuffer;
    sacn_send_buffer* SendBuffer;
    
    platform_socket_handle SendSocket;
    cid CID;
    
    s32 SequenceIterator;
};


// SACN Data Header Functions
internal void InitStreamHeader (u8* Buffer, s32 BufferSize, u16 SlotCount, u8 StartCode, u16 Universe, u8 Priority, u16 Reserved, u8 Options, const char* SourceName, cid CID);
internal void SetStreamHeaderSequence_ (u8* Buffer, u8 Sequence, b32 Draft);
internal void VHD_PackFlags_(u8* Buffer, b32 InheritVec, b32 InheritHead, b32 InheritData);
internal u8*  VHD_PackLength_(u8* Buffer, u32 Length, b32 IncludeLength);
internal cid  StringToCID_ (const char* String);

#define CalculateSendBufferSize(UniverseCount) ((UniverseCount * (STREAM_HEADER_SIZE + STREAM_BODY_SIZE)) + sizeof(sacn_send_buffer))
#define CalculateUniverseBufferSize(UniverseCount) ((UniverseCount * sizeof(sacn_universe)) + sizeof(sacn_universe_buffer))

// Utility

struct sacn_pixel
{
    u8 R;
    u8 G;
    u8 B;
};

internal sacn_pixel
PackFloatsToSACNPixel (r32 R, r32 G, r32 B)
{
    sacn_pixel Result = {};
    Result.R = (u8)(GSClamp01(R) * 255);
    Result.G = (u8)(GSClamp01(G) * 255);
    Result.B = (u8)(GSClamp01(B) * 255);
    return Result;
}

//

internal sacn_universe*
SACNGetUniverse (s32 UniverseNumber, streaming_acn* SACN)
{
    sacn_universe* Result = 0;
    
    sacn_universe_buffer* Header = SACN->UniverseBuffer;
    while (Header)
    {
        sacn_universe* Cursor = Header->Universes;
        for (s32 i = 0; i < Header->Used; i++)
        {
            if (Cursor->Universe == UniverseNumber)
            {
                Result = Cursor;
                break;
            }
            Cursor++;
        }
        Header = Header->Next;
    }
    
    return Result;
}

internal void
SACNPushSendBufferOnList (sacn_send_buffer* ListHead, sacn_send_buffer* NewBuffer)
{
    if (ListHead->Next)
    {
        SACNPushSendBufferOnList(ListHead->Next, NewBuffer);
    }
    else
    {
        ListHead->Next = NewBuffer;
    }
}

internal sacn_send_buffer* 
SACNRemoveSendBufferFromList (sacn_send_buffer* List, sacn_send_buffer* Entry)
{
    sacn_send_buffer* ListHead = 0;
    if (List != Entry && List->Next)
    {
        ListHead = SACNRemoveSendBufferFromList(List->Next, Entry);
    }
    else if (List == Entry)
    {
        ListHead = Entry->Next;
    }
    else
    {
        // NOTE(Peter): Trying to remove an entry from a list that doesn't contain it
        InvalidCodePath;
    }
    return ListHead;
}

internal void
SACNPushUniverseBufferOnList (sacn_universe_buffer* ListHead, sacn_universe_buffer* NewBuffer)
{
    if (ListHead->Next)
    {
        SACNPushUniverseBufferOnList(ListHead->Next, NewBuffer);
    }
    else
    {
        ListHead->Next = NewBuffer;
    }
}

internal sacn_universe_buffer* 
SACNRemoveUniverseBufferFromList (sacn_universe_buffer* List, sacn_universe_buffer* Entry)
{
    sacn_universe_buffer* ListHead = 0;
    if (List != Entry && List->Next)
    {
        ListHead = SACNRemoveUniverseBufferFromList(List->Next, Entry);
    }
    else if (List == Entry)
    {
        ListHead = Entry->Next;
    }
    else
    {
        // NOTE(Peter): Trying to remove an entry from a list that doesn't contain it
        InvalidCodePath;
    }
    return ListHead;
}

struct sacn_add_universes_result
{
    sacn_send_buffer* NewSendBuffer;
    sacn_universe_buffer* NewUniverseBuffer;
};
internal sacn_add_universes_result
SACNAddUniverses(s32* Universes, s32 UniversesLength, streaming_acn* SACN, context Context)
{
    sacn_add_universes_result Result = {};
    
    // Determine which universes are already registered and not to be readded. 
    // NOTE(Peter): This might create funky behaviour if two sculptures start sending data to the same universe
    // but I'm not sure its incorrect behavior. I think, eventually, we will want to spit out a report from
    // this function that says what universes were duplicated. We might want to display this information to the user
    // in a way that they don't have to exit out of every single time they load the software. Not sure
    s32 UniversesToAdd = 0;
    for (s32 i = 0; i < UniversesLength; i++)
    {
        sacn_universe* UniverseExists = SACNGetUniverse(Universes[i], SACN);
        if (UniverseExists)
        {
            Universes[i] = -1;
        }
        else
        {
            UniversesToAdd++;
        }
    }
    
    // Push On New Send and Universe Buffers
    s32 SendBufferSize = CalculateSendBufferSize(UniversesToAdd);
    u8* SendBufferMemory = PushArray(&SACN->Memory, u8, SendBufferSize);
    sacn_send_buffer* SendBufferHeader = (sacn_send_buffer*)SendBufferMemory;
    SendBufferHeader->Memory = (u8*)(SendBufferHeader + 1);
    SendBufferHeader->Size = SendBufferSize - sizeof(sacn_send_buffer);
    SendBufferHeader->Next = 0;
    if (SACN->SendBuffer)
    {
        SACNPushSendBufferOnList(SACN->SendBuffer, SendBufferHeader);
    }
    else
    {
        SACN->SendBuffer = SendBufferHeader;
    }
    
    s32 UniverseBufferSize = CalculateUniverseBufferSize(UniversesToAdd);
    u8* UniverseBufferMemory = PushArray(&SACN->Memory, u8, UniverseBufferSize);
    sacn_universe_buffer* UniverseBufferHeader = (sacn_universe_buffer*)UniverseBufferMemory;
    UniverseBufferHeader->Universes = (sacn_universe*)(UniverseBufferHeader + 1);
    UniverseBufferHeader->Used = 0;
    UniverseBufferHeader->Max = UniversesToAdd;
    if (SACN->UniverseBuffer)
    {
        SACNPushUniverseBufferOnList(SACN->UniverseBuffer, UniverseBufferHeader);
    }
    else
    {
        SACN->UniverseBuffer = UniverseBufferHeader;
    }
    
    // Add each of the valid universes
    for (s32 j = 0; j < UniversesLength; j++)
    {
        if (Universes[j] >= 0)
        {
            Assert(UniverseBufferHeader->Used < UniverseBufferHeader->Max);
            s32 Index = UniverseBufferHeader->Used++;
            s32 UniverseID = Universes[j];
            
            UniverseBufferHeader->Universes[Index].Universe         = UniverseID;
            UniverseBufferHeader->Universes[Index].SizeInSendBuffer = STREAM_HEADER_SIZE + STREAM_BODY_SIZE;
            UniverseBufferHeader->Universes[Index].BeginPixelCopyFromOffset = -1;
            
            // Configure how the universe looks into the pixel color buffer
            s32 SendBufferOffset        = (Index * (STREAM_HEADER_SIZE + STREAM_BODY_SIZE));
            u8* SendBufferStartPosition = SendBufferHeader->Memory + SendBufferOffset;
            UniverseBufferHeader->Universes[Index].OffsetInSendBuffer        = SendBufferOffset;
            UniverseBufferHeader->Universes[Index].StartPositionInSendBuffer = SendBufferStartPosition;
            
            // Set up the Send Address
            u8 MulticastAddressBuffer[IP_ADDRESS_BYTES];
            GSMemSet(MulticastAddressBuffer, 0, IP_ADDRESS_BYTES);
            MulticastAddressBuffer[12] = 239;
            MulticastAddressBuffer[13] = 255;
            PackB2(MulticastAddressBuffer + 14, UniverseID);
            u_long V4Address = (u_long)UpackB4(MulticastAddressBuffer + IP_ADDRESS_BYTES - sizeof(u32));
            
            GSMemSet(&UniverseBufferHeader->Universes[Index].SendAddress, 0, sizeof(sockaddr_in));
            UniverseBufferHeader->Universes[Index].SendAddress = Context.PlatformGetSendAddress(
                AF_INET,
                HostToNetU16(DEFAULT_STREAMING_ACN_PORT), 
                HostToNetU32(V4Address));
            
#if 0 // Old Net Code
            UniverseBufferHeader->Universes[Index].SendAddress.sin_family = AF_INET;
            UniverseBufferHeader->Universes[Index].SendAddress.sin_port = HostToNetU16(DEFAULT_STREAMING_ACN_PORT);
            UniverseBufferHeader->Universes[Index].SendAddress.sin_addr.s_addr = HostToNetU32(V4Address);
#endif
            
            s32 SlotCount = 512;
            InitStreamHeader(UniverseBufferHeader->Universes[Index].StartPositionInSendBuffer, 
                             UniverseBufferHeader->Universes[Index].SizeInSendBuffer, 
                             SlotCount,
                             STARTCODE_DMX,
                             UniverseID,
                             0,
                             0, // Reserved
                             0, // Options
                             "Source 1",
                             SACN->CID
                             );
        }
    }
    
    Result.NewUniverseBuffer = UniverseBufferHeader;
    Result.NewSendBuffer= SendBufferHeader;
    return Result;
}

internal void
SACNRemoveUniverseAndSendBuffer(streaming_acn* SACN, sacn_universe_buffer* Universes, sacn_send_buffer* SendBuffer)
{
    SACN->UniverseBuffer = SACNRemoveUniverseBufferFromList(SACN->UniverseBuffer, Universes);
    SACN->SendBuffer = SACNRemoveSendBufferFromList(SACN->SendBuffer, SendBuffer);
}

internal streaming_acn
InitializeSACN (platform_alloc* PlatformAlloc, context Context)
{
    streaming_acn SACN = {};
    
    InitMemoryArena(&SACN.Memory, 0, 0, PlatformAlloc);
    
    SACN.SendSocket = Context.PlatformGetSocketHandle(AF_INET, SOCK_DGRAM, 0);
    int Multicast_TimeToLive = 20;
    int Error = Context.PlatformSetSocketOption(SACN.SendSocket, IPPROTO_IP, IP_MULTICAST_TTL, 
                                                (const char*)(&Multicast_TimeToLive), sizeof(Multicast_TimeToLive));
    SACN.CID = StringToCID_ ("{67F9D986-544E-4abb-8986-D5F79382586C}");
    
    SACN.UniverseBuffer = 0;
    SACN.SendBuffer = 0;
    
    return SACN;
}

internal void
SACNSendDataToUniverse (streaming_acn* SACN, sacn_universe* Universe, platform_send_to* PlatformSendTo)
{
    //DEBUG_TRACK_FUNCTION;
    
    u8* StartPositionInSendBuffer = (u8*)Universe->StartPositionInSendBuffer;
    SetStreamHeaderSequence_(StartPositionInSendBuffer, SACN->SequenceIterator, false);
    
    PlatformSendTo(SACN->SendSocket, Universe->SendAddress, (const char*)StartPositionInSendBuffer, Universe->SizeInSendBuffer, 0);
#if 0 // Old Network Code
    // TODO(Peter): HUGE NOTE!!!!!!!!
    // This needs to be put on a separate thread. The sendto call is really slowing us down.
    s32 LengthSent = sendto(SACN->SendSocket, (const char*)StartPositionInSendBuffer, Universe->SizeInSendBuffer, 
                            0, (sockaddr*)(&Universe->SendAddress), sizeof(sockaddr_in));
    
    if (LengthSent == SOCKET_ERROR)
    {
        s32 LastSocketError = WSAGetLastError();
        InvalidCodePath;
    }
#endif
}

internal void
SACNCleanup(streaming_acn* SACN, context Context)
{
    Context.PlatformCloseSocket(SACN->SendSocket);
}


///////////////////////////////////////////////
//
//         SACN Data Header Functions
//
///////////////////////////////////////////////

internal void
InitStreamHeader (u8* Buffer, s32 BufferSize, 
                  u16 SlotCount,
                  u8 StartCode,
                  u16 Universe,
                  u8 Priority,
                  u16 Reserved,
                  u8 Options,
                  const char* SourceName,
                  cid CID
                  )
{
    
    u8* Cursor = Buffer;
    
    // Preamble Size
    Cursor = PackB2(Cursor, RLP_PREAMBLE_SIZE);
    Cursor = PackB2(Cursor, RLP_POSTAMBLE_SIZE);
    
    memcpy(Cursor, ACN_IDENTIFIER, ACN_IDENTIFIER_SIZE);
    Cursor += ACN_IDENTIFIER_SIZE;
    
    // TODO(Peter): If you never use this anywhere else, go back and remove the parameters
    VHD_PackFlags_(Cursor, false, false, false);
    Cursor = VHD_PackLength_(Cursor, 
                             STREAM_HEADER_SIZE - RLP_PREAMBLE_SIZE + SlotCount, 
                             false);
    
    // root vector
    Cursor = PackB4(Cursor, ROOT_VECTOR);
    
    // CID Pack
    for (s32 i = 0; i < CID_Bytes; i++)
    {
        *Cursor++ = CID.Bytes[i];
    }
    
    VHD_PackFlags_(Cursor, false, false, false);
    Cursor = VHD_PackLength_(Cursor, 
                             STREAM_HEADER_SIZE - FRAMING_FLAGS_AND_LENGTH_ADDR + SlotCount, 
                             false);
    
    // framing vector
    Cursor = PackB4(Cursor, FRAMING_VECTOR);
    
    // framing source name
    strncpy((char*)Cursor, SourceName, SOURCE_NAME_SIZE);
    Cursor[SOURCE_NAME_SIZE - 1] = '\0';
    Cursor += SOURCE_NAME_SIZE;
    
    // priority
    Cursor = PackB1(Cursor, Priority);
    
    // reserved
    Cursor = PackB2(Cursor, Reserved);
    
    // Sequence # is always set to 0/NONE at the beginning, but it is incremented when sending data
    Cursor = PackB1(Cursor, 0);
    
    // Options
    Cursor = PackB1(Cursor, Options);
    
    // Universe
    Cursor = PackB2(Cursor, Universe);
    
    VHD_PackFlags_(Cursor, false, false, false);
    Cursor = VHD_PackLength_(Cursor, 
                             STREAM_HEADER_SIZE - DMP_FLAGS_AND_LENGTH_ADDR + SlotCount,
                             false);
    
    // DMP Vector
    Cursor = PackB1(Cursor, DMP_VECTOR);
    
    // DMP Address and data type
    Cursor = PackB1(Cursor, ADDRESS_AND_DATA_FORMAT);
    
    // DMP first property address
    Cursor = PackB2(Cursor, 0);
    
    // DMP Address Increment
    Cursor = PackB2(Cursor, ADDRESS_INC);
    
    // Property Value Count -- Includes one byte for start code
    Cursor = PackB2(Cursor, SlotCount + 1);
    
    Cursor = PackB1(Cursor, StartCode);
    
    s32 DiffSize = Cursor - Buffer;
    if (Cursor - Buffer != STREAM_HEADER_SIZE)
    {
        InvalidCodePath;
    }
}

internal void
SetStreamHeaderSequence_ (u8* Buffer, u8 Sequence, b32 Draft)
{
    DEBUG_TRACK_FUNCTION;
    PackB1(Buffer + SEQ_NUM_ADDR, Sequence);
}

internal void
VHD_PackFlags_(u8* Buffer, b32 InheritVec, b32 InheritHead, b32 InheritData)
{
    u8* Cursor = Buffer;
    u8 NewByte = UpackB1(Cursor) & 0x8f;
    
    if (!InheritVec) { NewByte |= VHD_V_FLAG; }
    if (!InheritHead) { NewByte |= VHD_H_FLAG; }
    if (!InheritData) { NewByte |= VHD_D_FLAG; }
    
    PackB1(Cursor, NewByte);
}

internal u8*
VHD_PackLength_(u8* Buffer, u32 Length, b32 IncludeLength)
{
    u8* Cursor = Buffer;
    u32 AdjustedLength = Length;
    if (IncludeLength)
    {
        if (Length + 1 > VHD_MAXMINLENGTH)
        {
            AdjustedLength += 2;
        }
        else
        {
            AdjustedLength += 1;
        }
    }
    
    // Mask out the length bits to keep flags intact
    u8 NewByte = UpackB1(Cursor) & 0x70;
    if (AdjustedLength > VHD_MAXMINLENGTH)
    {
        NewByte |= VHD_L_FLAG;
    }
    
    u8 PackBuffer[4];
    PackB4(PackBuffer, AdjustedLength);
    if (AdjustedLength <= VHD_MAXMINLENGTH)
    {
        NewByte |= (PackBuffer[2] & 0x0f);
        Cursor = PackB1(Cursor, NewByte);
        Cursor = PackB1(Cursor, PackBuffer[3]);
    }
    else
    {
        NewByte |= (PackBuffer[1] & 0x0f);
        Cursor = PackB1(Cursor, PackBuffer[2]);
        Cursor = PackB1(Cursor, PackBuffer[3]);
    }
    
    return Cursor;
}

internal cid 
StringToCID_ (const char* String)
{
    cid Result = {};
    
    const char* Src = String;
    u8* Dest = &Result.Bytes[0];
    b32 FirstNibble = true;
    
    while(*Src && (Dest - &Result.Bytes[0] < CID_Bytes))
    {
        u8 Offset = 0;
        if ((*Src >= 0x30) && (*Src <= 0x39)){ Offset = 0x30; }
        else if ((*Src >= 0x41) && (*Src <= 0x46)) { Offset = 0x37; }
        else if ((*Src >= 0x61) && (*Src <= 0x66)) { Offset = 0x66; }
        
        if (Offset != 0)
        {
            if (FirstNibble)
            {
                *Dest = (u8)(*Src - Offset);
                *Dest <<= 4;
                FirstNibble = false;
            }
            else
            {
                *Dest |= (*Src - Offset);
                Dest++;
                FirstNibble = true;
            }
        }
        Src++;
    }
    
    return Result; 
}