pyjpeg 0.1__tar.gz

pyjpeg-0.1/.gitignore

@@ -0,0 +1,2 @@
+__pycache__
+dist/

pyjpeg-0.1/LICENSE

@@ -0,0 +1,165 @@
+                   GNU LESSER GENERAL PUBLIC LICENSE
+                       Version 3, 29 June 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+
+  This version of the GNU Lesser General Public License incorporates
+the terms and conditions of version 3 of the GNU General Public
+License, supplemented by the additional permissions listed below.
+
+  0. Additional Definitions.
+
+  As used herein, "this License" refers to version 3 of the GNU Lesser
+General Public License, and the "GNU GPL" refers to version 3 of the GNU
+General Public License.
+
+  "The Library" refers to a covered work governed by this License,
+other than an Application or a Combined Work as defined below.
+
+  An "Application" is any work that makes use of an interface provided
+by the Library, but which is not otherwise based on the Library.
+Defining a subclass of a class defined by the Library is deemed a mode
+of using an interface provided by the Library.
+
+  A "Combined Work" is a work produced by combining or linking an
+Application with the Library.  The particular version of the Library
+with which the Combined Work was made is also called the "Linked
+Version".
+
+  The "Minimal Corresponding Source" for a Combined Work means the
+Corresponding Source for the Combined Work, excluding any source code
+for portions of the Combined Work that, considered in isolation, are
+based on the Application, and not on the Linked Version.
+
+  The "Corresponding Application Code" for a Combined Work means the
+object code and/or source code for the Application, including any data
+and utility programs needed for reproducing the Combined Work from the
+Application, but excluding the System Libraries of the Combined Work.
+
+  1. Exception to Section 3 of the GNU GPL.
+
+  You may convey a covered work under sections 3 and 4 of this License
+without being bound by section 3 of the GNU GPL.
+
+  2. Conveying Modified Versions.
+
+  If you modify a copy of the Library, and, in your modifications, a
+facility refers to a function or data to be supplied by an Application
+that uses the facility (other than as an argument passed when the
+facility is invoked), then you may convey a copy of the modified
+version:
+
+   a) under this License, provided that you make a good faith effort to
+   ensure that, in the event an Application does not supply the
+   function or data, the facility still operates, and performs
+   whatever part of its purpose remains meaningful, or
+
+   b) under the GNU GPL, with none of the additional permissions of
+   this License applicable to that copy.
+
+  3. Object Code Incorporating Material from Library Header Files.
+
+  The object code form of an Application may incorporate material from
+a header file that is part of the Library.  You may convey such object
+code under terms of your choice, provided that, if the incorporated
+material is not limited to numerical parameters, data structure
+layouts and accessors, or small macros, inline functions and templates
+(ten or fewer lines in length), you do both of the following:
+
+   a) Give prominent notice with each copy of the object code that the
+   Library is used in it and that the Library and its use are
+   covered by this License.
+
+   b) Accompany the object code with a copy of the GNU GPL and this license
+   document.
+
+  4. Combined Works.
+
+  You may convey a Combined Work under terms of your choice that,
+taken together, effectively do not restrict modification of the
+portions of the Library contained in the Combined Work and reverse
+engineering for debugging such modifications, if you also do each of
+the following:
+
+   a) Give prominent notice with each copy of the Combined Work that
+   the Library is used in it and that the Library and its use are
+   covered by this License.
+
+   b) Accompany the Combined Work with a copy of the GNU GPL and this license
+   document.
+
+   c) For a Combined Work that displays copyright notices during
+   execution, include the copyright notice for the Library among
+   these notices, as well as a reference directing the user to the
+   copies of the GNU GPL and this license document.
+
+   d) Do one of the following:
+
+       0) Convey the Minimal Corresponding Source under the terms of this
+       License, and the Corresponding Application Code in a form
+       suitable for, and under terms that permit, the user to
+       recombine or relink the Application with a modified version of
+       the Linked Version to produce a modified Combined Work, in the
+       manner specified by section 6 of the GNU GPL for conveying
+       Corresponding Source.
+
+       1) Use a suitable shared library mechanism for linking with the
+       Library.  A suitable mechanism is one that (a) uses at run time
+       a copy of the Library already present on the user's computer
+       system, and (b) will operate properly with a modified version
+       of the Library that is interface-compatible with the Linked
+       Version.
+
+   e) Provide Installation Information, but only if you would otherwise
+   be required to provide such information under section 6 of the
+   GNU GPL, and only to the extent that such information is
+   necessary to install and execute a modified version of the
+   Combined Work produced by recombining or relinking the
+   Application with a modified version of the Linked Version. (If
+   you use option 4d0, the Installation Information must accompany
+   the Minimal Corresponding Source and Corresponding Application
+   Code. If you use option 4d1, you must provide the Installation
+   Information in the manner specified by section 6 of the GNU GPL
+   for conveying Corresponding Source.)
+
+  5. Combined Libraries.
+
+  You may place library facilities that are a work based on the
+Library side by side in a single library together with other library
+facilities that are not Applications and are not covered by this
+License, and convey such a combined library under terms of your
+choice, if you do both of the following:
+
+   a) Accompany the combined library with a copy of the same work based
+   on the Library, uncombined with any other library facilities,
+   conveyed under the terms of this License.
+
+   b) Give prominent notice with the combined library that part of it
+   is a work based on the Library, and explaining where to find the
+   accompanying uncombined form of the same work.
+
+  6. Revised Versions of the GNU Lesser General Public License.
+
+  The Free Software Foundation may publish revised and/or new versions
+of the GNU Lesser General Public License from time to time. Such new
+versions will be similar in spirit to the present version, but may
+differ in detail to address new problems or concerns.
+
+  Each version is given a distinguishing version number. If the
+Library as you received it specifies that a certain numbered version
+of the GNU Lesser General Public License "or any later version"
+applies to it, you have the option of following the terms and
+conditions either of that published version or of any later version
+published by the Free Software Foundation. If the Library as you
+received it does not specify a version number of the GNU Lesser
+General Public License, you may choose any version of the GNU Lesser
+General Public License ever published by the Free Software Foundation.
+
+  If the Library as you received it specifies that a proxy can decide
+whether future versions of the GNU Lesser General Public License shall
+apply, that proxy's public statement of acceptance of any version is
+permanent authorization for you to choose that version for the
+Library.

