Packet Byte[0] = PACKET_HEADER_BYTE :
Bit 7 = PACKET_HEADER_FLAG : Always SET (0b1, or bitmask 0x80 in the C sourcecode)
Bits 6..5 in the header byte determines the basic packet type (PACKET_HEADER_TYPE):
  0b00 : PACKET_HDR_TYPE_AUDIO.
         This packet contains a "short" audio sample point, with the structure 
         specified in an extra packet (PACKET_CONTENT_TYPE_AUDIO_SAMPLE_FORMAT,
         optional but recommended if the microcontroller firmware permits).
  0b01 : PACKET_HDR_TYPE_OTHER.
         This packet contains something that is specified by an extra byte of the packet 
         (example later, see PACKET_CONTENT_TYPE).
  0b10 : PACKET_HDR_TYPE_ASCII.
         This packet contains an ASCII STRING, with seven bits per character, easily parsed (example later).
  0b11 : PACKET_HDR_TYPE_RESERVED.
         Reserved for future use (packet flow control, CRC-protected payload, etc).
         Also for this header type, the packet content type is specified
         in an extra byte.
 
Bits 4..0 = SHORT_PAYLOAD_LENGTH : Determines the number bytes that follow
                                  in the payload. The header byte itself,
                                  as well as the 'optional header bytes'
                                  listed in the next chapter,
                                  are not counted (included) in this bitfield.
       SHORT_PAYLOAD_LENGTH = 1...30 indicate "the number of bytes that follow,
                                              with SEVEN usable bits each".
       SHORT_PAYLOAD_LENGTH = 0 : Length of the payload not indicated. Just keep reading
                                  until an end-of-string marker (0x00 in PACKET_HDR_TYPE_ASCII),
                                  or until the next packet header byte arrives. (*)
       SHORT_PAYLOAD_LENGTH = 31: Larger packet, 
                                  with the actual packet length following in 
                                  the next two bytes, directly after the 
                                  PACKET_HEADER_BYTE . 
                                  See next chapter, LONG_PAYLOAD_LENGTH.

  -Packet Byte [0]- -Packet Byte [1]- -Packet Byte [2]- -Packet Byte [3]- -Packet Byte [4]- ... -Packet Byte [259]-
  [7 6 5 4 3 2 1 0] [7 6 5 4 3 2 1 0] [7 6 5 4 3 2 1 0] [7 6 5 4 3 2 1 0] [7 6 5 4 3 2 1 0]     [7 6 5 4 3 2 1 0]
   : : : : : : : :   : : : : : : : :   : : : : : : : :   : : : : : : : :   : : : : : : : :       : : : : : : : :  
   1 0 1 1 1 1 1 1   0 1 1 1 1 1 1 1   0 0 0 0 0 0 0 1   0 ? ? ? ? ? ? ?   0 x x x x x x x       0 x x x x x x x
   | |_| |_______|     |___________|     |___________|     |___________|     |___________|         |___________|
   |  |      |                  |                  |            |             user payload  ...     user payload
   |  |  SHORT_PAYLOAD_LENGTH    |                  |   PACKET_CONTENT_TYPE,   |________________________________|
   |  |  = 31: "Long packet"  LONG_PAYLOAD_LENGTH,  |    | not counted in the     255 * 7 bits of 'user payload'
   |  PACKET_HDR_TYPE_OTHER   lower seven bits     |    | LONG_PAYLOAD_LENGTH",
 PACKET_HEADER_FLAG                LONG_PAYLOAD_LENGTH,  | presence indicated by PACKET_HDR_TYPE_OTHER' !
  |______________|                 upper seven bits.    '-----------------------------------------------    
  PACKET_HEADER_BYTE            0b0000001 1111111 = 0x00FF = 255 'frames' with SEVEN bits of payload per 'frame'
                       |_____________________________|
                        presence of this field (LONG_PAYLOAD_LENGTH)
                        indicated by SHORT_PAYLOAD_LENGTH=31 .

 Example for the "Bit layout" in the payload (best viewed as preformatted text with a monospaced font):

  -Packet Byte [1]- -Packet Byte [2]- -Packet Byte [3]- -Packet Byte [4]- -Packet Byte [5]- -Packet Byte [6]- -Packet Byte [7]-
  [7 6 5 4 3 2 1 0] [7 6 5 4 3 2 1 0] [7 6 5 4 3 2 1 0] [7 6 5 4 3 2 1 0] [7 6 5 4 3 2 1 0] [7 6 5 4 3 2 1 0] [7 6 5 4 3 2 1 0]
   0(bit 7 cleared)  0 : : : : : : :   0 : : : : : : :   0 : : : : : : :   0 : : : : : : :   0 : : : : : : :   0 : : : : : : :
     : : : : : : :     : : : : : : :     : : : : : : :     : : : : : : :     : : : : : : :     : : : : : : :     : : : : : : : 
