示例#1
0
 public SUDMSGAddModDel Decode(BinaryData encodedData)
 {
     return
         (new SUDMSGAddModDel(
              nidDecoder.Decode(encodedData.Take(4)),
              nidDecoder.Decode(encodedData.Take(4, 4))));
 }
示例#2
0
 public SUDMSGSpam Decode(BinaryData encodedData)
 {
     return
         (new SUDMSGSpam(
              nidDecoder.Decode(encodedData.Take(4)),
              nidDecoder.Decode(encodedData.Take(4, 4))));
 }
示例#3
0
        /// <summary>
        /// Decodes the given encoded data.
        /// </summary>
        /// <param name="inData">The encoded data. Can be multiple frames.</param>
        /// <param name="inOffset">Start offset where to read the encoded data from.</param>
        /// <param name="inCount">The number of bytes to decode.</param>
        /// <param name="outData">The output of the decoded data in samples.</param>
        /// <param name="outOffset">Start offset where to start writing the decoded samples from.</param>
        /// <param name="lostFrame">Indicates if we are decoding a lost frame. Alternatively the <paramref name="inData"/> parameter can be <value>null</value>.</param>
        /// <returns>The number of samples decoded.</returns>
        public int Decode(byte[] inData, int inOffset, int inCount, short[] outData, int outOffset, bool lostFrame)
        {
            if (decodedData.Length < outData.Length * 2)
            {
                // resize the decoded data buffer
                decodedData = new float[outData.Length * 2];
            }

            if (lostFrame || inData == null)
            {
                decoder.Decode(null, decodedData);
                for (int i = 0; i < frameSize; i++, outOffset++)
                {
                    outData[outOffset] = ConvertToShort(decodedData[i]);
                }
                return(frameSize);
            }

            bits.ReadFrom(inData, inOffset, inCount);
            int samplesDecoded = 0;

            while (decoder.Decode(bits, decodedData) == 0)
            {
                for (int i = 0; i < frameSize; i++, outOffset++)
                {
                    outData[outOffset] = ConvertToShort(decodedData[i]);
                }
                samplesDecoded += frameSize;
            }

            return(samplesDecoded);
        }
示例#4
0
        private void ButtonRunImage_Click(object sender, EventArgs e)
        {
            if (pictureBoxUploadedImage == null || pictureBoxUploadedImage.Image == null)
            {
                MessageBox.Show("Upload an image first");
                return;
            }

            string binaryUserInput = BitUtils.ImageToBinaryString(pictureBoxUploadedImage.Image);

            // Užkodavimas, siuntimas kanalu ir dekodavimas ---------------------------------
            string encoderOutput = _convolutionalEncoder.Encode(binaryUserInput);

            _simpleChannel.SetNoiseLevel((double)numericUpDownNoiseLevel.Value);

            int headerSize =
                binaryUserInput.Length -
                Image.GetPixelFormatSize(pictureBoxUploadedImage.Image.PixelFormat) * (pictureBoxUploadedImage.Image.Width * pictureBoxUploadedImage.Image.Height);

            // Pagal sąsūkos kodą užkodavus pranešimą jo ilgis yra 2k + 12, todėl atitinkamai headerio dydis pailgėja taip pat.
            string channelOutput = _simpleChannel.AddNoise(encoderOutput, (headerSize + 1) * 2 + 12);
            string decoderOutput = _convolutionalDecoder.Decode(channelOutput);

            pictureBoxDecoderOutput.Image = BitUtils.BinaryStringToImage(decoderOutput);

            // Tik siuntimas kanalu ---------------------------------------------------------
            channelOutput = _simpleChannel.AddNoise(binaryUserInput, headerSize + 1);
            pictureBoxChannelOutput.Image = BitUtils.BinaryStringToImage(channelOutput);
        }
示例#5
0
 /// <summary>
 ///  This is where the actual decoding takes place.
 /// </summary>
 /// <param name="lost">
 ///  true if the Speex packet has been lost.
 /// </param>
 private void processData(bool lost)
 {
     /* decode the bitstream */
     if (lost)
     {
         decoder.Decode(null, decodedData);
     }
     else
     {
         decoder.Decode(bits, decodedData);
     }
     if (channels == 2)
     {
         decoder.DecodeStereo(decodedData, frameSize);
     }
     for (int i = 0; i < frameSize * channels; i++)
     {
         if (decodedData[i] > 32767.0f)
         {
             decodedData[i] = 32767.0f;
         }
         else if (decodedData[i] < -32768.0f)
         {
             decodedData[i] = -32768.0f;
         }
     }
     outputSize = frameSize * channels;
 }
