Bit Operations (Bit in HEX)

[Amnon82]

Gibt es eine Liste, wo man nachschauen kann, welchen Wert die Bits in HEX haben?

Laut meiner Info ist Bit6 $40.

Ich würd gerne wissen, was bit1 - bit20 währen.

[Kroko1999]

Bit0 ist $0001
Bit1 ist Bit0*2 = $0002;
Bit2 ist Bit1*2 = $0004;
etc.

[Amnon82]

Ich habs aber in 8-bit hex number bit-mapped:

Beispiel:

Code:

92 b2 a2 b2 b2 a2 b2 b2 a2 b2 b2 a2

Ich müsste es für bit6 zum Beispiel so auslesen:

Delphi-Quellcode:

if val and $40 > 0 then
    pff := 1
else
    pff := 0;

Nun brauchs ich aber auch für bit1 zum Beispiel.

Dann müsste es nach deinem Post dann so sein:

Bit0 = $01
Bit1 = Bit0*2 > $02
Bit2 = Bit1*2 > $04
Bit3 = Bit2*2 > $10
Bit5 = Bit4*2 > $20
Bit6 = Bit5*2 > $40

$40 = 64
$20 = 32
$10 = 16
$04 = 8
$02 = 4
$01 = 2

[marabu]

Wenn du keinen hoch-performanten Code brauchst, dann würde ich den Bit-Test so machen:

Delphi-Quellcode:

function TestBit(const c: Cardinal; const bit: Byte): Boolean;
begin
  Result := Odd(c shr bit);
end;

Grüße vom marabu

[Amnon82]

Den Code hatte ich von nem Freund:

Delphi-Quellcode:

if val and $40 > 0 then
    pff := 1
else
    pff := 0;

Dieser ist meiner:

Delphi-Quellcode:

if pos(uppercase('Frame_Rate'),uppercase(listbox1.items[i])) > 0 then {nothing} else
if pos(uppercase(' '),uppercase(listbox1.items[i])) > 0 then
begin
temp:=listbox1.Items[i];
for tempi := 7 to length(temp) do
begin
value:=GetTok(temp, tempi, ' ');
if hextoint(value) and $40 > 0 then thirtytwo:=thirtytwo+1;
end;
end;
if thirtytwo > 0 then
checkbox1.checked:=true else checkbox1.checked:=false;

Ich scanne einen Text wie z.B. diesen Ausschnitt:

Code:

Aspect_Ratio=16:9
Picture_Size=720x576
Field_Operation=0
Frame_Rate=25000 (25/1)
Location=0,0,5,108C

d00 1 0 2048 1 1 92 b2 a2 b2 b2 a2 b2 b2 a2 b2 b2 a2
900 1 0 53248 1 1 32 32 92 b2 b2 a2 b2 b2 a2 b2 b2 a2

nach ' ' ab. Ich überspringe die Zeile mit 'Frame_Rate' und gehe dann auf
z.B. diese Zeile und beschränke mich auf die grünen Zahlen ...

d00 1 0 2048 1 1 92 b2 a2 b2 b2 a2 b2 b2 a2 b2 b2 a2

... mit folgendem Code:

Delphi-Quellcode:

function GetTok(const Str: string; const Idx: Integer; const Sep: Char): string;
var
  StrLen: Integer;
  StrIdx: Integer;
  ResLen: Integer;
  TokIdx: Integer;
begin
  Result := '';
  if Idx > 0 then
  begin
    StrLen := Length(Str);
    SetLength(Result, StrLen);
    ResLen := 0;
    TokIdx := 0;
    for StrIdx := 1 to StrLen do
    begin
      if (Str[StrIdx] <> Sep) and ((StrIdx = 1) or (Str[StrIdx-1] = Sep)) then
        Inc(TokIdx);
      if TokIdx > Idx then
        Break
      else if (TokIdx = Idx) and (Str[StrIdx] <> Sep) then
      begin
        Inc(ResLen);
        Result[ResLen] := Str[StrIdx];
      end;
    end;
    SetLength(Result, ResLen);
  end;