Bit numbers in channels 'A' and 'B':     : : : : : : :     : : : : : : :     : : : : : : :     : : : : : : :     : : : : : : :
     : : : : : : :     : : : : : : :     : : : : : : :     : : : : : : :     : : : : : : :     : : : : : : :     : : : : : : :  
     A A A A A A A     A A A A A A A     A A A A A A A     B B B B A A A     B B B B B B B     B B B B B B B     - B B B B B B 
     0 0 0 0 0 0 0     1 1 1 1 0 0 0     2 1 1 1 1 1 1     0 0 0 0 2 2 2     1 0 0 0 0 0 0     1 1 1 1 1 1 1     - 2 2 2 2 1 1
     6 5 4 3 2 1 0     3 2 1 0 9 8 7     0 9 8 7 6 5 4     3 2 1 0 3 2 1     0 9 8 7 6 5 4     7 6 5 4 3 2 1     - 3 2 1 0 9 8
     |<------------------ Channel A -----------------|     |Ch B | |Ch A|     |<-------- Channel B ------------- ^ --------->|
                                                                                                                /|\
   ^                 ^                 ^                 ^                   One unused ("remaining") bit HERE --'
  /|\               /|\               /|\               /|\                ^                 ^                 ^
   |                 |                 |                 |                /|\               /|\               /|\
 ,-'-----------------'-----------------'-----------------'-----------------'-----------------'-----------------'
 '-- Bit seven in each 'payload frame' cleared to tell them from the packet header byte (not shown here)

 The same "Bit layout" in the payload as shown above, but bits in a byte shown in reversed order:

  -Packet Byte [1]- -Packet Byte [2]- -Packet Byte [3]- -Packet Byte [4]- -Packet Byte [5]- -Packet Byte [6]- -Packet Byte [7]-
  [0 1 2 3 4 5 6 7] [0 1 2 3 4 5 6 7] [0 1 2 3 4 5 6 7] [0 1 2 3 4 5 6 7] [0 1 2 3 4 5 6 7] [0 1 2 3 4 5 6 7] [0 1 2 3 4 5 6 7]
   : : : : : : : 0(bit 7 cleared)  0   : : : : : : : 0   : : : : : : : 0   : : : : : : : 0   : : : : : : : 0   : : : : : : : 0