pyjpeg-0.1/PKG-INFO

@@ -0,0 +1,30 @@
+Metadata-Version: 2.4
+Name: pyjpeg
+Version: 0.1
+Summary: Pure Python JPEG image encoder/decoder
+Project-URL: Homepage, https://github.com/robert-ancell/pyjpeg
+Project-URL: Issues, https://github.com/robert-ancell/pyjpeg/issues
+Author-email: Robert Ancell <robert.ancell@gmail.com>
+License-Expression: LGPL-3.0
+License-File: LICENSE
+Classifier: License :: OSI Approved :: GNU Lesser General Public License v3 (LGPLv3)
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Multimedia :: Graphics
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+
+This repository contains a Python encoder and decoder for the [JPEG file format](https://jpeg.org/jpeg/).
+
+The easiest way to get PyJPEG is to install from the [Python Packaging Index](https://pypi.org/project/pyjpeg/):
+```
+pip install pyjpeg
+```
+
+TODO Example:
+```python
+import pyjpeg
+
+# FIXME
+```

pyjpeg-0.1/README.md

@@ -0,0 +1,13 @@
+This repository contains a Python encoder and decoder for the [JPEG file format](https://jpeg.org/jpeg/).
+
+The easiest way to get PyJPEG is to install from the [Python Packaging Index](https://pypi.org/project/pyjpeg/):
+```
+pip install pyjpeg
+```
+
+TODO Example:
+```python
+import pyjpeg
+
+# FIXME
+```

pyjpeg-0.1/analyze.py

@@ -0,0 +1,297 @@
+#!/usr/bin/env python3
+
+import sys
+
+import pyjpeg
+
+
+def print_data_unit(data_unit: list[int]) -> None:
+    values = pyjpeg.dct.unzig_zag(data_unit)
+
+    cols = []
+    for x in range(8):
+        col = []
+        for y in range(8):
+            col.append("%d" % values[y * 8 + x])
+        cols.append(col)
+
+    col_widths = []
+    for x in range(8):
+        width = 0
+        for y in range(8):
+            width = max(width, len(cols[x][y]))
+        col_widths.append(width)
+
+    for y in range(8):
+        row = []
+        for x in range(8):
+            row.append(cols[x][y].rjust(col_widths[x]))
+        print("  %s" % " ".join(row))
+
+
+if len(sys.argv) != 2:
+    print("Usage: analyze.py <filename.jpg>")
+    sys.exit(1)
+
+data = open(sys.argv[1], "rb").read()
+reader = pyjpeg.BufferedReader(data)
+stream = pyjpeg.Stream.read(reader)
+
+is_lossless = False
+is_ls = False
+for segment in stream.segments:
+    if isinstance(segment, pyjpeg.StartOfImage):
+        print("SOI Start of Image")
+    elif isinstance(segment, pyjpeg.JfifHeader):
+        print("APP%d JFIF" % segment.n)
+        print(" Version: %d.%d" % (segment.version[0], segment.version[1]))
+        if segment.density.unit == pyjpeg.JfifDensityUnit.ASPECT_RATIO:
+            print(" Aspect Ratio: %dx%d" % (segment.density.x, segment.density.y))
+        elif segment.density.unit == pyjpeg.JfifDensityUnit.DPI:
+            print(" Density: %dx%ddpi" % (segment.density.x, segment.density.y))
+        elif segment.density.unit == pyjpeg.JfifDensityUnit.DPCM:
+            print(" Density: %dx%ddpcm" % (segment.density.x, segment.density.y))
+        if len(segment.thumbnail_data) > 0:
+            # FIXME: Support RGB thumbnails
+            s = " Thumbnail %dx%d:" % (
+                segment.thumbnail_size[0],
+                segment.thumbnail_size[1],
+            )
+            for i in range(0, len(segment.thumbnail_data), 3):
+                if i % (segment.thumbnail_size[0] * 3) == 0:
+                    s += "\n "
+                s += " %d,%d,%d" % (
+                    segment.thumbnail_data[i],
+                    segment.thumbnail_data[i + 1],
+                    segment.thumbnail_data[i + 2],
+                )
+            print(s)
+    elif isinstance(segment, pyjpeg.JfifJpegThumbnail):
+        print("APP%d JPEG Thumbnail" % segment.n)
+        print(" Data: %s" % repr(segment.data))
+    elif isinstance(segment, pyjpeg.JfifPalletizedThumbnail):
+        print("APP%d Palletized Thumbnail" % segment.n)
+        print(" Width: %d" % segment.width)
+        print(" Height: %d" % segment.height)
+        print(" Data: %s" % segment.data)
+    elif isinstance(segment, pyjpeg.JfifRgbThumbnail):
+        print("APP%d RGB Thumbnail" % segment.n)
+        print(" Width: %d" % segment.width)
+        print(" Height: %d" % segment.height)
+        print(" Data: %s" % segment.data)
+    elif isinstance(segment, pyjpeg.SpiffHeader):
+        print("APP%d SPIFF" % segment.n)
+        print(" Version: %d.%d" % (segment.version[0], segment.version[1]))
+        print(" Profile: %d" % segment.profile)
+        print(" Number of Components: %d" % segment.number_of_components)
+        print(" Height: %d" % segment.height)
+        print(" Width: %d" % segment.width)
+        print(" Color Space: %d" % segment.color_space)
+        print(" Bits per Sample: %d" % segment.bits_per_sample)
+        print(" Compression Type: %d" % segment.compression_type)
+        print(" Resolution Units: %d" % segment.resolution_units)
+        print(" Vertical Resolution: %d" % segment.vertical_resoution)
+        print(" Horizontal Resolution: %d" % segment.horizontal_resolution)
+    elif isinstance(segment, pyjpeg.ExifHeader):
+        print("APP%d EXIF" % segment.n)
+        print(" Data: %r" % segment.data)
+    elif isinstance(segment, pyjpeg.AdobeHeader):
+        print("APP%d Adobe" % segment.n)
+        print(" Version: %d" % segment.version)
+        print(" Flags 0: %04x" % segment.flags0)
+        print(" Flags 1: %04x" % segment.flags1)
+        print(
+            " Colorspace: %s"
+            % {
+                pyjpeg.AdobeColorSpace.RGB_OR_CMYK: "RGB or CMYK",
+                pyjpeg.AdobeColorSpace.Y_CB_CR: "YCbCr",
+                pyjpeg.AdobeColorSpace.Y_CB_CR_K: "YCbCrK",
+            }.get(segment.color_space, "%d" % segment.color_space)
+        )
+    elif isinstance(segment, pyjpeg.UnknownApplicationSpecificData):
+        print("APP%d Application Specific Data" % segment.n)
+        s = " Data: "
+        for d in segment.data:
+            s += "%02X" % d
+        print(s)
+    elif isinstance(segment, pyjpeg.Comment):
+        print("COM Comment")
+        print(" Data: %s" % repr(segment.data))
+    elif isinstance(segment, pyjpeg.DefineQuantizationTables):
+        print("DQT Define Quantization Tables")
+        for quantization_table in segment.tables:
+            print(" Table %d:" % quantization_table.destination)
+            print("  Precision: %d bits" % quantization_table.precision)
+            print_data_unit(quantization_table.values)
+    elif isinstance(segment, pyjpeg.DefineHuffmanTables):
+        print("DHT Define Huffman Tables")
+        for huffman_table in segment.tables:
+            print(
+                " %s Table %d:"
+                % (
+                    {0: "DC", 1: "AC"}[huffman_table.table_class],
+                    huffman_table.destination,
+                )
+            )
+            for i, symbols in enumerate(huffman_table.table):
+                if len(symbols) > 0:
+                    s = "  Symbols of length %d:" % (i + 1)
+                    for symbol in symbols:
+                        s += " %02x" % symbol
+                    print(s)
+    elif isinstance(segment, pyjpeg.DefineArithmeticConditioning):
+        print("DAC Define Arithmetic Conditioning")
+        for conditioning in segment.tables:
+            print(
+                " %s Table %d: %s"
+                % (
+                    {0: "DC", 1: "AC"}[conditioning.table_class],
+                    conditioning.destination,
+                    repr(conditioning.value),
+                )
+            )
+    elif isinstance(segment, pyjpeg.DefineRestartInterval):
+        print("DRI Define Restart Interval")
+        print(" Restart interval: %d" % segment.restart_interval)
+    elif isinstance(segment, pyjpeg.ExpandReferenceComponents):
+        print("EXP Expand Reference Components")
+        print(
+            " Expand Horizontal: %s"
+            % {False: "No", True: "Yes"}[segment.expand_horizontal != 0]
+        )
+        print(
+            " Expand Vertical: %s"
+            % {False: "No", True: "Yes"}[segment.expand_vertical != 0]
+        )
+    elif isinstance(segment, pyjpeg.StartOfFrame):
+        is_lossless = segment.n in (3, 7, 11, 15)
+        is_ls = segment.n == 55
+        print(
+            "SOF%d Start of Frame, %s"
+            % (
+                segment.n,
+                {
+                    pyjpeg.FrameType.BASELINE: "Baseline DCT",
+                    pyjpeg.FrameType.EXTENDED_HUFFMAN: "Extended sequential DCT, Huffman coding",
+                    pyjpeg.FrameType.PROGRESSIVE_HUFFMAN: "Progressive DCT, Huffman coding",
+                    pyjpeg.FrameType.LOSSLESS_HUFFMAN: "Lossless (sequential), Huffman coding",
+                    pyjpeg.FrameType.DIFFERENTIAL_SEQUENTIAL_HUFFMAN: "Differential sequential DCT, Huffman coding",
+                    pyjpeg.FrameType.DIFFERENTIAL_PROGRESSIVE_HUFFMAN: "Differential progressive DCT, Huffman coding",
+                    pyjpeg.FrameType.DIFFERENTIAL_LOSSLESS_HUFFMAN: "Differential lossless (sequential), Huffman coding",
+                    pyjpeg.FrameType.EXTENDED_ARITHMETIC: "Extended sequential DCT, Arithmetic coding",
+                    pyjpeg.FrameType.PROGRESSIVE_ARITHMETIC: "Progressive DCT, Arithmetic coding",
+                    pyjpeg.FrameType.LOSSLESS_ARITHMETIC: "Lossless (sequential), Arithmetic coding",
+                    pyjpeg.FrameType.DIFFERENTIAL_SEQUENTIAL_ARITHMETIC: "Differential sequential DCT, Arithmetic coding",
+                    pyjpeg.FrameType.DIFFERENTIAL_PROGRESSIVE_ARITHMETIC: "Differential progressive DCT, Arithmetic coding",
+                    pyjpeg.FrameType.DIFFERENTIAL_LOSSLESS_ARITHMETIC: "Differential lossless (sequential), Arithmetic coding",
+                    pyjpeg.FrameType.LS: "JPEG-LS",
+                }[segment.n],
+            )
+        )
+        print(" Precision: %d bits" % segment.precision)
+        print(
+            " Number of lines: %d" % segment.number_of_lines
+        )  # FIXME: Note if zero defined later
+        print(" Number of samples per line: %d" % segment.samples_per_line)
+        for frame_component in segment.components:
+            print(" Component:")
+            print("  Id: %d" % frame_component.id)
+            print(
+                "  Sampling Factor: %dx%d"
+                % (
+                    frame_component.sampling_factor[0],
+                    frame_component.sampling_factor[1],
+                )
+            )
+            if not is_lossless and not is_ls:
+                print(
+                    "  Quantization Table: %d"
+                    % frame_component.quantization_table_index
+                )
+    elif isinstance(segment, pyjpeg.StartOfScan):
+        print("SOS Start of Scan")
+        for scan_component in segment.components:
+            print(" Component:")
+            print("  Id: %d" % scan_component.component_selector)
+            if is_ls:
+                print("  Mapping table: %d" % scan_component.get_mapping_table())
+            else:
+                print("  DC Table: %d" % scan_component.dc_table)
+                if not is_lossless:
+                    print("  AC Table: %d" % scan_component.ac_table)
+        if is_lossless:
+            print(" Predictor: %d" % segment.spectral_selection[0])
+        elif is_ls:
+            print(" Near: %d" % segment.spectral_selection[0])
+            print(
+                " Interleave Mode: %s"
+                % {
+                    pyjpeg.LSInterleaveMode.NONE: "None",
+                    pyjpeg.LSInterleaveMode.LINE: "Line",
+                    pyjpeg.LSInterleaveMode.SAMPLE: "Sample",
+                }.get(
+                    segment.spectral_selection[1], "%d" % segment.spectral_selection[1]
+                )
+            )
+        else:
+            print(
+                " Spectral Selection: %d-%d"
+                % (segment.spectral_selection[0], segment.spectral_selection[1])
+            )
+
+        if (segment.point_transform & 0xF0) != 0:
+            print(" Previous Point Transform: %d" % (segment.point_transform >> 4))
+        print(" Point Transform: %d" % (segment.point_transform & 0xF))
+    elif isinstance(segment, pyjpeg.HuffmanDCTScan) or isinstance(
+        segment, pyjpeg.ArithmeticDCTScan
+    ):
+        for data_unit in segment.data_units:
+            print_data_unit(data_unit)
+    elif (
+        isinstance(segment, pyjpeg.HuffmanLosslessScan)
+        or isinstance(segment, pyjpeg.ArithmeticLosslessScan)
+        or isinstance(segment, pyjpeg.LSScan)
+    ):
+        s = " Samples:"
+        for sample in segment.samples:
+            s += " %d" % sample
+        print(s)
+    elif isinstance(segment, pyjpeg.Restart):
+        print("RST%d Restart" % segment.index)
+    elif isinstance(segment, pyjpeg.DefineNumberOfLines):
+        print("DNL Define Number of Lines")
+        print(" Number of lines: %d" % segment.number_of_lines)
+    elif isinstance(segment, pyjpeg.LSCodingParameters):
+        print("LSE Coding Parameters")
+        print(" Maximum value: %d" % segment.maxval)
+        print(
+            " Gradient thresholds: %d, %d, %d"
+            % (
+                segment.gradient_thresholds[0],
+                segment.gradient_thresholds[1],
+                segment.gradient_thresholds[2],
+            )
+        )
+        print(" Reset: %d" % segment.reset)
+    elif isinstance(segment, pyjpeg.LSMappingTable):
+        print("LSE Mapping Table")
+        print(" Table ID: %d" % segment.table_id)
+        print(" Weight: %d" % segment.weight)
+        print(" Table Data: %s" % segment.table.hex())
+    elif isinstance(segment, pyjpeg.LSMappingTableContinuation):
+        print("LSE Mapping Table Continuation")
+        print(" Table ID: %d" % segment.table_id)
+        print(" Weight: %d" % segment.weight)
+        print(" Table Data: %s" % segment.table.hex())
+    elif isinstance(segment, pyjpeg.LSOversizeImageDimensions):
+        print("LSE Oversize Image Dimensions")
+        print(" Number of lines: %d" % segment.number_of_lines)
+        print(" Number of samples per line: %d" % segment.samples_per_line)
+    elif isinstance(segment, pyjpeg.LSUnknownPresetParameters):
+        print("LSE Preset Parameters")
+        print(" ID: %d" % segment.id)
+        print(" Data: %s" % segment.data.hex())
+    elif isinstance(segment, pyjpeg.EndOfImage):
+        print("EOI End of Image")
+    else:
+        print(segment)

pyjpeg-0.1/jpg2pnm.py

@@ -0,0 +1,88 @@
+#!/usr/bin/env python3
+
+import sys
+
+import pyjpeg
+from pnm import *
+
+if len(sys.argv) != 3:
+    print("Usage: jpg2pnm.py <input.jpg> <output.pnm>")
+    sys.exit(1)
+
+data = open(sys.argv[1], "rb").read()
+reader = pyjpeg.BufferedReader(data)
+stream = pyjpeg.Stream.read(reader)
+
+data = []
+convert_ycbcr = False
+sof = None
+sos = None
+quantization_tables = [
+    [1] * 64,
+    [1] * 64,
+    [1] * 64,
+    [1] * 64,
+]
+for segment in stream.segments:
+    if isinstance(segment, pyjpeg.JfifHeader):
+        convert_ycbcr = True
+    elif isinstance(segment, pyjpeg.AdobeHeader):
+        if segment.color_space == pyjpeg.AdobeColorSpace.Y_CB_CR:
+            convert_ycbcr = True
+    elif isinstance(segment, pyjpeg.StartOfFrame):
+        sof = segment
+        data = (
+            [0]
+            * segment.samples_per_line
+            * segment.number_of_lines
+            * len(segment.components)
+        )
+    elif isinstance(segment, pyjpeg.DefineQuantizationTables):
+        for table in segment.tables:
+            quantization_tables[table.destination] = table.values
+    elif isinstance(segment, pyjpeg.StartOfScan):
+        sos = segment
+    elif isinstance(segment, pyjpeg.HuffmanDCTScan) or isinstance(
+        segment, pyjpeg.ArithmeticDCTScan
+    ):
+        # FIXME: Channels, sampling factor
+        du_x = 0
+        du_y = 0
+        component = sof.get_component(sof.components[0].id)
+        for i, data_unit in enumerate(segment.data_units):
+            samples = pyjpeg.idct(
+                data_unit,
+                quantization_tables[component.quantization_table_index],
+                sof.precision,
+            )
+            x_max = 8
+            if du_x + x_max > sof.samples_per_line:
+                x_max = max(sof.samples_per_line - du_x, 0)
+            y_max = 8
+            if du_y + y_max > sof.number_of_lines:
+                y_max = max(sof.number_of_lines - du_y, 0)
+            for y in range(x_max):
+                for x in range(y_max):
+                    data[(du_y + y) * sof.samples_per_line + du_x + x] = samples[
+                        y * 8 + x
+                    ]
+
+            du_x += 8
+            if du_x >= sof.samples_per_line:
+                du_x = 0
+                du_y += 8
+    elif isinstance(segment, pyjpeg.HuffmanLosslessScan) or isinstance(
+        segment, pyjpeg.ArithmeticLosslessScan
+    ):
+        # FIXME: Channels, sampling factor
+        for i, sample in enumerate(segment.samples):
+            data[i] = sample
+
+
+write_pnm(
+    sys.argv[2],
+    sof.samples_per_line,
+    sof.number_of_lines,
+    data,
+    channels=len(sof.components),
+)