u8_to_mb: pass through the u8 str if term is UTF-8

In POSIX systems, if setlocale(LC_CTYPE, "") returns string ending with
'.UTF-8', we assume that UTF-8 can be displayed safely. In Windows,
assume this in Windows Terminal and MSYS window now (didn't find a
reliable way to do this eg. over SSH).

Do not expect c8rtomb on MSW (not present now, anyways) - it is a bit
dubious whether it will work even so (will need to be tested).

+ [minor] handle when implementation has MB_LEN_MAX==1 and buffer not long
enough (do not fail on assert because the `if` was entered with buflen==0)

Author: MartinPulec

configure.ac

@@ -432,7 +432,9 @@ AC_CHECK_LIB(rt, timer_create)
 AC_CHECK_FUNC(sin, MATHLIBS="", MATHLIBS="-lm")
 AC_SUBST(MATHLIBS)
 
-AC_CHECK_FUNCS(c8rtomb)
+if test "$system" != "Windows"; then
+        AC_CHECK_FUNCS(c8rtomb)
+fi
 
 # -------------------------------------------------------------------------------------------------
 # See if this system supports sched_setscheduler()

src/audio/capture/coreaudio.m

@@ -57,6 +57,7 @@
 #include "utils/macros.h"
 #include "utils/pthread.h"              // for CHK_PTHR
 #include "utils/ring_buffer.h"
+#include "utils/text.h"        // for c8_to_mb
 
 #define MOD_NAME "[CoreAudio cap.] "
 
@@ -390,9 +391,11 @@ static void (^cb)(BOOL) = ^void(BOOL granted) {
         } while(0);
 
         if (!failed) {
-                // c8rtomb not yet supported on mac - pass the str through
-                color_printf((const char *) u8"🔴 " MOD_NAME TBOLD(TYELLOW("This application"
-                             " is capturing computer audio.")) "\n");
+                char rec_fallb_sym[128] = TBOLD(TRED("(RECORDING)"));
+                const char *rec_sym = c8_to_mb(u8"🔴", sizeof rec_fallb_sym,
+                                               rec_fallb_sym);
+                color_printf("%s " MOD_NAME TBOLD(TYELLOW("This application"
+                             " is capturing computer audio.")) "\n", rec_sym);
                 return s;
         }
 

src/blackmagic_common.cpp

@@ -1739,8 +1739,8 @@ class BMDNotificationCallback : public IDeckLinkNotificationCallback
                 // check overheating
                 if (cur_temp >= m_tempThresholdErr) {
                         char  deg_fallb_sym[128] = "deg ";
-                        char *deg_sym = c8_to_mb(u8"°", sizeof deg_fallb_sym,
-                                                 deg_fallb_sym);
+                        const char *deg_sym            = c8_to_mb(
+                            u8"°", sizeof deg_fallb_sym, deg_fallb_sym);
                         log_msg(LOG_LEVEL_ERROR,
                                 "%sDevice is overheating! The temperature is "
                                 "%" PRId64 " %sC.\n",

src/host.cpp

@@ -544,6 +544,7 @@ struct init_data *common_preinit(int argc, char *argv[])
 #endif
 
         struct init_data init{};
+        bool is_win_utf8_terminal = false;
 #ifdef _WIN32
         WSADATA wsaData;
         int err = WSAStartup(MAKEWORD(2, 2), &wsaData);
@@ -578,8 +579,12 @@ struct init_data *common_preinit(int argc, char *argv[])
                              "consider using Windows Terminal instead!\n");
                 Sleep(1000);
         }
+        is_win_utf8_terminal = (getenv("TERM") == nullptr &&
+                          _isatty(fileno(stdout)) &&
+                          win_has_ancestor_process("WindowsTerminal.exe"))
+                || isMsysPty(fileno(stdout));
 #endif
