Konvertierung von C nach Delphi

[venice2]

Wie kann ich das nach Delphi umsetzen?

Code:

Cnv16to8(data,(signed char*) &tl.waveform[0][0], 1024);

damit komme ich nicht klar >> Cnv16to8

[mkinzler]

Das ist eine Funktion.

[himitsu]

Erstmal muß man wissen was Cnv16to8 eigentlich macht, um dann zu schauen ob es sowas schon fertig im Delphi gibt,
oder was man alternativ benutzen kann.

Tja, Cnv16to8 findet aber nciht wirklich viel dazu,
aber die ersten beiden der 5 Suchergebnisse behandeln genau das, was du suchst, auch wenn ohne Ergebnis.

[venice2]

Zitat:

Zitat von mkinzler (Beitrag 1468457)

Das ist eine Funktion.

Jo habe mir so etwas gedacht nur wie lege ich das nach Delphi um?

Zitat:

convert the data to 8 bit

Wie?
Scheinen 16 Bit Daten zu sein die nach 8 Bit konvertiert werden müssen.

Code:

long Cnv16to8 (signed short *source,signed char *dest,unsigned long samples)
{
  unsigned long i;

  for (i=0;i<samples;i=i+2)
    dest[i>>1]=source[i]>>8;

  return i; 

}

Danke

[Incocnito]

Hi venice2,

hast du denn die Ausgangsdaten überhaubt?
Sprich das was bei "source" und "samples" rein muss?
Und wohin willst du dann "dest" weiter reichen?
Vielleicht kann man Anhand dessen schonmal die Datentypen ermitteln!

Sonst rate ich, wäre das sowas:

Delphi-Quellcode:

type WordArr = Array of Word;
type ByteArr = Array of Byte;
function Cnv16to8 (const source WordArr; var dest ByteArr; const samlpes : Cardinal) : Cardinal;
var i2 : Cardinal;
begin
  for i2 := 0 to (samples div 2) do
  begin
    dest[i2] := source[i2 shr 1] shl 8;
  end;
  Result := i2;
end;

Annahmen:
- signed short = 16 Bit // Word = 16 Bit
- signed char = 8 Bit // Byte = 8 Bit
C arbeitet hier mit Pointern, da die Werte ja geändert werden müssen,
was wir uns ja bei Delphi prinzipiell schenken können, dank dem hilfreichen Compiler.
Da i immer 2 hochgezählt wird, habe ich mal "i2" genommen.
Ich hoffe nur, ich habe mich beim Umsetzen jetzt nicht verkaspert! ;-)
Ansonsten: Gegenvorschläge? Hinweise? Fehler? Ich bin für alles zu haben!

MfG
Incocnito

[himitsu]

for i2 := 0 to (samples div 2) - 1 do

und ich würde ehre auf SHR tippen
dest[i2] := source[i2 shr 1] shr 8;

oder

Delphi-Quellcode:

dest[i2] := High(source[i2 shr 1]);

bzw. besser so

Delphi-Quellcode:

dest[i2] := WordRec(source[i2 shr 1]).Hi;

Jupp, sieht so aus, als wenn da einfach nur jedes zweite Byte umkopiert wird,
also aus einem Word-Array wird ein Byte-Array und das kannst auch gern über zwei Arrays lösen

Delphi-Quellcode:

var
  WordData: array[0..Length-1] of Word;  // oder hier direkt WordRec als Typ, das erspart dann den Cast 
  ByteData: array[0..Length-1] of Byte;

for i := 0 to Length-1 do
  ByteData[i] := WordRec(WordData[i]).Hi;  // := WordData[i] shr 8;

Man könnte das hier sogar im selben Speicher/Array umkopieren, aber da darfs man dann NIEMALS von hinten kopieren, sondern muß vorwärts durch die Daten,
denn sonst überschreibt man Daten, die später noch kopieren werden sollen.

[venice2]

Zitat:

Zitat von Incocnito (Beitrag 1468468)

Hi venice2,

