/CUETools.Codecs.libFLAC/FLACDLL.cs

https://github.com/gchudov/cuetools.net · C# · 180 lines · 132 code · 48 blank · 0 comment · 5 complexity · 44ba31e0a44e8c4d9bf36c94d84b56f8 MD5 · raw file 

    

  1. using System;
    2. 

  2. using System.Runtime.InteropServices;
    3. 

  3. 

  4. namespace CUETools.Codecs.libFLAC
    5. 

  5. {
    6. 

  6.     internal unsafe static class FLACDLL
    7. 

  7.     {
    8. 

  8.         internal const string DllName = "libFLAC_dynamic";
    9. 

  9.         internal const CallingConvention libFLACCallingConvention = CallingConvention.Cdecl;
    10. 

  10.         internal const int FLAC__MAX_CHANNELS = 8;
    11. 

  11.         private static string version;
    12. 

  12. 

  13.         internal static string GetVersion => version;
    14. 

  14. 

  15.         [DllImport("kernel32.dll")]
    16. 

  16.         private static extern IntPtr LoadLibrary(string dllToLoad);
    17. 

  17. 

  18.         [DllImport("kernel32.dll")]
    19. 

  19.         public static extern IntPtr GetProcAddress(IntPtr hModule, string procedureName);
    20. 

  20. 

  21.         [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
    22. 

  22.         internal delegate FLAC__StreamDecoderReadStatus FLAC__StreamDecoderReadCallback(IntPtr decoder, byte* buffer, ref long bytes, void* client_data);
    23. 

  23. 

  24.         [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
    25. 

  25.         internal delegate FLAC__StreamDecoderSeekStatus FLAC__StreamDecoderSeekCallback(IntPtr decoder, long absolute_byte_offset, void* client_data);
    26. 

  26. 

  27.         [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
    28. 

  28.         internal delegate FLAC__StreamDecoderTellStatus FLAC__StreamDecoderTellCallback(IntPtr decoder, out long absolute_byte_offset, void* client_data);
    29. 

  29. 

  30.         [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
    31. 

  31.         internal delegate FLAC__StreamDecoderLengthStatus FLAC__StreamDecoderLengthCallback(IntPtr decoder, out long stream_length, void* client_data);
    32. 

  32. 

  33.         [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
    34. 

  34.         internal delegate int FLAC__StreamDecoderEofCallback(IntPtr decoder, void* client_data);
    35. 

  35. 

  36.         [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
    37. 

  37.         internal delegate FLAC__StreamDecoderWriteStatus FLAC__StreamDecoderWriteCallback(IntPtr decoder, FLAC__Frame* frame, int** buffer, void* client_data);
    38. 

  38. 

  39.         [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
    40. 

  40.         internal delegate void FLAC__StreamDecoderMetadataCallback(IntPtr decoder, FLAC__StreamMetadata* metadata, void* client_data);
    41. 

  41. 

  42.         [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
    43. 

  43.         internal delegate void FLAC__StreamDecoderErrorCallback(IntPtr decoder, FLAC__StreamDecoderErrorStatus status, void* client_data);
    44. 

  44. 

  45. 

  46.         [DllImport(DllName, CallingConvention = libFLACCallingConvention)]
    47. 

  47.         internal static extern IntPtr FLAC__stream_decoder_new();
    48. 

  48. 

  49.         [DllImport(DllName, CallingConvention = libFLACCallingConvention)]
    50. 

  50.         internal static extern int FLAC__stream_decoder_set_metadata_respond(IntPtr decoder, FLAC__MetadataType type);
    51. 

  51. 

  52.         [DllImport(DllName, CallingConvention = libFLACCallingConvention)]
    53. 

  53.         internal static extern int FLAC__stream_decoder_process_until_end_of_metadata(IntPtr decoder);
    54. 

  54. 

  55.         [DllImport(DllName, CallingConvention = libFLACCallingConvention)]
    56. 

  56.         internal static extern  FLAC__StreamDecoderInitStatus FLAC__stream_decoder_init_stream(
    57. 

  57.             IntPtr decoder,
    58. 

  58.             FLAC__StreamDecoderReadCallback read_callback,
    59. 

  59.             FLAC__StreamDecoderSeekCallback seek_callback,
    60. 

  60.             FLAC__StreamDecoderTellCallback tell_callback,
    61. 

  61.             FLAC__StreamDecoderLengthCallback length_callback,
    62. 

  62.             FLAC__StreamDecoderEofCallback eof_callback,
    63. 

  63.             FLAC__StreamDecoderWriteCallback write_callback,
    64. 

  64.             FLAC__StreamDecoderMetadataCallback metadata_callback,
    65. 

  65.             FLAC__StreamDecoderErrorCallback error_callback,
    66. 

  66.             void* client_data
    67. 

  67.         );
    68. 

  68. 

  69.         [DllImport(DllName, CallingConvention = libFLACCallingConvention)]
    70. 

  70.         internal static extern int FLAC__stream_decoder_finish(IntPtr decoder);
    71. 

  71. 

  72.         [DllImport(DllName, CallingConvention = libFLACCallingConvention)]
    73. 

  73.         internal static extern int FLAC__stream_decoder_delete(IntPtr decoder);
    74. 

  74. 

  75.         [DllImport(DllName, CallingConvention = libFLACCallingConvention)]
    76. 

  76.         internal static extern int FLAC__stream_decoder_seek_absolute(IntPtr decoder, long sample);
    77. 

  77. 

  78.         [DllImport(DllName, CallingConvention = libFLACCallingConvention)]
    79. 

  79.         internal static extern FLAC__StreamDecoderState FLAC__stream_decoder_get_state(IntPtr decoder);
    80. 

  80. 

  81.         [DllImport(DllName, CallingConvention = libFLACCallingConvention)]
    82. 

  82.         internal static extern int FLAC__stream_decoder_process_single(IntPtr decoder);
    83. 

  83. 

  84. 

  85. 

  86.         [DllImport(DllName, CallingConvention = libFLACCallingConvention)]
    87. 

  87.         internal static extern IntPtr FLAC__stream_encoder_new();
    88. 

  88. 

  89.         [DllImport(DllName, CallingConvention = libFLACCallingConvention)]
    90. 

  90.         internal static extern int FLAC__stream_encoder_set_bits_per_sample(IntPtr encoder, uint value);
    91. 

  91. 

  92.         [DllImport(DllName, CallingConvention = libFLACCallingConvention)]
    93. 

  93.         internal static extern int FLAC__stream_encoder_set_sample_rate(IntPtr encoder, uint value);
    94. 

  94. 

  95.         [DllImport(DllName, CallingConvention = libFLACCallingConvention)]
    96. 

  96.         internal static extern int FLAC__stream_encoder_set_channels(IntPtr encoder, uint value);
    97. 

  97. 

  98.         [DllImport(DllName, CallingConvention = libFLACCallingConvention)]
    99. 

  99.         internal static extern int FLAC__stream_encoder_finish(IntPtr encoder);
    100. 

  100. 

  101.         [DllImport(DllName, CallingConvention = libFLACCallingConvention)]
    102. 

  102.         internal static extern int FLAC__stream_encoder_delete(IntPtr encoder);
    103. 

  103. 

  104.         [DllImport(DllName, CallingConvention = libFLACCallingConvention)]
    105. 

  105.         internal static extern int FLAC__stream_encoder_process_interleaved(IntPtr encoder, int* buffer, int samples);
    106. 

  106. 

  107.         [DllImport(DllName, CallingConvention = libFLACCallingConvention)]
    108. 

  108.         internal static extern FLAC__StreamEncoderState FLAC__stream_encoder_get_state(IntPtr encoder);
    109. 

  109. 

  110.         [DllImport(DllName, CallingConvention = libFLACCallingConvention)]
    111. 

  111.         internal static extern void FLAC__stream_encoder_get_verify_decoder_error_stats(IntPtr encoder, out ulong absolute_sample, out uint frame_number, out uint channel, out uint sample, out int expected, out int got);
    112. 

  112. 

  113.         [DllImport(DllName, CallingConvention = libFLACCallingConvention)]
    114. 

  114.         internal static extern FLAC__StreamMetadata* FLAC__metadata_object_new(FLAC__MetadataType type);
    115. 

  115. 

  116.         [DllImport(DllName, CallingConvention = libFLACCallingConvention)]
    117. 

  117.         internal static extern int FLAC__metadata_object_seektable_template_append_spaced_points_by_samples(FLAC__StreamMetadata* metadata, int samples, long total_samples);
    118. 

  118. 

  119.         [DllImport(DllName, CallingConvention = libFLACCallingConvention)]
    120. 

  120.         internal static extern int FLAC__metadata_object_seektable_template_sort(FLAC__StreamMetadata* metadata, int compact);
    121. 

  121. 

  122.         [DllImport(DllName, CallingConvention = libFLACCallingConvention)]
    123. 

  123.         internal static extern int FLAC__stream_encoder_set_metadata(IntPtr encoder, FLAC__StreamMetadata** metadata, int num_blocks);
    124. 

  124. 

  125.         [DllImport(DllName, CallingConvention = libFLACCallingConvention)]
    126. 

  126.         internal static extern int FLAC__stream_encoder_set_verify(IntPtr encoder, int value);
    127. 

  127. 

  128.         [DllImport(DllName, CallingConvention = libFLACCallingConvention)]
    129. 

  129.         internal static extern int FLAC__stream_encoder_set_do_md5(IntPtr encoder, int value);
    130. 

  130. 

  131.         [DllImport(DllName, CallingConvention = libFLACCallingConvention)]
    132. 

  132.         internal static extern int FLAC__stream_encoder_set_total_samples_estimate(IntPtr encoder, long value);
    133. 

  133. 

  134.         [DllImport(DllName, CallingConvention = libFLACCallingConvention)]
    135. 

  135.         internal static extern int FLAC__stream_encoder_set_compression_level(IntPtr encoder, int value);
    136. 

  136. 

  137.         [DllImport(DllName, CallingConvention = libFLACCallingConvention)]
    138. 

  138.         internal static extern int FLAC__stream_encoder_set_blocksize(IntPtr encoder, int value);
    139. 

  139. 

  140.         [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
    141. 

  141.         internal delegate FLAC__StreamEncoderWriteStatus FLAC__StreamEncoderWriteCallback(IntPtr encoder, [MarshalAs(UnmanagedType.LPArray, SizeParamIndex = 2)] byte[] buffer, long bytes, int samples, int current_frame, void* client_data);
    142. 

  142. 

  143.         [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
    144. 

  144.         internal delegate FLAC__StreamEncoderSeekStatus FLAC__StreamEncoderSeekCallback(IntPtr encoder, long absolute_byte_offset, void* client_data);
    145. 

  145. 

  146.         [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
    147. 

  147.         internal delegate FLAC__StreamEncoderTellStatus FLAC__StreamEncoderTellCallback(IntPtr encoder, out long absolute_byte_offset, void* client_data);
    148. 

  148. 

  149.         [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
    150. 

  150.         internal delegate void FLAC__StreamEncoderMetadataCallback(IntPtr encoder, FLAC__StreamMetadata* metadata, void* client_data);
    151. 

  151. 

  152.         [DllImport(DllName, CallingConvention = libFLACCallingConvention)]
    153. 

  153.         internal static extern FLAC__StreamEncoderInitStatus FLAC__stream_encoder_init_stream(IntPtr encoder,
    154. 

  154.             FLAC__StreamEncoderWriteCallback write_callback,
    155. 

  155.             FLAC__StreamEncoderSeekCallback seek_callback,
    156. 

  156.             FLAC__StreamEncoderTellCallback tell_callback,
    157. 

  157.             FLAC__StreamEncoderMetadataCallback metadata_callback,
    158. 

  158.             void* client_data);
    159. 

  159. 

  160.         static FLACDLL()
    161. 

  161.         {
    162. 

  162.             var myPath = new Uri(typeof(FLACDLL).Assembly.CodeBase).LocalPath;
    163. 

  163.             var myFolder = System.IO.Path.GetDirectoryName(myPath);
    164. 

  164.             var is64 = IntPtr.Size == 8;
    165. 

  165.             var subfolder = is64 ? "x64" : "win32";
    166. 

  166. #if NET47
    167. 

  167.             IntPtr Dll = LoadLibrary(System.IO.Path.Combine(myFolder, subfolder, DllName + ".dll"));
    168. 

  168. #else
    169. 

  169.             IntPtr Dll = LoadLibrary(System.IO.Path.Combine(System.IO.Path.Combine(myFolder, subfolder), DllName + ".dll"));
    170. 

  170. #endif
    171. 

  171.             if (Dll == IntPtr.Zero)
    172. 

  172.                 Dll = LoadLibrary(DllName + ".dll");
    173. 

  173.             if (Dll == IntPtr.Zero)
    174. 

  174.                 throw new DllNotFoundException();
    175. 

  175.             IntPtr addr = GetProcAddress(Dll, "FLAC__VERSION_STRING");
    176. 

  176.             IntPtr ptr = Marshal.ReadIntPtr(addr);
    177. 

  177.             version = Marshal.PtrToStringAnsi(ptr);
    178. 

  178.         }
    179. 

  179.     };
    180. 

  180. }
    181.