using System;
using System.Collections.Generic;
using System.Linq;
using System.Reflection.Metadata.Ecma335;
using System.Runtime.InteropServices;
using System.Text;
using System.Threading.Tasks;
using skyscraper5.Skyscraper.IO.CrazycatStreamReader;

namespace skyscraper5.IO.StreamReader
{
    public partial class LocalStreamReader
    {
        private static class UnsafeStreamReaderMethods
        {
            /// <summary>
            /// Checks whether any sort of tuner is present in this system.
            /// </summary>
            /// <returns>Whether a tuner is present.</returns>
            [DllImport("StreamReader.dll", EntryPoint = "CheckForDVB")]
            internal static extern bool CheckForDVB();

            /// <summary>
            /// Checks whether one or more tuner is present in the system.
            /// </summary>
            /// <param name="func">A method which will be called for each tuner found.</param>
            /// <returns>Whether a tuner was found</returns>
            [DllImport("StreamReader.dll", EntryPoint = "CheckForDVBEx")]
            internal static extern bool CheckForDVBEx([MarshalAs(UnmanagedType.FunctionPtr)] DvbEnumCallback func);

            /// <summary>
            /// Checks whether one or more tuner is present in the system.
            /// </summary>
            /// <param name="func">A method which will be called for each tuner found.</param>
            /// <returns>Whether a tuner was found</returns>
            [DllImport("StreamReader.dll", EntryPoint = "CheckForDVBExEx")]
            public static extern bool CheckForDVBExEx([MarshalAs(UnmanagedType.FunctionPtr)] DvbEnumCallbackEx func);

            /// <summary>
            /// Boots the first system tuner and sets it as the currently active tuner. Note that
            /// only one tuner can be active at the same time.
            /// </summary>
            /// <returns>Whether a tuner was booted sucessfully.</returns>
            [DllImport("StreamReader.dll", EntryPoint = "StartDVB")]
            internal static extern bool StartDVB();

            /// <summary>
            /// Boots a tuner and makes it the currently active tuner. Note that only one tuner
            /// can be active at the same time.
            /// </summary>
            /// <param name="index">The ID of the tuner to boot</param>
            /// <returns>Whether the turner booted sucessfully.</returns>
            [DllImport("StreamReader.dll", EntryPoint = "StartDVBEx")]
            public static extern bool StartDvbEx(int index);

            /// <summary>
            /// Shuts down the currently active tuner.
            /// </summary>
            /// <returns>Whether the tuner was shut down sucessfully</returns>
            [DllImport("StreamReader.dll", EntryPoint = "StopDVB")]
            public static extern bool StopDVB();

            /// <summary>
            /// Retrieves the tuner standard.
            /// </summary>
            /// <param name="type">A Pointer in which the tuner type will be put into.</param>
            /// <returns>Whether the tuner reports a standard</returns>
            [DllImport("StreamReader.dll", EntryPoint = "GetTunerType")]
            internal static extern bool GetTunerType(ref STD_TYPE type);

            /// <summary>
            /// Sends a raw command to a DiSEqC switch with up to four positions.
            /// </summary>
            /// <param name="diseqcType">0 for disabling DiSEqc, 1 for a tone-burst, 2 for enabling DiSEqC 1.0</param>
            /// <param name="data">The opcode to send.</param>
            /// <returns>Whether the command was sent</returns>
            [DllImport("StreamReader.dll", EntryPoint = "SendDiSEqC")]
            public static extern bool SendDiSEqC(uint diseqcType, DiSEqC_Opcode data);

            /// <summary>
            /// Send a raw command to a DiSEqC-Motor, ignoring any potential responses.
            /// </summary>
            /// <param name="buffer">The buffer containing the raw command</param>
            /// <param name="length">The length of the command</param>
            /// <returns>Whether the command was sent</returns>
            [DllImport("StreamReader.dll", EntryPoint = "SendDiseqCmd")]
            internal static extern bool SendDiseqCmd(byte[] buffer, int length);

