Surnia Ulula

UNIX Ideas for SysAdmins

Wesley.pl optimize script for jpeg, png, and gif

Categories: Perl, UNIX (Generic)

Tags: exif, gif, gifsicle, github, google rank, jpeg, jpegtran, optimize, page load, png, pngcrush, wesley.pl

Comments: 1 Comment

Published on: Saturday, December 29th, 2012

To improve page load times (and Google ranking), you should make sure all jpeg, png, and gif files are properly optimized. Instead of writing my own script for jpegtran, pngcrush, and gifsicle, I used Mike Brittain’s Wesley.pl script on GitHub. It works great, though I did have to modify it to change the “jpegtran -copy” parameter it uses — I need to keep the EXIF on larger files, and strip it from thumbnails. I posted the diff on the GitHub Issues page.

Update 2012-12-31 : In case Mike doesn’t merge my diff, with the addition of the --copy=[all|comments|none] command-line argument (see my comment bellow for more info), you can download the patched wesley.pl script here instead.

Did you find this post useful? Share it with your circles / friends, or leave a quick note bellow.

Thank you,

js.

Jean-Sebastien Morisset
Looking for a Sr UNIX Systems Administrator specializing in Systems Integration? I may be available for freelance or contract work, either remotely or on-site. You can contact me by email at jsm@surniaulula.com to discuss your needs, and how my skills might contribute to your success. The Contact Me, Services and Rates pages contain additional information, including my current location and availability schedule.

Categories: Perl, UNIX (Generic)
Tags: exif, gif, gifsicle, github, google rank, jpeg, jpegtran, optimize, page load, png, pngcrush, wesley.pl
Published on: Saturday, December 29th, 2012

1 Comment - Leave a comment

Jean-Sebastien Morisset says:

Sunday, December 30th, 2012 at 3:39 pm EDT

Here’s the patched version of wesley.pl with the addition of a --copy=[all|comments|none] command-line argument.

#!/usr/bin/perl -w

#
# Wesley
#
# Version 0.1.0
#
# Recursively searches a directory path for image files (JPEG, GIF, PNG) and 
# applies lossless compression to files in-place.
#
# This script uses techniques described in this article about the use 
# of jpegtran: http://www.phpied.com/installing-jpegtran-mac-unix-linux/
# and used by the smush.it tool described here:
# http://developer.yahoo.com/yslow/smushit/faq.html
#
# Wesley makes use of gifsicle, ImageMagick, jpegtran, and pngcrush to optimize
# images.  You should make an attempt to ensure that each of these has been
# installed on your system prior to running this script.  If you are missing 
# any of these, however, Wesley will still run but will skip any optimizations
# for which the applicable software is not available.  In other words, if you 
# don't have jpegtran installed, Wesley will skip JPEG optimizations.
#
# USAGE:
#  
# Recursively optimize all images within a directory:
#
#   wesley.pl directory_path
#
# Optimize a single image:
#
#   wesley.pl filename
#

#
# *** WARNING ***
#
# Removal of copyright information from files you do not own may be a violation
# of the DMCA (http://en.wikipedia.org/wiki/Digital_Millennium_Copyright_Act).
# This script removes metadata and comments from image files.  Do not use this
# script to modify files for which you do not own the rights.
#

#
# PERMISSION NOTICE AND DISCLAIMER
# 
# Permission to use, copy, modify and distribute this software and its documentation 
# for any purpose and without fee is hereby granted. This software is provided "as is"
# without express or implied warranty.
# 
# IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL 
# DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, 
# WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT 
# OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
# 

#
# CHANGES
#
# 2012-12-20 - Jean-Sebastien Morisset - http://surniaulula.com/
#	Added --copy=[all|comments|none] command-line option (defaults to 'all').
#

use strict;
use File::Find;
use File::Copy;
use Getopt::Long;

my $DEBUG = 0;

