DRG_sprout: Run clang-format treewide

Signed-off-by: BladeRunner-A2C <[email protected]>

Author: BladeRunner-A2C

.clang-format

@@ -0,0 +1,13 @@
+BasedOnStyle: Google
+Standard: Cpp11
+AccessModifierOffset: -2
+AllowShortFunctionsOnASingleLine: Inline
+ColumnLimit: 100
+CommentPragmas: NOLINT:.*
+DerivePointerAlignment: false
+IncludeBlocks: Preserve
+IndentWidth: 4
+ContinuationIndentWidth: 8
+PointerAlignment: Left
+TabWidth: 4
+UseTab: Never

camera/megvii_shim.cpp

@@ -15,5 +15,5 @@
  */
 
 namespace android {
-    extern "C" void mg_facepp() {}
-}
+extern "C" void mg_facepp() {}
+}  // namespace android

dpm/strdup16to8.cpp

@@ -25,8 +25,7 @@
  * Convert a UTF-16 string to UTF-8.
  *
  */
-char * strndup16to8 (const char16_t* s, size_t n)
-{
+char* strndup16to8(const char16_t* s, size_t n) {
     if (s == NULL) {
         return NULL;
     }
@@ -37,14 +36,12 @@ char * strndup16to8 (const char16_t* s, size_t n)
      * too since it is an overflow value for our
      * strnlen16to8 implementation.
      */
-    if (len >= SIZE_MAX-1)
-        return NULL;
+    if (len >= SIZE_MAX - 1) return NULL;
 
     char* ret = static_cast<char*>(malloc(len + 1));
-    if (ret == NULL)
-        return NULL;
+    if (ret == NULL) return NULL;
 
-    strncpy16to8 (ret, s, n);
+    strncpy16to8(ret, s, n);
 
     return ret;
 }
@@ -53,8 +50,7 @@ char * strndup16to8 (const char16_t* s, size_t n)
  * Given a UTF-16 string, compute the length of the corresponding UTF-8
  * string in bytes.
  */
-extern size_t strnlen16to8(const char16_t* utf16Str, size_t len)
-{
+extern size_t strnlen16to8(const char16_t* utf16Str, size_t len) {
     size_t utf8Len = 0;
 
     /* A small note on integer overflow. The result can
@@ -81,7 +77,7 @@ extern size_t strnlen16to8(const char16_t* utf16Str, size_t len)
 
     /* Fast path for the usual case where 3*len is < SIZE_MAX-1.
      */
-    if (len < (SIZE_MAX-1)/3) {
+    if (len < (SIZE_MAX - 1) / 3) {
         while (len != 0) {
             len--;
             unsigned int uic = *utf16Str++;
@@ -99,8 +95,8 @@ extern size_t strnlen16to8(const char16_t* utf16Str, size_t len)
     /* The slower but paranoid version */
     while (len != 0) {
         len--;
-        unsigned int  uic     = *utf16Str++;
-        size_t        utf8Cur = utf8Len;
+        unsigned int uic = *utf16Str++;
+        size_t utf8Cur = utf8Len;
 
         if (uic > 0x07ff)
             utf8Len += 3;
@@ -110,17 +106,15 @@ extern size_t strnlen16to8(const char16_t* utf16Str, size_t len)
             utf8Len++;
 
         if (utf8Len < utf8Cur) /* overflow detected */
-            return SIZE_MAX-1;
+            return SIZE_MAX - 1;
     }
 
     /* don't return SIZE_MAX to avoid common user bug */
-    if (utf8Len == SIZE_MAX)
-        utf8Len = SIZE_MAX-1;
+    if (utf8Len == SIZE_MAX) utf8Len = SIZE_MAX - 1;
 
     return utf8Len;
 }
 
-
 /**
  * Convert a Java-Style UTF-16 string + length to a JNI-Style UTF-8 string.
  *
@@ -133,8 +127,7 @@ extern size_t strnlen16to8(const char16_t* utf16Str, size_t len)
  * Please note, a terminated \0 is always added, so your result will always
  * be "strlen16to8() + 1" bytes long.
  */
-extern char* strncpy16to8(char* utf8Str, const char16_t* utf16Str, size_t len)
-{
+extern char* strncpy16to8(char* utf8Str, const char16_t* utf16Str, size_t len) {
     char* utf8cur = utf8Str;
 
     /* Note on overflows: We assume the user did check the result of
@@ -161,7 +154,7 @@ extern char* strncpy16to8(char* utf8Str, const char16_t* utf16Str, size_t len)
         }
     }
 
-   *utf8cur = '\0';
+    *utf8cur = '\0';
 
-   return utf8Str;
+    return utf8Str;
 }

dpm/strdup8to16.cpp

@@ -31,8 +31,9 @@
 #define UTF8_SEQ_LENGTH(ch) (((0xe5000000 >> (((ch) >> 3) & 0x1e)) & 3) + 1)
 
 /* note: macro expands to multiple lines */
-#define UTF8_SHIFT_AND_MASK(unicode, byte)  \
-            (unicode)<<=6; (unicode) |= (0x3f & (byte));
+#define UTF8_SHIFT_AND_MASK(unicode, byte) \
+    (unicode) <<= 6;                       \
+    (unicode) |= (0x3f & (byte));
 
 #define UNICODE_UPPER_LIMIT 0x10fffd
 
@@ -41,23 +42,21 @@
  * length of the UTF-16 string (which may contain embedded \0's)
  */
 
-extern char16_t * strdup8to16 (const char* s, size_t *out_len)
-{
-    char16_t *ret;
+extern char16_t* strdup8to16(const char* s, size_t* out_len) {
+    char16_t* ret;
     size_t len;
 
     if (s == NULL) return NULL;
 
     len = strlen8to16(s);
 
     // fail on overflow
-    if (len && SIZE_MAX/len < sizeof(char16_t))
-        return NULL;
+    if (len && SIZE_MAX / len < sizeof(char16_t)) return NULL;
 
     // no plus-one here. UTF-16 strings are not null terminated
-    ret = (char16_t *) malloc (sizeof(char16_t) * len);
+    ret = (char16_t*)malloc(sizeof(char16_t) * len);
 
-    return strcpy8to16 (ret, s, out_len);
+    return strcpy8to16(ret, s, out_len);
 }
 
 /**
@@ -66,8 +65,7 @@ extern char16_t * strdup8to16 (const char* s, size_t *out_len)
  * The value returned is the number of UTF-16 characters required
  * to represent this string.
  */
-extern size_t strlen8to16 (const char* utf8Str)
-{
+extern size_t strlen8to16(const char* utf8Str) {
     size_t len = 0;
     int ic;
     int expected = 0;
@@ -99,8 +97,6 @@ extern size_t strlen8to16 (const char* utf8Str)
     return len;
 }
 
-
-
 /*
  * Retrieve the next UTF-32 character from a UTF-8 string.
  *
@@ -110,8 +106,7 @@ extern size_t strlen8to16 (const char* utf8Str)
  *
  * Advances "*pUtf8Ptr" to the start of the next character.
  */
-static inline uint32_t getUtf32FromUtf8(const char** pUtf8Ptr)
-{
+static inline uint32_t getUtf32FromUtf8(const char** pUtf8Ptr) {
     uint32_t ret;
     int seq_len;
     int i;
@@ -128,12 +123,12 @@ static inline uint32_t getUtf32FromUtf8(const char** pUtf8Ptr)
     /* note we tolerate invalid leader 11111xxx here */
     seq_len = UTF8_SEQ_LENGTH(**pUtf8Ptr);
 
-    ret = (**pUtf8Ptr) & leaderMask [seq_len - 1];
+    ret = (**pUtf8Ptr) & leaderMask[seq_len - 1];
 
     if (**pUtf8Ptr == '\0') return ret;
 
     (*pUtf8Ptr)++;
-    for (i = 1; i < seq_len ; i++, (*pUtf8Ptr)++) {
+    for (i = 1; i < seq_len; i++, (*pUtf8Ptr)++) {
         if ((**pUtf8Ptr) == '\0') return UTF16_REPLACEMENT_CHAR;
         if (((**pUtf8Ptr) & 0xc0) != 0x80) return UTF16_REPLACEMENT_CHAR;
 
@@ -143,30 +138,29 @@ static inline uint32_t getUtf32FromUtf8(const char** pUtf8Ptr)
     return ret;
 }
 
-
 /**
  * out_len is an out parameter (which may not be null) containing the
  * length of the UTF-16 string (which may contain embedded \0's)
  */
 
-extern char16_t * strcpy8to16 (char16_t *utf16Str, const char*utf8Str,
-                                       size_t *out_len)
-{
-    char16_t *dest = utf16Str;
+extern char16_t* strcpy8to16(char16_t* utf16Str, const char* utf8Str, size_t* out_len) {
+    char16_t* dest = utf16Str;
 
     while (*utf8Str != '\0') {
         uint32_t ret;
 
         ret = getUtf32FromUtf8(&utf8Str);
 
         if (ret <= 0xffff) {
-            *dest++ = (char16_t) ret;
-        } else if (ret <= UNICODE_UPPER_LIMIT)  {
+            *dest++ = (char16_t)ret;
+        } else if (ret <= UNICODE_UPPER_LIMIT) {
             /* Create surrogate pairs */
-            /* See http://en.wikipedia.org/wiki/UTF-16/UCS-2#Method_for_code_points_in_Plane_1.2C_Plane_2 */
+            /* See
+             * http://en.wikipedia.org/wiki/UTF-16/UCS-2#Method_for_code_points_in_Plane_1.2C_Plane_2
+             */
 
             *dest++ = 0xd800 | ((ret - 0x10000) >> 10);
-            *dest++ = 0xdc00 | ((ret - 0x10000) &  0x3ff);
+            *dest++ = 0xdc00 | ((ret - 0x10000) & 0x3ff);
         } else {
             *dest++ = UTF16_REPLACEMENT_CHAR;
         }