Stratégie pour décaler des bitsRésolu

Question

Salut la compagnie ,

Je travaille sur les fichiers midi : les évènements midi utilisent un paramètre qui est un DeltaTime et qui peut (et doit ) codé sur 32 bi</gras>. Sauf qu'il y a un sauf (ben oui sinon c'est pas drole).

Z'explique le truc :

Prenons un longword bidon :

10000001 10110001 10110001 1010001

Selon la norme Midi il faut sucré pour chaque Bytes le premier bit (ou le dernier si on va de la gauche vers la droite)

On obtient donc ceci

(1)0000001 (1)0110001 (1)0110001 (1)010001

On rafistole le tout (Encore un truc à la Mac Gyver ) :

On obtient 0000001 0110001 0110001 010001

On remplace les bits "perdus" par des zéros

On obtient : 0000 0000001 0110001 0110001 010001

Même si je connais les opérateurs binaires, je n'ai aucune idée de comment faire la chose.

Merci à vous

f0xi · Accepted Answer

masquage du 7 eme bit :

byte : $7F (1000-0000)
word: $7F7F (1000-0000-1000-0000)
longword : $7F7F7F7F
int64 : $7F7F7F7F7F7F7F7F

pouf

masque bit 0
$E

masque bit 1
$D

masque bit 2
$B

masque bit 3
$7

et comme les bits se repete en hexa par mot de 4 bits ...

masque bit 4
$EF

masque bit 5
$DF (SDF lol)

masque bit 6
$BF

masque bit 7
$7F

etc...

et on repetre pour du 16, 32, 64 bits.

ensuite pour tout ce qui est decalage/rotation :

assembleur : SHL, SHR, ROL, ROR
+ pour manipuler les octets : XCHG, BSWAP

Francky23012301 · Answer

Salut Cirec : j'ai vu cette source mais elle ne fait pas avancer rmon schmilblic .

Tavounet · Answer

J'ai été voir le lien sur ta réponse cirec et là, il me semble que le problème est bien plus complexe, il ne s'agit pas d'une vulgaire opération. ^^

Francky, est-ce que tu peux récupérer tes bits un par un?
Si oui, j'ai peut-être une idée.

Tu pars d'un longword 00000000 00000000 00000000 00000000.

Tu récupères le premier bit puis tu décales ton longword à droite en insérant le bit récupéré.

Idem pour le deuxième, troisième...

Tu as juste à "sauter" les 1 que tu veux virer.

Une fois tes 28 bits récupérés, tu fais un décalage à droite avec insertion de 0 quatre fois, et tu obtiendras ta valeur normalement.

Je ne sais pas si ça fonctionne, mais à tester ^^

Bon courage

Francky23012301 · Answer

Salut

En fait je ne récupère pas les messages midi : c'est pour faire un fichier midi.
Un lien pourles explications .

Si l'utilisateur veut ajouter une note : la procédure suivante est lancée :
procedure TMidiWriter.Add_NoteOn_Event(Const DeltaTime : LongWord; Const Channel, KeyNumber, Velocity: byte);
Et là il faut transformer le Delta Time en virant les premiers bits.

Pour être honnète j'ai trouvé ceci :

void WriteVarLen (register long value)
{
register long buffer;
buffer = value & 0x7f;
while ((value >>= 7) > 0)
{
buffer <<= 8;
buffer |= 0x80;
buffer += (value & 0x7f);
}
while (TRUE)
{
putc(buffer & 0xFF,outfile);
if (buffer & 0x80)
buffer >>= 8;
else
break;
}
}

doubleword ReadVarLen ()
{
register doubleword value;
register byte c;
if ((value = getc(infile)) & 0x80)
{
value &= 0x7f;
do
{ value (value <<7) + ((c getc(infile)) & 0x7f);
} while (c & 0x80);
}
return (value);
}

Manque de bol c'est du C donc j'y comprend que dalle et cette saloperie d'opérateur <<= je l'ai trouvé nul part donc je sais pas ce que c'est.

Merci A++
.

Francky23012301 · Answer

Salut Cari : la fonction de f0xi AllToBinStr(const Buffer; const bSize : integer; var OutBinStr : string); pourrait éventuellement me dépanner. Mais je trouve ca lourd tout ca pour déplacer 4 octets . Ca fait pas propre à mon gout (Je sais je suis chiant mais apres c'est qui qui va se faire gronder quand il va poster le source???? C'est francky ).

Je vais voir du coté de l'Assembleur  (En même temps mon pc est plus sous garantis donc j'hésite : l'asm peut etre dangereux  sous les mains de Francky )

Francky23012301 · Answer

Pardon 4 bits (une fonction éditer serait la bienvenue )

cs_Kenavo · Answer

Elle est où la contrepèterie dans le titre ??