示例#6
0
 public SUDFLDAddMov Decode(BinaryData encodedData)
 {
     return
         (new SUDFLDAddMov(
              nidDecoder.Decode(encodedData.Take(4)),
              nidDecoder.Decode(encodedData.Take(4, 4)),
              encodedData.Take(8, 4).ToInt32(),
              encodedData.Take(12, 4).ToInt32()));
 }
示例#7
0
        static void Main(string[] args)
        {
            Console.WriteLine("Введите адрес файла для кодировки");
            string fileName = Console.ReadLine();

            DateTime startEncode = DateTime.Now;

            Encoder encoder = new Encoder(fileName);

            encoder.Encode();

            TimeSpan tsEncode = DateTime.Now - startEncode;

            DisplayCodeInformation(encoder);

            encoder.WriteToFile("myFile.bin");

            DateTime startDecode = DateTime.Now;

            string   decoderType = ConfigurationManager.AppSettings.Get("DecoderType");
            IDecoder decoder     = DecoderCreator.Create(encoder.CodeToChar, "myFile.bin", encoder.TextLength, decoderType);

            decoder.Decode();
            TimeSpan tsDecode = DateTime.Now - startDecode;

            Console.WriteLine("Время выполнения кодировки/декодировки: " + tsEncode.ToString(@"ss\.ffff") + "/" + tsDecode.ToString(@"ss\.ffff"));

            decoder.SaveToText("text.txt", Encoding.GetEncoding(1251));

            Console.ReadLine();
        }
示例#8
0
        private static string Load(string className)
        {
            string line = "";
            var    path = PersistentDataPath + className + ".json";

            if (!System.IO.File.Exists(path))
            {
                return("");
            }

            StreamReader sr = null;

            try
            {
                sr = new StreamReader(path);
            }
            catch (Exception)
            {
                Debug.Log($"{className}.json not found.");
                sr.Close();
                return("");
            }

            line = sr.ReadLine();
            sr.Close();
            var decodeParam = _decoder.Decode(line);

            return(decodeParam);
        }
示例#9
0
        public void ATMController_EventIsRaised_DataIsPassedFromDecoderToFilter()
        {
            // Arrange

            _fakeEventArgs = new RawTransponderDataEventArgs(new List <string>());

            // Act

            //Fake decoder should return fake Trackdata when called with fakeEventArgs
            _fakeDecoder.Decode(_fakeEventArgs).Returns(_fakeTrackData = new List <TrackData>
            {
                new TrackData("AYE334", 12345, 54321, 5000, new DateTime(year: 2000, month: 10, day: 9, hour: 8, minute: 7, second: 6, millisecond: 5)),
                new TrackData("BYE331", 12121, 23232, 5001, new DateTime(year: 2001, month: 11, day: 10, hour: 9, minute: 8, second: 7, millisecond: 6)),
                new TrackData("HMM221", 34343, 45454, 5002, new DateTime(year: 2002, month: 12, day: 11, hour: 10, minute: 9, second: 8, millisecond: 7))
            });

            //Raise event
            _fakeReceiver.TransponderDataReady += Raise.EventWith(new object(), _fakeEventArgs);

            // Assert
            _fakeTrackDataFilter.Received().Filter(Arg.Is <List <TrackData> >(x =>
                                                                              x[0].Tag == "AYE334" && x[0].X == 12345 && x[0].Y == 54321 && x[0].Altitude == 5000 &&
                                                                              x[0].Timestamp.Year == 2000 && x[0].Timestamp.Month == 10 && x[0].Timestamp.Day == 9 && x[0].Timestamp.Hour == 8 &&
                                                                              x[0].Timestamp.Minute == 7 && x[0].Timestamp.Second == 6 && x[0].Timestamp.Millisecond == 5 &&

                                                                              x[1].Tag == "BYE331" && x[1].X == 12121 && x[1].Y == 23232 && x[1].Altitude == 5001 &&
                                                                              x[1].Timestamp.Year == 2001 && x[1].Timestamp.Month == 11 && x[1].Timestamp.Day == 10 && x[1].Timestamp.Hour == 9 &&
                                                                              x[1].Timestamp.Minute == 8 && x[1].Timestamp.Second == 7 && x[1].Timestamp.Millisecond == 6 &&

                                                                              x[2].Tag == "HMM221" && x[2].X == 34343 && x[2].Y == 45454 && x[2].Altitude == 5002 &&
                                                                              x[2].Timestamp.Year == 2002 && x[2].Timestamp.Month == 12 && x[2].Timestamp.Day == 11 && x[2].Timestamp.Hour == 10 &&
                                                                              x[2].Timestamp.Minute == 9 && x[2].Timestamp.Second == 8 && x[2].Timestamp.Millisecond == 7
                                                                              ));
        }