            /// <summary>
            /// Supposed to send a raw command to a DiSEqC-Motor and awaits a response.
            /// Since I couldn't test this - (I don't have a motor on my dish!) this will merely
            /// throw a NotImplementedException
            /// </summary>
            /// <param name="pCmd">The command to send to the motor</param>
            /// <param name="length">The length of the command to send to the motor.</param>
            /// <param name="reply">A byte array to store the motor's response in.</param>
            /// <param name="replyLength">Expected length of the motor's response</param>
            /// <returns>Throws a NotImplementedException</returns>
            internal static bool SendDiseqCmdEx(IntPtr pCmd, int length, IntPtr reply, int replyLength)
            {
                //I have no rotor to test this with.
                //Also, I'm not sure whether this method head is correct.
                throw new NotImplementedException(nameof(SendDiseqCmdEx));
            }

            /// <summary>
            /// Set the tuner to a satellite frequency
            /// </summary>
            /// <param name="freq">The frequency in kHz.</param>
            /// <param name="symbrate">The symbol rate in Sym/s. (e.g. 27500 * 1000 = 27500000)</param>
            /// <param name="pol">0 for horizontal, 1 for vertical.</param>
            /// <param name="fec">The error correction method used by the channel.</param>
            /// <param name="lof1">Local Oscillator Frequency 1 of the LNB in kHz. (9750000 for Ku-Band)</param>
            /// <param name="lof2">Local Oscillator Frequency 2 of the LNB in kHz. (10600000 for Ku-Band)</param>
            /// <param name="lofsw">Border Frequency for switching between Low Band and High Band in kHz (11700000 for Ku-Band)</param>
            /// <returns>Whether the tuner complied with the request</returns>
            [DllImport("StreamReader.dll", EntryPoint = "SetChannel")]
            public static extern bool SetChannel(int freq, int symbrate, int pol, VITERBIRATE_TYPE fec, int lof1,
                int lof2, int lofsw);

            /// <summary>
            /// Set the tuner to a satellite frequency
            /// </summary>
            /// <param name="freq">The frequency in kHz.</param>
            /// <param name="symbrate">The symbol rate in Sym/s. (e.g. 27500 * 1000 = 27500000)</param>
            /// <param name="pol">0 for horizontal, 1 for vertical.</param>
            /// <param name="fec">The error correction method used by the channel.</param>
            /// <param name="lof1">Local Oscillator Frequency 1 of the LNB in kHz. (9750000 for Ku-Band)</param>
            /// <param name="lof2">Local Oscillator Frequency 2 of the LNB in kHz. (10600000 for Ku-Band)</param>
            /// <param name="lofsw">Border Frequency for switching between Low Band and High Band in kHz (11700000 for Ku-Band)</param>
            /// <param name="mod">The modulation type used by the channel.</param>
            /// <returns>Whether the tuner complied with the request.</returns>
            [DllImport("StreamReader.dll", EntryPoint = "SetChannelEx")]
            internal static extern bool SetChannelEx(int freq, int symbrate, int pol, VITERBIRATE_TYPE fec, int lof1,
                int lof2, int lofsw, MOD_TYPE mod);

            /// <summary>
            /// Set the tuner to a satellite frequency
            /// </summary>
            /// <param name="freq">The frequency in kHz.</param>
            /// <param name="symbrate">The symbol rate in Sym/s. (e.g. 27500 * 1000 = 27500000)</param>
            /// <param name="pol">0 for horizontal, 1 for vertical.</param>
            /// <param name="fec">The error correction method used by the channel.</param>
            /// <param name="lof1">Local Oscillator Frequency 1 of the LNB in kHz. (9750000 for Ku-Band)</param>
            /// <param name="lof2">Local Oscillator Frequency 2 of the LNB in kHz. (10600000 for Ku-Band)</param>
            /// <param name="lofsw">Border Frequency for switching between Low Band and High Band in kHz (11700000 for Ku-Band)</param>
            /// <param name="mod">The modulation type used by the channel.</param>
            /// <param name="inv">Spectral inversion: 0 for autodetection, 1 for no spectral inversion, 2 for spectral inversion.</param>
            /// <param name="pilot">S2 Pilot Symbols: 0 for autodetection, 1 for no pilot symbols, 2 for pilot symbols</param>
            /// <param name="rolloff"></param>
            /// <returns></returns>
            [DllImport("StreamReader.dll", EntryPoint = "SetChannelExEx")]
            internal static extern bool SetChannelExEx(int freq, int symbrate, int pol, VITERBIRATE_TYPE fec, int lof1,
                int lof2, int lofsw, MOD_TYPE mod, int inv, int pilot, ROLLOFF_TYPE rolloff);