# Setup locations where we might find the necessary executables.
my @jpegtran_paths = qw( /usr/bin/jpegtran /usr/local/bin/jpegtran );
my @pngcrush_paths = qw( /usr/bin/pngcrush /usr/local/bin/pngcrush /sw/bin/pngcrush );
my @gifsicle_paths = qw( /usr/bin/gifsicle /usr/local/bin/gifsicle /sw/bin/gifsicle );
my @convert_paths  = qw( /usr/bin/convert /usr/local/bin/convert /sw/bin/convert );
my @identify_paths = qw( /usr/bin/identify /usr/local/bin/identify /sw/bin/identify );

# Turn off any of the following options you don't want to run.
my $do_jpeg_compress = 1;
my $do_png_compress  = 1;
my $do_gif_compress  = 1;
my $do_png_compare   = 1;

my $jpegtran_path;
my $pngcrush_path;
my $gifsicle_path;
my $convert_path;
my $identify_path;

my %opt = (
	'copy'	=> 'all',
);

GetOptions(\%opt,
	'copy=s',
);

# Locate paths to executables.
locateBinaries();

print "JPEG optimizations will be skipped.\n" if $DEBUG && !$do_jpeg_compress;
print "PNG optimizations will be skipped.\n" if $DEBUG && !$do_png_compress;
print "GIF optimizations will be skipped.\n" if $DEBUG && !$do_gif_compress;

# Get image search path from command-line args.
my $search_path = readInput();

# Setup default counters.
my $score = {};
$score->{'jpeg_count'} = 0;
$score->{'jpeg_modify'} = 0;
$score->{'jpeg_optimize'} = 0;
$score->{'jpeg_progressive'} = 0;
$score->{'jpeg_bytes_orig'} = 0;
$score->{'jpeg_bytes_saved'} = 0;
$score->{'png_count'} = 0;
$score->{'png_modify'} = 0;
$score->{'png_crush'} = 0;
$score->{'png_bytes_orig'} = 0;
$score->{'png_bytes_saved'} = 0;
$score->{'gif_count'} = 0;
$score->{'gif_modify'} = 0;
$score->{'gif_gifsicle'} = 0;
$score->{'gif_bytes_orig'} = 0;
$score->{'gif_bytes_saved'} = 0;
$score->{'gif2png_files'} = [];
$score->{'gif2png_bytes_orig'} = 0;
$score->{'gif2png_bytes_saved'} = 0;

# Compress image files.
find(\&compressFiles, $search_path);

# Output statistics.
writeSummary();

exit;


#
# Subroutines
#

sub compressFiles()
{
    if (m/\.jpg$/i && $do_jpeg_compress) {
        compressJPG($_);
    
    } elsif (m/\.png$/i && $do_png_compress) {
        compressPNG($_);

    } elsif (m/\.gif$/i) {
        if ($do_gif_compress) {
            compressGIF($_);
        }
        if ($do_png_compare) {
            comparePNG($_);
        }
    }
}

sub compressJPG
{
    $score->{'jpeg_count'}++;

    my $orig_size = -s $_;
    my $saved = 0;

    my $fullname = $File::Find::dir . '/' . $_;

    print "Inspecting $fullname\n";

    # Run Progressive JPEG and Huffman table optimizations, then inspect
    # which was best.

    `$jpegtran_path -copy $opt{'copy'} -optimize "$_" > "$_.opt"`; 
    my $opt_size = -s "$_.opt";

    `$jpegtran_path -copy $opt{'copy'} -progressive "$_" > "$_.prog"`; 
    my $prog_size = -s "$_.prog";

    if ($opt_size && $opt_size < $orig_size && $opt_size <= $prog_size) {
        move("$_.opt", "$_");
        $saved = $orig_size - $opt_size;
        $score->{'jpeg_bytes_saved'} += $saved;
        $score->{'jpeg_bytes_orig'} += $orig_size;
        $score->{'jpeg_modify'}++;
        $score->{'jpeg_optimize'}++;

        print " -- Huffman table optimization: "
            . "saved $saved bytes (orig $orig_size)\n" if $DEBUG;

    } elsif ($prog_size && $prog_size < $orig_size) {
        move("$_.prog", "$_");
        $saved = $orig_size - $prog_size;
        $score->{'jpeg_bytes_saved'} += $saved;
        $score->{'jpeg_bytes_orig'} += $orig_size;
        $score->{'jpeg_modify'}++;
        $score->{'jpeg_progressive'}++;

        print " -- Progressive JPEG optimization: "
            . "saved $saved bytes (orig $orig_size)\n" if $DEBUG;
    }

    # Cleanup temp files
    if (-e "$_.prog") {
         unlink("$_.prog");
    }
    if (-e "$_.opt") {
        unlink("$_.opt");
    }
}

