diff options
Diffstat (limited to 'system_wrappers/source/sort.cc')
| -rw-r--r-- | system_wrappers/source/sort.cc | 176 |
1 files changed, 88 insertions, 88 deletions
diff --git a/system_wrappers/source/sort.cc b/system_wrappers/source/sort.cc index 0bf80072..4aa181fd 100644 --- a/system_wrappers/source/sort.cc +++ b/system_wrappers/source/sort.cc @@ -59,7 +59,7 @@ #define KEY_QSORT(SORT_KEY, KEY, NUM_OF_ELEMENTS, KEY_TYPE, COMPARE_FUNC) \ do { \ KEY_TYPE* key_type = (KEY_TYPE*)(key); \ - for (WebRtc_UWord32 i = 0; i < (NUM_OF_ELEMENTS); ++i) { \ + for (uint32_t i = 0; i < (NUM_OF_ELEMENTS); ++i) { \ ptr_sort_key[i].key_ = &key_type[i]; \ ptr_sort_key[i].index_ = i; \ } \ @@ -72,13 +72,13 @@ namespace webrtc { #ifdef NO_STL struct SortKey { void* key_; - WebRtc_UWord32 index_; + uint32_t index_; }; #else template<typename KeyType> struct SortKey { KeyType key_; - WebRtc_UWord32 index_; + uint32_t index_; }; #endif @@ -86,35 +86,35 @@ namespace { // Unnamed namespace provides internal linkage. #ifdef NO_STL int CompareWord8(const void* x, const void* y) { - COMPARE_FOR_QSORT(x, y, WebRtc_Word8); + COMPARE_FOR_QSORT(x, y, int8_t); } int CompareUWord8(const void* x, const void* y) { - COMPARE_FOR_QSORT(x, y, WebRtc_UWord8); + COMPARE_FOR_QSORT(x, y, uint8_t); } int CompareWord16(const void* x, const void* y) { - COMPARE_FOR_QSORT(x, y, WebRtc_Word16); + COMPARE_FOR_QSORT(x, y, int16_t); } int CompareUWord16(const void* x, const void* y) { - COMPARE_FOR_QSORT(x, y, WebRtc_UWord16); + COMPARE_FOR_QSORT(x, y, uint16_t); } int CompareWord32(const void* x, const void* y) { - COMPARE_FOR_QSORT(x, y, WebRtc_Word32); + COMPARE_FOR_QSORT(x, y, int32_t); } int CompareUWord32(const void* x, const void* y) { - COMPARE_FOR_QSORT(x, y, WebRtc_UWord32); + COMPARE_FOR_QSORT(x, y, uint32_t); } int CompareWord64(const void* x, const void* y) { - COMPARE_FOR_QSORT(x, y, WebRtc_Word64); + COMPARE_FOR_QSORT(x, y, int64_t); } int CompareUWord64(const void* x, const void* y) { - COMPARE_FOR_QSORT(x, y, WebRtc_UWord64); + COMPARE_FOR_QSORT(x, y, uint64_t); } int CompareFloat32(const void* x, const void* y) { @@ -126,35 +126,35 @@ int CompareFloat64(const void* x, const void* y) { } int CompareKeyWord8(const void* sort_key_x, const void* sort_key_y) { - COMPARE_KEY_FOR_QSORT(sort_key_x, sort_key_y, WebRtc_Word8); + COMPARE_KEY_FOR_QSORT(sort_key_x, sort_key_y, int8_t); } int CompareKeyUWord8(const void* sort_key_x, const void* sort_key_y) { - COMPARE_KEY_FOR_QSORT(sort_key_x, sort_key_y, WebRtc_UWord8); + COMPARE_KEY_FOR_QSORT(sort_key_x, sort_key_y, uint8_t); } int CompareKeyWord16(const void* sort_key_x, const void* sort_key_y) { - COMPARE_KEY_FOR_QSORT(sort_key_x, sort_key_y, WebRtc_Word16); + COMPARE_KEY_FOR_QSORT(sort_key_x, sort_key_y, int16_t); } int CompareKeyUWord16(const void* sort_key_x, const void* sort_key_y) { - COMPARE_KEY_FOR_QSORT(sort_key_x, sort_key_y, WebRtc_UWord16); + COMPARE_KEY_FOR_QSORT(sort_key_x, sort_key_y, uint16_t); } int CompareKeyWord32(const void* sort_key_x, const void* sort_key_y) { - COMPARE_KEY_FOR_QSORT(sort_key_x, sort_key_y, WebRtc_Word32); + COMPARE_KEY_FOR_QSORT(sort_key_x, sort_key_y, int32_t); } int CompareKeyUWord32(const void* sort_key_x, const void* sort_key_y) { - COMPARE_KEY_FOR_QSORT(sort_key_x, sort_key_y, WebRtc_UWord32); + COMPARE_KEY_FOR_QSORT(sort_key_x, sort_key_y, uint32_t); } int CompareKeyWord64(const void* sort_key_x, const void* sort_key_y) { - COMPARE_KEY_FOR_QSORT(sort_key_x, sort_key_y, WebRtc_Word64); + COMPARE_KEY_FOR_QSORT(sort_key_x, sort_key_y, int64_t); } int CompareKeyUWord64(const void* sort_key_x, const void* sort_key_y) { - COMPARE_KEY_FOR_QSORT(sort_key_x, sort_key_y, WebRtc_UWord64); + COMPARE_KEY_FOR_QSORT(sort_key_x, sort_key_y, uint64_t); } int CompareKeyFloat32(const void* sort_key_x, const void* sort_key_y) { @@ -182,35 +182,35 @@ struct KeyRightShift { }; template <typename DataType> -inline void IntegerSort(void* data, WebRtc_UWord32 num_of_elements) { +inline void IntegerSort(void* data, uint32_t num_of_elements) { DataType* data_type = static_cast<DataType*>(data); boost::integer_sort(data_type, data_type + num_of_elements); } template <typename DataType, typename IntegerType> -inline void FloatSort(void* data, WebRtc_UWord32 num_of_elements) { +inline void FloatSort(void* data, uint32_t num_of_elements) { DataType* data_type = static_cast<DataType*>(data); IntegerType c_val = 0; boost::float_sort_cast(data_type, data_type + num_of_elements, c_val); } template <typename DataType> -inline void StdSort(void* data, WebRtc_UWord32 num_of_elements) { +inline void StdSort(void* data, uint32_t num_of_elements) { DataType* data_type = static_cast<DataType*>(data); std::sort(data_type, data_type + num_of_elements); } template<typename KeyType> -inline WebRtc_Word32 SetupKeySort(void* key, - SortKey<KeyType>*& ptr_sort_key, - WebRtc_UWord32 num_of_elements) { +inline int32_t SetupKeySort(void* key, + SortKey<KeyType>*& ptr_sort_key, + uint32_t num_of_elements) { ptr_sort_key = new(std::nothrow) SortKey<KeyType>[num_of_elements]; if (ptr_sort_key == NULL) { return -1; } KeyType* key_type = static_cast<KeyType*>(key); - for (WebRtc_UWord32 i = 0; i < num_of_elements; i++) { + for (uint32_t i = 0; i < num_of_elements; i++) { ptr_sort_key[i].key_ = key_type[i]; ptr_sort_key[i].index_ = i; } @@ -219,18 +219,18 @@ inline WebRtc_Word32 SetupKeySort(void* key, } template<typename KeyType> -inline WebRtc_Word32 TeardownKeySort(void* data, - SortKey<KeyType>* ptr_sort_key, - WebRtc_UWord32 num_of_elements, - WebRtc_UWord32 size_of_element) { - WebRtc_UWord8* ptr_data = static_cast<WebRtc_UWord8*>(data); - WebRtc_UWord8* ptr_data_sorted = - new(std::nothrow) WebRtc_UWord8[num_of_elements * size_of_element]; +inline int32_t TeardownKeySort(void* data, + SortKey<KeyType>* ptr_sort_key, + uint32_t num_of_elements, + uint32_t size_of_element) { + uint8_t* ptr_data = static_cast<uint8_t*>(data); + uint8_t* ptr_data_sorted = + new(std::nothrow) uint8_t[num_of_elements * size_of_element]; if (ptr_data_sorted == NULL) { return -1; } - for (WebRtc_UWord32 i = 0; i < num_of_elements; i++) { + for (uint32_t i = 0; i < num_of_elements; i++) { memcpy(ptr_data_sorted + i * size_of_element, ptr_data + ptr_sort_key[i].index_ * size_of_element, size_of_element); } @@ -241,9 +241,9 @@ inline WebRtc_Word32 TeardownKeySort(void* data, } template<typename KeyType> -inline WebRtc_Word32 IntegerKeySort(void* data, void* key, - WebRtc_UWord32 num_of_elements, - WebRtc_UWord32 size_of_element) { +inline int32_t IntegerKeySort(void* data, void* key, + uint32_t num_of_elements, + uint32_t size_of_element) { SortKey<KeyType>* ptr_sort_key; if (SetupKeySort<KeyType>(key, ptr_sort_key, num_of_elements) != 0) { return -1; @@ -261,9 +261,9 @@ inline WebRtc_Word32 IntegerKeySort(void* data, void* key, } template<typename KeyType> -inline WebRtc_Word32 StdKeySort(void* data, void* key, - WebRtc_UWord32 num_of_elements, - WebRtc_UWord32 size_of_element) { +inline int32_t StdKeySort(void* data, void* key, + uint32_t num_of_elements, + uint32_t size_of_element) { SortKey<KeyType>* ptr_sort_key; if (SetupKeySort<KeyType>(key, ptr_sort_key, num_of_elements) != 0) { return -1; @@ -282,7 +282,7 @@ inline WebRtc_Word32 StdKeySort(void* data, void* key, #endif } -WebRtc_Word32 Sort(void* data, WebRtc_UWord32 num_of_elements, Type type) { +int32_t Sort(void* data, uint32_t num_of_elements, Type type) { if (data == NULL) { return -1; } @@ -290,28 +290,28 @@ WebRtc_Word32 Sort(void* data, WebRtc_UWord32 num_of_elements, Type type) { #ifdef NO_STL switch (type) { case TYPE_Word8: - qsort(data, num_of_elements, sizeof(WebRtc_Word8), CompareWord8); + qsort(data, num_of_elements, sizeof(int8_t), CompareWord8); break; case TYPE_UWord8: - qsort(data, num_of_elements, sizeof(WebRtc_UWord8), CompareUWord8); + qsort(data, num_of_elements, sizeof(uint8_t), CompareUWord8); break; case TYPE_Word16: - qsort(data, num_of_elements, sizeof(WebRtc_Word16), CompareWord16); + qsort(data, num_of_elements, sizeof(int16_t), CompareWord16); break; case TYPE_UWord16: - qsort(data, num_of_elements, sizeof(WebRtc_UWord16), CompareUWord16); + qsort(data, num_of_elements, sizeof(uint16_t), CompareUWord16); break; case TYPE_Word32: - qsort(data, num_of_elements, sizeof(WebRtc_Word32), CompareWord32); + qsort(data, num_of_elements, sizeof(int32_t), CompareWord32); break; case TYPE_UWord32: - qsort(data, num_of_elements, sizeof(WebRtc_UWord32), CompareUWord32); + qsort(data, num_of_elements, sizeof(uint32_t), CompareUWord32); break; case TYPE_Word64: - qsort(data, num_of_elements, sizeof(WebRtc_Word64), CompareWord64); + qsort(data, num_of_elements, sizeof(int64_t), CompareWord64); break; case TYPE_UWord64: - qsort(data, num_of_elements, sizeof(WebRtc_UWord64), CompareUWord64); + qsort(data, num_of_elements, sizeof(uint64_t), CompareUWord64); break; case TYPE_Float32: qsort(data, num_of_elements, sizeof(float), CompareFloat32); @@ -327,28 +327,28 @@ WebRtc_Word32 Sort(void* data, WebRtc_UWord32 num_of_elements, Type type) { // warnings and VS 2003 build crashes respectively with spreadsort. switch (type) { case TYPE_Word8: - IntegerSort<WebRtc_Word8>(data, num_of_elements); + IntegerSort<int8_t>(data, num_of_elements); break; case TYPE_UWord8: - IntegerSort<WebRtc_UWord8>(data, num_of_elements); + IntegerSort<uint8_t>(data, num_of_elements); break; case TYPE_Word16: - IntegerSort<WebRtc_Word16>(data, num_of_elements); + IntegerSort<int16_t>(data, num_of_elements); break; case TYPE_UWord16: - IntegerSort<WebRtc_UWord16>(data, num_of_elements); + IntegerSort<uint16_t>(data, num_of_elements); break; case TYPE_Word32: - IntegerSort<WebRtc_Word32>(data, num_of_elements); + IntegerSort<int32_t>(data, num_of_elements); break; case TYPE_UWord32: - IntegerSort<WebRtc_UWord32>(data, num_of_elements); + IntegerSort<uint32_t>(data, num_of_elements); break; case TYPE_Word64: - StdSort<WebRtc_Word64>(data, num_of_elements); + StdSort<int64_t>(data, num_of_elements); break; case TYPE_UWord64: - StdSort<WebRtc_UWord64>(data, num_of_elements); + StdSort<uint64_t>(data, num_of_elements); break; case TYPE_Float32: StdSort<float>(data, num_of_elements); @@ -361,8 +361,8 @@ WebRtc_Word32 Sort(void* data, WebRtc_UWord32 num_of_elements, Type type) { return 0; } -WebRtc_Word32 KeySort(void* data, void* key, WebRtc_UWord32 num_of_elements, - WebRtc_UWord32 size_of_element, Type key_type) { +int32_t KeySort(void* data, void* key, uint32_t num_of_elements, + uint32_t size_of_element, Type key_type) { if (data == NULL) { return -1; } @@ -371,7 +371,7 @@ WebRtc_Word32 KeySort(void* data, void* key, WebRtc_UWord32 num_of_elements, return -1; } - if ((WebRtc_UWord64)num_of_elements * size_of_element > 0xffffffff) { + if ((uint64_t)num_of_elements * size_of_element > 0xffffffff) { return -1; } @@ -383,35 +383,35 @@ WebRtc_Word32 KeySort(void* data, void* key, WebRtc_UWord32 num_of_elements, switch (key_type) { case TYPE_Word8: - KEY_QSORT(ptr_sort_key, key, num_of_elements, WebRtc_Word8, + KEY_QSORT(ptr_sort_key, key, num_of_elements, int8_t, CompareKeyWord8); break; case TYPE_UWord8: - KEY_QSORT(ptr_sort_key, key, num_of_elements, WebRtc_UWord8, + KEY_QSORT(ptr_sort_key, key, num_of_elements, uint8_t, CompareKeyUWord8); break; case TYPE_Word16: - KEY_QSORT(ptr_sort_key, key, num_of_elements, WebRtc_Word16, + KEY_QSORT(ptr_sort_key, key, num_of_elements, int16_t, CompareKeyWord16); break; case TYPE_UWord16: - KEY_QSORT(ptr_sort_key, key, num_of_elements, WebRtc_UWord16, + KEY_QSORT(ptr_sort_key, key, num_of_elements, uint16_t, CompareKeyUWord16); break; case TYPE_Word32: - KEY_QSORT(ptr_sort_key, key, num_of_elements, WebRtc_Word32, + KEY_QSORT(ptr_sort_key, key, num_of_elements, int32_t, CompareKeyWord32); break; case TYPE_UWord32: - KEY_QSORT(ptr_sort_key, key, num_of_elements, WebRtc_UWord32, + KEY_QSORT(ptr_sort_key, key, num_of_elements, uint32_t, CompareKeyUWord32); break; case TYPE_Word64: - KEY_QSORT(ptr_sort_key, key, num_of_elements, WebRtc_Word64, + KEY_QSORT(ptr_sort_key, key, num_of_elements, int64_t, CompareKeyWord64); break; case TYPE_UWord64: - KEY_QSORT(ptr_sort_key, key, num_of_elements, WebRtc_UWord64, + KEY_QSORT(ptr_sort_key, key, num_of_elements, uint64_t, CompareKeyUWord64); break; case TYPE_Float32: @@ -427,14 +427,14 @@ WebRtc_Word32 KeySort(void* data, void* key, WebRtc_UWord32 num_of_elements, } // Shuffle into sorted position based on index map. - WebRtc_UWord8* ptr_data = static_cast<WebRtc_UWord8*>(data); - WebRtc_UWord8* ptr_data_sorted = - new(std::nothrow) WebRtc_UWord8[num_of_elements * size_of_element]; + uint8_t* ptr_data = static_cast<uint8_t*>(data); + uint8_t* ptr_data_sorted = + new(std::nothrow) uint8_t[num_of_elements * size_of_element]; if (ptr_data_sorted == NULL) { return -1; } - for (WebRtc_UWord32 i = 0; i < num_of_elements; i++) { + for (uint32_t i = 0; i < num_of_elements; i++) { memcpy(ptr_data_sorted + i * size_of_element, ptr_data + ptr_sort_key[i].index_ * size_of_element, size_of_element); } @@ -449,29 +449,29 @@ WebRtc_Word32 KeySort(void* data, void* key, WebRtc_UWord32 num_of_elements, // warnings and errors respectively with spreadsort. switch (key_type) { case TYPE_Word8: - return IntegerKeySort<WebRtc_Word8>(data, key, num_of_elements, - size_of_element); + return IntegerKeySort<int8_t>(data, key, num_of_elements, + size_of_element); case TYPE_UWord8: - return IntegerKeySort<WebRtc_UWord8>(data, key, num_of_elements, - size_of_element); + return IntegerKeySort<uint8_t>(data, key, num_of_elements, + size_of_element); case TYPE_Word16: - return IntegerKeySort<WebRtc_Word16>(data, key, num_of_elements, - size_of_element); + return IntegerKeySort<int16_t>(data, key, num_of_elements, + size_of_element); case TYPE_UWord16: - return IntegerKeySort<WebRtc_UWord16>(data, key, num_of_elements, - size_of_element); + return IntegerKeySort<uint16_t>(data, key, num_of_elements, + size_of_element); case TYPE_Word32: - return IntegerKeySort<WebRtc_Word32>(data, key, num_of_elements, - size_of_element); + return IntegerKeySort<int32_t>(data, key, num_of_elements, + size_of_element); case TYPE_UWord32: - return IntegerKeySort<WebRtc_UWord32>(data, key, num_of_elements, - size_of_element); + return IntegerKeySort<uint32_t>(data, key, num_of_elements, + size_of_element); case TYPE_Word64: - return StdKeySort<WebRtc_Word64>(data, key, num_of_elements, - size_of_element); + return StdKeySort<int64_t>(data, key, num_of_elements, + size_of_element); case TYPE_UWord64: - return StdKeySort<WebRtc_UWord64>(data, key, num_of_elements, - size_of_element); + return StdKeySort<uint64_t>(data, key, num_of_elements, + size_of_element); case TYPE_Float32: return StdKeySort<float>(data, key, num_of_elements, size_of_element); case TYPE_Float64: |