示例#10
0
        public void Decode(IEnumerable <IFieldInfoEx> fields)
        {
            if (fields == null)
            {
                return;
            }
            var decodeFields = from item in fields
                               where item.Decoder != null && item.Decoder.Type != DecoderType.None
                               select item;

            if (Decoder == null)
            {
                Decoder = new ObjectDecoderContainer();
            }
            foreach (var item in decodeFields)
            {
                IDecoder coder = GetDecoder(item.Decoder);
                if (coder != null)
                {
                    IDecoderItem decodeItem = coder.Decode(
                        MainObject.MemberValue(item.NickName).ConvertToString());
                    if (decodeItem != null)
                    {
                        Decoder.Add(item.NickName, decodeItem);
                    }
                }
            }
        }
示例#11
0
        private unsafe void Load(CancellationToken token)
        {
            sw.Restart();
            try
            {
                token.ThrowIfCancellationRequested();
                decoder.Device = device;
                lock (streamLock)
                {
                    decoder.Load(memoryStream);
                }
                token.ThrowIfCancellationRequested();

                description = decoder.Description;
                LoadingCompleted(description);
                decoder.Decode();
                token.ThrowIfCancellationRequested();

                Loaded = true;
            }
            catch (OperationCanceledException) { }
            catch (Exception e)
            {
                System.Diagnostics.Debug.WriteLine("load: {0}", e);
                throw e;
            }
            DecodeTime = sw.Elapsed.TotalMilliseconds;
        }
示例#12
0
 private void Read(string address, OpResult result, IAddressableEncoder encoder, IDecoder decoder, Action <OpResult, IEncoder, IDecoder> dataGotAction)
 {
     if (result.CheckNotNullOrWhiteSpace(address, SR.ArgumentIsNullOrEmpty))
     {
         FinsFrame frame = NewFrame();
         frame.MRC = 01;
         frame.SRC = 01;
         if (result.CheckTrue(encoder.FillAddress(address), SR.WrongAddressFormat))
         {
             frame.Content = encoder.Encode();
             var buffer = frame.Encode();
             try
             {
                 int count = _client.Send(buffer, buffer.Length);
                 buffer = _client.Receive(ref _remoteEndpoint);
                 var decodeFrame = new FinsFrame();
                 if (result.CheckTrue(decodeFrame.Decode(buffer), SR.DecodeError))
                 {
                     if (result.CheckTrue(decoder.Decode(decodeFrame.Content), SR.DecodeError))
                     {
                         dataGotAction?.Invoke(result, encoder, decoder);
                     }
                 }
             }
             catch (Exception ex)
             {
                 result.SetException(ex, SR.CallServiceException);
             }
         }
     }
 }
示例#13
0
 public SUDFLDModDel Decode(BinaryData encodedData)
 {
     return
         (new SUDFLDModDel(
              nidDecoder.Decode(encodedData.Take(4)),
              encodedData.Take(4, 4).ToInt32()));
 }
示例#14
0
        public string Decode(byte[] byteArray)
        {
            byte[] decodedData = decoder.Decode(byteArray);
            string retVal      = System.Text.Encoding.UTF8.GetString(decodedData);

            return(retVal);
        }
 public void HandleAudioDataReceived(object sender, VoipDataPacket e)
 {
     if (!enabled)
     {
         return;
     }
     if (e.Data != null && e.DataLength > 0)
     {
         //if (e.Data.Length > e.DataLength)
         //    Plugin.Log?.Debug($"Data length is {e.Data.Length}, expected length is {e.DataLength}");
         if (e.Data.Length < e.DataLength)
         {
             Plugin.Log?.Warn($"Data length of '{e.Data.Length}' is less than the expected length of '{e.DataLength}'");
         }
         float[] floatData = FloatAryPool.Rent(4096);
         int     length    = Decoder.Decode(e.Data, 0, e.DataLength, floatData, 0);
         //Plugin.Log?.Debug($"Playing fragment, length {length}x{Decoder.Channels}");
         PlayVoIPFragment(floatData, length * Decoder.Channels, e.Index);
         FloatAryPool.Return(floatData);
     }
     else
     {
         Plugin.Log?.Warn($"HandleAudioDataReceived {(e.Data == null ? "Data was null" : $"DataLength: {e.DataLength}")}");
     }
 }