sub compressPNG 
{
    $score->{'png_count'}++;

    my $orig_size = -s $_;
    my $saved = 0;
    
    my $fullname = $File::Find::dir . '/' . $_;

    print "Inspecting $fullname\n";

    # Run pngcrush
    `$pngcrush_path -rem alla -reduce -brute "$_" "$_.crush"`;
    my $crush_size = -s "$_.crush";

    if ($crush_size && $crush_size < $orig_size) {
        move("$_.crush", "$_");
        $saved = $orig_size - $crush_size;
        $score->{'png_bytes_saved'} += $saved;
        $score->{'png_bytes_orig'} += $orig_size;
        $score->{'png_modify'}++;
        $score->{'png_crush'}++;

        print " -- pngcrush optimization: "
            . "saved $saved bytes (orig $orig_size)\n" if $DEBUG;

    } else {
        unlink("$_.crush");
    }
}

sub compressGIF 
{
    $score->{'gif_count'}++;

    my $orig_size = -s $_;
    my $saved = 0;
    
    my $fullname = $File::Find::dir . '/' . $_;

    print "Inspecting $fullname\n";

    `$gifsicle_path --no-warnings --no-comments --optimize=2 "$_" > "$_.gifsicle"`;
    my $gifsicle_size = -s "$_.gifsicle";

    if ($gifsicle_size && $gifsicle_size < $orig_size) {
        move("$_.gifsicle", "$_");
        $saved = $orig_size - $gifsicle_size;
        $score->{'gif_bytes_saved'} += $saved;
        $score->{'gif_bytes_orig'} += $orig_size;
        $score->{'gif_modify'}++;
        $score->{'gif_gifsicle'}++;

        print " -- Gifsicle optimization: "
            . "saved $saved bytes (orig $orig_size)\n" if $DEBUG;
    } else {
        unlink("$_.gifsicle");
    }
}

sub comparePNG 
{
    my $orig_size = -s $_;
    my $saved = 0;
    my $png_size = 0;
    
    my $fullname = $File::Find::dir . '/' . $_;

    # Only try converting static GIFs.
    my $type = `$identify_path -format %m "$_"`;
    chomp $type;

    if ($type eq 'GIF') {

        print "Considering conversion to PNG: $fullname\n";

        # Try converting to PNG and crush if possible.
        `$convert_path "$_" "$_.try.png"`;
        if ($pngcrush_path) {
            `$pngcrush_path -rem alla -reduce -brute "$_.try.png" "$_.try.crush"`;
            $png_size = -s "$_.try.crush";
        } else {
            $png_size = -s "$_.try.png";
        }

        if ($png_size && $png_size < $orig_size) {
            $saved = $orig_size - $png_size;
            $score->{'gif2png_bytes_saved'} += $saved;
            $score->{'gif2png_bytes_orig'} += $orig_size;
            push @{$score->{'gif2png_files'}}, $fullname;

            print " -- Conversion to PNG would save "
                . "$saved bytes (orig $orig_size)\n" if $DEBUG;
        }
        
        # Clean up temp files.
        if (-e "$_.try.png") {
            unlink("$_.try.png");
        }
        if (-e "$_.try.crush") {
            unlink("$_.try.crush");
        }
    }
}


# Read search path from command line
sub readInput
{
    if (!$ARGV[0]) {
        print STDERR "Usage: $0 path_to_images\n";
        exit 1;
    }

    my $images_path = $ARGV[0];
    if (!-e $images_path) {
        print STDERR "Invalid path specified.\n";
        exit 1;
    }

    return $images_path;
}

