Introducing http://roadjunkyguides.com - a project i developed with friends.

The website is based on WordPress as a CMS and a 100% custom made frontend. The website does not use the official DISQUS WP Plugin since it does not have the features we were looking for and also has some poor implementation for the wp plugin. The commenting syncing is not very convincing. it features a two way sync which i dont see necessary at all. Either you sync from a -> b or b -> a but not a <-> b. There seem to be a lot of people complaining about lost comments and so on. Here as some negative points:

• two way sync produces more errors and not really needed
• it does not update comment details when edited in dsq client or wp backend
• poor error handling
• no error/event/sync logging

In our case we needed a fast and realiable mirroring of all the comments from DISQUS an WP serving as a slave only. Also we needed a true reflection on every change on a comment/thread/profile or whatever (even when an author updates his profile url). So in the end we developed our own implementation of a dsq wp plugin based on a PHP5 class structure for bridging and syncing the comments.

With the comments in sync we have a server side representation of all comments for search, editors picks, and SEO harvest. The service but has more to it. We played around with the DISQUS Client and added some cool features:

• Identify admins/moderators based on the DSQ request/response object and event handlers + storing profile properties server side in PHP session
• Enabling the DISQUS highlight feature as a way to flag and harvest valuable comments
• Trigger DISQUS sync on new post event
• Bridge highlighted post to twitter account on highlight event in client
• Facebook compatible DISQUS Widget for canvas apps
• unhighlight comments from wp
• and many more features …

Some of the features exploited were probably not intended to be used like this by the DISQUS developers but a mashup is a mashup – no rules apply. The best thing is that the DISQUS Client and/or the widget wrapping it can be hooked into any other website to harvest comments = content. It works flawless in facebook also replacing the facebook wall as a canvas app – HA!!! Im so excited to see if it works the way it is intended to … it has been just released BETA yesterday.

If the service runs stable im thinking of rolling out the DISQUS comment sync as a wp plugin for all those who do not like the official plugin and hardcode the client into their posts, pages or implemented them in their templates. lets see …

Type: Travel guide
Founded: 2012
Website: http://roadjunkyguides.com

About:
Roadjunkyguides is a true love job – based on the idea that only real travelers can provide content for a off-the-beaten-track guide. The usual online and print guides are based on the knowledge of a few or only see a certain side of a country/place for example. Many printed guides are also outdated in the moment they are released since the small but valuable tips/tricks may not be valid anymore. As seen in the Lonely Planet scandal you can not even trust editors since many of them will write on the basis of hearsay and third party information.

The idea behind Roadjunkyguides is simple as is: let the travelers write their own guidebook. To seed quality content moderators will pick valuable posts for the editors pick section so the quality content can be aggregated to a downloadable guide later on. The Roadjunky network has been around for years and has a large group of followers. With Roadjunkguides we hope to bridge the gap between informational travel websites and user generated travel content.

Website:
The webpage has been set up in WP. The template used is 100% custom made as the many function/plugins used. The heart of the website is the DISQUS commenting system which does not work as a usual blog comment system, but as the actual post/content. The website makes heavy use of the DISQUS API and a custom written wp/dsq plugin takes care of the syncing between the two. A DISQUS widget has been created to be computable as a facebook canvas app so a comment/content thread can be used inside facebook to harvest content. In due time the plan is to roll out distributable widgets, so users can plug a widget into their website to show latest entries and even post directly from there. Coding the website and DISQUS functionality has been real fun. See more about the technology used here: WordPress + Facebook + DISQUS mashup deluxe

Type: Social/Event Club
Founded: 2011
Location: Granada, Spain
Website: http://mysala.es

About:
Since long time it has been a dream to find a place to a) work and b) occasionally host and do events of various types. In its form it could be called a project place or creative hub because in daytime freelancers of different disciplines work side by side – after work the place changes into a creative space where a lot of different events are hosted. The place has about 120 sqm and has two rooms of 60 and 40 sqm. All the furniture is compact and movable in order to rapidly change according to the need the rooms have to provide. Since its opening in October 2011, we hosted over 15 different events already.

