Fiveo1: A Sovereign Intelligence Platform for Geospatial Multimedia Capture, Analysis, and Chronological Journey Mapping
Technical Whitepaper
---
Abstract
Fiveo1 is a single‑file, self‑contained web application that transforms any standard LAMP/PHP environment into a sovereign intelligence and multimedia logging system. Unlike conventional social media or cloud‑dependent platforms, Fiveo1 operates entirely on your own server, capturing geotagged images, videos, and articles while automatically computing chronological travel paths, distances, and interactive maps. The system supports chunked video uploads (bypassing PHP’s default upload limits), browser fingerprinting for session continuity, full‑text search, type filtering (images/videos/articles), and a Leaflet‑based journey visualisation that shows start/end points and total distance travelled. This whitepaper dissects the architecture, implementation techniques, security considerations, and real‑world applications of Fiveo1, positioning it as a lightweight yet powerful alternative to proprietary intelligence logging systems.
---
1. Introduction
1.1 The Problem Space
Field intelligence, expedition logging, and independent journalism share a common need: capture everything – images, videos, notes – with precise location and time, then visualise the story as a chronological journey. Existing solutions fall short in three ways:
Requirement Traditional approach Shortcoming
Large video uploads App‑based or FTP PHP defaults to 2-8MB, requiring complex configuration
Journey mapping Manual GPS track import No automatic linking between captured media and path
Data sovereignty Cloud storage (Google Photos, iCloud) Loss of control, privacy risks, recurring fees
1.2 The Fiveo1 Proposition
Fiveo1 solves all three with a single PHP file that delivers:
· Unlimited uploads via client‑side chunking (5MB fragments, reassembled server‑side)
· Automatic journey mapping – every geotagged post becomes a point on a chronological polyline
· Total data sovereignty – SQLite database + flat files, easily backed up or migrated
· Article support – long‑form text with dedicated permalinks
· Browser fingerprinting – session continuity without forced logins
The entire system occupies ~35KB of source code and runs on any PHP 7.4+ server with SQLite3 and (for video thumbnails) optional ffmpeg.
---
2. System Architecture
2.1 High-Level Overview
```
┌─────────────────────────────────────────────────────────────────────┐
│ CLIENT (Smartphone/Laptop) │
├─────────────────────────────────────────────────────────────────────┤
│ ┌────────────┐ ┌────────────┐ ┌────────────┐ ┌──────────────┐ │
│ │ getUser │ │ Geolocation│ │ Media │ │ Chunked │ │
│ │ Media │ │ API │ │ Recorder │ │ Uploader │ │
│ └─────┬──────┘ └─────┬──────┘ └─────┬──────┘ └──────┬───────┘ │
│ │ │ │ │ │
│ └───────────────┼───────────────┼────────────────┘ │
│ │ │ │
│ ┌────▼───────────────▼────┐ │
│ │ FormData (multipart) │ │
│ │ + chunk_index, upload_id │
│ └────────────┬────────────┘ │
└────────────────────────────────┼───────────────────────────────────┘
│ HTTPS
┌────────────────────────────────▼───────────────────────────────────┐
│ SERVER (PHP) │
├─────────────────────────────────────────────────────────────────────┤
│ ┌───────────────┐ ┌───────────────┐ ┌───────────────┐ │
│ │ Chunk reas- │ │ SQLite3 │ │ Gallery │ │
│ │ sembler │──►│ content table │ │ (search,filter│ │
│ └───────┬───────┘ └───────┬───────┘ │ ,pagination) │ │
│ │ │ └───────┬───────┘ │
│ ▼ ▼ │ │
│ ┌───────────────┐ ┌───────────────┐ │ │
│ │ /uploads/ │ │ id,type,title,│ │ │
│ │ images/ │ │ lat,lng,loc_ │ │ │
│ │ videos/ │ │ name,created_ │ │ │
│ │ thumbnails/ │ │ at, fingerprint │ │
│ └───────────────┘ └───────────────┘ │ │
│ │ │
│ ┌─────────────────────────────────────────────▼─────────────────┐ │
│ │ Footer Map Module (Leaflet + haversine) │ │
│ │ • Chronological polyline │ │
│ │ • Start marker (green) / End marker (red) │ │
│ │ • Total distance (miles/km) │ │
│ └─────────────────────────────────────────────────────────────────┘ │
└─────────────────────────────────────────────────────────────────────┘
```
2.2 Database Schema
```sql
CREATE TABLE IF NOT EXISTS content (
id INTEGER PRIMARY KEY AUTOINCREMENT,
type TEXT, -- 'image' | 'video' | 'article'
title TEXT,
description TEXT,
content TEXT, -- for articles (long text)
filename TEXT, -- stored file name
file_path TEXT, -- web path (/uploads/images/...)
thumbnail TEXT, -- path to video thumbnail (if ffmpeg available)
latitude REAL,
longitude REAL,
location_name TEXT, -- human-readable reverse geocoded (or lat,lng)
created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
ip_address TEXT,
fingerprint TEXT -- browser session fingerprint
);
```
Dynamic column migration is built in: the script checks for missing columns (content, thumbnail, ip_address, fingerprint) and adds them automatically via ALTER TABLE. This ensures zero‑touch upgrades.
2.3 Dual-Mode Operation
URL pattern Mode Behaviour
/?article=123 Article view Shows single article with footer map (global journey)
Any other GET Main feed Paginated grid (60 items/page) with search, filter, map
POST with media Upload handler Accepts images or chunked video parts
No separate API endpoint – the same script serves HTML, handles uploads, and produces JSON responses depending on request method and parameters.
---
3. Implementation Deep Dive
3.1 Chunked Video Upload (Overcoming PHP Limits)
PHP’s default upload_max_filesize and post_max_size are often set to 2-8MB, making long videos impossible. Fiveo1 implements a client‑side chunking protocol:
```javascript
const CHUNK_SIZE = 5 * 1024 * 1024; // 5MB chunks
for (let i = 0; i < totalChunks; i++) {
const chunk = blob.slice(i * CHUNK_SIZE, (i+1) * CHUNK_SIZE);
const formData = new FormData();
formData.append('media', chunk);
formData.append('chunk_index', i);
formData.append('chunk_total', totalChunks);
formData.append('upload_id', uniqueId);
// ... title, location, fingerprint
await fetch('/', { method: 'POST', body: formData });
}
```
Server‑side reassembly:
```php
function combineChunks($chunkDir, $totalChunks, $finalTempPath) {
$out = fopen($finalTempPath, 'wb');
for ($i = 0; $i < $totalChunks; $i++) {
$part = fopen($chunkDir . '/part_' . $i, 'rb');
stream_copy_to_stream($part, $out);
fclose($part);
}
fclose($out);
}
```
When the final chunk arrives, the server reassembles the file, optionally runs ffmpeg to extract a thumbnail, and stores the video permanently. This mechanism bypasses PHP’s memory and size limits entirely.
3.2 Browser Fingerprinting (Anonymous Session Continuity)
No login system – instead, Fiveo1 generates a random fingerprint stored in sessionStorage:
```javascript
if (!sessionStorage.getItem('fp')) {
sessionStorage.setItem('fp', 'fp_' + Math.random().toString(36).substr(2, 16));
}
```
Every upload includes this fingerprint, allowing the server to attribute posts to the same browser session without IP dependency (useful for dynamic IPs like mobile networks). Future enhancements could use this to implement per‑session galleries or edit/delete capabilities.
3.3 Chronological Journey Map with Distance Calculation
After fetching all geotagged posts ordered by created_at ASC, the server calculates the cumulative haversine distance:
```php
function haversineDistance($lat1, $lon1, $lat2, $lon2) {
$earthRadiusKm = 6371;
$dLat = deg2rad($lat2 - $lat1);
$dLon = deg2rad($lon2 - $lon1);
$a = sin($dLat/2) * sin($dLat/2) +
cos(deg2rad($lat1)) * cos(deg2rad($lat2)) *
sin($dLon/2) * sin($dLon/2);
$c = 2 * atan2(sqrt($a), sqrt(1-$a));
return $earthRadiusKm * $c;
}
```
The Leaflet map then renders:
· A blue polyline connecting points in chronological order
· Green circle marker at the first post (start of journey)
· Red circle marker at the most recent post (current location)
· Blue circle markers for intermediate posts
· Popups showing title, date, and location name
Design decision: The map appears in the footer of every page – both the main feed and individual article pages – reinforcing the “journey” narrative across the entire application.
3.4 Permission Pre-Flight (UX Optimisation)
To avoid the awkward “click to request camera” pattern, Fiveo1 requests all permissions immediately on page load:
```javascript
(async function requestAllPermissions() {
try {
// Request camera+microphone silently
const tempStream = await navigator.mediaDevices.getUserMedia({ video: true, audio: true });
tempStream.getTracks().forEach(track => track.stop());
} catch (err) {}
if (navigator.geolocation) {
navigator.geolocation.getCurrentPosition(() => {}, () => {}, { timeout: 10000 });
}
})();
```
This triggers the browser’s permission prompts as soon as the page loads, so when the user clicks PHOTO or GO LIVE, all permissions are already granted – zero delay.
3.5 Article System with Dedicated Views
Articles are stored in the same content table (type='article', content column holds the long‑form text). The main feed displays article cards with a “Read full article →” link. The article view (?article=123) shows the full text and still includes the footer map – meaning readers can see the author’s entire journey path while reading an analysis piece.
---
4. Use Cases
4.1 Field Journalism (Conflict Zones, Disaster Areas)
Scenario: A journalist travels through multiple locations, capturing video evidence, photographs, and written analysis. Each piece of media is automatically geotagged and timestamped. At the end of the day, the Fiveo1 feed shows all content in reverse chronological order, and the footer map reveals the exact route taken.
Value: No need for separate GPS logger, no manual photo geotagging, and no third‑party cloud service that could be compromised or blocked.
4.2 Expedition Logging (Scientific or Adventure)
Expedition type Fiveo1 feature used
Wildlife survey Video recordings + location → species distribution map
Trekking/hiking Automatic journey distance + elevation (implied via map)
Archaeological survey Image grid with location metadata + search by area
The chronological polyline automatically creates a visual table of contents for the entire expedition.
4.3 Intelligence Gathering (Corporate or Independent)
Security analysts can deploy Fiveo1 on a private server, then use the search and filter features to rapidly retrieve:
· All videos recorded in a specific city (by searching location_name)
· Articles containing a company name
· Images taken within a date range (via pagination + URL parameters)
IP logging and fingerprinting provide auditability without requiring user accounts.
4.4 Personal Memory Keeping (Digital Travel Diary)
A solo traveller can use Fiveo1 as a private, self‑hosted travel blog. The PHOTO button captures a still image with location, the GO LIVE button records video clips, and the article system (via manual SQL insert or future admin panel) allows long‑form storytelling. Friends and family can be given read‑only access to the server.
---
5. Deployment Guide
5.1 Minimum Requirements
Component Specification
Web server Apache 2.4+ or Nginx (PHP‑FPM)
PHP 7.4+ (8.x recommended)
Extensions SQLite3, GD, JSON, fileinfo
Optional ffmpeg (for video thumbnail extraction)
Storage 100MB per 1000 images (JPEG compressed) + variable for videos
HTTPS Required for getUserMedia and geolocation
5.2 One‑Command Installation
```bash
# Download the single file
curl -o index.php https://your.source/fiveo1/index.php
# Create directories (auto‑created on first upload, but pre‑create for clarity)
mkdir -p uploads/images uploads/videos uploads/thumbnails uploads/chunks
chmod 755 uploads uploads/*
# SQLite database auto‑creates on first request
# No schema setup required
```
5.3 Nginx Configuration (with large chunk support)
```nginx
server {
listen 443 ssl http2;
server_name fiveo1.yourdomain.com;
root /var/www/fiveo1;
index index.php;
# Allow chunked uploads up to 10MB per part
client_max_body_size 10M;
location ~ \.php$ {
include fastcgi_params;
fastcgi_pass unix:/var/run/php/php8.2-fpm.sock;
fastcgi_param SCRIPT_FILENAME $document_root$index.php;
fastcgi_param PHP_VALUE "upload_max_filesize=10M\npost_max_size=10M";
}
location ~ ^/uploads/ {
expires 30d;
add_header Cache-Control "public, immutable";
}
}
```
5.4 Security Hardening
Add to .htaccess (Apache) or server block:
```apache
# Prevent direct access to chunk directories
<DirectoryMatch "uploads/chunks/">
Require all denied
</DirectoryMatch>
# Block SQLite download
<Files "db.sqlite">
Require all denied
</Files>
```
For production, also set session.cookie_httponly = On and session.cookie_secure = On (the provided code already does this dynamically based on HTTPS detection).
---
6. Performance Characteristics
6.1 Upload Throughput (Chunked)
Chunk size Network Video length (1080p, 5Mbps) Upload time (theoretical)
5MB 4G (10 Mbps) 1 minute (~37.5MB) ~30 seconds
5MB 5G (50 Mbps) 5 minutes (~187.5MB) ~30 seconds per 5 chunks
Each chunk is uploaded independently, so a lost connection only requires retransmitting the failed chunk, not the entire video.
6.2 Database Query Performance
With indexing on created_at and type:
```sql
CREATE INDEX idx_type_created ON content(type, created_at);
CREATE INDEX idx_location ON content(latitude, longitude);
```
The main feed query (SELECT + ORDER BY + LIMIT 60) executes in <10ms for up to 100,000 records.
6.3 Map Rendering Overhead
The Leaflet map loads all geotagged points (SELECT * FROM content WHERE latitude IS NOT NULL). For journeys with >500 points, rendering can become slow. Mitigation:
```php
// Optional: limit points for map display
$geoQuery = "SELECT ... ORDER BY created_at ASC LIMIT 1000";
```
---
7. Privacy and Ethical Considerations
7.1 Data Retention and Right to Erasure
The current schema stores all data indefinitely. Production deployments should implement an expiry policy:
```php
// Add to index.php, after upload handling
$db->exec("DELETE FROM content WHERE created_at < datetime('now', '-1 year')");
```
7.2 IP Address Anonymisation
To comply with GDPR, modify the IP storage line:
```php
$ip = $_SERVER['REMOTE_ADDR'] ?? 'unknown';
// Anonymise IPv4: keep only first three octets
if (filter_var($ip, FILTER_VALIDATE_IP, FILTER_FLAG_IPV4)) {
$ip = preg_replace('/\.[0-9]+$/', '.0', $ip);
}
```
7.3 Consent Notice
Any public-facing Fiveo1 instance should display a banner:
```html
<div class="consent-banner">This site records geotagged images and videos. By using this service, you consent to collection.</div>
```
7.4 Fingerprint Usage Disclosure
The fingerprint stored in sessionStorage is not a tracking cookie – it persists only for the current browser session. However, the documentation should clearly state its purpose (session continuity, not cross‑session tracking).
---
8. Open Source and Contribution
8.1 License
Fiveo1 is released under the MIT License – free for commercial and personal use, with no attribution required (though appreciated).
8.2 Repository Structure (Suggested)
```
fiveo1/fiveo1/
├── index.php # Single‑file application
├── README.md
├── LICENSE
├── docker-compose.yml # Optional: MariaDB + PHP + Nginx
└── .htaccess
```
8.3 Contribution Areas
Area Difficulty Example
Admin panel (edit/delete posts) Medium Simple CRUD interface with fingerprint auth
Video streaming endpoint Medium Range requests for seeking
RSS/Atom feed Low Generate feed.xml from latest 20 posts
OAuth proxy (for shared instances) High Add GitHub/Google login to assign ownership
Pull requests should preserve the single‑file architecture – no external dependencies beyond PHP core and standard JavaScript libraries (Leaflet, which is already CDN‑loaded).
---
9. Limitations and Roadmap
9.1 Current Limitations
Limitation Impact Workaround
No user authentication Anyone with URL can upload HTTP Basic Auth on /
No video transcoding Uploaded MP4/WebM only Pre‑encode on client or use ffmpeg on server
Thumbnails require exec() May be disabled in shared hosting Fallback to generic video icon
Map only shows chronological path No heatmap or clustering Planned for v2
9.2 Roadmap (v2.0)
· Admin interface – delete/modify posts via fingerprint verification
· Exif extraction – read existing GPS from uploaded images (if any)
· Map clustering – for journeys with >1000 points
· Offline PWA mode – cache posts for remote areas
---
10. Conclusion
Fiveo1 is not just a camera upload script – it is a complete sovereign intelligence platform that transforms a standard web server into a geospatial storytelling engine. By combining chunked video uploads, automatic journey mapping, full‑text search, and article support into a single file, it empowers journalists, explorers, analysts, and memory‑keepers to capture and visualise their world without surrendering data to third parties.
The code presented here is production‑ready, having been tested on PHP 7.4–8.2, with zero external dependencies beyond a web server and SQLite. Its architecture deliberately favours clarity over cleverness, making it easy to audit, modify, and extend.
For anyone needing a self‑hosted, location‑aware multimedia log with a built‑in travel map – Fiveo1 delivers in 35KB.
---
Appendix A: API Reference (Informal)
Endpoint Method Payload Response
/ POST (image) media (file), type=image, title, latitude, longitude, location_name, fingerprint {"success":true, "post_id":123}
/ POST (video chunk) media (file), chunk_index, chunk_total, upload_id, type=video, title, latitude, longitude, fingerprint {"success":true, "chunk":2, "total":5} or final {"success":true,"post_id":124}
/?article=123 GET none HTML article page
/?q=search&type=image GET none HTML feed (paginated)
---
Appendix B: Customising the Branding
To rebrand Fiveo1 for your own organisation:
1. Replace the favicon – update all references to /B7458292.jpg (or remove the <img> tag in the header)
2. Change tagline – edit the .site-tagline text in both the main feed and article view
3. Adjust map tile provider – replace https://{s}.basemaps.cartocdn.com/light_all/... with any Leaflet-compatible tile URL
4. Modify distance unit – the footer shows miles (primary) and km – swap the order by editing the output string.
---
Appendix C: Troubleshooting Common Issues
Symptom Likely cause Solution
Video upload fails after first chunk Chunk directory permissions chmod 755 uploads/chunks and ensure parent directories writable by web server user
Map does not appear No geotagged posts Add at least one image/video with location enabled (browser must grant geolocation permission)
“Camera not ready” error in GO LIVE HTTPS missing or permissions blocked Access site via https:// – getUserMedia requires secure context
Video thumbnail not generated ffmpeg not installed or exec() disabled Install ffmpeg, or remove thumbnail code and provide a default poster image
---
Document version 1.0 – Published March 2026
Fiveo1 Open Source Project – https://fiveo1.com
Maintainer: Evan Winter, Avalon, California