示例#16
0
        public void Update(IB regionOffset, Func <TType, TType> processRegion)
        {
            var originalPosition = stream.Position;

            try
            {
                stream.Position = regionOffset;

                var rawRegion = new byte[typeSize];

                stream.Read(rawRegion, 0, typeSize);

                var type = typeDecoder.Decode(BinaryData.OfValue(rawRegion));

                var updatedType = processRegion(type);

                stream.Position = regionOffset;

                var encodedType = typeEncoder.Encode(updatedType);

                stream.Write(encodedType.Value, 0, encodedType.Value.Length);
            }
            finally
            {
                stream.Position = originalPosition;
            }
        }
示例#17
0
        public TM Resolve <TM>(IBasicProperties basicProperties, ReadOnlyMemory <byte> body)
            where TM : IMessage
        {
            if (basicProperties is null)
            {
                throw new ArgumentNullException(nameof(basicProperties));
            }
            if (basicProperties.Headers is null)
            {
                throw new ArgumentNullException(nameof(basicProperties), "message headers are missing");
            }

            if (!basicProperties.Headers.TryGetValue(HeaderNames.MessageType, out var tmp) ||
                tmp is not byte[] messageTypeBytes ||
                messageTypeBytes is null)
            {
                throw new ArgumentException("invalid message type");
            }

            var messageTypeName = Encoding.UTF8.GetString(messageTypeBytes);

            var dataType = _typeResolver.Resolve(messageTypeName);

            var decodedObj = _decoder.Decode(body, dataType);

            if (decodedObj is not TM message)
            {
                throw new ArgumentException($"type '{messageTypeName}' is not a valid message");
            }
            return(message);
        }
示例#18
0
        //Run every time new data is present
        private void Update(RawTransponderDataEventArgs e)
        {
            //Decode Data
            List <TrackData> trackData = _decoder.Decode(e);

            //Filter data
            trackData = _filter.Filter(trackData);

            //Update existing flight data
            _data = _flightCalculator.Calculate(_data, trackData);

            //Collision Detect
            Tuple <List <string>, List <string> > collisionResult = _collisionDetector.SeperationCheck(trackData);
            List <string> collisionTags        = collisionResult.Item1;
            List <string> displayCollisionList = collisionResult.Item2;


            //Set CollisionFlag on flights
            foreach (KeyValuePair <string, FlightData> entry in _data)
            {
                entry.Value.CollisionFlag = collisionTags.Contains(entry.Value.Tag);
            }

            //Display Data
            _display.Clear();
            _display.Render(_data, displayCollisionList);
        }
示例#19
0
        public SLEntry Decode(BinaryData encodedData)
        {
            var parser = BinaryDataParser.OfValue(encodedData);

            var localNID = parser.TakeAndSkip(8);

            var subnodeBID = parser.TakeAndSkip(8);

            var subnodeNID = parser.TakeAndSkip(8);

            return
                (new SLEntry(
                     NID.OfValue(localNID.Take(4)),
                     bidDecoder.Decode(subnodeBID),
                     bidDecoder.Decode(subnodeNID)));
        }
示例#20
0
            public void Run()
            {
                Bitmap bitmap = null;

                try
                {
                    if (_decoder.CanProcessImage == null || !_decoder.CanProcessImage())
                    {
                        _backgroundHandler.Post(new ImageDecoder(_backgroundHandler, _surfaceView));
                        return;
                    }

                    bitmap = _surfaceView.GetBitmap(_decoder.ImageSizeX, _decoder.ImageSizeY);
                    var result = _decoder.Decode(bitmap);
                    bitmap.Recycle();
                    if (_decoder.FinishProcessImage(result))
                    {
                        return;
                    }
                }
                catch (System.Exception ex)
                {
                    bitmap?.Recycle();
                    _decoder.HandleExceptionFromProcessImage?.Invoke(ex);
                }

                _backgroundHandler.Post(new ImageDecoder(_backgroundHandler, _surfaceView));
            }