            /// <summary>
            /// Starts receiving data from the tuner.
            /// </summary>
            /// <param name="pid">The PID you want to receive. Set this to 8192 if you want ALL pids.</param>
            /// <param name="func">The function to call when a packet was received.</param>
            /// <param name="callbackType">Set this to 0x02 for all that is holy. Others might cause blue-screens.</param>
            /// <param name="size">Set this to 1 to receive single packets, or 2 to receive (a varying amount of) multiple packets.</param>
            /// <param name="lpFilterNum">The pointer you can use with DelFilter.</param>
            /// <returns>Whether the filter was started sucesfully.</returns>
            [DllImport("StreamReader.dll", EntryPoint = "SetFilter")]
            public static extern bool SetFilter(int pid, [MarshalAs(UnmanagedType.FunctionPtr)] StdcallDvbCallback func,
                int callbackType, int size, ref IntPtr lpFilterNum);

            /// <summary>
            /// Starts receiving data from the tuner.
            /// </summary>
            /// <param name="pid">The PID you want to receive. Set this to 8192 if you want ALL pids.</param>
            /// <param name="func">The function to call when a packet was received.</param>
            /// <param name="callbackType">Set this to 0x02 for all that is holy. Others might cause blue-screens.</param>
            /// <param name="size">Set this to 1 to receive single packets, or 2 to receive (a varying amount of) multiple packets.</param>
            /// <param name="lpFilterNum">The pointer you can use with DelFilter.</param>
            /// <returns>Whether the filter was started sucesfully.</returns>
            [DllImport("StreamReader.dll", EntryPoint = "SetFilterEx")]
            internal static extern bool SetFilterEx(int pid,
                [MarshalAs(UnmanagedType.FunctionPtr)] StdcallDvbCallbackEx lpFunc, int callbackType, int size,
                ref IntPtr lpFilterNum);

            [DllImport("StreamReader.dll", EntryPoint = "SetBitFilter")]
            internal static extern bool SetBitFilter(int pid, IntPtr filterData, IntPtr filterMask, byte filterLength,
                [MarshalAs(UnmanagedType.FunctionPtr)] StdcallDvbCallback lpFunc, ref IntPtr lpFilterNum);

            /// <summary>
            /// Creates a filter to read data from the virtual IR Channel of the tuner.
            /// </summary>
            /// <param name="irtype">The remote control type. 0x00 works for all remote types.</param>
            /// <param name="devAddr">The adress of the remote control. Set to -1 for all remotes.</param>
            /// <param name="func">The function to call when an IR Command was received.</param>
            /// <param name="lpFilterNum">A pointer to the filter to use with DelFilter.</param>
            /// <returns>Whether the listening to a remote command is working.</returns>
            [DllImport("StreamReader.dll", EntryPoint = "SetRemoteControl")]
            internal static extern bool SetRemoteControl(int irtype, short devAddr,
                [MarshalAs(UnmanagedType.FunctionPtr)] StdcallDvbCallback func, ref IntPtr lpFilterNum);

            /// <summary>
            /// Stops reading data.
            /// </summary>
            /// <param name="filterNum">The pointer to the filter which should be stopped.</param>
            /// <returns>Whether the filter could be stopped.</returns>
            [DllImport("StreamReader.dll", EntryPoint = "DelFilter")]
            public static extern bool DelFilter(IntPtr filterNum);

            /// <summary>
            /// Reports the signal strength and quality. For some tuners you'll need GetSignalStrength instead.
            /// </summary>
            /// <param name="pStrength">A float pointer which will be set to the signal strength.</param>
            /// <param name="pQuality">A float pointer which will be set to the signal quality.</param>
            /// <returns>Whether these information could be reported.</returns>
            [DllImport("StreamReader.dll", EntryPoint = "GetSignal")]
            internal static extern bool GetSignal(ref int pStrength, ref int pQuality);

