2.00: CopyBinaryStringToRecord, CopyRecordToBinaryString

Nouvelle version:
KGF.dll V02.00 du 3 Mars 2013

J'ai ajouté deux fonctions qui permettent de:
- créer une chaîne de caractères binaire contenant l'image d'un enregistrement binaire
- copier le contenu d'une chaîne de caractères binaires dans les champs d'un enregistrement

Ces fonctions sont la réplique des fonctions d'ériture et lecture dans un fichier binaire, à la différence qu'elles travaillent uniquement avec une chaîne de caractères en mémoire sans lire ou écrire cette chaîne ans un fichier.

KGF.dll: res% = dll_call3("CopyBinaryStringToRecord",adr(nom$),adr(record$),delta%)
KGF_SUB.bas: CopyBinaryStringToRecord(nom$,record$)

KGF.dll:res% = dll_call3("CopyRecordToBinaryString",adr(nom$),adr(record$),delta%)
KGFSUB.bas: CopyRecordToBinaryString(nom$,record$)

La doc est à jour !

Modules modifiés:
KGF.dll
KGF_SUB.bas
KGF.chm, KGF.doc, KGF.pdf

Et voici une petite démo:

Code:: ' test_binary_string_and_record.bas

dim n%,v,s$, crlf$ : ' les champs du record
dim buf$, i%

n% = 17
v = 17.17
s$ = "abcde"
crlf$ = chr$(13)+chr$(10)

memo 1 : top 1,10 : left 1,10 : height 1,350
memo 2 : top 2,10 : left 2,210 : height 2,350

KGF_initialize("KGF.dll")

define_record(4)

add_integer_field(adr(n%))
add_float_field(adr(v))
add_string_field(adr(s$),5)
' comme ça, on peut terminer chaque enregistrement par un CR LF !
add_string_field(adr(crlf$),2)

build_record()

buf$ = string$(19,".")
CopyRecordToBinaryString(buf$,record$)
item_add 1,"Contenu initial:"
item_add 1,"n%="+str$(n%)
item_add 1,"v="+str$(v)
item_add 1,"s$="+s$
item_add 1," "
for i%=1 to len(buf$)
item_add 1,str$(i%)+": "+str$(asc(mid$(buf$,i%,1)))+" ("+mid$(buf$,i%,1)+")"
next i%

v = 0
buf$ = chr$(18)+mid$(buf$,2,15)+"X"+right$(buf$,2)

CopyBinaryStringToRecord(buf$,record$)
item_add 2,"Contenu après modif:"
item_add 2,"n%="+str$(n%)
item_add 2,"v="+str$(v)
item_add 2,"s$="+s$
item_add 2," "
item_add 2,"Contenu après modif:"
for i%=1 to len(buf$)
item_add 2,str$(i%)+": "+str$(asc(mid$(buf$,i%,1)))+" ("+mid$(buf$,i%,1)+")"
next i%

end

#INCLUDE "KGF_SUB.bas"

Pourquoi j'ai fait ces fonctions bizarres ?

Imaginez que vous devez lire en analyser un fichier binaire comme un fichier BMP ou JGP, par exemple. Vous devez analyser une section de 5 mots de 32 bits, dont le début est à partir de l'offset 753. Je prends volontairement des chiffres fantaisistes - c'est pour bien montrer le principe.

Lire 5 mots de 32 bits, cela correspond à lire 5*4 = 20 octets, à partir le l'offset 753. L'offset 753 correspond à la position 754 dans le fichier binaire. On ne peut malheureusement pas faire avec la fonction ReadBinaryFileRecord, car la position 754 n'est pas un multiple de la longueur d'enregistrement (qui est de 20). On utilise donc la fonctionReadBlockFromBinaryFileToString de la façon suivante:

Code:: dim buf$, nom$
nom$ = "nom_du_fichier_à_analyser.bmp"
buf$ = string$(20,".")
res% = dll_call4("ReadBlockFromBinaryFileToString",adr(nom$),20,754,adr(buf$)) : ' version KGF.dll
ou
ReadBlockFromBinaryFileToString"(nom$),20,754,buf$) : ' version KGF_SUB.bas