示例#21
0
        public TType TakeAndSkip <TType>(int count, IDecoder <TType> typeDecoder)
        {
            var buffer = new byte[count];

            stream.Read(buffer, 0, count);

            return(typeDecoder.Decode(BinaryData.OfValue(buffer)));
        }
 /// <inheritdoc />
 public FieldElement[] Decode(FieldElement[] noisyCodeword) =>
 _decoder.Decode(
     CodewordLength,
     InformationWordLength,
     CodeDistance,
     _generatingPolynomial,
     TransformNoisyCodeword(noisyCodeword)
     )
 .GetCoefficients(InformationWordLength - 1);
示例#23
0
        /// <inheritdoc cref="Decompress"/>
        public void Decompress(Stream input, Stream output)
        {
            if (_decoder == null)
            {
                throw new InvalidOperationException("The decoder is not set.");
            }

            _decoder.Decode(input, output);
        }
示例#24
0
 public InternalDataBlock LoadNode(LBBTEntry nodeReference)
 {
     return
         (cache
          .GetOrAdd(
              nodeReference.BlockReference.BlockId,
              () => internalDataBlockDecoder.Decode(dataBlockReader.Read(nodeReference.BlockReference.ByteIndex.Value, nodeReference.GetBlockSize())))
          .Value);
 }
示例#25
0
        private void DecodeButton_Click(object sender, RoutedEventArgs e)
        {
            if (string.IsNullOrEmpty(DataText.Text))
            {
                DecodeText.Clear();
                return;
            }

            DecodeText.Text = decoder.Decode(buff);
        }
示例#26
0
        public string Decode(string payload, IDecoder decoder)
        {
            // Decode
            Span <byte> bytes = decoder.Decode(payload);

            // Convert to string
            string result = Encoding.ASCII.GetString(bytes);

            return(result);
        }
        public void OnPlaneDecodedEventWasRaised()
        {
            var wasCalled = false;

            Uut.PlaneDecodedEvent += (o, e) => wasCalled = true; //lambda expression to subscribe on the event

            //Call Decode with a empty List only tests if the event is raised as it then doesn't use the foreach loop.
            Uut.Decode(new object(), new RawTransponderDataEventArgs(Substitute.For <List <string> >()));

            Assert.True(wasCalled);
        }
示例#28
0
        private void Decode(long offset, string key, string jsonMessage, BlockingCollection <DecodedMessage> decodedMessages)
        {
            Console.WriteLine($"Raw message consumed with offset: {offset}, key: {key}");
            var rawBusMessage = JsonConvert.DeserializeObject <RawBusMessage>(jsonMessage);
            var decoded       = _decoder.Decode(rawBusMessage);

            foreach (var decodedMessage in decoded)
            {
                decodedMessages.Add(decodedMessage); // blocks once bounded capacity reached
            }
        }
示例#29
0
        public long Run(IDataSource source, IEncoder encoder, IDecoder decoder, long msgCount, bool debug)
        {
            long totalBytesTransmitted = 0;

            for (long i = 0; i < msgCount; i++)
            {
                var sourceData = source.GetNextDataPoint();

                var encodedData = encoder.Encode(sourceData);

                // This is where the data is normally transmitted via network
                totalBytesTransmitted += encodedData.LongLength;

                var decodedData = decoder.Decode(encodedData);

                var areEqual = IotDevice.AreEquals(sourceData, decodedData, false);

                if (!areEqual || debug)
                {
                    Console.WriteLine();
                    Console.WriteLine("##########################################################");
                    Console.WriteLine($"Message number: {i+1}");
                    Console.WriteLine();

                    Console.WriteLine("source data:");
                    Console.WriteLine(sourceData);
                    Console.WriteLine();

                    Console.WriteLine("encoded data:");
                    Console.WriteLine(BitConverter.ToString(encodedData).Replace("-", ""));
                    Console.WriteLine();

                    Console.WriteLine("decoded data:");
                    Console.WriteLine(decodedData);
                    Console.WriteLine();

                    if (!areEqual)
                    {
                        // run this again to get debug outputs
                        IotDevice.AreEquals(sourceData, decodedData, true);
                    }

                    Console.WriteLine($"Encoding/Decoding successful: {areEqual}");
                }

                if (debug)
                {
                    Console.WriteLine("Press any key to send the next message.");
                    Console.ReadKey();
                }
            }

            return(totalBytesTransmitted);
        }
