Obviously there’s a lot of room for improvement; javascript encoding, representation as an image, and so on… but then it wouldn’t be quick an easy – it’d be slightly longer and just a little more complex.

class Amnuts_View_Helper_EncodeEmail extends Zend_View_Helper_Abstract
{
    /**
     * Return the class on direct calls.
     *
     * @return Amnuts_View_Helper_EncodeEmail
     */
    public function encodeEmail()
    {
        return $this;
    }

    /**
     * Return an encoded email address to help against spam.
     *
     * @param string $address The email address to encode
     * @return string
     */
    public function address($address)
    {
        $xhtml = '';
        $address = (string)$address;
        $len = strlen($address);
        for ($x = 0; $x < $len; $x++) {
            if (preg_match('!\w!', $address[$x])) {
                $xhtml .= '%' . bin2hex($address[$x]);
            } else {
                $xhtml .= $address[$x];
            }
        }
        return $xhtml;
    }

    /**
     * Return an encoded mailto link to help against spam.
     *
     * If no link text is supplied then the email address will be used
     * (as is generally preferred).
     *
     * @param string $address The email address to encode
     * @param null|string $text Text to use for link
     * @param array $attrs Any extra attributes for link
     * @return string
     */
    public function link($address, $text = null, array $attrs = array())
    {
        $encodedtext    = '';
        $encodedaddress = $this->address($address);
        if (null === $text) {
            $text = (string)$address;
        } else {
            $text = (string)$text;
        }
        $len = strlen($text);
        for ($x = 0; $x < $len; $x++) {
            $encodedtext .= '&#x' . bin2hex($text[$x]).';';
        }
        $xhtml = '<a href="&#109;&#97;&#105;&#108;&#116;&#111;&#58;' . $encodedaddress . '"';
        if (!empty($attrs)) {
            foreach ($attrs as $k => $v) {
                $xhtml .= ' ' . $this->view->escape($k) . '="' . $this->view->escape($v) . '"';
            }
        }
        $xhtml .= '>' . $encodedtext . '';
        return $xhtml;
    }
}

< ?php

/**
 * Display a tag cloud
 *
 * @category   Amnuts
 * @package    Amnuts_View
 * @subpackage Amnuts_View_Helper
 * @copyright  Copyright (c) 2008 Andrew Collington (http://www.amnuts.com/)
 * @license    http://framework.zend.com/license/new-bsd     New BSD License
 */
class Amnuts_View_Helper_TagCloud
{
    public $view;

    /**
     * Output the tag cloud.
     *
     * The $tags parameter is expected to be an array with the tag being the
     * index and the number of times it's used as the value.  For example:
     *
     *     array(
     *         'foo' => 3,
     *         'bar' => 1,
     *         'dog' => 5,
     *         'cat' => 1
     *     )
     *
     * The url will have the tag text appended to it, so that if you supply
     * '/filter/by/tag/' as the url, then given the above array you will have:
     *
     *     <a href="/filter/by/tag/foo">foo</a>
     *     <a href="/filter/by/tag/bar">bar</a>
     *
     * and so on.
     *
     * @param array $tags The tag array
     * @param string $url The link for each tag (with the tag name appended)
     * @param int|string $minFont The minimum font value
     * @param int|string $maxFont The maximum font value
     * @param string $unit The unit of size type (%, em, px, etc.)
     * @return string
     */
    public function tagCloud(array $tags, $url, $minFont = 100, $maxFont = 150, $unit = '%')
    {
        $xhtml = '';
        $cloud = array();

        if (!empty($tags)) {
            $min  = min(array_values($tags));
            $max  = max(array_values($tags));
            $diff = $max - $min;
            if (!$diff) {
                ++$diff;
            }

            foreach ($tags as $tag => $count) {
                $size = $minFont + ($count - $min) * ($maxFont - $minFont) / $diff;
                $cloud[] = '<a href="' . $url . urlencode($tag)
                         . '" style="font-size:' . $size . $unit . ';">'
                         . $this->view->escape($tag) . '</a>';
            }
            $xhtml .= '<div class="tagCloudContainer"><h4>Tag cloud</h4>' . join(', ', $cloud) . "</div>\n";
        }
        return $xhtml;
    }

