Updating Brother printer firmware (part 2)

Based on my previous post, I’ve received few enquiries regarding updating different network printers.
In the SNMP walk, you should find a section with lines; MODEL, SERIAL, SPEC (optional) and FIRMID (multiple if there are more than one firmware types). If the printer is in maintenance mode then the required lines will not be present in the SNMP output, and sometime is not there at all!

Here is a list of printers which I’ve been able to retrieve.

NAME	SPEC	FIRMID
DCP-1510 series	0003	MAIN,SUB3
DCP-1608	0020	MAIN
DCP-1610W series	0017	MAIN
DCP-7030	0101	MAIN
DCP-7040	0001	MAIN
DCP-7055	0001	MAIN
DCP-7055W	0001	MAIN
DCP-7060D	0001	MAIN,SUB1
DCP-7065DN	3004	MAIN,SUB1
DCP-7070DW	0001	MAIN,PCLPS,SUB1
DCP-7080	0020	MAIN
DCP-7080D	0120	MAIN
DCP-8070D	0024	MAIN,PCLPS
DCP-8080DN	0001	MAIN,PCLPS
DCP-8085DN	0101	MAIN,PCLPS
HL-1110 series		MAIN
HL-1200 series		MAIN
HL-1208		MAIN
HL-2220 series		MAIN
HL-2230 series		MAIN
HL-2240 series		MAIN
HL-2240D series		MAIN
HL-2250DN series		MAIN
HL-2270DW series		MAIN
HL-3140CW series		MAIN,PCLPS,SUB1
HL-3150CDW series		MAIN,SUB1
HL-3170CDW series		MAIN,PCLPS,SUB1
HL-5250DN series		MAIN,BRNET,BRNET2
HL-5270DN series		MAIN,BRNET,BRNET2
HL-5280DW series		MAIN,BRNET
HL-5370DW series		MAIN,BRNET
HL-5440D series	0001	MAIN
HL-5450DN series	0004	MAIN,SUB1
HL-5470DW series	0101	MAIN,SUB1
HL-S7000DN series		MAIN,ENGINE,SUB1
MFC-1810 series	0003	MAIN,SUB3
MFC-1900 series	0019	MAIN
MFC-1906	0020	MAIN
MFC-1910W series	0003	MAIN
MFC-1919NW	0020	MAIN
MFC-7340	0002	MAIN
MFC-7360N	2048	MAIN,SUB1
MFC-7460DN	0001	MAIN,SUB1,IFAX
MFC-7470D		MAIN,SUB1,PCLPS
MFC-7840W	0002	MAIN,IFAX
MFC-7860DN	0001	MAIN,PCLPS,SUB1,IFAX
MFC-7860DW	2248	MAIN,PCLPS,SUB1,IFAX
MFC-8370DN	2148	MAIN,PCLPS,IFAX
MFC-8520DN	0248	MAIN,SUB1,IFAX
MFC-8880DN	2348	MAIN,PCLPS
MFC-8890DW	0401	MAIN,PCLPS
MFC-9320CW	0201	MAIN,PCLPS,IFAX
MFC-9340CDW	0502	MAIN,SUB1,SUB2,IFAX
MFC-9970CDW		MAIN,PCLPS,SUB2
MFC-L8600CDW		MAIN,SUB1,SUB2,SUB4,IFAX

The following script performs the required HTTP requests.

#!/bin/bash
  
name=
spec=
firms=
  
while getopts ":n:s:f:" opt; do
  case $opt in
    n)
      name=$OPTARG
      ;;
    s)
      spec=$OPTARG
      ;;
    f)
      firms=$OPTARG
      ;;
  esac
done
  
