JfifSupport.vala 6.68 KB
Newer Older
1
/* Copyright 2016 Software Freedom Conservancy Inc.
2 3
 *
 * This software is licensed under the GNU LGPL (version 2.1 or later).
4
 * See the COPYING file in this distribution.
5 6 7 8
 */

public class JfifFileFormatDriver : PhotoFileFormatDriver {
    private static JfifFileFormatDriver instance = null;
9 10 11 12 13

    public static void init() {
        instance = new JfifFileFormatDriver();
        JfifFileFormatProperties.init();
    }
14 15 16 17 18 19 20 21 22 23 24 25 26
    
    public static JfifFileFormatDriver get_instance() {
        return instance;
    }
    
    public override PhotoFileFormatProperties get_properties() {
        return JfifFileFormatProperties.get_instance();
    }
    
    public override PhotoFileReader create_reader(string filepath) {
        return new JfifReader(filepath);
    }
    
27 28 29 30
    public override PhotoMetadata create_metadata() {
        return new PhotoMetadata();
    }
    
31 32 33 34 35
    public override bool can_write_image() {
        return true;
    }
    
    public override bool can_write_metadata() {
36 37 38 39 40 41 42
        return true;
    }
    
    public override PhotoFileWriter? create_writer(string filepath) {
        return new JfifWriter(filepath);
    }
    
43 44 45 46
    public override PhotoFileMetadataWriter? create_metadata_writer(string filepath) {
        return new JfifMetadataWriter(filepath);
    }
    
47 48 49 50 51 52 53
    public override PhotoFileSniffer create_sniffer(File file, PhotoFileSniffer.Options options) {
        return new JfifSniffer(file, options);
    }
}

public class JfifFileFormatProperties : PhotoFileFormatProperties {
    private static string[] KNOWN_EXTENSIONS = {
54
        "jpg", "jpeg", "jpe", "thm"
55
    };
56 57 58 59 60

    private static string[] KNOWN_MIME_TYPES = {
        "image/jpeg"
    };
        
61
    private static JfifFileFormatProperties instance = null;
62 63 64 65

    public static void init() {
        instance = new JfifFileFormatProperties();
    }
66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81
    
    public static JfifFileFormatProperties get_instance() {
        return instance;
    }
    
    public override PhotoFileFormat get_file_format() {
        return PhotoFileFormat.JFIF;
    }
    
    public override PhotoFileFormatFlags get_flags() {
        return PhotoFileFormatFlags.NONE;
    }
    
    public override string get_default_extension() {
        return "jpg";
    }
82 83 84 85 86

    public override string get_user_visible_name() {
        return _("JPEG");
    }

87 88 89
    public override string[] get_known_extensions() {
        return KNOWN_EXTENSIONS;
    }
90 91 92 93 94 95 96 97
    
    public override string get_default_mime_type() {
        return KNOWN_MIME_TYPES[0];
    }
    
    public override string[] get_mime_types() {
        return KNOWN_MIME_TYPES;
    }
98 99 100 101 102 103 104
}

public class JfifSniffer : GdkSniffer {
    public JfifSniffer(File file, PhotoFileSniffer.Options options) {
        base (file, options);
    }
    
105 106 107 108
    public override DetectedPhotoInformation? sniff(out bool is_corrupted) throws Error {
        // Rely on GdkSniffer to detect corruption
        is_corrupted = false;
        
109 110 111
        if (!Jpeg.is_jpeg(file))
            return null;
        
112
        DetectedPhotoInformation? detected = base.sniff(out is_corrupted);
113 114 115 116 117 118 119 120 121
        if (detected == null)
            return null;
        
        return (detected.file_format == PhotoFileFormat.JFIF) ? detected : null;
    }
}

public class JfifReader : GdkReader {
    public JfifReader(string filepath) {
122
        base (filepath, PhotoFileFormat.JFIF);
123
    }
124 125 126 127 128 129 130 131 132 133 134 135
}

public class JfifWriter : PhotoFileWriter {
    public JfifWriter(string filepath) {
        base (filepath, PhotoFileFormat.JFIF);
    }
    
    public override void write(Gdk.Pixbuf pixbuf, Jpeg.Quality quality) throws Error {
        pixbuf.save(get_filepath(), "jpeg", "quality", quality.get_pct_text());
    }
}

136 137 138 139 140 141 142 143 144 145
public class JfifMetadataWriter : PhotoFileMetadataWriter {
    public JfifMetadataWriter(string filepath) {
        base (filepath, PhotoFileFormat.JFIF);
    }
    
    public override void write_metadata(PhotoMetadata metadata) throws Error {
        metadata.write_to_file(get_file());
    }
}

146 147 148 149
namespace Jpeg {
    public const uint8 MARKER_PREFIX = 0xFF;
    
    public enum Marker {
150 151 152
        // Could also be 0xFF according to spec
        INVALID = 0x00,
        
153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203
        SOI = 0xD8,
        EOI = 0xD9,
        
        APP0 = 0xE0,
        APP1 = 0xE1;
        
        public uint8 get_byte() {
            return (uint8) this;
        }
    }
    
    public enum Quality {
        LOW = 50,
        MEDIUM = 75,
        HIGH = 90,
        MAXIMUM = 100;
        
        public int get_pct() {
            return (int) this;
        }
        
        public string get_pct_text() {
            return "%d".printf((int) this);
        }
        
        public static Quality[] get_all() {
            return { LOW, MEDIUM, HIGH, MAXIMUM };
        }
        
        public string? to_string() {
            switch (this) {
                case LOW:
                    return _("Low (%d%%)").printf((int) this);
                
                case MEDIUM:
                    return _("Medium (%d%%)").printf((int) this);
                
                case HIGH:
                    return _("High (%d%%)").printf((int) this);
                    
                case MAXIMUM:
                    return _("Maximum (%d%%)").printf((int) this);
            }
            
            warn_if_reached();
            
            return null;
        }
    }
    
    public bool is_jpeg(File file) throws Error {
204 205 206 207 208
        var fins = file.read(null);
        return is_jpeg_stream(fins);
    }

    public bool is_jpeg_stream(InputStream ins) throws Error {
209
        Marker marker;
210
        int segment_length = read_marker(ins, out marker);
211 212 213 214 215
        
        // for now, merely checking for SOI
        return (marker == Marker.SOI) && (segment_length == 0);
    }

216 217 218 219 220 221 222
    public bool is_jpeg_bytes(Bytes bytes) throws Error {
        var mins = new MemoryInputStream.from_bytes(bytes);

        return is_jpeg_stream(mins);
    }

    private int read_marker(InputStream fins, out Jpeg.Marker marker) throws Error {
223 224
        marker = Jpeg.Marker.INVALID;
        
225 226 227 228
        DataInputStream dins = new DataInputStream(fins);
        dins.set_byte_order(DataStreamByteOrder.BIG_ENDIAN);
        
        if (dins.read_byte() != Jpeg.MARKER_PREFIX)
229 230
            return -1;
        
231
        marker = (Jpeg.Marker) dins.read_byte();
232 233 234 235 236
        if ((marker == Jpeg.Marker.SOI) || (marker == Jpeg.Marker.EOI)) {
            // no length
            return 0;
        }
        
237
        uint16 length = dins.read_uint16();
238 239 240
        if (length < 2 && fins is Seekable) {
            debug("Invalid length %Xh at ofs %" + int64.FORMAT + "Xh", length,
                    (fins as Seekable).tell() - 2);
241 242 243 244 245 246 247 248 249
            
            return -1;
        }
        
        // account for two length bytes already read
        return length - 2;
    }
}