-        u8_to_mb_init(); // setlocale(LC_CTYPE, "");
+        u8_to_mb_init(is_win_utf8_terminal); // setlocale(LC_CTYPE, "");
 
         if (strstr(argv[0], "run_tests") == nullptr) {
                 open_all("ultragrid_*.so", init.opened_libs); // load modules

src/ndi_common.h

@@ -167,7 +167,7 @@ static inline void
 ndi_print_copyright()
 {
         char r_fallb_sym[128] = "(r)";
-        char *reg_sym = c8_to_mb(u8"®", sizeof r_fallb_sym, r_fallb_sym);
+        const char *reg_sym = c8_to_mb(u8"®", sizeof r_fallb_sym, r_fallb_sym);
 
         color_printf(TERM_BOLD TERM_FG_BLUE
                      "This application uses NDI%s available "

src/utils/color_out.c

@@ -73,9 +73,13 @@ static bool setWinTermAnsiColors(DWORD stream) {
         }
         return true;
 }
+#endif // defined _WIN32
 
 /// Taken from [rang](https://github.com/agauniyal/rang)
-static bool isMsysPty(int fd) {
+bool
+isMsysPty(int fd)
+{
+#ifdef _WIN32
         // Dynamic load for binary compatibility with old Windows
         BOOL (*ptrGetFileInformationByHandleEx)(
             HANDLE hFile, FILE_INFO_BY_HANDLE_CLASS FileInformationClass,
@@ -120,8 +124,11 @@ static bool isMsysPty(int fd) {
         }
 
         return true;
+#else
+        (void) fd;
+        return false;
+#endif
 }
-#endif // defined _WIN32
 
 ADD_TO_PARAM("log-color", "* log-color[=no]\n"
                  "  Force enable/disable ANSI text formatting.\n");

src/utils/color_out.h

@@ -98,6 +98,7 @@
 extern "C" {
 #endif
 
+bool isMsysPty(int fd);
 bool color_output_init(void);
 [[gnu::format(printf, 1, 2)]] int color_printf(const char *format, ...);
 

src/utils/text.c

@@ -44,12 +44,12 @@
 #include <assert.h>             // for assert
 #include <ctype.h>              // for isalnum
 #include <limits.h>             // for INT_MAX, PATH_MAX
+#include <locale.h>             // for setlocale
 #include <stdio.h>              // for fclose, fwrite, rewind, sprintf, sscanf
 #include <stdlib.h>             // for getenv, malloc, free, realloc
 #include <string.h>             // for memcpy, strlen, strpbrk
 #include <unistd.h>             // for unlink
 #ifdef HAVE_C8RTOMB
-#include <locale.h>             // for setlocale
 #include <uchar.h>              // for c8rtomb
 #endif
 
@@ -431,45 +431,43 @@ get_font_candidates()
         return ret;
 }
 
+static bool utf8_terminal = false;
 void
-u8_to_mb_init()
+u8_to_mb_init(bool is_win_utf8_terminal)
 {
-#ifdef HAVE_C8RTOMB
-        #ifndef __linux__
-                #warning "c8rtomb tested just in Linux - please check..."
-        #endif
+#ifdef _WIN32
+        utf8_terminal = is_win_utf8_terminal;
+#else
         const char *lc_ctype = setlocale(LC_CTYPE, "");
         if (lc_ctype == nullptr) {
                 MSG(WARNING, "Cannot set locale.");
         } else {
                 MSG(DEBUG, "LC_CTYPE set to: %s\n", lc_ctype);
+                utf8_terminal = strstr(lc_ctype, ".UTF-8") != nullptr;
         }
+        (void) is_win_utf8_terminal;
 #endif
 }
 
 /**
- * Tries to convert utf-8 string to locale-specific multibyte string or returns
- * fallback.
+ * Tries to convert utf-8 string to locale-specific multibyte string. If
+ * c8rtomb not present and UTF-8 terminal detected, copies the UTF-8 string.
+ * Otherwise, out_fallback is kept untouched (should contain fallback text).
  *
  * @param buflen  out_fallback buffer length long enough to hold the converted
                   string with some headroom (MB_LEN_MAX-1)
  * @param[in,out] out_fallback NUL-terminated fallback string. If conversion
  *                succeeds, it is rewritten by the u8_str converted to MBS
- * @returns out_fallback. If u8_str not convertible (eg. terminal in ASCII),
- * the content of out_fallback is returned unchanged (so that it should contain
- * the fallback and in any case it must be NULL-terminated).
- *
- * u8_to_mb_init() must be called otherwise conv never suceeds and fallback ret
+ * @returns out_fallback with converted data if we have c8rtomb
+ * @returns u8_str if it is safe to pass-through
+ * @returns out_fallback unchanged if u8_str not convertible and terminal not in UTF-8
  *
- * This is the correct way to output UTF-8, but at this time, c8rtomb is not yet
- * widely supported so if it is impotant that the u8_str is displayed and not the
- * fallback, prefer passing the UTF-8 string through. Also if is probable that
- * the term will likely to present the UTF-8 correcty. Most modern systems do.
+ * u8_to_mb_init() must be called otherwise fallback is always ret
  */
-char *
+const char *
 u8_to_mb(const unsigned char *u8_str, size_t buflen, char *out_fallback)
 {
-#ifdef HAVE_C8RTOMB
+#if defined HAVE_C8RTOMB && !defined _WIN32
         mbstate_t ps = { 0 };
         const char8_t *in_ptr = u8_str;
         // check convertibility first
@@ -484,7 +482,7 @@ u8_to_mb(const unsigned char *u8_str, size_t buflen, char *out_fallback)
         in_ptr = u8_str;
         char *out_ptr = out_fallback;
         do {
-                if (buflen < MB_LEN_MAX) {
+                if (buflen < MB_LEN_MAX || buflen == 1) {
                         MSG(WARNING, "utf-8 string truncated.\n");
                         assert(buflen >= 1);
                         *out_ptr = '\0';
@@ -495,8 +493,12 @@ u8_to_mb(const unsigned char *u8_str, size_t buflen, char *out_fallback)
                 out_ptr += ret;
                 buflen -= ret;
         } while (*in_ptr++ != '\0');
+        return out_fallback;
 #else
-        (void) u8_str, (void) buflen;
+        (void) buflen;
+        if (!utf8_terminal) {
+                return out_fallback;
+        }
+        return (const char *) u8_str;
 #endif
-        return out_fallback;
 }

src/utils/text.h

@@ -63,8 +63,9 @@ bool draw_line_scaled(char *buf, int pitch, const char *text, uint32_t fg,
 
 const char *const *get_font_candidates(void);
 
-void  u8_to_mb_init();
-char *u8_to_mb(const unsigned char *u8_str, size_t buflen, char *out_fallback);
+void        u8_to_mb_init(bool is_win_utf8_terminal);
+const char *u8_to_mb(const unsigned char *u8_str, size_t buflen,
+                     char *out_fallback);
 // convenience macro casting char8_t pointer to (const unsigned char *)
 #define c8_to_mb(c8_str, buflen, out_fallback)                                 \
         u8_to_mb((const unsigned char *) (c8_str), buflen, (out_fallback))

src/video_capture/avfoundation.mm

@@ -49,6 +49,7 @@
 #include "debug.h"
 #include "lib_common.h"
 #include "utils/color_out.h"
+#include "utils/text.h"      // for c8_to_mb
 #include "video.h"
 #include "video_capture.h"
 
@@ -800,9 +801,11 @@ static int vidcap_avfoundation_init(const struct vidcap_params *params, void **s
         if (!ret) {
                 return VIDCAP_INIT_FAIL;
         }
-        // c8rtomb not yet supported on mac - pass the str through
-        color_printf((const char *) u8"🔴 " MOD_NAME TBOLD(TYELLOW("This"
-                     " application is capturing computer video.")) "\n");
+        char rec_fallb_sym[128] = TBOLD(TRED("(RECORDING)"));
+        const char *rec_sym = c8_to_mb(u8"🔴", sizeof rec_fallb_sym,
+                                       rec_fallb_sym);
+        color_printf("%s " MOD_NAME TBOLD(TYELLOW("This"
+                     " application is capturing computer video.")) "\n", rec_sym);
         *state = ret;
         return VIDCAP_INIT_OK;
 }