IFS=',' read -a firmids <<< "$firms"
for firmid in "${firmids[@]}"
do
    for version in "0" "B0000000000"
    do
        echo -n '<REQUESTINFO><FIRMUPDATETOOLINFO><FIRMCATEGORY>' >> request.xml
        echo -n $firmid >> request.xml
        echo -n '</FIRMCATEGORY><OS>LINUX</OS><INSPECTMODE>1</INSPECTMODE></FIRMUPDATETOOLINFO><FIRMUPDATEINFO><MODELINFO><NAME>' >> request.xml
        echo -n $name >> request.xml
        echo -n '</NAME><SPEC>' >> request.xml
        echo -n $spec >> request.xml
        echo -n '</SPEC><DRIVER></DRIVER><FIRMINFO><FIRM><ID>' >> request.xml
        echo -n $firmid >> request.xml
        echo -n '</ID><VERSION>' >> request.xml
        echo -n $version >> request.xml
        echo -n '</VERSION></FIRM></FIRMINFO></MODELINFO><DRIVERCNT>1</DRIVERCNT><LOGNO>2</LOGNO><ERRBIT></ERRBIT><NEEDRESPONSE>1</NEEDRESPONSE></FIRMUPDATEINFO></REQUESTINFO>' >> request.xml
  
        curl -X POST -d @request.xml https://firmverup.brother.co.jp/kne_bh7_update_nt_ssl/ifax2.asmx/fileUpdate -H "Content-Type:text/xml" --sslv3 -o response.xml -s
        valid=`grep "<RESPONSEINFO><FIRMUPDATEINFO><VERSIONCHECK>0</VERSIONCHECK>" response.xml`
        if [ -n "$valid" ]
        then
            echo "--- request (name=$name, spec=$spec, firm=$firmid, version=$version) ---"
            cat request.xml | xmllint --format -
            echo "--- response ---"
            cat response.xml | xmllint --format -
        else
            partial=`grep "<RESPONSEINFO><FIRMUPDATEINFO><VERSIONCHECK>2</VERSIONCHECK><FIRMID>" response.xml`
            if [ -n "$partial" ]
            then
                echo "-- the request is partially incomplete (name=$name, spec=$spec, firm=$firmid, version=$version) --"
            else
                echo "-- the request is invalid (name=$name, spec=$spec, firm=$firmid, version=$version) --"
            fi
        fi
        rm request.xml response.xml
    done
done

Here is an example to fetch both firmwares for the HL-5450DN.

./fetch.sh -n "HL-5450DN series" -s 0004 -f MAIN,SUB1

*** If you have successfully retrieved the correct info from the SNMP walk; then please let me know and I’ll update this post with your printer.

Updating Brother printer firmware with Linux

I’ve got a network laser printer (Brother DCP-7065DN) in my home office which is only accessible from a Linux desktop …and guest what?; you can only update the firmware from a M$ Windows PC or from a Mac! 😦

After a lot of Googling and talking to the Brother’s support (which is obviously clueless), I’ve found the following blogs:

Resurrecting a Brother HL-2250DN after a failed firmware update
Brother Network Firmware Update with Linux

To get the content of the WebService request, I’ve downloaded a MIB SNMP browser from iReasoning and done a SNMP walk to extract the required values. The printer came with an original firmware version D (22/10/2010) and the latest is version J (06/09/2013).

<REQUESTINFO>
    <FIRMUPDATETOOLINFO>
        <FIRMCATEGORY>MAIN</FIRMCATEGORY>
        <OS>LINUX</OS>
        <INSPECTMODE>1</INSPECTMODE>
    </FIRMUPDATETOOLINFO>

    <FIRMUPDATEINFO>
        <MODELINFO>
            <SELIALNO>E69758E1N499775</SELIALNO>
            <NAME>DCP-7065DN</NAME>
            <SPEC>3004</SPEC>
            <DRIVER></DRIVER>
            <FIRMINFO>
                <FIRM>
                    <ID>MAIN</ID>
                    <VERSION>D1104201307:1B1C</VERSION>
                </FIRM>
            </FIRMINFO>
        </MODELINFO>
        <DRIVERCNT>1</DRIVERCNT>
        <LOGNO>2</LOGNO>
        <ERRBIT></ERRBIT>
        <NEEDRESPONSE>1</NEEDRESPONSE>
    </FIRMUPDATEINFO>
</REQUESTINFO>

…after curling the request to the WebService

curl -X POST -d @request.xml https://firmverup.brother.co.jp/kne_bh7_update_nt_ssl/ifax2.asmx/fileUpdate -H "Content-Type:text/xml" --sslv3

…BOOM!! 😉

<?xml version="1.0" encoding="UTF-8" ?>
<RESPONSEINFO>
  <FIRMUPDATEINFO>
    <VERSIONCHECK>0</VERSIONCHECK>
    <MEMORYVERSION>a</MEMORYVERSION>
    <FIRMID>MAIN</FIRMID>
    <LATESTVERSION>J1307022123</LATESTVERSION>
    <PATH>http://update-akamai.brother.co.jp/CS/LZ3637_J.djf</PATH>
    <DLTIME>129000</DLTIME>
  </FIRMUPDATEINFO>
