Second version

/**
 * Generate pseudo random bits using the best available method.
 *
 * @param int $bits Amount of random bits to generate.
 * @param bool $secure Use a cryptographically secure method of getting these random bits.
 * @param int $output_type The output type for the generated bits.
 * @return string A (pseudo) random string.
 *
 * @copyright: public domain
 * @author Beanow
 * @link http://tuxion.nl
 * @note Don't try to improve this, you will likely just ruin it
 * @note I did it anyways. Regards ~Beanow
 */
private function _random_bits($bits, $secure=true, $output_type=self::OUTPUT_HEX)
{

  //Obviously *NIX is for pro's and so we should use it's generator if available.
  //Ok the real reason is that it gives high entropy by gathering noise on an OS level.
  //So using that makes this function a lot faster and more safe.
  if (@is_readable('/dev/urandom')){
    $f=fopen('/dev/urandom', 'rb');
    $str=fread($f, ceil($bits/8));
    fclose($f);
    return $this->_convert_bin($str, $output_type);
  }

  //If we don't have it we're going to make the best out of getting microtime() bits of randomness.
  else
  {

    //Generate more entropy starting state, to give it that extra bit of spunk. :D
    $state = uniqid('', true);
    $intermediate_bytes = '';
    $random_bytes = '';
    $hash_algoritm = $this->pref_hash_algo($bits, true, $intermediate_bits);
    $intermediate_hashes = 0;

    //Increment with 20, because microtime() generates 6 decimals which is almost 20 bits.
    //The fraction of the last bit that isn't available from microtime() comes from mt_rand().
    //However if $secure is set to false we don't care and take the size of the hash output instead.
    //This will make the algorithm faster but will contain much less (~60%) entropy.
    //Note that the state hash and string appending hash are different and should be!
    //It makes it impossible for the state to leak into the output stream.
    for ($entropy = 0; $entropy < $bits; $entropy += ($secure === true ? 20 : 52))
    {

      $state = $this->hash(microtime().$state.mt_rand(), self::$HASH_PREFERENCES['128'][0]);
      $intermediate_bytes .= $this->hash(microtime().$state, self::$HASH_PREFERENCES['128'][0], self::OUTPUT_BINARY);

      //Whenever we have reached the max entropy we can cram into the hashing algorithm that was selected, hash it to the results.
      //Use bytes here so we don't get pointless data in here, like padding signs for base64.
      if($entropy >= ($intermediate_bits * ($intermediate_hashes+1))){
        $random_bytes .= $this->hash($intermediate_bytes, $hash_algoritm, self::OUTPUT_BINARY);
      }

    }

    //Do final conversion of binary data.
    return $this->_convert_bin($random_bytes, $output_type);

  }

}