hast du denn die Ausgangsdaten überhaubt?
Sprich das was bei "source" und "samples" rein muss?
Und wohin willst du dann "dest" weiter reichen?
Vielleicht kann man Anhand dessen schonmal die Datentypen ermitteln!

Sonst rate ich, wäre das sowas:

Delphi-Quellcode:

type WordArr = Array of Word;
type ByteArr = Array of Byte;
function Cnv16to8 (const source WordArr; var dest ByteArr; const samlpes : Cardinal) : Cardinal;
var i2 : Cardinal;
begin
  for i2 := 0 to (samples div 2) do
  begin
    dest[i2] := source[i2 shr 1] shl 8;
  end;
  Result := i2;
end;

Annahmen:
- signed short = 16 Bit // Word = 16 Bit
- signed char = 8 Bit // Byte = 8 Bit
C arbeitet hier mit Pointern, da die Werte ja geändert werden müssen,
was wir uns ja bei Delphi prinzipiell schenken können, dank dem hilfreichen Compiler.
Da i immer 2 hochgezählt wird, habe ich mal "i2" genommen.
Ich hoffe nur, ich habe mich beim Umsetzen jetzt nicht verkaspert! ;-)
Ansonsten: Gegenvorschläge? Hinweise? Fehler? Ich bin für alles zu haben!

MfG
Incocnito

Die Ausgangsdaten sind

Delphi-Quellcode:

  TimedLevel = record
    frequency : array [0..1, 0..SA_BUFFER_SIZE-1] of byte;
    waveform  : array [0..1, 0..SA_BUFFER_SIZE-1] of byte;
    state : integer;
    timeStamp : int64;
  end;

Code:

typedef struct tagTimedLevel
{
    unsigned char frequency[ 2 ][ 1024 ];
    unsigned char waveform[ 2 ][ 1024 ];
    int state;
    __int64 timeStamp;
}   TimedLevel;

Code:

{
   RECT rect;
   rect.left = rect.top = 0;
   rect.right = visWidth;
   rect.bottom = visHeight;
   TimedLevel tl;
   tl.state = play_state;

   short data[2048]={0};
   BASS_CHANNELINFO info;
   BASS_ChannelGetInfo(hStream, &info);
   
   BASS_ChannelGetData(hStream, data, 2048);
   for (int a=0;a<2048;a++)
      data[a] = (signed short)(data[a]);

   if(info.chans==1) {
      Cnv16to8(data,(signed char*) &tl.waveform[0][0], 1024);
      Cnv16to8(data,(signed char*) &tl.waveform[1][0], 1024);
   } else {
      Cnv16to8(data,(signed char*) &tl.waveform[0][0], 1024);
      Cnv16to8(data+1,(signed char*) &tl.waveform, 1024);
   }

   float fft[1024]={0};
   BASS_ChannelGetData(hStream, fft, BASS_DATA_FFT2048);
   for(int i=0;i<1024;i++)
      tl.frequency[0][i] = tl.frequency[1][i] = (BYTE)min(255,fft[i]*512)*25;
}

Zitat:

und ich würde ehre auf SHR tippen

Ja.. >> ist in Delphi SHR (Shift Right) bzw. << (Shift Left)

[himitsu]

PS: als kleine Rechenbeispiele:
https://www.delphipraxis.net/204656-...ml#post1467491

Da wird zwar von 4 auf 8 Bit umgerechnet, aber der "Scheiß" ist bestimmt dennoch nett anzuschauen. :duck:

[venice2]

Zitat:

Zitat von himitsu (Beitrag 1468494)

PS: als kleine Rechenbeispiele:
https://www.delphipraxis.net/204656-...ml#post1467491

Da wird zwar von 4 auf 8 Bit umgerechnet, aber der "Scheiß" ist bestimmt dennoch nett anzuschauen. :duck:

Danke gute Leseprobe hilft mir aber im Moment nicht weiter ;)

Das

Code:

   for(int i=0;i<1024;i++)
      tl.frequency[0][i] = tl.frequency[1][i] = (BYTE)min(255,fft[i]*512)*25;

