Bonsoir à tous.
 
 Voila, je ne connais strictement rien en dev aussi merci de me fusiller sur place ou bien de m'aider un poil ^^
 
 Voici ce que je souhaiterai obtenir, et ce, avec un langage ou un outil tout prêt (ouais je rêve) accessible pour un gogol comme moi.
 
 Je possède un fichier binaire qui doit au final ressembler à cela :
 
Source:
bb 1b 53 c4 bc 11 45 c4 11 11 c3 bc 11 b1 1c 11  
 
Destination:
1b bb c4 53 11 bc c4 45 11 11 bc c3 b1 11 11 1c  
 
 Grosso modo, j'ai besoin de swapper 2 octets entre eux tous les 2 octets ... pas clair ? .. normal je pige pas grand chose ^^
 
 Aussi si quelqu'un pouvait avoir la bonté de me répondre sans me proposer d'aller jouer dans le mixer ce serait fun.  

C'est pas trop autorisé par la charte ta requête, mais bon je suis de bonne humeur donc voilà un petit code en C qui devrait marcher correctement, je l'ai pas plus testé que ça mais ça a l'air de pas planter donc on va pas se plaindre
 

#include <stdio.h>
#include <fcntl.h>
 
# define BUF_SIZE 512
 
void        swap_bytes(char *filename)
{
    char    buffer[BUF_SIZE];
    char    curByte;
    int     fd;
    int     bytesRead;
    size_t  posBuffer;
 
    fd = open(filename, O_RDWR | O_BINARY);
    if (fd == -1)
    {
        printf("Erreur: Le fichier %s ne peut etre ouvert\n", filename);
        return;
    }
    while ((bytesRead = read(fd, buffer, BUF_SIZE)) > 0)
    {
        posBuffer = 0;
        while (posBuffer + 1 < bytesRead)
        {
            curByte = buffer[posBuffer];
            buffer[posBuffer] = buffer[posBuffer + 1];
            buffer[posBuffer + 1] = curByte;
            posBuffer += 2;
        }
        lseek(fd, -bytesRead, SEEK_CUR);
        write(fd, buffer, bytesRead);
    }
    close(fd);
}
 
 
int         main(int argc, char **argv)
{
    if (argc == 1)
        printf("Usage: %s fichier\n", argv[0]);
    else
        swap_bytes(argv[1]);
    return (0);
}

 
Si tu traites de gros fichiers, hésites pas a changer le # define BUF_SIZE 512 par un truc beaucoup plus gros genre # define BUF_SIZE 1048576, ça bourrinera moins le disque dur et tu gagneras en rapidité

Merci beaucoup pour ton aide,
 
 je teste cela de suite

Funky ^^
 
 j'ai voulu compiler sous linux, et j'ai lu l'histoire d'un mec qui disait que sa belle soeur par alliance de son oncle lui avait dit que O_BINARY n'était pas nécessaire sous système linux because pas de distingo entre text et binaire .. en plus ça compilait pas .. bref  
 
 testé sans O_BINARY ... fichier entrée = 2mo fichier sortie 4go ^^
 
 
 Je télécharge de ce pas la trial de vs2010 ^^

 
 Perl fonctionne en binaire ou octal ? je doute (mais je peux me tromper of course)

Y'a sûrement moyen de faire fonctionner perl pour manipuler directement les octets de ton fichier
 
O_BINARY je l'ai mis par sécurité histoire qu'il fasse pas du khakha mais en général ouais c'est pas utile

 
Essaye ça alors :
 

Merci mais rien ne s'affiche et aucune modification sur le fichier d'entrée ( je n'ai pas spécifié de sortie mais vu la commande il doit s'écraser sur l'entrée non ? )

Tu veux juste swapper les octets deux par deux? si tu es sous linux, dd est prévu pour cela:
dd if=inputfile of=outputfile conv=swab
A+,

Alors ça ça le fait ^^
 
 cela fonctionne merci bien ^^

 
Non il "affiche" sur stdout, et comme c'est du binaire il vaut mieux rediriger ça dans un fichier. Ca fonctionne chez moi :
 
 

Euh, tu es sur que ton code perl fonctionne encore si tu as des \n dans ton binaire?
En plus, à lire ton expression régulière, ça peut pas marcher du tout
/([^ \n]+) ([^ \n]+)/ ça va matcher sur texte composé de deux caractères séparés par du blanc, mais certainement pas le binaire voulu (ou il y a pas de blancs, etc).
Un petit test pour s'en convaincre:

#!/usr/bin/perl
use warnings;
use strict;
 
my $v = join '', (0x01,0x02,0x03,0x04);
$v =~ s/([^ \n]+) ([^ \n]+)/$2 $1/g;
map {printf "%#.2x ", $_} split //, $v;

En sortie, on a la même chose qu'en entrée, rien n'a été swappé des 4 octets successifs de valeur 1 2 3 et 4.
A la limite, tu aurais écrit s/(.)(.)/$2$1/g, ça aurait pu fonctionner (a la coupure de fin de ligne pour une ligne de longueur impaire près).
Il y a des techniques en perl pour faire ce type de conversion, mais elles reposent plutôt sur pack/unpack, et une lecture qui ne se fait pas ligne à ligne (contrairement à ce que fait ici le my $v = <STDIN> )
A+,

 
Oui j'me suis vautré dans mon copier coller, c'est plutôt "s/(.)(.)/$2$1/g" la regex.