convertir un fichier texte de bits en fichier binaire

J'ai un fichier instructions.txtavec le contenu:

00000000000000000000000000010011
00000010110100010010000010000011
00000000011100110000001010110011
00000000011100110000010000110011
00000000011100110110010010110011
00000000000000000000000000010011

Comment puis-je créer un fichier binaire instructions.bindes mêmes données que instructions.txt. En d'autres termes, le .binfichier doit être le même 192 bits qui sont dans le .txtfichier, avec 32 bits par ligne. J'utilise bash sur Ubuntu Linux. J'essayais d'utiliser xxd -b instructions.txtmais la sortie est bien plus longue que 192 bits.

oneliner pour convertir des chaînes de 32 bits de uns et de zéros en binaire correspondant:

$ perl -ne 'print pack("B32", $_)' < instructions.txt > instructions.bin

ce qu'il fait:

• perl -neva parcourir chaque ligne du fichier d'entrée fourni sur STDIN ( instructions.txt)
• pack("B32", $_)prendra une liste de chaînes de 32 bits ( $_que nous venons de lire à partir de STDIN) et la convertira en valeur binaire (vous pouvez également utiliser "b32"si vous souhaitez un ordre de bits croissant dans chaque octet au lieu d'un ordre de bits décroissant; voir perldoc -f packpour plus de détails)
• print sortirait ensuite cette valeur convertie en STDOUT, que nous redirigeons ensuite vers notre fichier binaire instructions.bin

Vérifier:

$ hexdump -Cv instructions.bin
00000000  00 00 00 13 02 d1 20 83  00 73 02 b3 00 73 04 33  |...... ..s...s.3|
00000010  00 73 64 b3 00 00 00 13                           |.sd.....|
00000018

$ xxd -b -c4 instructions.bin
00000000: 00000000 00000000 00000000 00010011  ....
00000004: 00000010 11010001 00100000 10000011  .. .
00000008: 00000000 01110011 00000010 10110011  .s..
0000000c: 00000000 01110011 00000100 00110011  .s.3
00000010: 00000000 01110011 01100100 10110011  .sd.
00000014: 00000000 00000000 00000000 00010011  ....

L'ajout de l' -roption (mode inverse) à xxd -bne fonctionne pas comme prévu, car xxd ne prend tout simplement pas en charge la combinaison de ces deux indicateurs (il ignore -bsi les deux sont donnés). Au lieu de cela, vous devez d'abord convertir les bits en hexadécimal. Par exemple, comme ceci:

( echo 'obase=16;ibase=2'; sed -Ee 's/[01]{4}/;\0/g' instructions.txt ) | bc | xxd -r -p > instructions.bin

Explication complète:

• La partie entre parenthèses crée un bcscript. Il définit d'abord la base d'entrée sur binaire (2) et la base de sortie sur hexadécimal (16). Après cela, la sedcommande imprime le contenu de instructions.txtavec un point-virgule entre chaque groupe de 4 bits, ce qui correspond à 1 chiffre hexadécimal. Le résultat est canalisé dansbc .
• Le point-virgule est un séparateur de commandes dans bc , donc tout ce que fait le script est de faire ressortir chaque entier d'entrée (après conversion de base).
• La sortie de bcest une séquence de chiffres hexadécimaux, qui peut être convertie en un fichier avec l'habituel xxd -r -p.

Production:

$ hexdump -Cv instructions.bin
00000000  00 00 00 13 02 d1 20 83  00 73 02 b3 00 73 04 33  |...... ..s...s.3|
00000010  00 73 64 b3 00 00 00 13                           |.sd.....|
00000018
$ xxd -b -c4 instructions.bin
00000000: 00000000 00000000 00000000 00010011  ....
00000004: 00000010 11010001 00100000 10000011  .. .
00000008: 00000000 01110011 00000010 10110011  .s..
0000000c: 00000000 01110011 00000100 00110011  .s.3
00000010: 00000000 01110011 01100100 10110011  .sd.
00000014: 00000000 00000000 00000000 00010011  ....

Ma réponse d'origine était incorrecte - xxdne peut accepter ni l'un -pni l' autre -ravec -b...

Étant donné que les autres réponses sont réalisables et dans l’intérêt d’ une « autre manière ", que diriez-vous des éléments suivants:

Contribution

$ cat instructions.txt
00000000000000000000000000010011
00000010110100010010000010000011
00000000011100110000001010110011
00000000011100110000010000110011
00000000011100110110010010110011
00000000000000000000000000010011

Production

$ hexdump -Cv < instructions.bin
00000000  00 00 00 13 02 d1 20 83  00 73 02 b3 00 73 04 33  |...... ..s...s.3|
00000010  00 73 64 b3 00 00 00 13                           |.sd.....|
00000018

Pipeline Bash:

cat instructions.txt \
    | tr -d $'\n' \
    | while read -N 4 nibble; do 
        printf '%x' "$((2#${nibble}))"; \
      done \
    | xxd -r -p \
    > instructions.bin

• cat - inutile, mais utilisé pour plus de clarté
• tr -d $'\n' - supprimer toutes les nouvelles lignes de l'entrée
• read -N 4 nibble- lire exactement 4 × caractères dans la nibblevariable
• printf '%x' "$((2#${nibble}))" convertir le quartet de binaire en 1 × caractère hexadécimal
  • $((2#...)) - convertir la valeur donnée de la base 2 (binaire) en base 10 (décimal)
  • printf '%x' - formate la valeur donnée de la base 10 (décimale) à la base 16 (hexadécimale)
• xxd -r -p- reverse ( -r) un vidage simple ( -p) - de l'hexadécimal au binaire brut

Python:

python << EOF > instructions.bin
d = '$(cat instructions.txt | tr -d $'\n')'
print(''.join([chr(int(d[i:i+8],2)) for i in range(0, len(d), 8)]))
EOF

• Un hérédoc non cité (<< EOF ) est utilisé pour obtenir du contenu dans le code Python
  • Ce n'est pas efficace si l'entrée devient grande
• catet tr- utilisé pour obtenir une entrée propre (une ligne)
• range(0, len(d), 8)- obtenir une liste de nombres de 0 à la fin de la chaîne d, en progressant de 8 × caractères à la fois.
• chr(int(d[i:i+8],2))- convertir la tranche actuelle ( d[i:i+8]) de binaire en decimal ( int(..., 2)), puis en caractère brut ( chr(...))
• [ x for y in z]- compréhension de la liste
• ''.join(...) - convertir la liste des caractères en une seule chaîne
• print(...) - imprime le

Vous pouvez aussi essayer de poster ceci sur le site CodeGolf SE, mais voici ma version alternative de Python (juste pour le défi de coup de pied):

python -c "import sys,struct;[sys.stdout.buffer.write(struct.pack('!i',int(x,2)))for x in sys.stdin]" \
< input.txt > output.bin

En supposant input.txt contient vos données et qu'elles sont formatées à 32 caractères par ligne.

Cela utilise le structpackage Python 3 et l'écriture / lecture dans stdin / out. (En Python 2, il aurait été plus court).