            /// <summary>
            /// An alternative method to read the signal strength and quality.
            /// </summary>
            /// <param name="pStrength">A float pointer which will be set to the signal strength.</param>
            /// <param name="pQuality">A float pointer which will be set to the signal quality.</param>
            /// <returns>Whether these information could be reported.</returns>
            [DllImport("StreamReader.dll", EntryPoint = "GetSignalStrength")]
            internal static extern bool GetSignalStrength(ref float pStrength, ref float pQuality);

            /// <summary>
            /// Gets information about the current signal.
            /// </summary>
            /// <param name="pSNR">Pointer to a float which will be set to the Signal-to-Noise ratio.</param>
            /// <param name="pBER">Pointer to a float which will be set to the biterror rate.</param>
            /// <returns>Whether the data could be reported.</returns>
            [DllImport("StreamReader.dll", EntryPoint = "GetSignalEx")]
            internal static extern bool GetSignalEx(ref float pSNR, ref float pBER);

            /// <summary>
            /// Gets information about the current signal.
            /// </summary>
            /// <param name="pPresent">Pointer to a boolean which will be set to true if a signal is present.</param>
            /// <param name="pLock">Pointer to a boolean which will be set to true if a signal lock is available.</param>
            /// <param name="pRFLevel">Pointer to an integer which will be set to the RF Level.</param>
            /// <param name="pSNR">Pointer to a float which will be set to the Signal-to-Noise ratio.</param>
            /// <param name="pBER">Pointer to a float which will be set to the biterror rate.</param>
            /// <returns>Whether the data could be reported.</returns>
            [DllImport("StreamReader.dll", EntryPoint = "GetSignalExEx")]
            internal static extern bool GetSignalExEx(ref bool pPresent, ref bool pLock, ref int pRFLevel,
                ref float pSNR, ref float pBER);

            /// <summary>
            /// Read signal statistics into an integer array.
            /// </summary>
            /// <param name="pStat">Pointer to an array which will receive the following elements: Locked?, Signal Quality, Signal Present?, Signal Strength</param>
            /// <returns>Whether the statistics could be reported.</returns>
            [DllImport("StreamReader.dll", EntryPoint = "Statistic")]
            internal static extern bool Statistic(int[] pStat);

            /// <summary>
            /// Reads the MAC Adress of a tuner.
            /// </summary>
            /// <param name="pMac">A byte array to put the MAC into.</param>
            /// <returns>Whether the MAC was sucessfully read.</returns>
            [DllImport("StreamReader.dll", EntryPoint = "GetMAC")]
            public static extern bool GetMAC(byte[] pMac);

            /// <summary>
            /// Gets the TunerMetadata capabilities.
            /// </summary>
            /// <returns>A bitmask containing all the tuner capabilities.</returns>
            [DllImport("StreamReader.dll", EntryPoint = "GetCaps")]
            public static extern Caps GetCaps();

            /// <summary>
            /// Gets the RF Strength of a satellite frequency.
            /// </summary>
            /// <param name="freq">An approximate channel frequency in kHz</param>
            /// <param name="pol">0 for horizontal, 1 for vertical</param>
            /// <param name="lof1">Local Oscillator Frequency 1 of the LNB in kHz. (9750000 for Ku-Band)</param>
            /// <param name="lof2">Local Oscillator Frequency 2 of the LNB in kHz. (10600000 for Ku-Band)</param>
            /// <param name="lofsw">Border Frequency for switching between Low Band and High Band in kHz (11700000 for Ku-Band)</param>
            /// <param name="pRFLevel">The pointer to put the result in.</param>
            /// <returns>Whether the probe was sucessful.</returns>
            [DllImport("StreamReader.dll", EntryPoint = "RFScan")]
            internal static extern bool RFScan(int freq, int pol, int lof1, int lof2, int lofsw, out double pRFLevel);

            [DllImport("StreamReader.dll", EntryPoint = "FFTInit")]
            internal static extern bool FFTInit();

            internal static bool FFTScan(int freq, int pol, int lof1, int lof2, int lofsw, uint range, byte mode,
                byte nb_acc, IntPtr pTab, IntPtr pBegin, IntPtr pNum)
            {
                //I don't have a tuner that supports this...
                throw new NotImplementedException();
            }