procedure Virons4Bits (var v: longword);
begin
  v :=  v  and  $7F7F7F7F;
  v : = (v+ v and $7F) div 2;      // 2^7 - 1
  v :=  (v + v  and  $3FFF) div 2;   // 2^14 - 1
  v : = (v + v and $1FFFFF) div 2; // 2^21 - 1


end;






C'est pour décaler les sons ??

Ken@vo




 



Code, Code, Codec !

Francky23012301 · Answer

Non Kenavo c'est pour formater le paramètre Delta Time des midis . Ta procédure supprime des bits  mais pas les bons  : je vais regarder cela ce soir

Caribensila · Answer

Delphi, c'est mieux que de compiler le C.

cs_Kenavo · Answer

Ou alors :

procedure Virons4BitsEncore(var v : longword);
type
  TTabByte =    array [0..3] of byte;
var
  TByte : TTabbyte absolute v;  // TByte et v partagent les mêmes octets 
begin
  v:  = Tbyte[0] and $7f + (Tbyte[1] and $7f)*$80 + (Tbyte[2] and $7f)*$4000 + (Tbyte[3] and $7f)*$200000;
end;

Ken@vo



 



Code, Code, Codec !

cs_Kenavo · Answer

Vérifie Francky !
(et ne me dit pas que le dernier octet du longword est est réellement un septet comme dans ton exemple)

Ken@vo




 



Code, Code, Codec !

Cirec · Answer

Alors mon lien n'était pas bon ... hein ^^

et il a utilisé quoi Kenavo alors 
me semble bien que ce sont des opérateurs logiques 

 
@+
Cirec

<hr siz="" />

Francky23012301 · Answer

Ah ben celle la elle est bonne : un message vide.

J'ai fais un test : 11111111 11111111 11111111 11111111 devient
11111111 11111111 11111111 00001111. 

Désoé Kénavo mais c'est pas bon ;).

@Cirec : mais j'ai pas dis qu'il ne fallait pas utiliser les opérateurs logiques mais le probleme c'est que c'est truc là j'y arrive jamais

Cirec · Answer

tiens bizzare j'obtiens pas la même chose que toi ???? :




Départ :=  11111111 11111111 11111111 11111111


Arivée :=   1111111  1111111  1111111  1111111





 






@+
Cirec





<hr siz="" />

Cirec · Answer

et en corrigant l'erreur de ton exemple (si c'est réellement une erreur) de Septet en Octet
ça le fait très bien ^^
10000001 10110001 10110001 10110001  Devient

       1  0110001  0110001  0110001

Alors Septet ou Octet ?

 
@+
Cirec

<hr siz="" />

Francky23012301 · Answer

Salut,

"10000001 10110001 10110001 10110001 Devient

1 0110001 0110001 0110001"

Vous avez pas compris En fait il faut supprimer les premiers bits de chaque octet, coller ce qui reste. Et mettre à gauche 4 zéros pour tomber sur 32 bits.

"Since 81 is larger than 80, you can see that the 00 byte is also
part of the VLV. Lets look at 81 00 in binary notation:
10000001 00000000

Separate the continuation bit from the data bits:
1 0000001 0 0000000

Now you can see in binary notation what you can also see in hex notation --
that the first byte expects at least one more byte to follow it in the VLV.
Remove the continuation bits:
0000001 0000000

This is the actual number that is represented by the VLV value <tt>81 00</tt>,
but maybe we should convert to decimal or hex so you understand it better.
First, combine all of the bits into one clump:
00000010000000

I will convert first to hexadecimal, and later to decimal. For hexadecimal
conversion of a binary number, arrange the digits into groups of 4, starting
with the least siginificant (smallest, right) side of the number:
00 0000 1000 0000

There are two zeros left on the left size, so add two more zeros to make a
grouping of four digits:
0000 0000 1000 0000

We can do this in decimal notation to show why this can be done:
the number 0045 and 45 are the same number.
Now, convert the binary groupings into hexadecimal digits:
0000 0000 1000 0000"
0 0 8 0

Donc si on prend ton exemple Cirec :

<strike>1</strike>0000001 <strike>1</strike>0110001 <strike>1</strike>0110001 <strike>1</strike>0110001

On obtient 0000001   0110001   0110001   0110001

Il reste 0000001   0110001   0110001   0110001
On rajoute 4 zéros 0000 0000001   0110001   0110001   0110001

On obtient donc 00000000 00101100 01011000 10110001 et non
10110001 0110001 0110001

Cirec · Answer

ils sont virés automatiquement il me semble puisqu'il n'influent pas sur le résultat
10110001  0110001  0110001 2906289 $2C58B100000000  00101100 01011000 10110001 2906289 $2C58B1

 
@+
Cirec

<hr siz="" />

Francky23012301 · Answer

La procédure de Kenavo me donne 
10110001 01011000 00101100 00000000
Si on part de 10000001 10110001 10110001 10110001 
Ca colle pas du tout

Francky23012301 · Answer