</RESPONSEINFO>

…finally just need to flash the firmware via FTP

wget http://update-akamai.brother.co.jp/CS/LZ3637_J.djf
ftp <printer IP address> (the user id is the admin password!)
  bin
  hash
  send LZ3637_J.djf
  bye

I can’t believe how easy it’ll be to provide a cross-platform tool to flash the firmware or just providing a direct link to the firmware file! …come on @Brother!!

Adapting Saturation with ImageMagick

In the previous article on Enfuse, the colours are a little dull on the tone mapped output image. So I’ve found a tutorial [1] which apply an intensity of saturation based on the existent saturated/unsaturated pixels.

#tested with ImageMagick 6.6.1-10
convert ${min_ev_name}_tm.tiff -sigmoidal-contrast 2x50% -alpha off ${min_ev_name}_contrast.tiff

convert -set option:modulate:colorspace HSB \( ${min_ev_name}_contrast.tiff -modulate 100,130,100 \) \( -clone 0 \( -clone 0 -modulate 100,0,100 \) -compose difference -composite -auto-level -negate \) -compose CopyOpacity -composite ${min_ev_name}_saturation_mask.tiff

composite ${min_ev_name}_saturation_mask.tiff ${min_ev_name}_contrast.tiff ${min_ev_name}_final.tiff

Here is a comparison between a standard 30% saturation and the adapting saturation. The white colour is the full 30% saturation ratio and the gray colour is the area where the adapting technique is applied.

A big thanks to ImageMagick [2] and Meet the Gimp [3] communities for the useful pointers!
—
[1] Adaptive Saturation
[2] ImageMagick – forum
[3] Meet the Gimp – forum

Tone Mapping with Enfuse

The previous article was about producing an image free of noise, now we can apply a tone mapping [1]. I’m going to use Enfuse to generate a natural HDR/LDR image.

Due to the nature of the image produced by the Noise Suppression technique, we can generate over-exposed images (1EV 2EV 3EV 4EV) without any quality issues. Then we are going to feed the resultant images (with a gamma 2.2 applied) to Enfuse.

convert ${min_ev_name}_fon.tiff -alpha off -gamma 2.2 ${min_ev_name}_tone_a.tiff
letters=( a b c d e f g h i j k l m n o p q r s t u v w x y z )
counter=1
while true; do
  exp=`echo "2^${counter}" | bc`
  if [ "${exp}" -gt "${max_exp}" ]; then
     break
  fi
  convert ${min_ev_name}_fon.tiff -alpha off -evaluate multiply ${exp} -gamma 2.2 ${min_ev_name}_tone_${letters[${counter}]}.tiff
  let counter=${counter}+1
done
convert ${min_ev_name}_fon.tiff -alpha off -evaluate multiply ${max_exp} -gamma 2.2 ${min_ev_name}_tone_${letters[${counter}]}.tiff
tone_files=`ls ${min_ev_name}_tone_*.tiff`
enfuse -v -o ${min_ev_name}_tm.tiff ${tone_files}

Enfuse generates internally the following merging masks.

Finally Enfuse produces a natural looking image.

Additionally we can process the image a little bit further by applying contrast and saturation to the HDR/LDR image. I’m using a sigmoidal contrast curve of 2×50% and a 30% increase of saturation.

convert ${min_ev_name}_tm.tiff -sigmoidal-contrast 2x50% -modulate 100,130,100 ${min_ev_name}_final.tiff

—
[1] Guillermo Lujik – HDR TONE MAPPING

Noise Suppression with ImageMagick

•December 1, 2009 • Leave a Comment

This post is a tribute to Guillermo Luijk‘s Zero Noise technique [1].

To replicate this process under Linux, I’m using dcraw and ImageMagick. To compare apple to apple, I’ve used the photos from Guillermo’s article.

The aim of this technique is to replace noisy pixels from the original image (0EV) with the pixels from the other over-exposed images. Therefore you need to take a number of catches with 2EV apart (e.g: 0EV +2EV +4EV) using a tripod. The reference image is the 0EV catch and that’s where the technique will apply.