            /// <summary>
            /// Given an approximate satellite frequency, tune to the nearest channel.
            /// </summary>
            /// <param name="freq">An approximate channel frequency in kHz</param>
            /// <param name="freq_range">The range where to look for in kHz</param>
            /// <param name="pol">0 for horizontal, 1 for vertical</param>
            /// <param name="lof1">Local Oscillator Frequency 1 of the LNB in kHz. (9750000 for Ku-Band)</param>
            /// <param name="lof2">Local Oscillator Frequency 2 of the LNB in kHz. (10600000 for Ku-Band)</param>
            /// <param name="lofsw">Border Frequency for switching between Low Band and High Band in kHz (11700000 for Ku-Band)</param>
            /// <param name="minsr">The minimum acceptable symbol rate. Depending on your tuner you either want 200 or 1000.</param>
            /// <param name="pSearchResult">The exact tuning data</param>
            /// <returns>Whether a channel could be found</returns>
            [DllImport("StreamReader.dll", EntryPoint = "BLScan")]
            internal static extern bool BLScan(int freq, int freq_range, int pol, int lof1, int lof2, int lofsw,
                int minsr, ref SearchResult pSearchResult);

            /// <summary>
            /// Given an approximate satellite frequency, tune to the nearest channel.
            /// </summary>
            /// <param name="freq">An approximate channel frequency in kHz</param>
            /// <param name="freq_range">The range where to look for in kHz</param>
            /// <param name="pol">0 for horizontal, 1 for vertical</param>
            /// <param name="lof1">Local Oscillator Frequency 1 of the LNB in kHz. (9750000 for Ku-Band)</param>
            /// <param name="lof2">Local Oscillator Frequency 2 of the LNB in kHz. (10600000 for Ku-Band)</param>
            /// <param name="lofsw">Border Frequency for switching between Low Band and High Band in kHz (11700000 for Ku-Band)</param>
            /// <param name="minsr">The minimum acceptable symbol rate. Depending on your tuner you either want 200 or 1000.</param>
            /// <param name="std">The network type</param>
            /// <param name="pSearchResult">The exact tuning data</param>
            /// <returns>Whether a channel could be found</returns>
            [DllImport("StreamReader.dll", EntryPoint = "BLScanEx")]
            internal static extern bool BLScanEx(int freq, int freq_range, int pol, int lof1, int lof2, int lofsw,
                int minsr, STD_TYPE std, ref SearchResult pSearchResult);
            
            /// <summary>
            /// Performs a blind scan on a satellite network.
            /// This method blocks until the scan is complete.
            /// </summary>
            /// <param name="freq_start">The frequency to the start the scan on in kHz (10700000 for Ku-Band)</param>
            /// <param name="freq_stop">The frequency to end the scan on in kHz (12750000 for Ku-Band)</param>
            /// <param name="pol">0 for horizontal, 1 for vertical.</param>
            /// <param name="lof1">Local Oscillator Frequency 1 of the LNB in kHz. (9750000 for Ku-Band)</param>
            /// <param name="lof2">Local Oscillator Frequency 2 of the LNB in kHz. (10600000 for Ku-Band)</param>
            /// <param name="lofsw">Border Frequency for switching between Low Band and High Band in kHz (11700000 for Ku-Band)</param>
            /// <param name="pSearchResult">The struct to put the last found channel in.</param>
            /// <param name="pTpNum">Number of channels found.</param>
            /// <param name="lpFunc">The function to call when a channel was found.</param>
            /// <returns>Whether the blind scan was performed sucessfully.</returns>
            [DllImport("StreamReader.dll", EntryPoint = "BLScan2")]
            public static extern bool BLScan2(int freq_start, int freq_stop, int pol, int lof1, int lof2, int lofsw,
                IntPtr pSearchResult, ref int pTpNum, [MarshalAs(UnmanagedType.FunctionPtr)] BlScanCallback lpFunc);

            /// <summary>
            /// Retrieve extended carrier info after lock for a sattelite signal.
            /// </summary>
            /// <param name="pSearchResult">Struct to output the data to</param>
            /// <returns>Whether the carrier info could be read.</returns>
            [DllImport("StreamReader.dll", EntryPoint = "SignalInfo")]
            public static extern bool SignalInfo(ref SearchResult pSearchResult);