Website:
The webpage has been done in WordPress and the wonderful organic structure themes from: http://www.organicthemes.com/themes/structure-theme/. It has been customized and optimized to suit our needs. We also use the Tribulant newsletter plugin for communication which is probably the only one for wordpress that really works.

If you want to keep control of the sync up to the last bit then i am at least not aware of any linux library the gives you full control over the process, logging, test running and so on. Since in one of my projects we needed to find a way to sync multiple servers via a XML configuration file which is created via an admin panel. Since PHP already includes everything needed for a syncing content i set up a sync script which will copy content from one server to another by using PHPs built in sftp functions. Both servers run SSH with passwords so it was rather easy to sync the two. A ssh connections based on keys is also possible but in this case we didnt bother in the first version of the script. When using PHP as a basis for such a script you will not miss anything that a local client like Transmit or FileZilla would also do. The features in the current built:

• compare by date or file size
• skip files by extension, name or folder
• exclude folders and subfolders
• sync only files since modified date
• set global chmod value for all files
• resync by looking for abandond files
• define multiple sync jobs in on .xml configuration file
• run in test modus to output/logfile sync logs before running live

The script will only run on PHP > 5.3 and cli command line on Linux and needs SSH2 installed. Its is known that PHPs SSH2 lib is not running stable under each environment. I can not say if its true but the difficulties that came up where in connection with the most crucial part of the script – copying the files and setting the permission. In the end none but the “ssh2_scp_send” function really worked. All other wrapper methods did not work in the sense that you can not copy a file and change its permission in one shot since the copy action is a asynchronous event and will not report back once copied. The only function that does so is “ssh2_scp_send“.

There are many things that can be of course optimized like: auth with ssh keys, plain ftp support, .. but for a first launch it works as expected. You can find the script here: https://github.com/setcooki/syncd

You need to install 7-zip first – see docs for more. once installed you should read the command line documentation since there are some important flags you should understand. The following script makes a mysql dump with optional conditions, stores the dump first in a .sql dump file, zips the file 7-zip pass protected, removes the original temporary .sql dump file and writes out/err stream to dump log file.

 '.$your_path_to_sql_dump.'.sql';
$cmd[] = '&& 7za a -t7z -mx9 -p'.$your_7zip_pass.' '.$your_path_to_7z_file.'.7z '.$your_path_to_sql_dump.'.sql';
$cmd[] = '&& rm '.$your_path_to_sql_dump.'.sql';
$cmd[] = '>> '.$your_path_to_log_file.'-dump.log 2>&1';

if(($proc = proc_open(trim(implode(" ", $cmd)), array(0 => array('pipe', 'r'), 1 => array('pipe', 'w'), 2 => array('pipe', 'w')), $pipes)) !== false)
{
	if(($stdout = stream_get_contents($pipes[1])) === false)
	{
		die("unable open stdout stream");
	}
	if(($stderr = stream_get_contents($pipes[2])) === false)
	{
		die("unable open stderr stream");
	}
	if(!@fclose($pipes[1]))
	{
		die("unable to close stdout stream");
	}
	if(!@fclose($pipes[2]))
	{
		die("unable to close stderr stream");
	}
	if(($res = (int)proc_close($proc)) === -1)
	{
		die("unable to close process");
	}
	if(!empty($stderr))
	{
		die("unable to dump backup, code: $res, error: $stderr");
	}
    echo $stdout;
}else{
	die("unable to execute command");
}

?>

In detail: the line:

“7za a -t7z -mx9 -p’.$your_7zip_pass.’ ‘.$your_path_to_7z_file.’.7z ‘.$your_path_to_sql_dump.’.sql’”

tells 7-zip to make an archive using the standard 7z format and the highest compression ratio. The password is set with the -p switch. The -p with no value will prompt your for an password if called from the shell btw. You can tweak around to see what suits you the best. I had problems with the .tgzip format throwing errors on my server. The 7z format seems to be stable.