The first step is to convert the raw files to linear TIFF (16bits) using the sRGB colorspace with for example an automatic white balance.

max_ev=`ls -1 *.cr2 | tail -n 1`
max_ev_name=`echo ${max_ev} | cut -d '.' -f1`
dcraw -v a -W -o 1 -q 3 -4 -T -c ${max_ev} > ${max_ev_name}.tiff 2> dcraw.log
cat dcraw.log
rgbg=`grep 'multipliers' dcraw.log | cut -d ' ' -f2,3,4,5`
rm dcraw.log
for other in $( ls -r *.cr2 ); do
  if [ ${other} != ${max_ev} ]; then
    dcraw -v -r $rgbg -W -o $color -q 3 -4 -T ${other}
  fi
done

Second step is to create the merging masks (2 masks for 3 catches). A mask is produced from the negate of over-exposed image which is copied into the alpha channel [2] of the corrected version of the over-exposed image. For example, the corrected version of the +2EV image is 0EV.
To generate the corrected images, I’ve wrote a little program (based on Guillermo’s algorithm) using the ImageMagick C++ API. The program prints the exposure difference between 2 images.

#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <wand/MagickWand.h>

int main(int argc,char **argv) {
  MagickBooleanType status;
  MagickPixelPacket pixel1, pixel2;
  MagickWand *image1, *image2;
  PixelIterator *iterator1, *iterator2;
  PixelWand **pixels1, **pixels2;

  long y;  
  register long x;
  unsigned long width;

  double min = 65536 / pow(2, 6);
  double max = 65536 * 0.9;
  double sum1 = 0, sum2 = 0;

  if (argc != 3) {
      fprintf(stdout, "Usage: %s normal-image over-exposed-image\n", argv[0]);
      exit(0);
  }

  MagickWandGenesis();
  image1 = NewMagickWand();
  status = MagickReadImage(image1, argv[1]);
  if (status == MagickFalse) {
    return -1;
  }
  image2 = NewMagickWand();
  status = MagickReadImage(image2, argv[2]);
  if (status == MagickFalse) {
    return -1;
  }

  iterator1 = NewPixelIterator(image1);
  iterator2 = NewPixelIterator(image2);
  if ((iterator1 == (PixelIterator *) NULL) || (iterator2 == (PixelIterator *) NULL)) {
    return -1;
  }
  for (y=0; y < (long) MagickGetImageHeight(image1); y++) {
    pixels1 = PixelGetNextIteratorRow(iterator1, &width);
    pixels2 = PixelGetNextIteratorRow(iterator2, &width);
    if ((pixels1 == (PixelWand **) NULL) || (pixels2 == (PixelWand **) NULL)) {
      break;
    }
    for (x=0; x < (long) width; x++) {
      PixelGetMagickColor(pixels1[x], &pixel1);
      PixelGetMagickColor(pixels2[x], &pixel2);
      if ((pixel1.red >= min) && (pixel1.red <= max) && (pixel2.red >= min) && (pixel2.red <= max)) {
         sum1 += pixel1.red;
         sum2 += pixel2.red;
      }
      if ((pixel1.green >= min) && (pixel1.green <= max) && (pixel2.green >= min) && (pixel2.green <= max)) {
         sum1 += pixel1.green;
         sum2 += pixel2.green;
      }
      if ((pixel1.blue >= min) && (pixel1.blue <= max) && (pixel2.blue >= min) && (pixel2.blue <= max)) {
         sum1 += pixel1.blue;
         sum2 += pixel2.blue;
      }
    }
  }
  if (y < (long) MagickGetImageHeight(image1)) {

    return -1;
  }
  iterator1 = DestroyPixelIterator(iterator1);
  image1 = DestroyMagickWand(image1);
  iterator2 = DestroyPixelIterator(iterator2);
  image2 = DestroyMagickWand(image2);
  MagickWandTerminus();

  printf("%.100g\n", sum1/sum2);
  return(0);
}

min_ev=`ls -1r *.tiff | tail -n 1`
for ev in $( ls *.tiff ); do
  if [ ${ev} != ${min_ev} ]; then
    ev_name=`echo ${ev} | cut -d '.' -f1`
    ec=`exposure ${min_ev} ${ev}`
    convert ${ev} -evaluate multiply $ec ${ev_name}_corrected.tiff
    composite -compose CopyOpacity \( ${ev} -negate \) ${ev_name}_corrected.tiff ${ev_name}_mask.tiff
  fi