end

Ich vergleiche nun die Werte mit

Code:

function HexToInt(s: string): Longword;
var
  b: Byte;
  c: Char;
begin
  Result := 0;
  s := UpperCase(s);
  for b := 1 to Length(s) do
  begin
    Result := Result * 16;
    c := s[b];
    case c of
      '0'..'9': Inc(Result, Ord(c) - Ord('0'));
      'A'..'F': Inc(Result, Ord(c) - Ord('A') + 10);
      else
        raise EConvertError.Create('No Hex-Number');
    end;
  end;
end;

'if hextoint(value) and $40 > 0' und zähle dann die Ergebnisse

Ergebnisswerte > 0 then Checkbox1.checked:=true;

Das war nun das Beispiel für Bit6 mit $40.

Bit1 müsste dann $02 sein.

Wie sollte ich denn Deinen Code verwenden?

Hier nochmal meine letzte Rls meines Tools:

Version 0.06
* PFF/TFF routine fixed (i hope so)
* Download bin version 0.06
* Download source version 0.06

[marabu]

Die Anwendung von TestBit() ist denkbar einfach - mit deinen Beispieldaten sieht das bei mir etwa so aus:

Delphi-Quellcode:

function CheckLines(lines: TSTrings): Cardinal;
var
  i, j: Integer;
  bSkip: Boolean;
  s: TStrings;
begin
  Result := 0;
  s := TStringList.Create;
  bSkip := true;
  for i := 0 to Pred(lines.Count) do
  begin
    if not bSkip then
    begin
      s.DelimitedText := lines[i];
      for j := 6 to Pred(s.Count) do
        Result := Result + Ord(TestBit(HexToInt(s[j]), 6))
    end;
    bSkip := bSkip xor (lines[i] = '')
  end;
  s.Free;
end;

procedure TDemoForm.CheckButtonClick(Sender: TObject);
var
  thirtytwo: Cardinal;
begin
  thirtytwo := CheckLines(Memo.Lines);
  ShowMessage(IntToStr(thirtytwo));
end;

marabu

[Amnon82]

Ich hab Deine Routine hinzugefügt, aber sie liefert nur Nuller. Kannst Du einen Blick drauf werfen?

Version 0.06a
* Added marabus routine
* Download bin version 0.06a
* Download source version 0.06a

[negaH]

123 dez = 1111011 bin.

entspricht

1 * 2^0 +
1 * 2^1 +
0 * 2^2 +
1 * 2^3 +
1 * 2^4 +
1 * 2^5 +
1 * 2^6

Die erste Spalte ist 1111011bin senkrecht geschrieben mit dem LSB beginnen zum MSB, sprich mit dem niederwertigsten Bit = Rechts zum höchstwertigen Bit Links.

Die zweite Spalte ist pure Mathmatik und stellt nichts anderes als das Binäre Zahlensystem dar.
Wie du richtig bermerken wirds sind die Potenzen dort 0,1,2,3,4 usw. Exakt dieses Potenzorder IST die Numerierung der Bits !

Ergo: beim Zählen von Bits arbeitet man immer mit einem 0-basierten Index. Also Bit 0 bis Bit x.
Die Zählung beginndend mit Bit 1 ist definitiv falsch.

Möchtest du wissen welchen Wert Bit 6 hat dann ergibt sich dieser durch 1 * 2^6 = 64 dez = $40 hex.

Gruß Hagen

[Amnon82]

Zitat:

123 dez = 1111011 bin.

entspricht

1 * 2^0 +
1 * 2^1 +
0 * 2^2 +
1 * 2^3 +
1 * 2^4 +
1 * 2^5 +
1 * 2^6

Wenn ich das nun ableite und Deine Tabele durchrechne komm ich auf folgendes:

1* 2^0 = 1 > $01
1* 2^1 = 2 > $02
1* 2^2 = 4 > $04
1* 2^3 = 8 > $08
1* 2^4 = 16 > $10
1* 2^5 = 32 > $20
1* 2^6 = 64 > $40

