ffmpeg_compat.h

Go to the documentation of this file.

 
#pragma once
 
#ifdef NXDK
 
  #include <errno.h>
  #include <stdarg.h>
  #include <stddef.h>
  #include <stdint.h>
  #include <stdio.h>
  #include <string.h>
  #include <sys/types.h>
  #include <wchar.h>
 
  #ifdef __cplusplus
extern "C" {
  #endif
 
  #ifndef ENOSYS
    #define ENOSYS 38
  #endif
 
  #ifndef O_BINARY
    #define O_BINARY 0
  #endif
 
  #ifndef F_SETFD
    #define F_SETFD 2
  #endif
 
  #ifndef FD_CLOEXEC
    #define FD_CLOEXEC 1
  #endif
 
  #ifndef CP_ACP
    #define CP_ACP 0U
  #endif
 
  #ifndef CP_UTF8
    #define CP_UTF8 65001U
  #endif
 
  #ifndef MB_ERR_INVALID_CHARS
    #define MB_ERR_INVALID_CHARS 0x00000008UL
  #endif
 
  #ifndef WC_ERR_INVALID_CHARS
    #define WC_ERR_INVALID_CHARS 0x00000080UL
  #endif
 
  #define access moonlight_nxdk_ffmpeg_access
  #define close moonlight_nxdk_ffmpeg_close
  #define fcntl moonlight_nxdk_ffmpeg_fcntl
  #define fdopen moonlight_nxdk_ffmpeg_fdopen
  #define isatty moonlight_nxdk_ffmpeg_isatty
  #define GetFullPathNameW moonlight_nxdk_ffmpeg_GetFullPathNameW
  #define mkstemp moonlight_nxdk_ffmpeg_mkstemp
  #define MultiByteToWideChar moonlight_nxdk_ffmpeg_MultiByteToWideChar
  #define open moonlight_nxdk_ffmpeg_open
  #define strerror_r moonlight_nxdk_ffmpeg_strerror_r
  #define tempnam moonlight_nxdk_ffmpeg_tempnam
  #define usleep moonlight_nxdk_ffmpeg_usleep
  #define WideCharToMultiByte moonlight_nxdk_ffmpeg_WideCharToMultiByte
 
  static inline int moonlight_nxdk_ffmpeg_access(const char *path, int mode) {
    (void) path;
    (void) mode;
    errno = ENOSYS;
    return -1;
  }
 
  static inline int moonlight_nxdk_ffmpeg_close(int fd) {
    (void) fd;
    return 0;
  }
 
  static inline int moonlight_nxdk_ffmpeg_fcntl(int fd, int cmd, ...) {
    (void) fd;
    (void) cmd;
    errno = ENOSYS;
    return -1;
  }
 
  static inline FILE *moonlight_nxdk_ffmpeg_fdopen(int fd, const char *mode) {
    (void) fd;
    (void) mode;
    errno = ENOSYS;
    return NULL;
  }
 
  static inline int moonlight_nxdk_ffmpeg_isatty(int fd) {
    (void) fd;
    return 0;
  }
 
  static inline int64_t gethrtime(void) {
    return 0;
  }
 
  static inline unsigned long moonlight_nxdk_ffmpeg_GetFullPathNameW(const wchar_t *path, unsigned long buffer_size, wchar_t *buffer, wchar_t **file_part) {
    size_t length;
    wchar_t *last_separator;
 
    if (path == NULL) {
      return 0;
    }
 
    length = wcslen(path);
    last_separator = NULL;
    for (size_t index = 0; index < length; ++index) {
      if (path[index] == L'\\' || path[index] == L'/') {
        last_separator = (wchar_t *) &path[index + 1U];
      }
    }
 
    if (file_part != NULL) {
      *file_part = last_separator;
    }
 
    if (buffer == NULL || buffer_size == 0U) {
      return (unsigned long) (length + 1U);
    }
 
    if (length + 1U > buffer_size) {
      if (buffer_size > 0U) {
        wcsncpy(buffer, path, buffer_size - 1U);
        buffer[buffer_size - 1U] = L'\0';
      }
      return (unsigned long) (length + 1U);
    }
 
    wcscpy(buffer, path);
    return (unsigned long) length;
  }
 
  static inline int moonlight_nxdk_ffmpeg_mkstemp(char *pattern) {
    (void) pattern;
    errno = ENOSYS;
    return -1;
  }
 
  static inline int moonlight_nxdk_ffmpeg_MultiByteToWideChar(unsigned int code_page, unsigned long flags, const char *source, int source_length, wchar_t *destination, int destination_length) {
    size_t length;
 
    (void) code_page;
    (void) flags;
 
    if (source == NULL) {
      return 0;
    }
 
    length = source_length >= 0 ? (size_t) source_length : strlen(source) + 1U;
    if (destination == NULL || destination_length <= 0) {
      return (int) length;
    }
 
    if ((size_t) destination_length < length) {
      return 0;
    }
 
    for (size_t index = 0; index < length; ++index) {
      destination[index] = (unsigned char) source[index];
    }
 
    return (int) length;
  }
 
  static inline int moonlight_nxdk_ffmpeg_open(const char *path, int flags, ...) {
    (void) path;
    (void) flags;
    errno = ENOSYS;
    return -1;
  }
 
  static inline int moonlight_nxdk_ffmpeg_strerror_r(int errnum, char *buffer, size_t buffer_size) {
    const char *message;
 
    if (buffer == NULL || buffer_size == 0) {
      errno = EINVAL;
      return -1;
    }
 
    message = strerror(errnum);
    if (message == NULL) {
      message = "Unknown error";
    }
 
    strncpy(buffer, message, buffer_size - 1U);
    buffer[buffer_size - 1U] = '\0';
    return 0;
  }
 
  static inline char *moonlight_nxdk_ffmpeg_tempnam(const char *dir, const char *prefix) {
    (void) dir;
    (void) prefix;
    errno = ENOSYS;
    return NULL;
  }
 
  static inline int moonlight_nxdk_ffmpeg_usleep(unsigned int usec) {
    (void) usec;
    return 0;
  }
 
  static inline int moonlight_nxdk_ffmpeg_WideCharToMultiByte(unsigned int code_page, unsigned long flags, const wchar_t *source, int source_length, char *destination, int destination_length, const char *default_char, int *used_default_char) {
    size_t length;
 
    (void) code_page;
    (void) flags;
    (void) default_char;
    if (used_default_char != NULL) {
      *used_default_char = 0;
    }
 
    if (source == NULL) {
      return 0;
    }
 
    length = source_length >= 0 ? (size_t) source_length : wcslen(source) + 1U;
    if (destination == NULL || destination_length <= 0) {
      return (int) length;
    }
 
    if ((size_t) destination_length < length) {
      return 0;
    }
 
    for (size_t index = 0; index < length; ++index) {
      destination[index] = (char) source[index];
    }
 
    return (int) length;
  }
 
  #ifdef __cplusplus
}
  #endif
 
#endif