public static int crypto_sign_keypair(
byte *pk,
byte *sk)
{
return(_is32bits
? X86.crypto_sign_keypair(pk, sk)
: X64.crypto_sign_keypair(pk, sk));
}
public static int crypto_sign_update(void * /* crypto_sign_state */ state,
byte *m,
ulong mlen)
{
return(_is32bits ?
X86.crypto_sign_update(state, m, mlen) :
X64.crypto_sign_update(state, m, mlen));
}
public static int sodium_memcmp(
byte *b1,
byte *b2,
UIntPtr len)
{
return(_is32bits ?
X86.sodium_memcmp(b1, b2, len) :
X64.sodium_memcmp(b1, b2, len));
}
public static int crypto_sign_final_create(void * /* crypto_generichash_state */ state,
byte *sig,
ulong *siglen_p,
byte *sk)
{
return(_is32bits ?
X86.crypto_sign_final_create(state, sig, siglen_p, sk) :
X64.crypto_sign_final_create(state, sig, siglen_p, sk));
}
public static int crypto_generichash_init(void * /* crypto_generichash_state */ state,
byte *key,
UIntPtr keylen,
UIntPtr outlen)
{
return(_is32bits ?
X86.crypto_generichash_init(state, key, keylen, outlen) :
X64.crypto_generichash_init(state, key, keylen, outlen));
}
public static int crypto_generichash_final(
void * /* crypto_generichash_state */ state,
byte * @out,
UIntPtr outlen)
{
return(_is32bits ?
X86.crypto_generichash_final(state, @out, outlen) :
X64.crypto_generichash_final(state, @out, outlen));
}
public static int crypto_generichash_update(
void * /* crypto_generichash_state */ state,
byte * @in,
ulong inlen)
{
return(_is32bits ?
X86.crypto_generichash_update(state, @in, inlen) :
X64.crypto_generichash_update(state, @in, inlen));
}
/// <inheritdoc/>
public override int GetHashCode()
{
unchecked
{
int result = base.GetHashCode();
result = (result * 397) ^ (CapabilityRegPath ?? "").GetHashCode();
result = (result * 397) ^ X64.GetHashCode();
return(result);
}
}
public static int crypto_sign_verify_detached(
byte *sig,
byte *m,
ulong mlen,
byte *pk)
{
return(_is32bits
? X86.crypto_sign_verify_detached(sig, m, mlen, pk)
: X64.crypto_sign_verify_detached(sig, m, mlen, pk));
}
public static int crypto_box_seal(
byte *b,
byte *b1,
ulong mlen,
byte *pk)
{
return(_is32bits
? X86.crypto_box_seal(b, b1, mlen, pk)
: X64.crypto_box_seal(b, b1, mlen, pk));
}
public static void ass_set_font_scale(IntPtr renderer, double fontScale)
{
if (Is64Bit)
{
X64.ass_set_font_scale(renderer, fontScale);
}
else
{
X86.ass_set_font_scale(renderer, fontScale);
}
}
public static int crypto_kdf_derive_from_key(
byte *subkey,
UIntPtr subkeylen,
ulong subkeyid,
byte *ctx,
byte *key)
{
return(_is32bits
? X86.crypto_kdf_derive_from_key(subkey, subkeylen, subkeyid, ctx, key)
: X64.crypto_kdf_derive_from_key(subkey, subkeylen, subkeyid, ctx, key));
}
public static void ass_set_hinting(IntPtr renderer, Hinting hinting)
{
if (Is64Bit)
{
X64.ass_set_hinting(renderer, hinting);
}
else
{
X86.ass_set_hinting(renderer, hinting);
}
}
public static void ass_set_line_position(IntPtr renderer, double linePosition)
{
if (Is64Bit)
{
X64.ass_set_line_position(renderer, linePosition);
}
else
{
X86.ass_set_line_position(renderer, linePosition);
}
}
public static void ass_process_force_style(IntPtr track)
{
if (Is64Bit)
{
X64.ass_process_force_style(track);
}
else
{
X86.ass_process_force_style(track);
}
}
public static int ass_library_version()
{
if (Is64Bit)
{
return(X64.ass_library_version());
}
else
{
return(X86.ass_library_version());
}
}
public static void ass_set_style_overrides(IntPtr library, IntPtr list)
{
if (Is64Bit)
{
X64.ass_set_style_overrides(library, list);
}
else
{
X86.ass_set_style_overrides(library, list);
}
}
public static IntPtr ass_library_done(IntPtr library)
{
if (Is64Bit)
{
return(X64.ass_library_done(library));
}
else
{
return(X86.ass_library_done(library));
}
}
public static void ass_set_fonts_dir(IntPtr library, [CanBeNull] string fontsDir)
{
if (Is64Bit)
{
X64.ass_set_fonts_dir(library, fontsDir);
}
else
{
X86.ass_set_fonts_dir(library, fontsDir);
}
}
public static void ass_set_selective_style_override_enabled(IntPtr renderer, OverrideBits bits)
{
if (Is64Bit)
{
X64.ass_set_selective_style_override_enabled(renderer, bits);
}
else
{
X86.ass_set_selective_style_override_enabled(renderer, bits);
}
}
public static void ass_set_fonts(IntPtr renderer, [CanBeNull] string defaultFont, [CanBeNull] string defaultFamily, DefaultFontProvider fontProvider, [CanBeNull] string config, bool update)
{
if (Is64Bit)
{
X64.ass_set_fonts(renderer, defaultFont, defaultFamily, fontProvider, config, update);
}
else
{
X86.ass_set_fonts(renderer, defaultFont, defaultFamily, fontProvider, config, update);
}
}
public static void ass_get_available_font_providers(IntPtr library, out IntPtr providers, out UIntPtr size)
{
if (Is64Bit)
{
X64.ass_get_available_font_providers(library, out providers, out size);
}
else
{
X86.ass_get_available_font_providers(library, out providers, out size);
}
}
public static int crypto_sign_detached(
byte *sig,
ulong *siglen,
byte *m,
ulong mlen,
byte *sk)
{
return(_is32bits
? X86.crypto_sign_detached(sig, siglen, m, mlen, sk)
: X64.crypto_sign_detached(sig, siglen, m, mlen, sk));
}
public static void ass_set_message_cb(IntPtr library, IntPtr callback, IntPtr userData)
{
if (Is64Bit)
{
X64.ass_set_message_cb(library, callback, userData);
}
else
{
X86.ass_set_message_cb(library, callback, userData);
}
}
public static void ass_set_extract_fonts(IntPtr library, bool extract)
{
if (Is64Bit)
{
X64.ass_set_extract_fonts(library, extract);
}
else
{
X86.ass_set_extract_fonts(library, extract);
}
}
public static void ass_set_line_spacing(IntPtr renderer, double lineSpacing)
{
if (Is64Bit)
{
X64.ass_set_line_spacing(renderer, lineSpacing);
}
else
{
X86.ass_set_line_spacing(renderer, lineSpacing);
}
}
public static void ass_set_use_margins(IntPtr renderer, bool use)
{
if (Is64Bit)
{
X64.ass_set_use_margins(renderer, use);
}
else
{
X86.ass_set_use_margins(renderer, use);
}
}
public static IntPtr ass_library_init()
{
if (Is64Bit)
{
return(X64.ass_library_init());
}
else
{
return(X86.ass_library_init());
}
}
public static void ass_set_pixel_aspect(IntPtr renderer, double pixelAspectRatio)
{
if (Is64Bit)
{
X64.ass_set_pixel_aspect(renderer, pixelAspectRatio);
}
else
{
X86.ass_set_pixel_aspect(renderer, pixelAspectRatio);
}
}
public static void ass_set_aspect_ratio(IntPtr renderer, double displayAspectRatio, double storageAspectRatio)
{
if (Is64Bit)
{
X64.ass_set_aspect_ratio(renderer, displayAspectRatio, storageAspectRatio);
}
else
{
X86.ass_set_aspect_ratio(renderer, displayAspectRatio, storageAspectRatio);
}
}
protected abstract void EmitCode(NodeFactory factory, ref X64.X64Emitter instructionEncoder, bool relocsOnly);