Da hab ich mich dann doch verhaun:

Zitat:

Bit0 = $01
Bit1 = Bit0*2 > $02
Bit2 = Bit1*2 > $04
Bit3 = Bit2*2 > $10
Bit5 = Bit4*2 > $20
Bit6 = Bit5*2 > $40

So nun ist mir das mit den BitOperationen klar welcher Wert welche HEX Zahl ist, aber ich find immer noch keinen Weg die zu parsenden Zeilen zu durchforsten. Wie gesagt mich interessiern Bit6, Bit1 und Bit0 davon.

Es geht um eine D2V-Datei die zur Encodierung von MPEG2-Dateien hergenommen wird. Die benötigten Informationen sind Leider in H8-bit hex number bit-mapped. Wenn Bit6 present ist, dann ist die MPEG2-Datei Progressive. Bit1 representiert TFF Flag und Bit0 RFF Flag.

Code:

bit 6    Progressive_Frame Flag (See notes below)
0 (Interlaced)
1 (Progressive)
bit 1    TFF Flag
bit 0    RFF Flag

Ich hab nun einen Teil des Datenteils einer D2V-Datei gepostet. Ich weis das sie Progressive und TFF ist. Wie kann ich diese Werte mit einer Routine nun aus den H8-bit hex number bit-mapped Werten, die ich grün markiert habe auslesen?

d00 1 0 2048 2 1 f2 f2 d2 f2 f2 e2 f2 f2 e2 f2 f2 e2 f2 f2 e2

Code:

900 1 0 77824 2 1 72 72 d2 f2 f2 e2 f2 f2 e2 f2 f2 e2 f2 f2 e2
900 1 0 247808 2 1 72 72 d2 f2 f2 e2 f2 f2 e2 f2 f2 e2 f2 f2 e2
900 1 0 913408 2 1 72 72 d2 f2 f2 e2 f2 f2 e2 f2 f2 e2 f2 f2 e2
900 1 0 1427456 2 1 72 72 d2 f2 f2 e2 f2 f2 e2 f2 f2 e2 f2 f2 e2
900 1 0 2045952 2 1 72 72 d2 f2 f2 e2 f2 f2 e2 f2 f2 e2 f2 f2 e2
900 1 0 2781184 2 1 72 72 d2 f2 f2 e2 f2 f2 e2 f2 f2 e2 f2 f2 e2
900 1 0 3411968 2 1 72 72 d2 f2 f2 e2 f2 f2 e2 f2 f2 e2 f2 f2 e2
900 1 0 4038656 2 1 72 72 d2 f2 f2 e2 f2 f2 e2 f2 f2 e2 f2 f2 e2
900 1 0 4575232 2 1 72 72 d2 f2 f2 e2 f2 f2 e2 f2 f2 e2 f2 f2 e2
900 1 0 5203968 2 1 72 72 d2 f2 f2 e2 f2 f2 e2 f2 f2 e2 f2 f2 e2
900 1 0 5840896 2 1 72 72 d2 f2 f2 e2 f2 f2 e2 f2 f2 e2 f2 f2 e2
900 1 0 6438912 2 1 72 72 d2 f2 f2 e2 f2 f2 e2 f2 f2 e2 f2 f2 e2

Hier nochmal der Link zum Handbuch von DGIndex, das Programm, welches die D2V-Dateien erstellt. Für mein Problem ist der Part 'D2V Format - Data Section' relevant. Falls Du mir helfen kannst, währe ich Dir sehr dankbar.

Hier die neuste D2VParse Release:

http://img86.imageshack.us/img86/6984/d2vparsev75ry.png

[marabu]

Jetzt, nachdem Hagen dir die dualen Zahlen als Stellenwertsystem näher gebracht hat, solltest du vielleicht nochmal die Routine CheckLines aus meinem Beitrag #6 anschauen. Wenn du nun den Aufbau einer Dualzahl verstehst, dann kannst du vielleicht auch den Code an deine Bedürfnisse anpassen?