sub locateBin
{
    my $name = shift;
    my @search_paths = @_;

    my $found_path;

    my $path = `/usr/bin/which $name`;
    if ($path =~ /\//) {
        chomp $path;
        $found_path = $path;
    } else {
        foreach my $path (@search_paths) {
            if (-e $path && -x $path) {
                $found_path = $path;
                last;
            }
        }
    }

    if ($found_path) {
        print "Found $name at $found_path.\n" if $DEBUG;
    } else {
        print "Warning: Could not locate $name.\n" if $DEBUG;
    }

    return $found_path;
}

#
# Locate paths to the executables we need for optimizations.  For each
# one, check the user's path (using 'which'), then try to fall back on
# search paths specified in globals at top of the script.
#
sub locateBinaries
{
    $jpegtran_path = locateBin('jpegtran', @jpegtran_paths);
    $pngcrush_path = locateBin('pngcrush', @pngcrush_paths);
    $gifsicle_path = locateBin('gifsicle', @gifsicle_paths);
    $convert_path = locateBin('convert', @convert_paths);
    $identify_path = locateBin('identify', @identify_paths);

    if (!$jpegtran_path) {
        $do_jpeg_compress = 0;
    }
    if (!$pngcrush_path) {
        $do_png_compress = 0;
    }
    if (!$gifsicle_path) {
        $do_gif_compress = 0;
    }
    if (!$identify_path || !$convert_path) {
        $do_png_compare = 0;
    }
}

sub writeSummary
{
    my $total_bytes_orig = $score->{'jpeg_bytes_orig'} + $score->{'png_bytes_orig'} + $score->{'gif_bytes_orig'};
    my $total_bytes_saved = $score->{'jpeg_bytes_saved'} + $score->{'png_bytes_saved'} + $score->{'gif_bytes_saved'};

    print "\n";
    print "----------------------------\n";
    print "  Summary\n";
    print "----------------------------\n";
    print "\n";

    if ($score->{'gif2png_bytes_saved'}) {
        print "  Converting the following GIFs to PNG would save additional file size.\n";
        print "  Bytes saved: $score->{'gif2png_bytes_saved'} "
               . "(orig $score->{'gif2png_bytes_orig'}, saved "
               . (int($score->{'gif2png_bytes_saved'}/$score->{'gif2png_bytes_orig'}*10000) / 100) 
               . "%)\n";
        print "\n";
        foreach my $file (@{$score->{'gif2png_files'}}) {
            print "    $file\n";
        }
        print "\n";
    }

    if ($score->{'jpeg_bytes_orig'}) {
        print "  Inspected $score->{'jpeg_count'} JPEG files.\n";
        print "  Modified $score->{'jpeg_modify'} files.\n";
        print "  Huffman table optimizations: $score->{'jpeg_optimize'}\n";
        print "  Progressive JPEG optimizations: $score->{'jpeg_progressive'}\n";
        print "  Bytes saved: $score->{'jpeg_bytes_saved'} "
               . "(orig $score->{'jpeg_bytes_orig'}, saved "
               . (int($score->{'jpeg_bytes_saved'}/$score->{'jpeg_bytes_orig'}*10000) / 100) 
               . "%)\n";
        print "\n";
    }
    if ($score->{'png_bytes_orig'}) {
        print "  Inspected $score->{'png_count'} PNG files.\n";
        print "  Modified $score->{'png_modify'} files.\n";
        print "  Bytes saved: $score->{'png_bytes_saved'} "
               . "(orig $score->{'png_bytes_orig'}, saved "
               . (int($score->{'png_bytes_saved'}/$score->{'png_bytes_orig'}*10000) / 100) 
               . "%)\n";
        print "\n";
    }
    if ($score->{'gif_bytes_orig'}) {
        print "  Inspected $score->{'gif_count'} GIF files.\n";
        print "  Modified $score->{'gif_modify'} files.\n";
        print "  Bytes saved: $score->{'gif_bytes_saved'} "
               . "(orig $score->{'gif_bytes_orig'}, saved "
               . (int($score->{'gif_bytes_saved'}/$score->{'gif_bytes_orig'}*10000) / 100) 
               . "%)\n";
        print "\n";
    }
    print "  Total bytes saved: $total_bytes_saved ";
    if ($total_bytes_orig) {
        print "(orig $total_bytes_orig, saved "
           . (int($total_bytes_saved/$total_bytes_orig*10000) / 100) 
           . "%)";
    }
    print "\n\n";
}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