On obtient une chaîne de caractères de longueur 20, contenant la suite des 5 mots de 32 bits. Mais ce n'est pas exploitable en état. Il faut maintenant décoder cette chaîne dans des variables de type entier afin de pouvoir les traiter. C'est la fonction CopyBinaryStringToRecord qui le fait:

Code:: dim mot1%, mot2%, mot2%, mot4%, mot5%
define_record(5) : ' créer unb enregistrement de 5 champs
add_integer_field(adr(mot1%))
add_integer_field(adr(mot2%))
add_integer_field(adr(mot3%))
add_integer_field(adr(mot4%))
add_integer_field(adr(mot5%))
build_record()
res% = dll_call3("CopyBinaryStringToRecord",adr(buf$),adr(record$),adr(number_click)-record%(0,2)) : ' version KGF.dll
ou
CopyBinaryStringToRecord(buf$,record$) : ' version KGF_SUB.bas

et les 5 variables de type entier sont chargés correctement.

Pour l'écriture dans un fichier, on effectue l'opération inverse.

Et voici une application concrète: l'analyse de l'entête du fichier et de l'entête de l'image d'un fichier BMP:

Code:: ' analyze_BMP.bas

' La structure d'un fichier bitmap est la suivante :
'
' En-tête du fichier (en anglais file header) (14 octets)
' En-tête du bitmap (en anglais bitmap information header,
' appelé aussi information Header) (40 octets fi Wondows)
' Palette (optionnellement)
' Corps de l'image
'
' Entête du fichier
'
' L'entête du fichier fournit des informations sur le type de fichier
' (Bitmap), sa taille et indique où commencent les informations concernant
' l'image à proprement parler.
'
' L'entête est composé de quatre champs :
'
' La signature (sur 2 octets), indiquant qu'il s'agit d'un fichier BMP à l'aide des deux caractères.
' BM, 424D en hexadécimal, indique qu'il s'agit d'un Bitmap Windows.
' BA indique qu'il s'agit d'un Bitmap OS/2.
' CI indique qu'il s'agit d'une icone couleur OS/2.
' CP indique qu'il s'agit d'un pointeur de couleur OS/2.
' IC indique qu'il s'agit d'une icone OS/2.
' PT indique qu'il s'agit d'un pointeur OS/2.
' La taille totale du fichier en octets (codée sur 4 octets)
' Un champ réservé (sur 4 octets)
' L'offset de l'image (sur 4 octets), en français décalage,
' c'est-à-dire l'adresse relative du début des informations
' concernant l'image par rapport au début du fichier
'
' Entête de l'image
'
' L'entête de l'image fournit des informations sur l'image,
' notamment ses dimensions et ses couleurs.
'
' L'entête de l'image est composé de quatre champs :
'
' E1: La taille de l'entête de l'image en octets (codée sur 4 octets).
' Les valeurs hexadécimales suivantes sont possibles suivant le type
' de format BMP :
' 28 pour Windows 3.1x, 95, NT, ...
' 0C pour OS/2 1.x
' F0 pour OS/2 2.x
' E2: La largeur de l'image (sur 4 octets), c'est-à-dire le nombre
' de pixels horizontalement (en anglais width)
' E3: La hauteur de l'image (sur 4 octets), c'est-à-dire le nombre
' de pixels verticalement (en anglais height)
' E4a: Le nombre de plans (sur 2 octets). Cette valeur vaut toujours 1
' E4b: La profondeur de codage de la couleur(sur 2 octets), c'est-à-dire
' le nombre de bits utilisés pour coder la couleur.
' Cette valeur peut-être égale à 1, 4, 8, 16, 24 ou 32
' E5: La méthode de compression (sur 4 octets). Cette valeur
' vaut 0 lorsque l'image n'est pas compressée,
' ou bien 1, 2 ou 3 suivant le type de compression utilisé :
' 1 pour un codage RLE de 8 bits par pixel
' 2 pour un codage RLE de 4 bits par pixel
' 3 pour un codage bitfields, signifiant que la couleur est
' codé par un triple masque représenté par la palette
' E6: La taille totale de l'image en octets (sur 4 octets).
' E7: La résolution horizontale (sur 4 octets), c'est-à-dire le nombre
' de pixels par mètre horizontalement
' E8: La résolution verticale (sur 4 octets), c'est-à-dire le nombre
' de pixels par mètre verticalement
' E9: Le nombre de couleurs de la palette (sur 4 octets)
' E10: Le nombre de couleurs importantes de la palette (sur 4 octets).
' Ce champ peut être égal à 0 lorsque chaque couleur a son importance.