示例#30
0
        /// <summary>
        /// Try read next array item..
        /// </summary>
        /// <param name="reader">The json reader.</param>
        /// <param name="decoder">The decoder.</param>
        /// <param name="value">The value of the array item.</param>
        /// <returns>If succeeded.</returns>
        private static bool TryReadArrayItem(IJsonReader reader, IDecoder <T> decoder, out T value)
        {
            value = default(T);

            while (!reader.IsEndArray)
            {
                value = decoder.Decode(reader);
                return(true);
            }

            return(false);
        }
示例#31
0
        /// <summary>
        /// Computes the spectogram of an audio file.
        /// </summary>
        /// <param name="decoder">The <see cref="IDecoder"/> instance.</param>
        /// <returns>Chroma image.</returns>
        public static Image ComputeSpectrogram(IDecoder decoder)
        {
            int numBands = 72;

            var image = new Image(numBands);
            var image_builder = new ImageBuilder(image);

            var chroma = new Spectrum(numBands, MIN_FREQ, MAX_FREQ, FRAME_SIZE, SAMPLE_RATE, image_builder);

            var fft = new FFT(FRAME_SIZE, OVERLAP, chroma, new LomontFFTService());
            var processor = new AudioProcessor(SAMPLE_RATE, fft);

            processor.Reset(decoder.SampleRate, decoder.Channels);
            decoder.Decode(processor, 120);
            processor.Flush();

            return image;
        }
示例#32
0
        //static int MAX_FILTER_WIDTH = 20;

        public static Image Compute(string file, IDecoder decoder)
        {
            int numBands = 72;

            Image image = new Image(numBands);
            ImageBuilder image_builder = new ImageBuilder(image);
            Spectrum chroma = new Spectrum(numBands, MIN_FREQ, MAX_FREQ, FRAME_SIZE, SAMPLE_RATE, image_builder);
            FFT fft = new FFT(FRAME_SIZE, OVERLAP, chroma);
            AudioProcessor processor = new AudioProcessor(SAMPLE_RATE, fft);

            processor.Reset(decoder.SampleRate, decoder.Channels);
            decoder.Decode(processor, 120);
            processor.Flush();

            //ExportImage(image, name, 0.5);

            return image;
        }
示例#33
0
        /// <summary>
        /// Computes the chromagram of an audio file.
        /// </summary>
        /// <param name="decoder">The <see cref="IDecoder"/> instance.</param>
        /// <returns>Chroma image.</returns>
        public static Image ComputeChromagram(IDecoder decoder)
        {
            var image = new Image(12);
            var image_builder = new ImageBuilder(image);

            var chroma_normalizer = new ChromaNormalizer(image_builder);
            var chroma_filter = new ChromaFilter(ChromaFilterCoefficients, chroma_normalizer);
            var chroma = new Chroma(MIN_FREQ, MAX_FREQ, FRAME_SIZE, SAMPLE_RATE, chroma_filter);

            var fft = new FFT(FRAME_SIZE, OVERLAP, chroma, new LomontFFTService());
            var processor = new AudioProcessor(SAMPLE_RATE, fft);

            processor.Reset(decoder.SampleRate, decoder.Channels);
            decoder.Decode(processor, 120);
            processor.Flush();

            return image;
        }
示例#34
0
        public static Image Compute(string file, IDecoder decoder)
        {
            Image image = new Image(12);
            ImageBuilder image_builder = new ImageBuilder(image);
            ChromaNormalizer chroma_normalizer = new ChromaNormalizer(image_builder);
            ChromaFilter chroma_filter = new ChromaFilter(ChromaFilterCoefficients, chroma_normalizer);
            //Chroma chroma = new Chroma(MIN_FREQ, MAX_FREQ, FRAME_SIZE, SAMPLE_RATE, &chroma_normalizer);
            Chroma chroma = new Chroma(MIN_FREQ, MAX_FREQ, FRAME_SIZE, SAMPLE_RATE, chroma_filter);
            FFT fft = new FFT(FRAME_SIZE, OVERLAP, chroma);
            AudioProcessor processor = new AudioProcessor(SAMPLE_RATE, fft);

            processor.Reset(decoder.SampleRate, decoder.Channels);
            decoder.Decode(processor, 120);
            processor.Flush();

            //ExportImage(image, name);

            return image;
        }