Existe-t-il un moyen rapide de lire des octets alternatifs dans dd

Aucune idée si cela sera plus rapide ou même possible avec BusyBox, mais c'est une pensée ...

#!/bin/bash

exec 3< datafile
for ((i=0;i<76800;i++)) ; do
    # Skip 2 bytes then read 2 bytes
    dd bs=2 count=1 skip=1 <&3 2> /dev/null
done > result

Ou cela devrait être plus efficace:

#!/bin/bash

# Empty result file
> result

exec 3< datafile
while true; do
    # Read 2 bytes into file "short"
    dd bs=2 count=1 <&3 > short 2> /dev/null
    [ ! -s short ] && break
    # Accumulate result file
    cat short >> result
    # Read two bytes and discard
    dd bs=2 count=1 <&3 > short 2> /dev/null
    [ ! -s short ] && break
done

Ou, peut-être que vous pourriez utiliser netcat ou ssh pour envoyer le fichier à un ordinateur sensible (plus puissant) avec les outils appropriés pour le traiter et le renvoyer. Par exemple, si l'ordinateur distant avait ImageMagick , il pourrait très simplement réduire la taille de l'image.

Sauter tous les autres caractères est simple pour des outils comme sed ou awk tant que vous n'avez pas besoin de gérer les nouvelles lignes et les octets nuls. Mais le support de Busybox pour les octets nuls dans sed et awk est suffisamment médiocre pour que je ne pense pas que vous puissiez les gérer du tout. Il est possible de gérer les nouvelles lignes, mais c'est une douleur énorme car il y a 16 combinaisons différentes à gérer selon que chaque position dans un bloc de 4 octets est une nouvelle ligne ou non.

Puisque les données binaires arbitraires sont pénibles, nous allons traduire en hexadécimal ou octal! Je vais m'inspirer de bin2hex et hex2bin scripts par Stéphane Chazelas . Comme nous ne nous soucions pas du format intermédiaire, j'utiliserai octal, ce qui est beaucoup plus simple à gérer car la dernière étape utilise printf qui ne prend en charge que l'octal. hex2bin de Stéphane utilise awk pour la conversion hexadécimale en octale; un oct2bin peut utiliser sed. Donc, à la fin, vous avez besoin de sh , od , sed et printf . Je ne pense pas que vous puissiez éviter printf : il est essentiel de générer des octets nuls. Bien que od soit essentiel, la plupart de ses options ne le sont pas, il devrait donc être possible de modifier ce code pour prendre en charge une od très simple avec un peu plus de post-traitement.

i=$(($(wc -c <"$1") / 4))
exec <"$1"
dd ibs=2 count=1 conv=notrunc 2>/dev/null
while [ $i -gt 1 ]; do
  dd ibs=2 count=1 skip=1 conv=notrunc 2>/dev/null
  i=$((i - 1))
done

La raison pour laquelle c'est si rapide par rapport à votre approche basée sur dd est que BusyBox exécute printf dans le processus parent, alors que dd nécessite le sien processus. La fourche est lente. Si je me souviens bien, il existe une option de compilation qui fait que BusyBox se fourche pour tous les utilitaires. Dans ce cas, mon approche sera probablement aussi lente que la vôtre. Voici une approche intermédiaire utilisant dd qui ne peut pas éviter les fourchettes, mais au moins évite d'ouvrir et de fermer le fichier à chaque fois. Il devrait être un peu plus rapide que le vôtre.

od -An -v -t o1 -w4 |
sed 's/^ \([0-7]*\) \([0-7]*\).*/printf \\\\\1\\\\\2/' |
sh

Une autre option pourrait être d'utiliser Lua qui a la réputation d'être petit, rapide et bien adapté aux systèmes embarqués - voir Site Web de Lua . Il existe également des binaires pré-construits et téléchargeables. Il est également suggéré sur le site Web Busybox ici .

Je n'ai jamais écrit de Lua auparavant, donc il peut y avoir quelques inefficacités mais cela semble fonctionner plutôt bien et traite une image 640x480 RGB565 en quelques millisecondes sur mon bureau.

magick -depth 16 -size 320x240 gray:smaller.bin smaller.jpg

J'ai créé une image de test en niveaux de gris avec ImageMagick comme suit:

lua scale.lua image.bin smaller.bin

Ensuite, j'ai exécuté le script Lua ci-dessus avec:

magick -depth 16 -size 640x480 gradient: gray:image.bin

Ensuite, j'ai créé un JPEG que j'ai pu voir pour le tester avec:

-- scale.lua
-- Usage: lua scale.lua input.bin output.bin
-- Scale an image by skipping alternate lines and alternate columns

-- Set up width, height and bytes per pixel
w   = 640
h   = 480
bpp = 2    

-- Open first argument for input, second for output
inp = assert(io.open(arg[1], "rb"))
out = assert(io.open(arg[2], "wb"))

-- Read image, one line at a time
for i = 0, h-1, 1 do
   -- Read a whole line
   line = inp:read(w*bpp)

   -- Only use every second line
   if (i % 2) == 0 then
      io.write("DEBUG: Processing row: ",i,"\n")
      -- Build up new, reduced line by picking substrings
      reduced=""
      for p = 1, w*bpp, bpp*2 do
         reduced = reduced .. string.sub(line,p,p+bpp-1)
      end
      io.write("DEBUG: New line length in bytes: ",#reduced,"\n")
      out:write(reduced)
   end
end

assert(out:close())