Bit numbers in channels 'A' and 'B'    : : : : : : :     : : : : : : :     : : : : : : :     : : : : : : :     : : : : : : :/|\
   : : : : : : :     : : : : : : :     : : : : : : :     : : : : : : :     : : : : : : :     : : : : : : :     : : : : : : : |
   A A A A A A A     A A A A A A A     A A A A A A A     A A A B B B B     B B B B B B B     B B B B B B B     B B B B B B - |
   0 0 0 0 0 0 0     0 0 0 1 1 1 1     1 1 1 1 1 1 2     2 2 2 0 0 0 0     0 0 0 0 0 0 0     1 1 1 1 1 1 1     1 1 2 2 2 2 - |
   0 1 2 3 4 5 6     7 8 9 0 1 2 3     4 5 6 7 8 9 0     1 2 3 0 1 2 3     4 5 6 7 8 9 0     1 2 3 4 5 6 7     8 9 0 1 2 3 - |
   |<------------------ Channel A -------------------------->| |<------------------- Channel B ------------------------->| ^ |
                 ^                 ^                 ^                 ^                                                  /|\|
                /|\               /|\               /|\               /|\             One unused ("remaining") bit HERE ---' |
   ,-------------'-----------------'-----------------'-----------------'-----------------------------------------------------'
   '-- Bit seven in each 'payload frame' cleared to tell them from the packet header byte (not shown here)

Byte[0] = PACKET_HEADER_BYTE : 0b1 01 0**** (PACKET_HEADER_FLAG, PACKET_HDR_TYPE_OTHER, SHORT_PAYLOAD_LENGTH=2 to 9)
Byte[1] = PACKET_CONTENT_TYPE : 0x01 = PACKET_CONTENT_TYPE_AUDIO_SAMPLE_FORMAT
          (again, since the presence of this 'optional header byte'
           is indicated in the packet header byte itself, it's not
           counted as part of the 'payload'. Instead, it belongs to the header,
           which in this case consists of Byte[0] and Byte [1] .
           Here, the variable-sized payload begins with the next byte,
           because this packet only needs a SHORT_PAYLOAD_LENGTH.)
Byte[2] : Number of bits per single sample, 1 .. 127, usually 1..32 (supported by Spectrum Lab)
Byte[3] : Number of channels per sample point, 1..127, usually 1..4 (supported by Spectrum Lab)
Byte[4] : Data type and endianness. 
            0 = Default. Signed integer and Little Endian. Highly recommended.
                Densely packed, with "bits 6..0 first", "bits 13..7 next", etc .
                In fact, the first reference implementation in Spectrum Lab
                didn't support anything else (no unsigned int, and no Big Endian).
            1 = Unsigned integer and Little Endian. For simple unipolar A/D converters.
            2 = Reserved for some BIG endian format (signed).
            3 = Reserved for another BIG endian format (unsigned).
            4 = IEEE-754 32-bit floating point ("single precision"), Little Endian as on Intel CPUs,
                each 32-bit value split into FIVE subsequent seven-bit slots with in the frame
                (to avoid too much bit-fiddling in the sender and receiver)
            Data types 5..127 reserved for "future use" / compressed sample / u-Law, etc.
Byte[5] : least significant SEVEN bits of the integer sampling rate
Byte[6] : Next SEVEN bits (bits 13..7) of the integer sampling rate
Byte[7] : Next SEVEN bits (bits 20..14) of the integer sampling rate (ok for up to ~ 1 MSample / second).
            If the sampling rate is omitted, Spectrum Lab will use whatever
            the user has entered in the Audio Settings tab.
Byte[8..10] : Reserved for a future 'fractional part', if the sampling rate isn't an integer.
Byte[11..?] : Reserved for future use. From the PACKET_LENGTH, the receiver knows if these bytes are sent.

Byte[0] = PACKET_HEADER_BYTE : 0b1 01 00*** (PACKET_HEADER_FLAG, PACKET_HDR_TYPE_OTHER, SHORT_PAYLOAD_LENGTH=3..6)
Byte[1] = PACKET_CONTENT_TYPE : 0x02 = PACKET_CONTENT_TYPE_TIME_OF_DAY
Byte[2] : Bits  6.. 0 of the integer part, mandatory (number of seconds in UTC)
Byte[3] : Bits 13.. 7 of the integer part, mandatory ..
Byte[4] : Bits 21..14 of the integer part, mandatory ...
Byte[5] : Bits  6.. 0 of the fractional part \ 
Byte[6] : Bits 13.. 7 of the fractional part |-- optional !
Byte[7] : Bits 21..14 of the fractional part /