geht in Delphi ja so auch nicht.

[himitsu]

Für später, falls du überlegst deinen Code dann noch zu optimieren, oder so. :lol:


Es sieht so aus, als wenn da Audio mit 2 Channels rein kommt und das auf zwei Streams mit jeweils einem Channel zerlegt wird,
für eine Fast Forward Transformation.
Da gibt es bestimmt unter den vielen BASS-Beispielen irgendwo schon was Fertiges für.

[venice2]

Zitat:

Zitat von himitsu (Beitrag 1468496)

Für später, falls du überlegst deinen Code dann noch zu optimieren, oder so. :lol:


Es sieht so aus, als wenn da Audio mit 2 Channels rein kommt und das auf zwei Streams mit jeweils einem Channel zerlegt wird.
Da gibt es bestimmt unter den vielen BASS-Beispielen irgendwo schon was Fertiges für.

Nein nicht für den besonderen Fall.

[himitsu]

Zitat:

Zitat von venice2 (Beitrag 1468495)

geht in Delphi ja so auch nicht.

Ist das zweite = ein Vergleich (oder war das dieses ==) oder auch eine Zuweisung?

Ist wohl eher das Zweite?

Delphi-Quellcode:

for var i := 0 to 1023 do  // das VAR im neusten Delphi, aber muß man nicht so machen, nur weil es in dem C-Code auch so gemacht wird
  tl.frequency[0][i] := tl.frequency[1][i] = Byte(Min(255, fft[i] * 512) * 25);

Delphi-Quellcode:

for var i := 0 to 1023 do begin
  tl.frequency[0][i] := Byte(Min(255, fft[i] * 512) * 25); 
  tl.frequency[1][i] := tl.frequency[0][i];
end;

[venice2]

Zitat:

Ist das zweite = ein Vergleich (oder war das dieses ==) oder auch eine Zuweisung?

In C (==) bedeutet in Delphi

Delphi-Quellcode:

if (x = x1) then

und (=)

Delphi-Quellcode:

x := x1;

Danke dir werde es mal testen.

[TurboMagic]

Noch eine Kleinigkeit: den Byte Array kann man evtl. auch durch den in SysUtils vordefinierten TBytes Datentyp ersetzen.

[venice2]

Zitat:

Zitat von TurboMagic (Beitrag 1468516)

Noch eine Kleinigkeit: den Byte Array kann man evtl. auch durch den in SysUtils vordefinierten TBytes Datentyp ersetzen.

Nein geht nicht weil die Definition Byte ist.

Delphi-Quellcode:

  TimedLevel = record
    frequency : array [0..1, 0..SA_BUFFER_SIZE-1] of byte;
    waveform : array [0..1, 0..SA_BUFFER_SIZE-1] of byte;
    state : integer;
    timeStamp : int64;
  end;

Den Record kann ich nicht mal so eben umschreiben der ist vorgegeben.

so gehts..

Delphi-Quellcode:

for var i := 0 to 1023 do 
begin
  tl.frequency[0, i] := Trunc(Min(255, fft[i] * 512) * 25); // Byte geht nicht. fft ist single
  tl.frequency[1, i] := tl.frequency[0, i];
end;

in C kann man das auf byte casten in Delphi nicht das verlangt round oder Trunc warum auch immer.

[himitsu]

Egal, da die Daten sowieso manuell reingefüllt werden, also von dir und deinem Code, also kännte man es auch ändern, falls man es für nötig hielte.
[edit] sah erst so aus, aber wollte nur nochmal schnell nachsehen wie groß SA_BUFFER_SIZE ist und ob man das ALLES auf dem Stack haben wöllte, und dann fand ich
https://docs.microsoft.com/en-us/pre...152(v%3Dvs.85)

[venice2]

Zitat:

Zitat von himitsu (Beitrag 1468524)

Egal, da die Daten sowieso manuell reingefüllt werden, also von dir und deinem Code, also kännte man es auch ändern, falls man es für nötig hielte.

Jo. ;)