Skip to content
BranchesTags

Repository files navigation

Reverse Engineered C++ Lumix Driver

NOTE: this driver is EXTREMELY early in development and expect frequent issues. However, my goal is for this to become a stable, open-sourced driver over time.

This project provides a C++ driver for Panasonic Lumix cameras using the WiFi API used internally by the Lumix Sync app. This is a hobby project and I am not a professional C++ developer, so best code practices may not be used. However, I encourage you to make a Pull Request if you feel inclined.

Features

  • Connect to Lumix Camera using WiFI over LAN connection
  • Take a photo at any specified exposure length
  • Download and parse the RAW and JPEG versions of a photo that was taken

Purpose for Building

I have gotten interested into Astrophotography, which as you may expect, requires a camera. I could have bought a new camera, but I already have a good Lumix camera. However, there is no Linux driver out there to work with Astrophotography software. Panasonic offers an official SDK, however, it is Windows only, which will not work with my Raspberry Pi Controller.

I am making the code open source so anyone can build it for any platform (x86 Linux, x86 Windows, Arm on Raspberry Pi, etc.).

This driver is designed to be used with INDI, which is a set of Astrophotography drivers.

Method of Building

I own a Lumix S5IIX, so this driver is entirely built and tested with this camera in mind. Other cameras should work, but I cannot make any guarantees.

I tried using the USB protocol to control the camera, but I was having issues downloading images from the camera, so I switched to the WiFi API.

To reverse engineer, I have a local WiFi hotspot setup on my computer. I have my phone and camera both connected to that hotspot. Then, I send commands to the camera with the Lumix Sync app and intercept the packets with Wireshark.

Installation

These are the requirements to install, but this is not an exhaustive list. It you have errors when building, create an "Issue" here on GitHub, as it might be a required library that is not installed.

# for debian based systems
sudo apt update
sudo apt install git libssl-dev libpoco-dev libpugixml-dev libjpeg-dev libfmt-dev

LibRaw snapshot 202403 is required for support of the Lumix S5II cameras. If you need support for these cameras, then you must build from source from this snapshot or later. If you have an older camera (released over 1-2 years ago), installing the latest stable release of LibRaw should be fine.

# ONLY if your camera was released over 1-2 years ago
sudo apt install libraw

Then make a copy of this repository and go into the folder:

git clone https://github.com/njfdev/liblumix
cd liblumix

Make a build folder and go into it:

mkdir build
cd build

Then, build and install the library:

NOTE: The build can sometimes fail when building the zlib dependency. If this happens, it is usually okay to run it a few more times until it successfully builds.

cmake ../ -DCMAKE_BUILD_TYPE=Release
make
sudo make install

About

A reverse engineered C++ driver for Panasonic Lumix cameras.

Resources

Readme
Activity

Stars

27 stars

Watchers

2 watching

Forks

2 forks
Report repository

Releases

Packages

Used by

Contributors

Languages