J'ai fais un autre test
010110010001001000000000000000000 Devient
010110010000100100000000000000000

Je suis en Little Endian

cs_Kenavo · Answer

Compiler le C ! 


Ah, Cari en voilà une bonne idée !  

Ken@vo




 



Code, Code, Codec !

sheorogath · Answer

"Je suis en Little Endian"


comme la pluspart des machine ^^

sinon j'espere que ma petite explication t'auras aide


parcontre vu que tu fais de la manipulation bit a bit faudras peut etre que tu prevois de gerer

l'endian de la machine ^^

"n'est pas mort ce qui semble a jamais dormir et en d'etrange temps meme la mort peut mourrir"

Francky23012301 · Answer

Arff Thomas c'est pas encore ca.

Tout doucement j'avance :

Function CutSevenBits(V: longword):longword;
type
  TTabByte = array[0..3] of byte;
var
  TByte : TTabbyte absolute v; // TByte et v partagent les mêmes octets
  LW0,LW1,LW2,LW3:LongWord;
  BT0,BT1,BT2, BT3 : Byte;
begin
  BT0:= Tbyte[0] ;
  BT0:=BT0 SHL 1;
  BT0:=BT0 SHR 1;
  LW0:=BT0 * $01000000 ;

  BT1:= Tbyte[1] ;
  BT1:=BT1 SHL 1;
  BT1:=BT1 SHR 1;
  LW1:=BT1 * $00010000 ;

  BT2:= Tbyte[2] ;
  BT2:=BT2 SHL 1;
  BT2:=BT2 SHR 1;
  LW2:=BT2 * $00000100;

  BT3:= Tbyte[3] ;
  BT3:=BT3 SHL 1;
  BT3:=BT3 SHR 1;
  LW3:=BT3 ;
  Result:=LW3;
end;

En prenant  10000001 10110001 10110001 10110001 
J'obtient pour respectivement pour LW0 à LW3:
00000000 00000000 00000000 00110001 => Ok 
00000000 00000000 00110001 00000000 => Ok
00000000 00110001 00000000 00000000 => Ok
00000001 00000000 00000000 00000000 => Ok

Francky23012301 · Answer

Bon ben voila j'ai la solution 

Function CutSevenBits(V: longword):longword;
type
  TTabByte = array[0..3] of byte;
var
  TByte : TTabbyte absolute v; // TByte et v partagent les mêmes octets
  LW0,LW1,LW2,LW3:LongWord;
  BT0,BT1,BT2, BT3 : Byte;
begin
  BT0:= Tbyte[0] ;
  BT0:=BT0 SHL 1;
  BT0:=BT0 SHR 1;
  LW0:=BT0 * $01000000 ;

  BT1:= Tbyte[1] ;
  BT1:=BT1 SHL 1;
  BT1:=BT1 SHR 1;
  LW1:=BT1 * $00010000 ;

  BT2:= Tbyte[2] ;
  BT2:=BT2 SHL 1;
  BT2:=BT2 SHR 1;
  LW2:=BT2 * $00000100;

  BT3:= Tbyte[3] ;
  BT3:=BT3 SHL 1;
  BT3:=BT3 SHR 1;
  LW3:=BT3 ;
  Result:=LW0 OR LW1 OR LW2 OR LW3;
end;

10000001 10110001 10110001 10110001  Se tranforme en
00000001 10110001 10110001 00110001 . Donc c'est bon

Par contre je trouve pas ca propre

Francky23012301 · Answer

Et merde c'est pas bon: j'ai parlé trop vite

Francky23012301 · Answer

Il y aurais pas moyen de décaller les longword d'un bit comme ceci

00000000 00000000 00110001 00000000
00000000 00000000 00011000 10000000 

Car si je fais un SHR 1 ca fait tout sauf ca

Merci

Francky23012301 · Answer

Salut,

Je tiens à tous vous remercier pour votre aider. Merci aux personnes qui m'ont aidé en privé (Twinuts, Sheorogath, Philippe).

Voila la procédure pour écrite la variable Length Quantitie :

Procedure WriteVLQ(Value:Word;MS:TMemoryStream);
Var
  Buffer, Count, Index:Word;
Begin
  Buffer:=Value AND $7F;
  Value:=Value SHR 7;
  Count:=0;
  While Value>0 Do
    Begin
      Buffer:=Buffer SHL 8;
      Buffer:=Buffer OR $80;
      Buffer:=Buffer+ (Value AND $7F);
      Value:=Value SHR 7;
      Inc(Count);
    End;
  For Index:=Count DownTo 0 Do
    Begin
      MS.Write(Buffer,1);
      Buffer:=Buffer SHR 8;
    End;
End;

Désolé d'avoir été un peu lourd mais sans ce fichu delta time, je ne pouvais plus avancer

Stratégie pour décaler des bits

26 réponses

Votre réponse

Discussions similaires