7-zip is not the only alternative! You can also use TAR and: http://loop-aes.sourceforge.net/aespipe/ to make an archive and pipe the stream directly into aespipe to encrypt the dump AES 256 Bit. Change the line for 7-zip into:

“&& tar -cvf ‘.$your_path_to_tar_file. ‘.tar.aes -C ‘.$path.’ –use-compress-program=/usr/local/bin/bz2aespipe ‘.$file.’.sql”

The -C switch changes directory to the path where the .sql dump file and the tar is located. the “–use-compress-programm” flag will pipe the tar stream into a wrapper for aespipe which i found somethere (look for bz2aespipe). its content is defined as:

#! /bin/sh

# FILE FORMAT
# 10 bytes: constant string 'bz2aespipe'
# 10 bytes: itercountk digits
# 1 byte: '0' = AES128, '1' = AES192, '2' = AES256
# 1 byte: '0' = SHA256, '1' = SHA384, '2' = SHA512, '3' = RMD160
# 24 bytes: random seed string
# remaining bytes are bzip2 compressed and aespipe encrypted

# These definitions are only used when encrypting.
# Decryption will autodetect these definitions from archive.
ENCRYPTION=AES256
HASHFUNC=SHA256
ITERCOUNTK=100
WAITSECONDS=10
PWDFILE=/usr/local/bin/aespipe.pwd

if test x$1 = x-d ; then
    # decrypt
    n=`head -c 10 - | tr -d -c 0-9a-zA-Z`
    if test x${n} != xbz2aespipe ; then
        echo "bz2aespipe: wrong magic - aborted" >/dev/tty
        exit 1
    fi
    itercountk=`head -c 10 - | tr -d -c 0-9`
    if test x${itercountk} = x ; then itercountk=0; fi
    n=`head -c 1 - | tr -d -c 0-9`
    encryption=AES128
    if test x${n} = x1 ; then encryption=AES192; fi
    if test x${n} = x2 ; then encryption=AES256; fi
    n=`head -c 1 - | tr -d -c 0-9`
    hashfunc=SHA256
    if test x${n} = x1 ; then hashfunc=SHA384; fi
    if test x${n} = x2 ; then hashfunc=SHA512; fi
    if test x${n} = x3 ; then hashfunc=RMD160; fi
    seedstr=`head -c 24 - | tr -d -c 0-9a-zA-Z+/`
    aespipe -e ${encryption} -H ${hashfunc} -S "${seedstr}" -C ${itercountk} -d | bzip2 -d -q
else
    # encrypt
    echo -n bz2aespipe
    echo ${ITERCOUNTK} | awk '{printf "%10u", $1;}'
    n=`echo ${ENCRYPTION} | tr -d -c 0-9`
    aesstr=0
    if test x${n} = x192 ; then aesstr=1; fi
    if test x${n} = x256 ; then aesstr=2; fi
    n=`echo ${HASHFUNC} | tr -d -c 0-9`
    hashstr=0
    if test x${n} = x384 ; then hashstr=1; fi
    if test x${n} = x512 ; then hashstr=2; fi
    if test x${n} = x160 ; then hashstr=3; fi
    seedstr=`head -c 18 /dev/urandom | uuencode -m - | head -n 2 | tail -n 1`
    echo -n ${aesstr}${hashstr}${seedstr}
    bzip2 | aespipe -e ${ENCRYPTION} -H ${HASHFUNC} -S ${seedstr} -P ${PWDFILE} -C ${ITERCOUNTK} -T -w ${WAITSECONDS}
fi
exit 0

Note the line “PWDFILE=/usr/local/bin/aespipe.pwd” here you must store your password so your are not asked for one and the encrypting will run automatically. I tried the encrypting and decrypting and had no problems. I can not really say if aespipe runs stable or not because in the end i preferred 7-zip with backups stored on a different server via ssh2/sftp and a jail rooted user account.