228

229

230

231

232

233

234

235

236

237

238

239

240

241

242

243

244

245

246

247

248

249

250

251

252

253

254

255

256

257

258

259

260

261

262

263

264

265

266

267

268

269

270

271

272

273

274

275

276

277

278

279

280

281

282

283

284

285

286

287

288

289

290

291

292

293

294

295

296

297

298

299

300

301

302

303

304

305

306

307

308

309

310

311

312

313

314

315

316

317

318

319

320

321

322

323

324

325

326

327

328

329

330

331

332

333

334

335

336

337

338

339

340

341

342

343

344

345

346

347

348

349

350

351

352

353

354

355

356

357

358

359

360

361

362

363

364

365

366

367

368

369

370

371

372

373

374

375

376

377

378

379

380

381

382

383

384

385

386

387

388

389

390

391

392

393

394

395

396

397

398

399

400

401

402

403

404

405

406

407

408

409

410

411

412

413

414

415

416

417

418

419

420

421

422

423

424

425

426

427

428

429

430

431

432

433

434

435

436

437

438

439

440

441

442

443

444

445

446

447

448

449

450

451

#!/usr/bin/perl -w

# Wesley

# Version 0.1.0

# Recursively searches a directory path for image files (JPEG, GIF, PNG) and

# applies lossless compression to files in-place.

# This script uses techniques described in this article about the use

# of jpegtran: http://www.phpied.com/installing-jpegtran-mac-unix-linux/

# and used by the smush.it tool described here:

# http://developer.yahoo.com/yslow/smushit/faq.html

# Wesley makes use of gifsicle, ImageMagick, jpegtran, and pngcrush to optimize

# images. You should make an attempt to ensure that each of these has been

# installed on your system prior to running this script. If you are missing

# any of these, however, Wesley will still run but will skip any optimizations

# for which the applicable software is not available. In other words, if you

# don't have jpegtran installed, Wesley will skip JPEG optimizations.

# USAGE:

# Recursively optimize all images within a directory:

# wesley.pl directory_path

# Optimize a single image:

# wesley.pl filename

# *** WARNING ***

# Removal of copyright information from files you do not own may be a violation

# of the DMCA (http://en.wikipedia.org/wiki/Digital_Millennium_Copyright_Act).

# This script removes metadata and comments from image files. Do not use this

# script to modify files for which you do not own the rights.

# PERMISSION NOTICE AND DISCLAIMER

# Permission to use, copy, modify and distribute this software and its documentation

# for any purpose and without fee is hereby granted. This software is provided "as is"

# without express or implied warranty.

# IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL

# DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,

# WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT

# OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

# CHANGES

# 2012-12-20 - Jean-Sebastien Morisset - http://surniaulula.com/

# Added --copy=[all|comments|none] command-line option (defaults to 'all').

use strict;

use File::Find;

use File::Copy;

use Getopt::Long;

my $DEBUG = 0;

# Setup locations where we might find the necessary executables.

my @jpegtran_paths = qw( /usr/bin/jpegtran /usr/local/bin/jpegtran );

my @pngcrush_paths = qw( /usr/bin/pngcrush /usr/local/bin/pngcrush /sw/bin/pngcrush );

my @gifsicle_paths = qw( /usr/bin/gifsicle /usr/local/bin/gifsicle /sw/bin/gifsicle );

my @convert_paths = qw( /usr/bin/convert /usr/local/bin/convert /sw/bin/convert );

my @identify_paths = qw( /usr/bin/identify /usr/local/bin/identify /sw/bin/identify );

# Turn off any of the following options you don't want to run.

my $do_jpeg_compress = 1;

my $do_png_compress = 1;

my $do_gif_compress = 1;

my $do_png_compare = 1;

my $jpegtran_path;

my $pngcrush_path;

my $gifsicle_path;

my $convert_path;

my $identify_path;

my %opt = (

'copy' => 'all',

);

GetOptions(\%opt,

'copy=s',

);

# Locate paths to executables.

