Differences

This shows you the differences between two versions of the page.

--- gsoc:google-summer-code-2022-openprinting-projects [2022/01/26 19:59]
till
+++ gsoc:google-summer-code-2022-openprinting-projects [2022/02/28 17:42]
Aveekb
@@ Line 8: / Line 8: @@
 Mailing list: [[http://lists.linux-foundation.org/mailman/listinfo/printing-architecture|printing-architecture at lists dot linux-foundation dot org]]
-IRC: #openprinting on Freenode
+IRC: #openprinting on [[https://libera.chat/|Libera.Chat]]
-[[https://github.com/OpenPrinting|OpenPrinting GitHub]]
+Our code repositories: [[https://github.com/OpenPrinting|OpenPrinting GitHub]]
 Keep in touch with [[https://openprinting.github.io/news/|OpenPrinting's state of the art]].
@@ Line 55: / Line 55: @@
 Having multi-function printers in mind (printer, scanner, also often fax in one device) the [[https://ftp.pwg.org/pub/pwg/candidates/cs-ippscan10-20140918-5100.17.pdf|IPP Scan]] standard got created, which allows the use of IPP for both printing and scanning. Especially driverless scanning is possible using the same principles as with driverless printing. Manufacturers actually use eSCL and WSD for driverless scanning instead (also [[https://github.com/alexpevzner/sane-airscan|supported in free software]]), but IPP Scan also helps to get scanning working in environments of only sandboxed packages and to more easily distribute scanner drivers.
-Currently, [[http://www.sane-project.org/|SANE]] is the standard platform for scanning. Here a frontend, for example a GUI user appication, like simple-scan or X-SANE, looks for backends (scanner drivers) which are supplied as dynamically loadable shared libraries in a given directory, runs each backend so that it returns back which of its supported scanners are currently present, having the frontend end up with a list of all currently available scanners and through which backend they are available.
+Currently, [[http://www.sane-project.org/|SANE]] is the standard platform for scanning. Here a frontend, for example a GUI user application, like simple-scan or X-SANE, looks for backends (scanner drivers) which are supplied as dynamically loadable shared libraries in a given directory, runs each backend so that it returns back which of its supported scanners are currently present, having the frontend end up with a list of all currently available scanners and through which backend they are available.
-This architecture is not viable for sandboxed packaging, where the user applications are in separate sandboxed packages and one wants to be able to add scanner drivers, preferrably each scanner driver also in a sandboxed package.
+This architecture is not viable for sandboxed packaging, where the user applications are in separate sandboxed packages and one wants to be able to add scanner drivers, preferably each scanner driver also in a sandboxed package.
 So as we create Printer Applications we create Scanner Applications emulating a driverless IPP scanner using the IPP Scan standard. Now scanner drivers can be distributed in individual sandboxed packages, OS-distribution-independent, and for multi-function devices one can even distribute a combined Printer/Scanner Application. The sandboxed packages of user applications which scan only need a backend for IPP Scan and this discovers all Scanner Applications (and scanners in native network devices).
@@ Line 92: / Line 92: @@
 =====GUI for discovering non-driverless printers and finding suitable Printer Applications for them=====
+contributor full-size (350 hours).
 Modern printers usually are driverless IPP printers, and those get discovered and set up fully automatically with CUPS, no Printer Application is required for them, so it is easy for users to get up and running with them.
@@ Line 107: / Line 109: @@
 Code License: GPL-2+ and LGPL-2+
-=====Converting SANE scanner drivers to Scanner Applications=====
+=====Scanning support in PAPPL=====
-By the time when coding starts we will have implemented IPP Scan server functionality to PAPPL and with this we have the base for creating Scanner Applications. To support the thousands of scanners which are already working with [[http://www.sane-project.org/|SANE]] with the new IPP Scan/Scanner Application method, we need to create a retro-fit Scanner Application which uses SANE internally.
+contributor full-size (350 hours).
-One could theoretically make use of the fact that most SANE backends are open-source and so extract the knowledge about how the scanners work and write native drivers, but without having all these scanners at hand for testing the risk is too high, as mentioned above here for the retro-fitting of printer drivers.
+In the Google Summer of Code 2021, Bhavna Kosta has started the work on [[https://github.com/Bhavna2020/GSoC-2021|Scanning support in PAPPL]] so that [[https://github.com/michaelrsweet/pappl/|PAPPL]] not only can be used for creating Printer Applications (emulation of a driverless IPP printer) but also for creating Scanner Applications (emulation of a driverless IPP/eSCL scanner), or even an emulation of a driverless IPP multi-function device.
-Therefore we want to create a framework to encapsulate existing SANE backends in a Scanner Application and do not modify the code of the backends themselves. This would be a SANE fromtend, but not as the ones we know which are primarily operated by a GUI or by the command line. Instead, it will be operated by IPP Scan and an administration web interface, all with the help of PAPPL.
+She has created the [[https://github.com/michaelrsweet/pappl/tree/scanning|needed data structures and API functions]] needed to extend PAPPL for supporting scanners.
-The contributor's task is to create this SANE retro-fit framework, especially making one Scanner Application from the sane-backends projects, but also allow to retro-fit any other SANE backend from a separate project (like HPLIP) into a Scanner Application.
+Next steps to complete the support are the following:
+  * IPP Scan interface: Extend the IPP server of PAPPL to understand IPP Scan requests and respond to them appropriately, so that the application emulates an IPP Scan device
+  * eSCL Scan interface: Add an eSCL interface to make the application emulate an eSCL scanner. eSCL is the most common communication protocol for driverless scanning, also used by AirPrint ([[https://github.com/SimulPiscator/AirSane|Code example]])
+  * Create a test scanner driver emulating a scanner withour needing actual scanner hardware
+  * Unit tests for both IPP Scan and eSCL interfaces
+The contributor's task to implement the above-mentioned components to complete the framework needed by all Scanner Application. With this done, only code for the particular group of scanners to support (scanner driver) needs to be added to PAPPL.
 Mentors: Till Kamppeter, Project Leader OpenPrinting (till at linux dot com), Michael Sweet, author of CUPS and PAPPL (msweet at msweet dot org), Jai Luthra (luthrajaiji at gmail dot com), Dheeraj Yadav (dhirajyadav135 at gmail dot com), Alexander Pevzner (pzz at apevzner dot com), TBD
 Desired knowledge: %%C/C++%%, CUPS
+Code License: Apache 2.0
+=====Print Dialogs: Make them use the Common Print Dialog Backends (CPDB)=====
+contributors full-size (350 hours).
+Most print jobs are sent via the print dialog of a desktop application, like evince, Chrome, LibreOffice, DarkTable, … Print dialogs are usually, like “Open …” or “Save as …” dialogs, provided by the GUI toolkits, in most cases GTK or Qt, sometimes applications come also with their own creations, like LibreOffice or Chrome.
+Problem here is usually not the design of the dialog itself, most are actually easy to use, but the way how they connect to CUPS (and also to other print technologies) and how well this connection code is maintained and kept up-to-date.
+GUI toolkit projects are large projects, often with long release cycles and all with a certain inertia, and there are things which many people are eager to work on, and others, like print dialogs, which have to be there but no one is really motivated to push their development forward and do the needed maintenance work.
+An important part of the maintenance of a GUI toolkit is that it interfaces well and correctly with the underlying operating system, graphics, sound, storage, …, and printing! The OS is under continuous development, things are changing all the time, components get replaced by others, printing is CUPS for 22 years, but within CUPS we have also changes, and they need to be taken care of in the print dialogs.
+Several years back, CUPS started to create temporary queues for driverless IPP network printers (or remote CUPS printers, which are emulations of IPP printers), which are only physically available when they are accessed (capabilities are polled or job printed). Print dialogs used an old API which did not support this, the temporary queues did not appear in the dialog, a helper daemon, cups-browsed had to convert the temporary queues into physical queues as a workaround. The correct solution had been to change the print dialogs to a newer CUPS API which supports these queues, but no one at the GUI toolkit projects has felt responsible and taken the time for this update for many years. Only recently this got fixed.
+This made me introducing the Common Print Dialog Backends (CPDB) back in 2017, a de-coupling of the print technology (CUPS, print-to-file, that time also Google Cloud Print) from the GUI. The GUI projects have to adopt the CPDB support only once and then OpenPrinting (or any upcoming cloud printing projects) takes care of the CPDB backend for the print technologies to be up-to-date with any changes. This way print technology projects can react quickly and are not dependent any more on the GUI toolkit’s inertia.
+As far as I know the GTK, Qt, and LibreOffice print dialogs support temporary print queues now (but only recently, there are many old dialog versions around), but now we are at the next challenge as we have to assure that the print dialogs use CUPS APIs which do not handle PPDs on the dialog side, so that if the system switched to PPD-less CUPS 3.x that the dialog continues to work. If we get the dialogs using CPDB, these changes happen (if actually needed) only in the CUPS CPDB backend, not in each print dialog individually.
+The contributor's task is to get CPDB into the print dialogs upstream, the UI of them does not need to be changed. Dialogs to be treated are GTK, Qt, (LibreOffice has already CPDB support AFAIR), Chrome, and perhaps others. Also important are backports, as there are many apps based on old toolkit versions around in the distributions (Firefox? Thunderbird?).
+For the CPDB integration we do not need UI design work.
+Mentors: Till Kamppeter, Project Leader OpenPrinting (till at linux dot com), GNOME/GTK developers, Qt developers, TBD
+Desired knowledge: %%C/C++%%, GTK or Qt, DNS-SD/Avahi, CUPS/IPP
+Code License: GPL-2+ and LGPL-2+, Apache 2.0
+=====Converting Braille embosser support into a Printer Application=====
+contributor full-size (350 hours).
+cups-filters currently supports Braille embossers through a series of PPD files and shell scripts that convert documents into a textual layout, convert the text into Braille dots, and convert the Braille dots to braille embosser-specific formats.
+For long-term support and wide availability, this needs to be converted to the newer CUPS infrastructure, Printer Applications.
+The contributor's task is thus:
+  * Converting these shell scripts into filter functions in libcupsfilters
+  * Creating a Printer Application that exposes Braille embossers configuration to users
+The contributor does not need to own any specific hardware, a comparison can be made between the output of the existing shell-script-based implementation and the output of the converted implementation.
+Mentors: Till Kamppeter, Project Leader OpenPrinting (till at linux dot com), Samuel Thibault, Braille expert (samuel dot thibault at ens-lyon dot org)
+Desired knowledge: %%C/C++%%, Shell, CUPS
 Code License: Apache 2.0
@@ Line 125: / Line 183: @@
 =====cups-filters: In filter functions call Ghostscript via libgs and not as external executable=====
+contributor half-size (175 hrs)
 cups-filters has always provided the filters which CUPS needs to convert job data from the input format (PDF in most cases) into the printer's native language. For use in Printer Applications the filters got converted from standalone executables to library functions, reducing the number of calls of separate executables and so saving resources.
@@ Line 140: / Line 200: @@
 =====cups-filters: Add Avahi calls for discovering and resolving driverless IPP printers to API and optimize the processes=====
+contributor half-size (175 hrs)
 The cups-browsed daemon and the "driverless" utility discover DNS-SD-advertised IPP printers in the network, for the former to automatically create queues and the latter to list the printers for printer setup tools and auto-generate PPD files for them.
@@ Line 159: / Line 221: @@
 =====cups-filters: Create OCR filter to deliver scans as searchable PDFs=====
+contributor half-size (175 hrs)
 Scanning with IPP Scan gives the user the possibility to request the scanned image in PDF format. If the IPP Scan server is a Scanner Application, a filter function from cups-filters would convert the the raster image coming from the scanner into PDF.
@@ Line 176: / Line 240: @@
 =====Turn the scp-dbus-service methods - GetBestDrivers and MissingExecutables - of system-config-printer into C=====
+contributor full-size (350 hrs)
 system-config-printer was the default printer setup tool in Red Hat/Fedora Linux for a lot of time and also got adopted by Ubuntu around ten years ago. During this time it received a lot of development work, especially on the algorithms for finding the best driver for a printer and for identifying whether printer discovery results from the CUPS backends actually come from the same physical printer.

Wiki

User Tools

Site Tools

Differences

Page Tools