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.