done

To get the final image, we need to merge the masks together and overlay the mask to the first image.

mask_files=`ls -r *_mask.tiff`
nb_mask=`ls  -r *_mask.tiff | wc -l`
if [[ $( echo "$nb_mask == 1.00" | bc ) == "1" ]]; then
  mv $mask_files final_mask.tiff
else
  composite ${mask_files} final_mask.tiff
fi
min_ev_name=`echo ${min_ev} | cut -d '.' -f1`
composite final_mask.tiff ${min_ev} ${min_ev_name}_fon.tiff

Here is the final bash script which takes in argument a folder with a number of catches. With the -c option, you can compile the latest dcraw and the exposure program (you need the ImageMagick development package). The script requires the following tools: bash, cut, tail, grep, bc, wget, gcc and ImageMagick Q16.

#!/bin/bash
compile=
color=1
wb=-w
ext=dng

while getopts 'w:e:c' OPTION
  do
    case $OPTION in
      w)      wb=-"$OPTARG"
               ;;
      e)      ext="$OPTARG"
               ;;
      c)      compile=1
               ;;
      ?)      printf "Usage: %s: [-w {dcraw white balance: a|w}] [-e {file extension}] [-c compile] {folder}\n" $(basename $0) >&2
               exit 2
               ;;
      esac
      done
shift $(($OPTIND - 1))

if [ -z $1 ]; then
  printf "Usage: %s: [-w {dcraw white balance: a|w}] [-e {file extension}] [-c compile] {folder}\n" $(basename $0) >&2
  exit 2;
fi

if [ "$compile" ]; then
  echo "--- compile dcraw"
  wget http://cybercom.net/~dcoffin/dcraw/dcraw.c
  gcc -o dcraw -O4 dcraw.c -lm -ljpeg -llcms
  rm dcraw.c
  echo "--- compile exposure"
  gcc `Magick-config --cflags --cppflags` -o exposure exposure.c `Magick-config --ldflags --libs`
fi

echo "--- process folder=${1}"
cd ${1}
rm *.tiff

echo "--- convert raw to tiff"
max_ev=`ls -1 *.${ext} | tail -n 1`
max_ev_name=`echo ${max_ev} | cut -d '.' -f1`
../dcraw -v $wb -W -o $color -q 3 -4 -T -c ${max_ev} > ${max_ev_name}.tiff 2> dcraw.log
cat dcraw.log
rgbg=`grep 'multipliers' dcraw.log | cut -d ' ' -f2,3,4,5`
rm dcraw.log
for other in $( ls -r *.${ext} ); do
  if [ ${other} != ${max_ev} ]; then
    ../dcraw -v -r $rgbg -W -o $color -q 3 -4 -T ${other}
  fi
done

min_ev=`ls -1r *.tiff | tail -n 1`
max_exp=0
for ev in $( ls *.tiff ); do
  if [ ${ev} != ${min_ev} ]; then
    ev_name=`echo ${ev} | cut -d '.' -f1`
    echo -n "--- calculate negative exposure between ${min_ev} and ${ev}="
    ec=`../exposure ${min_ev} ${ev}`
    echo $ec
    max_exp=`echo "1/$ec" | bc`
    echo "--- create a mask for ${ev}"
    convert ${ev} -evaluate multiply $ec ${ev_name}_corrected.tiff
    composite -compose CopyOpacity \( ${ev} -negate \) ${ev_name}_corrected.tiff ${ev_name}_mask.tiff
  fi
done

echo "--- merge the masks"
mask_files=`ls -r *_mask.tiff`
nb_mask=`ls  -r *_mask.tiff | wc -l`
if [[ $( echo "$nb_mask == 1.00" | bc ) == "1" ]]; then
  mv $mask_files final_mask.tiff
else
  composite ${mask_files} final_mask.tiff
fi

echo "--- overlay the mask with ${min_ev}"
min_ev_name=`echo ${min_ev} | cut -d '.' -f1`
composite final_mask.tiff ${min_ev} ${min_ev_name}_fon.tiff

rm *_mask.tiff *_corrected.tiff

—
[1] Guillermo Lujik – ZERO NOISE
[2] ImageMagick – Copy Opacity