locateBinaries();

print "JPEG optimizations will be skipped.\n" if $DEBUG && !$do_jpeg_compress;

print "PNG optimizations will be skipped.\n" if $DEBUG && !$do_png_compress;

print "GIF optimizations will be skipped.\n" if $DEBUG && !$do_gif_compress;

# Get image search path from command-line args.

my $search_path = readInput();

# Setup default counters.

my $score = {};

$score->{'jpeg_count'} = 0;

$score->{'jpeg_modify'} = 0;

$score->{'jpeg_optimize'} = 0;

$score->{'jpeg_progressive'} = 0;

$score->{'jpeg_bytes_orig'} = 0;

$score->{'jpeg_bytes_saved'} = 0;

$score->{'png_count'} = 0;

$score->{'png_modify'} = 0;

$score->{'png_crush'} = 0;

$score->{'png_bytes_orig'} = 0;

$score->{'png_bytes_saved'} = 0;

$score->{'gif_count'} = 0;

$score->{'gif_modify'} = 0;

$score->{'gif_gifsicle'} = 0;

$score->{'gif_bytes_orig'} = 0;

$score->{'gif_bytes_saved'} = 0;

$score->{'gif2png_files'} = [];

$score->{'gif2png_bytes_orig'} = 0;

$score->{'gif2png_bytes_saved'} = 0;

# Compress image files.

find(\&compressFiles, $search_path);

# Output statistics.

writeSummary();

exit;

# Subroutines

sub compressFiles()