AudioSampleFormat: BitsPerSample=24 Channels=4 SampRate=123456.789 UnixDate=2023-07-13_21:15:00.000
|________________| |______________________________________________________________________________|
Keyword/Label for    Audio-sample-specific Key=value pairs (all of them optional, in any sequence)
 the 'String Parser'

  (informal - this code fragment may be outdated. Use the Source ...) :

// Compiling Spectrum Lab or a microcontroller firmware ?
#ifndef SBP_COMPILING_SPECLAB // if not defined elsewhere, make a guess:
# ifdef __BORLANDC__  // obviously compiling Spectrum Lab, because the compiler is Borland C
#  define SBP_COMPILING_SPECLAB 1 // 1 : "Compiling for Spectrum Lab", 0 : no
# else   // not compiling Spectrum Lab, guess we're compiling a microcontroller firmware..
#  define SBP_COMPILING_SPECLAB 0 // 0 because we're definitely NOT compiling Spectrum Lab.
# endif // compiling with Borland C ?
#endif // ndef SBP_COMPILING_SPECLAB ?

#if( SBP_COMPILING_SPECLAB ) // "Compiling Spectrum Lab" ?
#  define SBP_BUILT_IN_UNIT_TESTS 1 // 1 : implement the Unit Tests,        0 : don't
#  define SBP_USE_FLOATING_POINT  1 // 1 : may use 'float' and 'double',    0 : don't
#  define SBP_SUPPORT_PACKET_TX   1 // 1 : support TRANSMISSION of packets, 0 : don't
#  define SBP_SUPPORT_PACKET_RX   1 // 1 : support RECEPTION  of packets,   0 : don't
#  define SBP_MAX_AUDIO_CHANNELS  4 // 4 channels PER SAMPLE POINT, only used for internal buffering
#  define SBP_USE_CALLBACK_FOR_RECEIVED_AUDIO 1 // 1 : use callbacks via FUNCTION POINTER,
                                                // 0 : use SBP_AppCB_ProcessReceivedAudio()
#else   // not compiling Spectrum Lab, so guess we're compiling a microcontroller firmware,
   // which "only" drives an ADC (or read samples from its on-chip analog inputs),
   // but doesn't drive a DAC, thus it only needs to SEND but not RECEIVE packets
   // (all these are just guesses, so modify the following, or move these defs
   //  into a separate, "project specific" include file) .
#  define SBP_BUILT_IN_UNIT_TESTS 0 // 0 : don't implement the Unit Tests (save precious ROM..)
#  define SBP_USE_FLOATING_POINT  0 // 0 : neither use 'float' nor 'double' ("too expensive")
#  define SBP_SUPPORT_PACKET_TX   1 // 1 : support TRANSMISSION of packets, 0 : don't
#  define SBP_SUPPORT_PACKET_RX   0 // 0 : support RECEPTION  of packets,   0 : don't
#  define SBP_MAX_AUDIO_CHANNELS  2 // set this to the number of ADC- or DAC channels supported
#  define SBP_USE_CALLBACK_FOR_RECEIVED_AUDIO 0 // 1 : use callbacks via FUNCTION POINTER,
                                                // 0 : use SBP_AppCB_ProcessReceivedAudio()
#endif // SBP_COMPILING_SPECLAB ?

