diff --git a/Base/etc/SystemServer.ini b/Base/etc/SystemServer.ini index 0f2d12a3dfb..e24dd6c914c 100644 --- a/Base/etc/SystemServer.ini +++ b/Base/etc/SystemServer.ini @@ -16,6 +16,15 @@ BootModes=graphical MultiInstance=1 AcceptSocketConnections=1 +[ImageDecoder] +Socket=/tmp/portal/image +SocketPermissions=660 +Lazy=1 +User=image +BootModes=graphical +MultiInstance=1 +AcceptSocketConnections=1 + [LookupServer] Socket=/tmp/portal/lookup SocketPermissions=660 diff --git a/Base/etc/group b/Base/etc/group index 5dd2b89ac34..374eeca8aa4 100644 --- a/Base/etc/group +++ b/Base/etc/group @@ -9,4 +9,5 @@ notify:x:12:anon window:x:13:anon,notify clipboard:x:14:anon,notify webcontent:x:15:anon +image:x:16:anon,webcontent users:x:100:anon diff --git a/Base/etc/passwd b/Base/etc/passwd index d52852ce2cd..7179b42dd8a 100644 --- a/Base/etc/passwd +++ b/Base/etc/passwd @@ -5,5 +5,6 @@ notify:x:12:12:NotificationServer,,,:/:/bin/false window:x:13:13:WindowServer,,,:/:/bin/false clipboard:x:14:14:Clipboard,,,:/:/bin/false webcontent:x:15:15:WebContent,,,:/:/bin/false +image:x:16:16:ImageDecoder,,,:/:/bin/false anon:x:100:100:Anonymous,,,:/home/anon:/bin/sh nona:x:200:200:Nona,,,:/home/nona:/bin/sh diff --git a/Libraries/CMakeLists.txt b/Libraries/CMakeLists.txt index 9d5eb6703ce..41e3fedb565 100644 --- a/Libraries/CMakeLists.txt +++ b/Libraries/CMakeLists.txt @@ -9,6 +9,7 @@ add_subdirectory(LibGfx) add_subdirectory(LibGUI) add_subdirectory(LibHTTP) add_subdirectory(LibIPC) +add_subdirectory(LibImageDecoderClient) add_subdirectory(LibJS) add_subdirectory(LibKeyboard) add_subdirectory(LibLine) diff --git a/Libraries/LibGfx/Bitmap.cpp b/Libraries/LibGfx/Bitmap.cpp index d1d34069d66..03831bafab2 100644 --- a/Libraries/LibGfx/Bitmap.cpp +++ b/Libraries/LibGfx/Bitmap.cpp @@ -28,13 +28,13 @@ #include #include #include -#include #include +#include #include +#include #include #include #include -#include #include #include #include @@ -71,7 +71,7 @@ Bitmap::Bitmap(BitmapFormat format, const IntSize& size, Purgeable purgeable) { ASSERT(!m_size.is_empty()); ASSERT(!size_would_overflow(format, size)); - allocate_palette_from_format(format); + allocate_palette_from_format(format, {}); int map_flags = purgeable == Purgeable::Yes ? (MAP_PURGEABLE | MAP_PRIVATE) : (MAP_ANONYMOUS | MAP_PRIVATE); m_data = (RGBA32*)mmap_with_name(nullptr, size_in_bytes(), PROT_READ | PROT_WRITE, map_flags, 0, 0, String::format("GraphicsBitmap [%dx%d]", width(), height()).characters()); ASSERT(m_data && m_data != (void*)-1); @@ -103,25 +103,35 @@ Bitmap::Bitmap(BitmapFormat format, const IntSize& size, size_t pitch, RGBA32* d , m_format(format) { ASSERT(!size_would_overflow(format, size)); - allocate_palette_from_format(format); + allocate_palette_from_format(format, {}); } RefPtr Bitmap::create_with_shared_buffer(BitmapFormat format, NonnullRefPtr&& shared_buffer, const IntSize& size) { if (size_would_overflow(format, size)) return nullptr; - return adopt(*new Bitmap(format, move(shared_buffer), size)); + return adopt(*new Bitmap(format, move(shared_buffer), size, {})); } -Bitmap::Bitmap(BitmapFormat format, NonnullRefPtr&& shared_buffer, const IntSize& size) +RefPtr Bitmap::create_with_shared_buffer(BitmapFormat format, NonnullRefPtr&& shared_buffer, const IntSize& size, const Vector& palette) +{ + if (size_would_overflow(format, size)) + return nullptr; + return adopt(*new Bitmap(format, move(shared_buffer), size, palette)); +} + +Bitmap::Bitmap(BitmapFormat format, NonnullRefPtr&& shared_buffer, const IntSize& size, const Vector& palette) : m_size(size) , m_data((RGBA32*)shared_buffer->data()) , m_pitch(round_up_to_power_of_two(size.width() * sizeof(RGBA32), 16)) , m_format(format) , m_shared_buffer(move(shared_buffer)) { - ASSERT(!is_indexed(format)); + ASSERT(!is_indexed() || !palette.is_empty()); ASSERT(!size_would_overflow(format, size)); + + if (is_indexed(m_format)) + allocate_palette_from_format(m_format, palette); } RefPtr Bitmap::rotated(Gfx::RotationDirection rotation_direction) const @@ -175,7 +185,7 @@ RefPtr Bitmap::to_bitmap_backed_by_shared_buffer() const if (m_shared_buffer) return *this; auto buffer = SharedBuffer::create_with_size(size_in_bytes()); - auto bitmap = Bitmap::create_with_shared_buffer(m_format, *buffer, m_size); + auto bitmap = Bitmap::create_with_shared_buffer(m_format, *buffer, m_size, palette_to_vector()); if (!bitmap) return nullptr; memcpy(buffer->data(), scanline(0), size_in_bytes()); @@ -249,17 +259,26 @@ ShareableBitmap Bitmap::to_shareable_bitmap(pid_t peer_pid) const return ShareableBitmap(*bitmap); } -void Bitmap::allocate_palette_from_format(BitmapFormat format) +void Bitmap::allocate_palette_from_format(BitmapFormat format, const Vector& source_palette) { - if (format == BitmapFormat::Indexed1) { - m_palette = new RGBA32[2]; - } else if (format == BitmapFormat::Indexed2) { - m_palette = new RGBA32[4]; - } else if (format == BitmapFormat::Indexed4) { - m_palette = new RGBA32[16]; - } else if (format == BitmapFormat::Indexed8) { - m_palette = new RGBA32[256]; + size_t size = palette_size(format); + if (size == 0) + return; + m_palette = new RGBA32[size]; + if (!source_palette.is_empty()) { + ASSERT(source_palette.size() == size); + memcpy(m_palette, source_palette.data(), size * sizeof(RGBA32)); } } +Vector Bitmap::palette_to_vector() const +{ + Vector vector; + auto size = palette_size(m_format); + vector.ensure_capacity(size); + for (size_t i = 0; i < size; ++i) + vector.unchecked_append(palette_color(i).value()); + return vector; +} + } diff --git a/Libraries/LibGfx/Bitmap.h b/Libraries/LibGfx/Bitmap.h index b6fac7fffeb..999130fb23a 100644 --- a/Libraries/LibGfx/Bitmap.h +++ b/Libraries/LibGfx/Bitmap.h @@ -65,6 +65,7 @@ public: static RefPtr create_wrapper(BitmapFormat, const IntSize&, size_t pitch, RGBA32*); static RefPtr load_from_file(const StringView& path); static RefPtr create_with_shared_buffer(BitmapFormat, NonnullRefPtr&&, const IntSize&); + static RefPtr create_with_shared_buffer(BitmapFormat, NonnullRefPtr&&, const IntSize&, const Vector& palette); static bool is_path_a_supported_image_format(const StringView& path) { #define __ENUMERATE_IMAGE_FORMAT(Name, Ext) \ @@ -102,12 +103,35 @@ public: SharedBuffer* shared_buffer() { return m_shared_buffer.ptr(); } const SharedBuffer* shared_buffer() const { return m_shared_buffer.ptr(); } + ALWAYS_INLINE bool is_indexed() const + { + return is_indexed(m_format); + } + ALWAYS_INLINE static bool is_indexed(BitmapFormat format) { return format == BitmapFormat::Indexed8 || format == BitmapFormat::Indexed4 || format == BitmapFormat::Indexed2 || format == BitmapFormat::Indexed1; } + size_t palette_size(BitmapFormat format) const + { + switch (format) { + case BitmapFormat::Indexed1: + return 2; + case BitmapFormat::Indexed2: + return 4; + case BitmapFormat::Indexed4: + return 16; + case BitmapFormat::Indexed8: + return 256; + default: + return 0; + } + } + + Vector palette_to_vector() const; + static unsigned bpp_for_format(BitmapFormat format) { switch (format) { @@ -186,9 +210,9 @@ private: Yes }; Bitmap(BitmapFormat, const IntSize&, Purgeable); Bitmap(BitmapFormat, const IntSize&, size_t pitch, RGBA32*); - Bitmap(BitmapFormat, NonnullRefPtr&&, const IntSize&); + Bitmap(BitmapFormat, NonnullRefPtr&&, const IntSize&, const Vector& palette); - void allocate_palette_from_format(BitmapFormat); + void allocate_palette_from_format(BitmapFormat, const Vector& source_palette ); IntSize m_size; RGBA32* m_data { nullptr }; diff --git a/Libraries/LibImageDecoderClient/CMakeLists.txt b/Libraries/LibImageDecoderClient/CMakeLists.txt new file mode 100644 index 00000000000..72a5ab29346 --- /dev/null +++ b/Libraries/LibImageDecoderClient/CMakeLists.txt @@ -0,0 +1,11 @@ +set(SOURCES + Client.cpp +) + +set(GENERATED_SOURCES + ../../Services/ImageDecoder/ImageDecoderClientEndpoint.h + ../../Services/ImageDecoder/ImageDecoderServerEndpoint.h +) + +serenity_lib(LibImageDecoderClient imagedecoderclient) +target_link_libraries(LibImageDecoderClient LibIPC LibGfx) diff --git a/Libraries/LibImageDecoderClient/Client.cpp b/Libraries/LibImageDecoderClient/Client.cpp new file mode 100644 index 00000000000..9aa7b2a4cd5 --- /dev/null +++ b/Libraries/LibImageDecoderClient/Client.cpp @@ -0,0 +1,88 @@ +/* + * Copyright (c) 2020, Andreas Kling + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * 1. Redistributions of source code must retain the above copyright notice, this + * list of conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR + * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER + * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include +#include + +namespace ImageDecoderClient { + +Client::Client() + : IPC::ServerConnection(*this, "/tmp/portal/image") +{ + handshake(); +} + +void Client::handshake() +{ + auto response = send_sync(getpid()); + set_my_client_id(response->client_id()); + set_server_pid(response->server_pid()); +} + +void Client::handle(const Messages::ImageDecoderClient::Dummy&) +{ +} + +RefPtr Client::decode_image(const ByteBuffer& encoded_data) +{ + if (encoded_data.is_empty()) + return nullptr; + + auto encoded_buffer = SharedBuffer::create_with_size(encoded_data.size()); + if (!encoded_buffer) { + dbg() << "Could not allocate encoded shbuf"; + return nullptr; + } + + memcpy(encoded_buffer->data(), encoded_data.data(), encoded_data.size()); + + encoded_buffer->seal(); + encoded_buffer->share_with(server_pid()); + + auto response = send_sync(encoded_buffer->shbuf_id(), encoded_data.size()); + auto bitmap_format = (Gfx::BitmapFormat)response->bitmap_format(); + if (bitmap_format == Gfx::BitmapFormat::Invalid) { +#ifdef IMAGE_DECODER_CLIENT_DEBUG + dbg() << "Response image was invalid"; +#endif + return nullptr; + } + + if (response->size().is_empty()) { + dbg() << "Response image was empty"; + return nullptr; + } + + auto decoded_buffer = SharedBuffer::create_from_shbuf_id(response->decoded_shbuf_id()); + if (!decoded_buffer) { + dbg() << "Could not map decoded image shbuf_id=" << response->decoded_shbuf_id(); + return nullptr; + } + + return Gfx::Bitmap::create_with_shared_buffer(bitmap_format, decoded_buffer.release_nonnull(), response->size(), response->palette()); +} + +} diff --git a/Libraries/LibImageDecoderClient/Client.h b/Libraries/LibImageDecoderClient/Client.h new file mode 100644 index 00000000000..7eeace6b22d --- /dev/null +++ b/Libraries/LibImageDecoderClient/Client.h @@ -0,0 +1,52 @@ +/* + * Copyright (c) 2020, Andreas Kling + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * 1. Redistributions of source code must retain the above copyright notice, this + * list of conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR + * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER + * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#pragma once + +#include +#include +#include +#include + +namespace ImageDecoderClient { + +class Client + : public IPC::ServerConnection + , public ImageDecoderClientEndpoint { + C_OBJECT(Client); + +public: + virtual void handshake() override; + + RefPtr decode_image(const ByteBuffer&); + +private: + Client(); + + virtual void handle(const Messages::ImageDecoderClient::Dummy&) override; +}; + +} diff --git a/Services/CMakeLists.txt b/Services/CMakeLists.txt index 364c7ea574d..71a343a009d 100644 --- a/Services/CMakeLists.txt +++ b/Services/CMakeLists.txt @@ -1,6 +1,7 @@ add_subdirectory(AudioServer) add_subdirectory(Clipboard) add_subdirectory(DHCPClient) +add_subdirectory(ImageDecoder) add_subdirectory(LaunchServer) add_subdirectory(LookupServer) add_subdirectory(NotificationServer) diff --git a/Services/ImageDecoder/CMakeLists.txt b/Services/ImageDecoder/CMakeLists.txt new file mode 100644 index 00000000000..ce9ad077fc4 --- /dev/null +++ b/Services/ImageDecoder/CMakeLists.txt @@ -0,0 +1,12 @@ +compile_ipc(ImageDecoderServer.ipc ImageDecoderServerEndpoint.h) +compile_ipc(ImageDecoderClient.ipc ImageDecoderClientEndpoint.h) + +set(SOURCES + ClientConnection.cpp + main.cpp + ImageDecoderServerEndpoint.h + ImageDecoderClientEndpoint.h +) + +serenity_bin(ImageDecoder) +target_link_libraries(ImageDecoder LibIPC LibGfx) diff --git a/Services/ImageDecoder/ClientConnection.cpp b/Services/ImageDecoder/ClientConnection.cpp new file mode 100644 index 00000000000..ce7ec85d6b3 --- /dev/null +++ b/Services/ImageDecoder/ClientConnection.cpp @@ -0,0 +1,102 @@ +/* + * Copyright (c) 2020, Andreas Kling + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * 1. Redistributions of source code must retain the above copyright notice, this + * list of conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR + * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER + * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include +#include +#include +#include +#include +#include +#include + +namespace ImageDecoder { + +static HashMap> s_connections; + +ClientConnection::ClientConnection(Core::LocalSocket& socket, int client_id) + : IPC::ClientConnection(*this, socket, client_id) +{ + s_connections.set(client_id, *this); +} + +ClientConnection::~ClientConnection() +{ +} + +void ClientConnection::die() +{ + s_connections.remove(client_id()); + exit(0); +} + +OwnPtr ClientConnection::handle(const Messages::ImageDecoderServer::Greet& message) +{ + set_client_pid(message.client_pid()); + return make(client_id(), getpid()); +} + +OwnPtr ClientConnection::handle(const Messages::ImageDecoderServer::DecodeImage& message) +{ + auto encoded_buffer = SharedBuffer::create_from_shbuf_id(message.encoded_shbuf_id()); + if (!encoded_buffer) { +#ifdef IMAGE_DECODER_DEBUG + dbg() << "Could not map encoded data buffer"; +#endif + return nullptr; + } + + if (message.encoded_size() > (size_t)encoded_buffer->size()) { +#ifdef IMAGE_DECODER_DEBUG + dbg() << "Encoded buffer is smaller than encoded size"; +#endif + return nullptr; + } + +#ifdef IMAGE_DECODER_DEBUG + dbg() << "Trying to decode " << message.encoded_size() << " bytes of image(?) data in shbuf_id=" << message.encoded_shbuf_id() << " (shbuf size: " << encoded_buffer->size() << ")"; +#endif + + auto decoder = Gfx::ImageDecoder::create((const u8*)encoded_buffer->data(), message.encoded_size()); + auto bitmap = decoder->bitmap(); + + if (!bitmap) { +#ifdef IMAGE_DECODER_DEBUG + dbg() << "Could not decode image from encoded data"; +#endif + return make(-1, Gfx::IntSize(), (i32)Gfx::BitmapFormat::Invalid, Vector()); + } + + // FIXME: We should fix ShareableBitmap so you can send it in responses as well as requests.. + m_shareable_bitmap = bitmap->to_bitmap_backed_by_shared_buffer(); + m_shareable_bitmap->shared_buffer()->share_with(client_pid()); + Vector palette; + if (m_shareable_bitmap->is_indexed()) { + palette = m_shareable_bitmap->palette_to_vector(); + } + return make(m_shareable_bitmap->shbuf_id(), m_shareable_bitmap->size(), (i32)m_shareable_bitmap->format(), palette); +} + +} diff --git a/Services/ImageDecoder/ClientConnection.h b/Services/ImageDecoder/ClientConnection.h new file mode 100644 index 00000000000..3b47ed18945 --- /dev/null +++ b/Services/ImageDecoder/ClientConnection.h @@ -0,0 +1,55 @@ +/* + * Copyright (c) 2020, Andreas Kling + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * 1. Redistributions of source code must retain the above copyright notice, this + * list of conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR + * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER + * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#pragma once + +#include +#include +#include +#include +#include + +namespace ImageDecoder { + +class ClientConnection final + : public IPC::ClientConnection + , public ImageDecoderServerEndpoint { + C_OBJECT(ClientConnection); + +public: + explicit ClientConnection(Core::LocalSocket&, int client_id); + ~ClientConnection() override; + + virtual void die() override; + +private: + virtual OwnPtr handle(const Messages::ImageDecoderServer::Greet&) override; + virtual OwnPtr handle(const Messages::ImageDecoderServer::DecodeImage&) override; + + RefPtr m_shareable_bitmap; +}; + +} diff --git a/Services/ImageDecoder/Forward.h b/Services/ImageDecoder/Forward.h new file mode 100644 index 00000000000..e43ca839609 --- /dev/null +++ b/Services/ImageDecoder/Forward.h @@ -0,0 +1,34 @@ +/* + * Copyright (c) 2020, Andreas Kling + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * 1. Redistributions of source code must retain the above copyright notice, this + * list of conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR + * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER + * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#pragma once + +namespace WebContent { + +class ClientConnection; +class PageHost; + +} diff --git a/Services/ImageDecoder/ImageDecoderClient.ipc b/Services/ImageDecoder/ImageDecoderClient.ipc new file mode 100644 index 00000000000..49dc3862c25 --- /dev/null +++ b/Services/ImageDecoder/ImageDecoderClient.ipc @@ -0,0 +1,4 @@ +endpoint ImageDecoderClient = 7002 +{ + Dummy() =| +} diff --git a/Services/ImageDecoder/ImageDecoderServer.ipc b/Services/ImageDecoder/ImageDecoderServer.ipc new file mode 100644 index 00000000000..295454282fb --- /dev/null +++ b/Services/ImageDecoder/ImageDecoderServer.ipc @@ -0,0 +1,7 @@ +endpoint ImageDecoderServer = 7001 +{ + Greet(i32 client_pid) => (i32 client_id, i32 server_pid) + + DecodeImage(i32 encoded_shbuf_id, u32 encoded_size) => (i32 decoded_shbuf_id, Gfx::IntSize size, i32 bitmap_format, Vector palette) + +} diff --git a/Services/ImageDecoder/main.cpp b/Services/ImageDecoder/main.cpp new file mode 100644 index 00000000000..1ee15b14960 --- /dev/null +++ b/Services/ImageDecoder/main.cpp @@ -0,0 +1,51 @@ +/* + * Copyright (c) 2020, Andreas Kling + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * 1. Redistributions of source code must retain the above copyright notice, this + * list of conditions and the following disclaimer. + * + * 2. Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE + * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL + * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR + * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER + * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include +#include +#include +#include + +int main(int, char**) +{ + Core::EventLoop event_loop; + if (pledge("stdio shared_buffer unix", nullptr) < 0) { + perror("pledge"); + return 1; + } + if (unveil(nullptr, nullptr) < 0) { + perror("unveil"); + return 1; + } + + auto socket = Core::LocalSocket::take_over_accepted_socket_from_system_server(); + IPC::new_client_connection(*socket, 1); + if (pledge("stdio shared_buffer", nullptr) < 0) { + perror("pledge"); + return 1; + } + return event_loop.exec(); +}