    /**
     * Set the view object
     *
     * @param Zend_View_Interface $view
     */
    public function setView(Zend_View_Interface $view)
    {
        $this->view = $view;
    }
}

?>

But before we get to that, a few caveats:

• It’s just a proof of concept
• The output needs updating for proper reference names, etc.
• Outputs everything to screen in one go and doesn’t save the files.

However, it might be handy to someone, so I post it up for your comments.

< ?php

require_once 'Zend/Loader.php';
Zend_Loader::registerAutoload();

$config = array(
	'host'	 => 'localhost',
	'username' => 'myusername',
	'password' => 'mypassword',
	'dbname'   => 'mydbname'
);
try {
	$db = Zend_Db::factory('pdo_mysql', $config);
} catch (Zend_Db_Exception $e) {
	echo $e->getMessage();
	die;
}

$model = < <<EOT
<?php

class %s extends Zend_Db_Table_Abstract
{
	protected \$_name = '%s';
%s
}
EOT;

$refmap_outer = <<<EOT
	protected \$_referenceMap	= array(
%s
	);
EOT;

$refmap_inner = <<<EOT
		'%s' => array(
			'columns'		   => array('%s'),
			'refTableClass'	 => '%s',
			'refColumns'		=> array('%s')
		)
EOT;

$toTable = new Zend_Filter_Inflector(
	':tbl',
	array(':tbl' => array('Word_CamelCaseToUnderscore', 'StringToLower'))
);

$toClass = new Zend_Filter_Inflector(
	':tbl',
	array(':tbl' => array('StringToLower', 'Word_UnderscoreToCamelCase'))
);

foreach ($db->listTables() as $table) {
	$sql = "
		select
			tc.constraint_name,
			kcu.table_name,
			kcu.column_name,
			kcu.referenced_table_name,
			kcu.referenced_column_name
		from
			information_schema.table_constraints tc,
			information_schema.key_column_usage kcu
		where
			tc.table_name = " . $db->quote($table) . "
			and tc.constraint_type = 'FOREIGN KEY'
			and kcu.constraint_name = tc.constraint_name
		";
	$keys = $db->fetchAll($sql);

	$refs = array();
	if (!empty($keys)) {
		$r = 0;
		foreach ($keys as $key) {
			$refs[] = sprintf($refmap_inner,
					'ref' . ++$r,
					$key['column_name'],
					$toClass->filter(array('tbl' => $key['referenced_table_name'])),
					$key['referenced_column_name']
				);
		}
	}
	printf($model,
		$toClass->filter(array('tbl' => $table)),
		$toTable->filter(array('tbl' => $table)),
		(!empty($refs) ? sprintf($refmap_outer, join(",\n", $refs)) : '')
	);
}

So assuming I had a database structure like:

--
-- Table structure for table `users`
--
CREATE TABLE `users` (
  `id` int(10) UNSIGNED NOT NULL AUTO_INCREMENT,
  `added` datetime NOT NULL,
  `username` varchar(32) NOT NULL,
  `password` varchar(64) NOT NULL,
  `name_first` varchar(32) NOT NULL,
  `name_last` varchar(32) NOT NULL,
  `name_nick` varchar(32) NOT NULL,
  PRIMARY KEY  (`id`),
  KEY `username` (`username`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;
-- --------------------------------------------------------
--
-- Table structure for table `user_tags`
--
CREATE TABLE `user_tags` (
  `id` int(10) UNSIGNED NOT NULL AUTO_INCREMENT,
  `user_id` int(10) UNSIGNED NOT NULL,
  `tag_user_id` int(10) UNSIGNED NOT NULL,
  `tag` varchar(24) NOT NULL,
  PRIMARY KEY  (`id`),
  KEY `tag` (`tag`),
  KEY `fk_user_tags_user_id` (`user_id`),
  KEY `fk_user_tags_tag_user_id` (`tag_user_id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;
--
-- Constraints for table `user_tags`
--
ALTER TABLE `user_tags`
  ADD CONSTRAINT `fk_user_tags_user_id` FOREIGN KEY (`user_id`) REFERENCES `users` (`id`) ON DELETE NO ACTION ON UPDATE NO ACTION,
  ADD CONSTRAINT `fk_user_tags_tag_user_id` FOREIGN KEY (`tag_user_id`) REFERENCES `users` (`id`) ON DELETE NO ACTION ON UPDATE NO ACTION;

it would output something like:

< ?php

class UserTags extends Zend_Db_Table_Abstract
{
	protected $_name = 'user_tags';
	protected $_referenceMap	= array(
		'ref1' => array(
			'columns'		   => array('user_id'),
			'refTableClass'	 => 'Users',
			'refColumns'		=> array('id')
		),
		'ref2' => array(
			'columns'		   => array('tag_user_id'),
			'refTableClass'	 => 'Users',
			'refColumns'		=> array('id')
		)
	);
}

<?php

class Users extends Zend_Db_Table_Abstract
{
	protected $_name = 'users';
}

/**
 * Force a file download via HTTP.
 *
 * File is required to be on the same server and accessible via a path.
 * If the file cannot be found or some other error occurs then a
 * '204 No content' header is sent.
 *
 * @param string $path Path and file name
 * @param string $name Name of file when saved on user's computer,
 *                     null for basename from path
 * @param string $type Content type header info (e.g., 'application/vnd.ms-excel')
 * @return void
 * @access public
 */
/* public static */ function download($path, $name = null, $type = 'binary/octet-stream')
{
    if (headers_sent()) {
        echo 'File download failure: HTTP headers have already been sent and cannot be changed.';
        exit;
    }

    $path = realpath($path);
    if ($path === false || !is_file($path) || !is_readable($path)) {
        header('HTTP/1.0 204 No Content');
        exit;
    }

    $name = (empty($name)) ? basename($path) : $name;
    $size = filesize($path);

    header('Expires: Mon, 20 May 1974 23:58:00 GMT');
    header('Last-Modified: ' . gmdate('D, d M Y H:i:s') . ' GMT');
    header('Cache-Control: no-store, no-cache, must-revalidate');
    header('Cache-Control: post-check=0, pre-check=0', false);
    header('Cache-Control: private');
    header('Pragma: no-cache');
    header("Content-Transfer-Encoding: binary");
    header("Content-type: {$type}");
    header("Content-length: {$size}");
    header("Content-disposition: attachment; filename=\"{$name}\"");
    readfile($path);
    exit;
}

Very easy to use, too! Here are some examples of how you might call the function:

download('./myfile.txt');

download(__FILE__, 'a file for you.php');

download('/home/you/files/spreadsheet.xml', 'ssheet_' . date('Ymd'), 'application/vnd.ms-excel');

< ?php

class Zend_View_Helper_Img
{
    public $view;
    protected static $_baseurl = null;
    protected static $_cache = null;

    /**
     * Constructor
     */
    public function __construct()
    {
        if (null === self::$_baseurl) {
            $url = Zend_Controller_Front::getInstance()->getRequest()->getBaseUrl();
            $root = '/' . trim($url, '/');
            if ('/' == $root) {
                $root = '';
            }
            self::$_baseurl = $root . '/';
        }
    }

    /**
     * Output the <img /> tag
     *
     * @param string $path
     * @param array $params
     * @return string
     */
    public function img($path, $params = array())
    {
        $plist = array();
        $paramstr = null;
        $imagepath = self::$_baseurl . ltrim($path, '/');
        if (!isset(self::$_cache[$path])) {
            self::$_cache[$path] = file_exists(realpath($_SERVER['DOCUMENT_ROOT'] . '/' . $imagepath));
        }
        if (!isset($params['alt'])) {
            $params['alt'] = '';
        }
        foreach ($params as $param => $value) {
            $plist[] = $param . '="' . $this->view->escape($value) . '"';
        }
        $paramstr = ' ' . join(' ', $plist);
        return '<img src="' .
                ((self::$_cache[$path])
                    ? self::$_baseurl . ltrim($path, '/')
                    : 'data:image/gif;base64,R0lGODlhFAAUAIAAAAAAAP///yH5BAAAAAAALAAAAAAUABQAAAI5jI+pywv4DJiMyovTi1srHnTQd1BRSaKh6rHT2cTyHJqnVcPcDWZgJ0oBV7sb5jc6KldHUytHi0oLADs=') .
                '"' . $paramstr . ' />';
    }

    /**
     * Set the view object
     *
     * @param Zend_View_Interface $view
     * @return void
     */
    public function setView(Zend_View_Interface $view)
    {
        $this->view = $view;
    }
}

Usage is really easy:

< ?php echo $this->img('/images/logo.png', array('id' => 'logo', 'title' => 'Cool Company')); ?>

So here is a class that will allow you to do all that in one easy method call:

<?php

define('EMAILCHECK_INVALID_ADDRESS', 0);
define('EMAILCHECK_INVALID_DNS_MX',  1);
define('EMAILCHECK_INVALID_DNS_A',   2);
define('EMAILCHECK_GUESS_THRESHOLD', 80);

class MailCheck
{
    /**
     * Validate an email address format against RFC822 specs.
     *
     * This method will check an email address against the RFC822 specs, as
     * well as validating the MX record if required.  Optionally you can have
     * the email address route portion return (rather than the boolean true
     * value).  This can be handy if you have an email address such as:
     *
     *    "Andrew Collington & Co." <a.collington@example.org>
     *
     * and you just want to use the actual address portion.  By default the
     * method will return true/false else route/false.
     *
     * Adapted from PHP code (Changes (c) 2005 Padraic Brady) which is a
     * translation of Perl code (Copyright 1997 O'Reilly & Associates, Inc.).
     *
     * Based on optimised email regex in Perl Copyright 1997 O'Reilly &
     * Associates, Inc. The "Mastering Regular Expressions" Email Regex
     * (from book on page 295 et seq).
     *
     * @param string $email The email address to validate
     * @param boolean $checkmx Check the MX Record if $email is valid
     * @return bool|string
     * @access public
     * @see <http://www.faqs.org/rfcs/rfc822.html>
     * @see <http://examples.oreilly.com/regex/email-opt.pl>
     */
    public static function format($email, $checkmx = false, $returnroute = false)
    {
        // Some things for avoiding backslashitis later on.
        $esc        = '\\\\';               $Period      = '\.';
        $space      = '\040';               $tab         = '\t';
        $OpenBR     = '\[';                 $CloseBR     = '\]';
        $OpenParen  = '\(';                 $CloseParen  = '\)';
        $NonASCII   = '\x80-\xff';          $ctrl        = '\000-\037';
        $CRlist     = '\n\015';  // note: this should really be only \015.

        // Items 19, 20, 21
        $qtext = "[^{$esc}{$NonASCII}{$CRlist}\"]";
        $dtext = "[^{$esc}{$NonASCII}{$CRlist}{$OpenBR}{$CloseBR}]";
        $quoted_pair = " {$esc} [^{$NonASCII}] ";

        // Items 22 and 23, comment.
        // Impossible to do properly with a regex, I make do by allowing at most one level of nesting.
        $ctext = " [^{$esc}{$NonASCII}{$CRlist}()] ";

        // $Cnested matches one non-nested comment.
        // It is unrolled, with normal of $ctext, special of $quoted_pair.
        $Cnested = "{$OpenParen}{$ctext}*(?: {$quoted_pair} {$ctext}* )*{$CloseParen}";

        // $comment allows one level of nested parentheses
        // It is unrolled, with normal of $ctext, special of ($quoted_pair|$Cnested)
        $comment = "{$OpenParen}{$ctext}*(?:(?: {$quoted_pair} | {$Cnested} ){$ctext}*)*{$CloseParen}";

        // $X is optional whitespace/comments.
        // Nab whitespace.  If comment found, allow more spaces.
        $X = "[{$space}{$tab}]*(?: {$comment} [{$space}{$tab}]* )*";

        // Item 10: atom
        $atom_char   = "[^($space)<>\@,;:\".$esc$OpenBR$CloseBR$ctrl$NonASCII]";
        // some number of atom characters not followed by something that could be part of an atom
        $atom = "{$atom_char}+(?!{$atom_char})";

        // Item 11: doublequoted string, unrolled.
        $quoted_str = "\"{$qtext} *(?: {$quoted_pair} {$qtext} * )*\"";

        // Item 7: word is an atom or quoted string
        $word = "(?:{$atom}|{$quoted_str})";

        // Item 12: domain-ref is just an atom
        $domain_ref = $atom;

        // Item 13: domain-literal is like a quoted string, but [...] instead of  "..."
        $domain_lit  = "{$OpenBR}(?: {$dtext} | {$quoted_pair} )*{$CloseBR}";

        // Item 9: sub-domain is a domain-ref or domain-literal
        $sub_domain  = "(?:{$domain_ref}|{$domain_lit}){$X}";

        // Item 6: domain is a list of subdomains separated by dots.
        $domain = "{$sub_domain}(?:{$Period} {$X} {$sub_domain})*";

        // Item 8: a route. A bunch of "@ $domain" separated by commas, followed by a colon.
        $route = "\@ {$X} {$domain}(?: , {$X} \@ {$X} {$domain} )*:{$X}";

        // Item 6: local-part is a bunch of $word separated by periods
        $local_part = "{$word} {$X}(?:{$Period} {$X} {$word} {$X})*";

        // Item 2: addr-spec is local@domain
        $addr_spec  = "{$local_part} \@ {$X} {$domain}";

        // Item 4: route-addr is <route? addr-spec>
        // parenthases around the route_addr to capture this in the final regexpr
        $route_addr = "< ({$X}(?: {$route} )?{$addr_spec})>";

        // Item 3: phrase... like ctrl, but without tab
        $phrase_ctrl = '\000-\010\012-\037';

        // Like atom-char, but without listing space, and uses phrase_ctrl.
        // Since the class is negated, this matches the same as atom-char plus space and tab
        $phrase_char = "[^()<>\@,;:\".{$esc}{$OpenBR}{$CloseBR}{$NonASCII}{$phrase_ctrl}]";

        // We've worked it so that $word, $comment, and $quoted_str to not consume trailing $X
        // because we take care of it manually.
        $phrase = "{$word}{$phrase_char} *(?:(?: {$comment} | {$quoted_str} ){$phrase_char} *)*";

        // Item #1: mailbox is an addr_spec or a phrase/route_addr
        $mailbox = "{$X}(?:{$addr_spec}|{$phrase}  ({$route_addr}))";

        // perform actual regex check to our recieved email address
        $matches = array();
        $isValid = preg_match('/^'.$mailbox.'$/xS', $email, $matches);
        $route = $matches[count($matches) - 1];

        // check the MX Record is needs be
        if ($isValid && $checkmx) {
            list(, $host) = explode('@', $route);
            return (@checkdnsrr($host, 'MX')) ? (($returnroute) ? $route : true) : false;
        }

        // finally return status
        return ($isValid && $returnroute) ? $route : $isValid;
    }

    /**
     * Check email addresses for validity
     *
     * You can pass either a string of an array of strings.  The string
     * contains the email address you want to check.  The method will check
     * that the format is valid and then check the A and MX record.  If
     * either the A or MX record fail then it will attempt to make some
     * suggestions of popular email hosts.
     *
     * @param string|array $email Email address of array of email addresses
     * @return array
     * @access public
     */
    public static function address($email)
    {
        // default metaphone conversions
        $mphones = array(
            'ALKK'     => 'aol.co.uk',
            'ALKM'     => 'aol.com',
            'EKSMPLKM' => 'example.com',
            'HTMLKK'   => 'hotmail.co.uk',
            'HTMLKM'   => 'hotmail.com',
            'KKLMLKM'  => 'googlemail.com',
            'KMLKM'    => 'gmail.com',
            'MSNKK'    => 'msn.co.uk',
            'MSNKM'    => 'msn.com',
            'YHKK'     => 'yahoo.co.uk',
            'YHKM'     => 'yahoo.com'
        );
        $emails = $suggestions = array();

        // validate email address format
        if (is_array($email)) {
            $email = array_unique($email);
            foreach ($email as $e) {
                $route = self::format($e, false, true);
                if (!$route) {
                    $emails[$e]['error'][EMAILCHECK_INVALID_ADDRESS] = true;
                } else {
                    list($emails[$e]['user'], $emails[$e]['domain']) = explode('@', $route);
                }
            }
        } else {
            $route = self::format($email, false, true);
            if (!$route) {
                $emails[$email]['error'] = EMAILCHECK_INVALID_ADDRESS;
            } else {
                list($emails[$email]['user'], $emails[$email]['domain']) = explode('@', $route);
            }
        }

        // check domains
        foreach ($emails as $orig => $e) {
            if ($e['domain']) {
                if (empty($e['error'])) {
                    $valid = checkdnsrr($e['domain'], 'MX');
                    if (!$valid) {
                        $emails[$orig]['error'][EMAILCHECK_INVALID_DNS_MX] = true;
                    }
                }
                if (empty($e['error'])) {
                    $valid = checkdnsrr($e['domain'], 'A');
                    if (!$valid) {
                        $emails[$orig]['error'][EMAILCHECK_INVALID_DNS_A] = true;
                    }
                }
                // failing anything, get suggestions
                if (!empty($emails[$orig]['error']) && !isset($e['error'][EMAILCHECK_INVALID_ADDRESS])) {
                    $emeta = metaphone($e['domain']);
                    $suggestions = array();
                    foreach ($mphones as $code => $addr) {
                        $percent = 0;
                        $lev = levenshtein($emeta, $code);
                        $sim = similar_text($emeta, $code, $percent);
                        $score = round($percent + max(-$lev + $sim, 0));
                        if ($score >= EMAILCHECK_GUESS_THRESHOLD) {
                            $suggestions[$addr] = $score;
                        }
                    }
                    if (!empty($suggestions)) {
                        arsort($suggestions);
                        $emails[$orig]['suggestion'] = array_keys($suggestions);
                    }
                }
            }
        }

        // send back results
        return $emails;
    }
}

?>

If I call it like this:

$validate = MailCheck::address('example@yahooo.co');
print_r($validate);

I will get the following returned:

Array
(
    [example@yahooo.co] => Array
        (
            [domain] => yahooo.co
            [user] => example
            [error] => Array
                (
                    [1] => 1
                    [2] => 1
                )
            [suggestion] => Array
                (
                    [0] => yahoo.com
                    [1] => yahoo.co.uk
                )
        )
)

Which is basically saying that while the address example@yahooo.co is a valid format, the domain yahooo.co doesn’t have a valid MX or A record, and it thinks that perhaps the user meant to use yahoo.com or yahoo.co.uk.

The address method can take an array of email addresses as well as a single string.

A further example of use is:

<?php

require('MailCheck.php');
$valid = MailCheck::address(array('user1@yahoo.com', 'user2@somethingmadeup.com', 'user3 is wrong'));
foreach ($valid as $address => $status) {
    echo $address, ' is ', (empty($status['error'])) ? 'valid' : 'not valid', "<br />\n";
}

?>

Which echos:

user1@yahoo.com is valid
user2@somethingmadeup.com is not valid
user3 is wrong is not valid

svnlook tree --full-paths /home/path/to/svn/project | \
egrep -a '/?tags/.+' | \
sed -re 's!.*/?tags/([^/]*).*!\1!' | \
sort -u

Looking at sites like YouTube, you may think it’s quite hard to create a lot of different thumbnails from video files, and have them from random times within that file. But, no, it’s not! As this article shows, by using the very fabulous FFmpeg library, it’s actually a very short amount of code that’s required to create all those lovely random thumbnails.

First a little information about FFmpeg. If you haven’t come across this yet then you’re missing out on an excellent bit of software to put in your tool kit. It can convert and stream all manner of video and audio files, is open source (under LGPL, but with some optional GPL bits), and is always being worked on and developed.

FFmpeg’s homepage is at http://ffmpeg.mplayerhq.hu/, where you can grab the latest revision from SVN. If you want it for Windows, then one location I found with quite recent builds is http://ffdshow.faireal.net/mirror/ffmpeg/, but if you know any better ones then let me know.

So on with the code…

<?php

// where ffmpeg is located, such as /usr/sbin/ffmpeg
$ffmpeg = 'ffmpeg';

// the input video file
$video  = dirname(__FILE__) . '/demo.mpg';

// where you'll save the image
$image  = dirname(__FILE__) . '/demo.jpg';

// default time to get the image
$second = 1;

// get the duration and a random place within that
$cmd = "$ffmpeg -i $video 2>&1";
if (preg_match('/Duration: ((\d+):(\d+):(\d+))/s', `$cmd`, $time)) {
    $total = ($time[2] * 3600) + ($time[3] * 60) + $time[4];
    $second = rand(1, ($total - 1));
}

// get the screenshot
$cmd = "$ffmpeg -i $video -deinterlace -an -ss $second -t 00:00:01 -r 1 -y -vcodec mjpeg -f mjpeg $image 2>&1";
$return = `$cmd`;

// done! 
echo 'done!';

?>

Nice and short, and that’s even with me being generous over white space!

The two key portions in this code are the ones to get the random time location of the video, which we do by parsing the output from a call to ffmpeg, and then running another command to generate the image.

When running the first command it’s important to remember the 2>&1 to redirect the stderr to stdout, as it’s actually an error message we want to capture. To be on the safe side, I simple add it to all my command line calls to FFmpeg (which in this example is only two!)

Now that you have your thumbnail image you may be thinking that you need to use GD, ImageMagick, or some other graphics library to resize the image, right? Well, you could, if you wanted to, but you could also do it in the very same command line to create the thumbnail! Basically, you’d use the -s flag to resize the thumbnail. For example:

$cmd = "$ffmpeg -i $video -deinterlace -an -ss $second -t 00:00:01 -r 1 -y -s 320x240 -vcodec mjpeg -f mjpeg $image 2>&1";

You may also notice the -deinterlace flag in there. You may not need this – it depends on whether you video file needs deinterlacing or not. All of the flags are detailed in the FFmpeg documentation.

Oh, and if you’re taking user input for the video file or output image file, then please remember to escape your variables accordingly! Use something like the escapeshellcmd() PHP function.

Have fun grabbing your video frames!!

function registration_key()
{
    return strtoupper(substr(chunk_split(sprintf('%03d%s',
                      rand(0,999), uniqid('')), 4, '-'), 0, -1));
}

function valid_uk_postcode($postcode)
{
    return (preg_match('/^([A-PR-UWYZ][A-HK-Y0-9][AEHMNPRTVXY0-9]?[ABEHMNPRVWXY0-9]? {0,2}[0-9][ABD-HJLN-UW-Z]{2}|GIR 0AA)$/i', $postcode)) ?
        true : false;
}