{

if (m/\.jpg$/i && $do_jpeg_compress) {

compressJPG($_);

} elsif (m/\.png$/i && $do_png_compress) {

compressPNG($_);

} elsif (m/\.gif$/i) {

if ($do_gif_compress) {

compressGIF($_);

}

if ($do_png_compare) {

comparePNG($_);

}

sub compressJPG

{

$score->{'jpeg_count'}++;

my $orig_size = -s $_;

my $saved = 0;

my $fullname = $File::Find::dir . '/' . $_;

print "Inspecting $fullname\n";

# Run Progressive JPEG and Huffman table optimizations, then inspect

# which was best.

`$jpegtran_path -copy $opt{'copy'} -optimize "$_" > "$_.opt"`;

my $opt_size = -s "$_.opt";

`$jpegtran_path -copy $opt{'copy'} -progressive "$_" > "$_.prog"`;

my $prog_size = -s "$_.prog";

if ($opt_size && $opt_size < $orig_size && $opt_size <= $prog_size) {

move("$_.opt", "$_");

$saved = $orig_size - $opt_size;

$score->{'jpeg_bytes_saved'} += $saved;

$score->{'jpeg_bytes_orig'} += $orig_size;

$score->{'jpeg_modify'}++;

$score->{'jpeg_optimize'}++;

print " -- Huffman table optimization: "

. "saved $saved bytes (orig $orig_size)\n" if $DEBUG;

} elsif ($prog_size && $prog_size < $orig_size) {

move("$_.prog", "$_");

$saved = $orig_size - $prog_size;

$score->{'jpeg_bytes_saved'} += $saved;

$score->{'jpeg_bytes_orig'} += $orig_size;

$score->{'jpeg_modify'}++;

$score->{'jpeg_progressive'}++;

print " -- Progressive JPEG optimization: "

. "saved $saved bytes (orig $orig_size)\n" if $DEBUG;

}

# Cleanup temp files

if (-e "$_.prog") {

unlink("$_.prog");

}

if (-e "$_.opt") {

unlink("$_.opt");

}

sub compressPNG

{

$score->{'png_count'}++;

my $orig_size = -s $_;

my $saved = 0;

my $fullname = $File::Find::dir . '/' . $_;

print "Inspecting $fullname\n";

# Run pngcrush

`$pngcrush_path -rem alla -reduce -brute "$_" "$_.crush"`;

my $crush_size = -s "$_.crush";

if ($crush_size && $crush_size < $orig_size) {

move("$_.crush", "$_");

$saved = $orig_size - $crush_size;

$score->{'png_bytes_saved'} += $saved;

$score->{'png_bytes_orig'} += $orig_size;

$score->{'png_modify'}++;

$score->{'png_crush'}++;

print " -- pngcrush optimization: "

. "saved $saved bytes (orig $orig_size)\n" if $DEBUG;

} else {

unlink("$_.crush");

}

sub compressGIF

{

$score->{'gif_count'}++;

my $orig_size = -s $_;

my $saved = 0;

my $fullname = $File::Find::dir . '/' . $_;

print "Inspecting $fullname\n";

`$gifsicle_path --no-warnings --no-comments --optimize=2 "$_" > "$_.gifsicle"`;

my $gifsicle_size = -s "$_.gifsicle";

if ($gifsicle_size && $gifsicle_size < $orig_size) {

move("$_.gifsicle", "$_");

$saved = $orig_size - $gifsicle_size;

$score->{'gif_bytes_saved'} += $saved;

$score->{'gif_bytes_orig'} += $orig_size;

$score->{'gif_modify'}++;

$score->{'gif_gifsicle'}++;

print " -- Gifsicle optimization: "

. "saved $saved bytes (orig $orig_size)\n" if $DEBUG;

} else {

unlink("$_.gifsicle");

}

sub comparePNG

{

my $orig_size = -s $_;

my $saved = 0;

my $png_size = 0;

my $fullname = $File::Find::dir . '/' . $_;

# Only try converting static GIFs.

my $type = `$identify_path -format %m "$_"`;

chomp $type;

if ($type eq 'GIF') {

print "Considering conversion to PNG: $fullname\n";

# Try converting to PNG and crush if possible.

`$convert_path "$_" "$_.try.png"`;

if ($pngcrush_path) {

`$pngcrush_path -rem alla -reduce -brute "$_.try.png" "$_.try.crush"`;

$png_size = -s "$_.try.crush";

} else {

$png_size = -s "$_.try.png";

}

if ($png_size && $png_size < $orig_size) {

$saved = $orig_size - $png_size;

$score->{'gif2png_bytes_saved'} += $saved;

$score->{'gif2png_bytes_orig'} += $orig_size;

push @{$score->{'gif2png_files'}}, $fullname;

print " -- Conversion to PNG would save "

. "$saved bytes (orig $orig_size)\n" if $DEBUG;

}

# Clean up temp files.

if (-e "$_.try.png") {

unlink("$_.try.png");

}

if (-e "$_.try.crush") {

unlink("$_.try.crush");

}

# Read search path from command line

sub readInput

{

if (!$ARGV[0]) {

print STDERR "Usage: $0 path_to_images\n";

exit 1;

}

my $images_path = $ARGV[0];

if (!-e $images_path) {

print STDERR "Invalid path specified.\n";

exit 1;

}

return $images_path;

}

sub locateBin

{

my $name = shift;

my @search_paths = @_;

my $found_path;

my $path = `/usr/bin/which $name`;

if ($path =~ /\//) {

chomp $path;

$found_path = $path;

} else {

foreach my $path (@search_paths) {

if (-e $path && -x $path) {

$found_path = $path;

last;

}

if ($found_path) {

print "Found $name at $found_path.\n" if $DEBUG;

} else {

print "Warning: Could not locate $name.\n" if $DEBUG;

}

return $found_path;

}

# Locate paths to the executables we need for optimizations. For each

# one, check the user's path (using 'which'), then try to fall back on

# search paths specified in globals at top of the script.

sub locateBinaries

{

$jpegtran_path = locateBin('jpegtran', @jpegtran_paths);

$pngcrush_path = locateBin('pngcrush', @pngcrush_paths);

$gifsicle_path = locateBin('gifsicle', @gifsicle_paths);

$convert_path = locateBin('convert', @convert_paths);

$identify_path = locateBin('identify', @identify_paths);

if (!$jpegtran_path) {

$do_jpeg_compress = 0;

}

if (!$pngcrush_path) {

$do_png_compress = 0;

}

if (!$gifsicle_path) {

$do_gif_compress = 0;

}

if (!$identify_path || !$convert_path) {

$do_png_compare = 0;

}

sub writeSummary

{

my $total_bytes_orig = $score->{'jpeg_bytes_orig'} + $score->{'png_bytes_orig'} + $score->{'gif_bytes_orig'};

my $total_bytes_saved = $score->{'jpeg_bytes_saved'} + $score->{'png_bytes_saved'} + $score->{'gif_bytes_saved'};

print "\n";

print "----------------------------\n";

print " Summary\n";

print "----------------------------\n";

print "\n";

if ($score->{'gif2png_bytes_saved'}) {

print " Converting the following GIFs to PNG would save additional file size.\n";

print " Bytes saved: $score->{'gif2png_bytes_saved'} "

. "(orig $score->{'gif2png_bytes_orig'}, saved "

. (int($score->{'gif2png_bytes_saved'}/$score->{'gif2png_bytes_orig'}*10000) / 100)

. "%)\n";

print "\n";

foreach my $file (@{$score->{'gif2png_files'}}) {

print " $file\n";

}

print "\n";

}

if ($score->{'jpeg_bytes_orig'}) {

print " Inspected $score->{'jpeg_count'} JPEG files.\n";

print " Modified $score->{'jpeg_modify'} files.\n";

print " Huffman table optimizations: $score->{'jpeg_optimize'}\n";

print " Progressive JPEG optimizations: $score->{'jpeg_progressive'}\n";

print " Bytes saved: $score->{'jpeg_bytes_saved'} "

. "(orig $score->{'jpeg_bytes_orig'}, saved "

. (int($score->{'jpeg_bytes_saved'}/$score->{'jpeg_bytes_orig'}*10000) / 100)

. "%)\n";

print "\n";

}

if ($score->{'png_bytes_orig'}) {

print " Inspected $score->{'png_count'} PNG files.\n";

print " Modified $score->{'png_modify'} files.\n";

print " Bytes saved: $score->{'png_bytes_saved'} "

. "(orig $score->{'png_bytes_orig'}, saved "

. (int($score->{'png_bytes_saved'}/$score->{'png_bytes_orig'}*10000) / 100)

. "%)\n";

print "\n";

}

if ($score->{'gif_bytes_orig'}) {

print " Inspected $score->{'gif_count'} GIF files.\n";

print " Modified $score->{'gif_modify'} files.\n";

print " Bytes saved: $score->{'gif_bytes_saved'} "

. "(orig $score->{'gif_bytes_orig'}, saved "

. (int($score->{'gif_bytes_saved'}/$score->{'gif_bytes_orig'}*10000) / 100)

. "%)\n";

print "\n";

}

print " Total bytes saved: $total_bytes_saved ";

if ($total_bytes_orig) {

print "(orig $total_bytes_orig, saved "

. (int($total_bytes_saved/$total_bytes_orig*10000) / 100)

. "%)";

}

print "\n\n";

}

You can download the wesley.pl script here.

And if you have the perl-Image-ExifTool package installed (yum install perl-Image-ExifTool), you may find my exif-res.sh script useful as well. It can be used to get the resolution of an image, and then run wesley.pl with --copy=none or --copy=add depending on the image size.

$ ./exif-res.sh --help

Syntax: /usr/local/bin/exif-res.sh [--[width|height|size|vars]] {filepaths...}

--width   Print the width of the image
--height  Print the height of the image
--size    Print the width or height of the image - whichever is greater
--vars    Print the width and height as variables that can be eval'ed

Without any command line options, the script prints the width and height (as WxH)

Example: eval `/usr/local/bin/exif-res.sh --vars image.jpg`; echo "$W by $H";

$ ./exif-res.sh --help

Syntax: /usr/local/bin/exif-res.sh [--[width|height|size|vars]] {filepaths...}

--width Print the width of the image

--height Print the height of the image

--size Print the width or height of the image - whichever is greater

--vars Print the width and height as variables that can be eval'ed

Without any command line options, the script prints the width and height (as WxH)

Example: eval `/usr/local/bin/exif-res.sh --vars image.jpg`; echo "$W by $H";

You can download the exif-res.sh script here.

js.

Surnia Ulula

Wesley.pl optimize script for jpeg, png, and gif

Leave a comment Cancel reply

Leave a comment
Cancel reply