            /// <summary>
            /// Read constellation data for a satellite signal.
            /// </summary>
            /// <param name="input">Type of constellation data to read. You probably want 0.</param>
            /// <param name="pIQ">Output Array</param>
            /// <param name="num">Number of Constellation points to read. Must be (pIQ.Length / 2)</param>
            /// <returns>Whether the constellation data was read</returns>
            [DllImport("StreamReader.dll", EntryPoint = "IQScan")]
            internal static extern bool IQScan(uint input, sbyte[] pIQ, uint num);

            /// <summary>
            /// Read constellation data for a non-satellite signal.
            /// </summary>
            /// <param name="input">Type of constellation data to read. You probably want 0.</param>
            /// <param name="pIQ">Output Array</param>
            /// <param name="num">Number of Constellation points to read. Must be (pIQ.Length / 2)</param>
            /// <returns>Whether the constellation data was read</returns>
            [DllImport("StreamReader.dll", EntryPoint = "IQScan2")]
            internal static extern bool IQScan2(uint point, short[] pIQ, uint num);

            [DllImport("StreamReader.dll", EntryPoint = "IQScan2Range")]
            internal static extern bool IQScan2Range(byte input, ref ushort pMinPoint, ref ushort pMaxPoint);

            [DllImport("StreamReader.dll", EntryPoint = "CIRScanRange")]
            internal static extern bool CIRScanRange(bool bHiRes, ref ushort pMinCnum, ref ushort pMaxCnum,
                ref int pMinDelayNs, ref int pMaxDelayNs);

            [DllImport("StreamReader.dll", EntryPoint = "CIRScan")]
            internal static extern bool CIRScan(bool bHiRes, int[] pPowers, int[] pDelays);

            [DllImport("StreamReader.dll", EntryPoint = "CarRange")]
            internal static extern bool CarRange(ref ushort pMinCnum, ref ushort pMaxCnum);

            [DllImport("StreamReader.dll", EntryPoint = "CarEsNo")]
            internal static extern bool CarEsNo(ref ushort cnum, ref double pEsNo);

            [DllImport("StreamReader.dll", EntryPoint = "MISSel")]
            public static extern bool MISSel(bool bEnable, byte misFilter, byte misFilterMask);

            /// <summary>
            /// Sets the Physical Layer Scrambling credentials.
            /// </summary>
            /// <param name="plsMode">The PLS mode.</param>
            /// <param name="code">The PLS key.</param>
            /// <returns>Whether the tuner complied.</returns>
            [DllImport("StreamReader.dll", EntryPoint = "PLSSel")]
            internal static extern bool PLSSel(byte plsMode, uint code);

            /// <summary>
            /// Gets the current Physical Layer Scrambling key.
            /// </summary>
            /// <param name="pMode">The pointer to write the PLS Mode in.</param>
            /// <param name="pCode">The pointer to write the PLS Key in.</param>
            /// <returns>Whether the tuner sent valid PLS credentials.</returns>
            [DllImport("StreamReader.dll", EntryPoint = "PLSGet")]
            internal static extern bool PLSGet(byte pMode, ref uint pCode);

            [DllImport("StreamReader.dll", EntryPoint = "ModSel")]
            internal static extern bool ModSel(ref S2Mode ps2Modes, uint num);

            [DllImport("StreamReader.dll", EntryPoint = "ModInv")]
            internal static extern bool ModInv(uint WaitMs, ref S2Mode pS2Modes, ref uint pNum);

            /// <summary>
            /// Tune to DVB-T2 / DVB-C Channel
            /// </summary>
            /// <param name="freq">Frequency in kHz</param>
            /// <param name="bandwidth">Channel Bandwidth in kHz (usually 8000)</param>
            /// <returns>Whether the tuner complied with the request.</returns>
            [DllImport("StreamReader.dll", EntryPoint = "SetChannel2")]
            public static extern bool SetChannel2(uint freq, uint bandwidth);

            /// <summary>
            /// Tune to DVB-T2 / DVB-C channel.
            /// </summary>
            /// <param name="freq">Frequency in kH</param>
            /// <param name="bandwidth">Channel Bandwidth in kHz (usually 8000)</param>
            /// <param name="std">Type of network</param>
            /// <param name="stream">??? (Setting this to 0 works.)</param>
            /// <returns>Whether the tuner complied with the request.</returns>
            [DllImport("StreamReader.dll", EntryPoint = "SetChannel2Ex")]
            internal static extern bool SetChannel2Ex(uint freq, uint bandwidth, STD_TYPE std, int stream);