label ouvrir

dim taille_totale%, bidon%, offset_image%
dim E1%, E2%, E3%, E4%, E5%, E6%, E7%, E8%, E9%, E10%
dim nom$, buf$

KGF_initialize("KGF.dll")

open_dialog 1 : filter 1,"Fichiers BMP|*.bmp"
button 100 : top 100,10 : left 100,10 : caption 100,"Ouvrir" : on_click 100,ouvrir
memo 101 : top 101,40 : left 101,10 : width 101,400 : height 101,400
font_name 101,"Courier"

end

ouvrir:
nom$ = file_name$(1)
if nom$="_" then return
clear 101

item_add 101,nom$
ReadBlockFromBinaryFileToString(nom$,2,1)
buf$ = ReadBlockFromBinaryFileToString$
if buf$="BM" then item_add 101," signature: BM = Bitmap Windows"
if buf$="BA" then item_add 101," signature: BA = Bitmap OS/2.
if buf$="CI" then item_add 101," signature: CI = icone couleur OS/2.
if buf$="CP" then item_add 101," signature: CP = pointeur de couleur OS/2.
if buf$="IC" then item_add 101," signature: IC = icone OS/2.
if buf$="PT" then item_add 101," signature: PT = pointeur OS/2.
if buf$<>"BM"
item_add 101,"Terminé."
return
end_if

item_add 101,""
item_add 101,"Entête du fichier:"
ReadBlockFromBinaryFileToString(nom$,12,3)
buf$ = ReadBlockFromBinaryFileToString$
define_record(3)
add_integer_field(adr(taille_totale%))
add_integer_field(adr(bidon%))
add_integer_field(adr(offset_image%))
build_record()
CopyBinaryStringToRecord(buf$,record$)
item_add 101," Taille totale: "+str$(taille_totale%)
item_add 101," Offset image: "+str$(offset_image%)

item_add 101,""
item_add 101,"Entête de l'image:"
ReadBlockFromBinaryFileToString(nom$,40,15)
buf$ = ReadBlockFromBinaryFileToString$
define_record(10)
add_integer_field(adr(E1%))
add_integer_field(adr(E2%))
add_integer_field(adr(E3%))
add_integer_field(adr(E4%))
add_integer_field(adr(E5%))
add_integer_field(adr(E6%))
add_integer_field(adr(E7%))
add_integer_field(adr(E8%))
add_integer_field(adr(E9%))
add_integer_field(adr(E10%))
build_record()
CopyBinaryStringToRecord(buf$,record$)
item_add 101," Taille entête image: "+str$(E1%)
item_add 101," Largeur image: "+str$(E2%)
item_add 101," Hauteur image: "+str$(E3%)
item_add 101," Nombre de plans: "+str$(bin_and(E4%,65535))
item_add 101," Profondeur de codage de couleur: "+str$(int(E4%/65536))
item_add 101," Méthode de compression: "+str$(E5%)
item_add 101," Taille totale image: "+str$(E6%)+" octets"
item_add 101," Résolution horizontale: "+str$(E7%)+" pixels/mètre"
item_add 101," Résolution verticale: "+str$(E8%)+" pixels/mètre"
item_add 101," Nombre de couleurs de la palette: "+str$(E9%)
item_add 101," Nombre de couleurs importantes: "+str$(E10%)
item_add 101," Terminé."

return

#INCLUDE "KGF_SUB.bas"

Cela montre avec quelle facilité on peut ainsi parcourir un fichier binaire et lui appliquer des dessins d'enregistrements, section par section, selon les besoins.

P.S.
Je pense que la réalisation de mes fonctions de gestion de fichiers binaires mérite bien une bouteille de champagne ? Allez, on trinque ensemble ! lol!

A la tienne Klaus. Désolé, je passe peu de temps pour la programmation en ce moment, mais ta DLL et ses fonctions ouvrent toujours de grandes possibilités Wink

Champagne pour tous les panoramiciens