sbgStreamBufferLE.h
Go to the documentation of this file.
1 
21 #ifndef __SBG_STREAM_BUFFER_LE_H__
22 #define __SBG_STREAM_BUFFER_LE_H__
23 
24 #include "sbgStreamBufferCommon.h"
25 
26 //----------------------------------------------------------------------//
27 //- Read operations methods -//
28 //----------------------------------------------------------------------//
29 
35 SBG_INLINE int16 sbgStreamBufferReadInt16LE(SbgStreamBuffer *pHandle)
36 {
37  int16 bytesValues[2];
38 
39  //
40  // Check input parameters
41  //
42  SBG_ASSERT(pHandle);
43 
44  //
45  // Test if we haven't already an error
46  //
47  if (pHandle->errorCode == SBG_NO_ERROR)
48  {
49  //
50  // Test if we can access this item
51  //
52  if (sbgStreamBufferGetSpace(pHandle) >= sizeof(int16))
53  {
54  //
55  // Test if the platform supports un-aligned access and if the endianness is the same
56  //
57  #if (SBG_CONFIG_UNALIGNED_ACCESS_AUTH == 1) && (SBG_CONFIG_BIG_ENDIAN == 0)
58  //
59  // Read the current value
60  //
61  bytesValues[0] = *((int16*)pHandle->pCurrentPtr);
62 
63  //
64  // Increment the current pointer
65  //
66  pHandle->pCurrentPtr += sizeof(int16);
67 
68  return bytesValues[0];
69  #else
70  //
71  // Read the each bytes
72  //
73  bytesValues[0] = *(pHandle->pCurrentPtr++);
74  bytesValues[1] = *(pHandle->pCurrentPtr++);
75 
76  //
77  // Store data according to platform endianness
78  //
79  #if (SBG_CONFIG_BIG_ENDIAN == 1)
80  return bytesValues[1] | (bytesValues[0] << 8);
81  #else
82  return bytesValues[0] | (bytesValues[1] << 8);
83  #endif
84  #endif
85  }
86  else
87  {
88  //
89  // We have a buffer overflow so return 0
90  //
91  pHandle->errorCode = SBG_BUFFER_OVERFLOW;
92  }
93  }
94 
95  //
96  // If we are here, it means we have an error so return 0
97  //
98  return 0;
99 }
100 
106 SBG_INLINE uint16 sbgStreamBufferReadUint16LE(SbgStreamBuffer *pHandle)
107 {
108  uint16 bytesValues[2];
109 
110  //
111  // Check input parameters
112  //
113  SBG_ASSERT(pHandle);
114 
115  //
116  // Test if we haven't already an error
117  //
118  if (pHandle->errorCode == SBG_NO_ERROR)
119  {
120  //
121  // Test if we can access this item
122  //
123  if (sbgStreamBufferGetSpace(pHandle) >= sizeof(uint16))
124  {
125  //
126  // Test if the platform supports un-aligned access and if the endianness is the same
127  //
128  #if (SBG_CONFIG_UNALIGNED_ACCESS_AUTH == 1) && (SBG_CONFIG_BIG_ENDIAN == 0)
129  //
130  // Read the current value
131  //
132  bytesValues[0] = *((uint16*)pHandle->pCurrentPtr);
133 
134  //
135  // Increment the current pointer
136  //
137  pHandle->pCurrentPtr += sizeof(uint16);
138 
139  return bytesValues[0];
140  #else
141  //
142  // Read the each bytes
143  //
144  bytesValues[0] = *(pHandle->pCurrentPtr++);
145  bytesValues[1] = *(pHandle->pCurrentPtr++);
146 
147  //
148  // Store data according to platform endianness
149  //
150  #if (SBG_CONFIG_BIG_ENDIAN == 1)
151  return bytesValues[1] | (bytesValues[0] << 8);
152  #else
153  return bytesValues[0] | (bytesValues[1] << 8);
154  #endif
155  #endif
156  }
157  else
158  {
159  //
160  // We have a buffer overflow so return 0
161  //
162  pHandle->errorCode = SBG_BUFFER_OVERFLOW;
163  }
164  }
165 
166  //
167  // If we are here, it means we have an error so return 0
168  //
169  return 0;
170 }
171 
177 SBG_INLINE int32 sbgStreamBufferReadInt24LE(SbgStreamBuffer *pHandle)
178 {
179  int32 bytesValues[3];
180 
181  //
182  // Check input parameters
183  //
184  SBG_ASSERT(pHandle);
185 
186  //
187  // Test if we haven't already an error
188  //
189  if (pHandle->errorCode == SBG_NO_ERROR)
190  {
191  //
192  // Test if we can access this item
193  //
194  if (sbgStreamBufferGetSpace(pHandle) >= 3*sizeof(int8))
195  {
196  //
197  // Read the each bytes
198  //
199  bytesValues[0] = *(pHandle->pCurrentPtr++);
200  bytesValues[1] = *(pHandle->pCurrentPtr++);
201  bytesValues[2] = *(pHandle->pCurrentPtr++);
202 
203  //
204  // Store data according to platform endianness
205  //
206  #if (SBG_CONFIG_BIG_ENDIAN == 1)
207  return bytesValues[2] | (bytesValues[1] << 8) | (bytesValues[0] << 16);
208  #else
209  return bytesValues[0] | (bytesValues[1] << 8) | (bytesValues[2] << 16);
210  #endif
211  }
212  else
213  {
214  //
215  // We have a buffer overflow so return 0
216  //
217  pHandle->errorCode = SBG_BUFFER_OVERFLOW;
218  }
219  }
220 
221  //
222  // If we are here, it means we have an error so return 0
223  //
224  return 0;
225 }
226 
232 SBG_INLINE uint32 sbgStreamBufferReadUint24LE(SbgStreamBuffer *pHandle)
233 {
234  uint32 bytesValues[3];
235 
236  //
237  // Check input parameters
238  //
239  SBG_ASSERT(pHandle);
240 
241  //
242  // Test if we haven't already an error
243  //
244  if (pHandle->errorCode == SBG_NO_ERROR)
245  {
246  //
247  // Test if we can access this item
248  //
249  if (sbgStreamBufferGetSpace(pHandle) >= 3*sizeof(uint8))
250  {
251  //
252  // Read the each bytes
253  //
254  bytesValues[0] = *(pHandle->pCurrentPtr++);
255  bytesValues[1] = *(pHandle->pCurrentPtr++);
256  bytesValues[2] = *(pHandle->pCurrentPtr++);
257 
258  //
259  // Store data according to platform endianness
260  //
261  #if (SBG_CONFIG_BIG_ENDIAN == 1)
262  return bytesValues[2] | (bytesValues[1] << 8) | (bytesValues[0] << 16);
263  #else
264  return bytesValues[0] | (bytesValues[1] << 8) | (bytesValues[2] << 16);
265  #endif
266  }
267  else
268  {
269  //
270  // We have a buffer overflow so return 0
271  //
272  pHandle->errorCode = SBG_BUFFER_OVERFLOW;
273  }
274  }
275 
276  //
277  // If we are here, it means we have an error so return 0
278  //
279  return 0;
280 }
281 
287 SBG_INLINE int32 sbgStreamBufferReadInt32LE(SbgStreamBuffer *pHandle)
288 {
289  int32 bytesValues[4];
290 
291  //
292  // Check input parameters
293  //
294  SBG_ASSERT(pHandle);
295 
296  //
297  // Test if we haven't already an error
298  //
299  if (pHandle->errorCode == SBG_NO_ERROR)
300  {
301  //
302  // Test if we can access this item
303  //
304  if (sbgStreamBufferGetSpace(pHandle) >= sizeof(int32))
305  {
306  //
307  // Test if the platform supports un-aligned access and if the endianness is the same
308  //
309  #if (SBG_CONFIG_UNALIGNED_ACCESS_AUTH == 1) && (SBG_CONFIG_BIG_ENDIAN == 0)
310  //
311  // Read the current value
312  //
313  bytesValues[0] = *((int32*)pHandle->pCurrentPtr);
314 
315  //
316  // Increment the current pointer
317  //
318  pHandle->pCurrentPtr += sizeof(int32);
319 
320  return bytesValues[0];
321  #else
322  //
323  // Read the each bytes
324  //
325  bytesValues[0] = *(pHandle->pCurrentPtr++);
326  bytesValues[1] = *(pHandle->pCurrentPtr++);
327  bytesValues[2] = *(pHandle->pCurrentPtr++);
328  bytesValues[3] = *(pHandle->pCurrentPtr++);
329 
330  //
331  // Store data according to platform endianness
332  //
333  #if (SBG_CONFIG_BIG_ENDIAN == 1)
334  return bytesValues[3] | (bytesValues[2] << 8) | (bytesValues[1] << 16) | (bytesValues[0] << 24);
335  #else
336  return bytesValues[0] | (bytesValues[1] << 8) | (bytesValues[2] << 16) | (bytesValues[3] << 24);
337  #endif
338  #endif
339  }
340  else
341  {
342  //
343  // We have a buffer overflow so return 0
344  //
345  pHandle->errorCode = SBG_BUFFER_OVERFLOW;
346  }
347  }
348 
349  //
350  // If we are here, it means we have an error so return 0
351  //
352  return 0;
353 }
354 
360 SBG_INLINE uint32 sbgStreamBufferReadUint32LE(SbgStreamBuffer *pHandle)
361 {
362  uint32 bytesValues[4];
363 
364  //
365  // Check input parameters
366  //
367  SBG_ASSERT(pHandle);
368 
369  //
370  // Test if we haven't already an error
371  //
372  if (pHandle->errorCode == SBG_NO_ERROR)
373  {
374  //
375  // Test if we can access this item
376  //
377  if (sbgStreamBufferGetSpace(pHandle) >= sizeof(uint32))
378  {
379  //
380  // Test if the platform supports un-aligned access and if the endianness is the same
381  //
382  #if (SBG_CONFIG_UNALIGNED_ACCESS_AUTH == 1) && (SBG_CONFIG_BIG_ENDIAN == 0)
383  //
384  // Read the current value
385  //
386  bytesValues[0] = *((uint32*)pHandle->pCurrentPtr);
387 
388  //
389  // Increment the current pointer
390  //
391  pHandle->pCurrentPtr += sizeof(uint32);
392 
393  return bytesValues[0];
394  #else
395  //
396  // Read the each bytes
397  //
398  bytesValues[0] = *(pHandle->pCurrentPtr++);
399  bytesValues[1] = *(pHandle->pCurrentPtr++);
400  bytesValues[2] = *(pHandle->pCurrentPtr++);
401  bytesValues[3] = *(pHandle->pCurrentPtr++);
402 
403  //
404  // Store data according to platform endianness
405  //
406  #if (SBG_CONFIG_BIG_ENDIAN == 1)
407  return bytesValues[3] | (bytesValues[2] << 8) | (bytesValues[1] << 16) | (bytesValues[0] << 24);
408  #else
409  return bytesValues[0] | (bytesValues[1] << 8) | (bytesValues[2] << 16) | (bytesValues[3] << 24);
410  #endif
411  #endif
412  }
413  else
414  {
415  //
416  // We have a buffer overflow so return 0
417  //
418  pHandle->errorCode = SBG_BUFFER_OVERFLOW;
419  }
420  }
421 
422  //
423  // If we are here, it means we have an error so return 0
424  //
425  return 0;
426 }
427 
433 SBG_INLINE int64 sbgStreamBufferReadInt64LE(SbgStreamBuffer *pHandle)
434 {
435  int64 lowPart;
436  int64 highPart;
437 
438  //
439  // Check input parameters
440  //
441  SBG_ASSERT(pHandle);
442 
443  //
444  // Test if we haven't already an error
445  //
446  if (pHandle->errorCode == SBG_NO_ERROR)
447  {
448  //
449  // Test if we can access this item
450  //
451  if (sbgStreamBufferGetSpace(pHandle) >= sizeof(int64))
452  {
453  //
454  // Test if the platform supports un-aligned access and if the endianness is the same
455  //
456  #if (SBG_CONFIG_UNALIGNED_ACCESS_AUTH == 1) && (SBG_CONFIG_BIG_ENDIAN == 0)
457  //
458  // Read the current value
459  //
460  lowPart = *((int64*)pHandle->pCurrentPtr);
461 
462  //
463  // Increment the current pointer
464  //
465  pHandle->pCurrentPtr += sizeof(int64);
466 
467  return lowPart;
468  #else
469  //
470  // Read 64 bit value using two 32 bits read to avoid too much 64 bits operations
471  //
472  lowPart = sbgStreamBufferReadUint32LE(pHandle);
473  highPart = sbgStreamBufferReadUint32LE(pHandle);
474 
475  //
476  // Store data according to platform endianness
477  //
478  #if (SBG_CONFIG_BIG_ENDIAN == 1)
479  return (lowPart << 32) | highPart;
480  #else
481  return lowPart | (highPart << 32);
482  #endif
483  #endif
484  }
485  else
486  {
487  //
488  // We have a buffer overflow so return 0
489  //
490  pHandle->errorCode = SBG_BUFFER_OVERFLOW;
491  }
492  }
493 
494  //
495  // If we are here, it means we have an error so return 0
496  //
497  return 0ll;
498 }
499 
505 SBG_INLINE uint64 sbgStreamBufferReadUint64LE(SbgStreamBuffer *pHandle)
506 {
507  uint64 lowPart;
508  uint64 highPart;
509 
510  //
511  // Check input parameters
512  //
513  SBG_ASSERT(pHandle);
514 
515  //
516  // Test if we haven't already an error
517  //
518  if (pHandle->errorCode == SBG_NO_ERROR)
519  {
520  //
521  // Test if we can access this item
522  //
523  if (sbgStreamBufferGetSpace(pHandle) >= sizeof(uint64))
524  {
525  //
526  // Test if the platform supports un-aligned access and if the endianness is the same
527  //
528  #if (SBG_CONFIG_UNALIGNED_ACCESS_AUTH == 1) && (SBG_CONFIG_BIG_ENDIAN == 0)
529  //
530  // Read the current value
531  //
532  lowPart = *((uint64*)pHandle->pCurrentPtr);
533 
534  //
535  // Increment the current pointer
536  //
537  pHandle->pCurrentPtr += sizeof(uint64);
538 
539  return lowPart;
540  #else
541  //
542  // Read 64 bit value using two 32 bits read to avoid too much 64 bits operations
543  //
544  lowPart = sbgStreamBufferReadUint32LE(pHandle);
545  highPart = sbgStreamBufferReadUint32LE(pHandle);
546 
547  //
548  // Store data according to platform endianness
549  //
550  #if (SBG_CONFIG_BIG_ENDIAN == 1)
551  return (lowPart << 32) | highPart;
552  #else
553  return lowPart | (highPart << 32);
554  #endif
555  #endif
556  }
557  else
558  {
559  //
560  // We have a buffer overflow so return 0
561  //
562  pHandle->errorCode = SBG_BUFFER_OVERFLOW;
563  }
564  }
565 
566  //
567  // If we are here, it means we have an error so return 0
568  //
569  return 0ull;
570 }
571 
577 SBG_INLINE size_t sbgStreamBufferReadSizeT32LE(SbgStreamBuffer *pHandle)
578 {
579  //
580  // Just call the read method for uint32
581  // We assume that a size_t is at least 32 bits on all platforms
582  //
583  return (size_t)sbgStreamBufferReadUint32LE(pHandle);
584 }
585 
591 SBG_INLINE size_t sbgStreamBufferReadSizeT64LE(SbgStreamBuffer *pHandle)
592 {
593  uint64 size;
594 
595  //
596  // Just call the read method for uint64
597  //
598  size = sbgStreamBufferReadUint64LE(pHandle);
599 
600  //
601  // Make sure the read size can fit in the size_t in size_t is 32 bits
602  //
603  SBG_ASSERT((sizeof(size_t) == 8) || ((sizeof(size_t) == 4) && (size <= SBG_MAX_UINT_32)));
604 
605  //
606  // Return the read value
607  //
608  return (size_t)size;
609 }
610 
616 SBG_INLINE float sbgStreamBufferReadFloatLE(SbgStreamBuffer *pHandle)
617 {
618  FloatNint floatInt;
619 
620  //
621  // Check input parameters
622  //
623  SBG_ASSERT(pHandle);
624 
625  //
626  // Test if we haven't already an error
627  //
628  if (pHandle->errorCode == SBG_NO_ERROR)
629  {
630  //
631  // Test if we can access this item
632  //
633  if (sbgStreamBufferGetSpace(pHandle) >= sizeof(float))
634  {
635  //
636  // Read the float as an uint32
637  //
638  floatInt.valU = sbgStreamBufferReadUint32LE(pHandle);
639 
640  //
641  // Return the float using an union to avoid compiller cast
642  //
643  return floatInt.valF;
644  }
645  else
646  {
647  //
648  // We have a buffer overflow so return 0
649  //
650  pHandle->errorCode = SBG_BUFFER_OVERFLOW;
651  }
652  }
653 
654  //
655  // If we are here, it means we have an error so return 0
656  //
657  return 0.0f;
658 }
659 
665 SBG_INLINE double sbgStreamBufferReadDoubleLE(SbgStreamBuffer *pHandle)
666 {
667  DoubleNint doubleInt;
668 
669  //
670  // Check input parameters
671  //
672  SBG_ASSERT(pHandle);
673 
674  //
675  // Test if we haven't already an error
676  //
677  if (pHandle->errorCode == SBG_NO_ERROR)
678  {
679  //
680  // Test if we can access this item
681  //
682  if (sbgStreamBufferGetSpace(pHandle) >= sizeof(double))
683  {
684  //
685  // Read the float as an uint64
686  //
687  doubleInt.valU = sbgStreamBufferReadUint64LE(pHandle);
688 
689  //
690  // Return the double using an union to avoid compiller cast
691  //
692  return doubleInt.valF;
693  }
694  else
695  {
696  //
697  // We have a buffer overflow so return 0
698  //
699  pHandle->errorCode = SBG_BUFFER_OVERFLOW;
700  }
701  }
702 
703  //
704  // If we are here, it means we have an error so return 0
705  //
706  return 0.0;
707 }
708 
709 //----------------------------------------------------------------------//
710 //- Write operations methods -//
711 //----------------------------------------------------------------------//
712 
719 SBG_INLINE SbgErrorCode sbgStreamBufferWriteInt16LE(SbgStreamBuffer *pHandle, int16 value)
720 {
721  //
722  // Check input parameters
723  //
724  SBG_ASSERT(pHandle);
725 
726  //
727  // Test if we haven't already an error
728  //
729  if (pHandle->errorCode == SBG_NO_ERROR)
730  {
731  //
732  // Test if we can access this item
733  //
734  if (sbgStreamBufferGetSpace(pHandle) >= sizeof(int16))
735  {
736  //
737  // Test if the platform supports un-aligned access and if the endianness is the same
738  //
739  #if (SBG_CONFIG_UNALIGNED_ACCESS_AUTH == 1) && (SBG_CONFIG_BIG_ENDIAN == 0)
740  //
741  // Write the value
742  //
743  *((int16*)(pHandle->pCurrentPtr)) = value;
744 
745  //
746  // Increment the current pointer
747  //
748  pHandle->pCurrentPtr += sizeof(int16);
749  #else
750  //
751  // Store data according to platform endianness
752  //
753  #if (SBG_CONFIG_BIG_ENDIAN == 1)
754  *(pHandle->pCurrentPtr++) = (uint8)(value >> 8);
755  *(pHandle->pCurrentPtr++) = (uint8)(value);
756  #else
757  *(pHandle->pCurrentPtr++) = (uint8)(value);
758  *(pHandle->pCurrentPtr++) = (uint8)(value >> 8);
759  #endif
760  #endif
761  }
762  else
763  {
764  //
765  // We are accessing a data that is outside the stream buffer
766  //
767  pHandle->errorCode = SBG_BUFFER_OVERFLOW;
768  }
769  }
770 
771  return pHandle->errorCode;
772 }
773 
780 SBG_INLINE SbgErrorCode sbgStreamBufferWriteUint16LE(SbgStreamBuffer *pHandle, uint16 value)
781 {
782  //
783  // Check input parameters
784  //
785  SBG_ASSERT(pHandle);
786 
787  //
788  // Test if we haven't already an error
789  //
790  if (pHandle->errorCode == SBG_NO_ERROR)
791  {
792  //
793  // Test if we can access this item
794  //
795  if (sbgStreamBufferGetSpace(pHandle) >= sizeof(uint16))
796  {
797  //
798  // Test if the platform supports un-aligned access and if the endianness is the same
799  //
800  #if (SBG_CONFIG_UNALIGNED_ACCESS_AUTH == 1) && (SBG_CONFIG_BIG_ENDIAN == 0)
801  //
802  // Write the value
803  //
804  *((uint16*)(pHandle->pCurrentPtr)) = value;
805 
806  //
807  // Increment the current pointer
808  //
809  pHandle->pCurrentPtr += sizeof(uint16);
810  #else
811  //
812  // Store data according to platform endianness
813  //
814  #if (SBG_CONFIG_BIG_ENDIAN == 1)
815  *(pHandle->pCurrentPtr++) = (uint8)(value >> 8);
816  *(pHandle->pCurrentPtr++) = (uint8)(value);
817  #else
818  *(pHandle->pCurrentPtr++) = (uint8)(value);
819  *(pHandle->pCurrentPtr++) = (uint8)(value >> 8);
820  #endif
821  #endif
822  }
823  else
824  {
825  //
826  // We are accessing a data that is outside the stream buffer
827  //
828  pHandle->errorCode = SBG_BUFFER_OVERFLOW;
829  }
830  }
831 
832  return pHandle->errorCode;
833 }
834 
835 
842 SBG_INLINE SbgErrorCode sbgStreamBufferWriteInt24LE(SbgStreamBuffer *pHandle, int32 value)
843 {
844  //
845  // Check input parameters
846  //
847  SBG_ASSERT(pHandle);
848 
849  //
850  // Test if we haven't already an error
851  //
852  if (pHandle->errorCode == SBG_NO_ERROR)
853  {
854  //
855  // Make sure that the value is within 24 bit bonds
856  //
857  if ( (value >= SBG_MIN_INT_24) && (value <= SBG_MAX_INT_24) )
858  {
859  //
860  // Test if we can access this item
861  //
862  if (sbgStreamBufferGetSpace(pHandle) >= 3*sizeof(int8))
863  {
864  //
865  // Store data according to platform endianness
866  //
867  #if (SBG_CONFIG_BIG_ENDIAN == 1)
868  *(pHandle->pCurrentPtr++) = (uint8)(value >> 16);
869  *(pHandle->pCurrentPtr++) = (uint8)(value >> 8);
870  *(pHandle->pCurrentPtr++) = (uint8)(value);
871  #else
872  *(pHandle->pCurrentPtr++) = (uint8)(value);
873  *(pHandle->pCurrentPtr++) = (uint8)(value >> 8);
874  *(pHandle->pCurrentPtr++) = (uint8)(value >> 16);
875  #endif
876  }
877  else
878  {
879  //
880  // We are accessing a data that is outside the stream buffer
881  //
882  pHandle->errorCode = SBG_BUFFER_OVERFLOW;
883  }
884  }
885  else
886  {
887  //
888  // The input value is not within a 24 bit integer bounds
889  //
890  pHandle->errorCode = SBG_INVALID_PARAMETER;
891  }
892  }
893 
894  return pHandle->errorCode;
895 }
896 
903 SBG_INLINE SbgErrorCode sbgStreamBufferWriteUint24LE(SbgStreamBuffer *pHandle, uint32 value)
904 {
905  //
906  // Check input parameters
907  //
908  SBG_ASSERT(pHandle);
909 
910  //
911  // Test if we haven't already an error
912  //
913  if (pHandle->errorCode == SBG_NO_ERROR)
914  {
915  //
916  // Make sure that the value is within 24 bit bonds
917  //
918  if (value <= SBG_MAX_UINT_24)
919  {
920  //
921  // Test if we can access this item
922  //
923  if (sbgStreamBufferGetSpace(pHandle) >= 3*sizeof(uint8))
924  {
925  //
926  // Store data according to platform endianness
927  //
928  #if (SBG_CONFIG_BIG_ENDIAN == 1)
929  *(pHandle->pCurrentPtr++) = (uint8)(value >> 16);
930  *(pHandle->pCurrentPtr++) = (uint8)(value >> 8);
931  *(pHandle->pCurrentPtr++) = (uint8)(value);
932  #else
933  *(pHandle->pCurrentPtr++) = (uint8)(value);
934  *(pHandle->pCurrentPtr++) = (uint8)(value >> 8);
935  *(pHandle->pCurrentPtr++) = (uint8)(value >> 16);
936  #endif
937  }
938  else
939  {
940  //
941  // We are accessing a data that is outside the stream buffer
942  //
943  pHandle->errorCode = SBG_BUFFER_OVERFLOW;
944  }
945  }
946  else
947  {
948  //
949  // The input value is not within a 24 bit integer bounds
950  //
951  pHandle->errorCode = SBG_INVALID_PARAMETER;
952  }
953  }
954 
955  return pHandle->errorCode;
956 }
957 
964 SBG_INLINE SbgErrorCode sbgStreamBufferWriteInt32LE(SbgStreamBuffer *pHandle, int32 value)
965 {
966  //
967  // Check input parameters
968  //
969  SBG_ASSERT(pHandle);
970 
971  //
972  // Test if we haven't already an error
973  //
974  if (pHandle->errorCode == SBG_NO_ERROR)
975  {
976  //
977  // Test if we can access this item
978  //
979  if (sbgStreamBufferGetSpace(pHandle) >= sizeof(int32))
980  {
981  //
982  // Test if the platform supports un-aligned access and if the endianness is the same
983  //
984  #if (SBG_CONFIG_UNALIGNED_ACCESS_AUTH == 1) && (SBG_CONFIG_BIG_ENDIAN == 0)
985  //
986  // Write the value
987  //
988  *((int32*)(pHandle->pCurrentPtr)) = value;
989 
990  //
991  // Increment the current pointer
992  //
993  pHandle->pCurrentPtr += sizeof(int32);
994  #else
995  //
996  // Store data according to platform endianness
997  //
998  #if (SBG_CONFIG_BIG_ENDIAN == 1)
999  *(pHandle->pCurrentPtr++) = (uint8)(value >> 24);
1000  *(pHandle->pCurrentPtr++) = (uint8)(value >> 16);
1001  *(pHandle->pCurrentPtr++) = (uint8)(value >> 8);
1002  *(pHandle->pCurrentPtr++) = (uint8)(value);
1003  #else
1004  *(pHandle->pCurrentPtr++) = (uint8)(value);
1005  *(pHandle->pCurrentPtr++) = (uint8)(value >> 8);
1006  *(pHandle->pCurrentPtr++) = (uint8)(value >> 16);
1007  *(pHandle->pCurrentPtr++) = (uint8)(value >> 24);
1008  #endif
1009  #endif
1010  }
1011  else
1012  {
1013  //
1014  // We are accessing a data that is outside the stream buffer
1015  //
1016  pHandle->errorCode = SBG_BUFFER_OVERFLOW;
1017  }
1018  }
1019 
1020  return pHandle->errorCode;
1021 }
1022 
1029 SBG_INLINE SbgErrorCode sbgStreamBufferWriteUint32LE(SbgStreamBuffer *pHandle, uint32 value)
1030 {
1031  //
1032  // Check input parameters
1033  //
1034  SBG_ASSERT(pHandle);
1035 
1036  //
1037  // Test if we haven't already an error
1038  //
1039  if (pHandle->errorCode == SBG_NO_ERROR)
1040  {
1041  //
1042  // Test if we can access this item
1043  //
1044  if (sbgStreamBufferGetSpace(pHandle) >= sizeof(uint32))
1045  {
1046  //
1047  // Test if the platform supports un-aligned access and if the endianness is the same
1048  //
1049  #if (SBG_CONFIG_UNALIGNED_ACCESS_AUTH == 1) && (SBG_CONFIG_BIG_ENDIAN == 0)
1050  //
1051  // Write the value
1052  //
1053  *((uint32*)(pHandle->pCurrentPtr)) = value;
1054 
1055  //
1056  // Increment the current pointer
1057  //
1058  pHandle->pCurrentPtr += sizeof(uint32);
1059  #else
1060  //
1061  // Store data according to platform endianness
1062  //
1063  #if (SBG_CONFIG_BIG_ENDIAN == 1)
1064  *(pHandle->pCurrentPtr++) = (uint8)(value >> 24);
1065  *(pHandle->pCurrentPtr++) = (uint8)(value >> 16);
1066  *(pHandle->pCurrentPtr++) = (uint8)(value >> 8);
1067  *(pHandle->pCurrentPtr++) = (uint8)(value);
1068  #else
1069  *(pHandle->pCurrentPtr++) = (uint8)(value);
1070  *(pHandle->pCurrentPtr++) = (uint8)(value >> 8);
1071  *(pHandle->pCurrentPtr++) = (uint8)(value >> 16);
1072  *(pHandle->pCurrentPtr++) = (uint8)(value >> 24);
1073  #endif
1074  #endif
1075  }
1076  else
1077  {
1078  //
1079  // We are accessing a data that is outside the stream buffer
1080  //
1081  pHandle->errorCode = SBG_BUFFER_OVERFLOW;
1082  }
1083  }
1084 
1085  return pHandle->errorCode;
1086 }
1087 
1094 SBG_INLINE SbgErrorCode sbgStreamBufferWriteInt64LE(SbgStreamBuffer *pHandle, int64 value)
1095 {
1096  //
1097  // Check input parameters
1098  //
1099  SBG_ASSERT(pHandle);
1100 
1101  //
1102  // Test if we haven't already an error
1103  //
1104  if (pHandle->errorCode == SBG_NO_ERROR)
1105  {
1106  //
1107  // Test if we can access this item
1108  //
1109  if (sbgStreamBufferGetSpace(pHandle) >= sizeof(int64))
1110  {
1111  //
1112  // Test if the platform supports un-aligned access and if the endianness is the same
1113  //
1114  #if (SBG_CONFIG_UNALIGNED_ACCESS_AUTH == 1) && (SBG_CONFIG_BIG_ENDIAN == 0)
1115  //
1116  // Write the value
1117  //
1118  *((int64*)(pHandle->pCurrentPtr)) = value;
1119 
1120  //
1121  // Increment the current pointer
1122  //
1123  pHandle->pCurrentPtr += sizeof(int64);
1124  #else
1125  //
1126  // Store data according to platform endianness
1127  //
1128  #if (SBG_CONFIG_BIG_ENDIAN == 1)
1129  *(pHandle->pCurrentPtr++) = (uint8)(value >> 56);
1130  *(pHandle->pCurrentPtr++) = (uint8)(value >> 48);
1131  *(pHandle->pCurrentPtr++) = (uint8)(value >> 40);
1132  *(pHandle->pCurrentPtr++) = (uint8)(value >> 32);
1133  *(pHandle->pCurrentPtr++) = (uint8)(value >> 24);
1134  *(pHandle->pCurrentPtr++) = (uint8)(value >> 16);
1135  *(pHandle->pCurrentPtr++) = (uint8)(value >> 8);
1136  *(pHandle->pCurrentPtr++) = (uint8)(value);
1137  #else
1138  *(pHandle->pCurrentPtr++) = (uint8)(value);
1139  *(pHandle->pCurrentPtr++) = (uint8)(value >> 8);
1140  *(pHandle->pCurrentPtr++) = (uint8)(value >> 16);
1141  *(pHandle->pCurrentPtr++) = (uint8)(value >> 24);
1142  *(pHandle->pCurrentPtr++) = (uint8)(value >> 32);
1143  *(pHandle->pCurrentPtr++) = (uint8)(value >> 40);
1144  *(pHandle->pCurrentPtr++) = (uint8)(value >> 48);
1145  *(pHandle->pCurrentPtr++) = (uint8)(value >> 56);
1146  #endif
1147  #endif
1148  }
1149  else
1150  {
1151  //
1152  // We are accessing a data that is outside the stream buffer
1153  //
1154  pHandle->errorCode = SBG_BUFFER_OVERFLOW;
1155  }
1156  }
1157 
1158  return pHandle->errorCode;
1159 }
1160 
1167 SBG_INLINE SbgErrorCode sbgStreamBufferWriteUint64LE(SbgStreamBuffer *pHandle, uint64 value)
1168 {
1169  //
1170  // Check input parameters
1171  //
1172  SBG_ASSERT(pHandle);
1173 
1174  //
1175  // Test if we haven't already an error
1176  //
1177  if (pHandle->errorCode == SBG_NO_ERROR)
1178  {
1179  //
1180  // Test if we can access this item
1181  //
1182  if (sbgStreamBufferGetSpace(pHandle) >= sizeof(uint64))
1183  {
1184  //
1185  // Test if the platform supports un-aligned access and if the endianness is the same
1186  //
1187  #if (SBG_CONFIG_UNALIGNED_ACCESS_AUTH == 1) && (SBG_CONFIG_BIG_ENDIAN == 0)
1188  //
1189  // Write the value
1190  //
1191  *((uint64*)(pHandle->pCurrentPtr)) = value;
1192 
1193  //
1194  // Increment the current pointer
1195  //
1196  pHandle->pCurrentPtr += sizeof(uint64);
1197  #else
1198  //
1199  // Store data according to platform endianness
1200  //
1201  #if (SBG_CONFIG_BIG_ENDIAN == 1)
1202  *(pHandle->pCurrentPtr++) = (uint8)(value >> 56);
1203  *(pHandle->pCurrentPtr++) = (uint8)(value >> 48);
1204  *(pHandle->pCurrentPtr++) = (uint8)(value >> 40);
1205  *(pHandle->pCurrentPtr++) = (uint8)(value >> 32);
1206  *(pHandle->pCurrentPtr++) = (uint8)(value >> 24);
1207  *(pHandle->pCurrentPtr++) = (uint8)(value >> 16);
1208  *(pHandle->pCurrentPtr++) = (uint8)(value >> 8);
1209  *(pHandle->pCurrentPtr++) = (uint8)(value);
1210  #else
1211  *(pHandle->pCurrentPtr++) = (uint8)(value);
1212  *(pHandle->pCurrentPtr++) = (uint8)(value >> 8);
1213  *(pHandle->pCurrentPtr++) = (uint8)(value >> 16);
1214  *(pHandle->pCurrentPtr++) = (uint8)(value >> 24);
1215  *(pHandle->pCurrentPtr++) = (uint8)(value >> 32);
1216  *(pHandle->pCurrentPtr++) = (uint8)(value >> 40);
1217  *(pHandle->pCurrentPtr++) = (uint8)(value >> 48);
1218  *(pHandle->pCurrentPtr++) = (uint8)(value >> 56);
1219  #endif
1220  #endif
1221  }
1222  else
1223  {
1224  //
1225  // We are accessing a data that is outside the stream buffer
1226  //
1227  pHandle->errorCode = SBG_BUFFER_OVERFLOW;
1228  }
1229  }
1230 
1231  return pHandle->errorCode;
1232 }
1233 
1240 SBG_INLINE SbgErrorCode sbgStreamBufferWriteSizeT32LE(SbgStreamBuffer *pHandle, size_t value)
1241 {
1242  //
1243  // Check input parameters
1244  //
1245  SBG_ASSERT(pHandle);
1246 
1247  //
1248  // Make sure the provided size_t value doesn't exceed a uint32 storage
1249  //
1250  SBG_ASSERT(value <= SBG_MAX_UINT_32);
1251 
1252  //
1253  // Call the write method to store a uint32
1254  //
1255  return sbgStreamBufferWriteUint32LE(pHandle, (uint32)value);
1256 }
1257 
1264 SBG_INLINE SbgErrorCode sbgStreamBufferWriteSizeT64LE(SbgStreamBuffer *pHandle, size_t value)
1265 {
1266  //
1267  // Check input parameters
1268  //
1269  SBG_ASSERT(pHandle);
1270 
1271  //
1272  // Call the write method to store a uint64
1273  //
1274  return sbgStreamBufferWriteUint64LE(pHandle, (uint64)value);
1275 }
1276 
1283 SBG_INLINE SbgErrorCode sbgStreamBufferWriteFloatLE(SbgStreamBuffer *pHandle, float value)
1284 {
1285  FloatNint floatInt;
1286 
1287  //
1288  // Check input parameters
1289  //
1290  SBG_ASSERT(pHandle);
1291 
1292  //
1293  // Test if we haven't already an error
1294  //
1295  if (pHandle->errorCode == SBG_NO_ERROR)
1296  {
1297  //
1298  // We use an union to avoid compiler cast
1299  //
1300  floatInt.valF = value;
1301 
1302  //
1303  // Write this float as an uint32
1304  //
1305  return sbgStreamBufferWriteUint32LE(pHandle, floatInt.valU);
1306  }
1307 
1308  return pHandle->errorCode;
1309 }
1310 
1317 SBG_INLINE SbgErrorCode sbgStreamBufferWriteDoubleLE(SbgStreamBuffer *pHandle, double value)
1318 {
1319  DoubleNint doubleInt;
1320 
1321  //
1322  // Check input parameters
1323  //
1324  SBG_ASSERT(pHandle);
1325 
1326  //
1327  // Test if we haven't already an error
1328  //
1329  if (pHandle->errorCode == SBG_NO_ERROR)
1330  {
1331  //
1332  // We use an union to avoid compiler cast
1333  //
1334  doubleInt.valF = value;
1335 
1336  //
1337  // Write this float as an uint64
1338  //
1339  return sbgStreamBufferWriteUint64LE(pHandle, doubleInt.valU);
1340  }
1341 
1342  return pHandle->errorCode;
1343 }
1344 
1345 #endif /* __SBG_STREAM_BUFFER_LE_H__ */
sbgStreamBufferReadInt24LE
SBG_INLINE int32 sbgStreamBufferReadInt24LE(SbgStreamBuffer *pHandle)
Definition: sbgStreamBufferLE.h:177
_DoubleNint::valF
double valF
Definition: sbgTypes.h:136
sbgStreamBufferReadSizeT32LE
SBG_INLINE size_t sbgStreamBufferReadSizeT32LE(SbgStreamBuffer *pHandle)
Definition: sbgStreamBufferLE.h:577
SBG_MAX_UINT_24
#define SBG_MAX_UINT_24
Definition: sbgTypes.h:41
sbgStreamBufferReadFloatLE
SBG_INLINE float sbgStreamBufferReadFloatLE(SbgStreamBuffer *pHandle)
Definition: sbgStreamBufferLE.h:616
uint32
unsigned int uint32
Definition: sbgTypes.h:58
sbgStreamBufferWriteInt32LE
SBG_INLINE SbgErrorCode sbgStreamBufferWriteInt32LE(SbgStreamBuffer *pHandle, int32 value)
Definition: sbgStreamBufferLE.h:964
sbgStreamBufferReadInt64LE
SBG_INLINE int64 sbgStreamBufferReadInt64LE(SbgStreamBuffer *pHandle)
Definition: sbgStreamBufferLE.h:433
sbgStreamBufferCommon.h
Used to read/write data from/to a memory buffer stream.
_SbgStreamBuffer::errorCode
SbgErrorCode errorCode
Definition: sbgStreamBufferCommon.h:146
SBG_MAX_UINT_32
#define SBG_MAX_UINT_32
Definition: sbgTypes.h:46
sbgStreamBufferReadInt16LE
SBG_INLINE int16 sbgStreamBufferReadInt16LE(SbgStreamBuffer *pHandle)
Definition: sbgStreamBufferLE.h:35
int16
signed short int16
Definition: sbgTypes.h:63
sbgStreamBufferReadUint64LE
SBG_INLINE uint64 sbgStreamBufferReadUint64LE(SbgStreamBuffer *pHandle)
Definition: sbgStreamBufferLE.h:505
sbgStreamBufferWriteSizeT32LE
SBG_INLINE SbgErrorCode sbgStreamBufferWriteSizeT32LE(SbgStreamBuffer *pHandle, size_t value)
Definition: sbgStreamBufferLE.h:1240
_FloatNint::valU
uint32 valU
Definition: sbgTypes.h:128
sbgStreamBufferWriteDoubleLE
SBG_INLINE SbgErrorCode sbgStreamBufferWriteDoubleLE(SbgStreamBuffer *pHandle, double value)
Definition: sbgStreamBufferLE.h:1317
_SbgStreamBuffer::pCurrentPtr
uint8 * pCurrentPtr
Definition: sbgStreamBufferCommon.h:145
sbgStreamBufferReadUint16LE
SBG_INLINE uint16 sbgStreamBufferReadUint16LE(SbgStreamBuffer *pHandle)
Definition: sbgStreamBufferLE.h:106
_DoubleNint::valU
uint64 valU
Definition: sbgTypes.h:137
sbgStreamBufferWriteUint64LE
SBG_INLINE SbgErrorCode sbgStreamBufferWriteUint64LE(SbgStreamBuffer *pHandle, uint64 value)
Definition: sbgStreamBufferLE.h:1167
uint64
unsigned long long int uint64
Definition: sbgTypes.h:60
int8
signed char int8
Definition: sbgTypes.h:62
sbgStreamBufferWriteSizeT64LE
SBG_INLINE SbgErrorCode sbgStreamBufferWriteSizeT64LE(SbgStreamBuffer *pHandle, size_t value)
Definition: sbgStreamBufferLE.h:1264
int64
signed long long int int64
Definition: sbgTypes.h:65
sbgStreamBufferWriteInt24LE
SBG_INLINE SbgErrorCode sbgStreamBufferWriteInt24LE(SbgStreamBuffer *pHandle, int32 value)
Definition: sbgStreamBufferLE.h:842
SBG_MAX_INT_24
#define SBG_MAX_INT_24
Definition: sbgTypes.h:39
_FloatNint::valF
float valF
Definition: sbgTypes.h:126
sbgStreamBufferGetSpace
SBG_INLINE size_t sbgStreamBufferGetSpace(SbgStreamBuffer *pHandle)
Definition: sbgStreamBufferCommon.h:307
sbgStreamBufferWriteInt64LE
SBG_INLINE SbgErrorCode sbgStreamBufferWriteInt64LE(SbgStreamBuffer *pHandle, int64 value)
Definition: sbgStreamBufferLE.h:1094
sbgStreamBufferReadSizeT64LE
SBG_INLINE size_t sbgStreamBufferReadSizeT64LE(SbgStreamBuffer *pHandle)
Definition: sbgStreamBufferLE.h:591
sbgStreamBufferReadUint32LE
SBG_INLINE uint32 sbgStreamBufferReadUint32LE(SbgStreamBuffer *pHandle)
Definition: sbgStreamBufferLE.h:360
sbgStreamBufferWriteInt16LE
SBG_INLINE SbgErrorCode sbgStreamBufferWriteInt16LE(SbgStreamBuffer *pHandle, int16 value)
Definition: sbgStreamBufferLE.h:719
SBG_INLINE
#define SBG_INLINE
Definition: sbgDefines.h:94
sbgStreamBufferWriteUint16LE
SBG_INLINE SbgErrorCode sbgStreamBufferWriteUint16LE(SbgStreamBuffer *pHandle, uint16 value)
Definition: sbgStreamBufferLE.h:780
SBG_MIN_INT_24
#define SBG_MIN_INT_24
Definition: sbgTypes.h:38
sbgStreamBufferWriteFloatLE
SBG_INLINE SbgErrorCode sbgStreamBufferWriteFloatLE(SbgStreamBuffer *pHandle, float value)
Definition: sbgStreamBufferLE.h:1283
_SbgStreamBuffer
Definition: sbgStreamBufferCommon.h:140
_FloatNint
Definition: sbgTypes.h:124
sbgStreamBufferWriteUint32LE
SBG_INLINE SbgErrorCode sbgStreamBufferWriteUint32LE(SbgStreamBuffer *pHandle, uint32 value)
Definition: sbgStreamBufferLE.h:1029
uint8
unsigned char uint8
Definition: sbgTypes.h:56
SBG_ASSERT
#define SBG_ASSERT(expression)
Definition: sbgDebug.h:52
sbgStreamBufferWriteUint24LE
SBG_INLINE SbgErrorCode sbgStreamBufferWriteUint24LE(SbgStreamBuffer *pHandle, uint32 value)
Definition: sbgStreamBufferLE.h:903
sbgStreamBufferReadInt32LE
SBG_INLINE int32 sbgStreamBufferReadInt32LE(SbgStreamBuffer *pHandle)
Definition: sbgStreamBufferLE.h:287
_DoubleNint
Definition: sbgTypes.h:134
int32
signed int int32
Definition: sbgTypes.h:64
sbgStreamBufferReadUint24LE
SBG_INLINE uint32 sbgStreamBufferReadUint24LE(SbgStreamBuffer *pHandle)
Definition: sbgStreamBufferLE.h:232
sbgStreamBufferReadDoubleLE
SBG_INLINE double sbgStreamBufferReadDoubleLE(SbgStreamBuffer *pHandle)
Definition: sbgStreamBufferLE.h:665
uint16
unsigned short uint16
Definition: sbgTypes.h:57
SbgErrorCode
enum _SbgErrorCode SbgErrorCode

sbg_driver
Author(s):
autogenerated on Sun Jan 27 2019 03:42:20