            /// <summary>
            /// Tune to DVB-T2 / DVB-C Channel. Beware, will freeze for a minute when SymbolRate is wrong.
            /// </summary>
            /// <param name="freq">Frequency in kHz</param>
            /// <param name="bandwidth">Channel Bandwidth in kHz (usually 8000)</param>
            /// <param name="symbrate">Sybol Rate in kiloSymbols (6900000 for Vodafone)</param>
            /// <param name="std">Type of network</param>
            /// <param name="stream">??? Setting this to 0 works.</param>
            /// <returns>Whether the tuner complied with the request.</returns>
            [DllImport("StreamReader.dll", EntryPoint = "SetChannel2ExEx")]
            internal static extern bool SetChannel2ExEx(uint freq, uint bandwidth, uint symbrate, STD_TYPE std,
                int stream);

            /// <summary>
            /// Retrieve extended carrier info after lock for a non-sattelite signal.
            /// </summary>
            /// <param name="si2">Outputs the Signal information</param>
            /// <returns>Whether the signal information was read sucessfully</returns>
            [DllImport("StreamReader.dll", EntryPoint = "SignalInfo2")]
            public static extern bool SignalInfo2(ref SearchResult2 si2);


            /// <summary>
            /// Get RF Level from FM / UHF / VHF Frequency
            /// </summary>
            /// <param name="freq">Frequency in kHz</param>
            /// <param name="std">TunerMetadata standard</param>
            /// <param name="pRFLevel">Output pointer</param>
            /// <returns>whether the operation completed sucessfully</returns>
            [DllImport("StreamReader.dll", EntryPoint = "RFScan2")]
            internal static extern bool RFScan2(uint freq, STD_TYPE std, ref double pRFLevel);

            /// <summary>
            /// Performs a blind scan on non-satellite networks.
            /// This method blocks until the scan is complete!
            /// </summary>
            /// <param name="freq_start">Starting Frequency in kHz</param>
            /// <param name="freq_stop">End Frequency in kHz</param>
            /// <param name="step">Frequency increment in kHz (3000 is usually a safe choice here)</param>
            /// <param name="bandwidth">System bandwidth (usually 8000)</param>
            /// <param name="std">Type of Network</param>
            /// <param name="pSearchResult">Outputs the final channel. Not really necessary.</param>
            /// <param name="pTpNum">Outputs the number of channels.</param>
            /// <param name="lpFunc">Function to call when a channel was found.</param>
            /// <returns>Whether the scan was performed sucessfully</returns>
            [DllImport("StreamReader.dll", EntryPoint = "AirScan")]
            public static extern bool AirScan(int freq_start, int freq_stop, uint step, uint bandwidth, int std,
                IntPtr pSearchResult, ref int pTpNum, [MarshalAs(UnmanagedType.FunctionPtr)] AirScanCallback lpFunc);

            /// <summary>
            /// Reads from the EEPROM of the tuner.
            /// </summary>
            /// <param name="buffer">Buffer to put the read data in.</param>
            /// <param name="offset">Offset from where to start reading from the EEPROM</param>
            /// <param name="len">How many bytes to read</param>
            /// <returns>Wheter the reading operation was sucessful.</returns>
            [DllImport("StreamReader.dll", EntryPoint = "GetEEPROM")]
            internal static extern bool GetEEPROM(byte[] buffer, int offset, int len);

            /// <summary>
            /// Supposed to write data to the device's EEPROM.
            /// This method is not implemented on purpose because I neither have the balls to try
            /// this, nor the money to replace my tuner in case I mess up.
            /// This will throw a NotSupportedException when calling this.
            /// </summary>
            /// <param name="buffer">Buffer of data to write to the EEPROM.</param>
            /// <param name="offset">Offset in the EEPROM to start writing.</param>
            /// <param name="len">How many bytes to write to the EEPROM</param>
            /// <returns>Throws NotSupportedException</returns>
            internal static bool SetEEPROM(byte[] buffer, int offset, int len)
            {
                //I'm not willing to try this out. TBS Tuners are way too expensive for me than to
                //mess with their firmware.
                throw new NotSupportedException();
            }
        }
    }
}