Delphi type nach c#

[EWeiss]

Wie könnte ich das nach c# umsetzen ?

Delphi-Quellcode:

type
 TWaveData = array [0 .. 1023] of smallint;

 MeineClass = class(TComponent)
 public
   function GetWaveData: TWaveData;

end;

gruss

[Neutral General]

Was ich gefunden hab wäre oben bei den "uses":

Code:

using TWaveData = Int16[1024];

Aber das ist ungetestet. (Quelle: http://stackoverflow.com/questions/9...g-type-aliases )

[Dejan Vu]

Nee, das geht so nicht.

So wäre es straightforward.

Code:

class MyClass
{
  public int[] GetWaveData { return new int16[1024]; }
}

Wenn Du auf deinen 1024 Words bestehst, dann kannst Du das auch in eine Klasse packen und verhindern, das man den Puffer verändert;

Code:

class WaveData
{
  private readonly Int16[] data = new Int16[1024];
  public Int16[] Data {get{return data;}}
}

Dafür ein Unittest und fertig.

Code:

[Test]
public void WaveDataSizeTest()
{
  var unit = new WaveData();
  Assert.AreEqual(unit.Data.Length, 1024);
}

Alternativ geht es auch mit unsafe:

Code:

internal unsafe struct WaveData
{
    public fixed Int16 Data [1024];
}

internal class MeineClass
{
    public unsafe WaveData GetWaveData()
    {
        var myWaveData = new WaveData();
        myWaveData.Data[0] = 3;
        return myWaveData;
    }
}

Dann musst Du mit der Option '/unsafe' kompilieren bzw. dies so in den Projekteigenschaften einstellen.

Ich persönlich würde eine der ersten beiden Varianten wählen. Ich weiß nicht, ob die 1024 Words in Stein gemeißelt sein müssen. Imho reicht es, wenn 1024 Elemente geliefert werden und dann -wie es sein sollte- über 'Length' iteriert wird.

Es wäre aber natürlich denkbar, das an 1000 Stellen im Code implizit diese Größe vorausgesetzt wird, dann Variante #2.

Der Nachteil/Das Besondere von #3 ist der, das der Speicherbereich nicht mehr verändert wird, d.h. die Adresse ändert sich nicht mehr.

[EWeiss]

Danke.
Weis jetzt nicht ob das so möglich ist unter MSV

int16 ja da muss ich drauf bestehen denn anschließend benötige ich das gleiche nochmal
mit 32 Bit Floating Point also float[1024]

Ich wollte es so machen
Geht aber nicht.

Code:

namespace MediaPortal.UI.Presentation.Players
{
  /// <summary>
  /// Provides access to sound player functionality needed to render Wave.
  /// </summary>
  public interface IWavePlayer : IAudioPlayer
  {
    float WaveData = new WaveData[1023];
    int16 WaveData32 = new WaveData32[1023];

    //Hier ne function mit der ich den wert zurückgeben kann wie in Delphi halt
  }
}

0..1023 = 1024 in c# ?

gruss

[Dejan Vu]

Da fehlen noch die [] in der Deklaration. Egal was Du willst, es geht nur so, wie ich beschrieben habe. Such dir eins aus.
Und klar: 1024 Elemente belegen die Indizes 0 bis 1023 einschließlich. Also müsstest Du deine Arrays mit [1024] instantiieren.

Code:

namespace MediaPortal.UI.Presentation.Players
{
  public class WaveData
  { // siehe meinen Code
  }

  /// <summary>
  /// Provides access to sound player functionality needed to render Wave.
  /// </summary>
  public interface IWavePlayer : IAudioPlayer
  {
    int[] GetWaveData();  // so
    WaveData GetWaveData1(); // oder so
 }

}

[EWeiss]

Danke dir..
Bin jetzt etwas Durcheinander weil von einem Beitrag auf den anderen verwiesen wird.
Werd mal schauen ob ich das jetzt irgendwie zusammenkleben kann.

gruss

[EWeiss]

Komme noch nicht ganz zurecht.

Code:

namespace MediaPortal.UI.Presentation.Players
{
  /// <summary>
  /// Provides access to sound player functionality needed to render Wave over 32 Bit Floating Point. See BASS_SAMPLE_FLOAT.
  /// </summary> 
  public class WaveData32
  {
    private readonly float[] data = new float[1024];
    public float[] Data { get { return data; } }
  }
  
  /// <summary>
  /// Provides access to sound player functionality needed to render Wave.
  /// </summary>  
  public class WaveData
  {
    private readonly Int16[] data = new Int16[1024];
    public Int16[] Data { get { return data; } }
  }  

  /// <summary>
  /// Provides access to sound player functionality needed to render a spectrum analyzer.
  /// </summary>
  public interface IVizAnalyze : IAudioPlayer
  {
    
    WaveData GetWaveData();

    WaveData32 GetWaveData32();
  .....

Rückgabe: c#

Code:

    public WaveData GetWaveData()
    {
      BassStream vizStream = _controller.PlaybackProcessor.VizStream;
      if (vizStream == null)
        return GetWaveData(); // <- Fehler?

      if (_externalState == PlayerState.Active)
      {
        if (BassWasapi.BASS_WASAPI_IsStarted())
        {
          BassWasapi.BASS_WASAPI_GetData(return , 2048);
        }
        else
          Bass.BASS_ChannelGetData(vizStream.Handle, return, 2048);
      }
    }

Delphi wäre return @Result
also
TWaveData = array [0 .. 1023] of smallint;

wie muss ich das noch umsetzen?
Will irgendwie nicht.

gruss

[Dejan Vu]

100% habe ich den Code nicht verstanden, aber ich versuche es mal

Code:

public WaveData GetWaveData()
{
  WaveData result = new WaveData();
  BassStream vizStream = _controller.PlaybackProcessor.VizStream;
  if (vizStream == null)
     return result;

  if (_externalState == PlayerState.Active)
  {
    if (BassWasapi.BASS_WASAPI_IsStarted())
    {
      BassWasapi.BASS_WASAPI_GetData(WaveData.Data , 2048);
    }
    else
    {
      Bass.BASS_ChannelGetData(vizStream.Handle, WaveData.Data, 2048);
    }
  }
  return result;
}

Hier ist es wichtig, wie die DLL-Aufrufe in C# deklariert sind.

[EWeiss]

Zitat von Dejan Vu:

100% habe ich den Code nicht verstanden, aber ich versuche es mal

Code:

public WaveData GetWaveData()
{
  WaveData result = new WaveData();
  BassStream vizStream = _controller.PlaybackProcessor.VizStream;
  if (vizStream == null)
     return result;

  if (_externalState == PlayerState.Active)
  {
    if (BassWasapi.BASS_WASAPI_IsStarted())
    {
      BassWasapi.BASS_WASAPI_GetData(WaveData.Data , 2048);
    }
    else
    {
      Bass.BASS_ChannelGetData(vizStream.Handle, WaveData.Data, 2048);
    }
  }
  return result;
}

Hier ist es wichtig, wie die DLL-Aufrufe in C# deklariert sind.

Super.. Danke schön
Jetzt nur noch ein kleines Problem..

Zitat:

Error 2 Argument 1: cannot convert from 'short[]' to 'float[]' D:\MP 2.0\MediaPortal-2\MediaPortal\Source\UI\Players\BassPlayer\BassPla yer.cs 445 42 BassPlayer

BASS_WASAPI_GetData erwartet als Argument float[] ich muss aber short übergeben

Delphi

Delphi-Quellcode:

  TWaveData   = array [0 .. 1023] of smallint; // Wave Data
  TWaveData32 = array [0 .. 1023] of Single;   // 32 Bit Wave Data

gruss

[Medium]

Dann wirst du wohl zwei Arrays brauchen, eins mit floats und eines mit int16. Das float-Array in GetData() einsetzen, dessen Inhalt danach unter dem üblichen Genauigkeitsverlust in das int16-Array umkopieren (bzw. "umkopikonvertieren"), und dieses dann nachher weiter benutzen. Anders würde man das in Delphi auch nicht machen können, wenn schlicht die Typen (und in diesem Fall sogar die Längen in Byte) nicht übereinstimmen.

Am Rande: Ich vermute, dass Wave-Daten als Floats in Werten von -1..1 geliefert, als int16 aber -32768..32767 erwartet werden. Du müsstest in diesem Fall dann natürlich entsprechend skalieren beim "umkopikonvertieren".