sbgStreamBufferBE.h
Go to the documentation of this file.
1 
21 #ifndef __SBG_STREAM_BUFFER_BE_H__
22 #define __SBG_STREAM_BUFFER_BE_H__
23 
24 #include "sbgStreamBufferCommon.h"
25 
26 //----------------------------------------------------------------------//
27 //- Read operations methods -//
28 //----------------------------------------------------------------------//
29 
35 SBG_INLINE int16 sbgStreamBufferReadInt16BE(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 == 1)
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[1] = *(pHandle->pCurrentPtr++);
74  bytesValues[0] = *(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 sbgStreamBufferReadUint16BE(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 == 1)
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[1] = *(pHandle->pCurrentPtr++);
145  bytesValues[0] = *(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 sbgStreamBufferReadInt24BE(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[2] = *(pHandle->pCurrentPtr++);
200  bytesValues[1] = *(pHandle->pCurrentPtr++);
201  bytesValues[0] = *(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 sbgStreamBufferReadUint24BE(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[2] = *(pHandle->pCurrentPtr++);
255  bytesValues[1] = *(pHandle->pCurrentPtr++);
256  bytesValues[0] = *(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 sbgStreamBufferReadInt32BE(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 == 1)
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[3] = *(pHandle->pCurrentPtr++);
326  bytesValues[2] = *(pHandle->pCurrentPtr++);
327  bytesValues[1] = *(pHandle->pCurrentPtr++);
328  bytesValues[0] = *(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 sbgStreamBufferReadUint32BE(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 == 1)
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[3] = *(pHandle->pCurrentPtr++);
399  bytesValues[2] = *(pHandle->pCurrentPtr++);
400  bytesValues[1] = *(pHandle->pCurrentPtr++);
401  bytesValues[0] = *(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 sbgStreamBufferReadInt64BE(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 == 1)
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  highPart = sbgStreamBufferReadUint32BE(pHandle);
473  lowPart = sbgStreamBufferReadUint32BE(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 sbgStreamBufferReadUint64BE(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 == 1)
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  highPart = sbgStreamBufferReadUint32BE(pHandle);
545  lowPart = sbgStreamBufferReadUint32BE(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 0ll;
570 }
571 
577 SBG_INLINE size_t sbgStreamBufferReadSizeT32BE(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)sbgStreamBufferReadUint32BE(pHandle);
584 }
585 
591 SBG_INLINE size_t sbgStreamBufferReadSizeT64BE(SbgStreamBuffer *pHandle)
592 {
593  uint64 size;
594 
595  //
596  // Just call the read method for uint64
597  //
598  size = sbgStreamBufferReadUint64BE(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 sbgStreamBufferReadFloatBE(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 = sbgStreamBufferReadUint32BE(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 sbgStreamBufferReadDoubleBE(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 = sbgStreamBufferReadUint64BE(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 sbgStreamBufferWriteInt16BE(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 == 1)
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);
755  *(pHandle->pCurrentPtr++) = (uint8)(value >> 8);
756  #else
757  *(pHandle->pCurrentPtr++) = (uint8)(value >> 8);
758  *(pHandle->pCurrentPtr++) = (uint8)(value);
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 sbgStreamBufferWriteUint16BE(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 == 1)
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);
816  *(pHandle->pCurrentPtr++) = (uint8)(value >> 8);
817  #else
818  *(pHandle->pCurrentPtr++) = (uint8)(value >> 8);
819  *(pHandle->pCurrentPtr++) = (uint8)(value);
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 
841 SBG_INLINE SbgErrorCode sbgStreamBufferWriteInt24BE(SbgStreamBuffer *pHandle, int32 value)
842 {
843  //
844  // Check input parameters
845  //
846  SBG_ASSERT(pHandle);
847 
848  //
849  // Test if we haven't already an error
850  //
851  if (pHandle->errorCode == SBG_NO_ERROR)
852  {
853  //
854  // Make sure that the value is within 24 bit bonds
855  //
856  if ( (value >= SBG_MIN_INT_24) && (value <= SBG_MAX_INT_24) )
857  {
858  //
859  // Test if we can access this item
860  //
861  if (sbgStreamBufferGetSpace(pHandle) >= 3*sizeof(int8))
862  {
863  //
864  // Store data according to platform endianness
865  //
866  #if (SBG_CONFIG_BIG_ENDIAN == 1)
867  *(pHandle->pCurrentPtr++) = (uint8)(value);
868  *(pHandle->pCurrentPtr++) = (uint8)(value >> 8);
869  *(pHandle->pCurrentPtr++) = (uint8)(value >> 16);
870  #else
871  *(pHandle->pCurrentPtr++) = (uint8)(value >> 16);
872  *(pHandle->pCurrentPtr++) = (uint8)(value >> 8);
873  *(pHandle->pCurrentPtr++) = (uint8)(value);
874  #endif
875  }
876  else
877  {
878  //
879  // We are accessing a data that is outside the stream buffer
880  //
881  pHandle->errorCode = SBG_BUFFER_OVERFLOW;
882  }
883  }
884  else
885  {
886  //
887  // The input value is not within a 24 bit integer bounds
888  //
889  pHandle->errorCode = SBG_INVALID_PARAMETER;
890  }
891  }
892 
893  return pHandle->errorCode;
894 }
895 
902 SBG_INLINE SbgErrorCode sbgStreamBufferWriteUint24BE(SbgStreamBuffer *pHandle, uint32 value)
903 {
904  //
905  // Check input parameters
906  //
907  SBG_ASSERT(pHandle);
908 
909  //
910  // Test if we haven't already an error
911  //
912  if (pHandle->errorCode == SBG_NO_ERROR)
913  {
914  //
915  // Make sure that the value is within 24 bit bonds
916  //
917  if (value <= SBG_MAX_UINT_24)
918  {
919  //
920  // Test if we can access this item
921  //
922  if (sbgStreamBufferGetSpace(pHandle) >= 3*sizeof(uint8))
923  {
924  //
925  // Store data according to platform endianness
926  //
927  #if (SBG_CONFIG_BIG_ENDIAN == 1)
928  *(pHandle->pCurrentPtr++) = (uint8)(value);
929  *(pHandle->pCurrentPtr++) = (uint8)(value >> 8);
930  *(pHandle->pCurrentPtr++) = (uint8)(value >> 16);
931  #else
932  *(pHandle->pCurrentPtr++) = (uint8)(value >> 16);
933  *(pHandle->pCurrentPtr++) = (uint8)(value >> 8);
934  *(pHandle->pCurrentPtr++) = (uint8)(value);
935  #endif
936  }
937  else
938  {
939  //
940  // We are accessing a data that is outside the stream buffer
941  //
942  pHandle->errorCode = SBG_BUFFER_OVERFLOW;
943  }
944  }
945  else
946  {
947  //
948  // The input value is not within a 24 bit integer bounds
949  //
950  pHandle->errorCode = SBG_INVALID_PARAMETER;
951  }
952  }
953 
954  return pHandle->errorCode;
955 }
956 
963 SBG_INLINE SbgErrorCode sbgStreamBufferWriteInt32BE(SbgStreamBuffer *pHandle, int32 value)
964 {
965  //
966  // Check input parameters
967  //
968  SBG_ASSERT(pHandle);
969 
970  //
971  // Test if we haven't already an error
972  //
973  if (pHandle->errorCode == SBG_NO_ERROR)
974  {
975  //
976  // Test if we can access this item
977  //
978  if (sbgStreamBufferGetSpace(pHandle) >= sizeof(int32))
979  {
980  //
981  // Test if the platform supports un-aligned access and if the endianness is the same
982  //
983  #if (SBG_CONFIG_UNALIGNED_ACCESS_AUTH == 1) && (SBG_CONFIG_BIG_ENDIAN == 1)
984  //
985  // Write the value
986  //
987  *((int32*)(pHandle->pCurrentPtr)) = value;
988 
989  //
990  // Increment the current pointer
991  //
992  pHandle->pCurrentPtr += sizeof(int32);
993  #else
994  //
995  // Store data according to platform endianness
996  //
997  #if (SBG_CONFIG_BIG_ENDIAN == 1)
998  *(pHandle->pCurrentPtr++) = (uint8)(value);
999  *(pHandle->pCurrentPtr++) = (uint8)(value >> 8);
1000  *(pHandle->pCurrentPtr++) = (uint8)(value >> 16);
1001  *(pHandle->pCurrentPtr++) = (uint8)(value >> 24);
1002  #else
1003  *(pHandle->pCurrentPtr++) = (uint8)(value >> 24);
1004  *(pHandle->pCurrentPtr++) = (uint8)(value >> 16);
1005  *(pHandle->pCurrentPtr++) = (uint8)(value >> 8);
1006  *(pHandle->pCurrentPtr++) = (uint8)(value);
1007  #endif
1008  #endif
1009  }
1010  else
1011  {
1012  //
1013  // We are accessing a data that is outside the stream buffer
1014  //
1015  pHandle->errorCode = SBG_BUFFER_OVERFLOW;
1016  }
1017  }
1018 
1019  return pHandle->errorCode;
1020 }
1021 
1028 SBG_INLINE SbgErrorCode sbgStreamBufferWriteUint32BE(SbgStreamBuffer *pHandle, uint32 value)
1029 {
1030  //
1031  // Check input parameters
1032  //
1033  SBG_ASSERT(pHandle);
1034 
1035  //
1036  // Test if we haven't already an error
1037  //
1038  if (pHandle->errorCode == SBG_NO_ERROR)
1039  {
1040  //
1041  // Test if we can access this item
1042  //
1043  if (sbgStreamBufferGetSpace(pHandle) >= sizeof(uint32))
1044  {
1045  //
1046  // Test if the platform supports un-aligned access and if the endianness is the same
1047  //
1048  #if (SBG_CONFIG_UNALIGNED_ACCESS_AUTH == 1) && (SBG_CONFIG_BIG_ENDIAN == 1)
1049  //
1050  // Write the value
1051  //
1052  *((uint32*)(pHandle->pCurrentPtr)) = value;
1053 
1054  //
1055  // Increment the current pointer
1056  //
1057  pHandle->pCurrentPtr += sizeof(uint32);
1058  #else
1059  //
1060  // Store data according to platform endianness
1061  //
1062  #if (SBG_CONFIG_BIG_ENDIAN == 1)
1063  *(pHandle->pCurrentPtr++) = (uint8)(value);
1064  *(pHandle->pCurrentPtr++) = (uint8)(value >> 8);
1065  *(pHandle->pCurrentPtr++) = (uint8)(value >> 16);
1066  *(pHandle->pCurrentPtr++) = (uint8)(value >> 24);
1067  #else
1068  *(pHandle->pCurrentPtr++) = (uint8)(value >> 24);
1069  *(pHandle->pCurrentPtr++) = (uint8)(value >> 16);
1070  *(pHandle->pCurrentPtr++) = (uint8)(value >> 8);
1071  *(pHandle->pCurrentPtr++) = (uint8)(value);
1072  #endif
1073  #endif
1074  }
1075  else
1076  {
1077  //
1078  // We are accessing a data that is outside the stream buffer
1079  //
1080  pHandle->errorCode = SBG_BUFFER_OVERFLOW;
1081  }
1082  }
1083 
1084  return pHandle->errorCode;
1085 }
1086 
1093 SBG_INLINE SbgErrorCode sbgStreamBufferWriteInt64BE(SbgStreamBuffer *pHandle, int64 value)
1094 {
1095  //
1096  // Check input parameters
1097  //
1098  SBG_ASSERT(pHandle);
1099 
1100  //
1101  // Test if we haven't already an error
1102  //
1103  if (pHandle->errorCode == SBG_NO_ERROR)
1104  {
1105  //
1106  // Test if we can access this item
1107  //
1108  if (sbgStreamBufferGetSpace(pHandle) >= sizeof(int64))
1109  {
1110  //
1111  // Test if the platform supports un-aligned access and if the endianness is the same
1112  //
1113  #if (SBG_CONFIG_UNALIGNED_ACCESS_AUTH == 1) && (SBG_CONFIG_BIG_ENDIAN == 1)
1114  //
1115  // Write the value
1116  //
1117  *((int64*)(pHandle->pCurrentPtr)) = value;
1118 
1119  //
1120  // Increment the current pointer
1121  //
1122  pHandle->pCurrentPtr += sizeof(int64);
1123  #else
1124  //
1125  // Store data according to platform endianness
1126  //
1127  #if (SBG_CONFIG_BIG_ENDIAN == 1)
1128  *(pHandle->pCurrentPtr++) = (uint8)(value);
1129  *(pHandle->pCurrentPtr++) = (uint8)(value >> 8);
1130  *(pHandle->pCurrentPtr++) = (uint8)(value >> 16);
1131  *(pHandle->pCurrentPtr++) = (uint8)(value >> 24);
1132  *(pHandle->pCurrentPtr++) = (uint8)(value >> 32);
1133  *(pHandle->pCurrentPtr++) = (uint8)(value >> 40);
1134  *(pHandle->pCurrentPtr++) = (uint8)(value >> 48);
1135  *(pHandle->pCurrentPtr++) = (uint8)(value >> 56);
1136  #else
1137  *(pHandle->pCurrentPtr++) = (uint8)(value >> 56);
1138  *(pHandle->pCurrentPtr++) = (uint8)(value >> 48);
1139  *(pHandle->pCurrentPtr++) = (uint8)(value >> 40);
1140  *(pHandle->pCurrentPtr++) = (uint8)(value >> 32);
1141  *(pHandle->pCurrentPtr++) = (uint8)(value >> 24);
1142  *(pHandle->pCurrentPtr++) = (uint8)(value >> 16);
1143  *(pHandle->pCurrentPtr++) = (uint8)(value >> 8);
1144  *(pHandle->pCurrentPtr++) = (uint8)(value);
1145  #endif
1146  #endif
1147  }
1148  else
1149  {
1150  //
1151  // We are accessing a data that is outside the stream buffer
1152  //
1153  pHandle->errorCode = SBG_BUFFER_OVERFLOW;
1154  }
1155  }
1156 
1157  return pHandle->errorCode;
1158 }
1159 
1166 SBG_INLINE SbgErrorCode sbgStreamBufferWriteUint64BE(SbgStreamBuffer *pHandle, uint64 value)
1167 {
1168  //
1169  // Check input parameters
1170  //
1171  SBG_ASSERT(pHandle);
1172 
1173  //
1174  // Test if we haven't already an error
1175  //
1176  if (pHandle->errorCode == SBG_NO_ERROR)
1177  {
1178  //
1179  // Test if we can access this item
1180  //
1181  if (sbgStreamBufferGetSpace(pHandle) >= sizeof(uint64))
1182  {
1183  //
1184  // Test if the platform supports un-aligned access and if the endianness is the same
1185  //
1186  #if (SBG_CONFIG_UNALIGNED_ACCESS_AUTH == 1) && (SBG_CONFIG_BIG_ENDIAN == 1)
1187  //
1188  // Write the value
1189  //
1190  *((uint64*)(pHandle->pCurrentPtr)) = value;
1191 
1192  //
1193  // Increment the current pointer
1194  //
1195  pHandle->pCurrentPtr += sizeof(uint64);
1196  #else
1197  //
1198  // Store data according to platform endianness
1199  //
1200  #if (SBG_CONFIG_BIG_ENDIAN == 1)
1201  *(pHandle->pCurrentPtr++) = (uint8)(value);
1202  *(pHandle->pCurrentPtr++) = (uint8)(value >> 8);
1203  *(pHandle->pCurrentPtr++) = (uint8)(value >> 16);
1204  *(pHandle->pCurrentPtr++) = (uint8)(value >> 24);
1205  *(pHandle->pCurrentPtr++) = (uint8)(value >> 32);
1206  *(pHandle->pCurrentPtr++) = (uint8)(value >> 40);
1207  *(pHandle->pCurrentPtr++) = (uint8)(value >> 48);
1208  *(pHandle->pCurrentPtr++) = (uint8)(value >> 56);
1209  #else
1210  *(pHandle->pCurrentPtr++) = (uint8)(value >> 56);
1211  *(pHandle->pCurrentPtr++) = (uint8)(value >> 48);
1212  *(pHandle->pCurrentPtr++) = (uint8)(value >> 40);
1213  *(pHandle->pCurrentPtr++) = (uint8)(value >> 32);
1214  *(pHandle->pCurrentPtr++) = (uint8)(value >> 24);
1215  *(pHandle->pCurrentPtr++) = (uint8)(value >> 16);
1216  *(pHandle->pCurrentPtr++) = (uint8)(value >> 8);
1217  *(pHandle->pCurrentPtr++) = (uint8)(value);
1218  #endif
1219  #endif
1220  }
1221  else
1222  {
1223  //
1224  // We are accessing a data that is outside the stream buffer
1225  //
1226  pHandle->errorCode = SBG_BUFFER_OVERFLOW;
1227  }
1228  }
1229 
1230  return pHandle->errorCode;
1231 }
1232 
1239 SBG_INLINE SbgErrorCode sbgStreamBufferWriteSizeT32BE(SbgStreamBuffer *pHandle, size_t value)
1240 {
1241  //
1242  // Check input parameters
1243  //
1244  SBG_ASSERT(pHandle);
1245 
1246  //
1247  // Make sure the provided size_t value doesn't exceed a uint32 storage
1248  //
1249  SBG_ASSERT(value <= SBG_MAX_UINT_32);
1250 
1251  //
1252  // Call the write method to store a uint32
1253  //
1254  return sbgStreamBufferWriteUint32BE(pHandle, (uint32)value);
1255 }
1256 
1263 SBG_INLINE SbgErrorCode sbgStreamBufferWriteSizeT64BE(SbgStreamBuffer *pHandle, size_t value)
1264 {
1265  //
1266  // Check input parameters
1267  //
1268  SBG_ASSERT(pHandle);
1269 
1270  //
1271  // Call the write method to store a uint64
1272  //
1273  return sbgStreamBufferWriteUint64BE(pHandle, (uint64)value);
1274 }
1275 
1282 SBG_INLINE SbgErrorCode sbgStreamBufferWriteFloatBE(SbgStreamBuffer *pHandle, float value)
1283 {
1284  FloatNint floatInt;
1285 
1286  //
1287  // Check input parameters
1288  //
1289  SBG_ASSERT(pHandle);
1290 
1291  //
1292  // Test if we haven't already an error
1293  //
1294  if (pHandle->errorCode == SBG_NO_ERROR)
1295  {
1296  //
1297  // We use an union to avoid compiler cast
1298  //
1299  floatInt.valF = value;
1300 
1301  //
1302  // Write this float as an uint32
1303  //
1304  return sbgStreamBufferWriteUint32BE(pHandle, floatInt.valU);
1305  }
1306 
1307  return pHandle->errorCode;
1308 }
1309 
1316 SBG_INLINE SbgErrorCode sbgStreamBufferWriteDoubleBE(SbgStreamBuffer *pHandle, double value)
1317 {
1318  DoubleNint doubleInt;
1319 
1320  //
1321  // Check input parameters
1322  //
1323  SBG_ASSERT(pHandle);
1324 
1325  //
1326  // Test if we haven't already an error
1327  //
1328  if (pHandle->errorCode == SBG_NO_ERROR)
1329  {
1330  //
1331  // We use an union to avoid compiler cast
1332  //
1333  doubleInt.valF = value;
1334 
1335  //
1336  // Write this float as an uint64
1337  //
1338  return sbgStreamBufferWriteUint64BE(pHandle, doubleInt.valU);
1339  }
1340 
1341  return pHandle->errorCode;
1342 }
1343 
1344 #endif /* __SBG_STREAM_BUFFER_BE_H__ */
sbgStreamBufferWriteFloatBE
SBG_INLINE SbgErrorCode sbgStreamBufferWriteFloatBE(SbgStreamBuffer *pHandle, float value)
Definition: sbgStreamBufferBE.h:1282
sbgStreamBufferWriteInt16BE
SBG_INLINE SbgErrorCode sbgStreamBufferWriteInt16BE(SbgStreamBuffer *pHandle, int16 value)
Definition: sbgStreamBufferBE.h:719
_DoubleNint::valF
double valF
Definition: sbgTypes.h:136
sbgStreamBufferReadFloatBE
SBG_INLINE float sbgStreamBufferReadFloatBE(SbgStreamBuffer *pHandle)
Definition: sbgStreamBufferBE.h:616
SBG_MAX_UINT_24
#define SBG_MAX_UINT_24
Definition: sbgTypes.h:41
sbgStreamBufferReadUint24BE
SBG_INLINE uint32 sbgStreamBufferReadUint24BE(SbgStreamBuffer *pHandle)
Definition: sbgStreamBufferBE.h:232
uint32
unsigned int uint32
Definition: sbgTypes.h:58
sbgStreamBufferReadInt16BE
SBG_INLINE int16 sbgStreamBufferReadInt16BE(SbgStreamBuffer *pHandle)
Definition: sbgStreamBufferBE.h:35
sbgStreamBufferCommon.h
Used to read/write data from/to a memory buffer stream.
sbgStreamBufferWriteSizeT64BE
SBG_INLINE SbgErrorCode sbgStreamBufferWriteSizeT64BE(SbgStreamBuffer *pHandle, size_t value)
Definition: sbgStreamBufferBE.h:1263
_SbgStreamBuffer::errorCode
SbgErrorCode errorCode
Definition: sbgStreamBufferCommon.h:146
SBG_MAX_UINT_32
#define SBG_MAX_UINT_32
Definition: sbgTypes.h:46
int16
signed short int16
Definition: sbgTypes.h:63
_FloatNint::valU
uint32 valU
Definition: sbgTypes.h:128
_SbgStreamBuffer::pCurrentPtr
uint8 * pCurrentPtr
Definition: sbgStreamBufferCommon.h:145
sbgStreamBufferWriteUint64BE
SBG_INLINE SbgErrorCode sbgStreamBufferWriteUint64BE(SbgStreamBuffer *pHandle, uint64 value)
Definition: sbgStreamBufferBE.h:1166
_DoubleNint::valU
uint64 valU
Definition: sbgTypes.h:137
sbgStreamBufferReadUint16BE
SBG_INLINE uint16 sbgStreamBufferReadUint16BE(SbgStreamBuffer *pHandle)
Definition: sbgStreamBufferBE.h:106
sbgStreamBufferReadSizeT32BE
SBG_INLINE size_t sbgStreamBufferReadSizeT32BE(SbgStreamBuffer *pHandle)
Definition: sbgStreamBufferBE.h:577
uint64
unsigned long long int uint64
Definition: sbgTypes.h:60
sbgStreamBufferReadDoubleBE
SBG_INLINE double sbgStreamBufferReadDoubleBE(SbgStreamBuffer *pHandle)
Definition: sbgStreamBufferBE.h:665
sbgStreamBufferWriteDoubleBE
SBG_INLINE SbgErrorCode sbgStreamBufferWriteDoubleBE(SbgStreamBuffer *pHandle, double value)
Definition: sbgStreamBufferBE.h:1316
int8
signed char int8
Definition: sbgTypes.h:62
sbgStreamBufferWriteSizeT32BE
SBG_INLINE SbgErrorCode sbgStreamBufferWriteSizeT32BE(SbgStreamBuffer *pHandle, size_t value)
Definition: sbgStreamBufferBE.h:1239
sbgStreamBufferWriteInt24BE
SBG_INLINE SbgErrorCode sbgStreamBufferWriteInt24BE(SbgStreamBuffer *pHandle, int32 value)
Definition: sbgStreamBufferBE.h:841
int64
signed long long int int64
Definition: sbgTypes.h:65
sbgStreamBufferReadInt24BE
SBG_INLINE int32 sbgStreamBufferReadInt24BE(SbgStreamBuffer *pHandle)
Definition: sbgStreamBufferBE.h:177
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
sbgStreamBufferReadUint32BE
SBG_INLINE uint32 sbgStreamBufferReadUint32BE(SbgStreamBuffer *pHandle)
Definition: sbgStreamBufferBE.h:360
sbgStreamBufferWriteUint24BE
SBG_INLINE SbgErrorCode sbgStreamBufferWriteUint24BE(SbgStreamBuffer *pHandle, uint32 value)
Definition: sbgStreamBufferBE.h:902
sbgStreamBufferReadInt64BE
SBG_INLINE int64 sbgStreamBufferReadInt64BE(SbgStreamBuffer *pHandle)
Definition: sbgStreamBufferBE.h:433
SBG_INLINE
#define SBG_INLINE
Definition: sbgDefines.h:94
SBG_MIN_INT_24
#define SBG_MIN_INT_24
Definition: sbgTypes.h:38
sbgStreamBufferWriteUint16BE
SBG_INLINE SbgErrorCode sbgStreamBufferWriteUint16BE(SbgStreamBuffer *pHandle, uint16 value)
Definition: sbgStreamBufferBE.h:780
sbgStreamBufferWriteUint32BE
SBG_INLINE SbgErrorCode sbgStreamBufferWriteUint32BE(SbgStreamBuffer *pHandle, uint32 value)
Definition: sbgStreamBufferBE.h:1028
sbgStreamBufferWriteInt64BE
SBG_INLINE SbgErrorCode sbgStreamBufferWriteInt64BE(SbgStreamBuffer *pHandle, int64 value)
Definition: sbgStreamBufferBE.h:1093
sbgStreamBufferReadInt32BE
SBG_INLINE int32 sbgStreamBufferReadInt32BE(SbgStreamBuffer *pHandle)
Definition: sbgStreamBufferBE.h:287
_SbgStreamBuffer
Definition: sbgStreamBufferCommon.h:140
_FloatNint
Definition: sbgTypes.h:124
sbgStreamBufferWriteInt32BE
SBG_INLINE SbgErrorCode sbgStreamBufferWriteInt32BE(SbgStreamBuffer *pHandle, int32 value)
Definition: sbgStreamBufferBE.h:963
uint8
unsigned char uint8
Definition: sbgTypes.h:56
SBG_ASSERT
#define SBG_ASSERT(expression)
Definition: sbgDebug.h:52
sbgStreamBufferReadUint64BE
SBG_INLINE uint64 sbgStreamBufferReadUint64BE(SbgStreamBuffer *pHandle)
Definition: sbgStreamBufferBE.h:505
_DoubleNint
Definition: sbgTypes.h:134
int32
signed int int32
Definition: sbgTypes.h:64
uint16
unsigned short uint16
Definition: sbgTypes.h:57
sbgStreamBufferReadSizeT64BE
SBG_INLINE size_t sbgStreamBufferReadSizeT64BE(SbgStreamBuffer *pHandle)
Definition: sbgStreamBufferBE.h:591
SbgErrorCode
enum _SbgErrorCode SbgErrorCode

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