Freundliche Grüße vom marabu

[Amnon82]

Hmm. Wenn Du willst kannst Du ja die neuste Release näher anschauen.

Ich hab mal das Test.d2v-file mit meiner Routine bis Zeile 16 gescannt. Der erste Wert ist der HEX-Wert, den ich parse. HEXTOINT ist der gleiche Wert umgewandelt in Integer. Danach zurück zu String.

Code:

Bit1 - HEX:    92   HEXTOINT:   146   INTTOSTR:   2
Bit6 - HEX:    f2   HEXTOINT:   242   INTTOSTR:   64
Bit1 - HEX:    f2   HEXTOINT:   242   INTTOSTR:   2
Bit6 - HEX:    e2   HEXTOINT:   226   INTTOSTR:   64
Bit1 - HEX:    e2   HEXTOINT:   226   INTTOSTR:   2
Bit6 - HEX:    f2   HEXTOINT:   242   INTTOSTR:   64
Bit1 - HEX:    f2   HEXTOINT:   242   INTTOSTR:   2
Bit6 - HEX:    f2   HEXTOINT:   242   INTTOSTR:   64
Bit1 - HEX:    f2   HEXTOINT:   242   INTTOSTR:   2
Bit6 - HEX:    e2   HEXTOINT:   226   INTTOSTR:   64
Bit1 - HEX:    e2   HEXTOINT:   226   INTTOSTR:   2
Bit6 - HEX:    f2   HEXTOINT:   242   INTTOSTR:   64
Bit1 - HEX:    f2   HEXTOINT:   242   INTTOSTR:   2
Bit6 - HEX:    f2   HEXTOINT:   242   INTTOSTR:   64
Bit1 - HEX:    f2   HEXTOINT:   242   INTTOSTR:   2
Bit6 - HEX:    e2   HEXTOINT:   226   INTTOSTR:   64
Bit1 - HEX:    e2   HEXTOINT:   226   INTTOSTR:   2
Bit6 - HEX:    f2   HEXTOINT:   242   INTTOSTR:   64
Bit1 - HEX:    f2   HEXTOINT:   242   INTTOSTR:   2
Bit6 - HEX:    f2   HEXTOINT:   242   INTTOSTR:   64
Bit1 - HEX:    f2   HEXTOINT:   242   INTTOSTR:   2
Bit6 - HEX:    e2   HEXTOINT:   226   INTTOSTR:   64
Bit1 - HEX:    e2   HEXTOINT:   226   INTTOSTR:   2
Bit6 - HEX:    72   HEXTOINT:   114   INTTOSTR:   64
Bit1 - HEX:    72   HEXTOINT:   114   INTTOSTR:   2

Zum Vergleichen verwende ich:

Delphi-Quellcode:

begin
  value:=GetTok(temp, tempi, ' ');
  if hextoint(value) and $40 > 0
  then
  begin
    thirtytwo:=thirtytwo+1;
    memo1.lines.add('Bit6 - HEX:    '+value+'   HEXTOINT:   '+inttostr(hextoint(value))+'   INTTOSTR:   '+inttostr($40));
  end;
  if hextoint(value) and $02 > 0
  then
  begin
    wo:=two+1;
    memo1.lines.add('Bit1 - HEX:    '+value+'   HEXTOINT:   '+inttostr(hextoint(value))+'   INTTOSTR:   '+inttostr($02));
  end;
  if hextoint(value) and $01 > 0
  then
  begin
   zero:=zero+1;
   memo1.lines.add('Bit0 - HEX:    '+value+'   HEXTOINT:   '+inttostr(hextoint(value))+'   INTTOSTR:   '+inttostr($01));
  end;
  if thirtytwo > 0
  then
  checkbox1.checked:=true
  else
  checkbox1.checked:=false;
  if two > zero
  then
  radiobutton1.checked:=true
  else
  radiobutton2.checked:=true;
  if checkbox3.checked=true
  then
  if i > strtoint(edit14.text)
  then
  exit;