Both are valid options and a consideration when wanting to have at least some sort of security.

For some the player simply wont do nothing since the credentials (S3 Access Keys) are not valid once passed via GET to PHP file responsible for outputting the .xml string for the Dewplayer. See comments at the developer website for more (http://www.isimpledesign.co.uk/blog/amazon-s3-music-player-mp3-player-audio-player). Also, and this i find a major drawback, it only lets you put one instance of the player across your whole blog. So if you want have multiple instances – here is what you have to do and tweak:

1. Install the PHP Exec plugin (http://wordpress.org/extend/plugins/exec-php/) so you can put php code directly into your post or page
2. Install the iSimpleDesign plugin and enter your credentials in the backend (leave folder blank!)
3. Open the file “amazon-s3-player.php” in the “isimpledesign-amazon-s3-music-player-plugin” plugin folder and change the following code:

   // Base function
   function isd_s3player($_folder = null) {
   
   // Plugin Url
   $s3url = WP_PLUGIN_URL.'/'.str_replace(basename( __FILE__),"",plugin_basename(__FILE__));
   
   $amazon_key	= get_option("isd-amazon_key");
   $amazon_secret_key	= get_option("isd-amazon_secret_key");
   $bucket	= get_option("isd-bucket");
   if($_folder !== null)
   {
       $folder	= $_folder;
   }else{
       $folder	= get_option("isd-folder");
   }
   
   $test = $amazon_key."-".$amazon_secret_key."-".$bucket."-".$folder;
   
   ....

   this lets you pass a folder name to the php function responsible for generating the playlist .xml list.

4. then open the file “playlist.php” and exchange the following code in the top of the file:

   $bucket	= $_GET["name"];
   $store = explode("-", $bucket);
   if(!empty($store[3]))
   {
       $store[3] = rtrim($store[3], "/") . "/";
   }...

   this is to make sure that we always have a backslash at the end of the folder name. we can now pass the folder name to the player and use multiple instances in the same post or blog.

5. finally you can use the php function isd_s3player() in your post or page to use multiple instances accross your blog or even post by simple pasting the function with php code directly into the wysiwyg editor like:

   All you need to do is pass the folder name as first parameter of the function et voila.

So you could say that only a small backslash did the trick … Further tweaks could be including a ID3 Parser and extending the configuration so Dewplayer properties can also be controlled from backend.

Hope it helps somebody

by using the linux lib http://www.pdflabs.com/tools/pdftk-the-pdf-toolkit/ you can use the following command to write a bookmark structure from a PDF to a .txt file

pdftk /tmp/bookmark.pdf dump_data output /tmp/report.txt

Use the known PHP exec(), system() commands to execute the command. The result looks like:

 InfoKey: Creator
InfoValue: Writer
InfoKey: Producer
InfoValue: OpenOffice.org 3.3
InfoKey: Author
InfoValue: setcookie
InfoKey: CreationDate
InfoValue: D:20110527153051+02'00'
PdfID0: 51d2362ea610d06bd86af64d44b4f
PdfID1: 51d2362ea610d06bd86af64d44b4f
NumberOfPages: 66
BookmarkTitle: 1 Vorwort
BookmarkLevel: 1
BookmarkPageNumber: 4
BookmarkTitle: 2 Versionen / Historie
BookmarkLevel: 1
BookmarkPageNumber: 4
BookmarkTitle: 3 Allgemein
BookmarkLevel: 1
BookmarkPageNumber: 5
BookmarkTitle: 4 Gateway URL
BookmarkLevel: 1
BookmarkPageNumber: 5
BookmarkTitle: 5 Globale Parameter
BookmarkLevel: 1
BookmarkPageNumber: 5
....

The result can be parsed into a nested array to iterate of the depths of the structure to split the PDF or use the structure for a Bookmark preview in a JS/AS 3 PDF Viewer.
You should be able to redirect the stdout to gain direct access to the output with PHP rather than writing the report file first. In conjunction with SWFTools a whole PDF > Flash converter can be build.
All OpenSource so need to install PDFLib or whatever.

Good luck

This will only work on Linux as you need the sOx Soundexchange Library http://sox.sourceforge.net/ and Lame http://lame.sourceforge.net/. Make sure you have the right versions for your environment installed as the wrong setup will not be stable. For installation – see installation guides on the project websites. Once you have everything up and running you should specify your needs and create a runtime routine for rendering audio on-the-fly.

If you want to mix/merg single audio snippets into a single exportable .mp3 file you should first consider that every step will a) consume ram/cpu time b) needs validation since a failure will effect the whole rendering process. The only performant way of processing multiple render task is to work with a background daemon as running process to manage the cue of rendering task.

You may want to use the following PEAR class http://kevin.vanzonneveld.net/techblog/article/create_daemons_in_php/ which has turned out to be quite stable handling a constant load in production environment. The following approach worked well on a web application handling thousands of jobs a day.

1. Prepare and organize your source audio files as .wav in 16-bit 44 Khz (Make sure each file is normalized and starts exactly at 0 sample length)
2. Create a PHP class structure for representation of the audio files, its properties, eventually breaking down songs, into tracks, segments and parts, represented each by a class so a song track contain segments and a segment can contain parts
3. if you want to mix sound channels you should make that the base class so each channel can be bounced later as well
4. Create a job class which can recieve the necessary commands for all audio task, which can be serialized and stored in a database for the deamon to pickup a new job once available
5. Organize all audio task in classes/or plugins that execute the commands
6. The deamon itsself should trigger the rendering process and execute all commands in a loop until the last step exporting the final audio file to mp3

protected function getSampleLength($bpm = null, $bars = null, $clock = 4, $rate = 44100)
    {
        $timelength = null;
        $samplelength = null;
        if($bpm !== null && $bars !== null)
        {
            $timelength     = (float)((int)$bars * (60 * (int)$clock)) / (int)$bpm;
            $samplelength   = ceil(($timelength * (int)$rate) / 1);
            return $samplelength;
        }
    }

    System_Daemon::start();

    try
    {
        $db = DBFactory::create(DBFactory::DRIVER_MYSQLI, PSOX::credentials());
        $query = QueryFactory::create(QueryFactory::DRIVER_MYSQL, &$db);

        $ok = 0;

        while(true)
        {
            try
            {
                $ok = 0;

                if(!$db->isConnected())
                {
                    $db->reconnect();
                }
                if(($res = $query->getNextJob()) !== 0)
                {
                    $query->write($res['job_id'], null, PSOX::FLAG_MIXING);
                    $sox = PSOX::deserialize($res['job_data']);
                    PSOX::log(PSOX::LOG_DEBUG, "job is unserialized for mixing");  

                    sleep(1);
                    if($sox->hasJob(PSOX::JOB_INIT))
                    {
                        if($sox->runJob(PSOX::JOB_INIT) === true) $ok++;
                    }
                    sleep(1);
                    if($sox->hasJob(PSOX::JOB_MIX))
                    {
                        if($sox->runJob(PSOX::JOB_MIX) === true) $ok++;
                    }
                    sleep(1);
                    if($sox->hasJob(PSOX::JOB_MERGE))
                    {
                        if($sox->runJob(PSOX::JOB_MERGE) === true) $ok++;
                    }
                    sleep(1);
                    if($sox->hasJob(PSOX::JOB_MP3))
                    {
                        if($sox->runJob(PSOX::JOB_MP3) === true) $ok++;
                    }
                    sleep(1);
                    if($sox->hasJob(PSOX::JOB_COPY))
                    {
                        if($sox->runJob(PSOX::JOB_COPY) === true) $ok++;
                    }
                    sleep(1);
                    if($sox->hasJob(PSOX::JOB_CLEAR))
                    {
                        if($err = $sox->runJob(PSOX::JOB_CLEAR) === true) $ok++;
                    }
                    sleep(1);
                    if($sox->hasJob(PSOX::JOB_MAIL))
                    {
                        if($sox->runJob(PSOX::JOB_MAIL) === true) $ok++;
                    }
                    if($ok === $sox->countJobs())
                    {
                        $query->write($res['job_id'], null, PSOX::FLAG_DONE, null, $sox->runtime($sox->getOption(PSOX::OPTION_RUNTIME_START), microtime()));
                        $sox->publish($res['job_cid']);
                        PSOX::log(PSOX::LOG_DEBUG, "job is done");
                    }else{
                        throw new PSOXException("unable to process job: ".$res['job_id'], PSOX::DAEMON_PROCEED);
                    }
                }
            }
            catch(PSOXException $e)
            {
                if((int)$e->getCode() === PSOX::DAEMON_ABORT)
                {
                    PSOX::log(PSOX::LOG_ERROR, $e->getMessage());
                    echo $e->getMessage();
                    break;
                    System_Daemon::stop();
                }else{
                    $query->bounceJob($res['job_id']);
                    PSOX::log(PSOX::LOG_ERROR, $e->getMessage());
                    PSOX::log(PSOX::LOG_DEBUG, "job is bounced");
                }
            }
            sleep(10);
        }
    }
    catch(PSOXException $e)
    {
        PSOX::log(PSOX::LOG_ERROR, $e->getMessage());
        echo $e->getMessage();
        System_Daemon::stop();
    }

class PROC extends PSOX
{
    /**
    * @desc method that does a proc_open command call with the command set
    * in first parameter $cmd. if the second parameter $output is set to false
    * the command will produce no output thus only returning true if command has
    * terminated
    * @param    string $cmd expects the command to call
    * @param    boolean $output expects whether to look for output
    * @param    array $env optionals env options
    * @param    string $cwd optional working dir
    * @access   public
    * @returns  mixed when $output = true returns string, else either empty string or true
    */
    public static function exec($cmd = null, $output = true, $env = null, $cwd = null)
    {
        $process = null;
        $pipes = array();
        $out = '';
        $status = null;

        if($cmd !== null)
        {
            $process = proc_open(   escapeshellcmd($cmd),
                                    array(
                                        0 => array('pipe', 'r'),
                                        1 => array('pipe', 'w'),
                                        2 => array('pipe', 'w')
                                    ),
                                    $pipes,
                                    $cwd,
                                    $env
                                );

            if(is_resource($process))
            {
                usleep(1000);
                stream_set_write_buffer($pipes[1], 0);
                stream_set_write_buffer($pipes[2], 0);
                stream_set_timeout($pipes[1], 600);
                stream_set_timeout($pipes[2], 600);
                stream_set_blocking($pipes[0], false);
                stream_set_blocking($pipes[1], false);
                stream_set_blocking($pipes[2], false);

                if((bool)$output)
                {
                    while(!feof($pipes[2]))
                    {
                        $status = proc_get_status($process);
                        $out .= htmlspecialchars(fgets($pipes[2]), ENT_COMPAT, 'UTF-8');
                    }
                }else{
                    while(true)
                    {
                        $status = proc_get_status($process);
                        if((bool)$status['running'])
                        {
                            $out = true;
                            break;
                        }
                    }
                }

                fclose($pipes[0]);
                fclose($pipes[1]);
                fclose($pipes[2]);

                @proc_close($process);
                @exec('kill '.$status['pid'].' 2>/dev/null >&- >/dev/null');
                @clearstatcache();

                return $out;

            }else{
                 throw new PSOXException("invalid ressource - unable to open process for: $cmd");
            }
        }
    }

}

I have seen quite some efforts on different blogs and the comments on php.net in some of the functions suggest some valid approaches. The problem with most approaches though, i find, is the lack of xml testing before passing it to the function to transform the xml to array. When you want to make sure you have a valid XML string the PHP DOMDocument class and its sub classes provide everything for iteration through its childs, to saving string presentations to file and so on. On top DOM perfectly validates XML strings when passed into the loading methods of the class. Also i believe any approach using DOM rather then handling the XML string with regex or whatever should be much faster and safer to rely on.

After having validated the XML string, your XML to Array function should never throw any errors. So since you validated your XML with DOM you might as well make use of the DOM functions to transform your XML into Array; rather then only testing your XML string for validity. So here is a function i found a while ago (i dont remember where exactly so no credits :/) which i optimized a little to get rid of unwanted notices and also to make it more reliable:

function xmlToArray(DOMNode $node = null)
{
    $result = array();
    $group = array();
    $attrs = null;
    $children = null;

    if($node->hasAttributes())
    {
        $attrs = $node->attributes;
        foreach($attrs as $k => $v)
        {
            $result[$v->name] = $v->value;
        }
    }

    $children = $node->childNodes;

    if(!empty($children))
    {
        if((int)$children->length === 1)
        {
            $child = $children->item(0);

            if($child !== null && $child->nodeType === XML_TEXT_NODE)
            {
                $result['#value'] = $child->nodeValue;
                if(count($result) == 1)
                {
                    return $result['#value'];
                }else{
                    return $result;
                }
            }
        }

        for($i = 0; $i < (int)$children->length; $i++)
        {
            $child = $children->item($i);

            if($child !== null)
            {
                if(!isset($result[$child->nodeName]))
                {
                    $result[$child->nodeName] = xmlToArray($child);
                }else{
                    if(!isset($group[$child->nodeName]))
                    {
                        $result[$child->nodeName] = array($result[$child->nodeName]);
                        $group[$child->nodeName] = 1;
                    }
                    $result[$child->nodeName][] = xmlToArray($child);
                }
            }
        }
    }
    return $result;
}

$doc = DOMDocument::loadXML('your xml string');
$arr = xmlToArray($doc);
print_r($arr);

If you want to have control over how the function deals with the value containing text nodes and attributes – looks for the attributes loop. You can alter it to the way you like. In the current form it will, once there is a node attribute, return a associative Array with attribute name => attribute value pairs and the actually text node value as #value key. If you always check for arrays, in the lowest depth where you will expect the node values, you should do fine.

One way of finding out how to count the pages of a PDF file with PHP apart from imagemagick which always performance very slow and shaky (depends on the version) is to use the Linux Ghostscript library via shell and PHPs exec() commands.

//$pdf full path to pdf file
function countPages($pdf = null)
{
    if($pdf !== null)
    {
        $c = "gs " . @escapeshellcmd("-q -sPDFname=".$pdf." ".rtrim(dirname(__FILE__), "/")."/counter.ps");
        @exec($c, $r);
        if(stristr($r[0], "error") === false)
        {
            if((bool)preg_match("/\%\%Pages\:\s+([0-9]{1,})/i", $r[0], $m))
            {
                return (int)$m[1];
            }
        }else{
            throw new Exception($r[0]);
        }
    }
}

Just make sure Ghostscript is installed and configured right and executable from bash and you have the counter.ps postscript file in the same directory from where you call the script. The content of the .ps file looks like. I found it on some other page but cannot remember where exactly so credits to unknown:

% pdfpagecount.ps
% read pdf file and output number of pages
% based on pdf2dsc.ps with one line taken from ps2ascii.ps
/PDFfile PDFname (r) file def 

/PageCountString 255 string 

def
systemdict /.setsafe known { .setsafe } if
/.show.stdout { (%stdout) (w) file } bind def
/puts { .show.stdout exch writestring } bind def
GS_PDF_ProcSet begin
pdfdict begin
PDFfile
pdfopen begin
/FirstPage where { pop } { /FirstPage 1 def } ifelse
/LastPage where { pop } { /LastPage pdfpagecount def } ifelse
(%%Pages: ) puts
LastPage FirstPage sub 1 add 

PageCountString cvs puts 

quit

Just parse the result with regular expressions for the line with “Pages” and you have the number of pages of your PDF file. I have tried it with different PDF version and standards and so far the results have been all correct.