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