end;

Ich hoffe ich bin nun auf dem Richtigen Weg.

Hier noch mal ein Test.d2v-file:

[marabu]

Ich habe mir deinen Quelltext mal angesehen. Speziell hat mich interessiert, warum du mit meiner Routine CheckLines nicht zurecht kommst. Das liegt daran, dass du die Routine nicht korrekt an deine Bedürfnisse angepasst hattest. Deine Schleifensteuerung ist auch jetzt nicht auf die Verwendung meines Codes abgestimmt. CheckLines verarbeitet alle Zeilen in einem Rutsch. Willst du eine zeilenweise Verarbeitung, dann musst du den Code umbauen. Ich habe dir die Routine mal als FSM an die Testdatei angepasst:

Delphi-Quellcode:

function CheckLines(lines: TSTrings): Cardinal;
type
  TState = (stUndefined, stHeader1, stHeader2, stData);
var
  i, j: Integer;
  s: TStrings;
  state: TState;
begin
  state := stUndefined;
  Result := 0;
  s := TStringList.Create;
  for i := 0 to Pred(lines.Count) do
  begin
    case state of
      stUndefined:
        if AnsiStartsText('DGIndex', lines[i]) then
          Inc(state);
      stHeader1,
      stHeader2:
        if lines[i] = '' then
          Inc(state);
      stData:
        if lines[i] = '' then
          state := stUndefined else
        begin
          s.DelimitedText := lines[i];
          for j := 6 to Pred(s.Count) do
            Result := Result + Ord(TestBit(HexToInt(s[j]), strtoint(form1.Edit15.text)))
        end;
    end;
  end;
  s.Free;
end;

marabu

[Amnon82]

@Marabu:

Ich hab nun Deine modifizierte Function eingebaut. Nun müsste man nur die Auswertung diskutieren.

Wenn ich $02 für Bit1 eingebe erhalte ich folgendes Ergebnis:

BitX 1 $02
BitX 1 $02
BitX 1 $02
BitX 1 $02

Somit müsste bit1 enthalten sein.
Auch bei bit6 mit $40 kommt das gleiche Ergebnis:

BitX 1 $40
BitX 1 $40
BitX 1 $40
BitX 1 $40

Nur bei bit0 was RFF simbolisiert kommt ein anderes:

BitX 3173 $01
BitX 3173 $01
BitX 3173 $01
BitX 3173 $01

also müsste der Wert 3173 falsch sein.

bei $64 käme z.B. folgendes raus:

BitX 2380 $64
BitX 2380 $64
BitX 2380 $64
BitX 2380 $64

$10 & $08 hingegen lieften folgendes:

BitX 0 $10
BitX 0 $10
BitX 0 $10
BitX 0 $10

BitX 0 $08
BitX 0 $08
BitX 0 $08
BitX 0 $08

Eins und Null währen mir klar. 1 für enthalten. 0 für nicht enthalten. Was haben aber die anderen Werte zu sagen?

Deine Function hab ich mit folgendem Code ausgeführt:

Delphi-Quellcode:

      
begin        
  Application.ProcessMessages;
  thirtytwo2 := CheckLines(memo.lines);
  Progressbar1.position:=i;
  memo1.lines.add('BitX '+inttostr(thirtytwo2)+' '+edit15.text);
end

Ich hab mal Version8 gecodet. Kannst Du nochmal einen abschließend Blick drauf werfen? Deine Routine ist echt schneller als meine ;)

[marabu]

Um Missverständnissen vorzubeugen: mein Code ist nicht auf Performanz ausgelegt - Tuning für das Verarbeiten großer Datenmengen steht da gewiss noch aus. 1 und 0 stehen gewiss nicht für vorhanden und nicht vorhanden, sondern sind Zähler für das Vorkommen eines bestimmten Bits in einem Datenabschnitt. Wie kommt es zur Ausgabe von BitX 1 $02 viermal hintereinander? Liegt das immer noch an deinem Rahmenprogramm, welches nicht auf die Verwendung von CheckLines() ausgelegt war? Oder hast du eine Datei mit vier DGIndex-Abschnitten? Die Ausgabe BitX 3173 $01 hat die Bedeutung Bit 0 war im entsprechenden Datenabschnitt 3173-mal gesetzt.