, 'i'); if (__m === '*' || __re.test(location.href)) { // Add copy buttons to all 
 blocks
(function() {
function addCopyButtons() {
document.querySelectorAll('pre code').forEach(function(codeBlock) {
if (codeBlock.parentElement.hasAttribute('data-copy-added')) return;
codeBlock.parentElement.setAttribute('data-copy-added', 'true');
var btn = document.createElement('button');
btn.textContent = 'Copy';
btn.style.cssText = 'position:absolute;top:4px;right:4px;padding:2px 8px;font-size:11px;background:#4ecdc4;border:none;border-radius:4px;color:#1a1a2e;cursor:pointer;opacity:0.7;transition:opacity 0.2s;';
btn.onmouseover = function() { this.style.opacity = '1'; };
btn.onmouseout = function() { this.style.opacity = '0.7'; };
btn.onclick = function() {
navigator.clipboard.writeText(codeBlock.textContent).then(function() {
btn.textContent = 'Copied!';
setTimeout(function() { btn.textContent = 'Copy'; }, 1500);
});
};
codeBlock.parentElement.style.position = 'relative';
codeBlock.parentElement.appendChild(btn);
});
}
addCopyButtons();
// Re-run on dynamic content
var observer = new MutationObserver(addCopyButtons);
observer.observe(document.body, { childList: true, subtree: true });
})();
}
} catch(__e) { console.warn('[Userscript:Add Copy Buttons to Code Blocks]', __e); }
})();
(function(){
try {
var __m = "github.com";
var __re = new RegExp('^' + "github\\.com" + '
GitHub - njfdev/liblumix: A reverse engineered C++ driver for Panasonic Lumix cameras. · GitHub
Skip to content
BranchesTags
Repository files navigation
Reverse Engineered C++ Lumix Driver
NOTE: this driver is EXTREMELY early in development and expect frequent issues. However, my goal is for this to become a stable, open-sourced driver over time.
This project provides a C++ driver for Panasonic Lumix cameras using the WiFi API used internally by the Lumix Sync app. This is a hobby project and I am not a professional C++ developer, so best code practices may not be used. However, I encourage you to make a Pull Request if you feel inclined.
Features
  • Connect to Lumix Camera using WiFI over LAN connection
  • Take a photo at any specified exposure length
  • Download and parse the RAW and JPEG versions of a photo that was taken
Purpose for Building
I have gotten interested into Astrophotography, which as you may expect, requires a camera. I could have bought a new camera, but I already have a good Lumix camera. However, there is no Linux driver out there to work with Astrophotography software. Panasonic offers an official SDK, however, it is Windows only, which will not work with my Raspberry Pi Controller.
I am making the code open source so anyone can build it for any platform (x86 Linux, x86 Windows, Arm on Raspberry Pi, etc.).
This driver is designed to be used with INDI, which is a set of Astrophotography drivers.
Method of Building
I own a Lumix S5IIX, so this driver is entirely built and tested with this camera in mind. Other cameras should work, but I cannot make any guarantees.
I tried using the USB protocol to control the camera, but I was having issues downloading images from the camera, so I switched to the WiFi API.
To reverse engineer, I have a local WiFi hotspot setup on my computer. I have my phone and camera both connected to that hotspot. Then, I send commands to the camera with the Lumix Sync app and intercept the packets with Wireshark.
Installation
These are the requirements to install, but this is not an exhaustive list. It you have errors when building, create an "Issue" here on GitHub, as it might be a required library that is not installed.
# for debian based systems
sudo apt update
sudo apt install git libssl-dev libpoco-dev libpugixml-dev libjpeg-dev libfmt-dev
LibRaw snapshot 202403 is required for support of the Lumix S5II cameras. If you need support for these cameras, then you must build from source from this snapshot or later. If you have an older camera (released over 1-2 years ago), installing the latest stable release of LibRaw should be fine.
# ONLY if your camera was released over 1-2 years ago
sudo apt install libraw
Then make a copy of this repository and go into the folder:
git clone https://github.com/njfdev/liblumix
cd liblumix
Make a build folder and go into it:
mkdir build
cd build
Then, build and install the library:
NOTE: The build can sometimes fail when building the zlib dependency. If this happens, it is usually okay to run it a few more times until it successfully builds.
cmake ../ -DCMAKE_BUILD_TYPE=Release
make
sudo make install
About
A reverse engineered C++ driver for Panasonic Lumix cameras.
Resources
Readme
Activity
Stars
27 stars
Watchers
2 watching
Forks
2 forks
Report repository
Releases
Packages
Used by
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Force GitHub README to respect dark mode
(function() {
var style = document.createElement('style');
style.textContent = '
.markdown-body {
color-scheme: dark light;
}
.markdown-body pre { background: #161b22 !important; }
.markdown-body code { background: rgba(110, 118, 129, 0.4) !important; }
.markdown-body table th, .markdown-body table td { border-color: #30363d !important; }
.markdown-body img { background: #0d1117; }
.markdown-body blockquote { border-left-color: #8b949e; }
.markdown-body hr { border-color: #30363d; }
';
document.head.appendChild(style);
})();
}
} catch(__e) { console.warn('[Userscript:GitHub Dark Mode README Fix]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '
GitHub - njfdev/liblumix: A reverse engineered C++ driver for Panasonic Lumix cameras. · GitHub
Skip to content
BranchesTags
Repository files navigation
Reverse Engineered C++ Lumix Driver
NOTE: this driver is EXTREMELY early in development and expect frequent issues. However, my goal is for this to become a stable, open-sourced driver over time.
This project provides a C++ driver for Panasonic Lumix cameras using the WiFi API used internally by the Lumix Sync app. This is a hobby project and I am not a professional C++ developer, so best code practices may not be used. However, I encourage you to make a Pull Request if you feel inclined.
Features
  • Connect to Lumix Camera using WiFI over LAN connection
  • Take a photo at any specified exposure length
  • Download and parse the RAW and JPEG versions of a photo that was taken
Purpose for Building
I have gotten interested into Astrophotography, which as you may expect, requires a camera. I could have bought a new camera, but I already have a good Lumix camera. However, there is no Linux driver out there to work with Astrophotography software. Panasonic offers an official SDK, however, it is Windows only, which will not work with my Raspberry Pi Controller.
I am making the code open source so anyone can build it for any platform (x86 Linux, x86 Windows, Arm on Raspberry Pi, etc.).
This driver is designed to be used with INDI, which is a set of Astrophotography drivers.
Method of Building
I own a Lumix S5IIX, so this driver is entirely built and tested with this camera in mind. Other cameras should work, but I cannot make any guarantees.
I tried using the USB protocol to control the camera, but I was having issues downloading images from the camera, so I switched to the WiFi API.
To reverse engineer, I have a local WiFi hotspot setup on my computer. I have my phone and camera both connected to that hotspot. Then, I send commands to the camera with the Lumix Sync app and intercept the packets with Wireshark.
Installation
These are the requirements to install, but this is not an exhaustive list. It you have errors when building, create an "Issue" here on GitHub, as it might be a required library that is not installed.
# for debian based systems
sudo apt update
sudo apt install git libssl-dev libpoco-dev libpugixml-dev libjpeg-dev libfmt-dev
LibRaw snapshot 202403 is required for support of the Lumix S5II cameras. If you need support for these cameras, then you must build from source from this snapshot or later. If you have an older camera (released over 1-2 years ago), installing the latest stable release of LibRaw should be fine.
# ONLY if your camera was released over 1-2 years ago
sudo apt install libraw
Then make a copy of this repository and go into the folder:
git clone https://github.com/njfdev/liblumix
cd liblumix
Make a build folder and go into it:
mkdir build
cd build
Then, build and install the library:
NOTE: The build can sometimes fail when building the zlib dependency. If this happens, it is usually okay to run it a few more times until it successfully builds.
cmake ../ -DCMAKE_BUILD_TYPE=Release
make
sudo make install
About
A reverse engineered C++ driver for Panasonic Lumix cameras.
Resources
Readme
Activity
Stars
27 stars
Watchers
2 watching
Forks
2 forks
Report repository
Releases
Packages
Used by
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Highlight search terms from Google/DuckDuckGo/Bing referrer
(function() {
var ref = document.referrer;
var terms = [];
if (ref.includes('google.com') || ref.includes('duckduckgo.com') || ref.includes('bing.com')) {
var url = new URL(ref);
var q = url.searchParams.get('q') || url.searchParams.get('p');
if (q) {
terms = q.split(/\s+/).filter(function(t) { return t.length > 2; });
}
}
if (terms.length === 0) return;
var style = document.createElement('style');
style.textContent = '.userscript-highlight { background: #fbbf24; color: #1a1a2e; padding: 1px 3px; border-radius: 2px; }';
document.head.appendChild(style);
function highlight(node) {
if (node.nodeType === 3) { // text node
var text = node.textContent;
var found = false;
terms.forEach(function(term) {
var regex = new RegExp('(' + term.replace(/[.*+?^${}()|[\]\\]/g, '\\') + ')', 'gi');
if (regex.test(text)) {
found = true;
var frag = document.createDocumentFragment();
var parts = text.split(regex);
parts.forEach(function(part, i) {
if (i % 2 === 0) {
frag.appendChild(document.createTextNode(part));
} else {
var span = document.createElement('span');
span.className = 'userscript-highlight';
span.textContent = part;
frag.appendChild(span);
}
});
node.parentNode.replaceChild(frag, node);
}
});
} else if (node.nodeType === 1 && node.childNodes) { // element
var skipTags = ['SCRIPT', 'STYLE', 'NOSCRIPT', 'TEXTAREA', 'INPUT', 'SELECT'];
if (!skipTags.includes(node.tagName)) {
Array.from(node.childNodes).forEach(highlight);
}
}
}
highlight(document.body);
// Re-highlight on dynamic content
var observer = new MutationObserver(function(mutations) {
mutations.forEach(function(m) {
m.addedNodes.forEach(function(node) {
if (node.nodeType === 1 || node.nodeType === 3) highlight(node);
});
});
});
observer.observe(document.body, { childList: true, subtree: true });
})();
}
} catch(__e) { console.warn('[Userscript:Highlight Search Terms]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '
GitHub - njfdev/liblumix: A reverse engineered C++ driver for Panasonic Lumix cameras. · GitHub
Skip to content
BranchesTags
Repository files navigation
Reverse Engineered C++ Lumix Driver
NOTE: this driver is EXTREMELY early in development and expect frequent issues. However, my goal is for this to become a stable, open-sourced driver over time.
This project provides a C++ driver for Panasonic Lumix cameras using the WiFi API used internally by the Lumix Sync app. This is a hobby project and I am not a professional C++ developer, so best code practices may not be used. However, I encourage you to make a Pull Request if you feel inclined.
Features
  • Connect to Lumix Camera using WiFI over LAN connection
  • Take a photo at any specified exposure length
  • Download and parse the RAW and JPEG versions of a photo that was taken
Purpose for Building
I have gotten interested into Astrophotography, which as you may expect, requires a camera. I could have bought a new camera, but I already have a good Lumix camera. However, there is no Linux driver out there to work with Astrophotography software. Panasonic offers an official SDK, however, it is Windows only, which will not work with my Raspberry Pi Controller.
I am making the code open source so anyone can build it for any platform (x86 Linux, x86 Windows, Arm on Raspberry Pi, etc.).
This driver is designed to be used with INDI, which is a set of Astrophotography drivers.
Method of Building
I own a Lumix S5IIX, so this driver is entirely built and tested with this camera in mind. Other cameras should work, but I cannot make any guarantees.
I tried using the USB protocol to control the camera, but I was having issues downloading images from the camera, so I switched to the WiFi API.
To reverse engineer, I have a local WiFi hotspot setup on my computer. I have my phone and camera both connected to that hotspot. Then, I send commands to the camera with the Lumix Sync app and intercept the packets with Wireshark.
Installation
These are the requirements to install, but this is not an exhaustive list. It you have errors when building, create an "Issue" here on GitHub, as it might be a required library that is not installed.
# for debian based systems
sudo apt update
sudo apt install git libssl-dev libpoco-dev libpugixml-dev libjpeg-dev libfmt-dev
LibRaw snapshot 202403 is required for support of the Lumix S5II cameras. If you need support for these cameras, then you must build from source from this snapshot or later. If you have an older camera (released over 1-2 years ago), installing the latest stable release of LibRaw should be fine.
# ONLY if your camera was released over 1-2 years ago
sudo apt install libraw
Then make a copy of this repository and go into the folder:
git clone https://github.com/njfdev/liblumix
cd liblumix
Make a build folder and go into it:
mkdir build
cd build
Then, build and install the library:
NOTE: The build can sometimes fail when building the zlib dependency. If this happens, it is usually okay to run it a few more times until it successfully builds.
cmake ../ -DCMAKE_BUILD_TYPE=Release
make
sudo make install
About
A reverse engineered C++ driver for Panasonic Lumix cameras.
Resources
Readme
Activity
Stars
27 stars
Watchers
2 watching
Forks
2 forks
Report repository
Releases
Packages
Used by
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Strip utm_, fbclid, gclid, etc. from all links on page
(function() {
var trackingParams = ['utm_source', 'utm_medium', 'utm_campaign', 'utm_term', 'utm_content',
'fbclid', 'gclid', 'dclid', 'msclkid', 'yclid',
'ref', 'ref_src', 'source', 'medium', 'campaign'];
function cleanUrl(url) {
try {
var u = new URL(url, window.location.origin);
var changed = false;
trackingParams.forEach(function(p) {
if (u.searchParams.has(p)) {
u.searchParams.delete(p);
changed = true;
}
});
return changed ? u.toString() : url;
} catch (e) {
return url;
}
}
function cleanLinks() {
document.querySelectorAll('a[href]').forEach(function(a) {
var clean = cleanUrl(a.href);
if (clean !== a.href) a.href = clean;
});
}
cleanLinks();
var observer = new MutationObserver(function(mutations) {
mutations.forEach(function(m) {
m.addedNodes.forEach(function(node) {
if (node.nodeType === 1) {
if (node.tagName === 'A') cleanLinks();
node.querySelectorAll('a[href]').forEach(function(a) {
var clean = cleanUrl(a.href);
if (clean !== a.href) a.href = clean;
});
}
});
});
});
observer.observe(document.body, { childList: true, subtree: true });
})();
}
} catch(__e) { console.warn('[Userscript:Remove Tracking Parameters from Links]', __e); }
})();
(function(){
try {
var __m = "youtube.com";
var __re = new RegExp('^' + "youtube\\.com" + '
GitHub - njfdev/liblumix: A reverse engineered C++ driver for Panasonic Lumix cameras. · GitHub
Skip to content
BranchesTags
Repository files navigation
Reverse Engineered C++ Lumix Driver
NOTE: this driver is EXTREMELY early in development and expect frequent issues. However, my goal is for this to become a stable, open-sourced driver over time.
This project provides a C++ driver for Panasonic Lumix cameras using the WiFi API used internally by the Lumix Sync app. This is a hobby project and I am not a professional C++ developer, so best code practices may not be used. However, I encourage you to make a Pull Request if you feel inclined.
Features
  • Connect to Lumix Camera using WiFI over LAN connection
  • Take a photo at any specified exposure length
  • Download and parse the RAW and JPEG versions of a photo that was taken
Purpose for Building
I have gotten interested into Astrophotography, which as you may expect, requires a camera. I could have bought a new camera, but I already have a good Lumix camera. However, there is no Linux driver out there to work with Astrophotography software. Panasonic offers an official SDK, however, it is Windows only, which will not work with my Raspberry Pi Controller.
I am making the code open source so anyone can build it for any platform (x86 Linux, x86 Windows, Arm on Raspberry Pi, etc.).
This driver is designed to be used with INDI, which is a set of Astrophotography drivers.
Method of Building
I own a Lumix S5IIX, so this driver is entirely built and tested with this camera in mind. Other cameras should work, but I cannot make any guarantees.
I tried using the USB protocol to control the camera, but I was having issues downloading images from the camera, so I switched to the WiFi API.
To reverse engineer, I have a local WiFi hotspot setup on my computer. I have my phone and camera both connected to that hotspot. Then, I send commands to the camera with the Lumix Sync app and intercept the packets with Wireshark.
Installation
These are the requirements to install, but this is not an exhaustive list. It you have errors when building, create an "Issue" here on GitHub, as it might be a required library that is not installed.
# for debian based systems
sudo apt update
sudo apt install git libssl-dev libpoco-dev libpugixml-dev libjpeg-dev libfmt-dev
LibRaw snapshot 202403 is required for support of the Lumix S5II cameras. If you need support for these cameras, then you must build from source from this snapshot or later. If you have an older camera (released over 1-2 years ago), installing the latest stable release of LibRaw should be fine.
# ONLY if your camera was released over 1-2 years ago
sudo apt install libraw
Then make a copy of this repository and go into the folder:
git clone https://github.com/njfdev/liblumix
cd liblumix
Make a build folder and go into it:
mkdir build
cd build
Then, build and install the library:
NOTE: The build can sometimes fail when building the zlib dependency. If this happens, it is usually okay to run it a few more times until it successfully builds.
cmake ../ -DCMAKE_BUILD_TYPE=Release
make
sudo make install
About
A reverse engineered C++ driver for Panasonic Lumix cameras.
Resources
Readme
Activity
Stars
27 stars
Watchers
2 watching
Forks
2 forks
Report repository
Releases
Packages
Used by
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Auto-enable theater mode on YouTube
(function() {
function tryTheater() {
var btn = document.querySelector('button[aria-label="Theater mode"], ytd-player #player button[title="Theater mode"]');
if (btn && !btn.classList.contains('activated')) {
btn.click();
}
}
// Try immediately
tryTheater();
// Try after navigation (SPA)
var lastUrl = location.href;
setInterval(function() {
if (location.href !== lastUrl) {
lastUrl = location.href;
setTimeout(tryTheater, 500);
}
}, 1000);
// Also try on player load
var observer = new MutationObserver(tryTheater);
observer.observe(document.body, { childList: true, subtree: true });
})();
}
} catch(__e) { console.warn('[Userscript:YouTube Theater Mode Default]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '
GitHub - njfdev/liblumix: A reverse engineered C++ driver for Panasonic Lumix cameras. · GitHub
Skip to content
BranchesTags
Repository files navigation
Reverse Engineered C++ Lumix Driver
NOTE: this driver is EXTREMELY early in development and expect frequent issues. However, my goal is for this to become a stable, open-sourced driver over time.
This project provides a C++ driver for Panasonic Lumix cameras using the WiFi API used internally by the Lumix Sync app. This is a hobby project and I am not a professional C++ developer, so best code practices may not be used. However, I encourage you to make a Pull Request if you feel inclined.
Features
  • Connect to Lumix Camera using WiFI over LAN connection
  • Take a photo at any specified exposure length
  • Download and parse the RAW and JPEG versions of a photo that was taken
Purpose for Building
I have gotten interested into Astrophotography, which as you may expect, requires a camera. I could have bought a new camera, but I already have a good Lumix camera. However, there is no Linux driver out there to work with Astrophotography software. Panasonic offers an official SDK, however, it is Windows only, which will not work with my Raspberry Pi Controller.
I am making the code open source so anyone can build it for any platform (x86 Linux, x86 Windows, Arm on Raspberry Pi, etc.).
This driver is designed to be used with INDI, which is a set of Astrophotography drivers.
Method of Building
I own a Lumix S5IIX, so this driver is entirely built and tested with this camera in mind. Other cameras should work, but I cannot make any guarantees.
I tried using the USB protocol to control the camera, but I was having issues downloading images from the camera, so I switched to the WiFi API.
To reverse engineer, I have a local WiFi hotspot setup on my computer. I have my phone and camera both connected to that hotspot. Then, I send commands to the camera with the Lumix Sync app and intercept the packets with Wireshark.
Installation
These are the requirements to install, but this is not an exhaustive list. It you have errors when building, create an "Issue" here on GitHub, as it might be a required library that is not installed.
# for debian based systems
sudo apt update
sudo apt install git libssl-dev libpoco-dev libpugixml-dev libjpeg-dev libfmt-dev
LibRaw snapshot 202403 is required for support of the Lumix S5II cameras. If you need support for these cameras, then you must build from source from this snapshot or later. If you have an older camera (released over 1-2 years ago), installing the latest stable release of LibRaw should be fine.
# ONLY if your camera was released over 1-2 years ago
sudo apt install libraw
Then make a copy of this repository and go into the folder:
git clone https://github.com/njfdev/liblumix
cd liblumix
Make a build folder and go into it:
mkdir build
cd build
Then, build and install the library:
NOTE: The build can sometimes fail when building the zlib dependency. If this happens, it is usually okay to run it a few more times until it successfully builds.
cmake ../ -DCMAKE_BUILD_TYPE=Release
make
sudo make install
About
A reverse engineered C++ driver for Panasonic Lumix cameras.
Resources
Readme
Activity
Stars
27 stars
Watchers
2 watching
Forks
2 forks
Report repository
Releases
Packages
Used by
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Remove or un-stick sticky/fixed headers that block content
(function() {
function unstick() {
document.querySelectorAll('header, nav, [role="banner"], .header, .navbar, .sticky, .fixed-top, [style*="position: fixed"], [style*="position:sticky"]').forEach(function(el) {
if (el.style.position === 'fixed' || el.style.position === 'sticky' || getComputedStyle(el).position === 'fixed' || getComputedStyle(el).position === 'sticky') {
el.style.position = 'static';
el.style.top = 'auto';
el.style.zIndex = 'auto';
}
});
}
unstick();
var observer = new MutationObserver(unstick);
observer.observe(document.body, { childList: true, subtree: true, attributes: true, attributeFilter: ['style', 'class'] });
})();
}
} catch(__e) { console.warn('[Userscript:Kill Sticky Headers]', __e); }
})();
})();
GitHub - njfdev/liblumix: A reverse engineered C++ driver for Panasonic Lumix cameras. · GitHub
Skip to content
BranchesTags
Repository files navigation
Reverse Engineered C++ Lumix Driver
NOTE: this driver is EXTREMELY early in development and expect frequent issues. However, my goal is for this to become a stable, open-sourced driver over time.
This project provides a C++ driver for Panasonic Lumix cameras using the WiFi API used internally by the Lumix Sync app. This is a hobby project and I am not a professional C++ developer, so best code practices may not be used. However, I encourage you to make a Pull Request if you feel inclined.
Features
  • Connect to Lumix Camera using WiFI over LAN connection
  • Take a photo at any specified exposure length
  • Download and parse the RAW and JPEG versions of a photo that was taken
Purpose for Building
I have gotten interested into Astrophotography, which as you may expect, requires a camera. I could have bought a new camera, but I already have a good Lumix camera. However, there is no Linux driver out there to work with Astrophotography software. Panasonic offers an official SDK, however, it is Windows only, which will not work with my Raspberry Pi Controller.
I am making the code open source so anyone can build it for any platform (x86 Linux, x86 Windows, Arm on Raspberry Pi, etc.).
This driver is designed to be used with INDI, which is a set of Astrophotography drivers.
Method of Building
I own a Lumix S5IIX, so this driver is entirely built and tested with this camera in mind. Other cameras should work, but I cannot make any guarantees.
I tried using the USB protocol to control the camera, but I was having issues downloading images from the camera, so I switched to the WiFi API.
To reverse engineer, I have a local WiFi hotspot setup on my computer. I have my phone and camera both connected to that hotspot. Then, I send commands to the camera with the Lumix Sync app and intercept the packets with Wireshark.
Installation
These are the requirements to install, but this is not an exhaustive list. It you have errors when building, create an "Issue" here on GitHub, as it might be a required library that is not installed.
# for debian based systems
sudo apt update
sudo apt install git libssl-dev libpoco-dev libpugixml-dev libjpeg-dev libfmt-dev
LibRaw snapshot 202403 is required for support of the Lumix S5II cameras. If you need support for these cameras, then you must build from source from this snapshot or later. If you have an older camera (released over 1-2 years ago), installing the latest stable release of LibRaw should be fine.
# ONLY if your camera was released over 1-2 years ago
sudo apt install libraw
Then make a copy of this repository and go into the folder:
git clone https://github.com/njfdev/liblumix
cd liblumix
Make a build folder and go into it:
mkdir build
cd build
Then, build and install the library:
NOTE: The build can sometimes fail when building the zlib dependency. If this happens, it is usually okay to run it a few more times until it successfully builds.
cmake ../ -DCMAKE_BUILD_TYPE=Release
make
sudo make install
About
A reverse engineered C++ driver for Panasonic Lumix cameras.
Resources
Readme
Activity
Stars
27 stars
Watchers
2 watching
Forks
2 forks
Report repository
Releases
Packages
Used by
Contributors
Languages