Line data    Source code

       1             : /******************************************************************************
       2             :  * $Id$
       3             :  *
       4             :  * Project:  FIT Driver
       5             :  * Purpose:  Implement FIT Support - not using the SGI iflFIT library.
       6             :  * Author:   Philip Nemec, nemec@keyholecorp.com
       7             :  *
       8             :  ******************************************************************************
       9             :  * Copyright (c) 2001, Keyhole, Inc.
      10             :  *
      11             :  * SPDX-License-Identifier: MIT
      12             :  ****************************************************************************/
      13             : 
      14             : #ifndef gstEndian_h_
      15             : #define gstEndian_h_
      16             : 
      17             : // endian swapping tools
      18             : 
      19             : #include <stdio.h>
      20             : #include "cpl_port.h"
      21             : 
      22             : #include "gstTypes.h"
      23             : 
      24             : namespace gstEndian
      25             : {
      26             : 
      27             : // have to do swapping on Linux and Windows
      28             : #ifdef CPL_LSB
      29             : #define swapping
      30             : #else
      31             : #endif
      32             : 
      33             : #ifdef swapping
      34             : size_t swapped_fread(void *ptr, size_t size, size_t nitems, FILE *stream);
      35             : size_t swapped_fwrite(const void *ptr, size_t size, size_t nitems,
      36             :                       FILE *stream);
      37             : 
      38         506 : static inline void gst_swap64(void *value)
      39             : {
      40             :     // 0x1122334455667788 --> 0x8877665544332211
      41             : 
      42         506 :     *(uint64 *)(value) = (((*(uint64 *)(value)&0x00000000000000ff) << 56) |
      43         506 :                           ((*(uint64 *)(value)&0x000000000000ff00) << 40) |
      44         506 :                           ((*(uint64 *)(value)&0x0000000000ff0000) << 24) |
      45         506 :                           ((*(uint64 *)(value)&0x00000000ff000000) << 8) |
      46         506 :                           ((*(uint64 *)(value) >> 8) & 0x00000000ff000000) |
      47         506 :                           ((*(uint64 *)(value) >> 24) & 0x0000000000ff0000) |
      48         506 :                           ((*(uint64 *)(value) >> 40) & 0x000000000000ff00) |
      49         506 :                           ((*(uint64 *)(value) >> 56) & 0x00000000000000ff));
      50         506 : }
      51             : 
      52        1905 : static inline void gst_swap32(void *value)
      53             : {
      54             :     // 0x12 34 56 78 --> 0x78 56 34 12
      55             : 
      56        1905 :     *(uint32 *)(value) = (((*(uint32 *)(value)&0x000000ff) << 24) |
      57        1905 :                           ((*(uint32 *)(value)&0x0000ff00) << 8) |
      58        1905 :                           ((*(uint32 *)(value) >> 8) & 0x0000ff00) |
      59        1905 :                           ((*(uint32 *)(value) >> 24) & 0x000000ff));
      60        1905 : }
      61             : 
      62         800 : static inline void gst_swap16(void *value)
      63             : {
      64         800 :     *(uint16 *)(value) = (((*(uint16 *)(value)&0x00ff) << 8) |
      65         800 :                           ((*(uint16 *)(value) >> 8) & 0x00ff));
      66         800 : }
      67             : 
      68         811 : static inline void gst_swapbytes(void *value, int size)
      69             : {
      70         811 :     switch (size)
      71             :     {
      72           0 :         case 1:
      73             :             // do nothing
      74           0 :             break;
      75           0 :         case 2:
      76           0 :             gst_swap16(value);
      77           0 :             break;
      78         705 :         case 4:
      79         705 :             gst_swap32(value);
      80         705 :             break;
      81         106 :         case 8:
      82         106 :             gst_swap64(value);
      83         106 :             break;
      84           0 :         default:
      85           0 :             fprintf(stderr,
      86             :                     "gst_swapbytes unsupported size %i - not swapping\n", size);
      87           0 :             break;
      88             :     }  // switch
      89         811 : }
      90             : 
      91             : #define gst_swapb(value) gst_swapbytes(&value, sizeof(value))
      92             : 
      93             : #else  // swapping
      94             : 
      95             : #define swapped_fread(ptr, size, nitems, stream)                               \
      96             :     fread(ptr, size, nitems, stream)
      97             : #define swapped_fwrite(ptr, size, nitems, stream)                              \
      98             :     fwrite(ptr, size, nitems, stream)
      99             : 
     100             : #define gst_swap64(value)
     101             : #define gst_swap32(value)
     102             : #define gst_swap16(value)
     103             : #define gst_swapbytes(value, size)
     104             : #define gst_swapb(value)
     105             : 
     106             : #endif  // swapping
     107             : 
     108             : }  // namespace gstEndian
     109             : 
     110             : #endif  // ! gstEndian_h_