marabu

[Amnon82]

@marabu: Dann müsste ich es ja total anders auslesen.

Einen den ich kenne hat folgendes geschrieben:

Zitat:

Zitat von Garfield

Zitat:

Zitat von Amnon82

Der Leerzeichencode hat eh noch einen Bug, da ich erst ab der Zeile Stream_Type= anfangen zu Suchen müsste.

Da könnte man die Schleife mit 4 (= Zeile 5) beginnen lassen. Vorausgesetzt, die Liste der Dateinamen wird ab einer bestimmten Länge nicht auf mehrere Zeilen verteilt.

Zitat:

Zitat von Amnon82

Das Problem ist noch nicht ganz gelöst. Ich komm mit der Bit-Auslesung nicht klar.

Sollte doch nicht so schwer sein. :gruebel:

Zitat:

Zitat von jfheins

Delphi-Quellcode:

if (value and $00100000) <> 0 then
// Bit gesetzt

;)

Das ist natürlich falsch, weil $ einer hexadezimalen und keiner dualen Zahl vorangestellt wird. Damit sind es nicht 8 Bit sondern 8 Byte. $00100000 müsste 1.048.576 sein. Das sechste Bit ist 32 bzw $20.

$20 ist vom Typ Integer. Da Du Strings hast, muss konvertiert werden. Aus dem String musst Du die beiden Zeichen, welche Du auswerten willst - zum Beispiel 'B0' - extrahieren. Dann kannst Du es so auswerten:

Delphi-Quellcode:

...
var
  Wert : String;
  Zahl : Byte;   // $00 bis $FF
...
begin
  ...
  Wert := 'B0';

  Zahl := StrToInt ('$' + Wert);

  if Zahl AND $20 > 0
  then
    { Bit 6 gesetzt }
  else
    { Bit 6 nicht gesetzt };
  ...

Die anderen Bits lassen sich entsprechend auswerten.

Ich werd mir mal was ausdenken ...

[Amnon82]

Delphi-Quellcode:

{D2VParse v8

              forty2 :=0;
              forty2 := CheckLines(memo.lines,$40);
              if forty2=1 then
              begin
              forty:=forty+1;
              memo1.lines.add('Bit6 found - '+inttostr(forty));
              end;
              forty2 :=0;
              forty2 := CheckLines(memo.lines,$02);
              if forty2=1 then
              begin
              two:=two+1;
              memo1.lines.add('Bit2 found - '+inttostr(two));
              end;
              forty2 :=0;
              forty2 := CheckLines(memo.lines,$01);
              if forty2=1 then
              begin
              zero:=zero+1;
              memo1.lines.add('Bit0 found - '+inttostr(zero));
              end;

              D2VParse v9}
              forty2 :=0;
              forty2 := CheckLines(memo.lines,$40);
              if forty2>0 then
              begin
              forty:=forty+forty2;
              memo1.lines.add('Bit6 found - '+inttostr(forty));
              end;
              forty2 :=0;
              forty2 := CheckLines(memo.lines,$02);
              if forty2>0 then
              begin
              two:=two+forty2;
              memo1.lines.add('Bit1 found - '+inttostr(two));
              end;
              forty2 :=0;
              forty2 := CheckLines(memo.lines,$01);
              if forty2>0 then
              begin
              zero:=zero+forty2;
              memo1.lines.add('Bit0 found - '+inttostr(zero));
              end;

Ich hab mal die marabu routine angepasst. Nun kommen andere Werte raus, da er nun auch die Bit0 zählt. Laut DGIndex ist das D2V aber TFF und nicht BFF.

http://img49.imageshack.us/img49/188/top2ae.png