//---------------------------------------------------------------------------
void SBP_WriteBitgroup( // Appends a 1- to 32-bit value to the packet buffer, "densely packed".
   T_SBP_Instance *pInst, // [out] pInst->pbDst (always points to the "first payload byte")
                      // [in,out] pInst->iWriteBitIndex (INCREMENTED here)
   uint32_t u32Value, // [in] signed or unsigned integer with anything from 1 to 32 bits .
                      //      Will occupy up to ceil(32/7) = FIVE bytes in pbDst[],
                      //      but the remaining "unused" bits in the last byte
                      //      will be filled in the NEXT call of this function .
   int iBitgroupSize) // [in] Number of bits REALLY USED in u32Value. Range: 1..32 [bits].
{
   int iBitIndex  = pInst->iWriteBitIndex; // "bit index" into a packet buffer", 0 .. 8*SBP_PACKET_BUFFER_SIZE - 1
   int iBitOfByte;
   int iByteIndex;  // the "byte index" (into pbDst[]) is the "bit index" / 8 (or bitwise shifted right 3 times)
   int nBitsInByte;
   BYTE b;

   while( ((iByteIndex=(iBitIndex>>3))<SBP_PACKET_BUFFER_SIZE) && (iBitgroupSize>0) ) // more bits to "emit" ?
    {
      // How many "new bits" can be moved into pbDst[iByteIndex] before that byte is 'full' ?
      iBitOfByte = iBitIndex & 7;   // -> 0..7, where 7 would be the PACKET_HEADER_FLAG ("taboo" here)
      nBitsInByte = 7 - iBitOfByte; // -> number of bits that can be moved into pbDst[iByteIndex]
      if( iBitOfByte==0 ) // beginning a 'new byte', no bit-wise OR required now, may emit up to SEVEN bits:
       { b = (BYTE)u32Value;
         nBitsInByte = (iBitgroupSize >= 7) ? 7 : iBitgroupSize; // -> 1..7 bits to emit in THIS loop
         b &= (0xFF >> (8-nBitsInByte) );  // for example, with nBitsInByte=7, bitwise-AND with 0x7F
       }
      else  // nBitsInByte != 0 -> not a 'new byte', so read back some already-set-bits from the packet buffer:
       { b = pInst->pbDst[iByteIndex]; // <- already contains <iBitOfByte> bits that MUST NOT BE MODIFIED below.
         if( nBitsInByte > iBitgroupSize )
          {  nBitsInByte = iBitgroupSize;   // cannot emit more than what's left in u32Value !
          }
         // The bits already in 'b' must not be shifted but kept 'in place'.
         // Only <nBitsInByte> from u32Value must be shifted LEFT,
         //                    before bitwise ORing them into the 8-bit 'b'.
         b |= ( ( (BYTE)u32Value & (0xFF >> (8-nBitsInByte) ) ) << iBitOfByte );
         //       |_____________|  |________________________|   |_____________|
         //        next 1..7 (?)    isolate 7..1                 e.g. bitwise shift
         //        "new" bits       "new bits",                  LEFT 3 times,
         //      from the source    e.g bitwise AND              because iBitOfByte=3 [bits]
         //                         with 0x0F if only            were alreay in 'b'
         //                         4 bits are emitted
         //                         in this loop.
         //   |________________________________________________________________|
         //     After this bit-fiddling ("new" and "old" bits in byte 'b'),
         //     the maximum value in b cannot exceed 0x7F = 0b01111111 .
       }
      pInst->pbDst[iByteIndex] = b;  // write the 'new' byte, or write back the 'modified' byte
      iBitgroupSize -= nBitsInByte;  // decrement the REMAINING number of bits by 1..7 (not 8)
      u32Value >>= nBitsInByte;      // shift the next bits in place, for the next loop
      iBitIndex += nBitsInByte;      // increment the BIT INDEX into the packet buffer ...
      // If iBitIndex just reached bit SEVEN in a byte of the payload,
      // increment it by one more step (bit) to skip that bit:
      if( (iBitIndex & 7) == 7 )
       { ++iBitIndex; // skip bit SEVEN ( avoid PACKET_HEADER_FLAG occurring in the payload)
       }
    } // end while < more bits or bitgroups to "emit" into the packet buffer >

  pInst->iWriteBitIndex = iBitIndex; // write back the INCREMENTED packet-buffer-bit-index
} // end SBP_WriteBitgroup()