Ejemplo n.º 1
0
        public static CertPrivateKey ImportPrivateKey(EncodingFormat fmt, Stream source)
        {
            if (fmt != EncodingFormat.PEM)
            {
                throw new NotSupportedException("Unsupported archive format");
            }

            using (var tr = new StreamReader(source))
            {
                var pr   = new PemReader(tr);
                var pem  = pr.ReadObject();
                var ackp = pem as AsymmetricCipherKeyPair;

                if (ackp != null)
                {
                    var rsa = ackp.Private as RsaPrivateCrtKeyParameters;
                    if (rsa != null)
                    {
                        return(new CertPrivateKey
                        {
                            KeyPair = ackp,
                        });
                    }
                }

                throw new InvalidDataException("could not read source as PEM private key");
            }
        }
        private static string getStringfromEncodingFormat(EncodingFormat format)
        {
            switch (format)
            {
            case EncodingFormat.PNG:
                return(".png");

            case EncodingFormat.JPEG:
                return(".jpg");

            case EncodingFormat.TIFF:
                return(".tif");

            case EncodingFormat.WebP:
                return(".webp");

            case EncodingFormat.Bitmap:
                return(".bmp");

            case EncodingFormat.JPEG2000:
                return(".jp2");

            case EncodingFormat.PBM:
                return(".pbm");

            case EncodingFormat.Raster:
                return(".ras");

            default:
                throw new ArgumentOutOfRangeException($@"""{nameof(format)}"" is not a valid export format.");
            }
        }
Ejemplo n.º 3
0
        // For reading mips_encode.dat
        public void ReadEncodeList()
        {
            StreamReader reader = new StreamReader("mips_encode.dat");

            try
            {
                while (reader.Peek() != -1)
                {
                    string line = reader.ReadLine();
                    line = RemoveSpaces(line);
                    string[] lineArray = line.Split(':');

                    EncodingFormat encoding = new EncodingFormat();
                    encoding.command = lineArray[0];
                    encoding.type    = Convert.ToInt32(lineArray[1]);
                    encoding.format  = lineArray[2];

                    encodeList.Add(encoding);
                }
            }
            catch
            {
            }
            finally
            {
                reader.Close();
            }
        }
Ejemplo n.º 4
0
        public override void ExportCertificate(Crt cert, EncodingFormat fmt, Stream target)
        {
            string outform;

            switch (fmt)
            {
            case EncodingFormat.PEM:
                outform = "PEM";
                break;

            case EncodingFormat.DER:
                outform = "DER";
                break;

            default:
                throw new NotSupportedException("unsupported encoding format");
            }

            var tempSource = Path.GetTempFileName();
            var tempTarget = Path.GetTempFileName();

            try
            {
                File.WriteAllText(tempSource, cert.Pem);
                RunCli($"x509 -inform PEM -in {tempSource} -outform {outform} -out {tempTarget}");
                var targetBytes = File.ReadAllBytes(tempTarget);
                target.Write(targetBytes, 0, targetBytes.Length);
            }
            finally
            {
                File.Delete(tempSource);
                File.Delete(tempTarget);
            }
        }
Ejemplo n.º 5
0
 public override Csr ImportCsr(EncodingFormat fmt, Stream source)
 {
     if (fmt == EncodingFormat.PEM)
     {
         using (var tr = new StreamReader(source))
         {
             PemReader pr  = new PemReader(tr);
             var       csr = (Pkcs10CertificationRequest)pr.ReadObject();
             return(new Csr(ToCsrPem(csr)));
         }
     }
     else if (fmt == EncodingFormat.DER)
     {
         using (var ms = new MemoryStream())
         {
             source.CopyTo(ms);
             var csr = new Pkcs10CertificationRequest(ms.ToArray());
             return(new Csr(ToCsrPem(csr)));
         }
     }
     else
     {
         throw new NotSupportedException("unsupported encoding format");
     }
 }
Ejemplo n.º 6
0
        public string Encode() => this.Encode(WorkflowSymbol.DefaultEncodingFormat); // default format

        /// <summary>
        /// Encodes the specified encoding format.
        /// </summary>
        /// <param name="encodingFormat">The encoding format.</param>
        /// <returns>System.String.</returns>
        /// <exception cref="SerializationException"></exception>
        internal string Encode(EncodingFormat encodingFormat)
        {
            using var ms     = new MemoryStream();
            using var writer = new BinaryWriter(ms);
            if (this.checksum != null)
            {
                writer.Write((byte)(encodingFormat | EncodingFormat.Checksum));
                SymbolHelper.WriteEncodedInt32(writer, this.checksum.Length);
                writer.Write(this.checksum);
            }
            else
            {
                writer.Write((byte)encodingFormat);
            }
            switch (encodingFormat)
            {
            case EncodingFormat.Binary:
                this.Write(writer);
                break;

            case EncodingFormat.String:
                writer.Write(this.ToString());
                break;

            default:
                throw FxTrace.Exception.AsError(new SerializationException());
            }

            // Need to copy to a buffer to trim excess capacity.
            var buffer = new byte[ms.Length];

            Array.Copy(ms.GetBuffer(), buffer, ms.Length);
            return(Convert.ToBase64String(buffer));
        }
Ejemplo n.º 7
0
        // Decode from Base64 string.
        public static WorkflowSymbol Decode(string symbolString)
        {
            byte[] data = Convert.FromBase64String(symbolString);
            using (BinaryReader reader = new BinaryReader(new MemoryStream(data)))
            {
                byte[]         checksum          = null;
                EncodingFormat format            = (EncodingFormat)reader.ReadByte();
                int            payloadBytesCount = data.Length - sizeof(EncodingFormat);
                if (0 != (format & EncodingFormat.Checksum))
                {
                    int bytesCount = SymbolHelper.ReadEncodedInt32(reader);
                    checksum           = reader.ReadBytes(bytesCount);
                    payloadBytesCount -= SymbolHelper.GetEncodedSize(bytesCount);
                    format            &= (~EncodingFormat.Checksum);
                }
                switch (format)
                {
                case EncodingFormat.Binary:
                    return(ParseBinary(reader.ReadBytes(payloadBytesCount), checksum));    // Compute the

                case EncodingFormat.String:
                    return(ParseStringRepresentation(reader.ReadString(), checksum));
                }
            }
            throw FxTrace.Exception.AsError(new SerializationException());
        }
Ejemplo n.º 8
0
        public override PrivateKey ImportPrivateKey <PK>(EncodingFormat fmt, Stream source)
        {
            if (typeof(PK) == typeof(RsaPrivateKey))
            {
                using (var tr = new StreamReader(source))
                {
                    var pr   = new PemReader(tr);
                    var pem  = pr.ReadObject();
                    var ackp = pem as AsymmetricCipherKeyPair;

                    if (ackp != null)
                    {
                        var rsa = ackp.Private as RsaPrivateCrtKeyParameters;
                        if (rsa != null)
                        {
                            return(new RsaPrivateKey(
                                       rsa.Modulus.BitLength,
                                       rsa.Exponent.ToString(16),
                                       ToPrivatePem(ackp)));
                        }
                    }
                }

                throw new NotSupportedException("unsupported or invalid private key PEM content");
            }
            else
            {
                throw new NotSupportedException("unsupported private key type");
            }
        }
Ejemplo n.º 9
0
        public XnaRecorder(Stream stream, EncodingFormat format, int preset)
        {
            if (stream == null)
            {
                throw new ArgumentNullException("stream");
            }

            _stream     = stream;
            _sampleRate = 16000;
            _bitRate    = 16;
            _channels   = 1;
            _format     = format;
            _preset     = preset;

            _size     = 0;
            _duration = 0;
            _state    = RecorderState.Unknown;

            InitializeMicrophone();

            if (_format == EncodingFormat.Wave)
            {
                _writer = new WaveWriter(_stream, _sampleRate, _bitRate, _channels);
            }
            else if (_format == EncodingFormat.MP3)
            {
                _writer = new Mp3Writer(_stream, _sampleRate, _bitRate, _channels, (LAMEPreset)_preset);
            }
        }
Ejemplo n.º 10
0
        public void AsyncClientShouldNotThrowExceptionWithInvalidCredential()
        {
            client.UserId = "invalid_id";
            client.UserKey = "invalid_key";

            Assert.DoesNotThrow(() =>
            {
                client.GetMediaListAsync(
                (mediaList) =>
                {
                },
                (errors) =>
                {
                });
            });

            Uri[] sources = new Uri[]{};
            EncodingFormat[] formats = new EncodingFormat[]{};

            Assert.DoesNotThrow(() =>
            {
                client.AddMediaAsync(sources, formats,
                (mediaId) =>
                {
                },
                (errors) =>
                {
                });
            });
        }
Ejemplo n.º 11
0
        public override PrivateKey ImportPrivateKey <PK>(EncodingFormat fmt, Stream source)
        {
            if (typeof(PK) == typeof(RsaPrivateKey))
            {
                using (BIO keyBio = BIO.MemoryBuffer())
                {
                    using (var ms = new MemoryStream())
                    {
                        source.CopyTo(ms);
                        keyBio.Write(ms.ToArray());
                    }

                    using (var key = CryptoKey.FromPrivateKey(keyBio, null))
                    {
                        var rsa = key.GetRSA();
                        return(new RsaPrivateKey(rsa.Size,
                                                 rsa.PrivateExponent.ToHexString(),
                                                 rsa.PrivateKeyAsPEM));
                    }
                }
            }
            else
            {
                throw new NotSupportedException("unsupported private key type");
            }
        }
 public void TestImportRsaPrivatekey(EncodingFormat fmt, string filePath)
 {
     using (var cp = GetCP())
     {
         using (var source = new FileStream(filePath, FileMode.Open))
         {
             var pk = cp.ImportPrivateKey<RsaPrivateKey>(fmt, source);
         }
     }
 }
Ejemplo n.º 13
0
 private void TestImportCertificate(EncodingFormat fmt, string filePath)
 {
     using (var cp = CertificateProvider.GetProvider())
     {
         using (var source = new FileStream(filePath, FileMode.Open))
         {
             var crt = cp.ImportCertificate(fmt, source);
         }
     }
 }
Ejemplo n.º 14
0
 public void TestImportRsaPrivatekey(EncodingFormat fmt, string filePath)
 {
     using (var cp = GetCP())
     {
         using (var source = new FileStream(filePath, FileMode.Open))
         {
             var pk = cp.ImportPrivateKey <RsaPrivateKey>(fmt, source);
         }
     }
 }
        /// <summary>
        /// Create a new virtual camera device from a file.
        /// </summary>
        /// <param name="filePath">File relative to the executing application.</param>
        /// <param name="format">Image format used for encoding.</param>
        /// <param name="encodingParams">An array of parameters used for encoding.</param>
        public CameraVirtual(string filePath, EncodingFormat format = EncodingFormat.PNG, Dictionary <ImwriteFlags, int> encodingParams = null)
            : base(format, encodingParams)
        {
            if (!File.Exists(filePath))
            {
                throw new FileNotFoundException($"\"{filePath}\" is not found.");
            }

            FilePath = filePath;
            Capture  = new VideoCapture(FilePath, api);
        }
Ejemplo n.º 16
0
        static String toHexAddr(Byte[] rawData, EncodingFormat format, Int32 start, Int32 count, Boolean forceUpperCase)
        {
            count = getCount(rawData.Length, start, count);
            StringBuilder SB = new StringBuilder();
            Int32         rowCount = 0, n = 0;
            Int32         addrLength = getAddrLength(rawData.Length);

            for (Int32 index = start; index < start + count; index++)
            {
                if (n % 16 == 0)
                {
                    String addr = Convert.ToString(rowCount, 16).PadLeft(addrLength, '0');
                    if (forceUpperCase)
                    {
                        addr = addr.ToUpper();
                    }
                    SB.Append(addr);
                    SB.Append("    ");
                    rowCount += 16;
                }
                byteToHexOctet(SB, rawData[index], forceUpperCase);
                if (index == start)
                {
                    SB.Append(" ");
                    n++;
                    continue;
                }
                if ((n + 1) % 16 == 0)
                {
                    SB.Append(format == EncodingFormat.NOCR ? "\n" : "\r\n");
                }
                else if ((n + 1) % 8 == 0)
                {
                    SB.Append("  ");
                }
                else
                {
                    SB.Append(" ");
                }
                n++;
            }
            switch (format)
            {
            case EncodingFormat.NOCR:
                SB.Append('\n'); break;

            case EncodingFormat.NOCRLF:
                break;

            default:
                SB.Append("\r\n"); break;
            }
            return(SB.ToString());
        }
Ejemplo n.º 17
0
        private static WaveFormatEncoding GetWaveEncodingFormat(EncodingFormat encoding)
        {
            switch (encoding)
            {
            case EncodingFormat.Pcm:
                return(WaveFormatEncoding.LPCM);

            default:
                return(WaveFormatEncoding.Unknown);
            }
        }
Ejemplo n.º 18
0
        static String toHex(Byte[] rawData, EncodingFormat format, Int32 start, Int32 count, Boolean forceUpperCase)
        {
            count = getCount(rawData.Length, start, count);
            StringBuilder SB = new StringBuilder();
            //if (format == EncodingFormat.NOCRLF) {
            //	for (Int32 i = start; i < start + count; i++) {
            //byteToHexOctet(SB, rawData[i], forceUpperCase);
            //}
            //	return SB.Remove(SB.Length - 1, 1).ToString();
            //}
            Int32 n = 0;

            for (Int32 index = start; index < start + count; index++)
            {
                n++;
                byteToHexOctet(SB, rawData[index], forceUpperCase);
                if (index == start)
                {
                    SB.Append(" ");
                    continue;
                }
                if (n % 16 == 0)
                {
                    switch (format)
                    {
                    case EncodingFormat.NOCRLF: SB.Append(" "); break;

                    case EncodingFormat.CRLF: SB.Append("\r\n"); break;

                    case EncodingFormat.NOCR: SB.Append("\n"); break;
                    }
                }
                else if (n % 8 == 0 && format != EncodingFormat.NOCRLF)
                {
                    SB.Append("  ");
                }
                else
                {
                    SB.Append(" ");
                }
            }
            switch (format)
            {
            case EncodingFormat.NOCR:
                SB.Append('\n'); break;

            case EncodingFormat.NOCRLF:
                break;

            default:
                SB.Append("\r\n"); break;
            }
            return(SB.ToString());
        }
        private void TestExportRsaPrivateKey(EncodingFormat fmt)
        {
            using (var cp = GetCP())
            {
                var pkp = new RsaPrivateKeyParams();
                var pk = cp.GeneratePrivateKey(pkp);

                using (var target = new MemoryStream())
                {
                    cp.ExportPrivateKey(pk, fmt, target);
                }
            }
        }
Ejemplo n.º 20
0
        private void TestExportRsaPrivateKey(EncodingFormat fmt)
        {
            using (var cp = GetCP())
            {
                var pkp = new RsaPrivateKeyParams();
                var pk  = cp.GeneratePrivateKey(pkp);

                using (var target = new MemoryStream())
                {
                    cp.ExportPrivateKey(pk, fmt, target);
                }
            }
        }
Ejemplo n.º 21
0
 public SpeechAudioFormatInfo(EncodingFormat encodingFormat, int samplesPerSecond, int bitsPerSample, int channelCount, int averageBytesPerSecond, int blockAlign, byte[] formatSpecificData)
     : this(encodingFormat, samplesPerSecond, (short)bitsPerSample, (short)channelCount, formatSpecificData)
 {
     if (averageBytesPerSecond <= 0)
     {
         throw new ArgumentOutOfRangeException("averageBytesPerSecond", SR.Get(SRID.MustBeGreaterThanZero));
     }
     if (blockAlign <= 0)
     {
         throw new ArgumentOutOfRangeException("blockAlign", SR.Get(SRID.MustBeGreaterThanZero));
     }
     _averageBytesPerSecond = averageBytesPerSecond;
     _blockAlign            = (short)blockAlign;
 }
Ejemplo n.º 22
0
        public WasapiRecorder(Stream stream, int sampleRate, int bitRate, int channels, EncodingFormat format, int preset)
        {
            if (stream == null)
            {
                throw new ArgumentNullException("stream");
            }

            if (channels != 1 && channels != 2)
            {
                throw new ArgumentException(string.Format("Unsupported number of channels {0}", channels), "channels");
            }

            if (bitRate != 16)
            {
                throw new ArgumentException(string.Format("Unsupported PCM sample size {0}", bitRate), "bitRate");
            }

            if (sampleRate < 8000 || sampleRate > 48000)
            {
                throw new ArgumentException(string.Format("Unsupported Sample Rate {0}", sampleRate), "sampleRate");
            }

            _stream     = stream;
            _sampleRate = sampleRate;
            _bitRate    = bitRate;
            _channels   = channels;
            _format     = format;
            _preset     = preset;

            _capture = new AudioCapture();
            _capture.SetCaptureFormat(_sampleRate, (ushort)_channels, (ushort)_bitRate);

            _size     = 0;
            _duration = 0;
            _state    = RecorderState.Unknown;

            if (_format == EncodingFormat.Wave)
            {
                _writer = new WaveWriter(_stream, _sampleRate, _bitRate, _channels);
            }
            else if (_format == EncodingFormat.MP3)
            {
                _writer = new Mp3Writer(_stream, _sampleRate, _bitRate, _channels, (LAMEPreset)_preset);
            }

            _timer          = new DispatcherTimer();
            _timer.Interval = TimeSpan.FromMilliseconds(33);
            _timer.Tick    += OnSampleReceived;
        }
Ejemplo n.º 23
0
        private void TestExportCertificate(EncodingFormat fmt, string filePath)
        {
            using (var cp = CertificateProvider.GetProvider())
            {
                using (var source = new FileStream(filePath, FileMode.Open))
                {
                    var crt = cp.ImportCertificate(fmt, source);

                    using (var target = new MemoryStream())
                    {
                        cp.ExportCertificate(crt, fmt, target);
                    }
                }
            }
        }
Ejemplo n.º 24
0
 public SpeechAudioFormatInfo(EncodingFormat encodingFormat, int samplesPerSecond, int bitsPerSample, int channelCount, int averageBytesPerSecond, int blockAlign, byte[] formatSpecificData)
     : this(encodingFormat, samplesPerSecond, (short)bitsPerSample, (short)channelCount, formatSpecificData)
 {
     // Don't explicitly check these are sensible values - allow flexibility here as some formats may do unexpected things here.
     if (averageBytesPerSecond <= 0)
     {
         throw new ArgumentOutOfRangeException(nameof(averageBytesPerSecond), SR.Get(SRID.MustBeGreaterThanZero));
     }
     if (blockAlign <= 0)
     {
         throw new ArgumentOutOfRangeException(nameof(blockAlign), SR.Get(SRID.MustBeGreaterThanZero));
     }
     _averageBytesPerSecond = averageBytesPerSecond;
     _blockAlign            = (short)blockAlign;
 }
        /// <summary>
        /// Create a new virtual camera device from a <see cref="Stream"/>.
        /// </summary>
        /// <param name="stream">A video stream.</param>
        /// <param name="format">Image format used for encoding.</param>
        /// <param name="encodingParams">An array of parameters used for encoding.</param>
        public CameraVirtual(Stream stream, EncodingFormat format = EncodingFormat.PNG, Dictionary <ImwriteFlags, int> encodingParams = null)
            : base(format, encodingParams)
        {
            if (stream == null)
            {
                throw new NullReferenceException($"{nameof(stream)} cannot be null.");
            }

            FilePath = Path.Combine(Path.GetTempPath(), Guid.NewGuid().ToString());

            using (var file = File.Create(FilePath))
                stream.CopyTo(file);

            Capture     = new VideoCapture(FilePath, api);
            hasTempFile = true;
        }
Ejemplo n.º 26
0
        private SpeechAudioFormatInfo(EncodingFormat encodingFormat, int samplesPerSecond, short bitsPerSample, short channelCount, byte[] formatSpecificData)
        {
            if (encodingFormat == 0)
            {
                throw new ArgumentException(SR.Get(SRID.CannotUseCustomFormat), nameof(encodingFormat));
            }
            if (samplesPerSecond <= 0)
            {
                throw new ArgumentOutOfRangeException(nameof(samplesPerSecond), SR.Get(SRID.MustBeGreaterThanZero));
            }
            if (bitsPerSample <= 0)
            {
                throw new ArgumentOutOfRangeException(nameof(bitsPerSample), SR.Get(SRID.MustBeGreaterThanZero));
            }
            if (channelCount <= 0)
            {
                throw new ArgumentOutOfRangeException(nameof(channelCount), SR.Get(SRID.MustBeGreaterThanZero));
            }

            _encodingFormat   = encodingFormat;
            _samplesPerSecond = samplesPerSecond;
            _bitsPerSample    = bitsPerSample;
            _channelCount     = channelCount;
            if (formatSpecificData == null)
            {
                _formatSpecificData = Array.Empty <byte>();
            }
            else
            {
                _formatSpecificData = (byte[])formatSpecificData.Clone();
            }

            switch (encodingFormat)
            {
            case EncodingFormat.ALaw:
            case EncodingFormat.ULaw:
                if (bitsPerSample != 8)
                {
                    throw new ArgumentOutOfRangeException(nameof(bitsPerSample));
                }
                if (formatSpecificData != null && formatSpecificData.Length != 0)
                {
                    throw new ArgumentOutOfRangeException(nameof(formatSpecificData));
                }
                break;
            }
        }
        public override void ExportPrivateKey(PrivateKey pk, EncodingFormat fmt, Stream target)
        {
            var rsaPk = pk as CeRsaPrivateKey;

            if (rsaPk == null)
            {
                throw new NotSupportedException("unsupported private key type");
            }

            var cePk = new CERTENROLLLib.CX509PrivateKey();

            // MS_DEF_PROV
            //cePk.ProviderName = "Microsoft Base Cryptographic Provider";
            cePk.ProviderName = "Microsoft Enhanced Cryptographic Provider v1.0";

            // Don't store in the machine's local cert store and allow exporting of private key
            cePk.MachineContext = false;
            cePk.ExportPolicy   = CERTENROLLLib.X509PrivateKeyExportFlags.XCN_NCRYPT_ALLOW_EXPORT_FLAG;



            cePk.Import(BCRYPT_PRIVATE_KEY_BLOB, rsaPk.Exported);

            if (fmt == EncodingFormat.PEM)
            {
                var pem = cePk.Export(BCRYPT_PRIVATE_KEY_BLOB,
                                      CERTENROLLLib.EncodingType.XCN_CRYPT_STRING_BASE64HEADER);
                var pemBytes = Encoding.UTF8.GetBytes(pem);
                target.Write(pemBytes, 0, pemBytes.Length);
            }
            else if (fmt == EncodingFormat.DER)
            {
                // TODO: Verify this is DER, not quite sure
                var der = cePk.Export(BCRYPT_PRIVATE_KEY_BLOB,
                                      CERTENROLLLib.EncodingType.XCN_CRYPT_STRING_BINARY);
                var derBytes = new byte[der.Length];
                for (int i = 0; i < derBytes.Length; ++i)
                {
                    derBytes[i] = (byte)der[i];
                }
                target.Write(derBytes, 0, derBytes.Length);
            }
            else
            {
                throw new NotSupportedException("unsupported encoding format");
            }
        }
Ejemplo n.º 28
0
        /// <summary>
        /// Support exporting CSR to <see cref="EncodingFormat.PEM">PEM</see> format.
        /// </summary>
        public override void ExportPrivateKey(PrivateKey pk, EncodingFormat fmt, Stream target)
        {
            var rsaPk = pk as RsaPrivateKey;

            if (rsaPk == null)
            {
                throw new NotSupportedException("unsupported private key type");
            }

            if (fmt == EncodingFormat.PEM)
            {
                var bytes = Encoding.UTF8.GetBytes(rsaPk.Pem);
                target.Write(bytes, 0, bytes.Length);
            }
            else
            {
                throw new NotSupportedException("unsupported encoding format");
            }
        }
Ejemplo n.º 29
0
        public static void ExportPrivateKey(CertPrivateKey pk, EncodingFormat fmt, Stream target)
        {
            switch (fmt)
            {
            case EncodingFormat.PEM:
                var pem   = ToPrivatePem(pk.KeyPair);
                var bytes = Encoding.UTF8.GetBytes(pem);
                target.Write(bytes, 0, bytes.Length);
                break;

            case EncodingFormat.DER:
                var der = PrivateKeyInfoFactory.CreatePrivateKeyInfo(pk.KeyPair.Private).GetDerEncoded();
                target.Write(der, 0, der.Length);
                break;

            default:
                throw new NotSupportedException("unsupported encoding format");
            }
        }
Ejemplo n.º 30
0
 /// <summary>
 /// Supports importing certificates from <see cref="EncodingFormat.PEM">PEM</see>
 /// and <see cref="EncodingFormat.DER">DER</see> formats.
 /// </summary>
 public override Crt ImportCertificate(EncodingFormat fmt, Stream source)
 {
     if (fmt == EncodingFormat.DER)
     {
         using (var ms = new MemoryStream())
         {
             source.CopyTo(ms);
             using (var bio = BIO.MemoryBuffer())
             {
                 bio.Write(ms.ToArray());
                 using (var x509 = X509Certificate.FromDER(bio))
                 {
                     return(new Crt
                     {
                         Pem = x509.PEM
                     });
                 }
             }
         }
     }
     else if (fmt == EncodingFormat.PEM)
     {
         using (var r = new StreamReader(source))
         {
             using (var bio = BIO.MemoryBuffer())
             {
                 bio.Write(r.ReadToEnd());
                 using (var x509 = new X509Certificate(bio))
                 {
                     return(new Crt
                     {
                         Pem = x509.PEM
                     });
                 }
             }
         }
     }
     else
     {
         throw new NotSupportedException("encoding format has not been implemented");
     }
 }
Ejemplo n.º 31
0
 private SpeechAudioFormatInfo(EncodingFormat encodingFormat, int samplesPerSecond, short bitsPerSample, short channelCount, byte[] formatSpecificData)
 {
     if (encodingFormat == (EncodingFormat)0)
     {
         throw new ArgumentException(SR.Get(SRID.CannotUseCustomFormat), "encodingFormat");
     }
     if (samplesPerSecond <= 0)
     {
         throw new ArgumentOutOfRangeException("samplesPerSecond", SR.Get(SRID.MustBeGreaterThanZero));
     }
     if (bitsPerSample <= 0)
     {
         throw new ArgumentOutOfRangeException("bitsPerSample", SR.Get(SRID.MustBeGreaterThanZero));
     }
     if (channelCount <= 0)
     {
         throw new ArgumentOutOfRangeException("channelCount", SR.Get(SRID.MustBeGreaterThanZero));
     }
     _encodingFormat   = encodingFormat;
     _samplesPerSecond = samplesPerSecond;
     _bitsPerSample    = bitsPerSample;
     _channelCount     = channelCount;
     if (formatSpecificData == null)
     {
         _formatSpecificData = new byte[0];
     }
     else
     {
         _formatSpecificData = (byte[])formatSpecificData.Clone();
     }
     if ((uint)(encodingFormat - 6) <= 1u)
     {
         if (bitsPerSample != 8)
         {
             throw new ArgumentOutOfRangeException("bitsPerSample");
         }
         if (formatSpecificData != null && formatSpecificData.Length != 0)
         {
             throw new ArgumentOutOfRangeException("formatSpecificData");
         }
     }
 }
        public override Crt ImportCertificate(EncodingFormat fmt, Stream source)
        {
            if (fmt == EncodingFormat.DER)
            {
                var x509 = new X509Certificate2();
                using (var ms = new MemoryStream())
                {
                    source.CopyTo(ms);
                    x509.Import(ms.ToArray());
                }

                var crt = new Crt
                {
                    Pem = Convert.ToBase64String(x509.RawData),
                };
                return(crt);
            }

            throw new NotSupportedException("unsupported encoding format");
        }
Ejemplo n.º 33
0
        private void TestImportRsaCsr(EncodingFormat fmt)
        {
            using (var cp = CertificateProvider.GetProvider())
            {
                var pkp = new RsaPrivateKeyParams();
                var pk  = cp.GeneratePrivateKey(pkp);

                var crp = new CsrParams
                {
                    Details = new CsrDetails
                    {
                        CommonName = "TEST CERT",
                    }
                };

                var    csr = cp.GenerateCsr(crp, pk, Crt.MessageDigest.SHA256);
                byte[] bytes;
                using (var target = new MemoryStream())
                {
                    cp.ExportCsr(csr, fmt, target);
                    bytes = target.ToArray();
                }

                var imp = csr;
                using (var source = new MemoryStream(bytes))
                {
                    imp = cp.ImportCsr(fmt, source);
                }

                using (MemoryStream save1 = new MemoryStream(), save2 = new MemoryStream())
                {
                    cp.SaveCsr(csr, save1);
                    cp.SaveCsr(imp, save2);

                    var bytes1 = save1.ToArray();
                    var bytes2 = save2.ToArray();

                    CollectionAssert.AreEqual(bytes1, bytes2);
                }
            }
        }
        private void TestExportRsaCsr(EncodingFormat fmt)
        {
            using (var cp = CertificateProvider.GetProvider())
            {
                var pkp = new RsaPrivateKeyParams();
                var pk = cp.GeneratePrivateKey(pkp);

                var crp = new CsrParams
                {
                    Details = new CsrDetails
                    {
                        CommonName = "TEST CERT",
                    }
                };

                var csr = cp.GenerateCsr(crp, pk, Crt.MessageDigest.SHA256);

                using (var target = new MemoryStream())
                {
                    cp.ExportCsr(csr, fmt, target);
                }
            }
        }
Ejemplo n.º 35
0
        private string DecodePartialVFPURegister(EncodingFormat encFormat, uint line, int regIndex, char lookupChar)
        {
            string formatBinary = encFormat.Binary;
            string newFormat = encFormat.ExpandedFormat;

            /*
            int[] binaryIndex = new int[2];

            int part1Index = formatBinary.IndexOf("[p" + (regIndex + 1).ToString() + "-1");
            int part2Index = formatBinary.IndexOf("[p" + (regIndex + 1).ToString() + "-2");

            int firstIndex = newFormat.IndexOf(lookupChar);
            int searchPartIndex = firstIndex;
            for (; newFormat[searchPartIndex] == lookupChar; searchPartIndex++) ;
            int secondIndex = newFormat.IndexOf(lookupChar, searchPartIndex);

            if (part1Index > part2Index)
            {
                binaryIndex[0] = secondIndex;
                binaryIndex[1] = firstIndex;
            }
            else
            {
                binaryIndex[0] = firstIndex;
                binaryIndex[1] = secondIndex;
            }
            */

            //string firstValue = binaryLine.Substring(binaryIndex[0], encFormat.PartialRegisterSizes[0]);
            //string secondValue = binaryLine.Substring(binaryIndex[1], encFormat.PartialRegisterSizes[1]);

            //int firstValue = FindNumericArgValue(line, encFormat.PartialRegisterPositions[regIndex][0], ASMValueHelper.GetIncludeMask(encFormat.PartialRegisterSizes[0]));
            //int secondValue = FindNumericArgValue(line, encFormat.PartialRegisterPositions[regIndex][1], ASMValueHelper.GetIncludeMask(encFormat.PartialRegisterSizes[1]));

            int firstValue = FindNumericArgValue(line, encFormat.PartialRegisterPositions[regIndex][0], encFormat.PartialRegisterIncludeMasks[regIndex][0]);
            int secondValue = FindNumericArgValue(line, encFormat.PartialRegisterPositions[regIndex][1], encFormat.PartialRegisterIncludeMasks[regIndex][1]);

            //string binaryValue = firstValue + secondValue;
            int totalValue = (firstValue << encFormat.PartialRegisterSizes[1]) + secondValue;
            string argValue = DecodeRegister(totalValue, ASMElementTypeCharacter.PartialVFPURegister, false, encFormat.VFPURegisterTypes[regIndex]);

            return argValue;
        }
Ejemplo n.º 36
0
            internal string Encode(string input, EncodingFormat format)
            {
                str_rle = null;
                str_base = input;

                if (format == EncodingFormat.New)
                {
                    for (int i = 0; i < str_base.Length; i++)
                    {
                        char symbol = str_base[i];
                        int count = 1;

                        for (int j = i; j < str_base.Length - 1; j++)
                        {
                            if (str_base[j + 1] != symbol) break;

                            count++;
                            i++;
                        }
                        if (count == 1) str_rle += symbol;
                        else str_rle += count.ToString() + symbol;
                    }
                }
                else if (format == EncodingFormat.Old)
                {
                    for (int i = 0; i < str_base.Length; i++)
                    {
                        char symbol = str_base[i];
                        int count = 1;

                        for (int j = i; j < str_base.Length - 1; j++)
                        {
                            if (str_base[j + 1] != symbol) break;

                            count++;
                            i++;
                        }

                        str_rle += count.ToString() + symbol;
                    }
                }

                return str_rle;
            }
Ejemplo n.º 37
0
 internal string Encode(EncodingFormat encodingFormat)
 {
     using (MemoryStream ms = new MemoryStream())
     {
         using (BinaryWriter writer = new BinaryWriter(ms))
         {
             if (this.checksum != null)
             {
                 writer.Write((byte)(encodingFormat | EncodingFormat.Checksum));
                 SymbolHelper.WriteEncodedInt32(writer, this.checksum.Length);
                 writer.Write(this.checksum);
             }
             else
             {
                 writer.Write((byte)encodingFormat);
             }
             switch (encodingFormat)
             {
                 case EncodingFormat.Binary:
                     this.Write(writer);
                     break;
                 case EncodingFormat.String:
                     writer.Write(this.ToString());
                     break;
                 default:
                     throw FxTrace.Exception.AsError(new SerializationException());
             }
             // Need to copy to a buffer to trim excess capacity.
             byte[] buffer = new byte[ms.Length];
             Array.Copy(ms.GetBuffer(), buffer, ms.Length);
             return Convert.ToBase64String(buffer);
         }
     } 
 }
Ejemplo n.º 38
0
 private ASMSingleEncodeResult TryEncodeSingle(string[] parts, EncodingFormat encoding, uint pc, string processLine, bool littleEndian)
 {
     try
     {
         return EncodeASMSingle(parts, encoding, pc, littleEndian);
     }
     catch (Exception ex)
     {
         _errorTextBuilder.Append("FAILED TO ENCODE LINE : ");
         _errorTextBuilder.Append(processLine);
         _errorTextBuilder.Append(" (");
         _errorTextBuilder.Append(ex.Message);
         _errorTextBuilder.Append(")");
         _errorTextBuilder.Append("\r\n");
         return new ASMSingleEncodeResult("", new List<byte>().ToArray());
     }
 }
        private void TestExportCertificate(EncodingFormat fmt, string filePath)
        {
            using (var cp = CertificateProvider.GetProvider())
            {

                using (var source = new FileStream(filePath, FileMode.Open))
                {
                    var crt = cp.ImportCertificate(fmt, source);

                    using (var target = new MemoryStream())
                    {
                        cp.ExportCertificate(crt, fmt, target);
                    }
                }
            }
        }
        private void TestImportCertificate(EncodingFormat fmt, string filePath)
        {
            using (var cp = CertificateProvider.GetProvider())
            {

                using (var source = new FileStream(filePath, FileMode.Open))
                {
                    var crt = cp.ImportCertificate(fmt, source);
                }
            }
        }
Ejemplo n.º 41
0
        private byte[] EncodeASMSingle(string[] parts, EncodingFormat encoding, int pc)
        {
            // Initialize variables
            string binary = encoding.format.Substring(0);
            string hex = "";
            string strArgs = "";
            string[] args = null;

            if (!string.IsNullOrEmpty(parts[1]))
            {
                strArgs = RemoveSpaces(parts[1]);
                args = strArgs.Split(',');
            }

            int immed = 0;
            int difference = 0;
            string hexImmed = "";
            string binaryImmed = "";
            int startParenIndex = 0;
            int endParenIndex = 0;
            string strImmed = "";
            string regS = "";

            // (1) -- Encode MIPS instruction in BINARY --

            // I've defined 17 types of MIPS instructions based on R/I/J type as well as order
            // of arguments (rd,rs,rt and rd,rt,rs would be two different types)
            // (See mips_encode.dat: Format is: [ command : type : encoding ])

            // For each type, determine what in the encoding is variable, and replace it with the properly
            // encoded argument (register or immediate).

            switch (encoding.type)
            {
                case 1: 	// R-type register-only operations: rd,rs,rt (add,and,or,sub,subu,slt,etc)
                    binary = binary.Replace("d", EncodeRegister(args[0]));
                    binary = binary.Replace("s", EncodeRegister(args[1]));
                    binary = binary.Replace("t", EncodeRegister(args[2]));
                    break;
                case 2:		// I-type conditional branches on register values: rs,rt,[immediate] (beq,bne)
                    if (args[2].StartsWith("0x"))
                    {
                        if (args[2].Length >= 10)
                            immed = HexToUnsigned(args[2].Substring(3,args[2].Length-3));
                        else
                            immed = HexToUnsigned(args[2].Substring(2,args[2].Length-2));
                    }
                    else if (StringIsNumeric(args[2]))
                    {
                        immed = Convert.ToInt32(args[2]);
                    }
                    else
                    {
                        immed = LabelToUnsigned(args[2]);
                    }

                    difference = (immed - pc - 4) / 4;
                    hexImmed = SignedToHex_WithLength(difference, 4);
                    binaryImmed = HexHalfWordToBinary(hexImmed);
                    binary = binary.Replace("s", EncodeRegister(args[0]));
                    binary = binary.Replace("t", EncodeRegister(args[1]));
                    binary = binary.Replace("i", binaryImmed);
                    break;
                case 3:		// I-type operations with immediates: rt,rs,[immediate] (addi,addiu,andi,ori,xori,slti,sltiu)
                case 17:
                    binary = binary.Replace("t", EncodeRegister(args[0]));
                    binary = binary.Replace("s", EncodeRegister(args[1]));
                    binary = binary.Replace("i", EncodeImmediateHalfWord(args[2]));
                    break;
                case 4:		// I-type conditional branches on register value vs. fixed value: rs,[immediate] (bgez,bgtz,blez,bltz)
                    if (args[1].StartsWith("0x"))
                    {
                        if (args[1].Length >= 10)
                            immed = HexToUnsigned(args[1].Substring(3,args[1].Length-3));
                        else
                            immed = HexToUnsigned(args[1].Substring(2,args[1].Length-2));
                    }
                    else if (StringIsNumeric(args[1]))
                    {
                        immed = Convert.ToInt32(args[1]);
                    }
                    else
                    {
                        immed = LabelToUnsigned(args[1]);
                    }

                    difference = (immed - pc - 4) / 4;
                    hexImmed = SignedToHex_WithLength(difference, 4);
                    binaryImmed = HexHalfWordToBinary(hexImmed);
                    binary = binary.Replace("s", EncodeRegister(args[0]));
                    binary = binary.Replace("i", binaryImmed);
                    break;
                case 5:		// R-type operations using HI/LO as destination registers: rs,rt (mult,multu,div,divu)
                    binary = binary.Replace("s", EncodeRegister(args[0]));
                    binary = binary.Replace("t", EncodeRegister(args[1]));
                    break;
                case 6:		// J-type unconditional jumps to address specified by long immediate: [immediate] (j,jal)
                    binary = binary.Replace("i", EncodeLongImmediate(args[0], 8));
                    break;
                case 7:		// R-type instructions with only one argument: rs (jr,mthi,mtlo)
                    binary = binary.Replace("s", EncodeRegister(args[0]));
                    break;
                case 8:		// I-type memory operations: rt, [immediate](rs) (lb,lbu,lh,lhu,lw,sb,sh,sw)
                    startParenIndex = args[1].IndexOf('(');
                    endParenIndex = args[1].IndexOf(')');
                    strImmed = args[1].Substring(0,startParenIndex);
                    regS = args[1].Substring(startParenIndex+1, endParenIndex-startParenIndex-1);
                    binary = binary.Replace("t", EncodeRegister(args[0]));
                    binary = binary.Replace("s", EncodeRegister(regS));
                    binary = binary.Replace("i", EncodeImmediateHalfWord(strImmed));
                    break;
                case 9:		// I-type operations loading immediates into registers: rt, [immediate] (lui)
                    binary = binary.Replace("t", EncodeRegister(args[0]));
                    binary = binary.Replace("i", EncodeImmediateHalfWord(args[1]));
                    break;
                case 10:	// R-type moves from HI/LO to a destination register: rd (mfhi,mflo)
                    binary = binary.Replace("d", EncodeRegister(args[0]));
                    break;
                case 11:	// R-type operations with no arguments (syscall,nop)
                    break;
                case 12:	// R-type shift operations using [shamt] as shift amount: rd,rt,[shamt] (sll,srl,sra)
                    binary = binary.Replace("d", EncodeRegister(args[0]));
                    binary = binary.Replace("t", EncodeRegister(args[1]));
                    binary = binary.Replace("h", EncodeShiftAmount(args[2]));
                    break;
                case 13:	// R-type shift operations using register value as shift amount: rd,rt,rs (sllv,srlv)
                    binary = binary.Replace("d", EncodeRegister(args[0]));
                    binary = binary.Replace("t", EncodeRegister(args[1]));
                    binary = binary.Replace("s", EncodeRegister(args[2]));
                    break;
                case 14:	// R-type or I-type operations using only one operand and a destination register: rt,rs (not,move)
                    binary = binary.Replace("t", EncodeRegister(args[0]));
                    binary = binary.Replace("s", EncodeRegister(args[1]));
                    break;
                case 15:	// R-type opreations with 10-bit immediate (syscall, break)
                    binary = binary.Replace("i", EncodeImmediate(args[0], 10));
                    break;
                case 16: 	// J-type operations with 26-bit immediate, not using jump-encoding (trap)
                    binary = binary.Replace("i", EncodeImmediate(args[0], 26));
                    break;
                default: break;
            }

            // (2) -- Translate BINARY to HEX --
            hex = BinaryWordToHex_LittleEndian(binary);

            // (3) -- Translate HEX to BYTE LIST --
            List<Byte> result = new List<Byte>();
            result.Add(Convert.ToByte(hex.Substring(0,2),16));
            result.Add(Convert.ToByte(hex.Substring(2,2),16));
            result.Add(Convert.ToByte(hex.Substring(4,2),16));
            result.Add(Convert.ToByte(hex.Substring(6,2),16));

            return result.ToArray();
        }
        private void TestImportRsaCsr(EncodingFormat fmt)
        {
            using (var cp = CertificateProvider.GetProvider())
            {
                var pkp = new RsaPrivateKeyParams();
                var pk = cp.GeneratePrivateKey(pkp);

                var crp = new CsrParams
                {
                    Details = new CsrDetails
                    {
                        CommonName = "TEST CERT",
                    }
                };

                var csr = cp.GenerateCsr(crp, pk, Crt.MessageDigest.SHA256);
                byte[] bytes;
                using (var target = new MemoryStream())
                {
                    cp.ExportCsr(csr, fmt, target);
                    bytes = target.ToArray();
                }

                var imp = csr;
                using (var source = new MemoryStream(bytes))
                {
                    imp = cp.ImportCsr(fmt, source);
                }

                using (MemoryStream save1 = new MemoryStream(), save2 = new MemoryStream())
                {
                    cp.SaveCsr(csr, save1);
                    cp.SaveCsr(imp, save2);

                    var bytes1 = save1.ToArray();
                    var bytes2 = save2.ToArray();

                    CollectionAssert.AreEqual(bytes1, bytes2);
                }
            }
        }
Ejemplo n.º 43
0
        private ASMSingleEncodeResult EncodeASMSingle(string[] parts, EncodingFormat encoding, uint pc, bool littleEndian)
        {
            // Initialize variables
            //string binary = "";
            //string hex = "";
            string strArgs = "";
            string[] args = null;

            /*
            if (!string.IsNullOrEmpty(parts[1]))
            {
                strArgs = ASMStringHelper.RemoveSpaces(parts[1]).Replace('(',',').Replace(")","");
                args = strArgs.Split(',');
            }
            */

            // Find encoding format and syntax
            string command = parts[0].ToLower();
            EncodingFormat encodingFormat = FormatHelper.FindFormatByCommand(command);
            string formatBinary = encodingFormat.Binary;
            string syntax = encodingFormat.Syntax;
            string newFormat = formatBinary;

            if (!string.IsNullOrEmpty(parts[1]))
            {
                List<string> argsList = new List<string>();
                strArgs = ASMStringHelper.RemoveSpaces(parts[1]);
                bool foundArg = false;
                int strArgCharIndex = 0;

                foreach (char currentChar in syntax)
                {
                    if (Char.IsLetter(currentChar))
                    {
                        foundArg = true;
                    }
                    else if (foundArg)
                    {
                        foundArg = false;
                        bool isHiLo = ((strArgs.IndexOf("%hi(", strArgCharIndex) == strArgCharIndex) || (strArgs.IndexOf("%lo(", strArgCharIndex) == strArgCharIndex));
                        int separatorIndex = strArgs.IndexOf(currentChar, strArgCharIndex + (isHiLo ? 4 : 0));
                        argsList.Add(strArgs.Substring(strArgCharIndex, separatorIndex - strArgCharIndex));
                        strArgCharIndex = separatorIndex + 1;
                    }
                }

                if (foundArg)
                {
                    argsList.Add(strArgs.Substring(strArgCharIndex, strArgs.Length - strArgCharIndex));
                }

                args = argsList.ToArray();
            }

            // Create array for registers and immediates
            Nullable<uint>[] regValue = new Nullable<uint>[26];
            Nullable<uint>[][] partialRegValue = new Nullable<uint>[26][];
            uint[] immedValue = new uint[26];

            int argsIndex = 0;
            int regIndex = 0;
            int immedIndex = 0;

            // Fill arrays based on order of arguments (syntax)
            foreach (char elementTypeChar in syntax)
            {
                bool incrementArgsIndex = true;

                switch (elementTypeChar)
                {
                    case ASMElementTypeCharacter.GPRegister:
                        regValue[regIndex++] = EncodeGPRegister(args[argsIndex]);
                        break;
                    case ASMElementTypeCharacter.GenericRegister:
                        regValue[regIndex++] = EncodeGenericRegister(args[argsIndex]);
                        break;
                    case ASMElementTypeCharacter.FloatRegister:
                        regValue[regIndex++] = EncodeFloatRegister(args[argsIndex]);
                        break;
                    case ASMElementTypeCharacter.VFPURegister:
                        regValue[regIndex] = EncodeVFPURegister(args[argsIndex], encodingFormat.VFPURegisterTypes[regIndex]);
                        regIndex++;
                        break;
                    case ASMElementTypeCharacter.PartialVFPURegister:
                        partialRegValue[regIndex] = EncodePartialVFPURegister(args[argsIndex], encodingFormat.VFPURegisterTypes[regIndex], encodingFormat.PartialRegisterSizes, encodingFormat.PartialRegisterIncludeMasks[regIndex]);
                        regIndex++;
                        break;
                    case ASMElementTypeCharacter.InvertedSingleBitVFPURegister:
                        regValue[regIndex] = EncodeInvertedSingleBitVFPURegister(args[argsIndex], encodingFormat.VFPURegisterTypes[regIndex]);
                        regIndex++;
                        break;
                    case ASMElementTypeCharacter.Cop0Register:
                        regValue[regIndex] = EncodeCop0Register(args[argsIndex]);
                        regIndex++;
                        break;
                    case ASMElementTypeCharacter.GTEControlRegister:
                        regValue[regIndex] = EncodeGTEControlRegister(args[argsIndex]);
                        regIndex++;
                        break;
                    case ASMElementTypeCharacter.GTEDataRegister:
                        regValue[regIndex] = EncodeGTEDataRegister(args[argsIndex]);
                        regIndex++;
                        break;
                    case ASMElementTypeCharacter.SignedImmediate:
                    case ASMElementTypeCharacter.UnsignedImmediate:
                        immedValue[immedIndex] = EncodeImmediate(args[argsIndex], encodingFormat.ImmediateLengths[immedIndex], (uint)encodingFormat.ImmediateIncludeMasks[immedIndex]);
                        immedIndex++;
                        break;
                    case ASMElementTypeCharacter.BranchImmediate:
                        immedValue[immedIndex] = EncodeBranchImmediate(args[argsIndex], pc, (uint)encodingFormat.ImmediateIncludeMasks[immedIndex]);
                        immedIndex++;
                        break;
                    case ASMElementTypeCharacter.JumpImmediate:
                        immedValue[immedIndex] = EncodeJumpImmediate(args[argsIndex], 26, pc);
                        immedIndex++;
                        break;
                    case ASMElementTypeCharacter.DecrementedImmediate:
                        immedValue[immedIndex] = EncodeDecrementedImmediate(args[argsIndex], encodingFormat.ImmediateLengths[immedIndex], (uint)encodingFormat.ImmediateIncludeMasks[immedIndex]);
                        immedIndex++;
                        break;
                    case ASMElementTypeCharacter.ModifiedImmediate:
                        immedValue[immedIndex] = EncodeModifiedImmediate(args[argsIndex], args[argsIndex - 1], encodingFormat.ImmediateLengths[immedIndex], (uint)encodingFormat.ImmediateIncludeMasks[immedIndex]);
                        immedIndex++;
                        break;
                    case ASMElementTypeCharacter.ShiftedImmediate:
                        immedValue[immedIndex] = EncodeShiftedImmediate(args[argsIndex], encodingFormat.ImmediateLengths[immedIndex], encodingFormat.ShiftedImmediateAmounts[immedIndex], (uint)encodingFormat.ImmediateIncludeMasks[immedIndex]);
                        immedIndex++;
                        break;
                    case ASMElementTypeCharacter.VFPUPrefixImmediate:
                        immedValue[immedIndex] = EncodeVFPUPrefixImmediate(args[argsIndex], encodingFormat.VFPUPrefixType, encodingFormat.ImmediateLengths[immedIndex]);
                        immedIndex++;
                        break;
                    default:
                        incrementArgsIndex = false;
                        break;
                }

                if (incrementArgsIndex)
                    argsIndex++;
            }

            /*
            // Replace bracket blocks in format with appropriate values
            for (int i = 0; i < regIndex; i++)
            {
                newFormat = newFormat.Replace("[" + encodingFormat.RegisterTypes[i] + (i + 1) + "]", regBinary[i]);

                if (partialRegBinary[i] != null)
                {
                    newFormat = newFormat.Replace("[" + encodingFormat.RegisterTypes[i] + (i + 1) + "-1]", partialRegBinary[i][0]);
                    newFormat = newFormat.Replace("[" + encodingFormat.RegisterTypes[i] + (i + 1) + "-2]", partialRegBinary[i][1]);
                }
            }
            for (int i = 0; i < immedIndex; i++)
            {
                newFormat = newFormat.Replace("[" + encodingFormat.ImmediateTypes[i] + (i + 1) + "]", immedBinary[i]);
            }

            binary = newFormat;
            */

            uint uEncodingValue = encodingFormat.BaseEncoding;

            for (int i = 0; i < regIndex; i++)
            {
                if (regValue[i] != null)
                {
                    uEncodingValue |= (((uint)regValue[i]) << encodingFormat.RegisterPositions[i]);
                }
                else if (partialRegValue[i] != null)
                {
                    uEncodingValue |= (((uint)partialRegValue[i][0]) << encodingFormat.PartialRegisterPositions[i][0]);
                    uEncodingValue |= (((uint)partialRegValue[i][1]) << encodingFormat.PartialRegisterPositions[i][1]);
                }
            }

            for (int i = 0; i < immedIndex; i++)
            {
                uEncodingValue |= (immedValue[i] << encodingFormat.ImmediatePositions[i]);
            }

            //byte[] bytes = BitConverter.GetBytes(uEncodingValue);
            byte[] bytes = ASMValueHelper.ConvertUIntToBytes(uEncodingValue, littleEndian);

            if (littleEndian)
            {
                uEncodingValue = ASMValueHelper.ReverseBytes(uEncodingValue);
            }
            //else
            //{
            //    Array.Reverse(bytes);
            //}

            string hex = ASMValueHelper.UnsignedToHex_WithLength(uEncodingValue, 8).ToUpper();
            return new ASMSingleEncodeResult(hex, bytes);
        }
Ejemplo n.º 44
0
        private static WaveFormatEncoding GetWaveEncodingFormat(EncodingFormat encoding)
        {
            switch (encoding)
            {
                case EncodingFormat.Pcm:
                    return WaveFormatEncoding.LPCM;

                default:
                    return WaveFormatEncoding.Unknown;
            }
        }
Ejemplo n.º 45
0
        // For reading mips_encode.dat
        public void ReadEncodeList()
        {
            StreamReader reader = new StreamReader("mips_encode.dat");

            try
            {
                while(reader.Peek() != -1)
                {
                    string line = reader.ReadLine();
                    line = RemoveSpaces(line);
                    string[] lineArray = line.Split(':');

                    EncodingFormat encoding = new EncodingFormat();
                    encoding.command = lineArray[0];
                    encoding.type = Convert.ToInt32(lineArray[1]);
                    encoding.format = lineArray[2];

                    encodeList.Add(encoding);
                }
            }
            catch
            {

            }
            finally
            {
                reader.Close();
            }
        }