misc/piphoto
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Move ToPng() into Image, make PiRaw static-only

Browse Source
This commit is contained in:
Ian Gulliver
2017-08-06 19:55:31 +00:00
parent acaac65ac5
commit 680191a11d
3 changed files with 57 additions and 74 deletions
Download Patch File Download Diff File Expand all files Collapse all files

82
piraw.h
View File

@@ -1,8 +1,5 @@
#pragma once
#include <arpa/inet.h>
#include <png.h>
#include <cassert>
#include <experimental/string_view>
@@ -16,16 +13,12 @@ using string_view = experimental::string_view;
template <uint32_t X, uint32_t Y, uint32_t D, uint32_t A, uint32_t P>
class PiRaw {
public:
PiRaw(std::unique_ptr<Image<X, Y>>);
static PiRaw FromJpeg(const std::string_view& jpeg);
static PiRaw FromRaw(const std::string_view& raw);
std::string ToPng();
Image<X, Y>* GetImage();
const Image<X, Y>& GetImage() const;
static std::unique_ptr<Image<X, Y>> FromJpeg(const std::string_view& jpeg);
static std::unique_ptr<Image<X, Y>> FromRaw(const std::string_view& raw);
private:
PiRaw() {}
static constexpr uint32_t kJpegHeaderBytes = 32768;
static constexpr const char* kJpegHeaderMagic = "BRCM";
static constexpr uint32_t kPixelsPerChunk = 4;
@@ -40,27 +33,21 @@ class PiRaw {
typedef std::array<uint32_t, kPixelsPerChunk> Chunk;
static Chunk GetChunk(const std::string_view& raw, const uint32_t x_chunk, const uint32_t y);
static Color CombineRaw(uint32_t y0x0, uint32_t y0x1, uint32_t y1x0, uint32_t y1x1);
std::unique_ptr<Image<X, Y>> image_;
static constexpr Chunk GetChunk(const std::string_view& raw, const uint32_t x_chunk, const uint32_t y);
static constexpr Color CombineRaw(uint32_t y0x0, uint32_t y0x1, uint32_t y1x0, uint32_t y1x1);
};
typedef PiRaw<3280, 2464, 10, 16, 2> PiRaw2;
template <uint32_t X, uint32_t Y, uint32_t D, uint32_t A, uint32_t P>
PiRaw<X, Y, D, A, P>::PiRaw(std::unique_ptr<Image<X, Y>> image)
: image_(std::move(image)) {}
template <uint32_t X, uint32_t Y, uint32_t D, uint32_t A, uint32_t P>
PiRaw<X, Y, D, A, P> PiRaw<X, Y, D, A, P>::FromJpeg(const std::string_view& jpeg) {
typename std::unique_ptr<Image<X, Y>> PiRaw<X, Y, D, A, P>::FromJpeg(const std::string_view& jpeg) {
auto container_len = GetRawBytes() + kJpegHeaderBytes;
assert(jpeg.substr(jpeg.size() - container_len, 4) == kJpegHeaderMagic);
return FromRaw(jpeg.substr(jpeg.size() - GetRawBytes(), GetRawBytes()));
}
template <uint32_t X, uint32_t Y, uint32_t D, uint32_t A, uint32_t P>
PiRaw<X, Y, D, A, P> PiRaw<X, Y, D, A, P>::FromRaw(const std::string_view& raw) {
typename std::unique_ptr<Image<X, Y>> PiRaw<X, Y, D, A, P>::FromRaw(const std::string_view& raw) {
static_assert(X % 2 == 0);
static_assert(Y % 2 == 0);
static_assert(kPixelsPerChunk == 4);
@@ -77,7 +64,7 @@ PiRaw<X, Y, D, A, P> PiRaw<X, Y, D, A, P>::FromRaw(const std::string_view& raw)
image->at(out_y).at(out_x + 1) = CombineRaw(chunk1.at(2), chunk1.at(3), chunk2.at(2), chunk2.at(3));
}
}
return PiRaw<X, Y, D, A, P>(std::move(image));
return image;
}
template <uint32_t X, uint32_t Y, uint32_t D, uint32_t A, uint32_t P>
@@ -106,7 +93,7 @@ constexpr uint32_t PiRaw<X, Y, D, A, P>::Align(uint32_t val) {
}
template <uint32_t X, uint32_t Y, uint32_t D, uint32_t A, uint32_t P>
typename PiRaw<X, Y, D, A, P>::Chunk PiRaw<X, Y, D, A, P>::GetChunk(const std::string_view& raw, const uint32_t x_chunk, const uint32_t y) {
constexpr typename PiRaw<X, Y, D, A, P>::Chunk PiRaw<X, Y, D, A, P>::GetChunk(const std::string_view& raw, const uint32_t x_chunk, const uint32_t y) {
// Function is bit depth & layout specific
static_assert(D == 10);
@@ -126,7 +113,7 @@ typename PiRaw<X, Y, D, A, P>::Chunk PiRaw<X, Y, D, A, P>::GetChunk(const std::s
}
template <uint32_t X, uint32_t Y, uint32_t D, uint32_t A, uint32_t P>
Color PiRaw<X, Y, D, A, P>::CombineRaw(uint32_t y0x0, uint32_t y0x1, uint32_t y1x0, uint32_t y1x1) {
constexpr Color PiRaw<X, Y, D, A, P>::CombineRaw(uint32_t y0x0, uint32_t y0x1, uint32_t y1x0, uint32_t y1x1) {
// Function is bit layout specific
Color ret;
ret.r = y1x1;
@@ -134,50 +121,3 @@ Color PiRaw<X, Y, D, A, P>::CombineRaw(uint32_t y0x0, uint32_t y0x1, uint32_t y1
ret.b = y0x0;
return ret;
}
static void WriteCallback(png_structp png_ptr, png_bytep data, png_size_t length) {
auto dest = static_cast<std::string*>(png_get_io_ptr(png_ptr));
dest->append(reinterpret_cast<char*>(data), length);
}
template <uint32_t X, uint32_t Y, uint32_t D, uint32_t A, uint32_t P>
std::string PiRaw<X, Y, D, A, P>::ToPng() {
std::string ret;
auto png_ptr = png_create_write_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);
assert(png_ptr);
auto info_ptr = png_create_info_struct(png_ptr);
assert(info_ptr);
png_set_write_fn(png_ptr, &ret, &WriteCallback, nullptr);
png_set_IHDR(png_ptr, info_ptr, X / 2, Y / 2,
16, PNG_COLOR_TYPE_RGB, PNG_INTERLACE_NONE,
PNG_COMPRESSION_TYPE_BASE, PNG_FILTER_TYPE_BASE);
png_write_info(png_ptr, info_ptr);
for (auto& row : *image_) {
std::array<uint16_t, X * 3> out_row;
for (uint32_t x = 0; x < X; ++x) {
out_row[x * 3 + 0] = htons(static_cast<uint16_t>(row[x].r));
out_row[x * 3 + 1] = htons(static_cast<uint16_t>(row[x].g));
out_row[x * 3 + 2] = htons(static_cast<uint16_t>(row[x].b));
}
png_write_row(png_ptr, reinterpret_cast<unsigned char*>(out_row.data()));
}
png_write_end(png_ptr, nullptr);
png_free_data(png_ptr, info_ptr, PNG_FREE_ALL, -1);
png_destroy_write_struct(&png_ptr, &info_ptr);
return ret;
}
template <uint32_t X, uint32_t Y, uint32_t D, uint32_t A, uint32_t P>
Image<X, Y>* PiRaw<X, Y, D, A, P>::GetImage() {
return image_.get();
}
template <uint32_t X, uint32_t Y, uint32_t D, uint32_t A, uint32_t P>
const Image<X, Y>& PiRaw<X, Y, D, A, P>::GetImage() const {
return *image_;
}