1

"""

     2

    The various Exif backends that we have

     3

"""

     4

     5

from __future__ import with_statement

     6

     7

import utils

     8

     9

MIRROR_NONE         = 0

    10

MIRROR_HORIZONTAL   = 1

    11

MIRROR_VERTICAL     = 2

    12

    13

ROTATE_NONE         = 0

    14

ROTATE_90           = 90

    15

ROTATE_180          = 180

    16

ROTATE_270          = 270

    17

    18

class ExifHandler (object) :

    19

    """

    20

        Our generic interface for Exif data

    21

    """

    22

    23

    def __init__ (self, file) :

    24

        """

    25

            Load Exif data from the given File.

    26

        """

    27

    28

        self.file = file

    29

    30

    def image_tag_value (self, tag, default=None) :

    31

        """

    32

            Load and return the raw binary value for the given main image tag.

    33

        """

    34

    35

        return default

    36

    37

    def image_tag (self, tag, default=None) :

    38

        """

    39

            Load and return the human-readable unicode-safe value for the given main image tag.

    40

        """

    41

    42

        return default

    43

    44

    def image_tags (self, tags) :

    45

        """

    46

            Load and return the given tags for the main image as a sequence of (tag, value) tuples , following the same

    47

            rules as image_tag, except there should mainly be only one call to this function, encompassing all the

    48

            relevant tags.

    49

    50

            The returned list should omit those values which were not found.

    51

        """

    52

    53

        for tag in tags :

    54

            # try and fetch value

    55

            value = self.image_tag(tag)

    56

    57

            # filter out default not-found

    58

            if value is not None :

    59

                yield tag, value

    60

    61

    62

    def get_orientation (self) :

    63

        """

    64

            Get the orientation of the image in terms of mirroring and rotation in integer degrees clockwise.

    65

    66

            Returns a (MIRROR_*, ROTATE_*) tuple, or None if the Orientation tag could not be found.

    67

    68

            Returns None if it could not be found.

    69

        """

    70

    71

        # load value

    72

        orientation = self.image_tag_value('Orientation')

    73

    74

        # map to tuple or None

    75

        # XXX: these are from EXIFpy, verify

    76

        return {

    77

            1:  (MIRROR_NONE,       ROTATE_NONE ),  # Horizontal (normal)

    78

            2:  (MIRROR_HORIZONTAL, ROTATE_NONE ),  # Mirrored horizontal

    79

            3:  (MIRROR_NONE,       ROTATE_180  ),  # Rotated 180

    80

            4:  (MIRROR_VERTICAL,   ROTATE_NONE ),  # Mirrored vertical

    81

            5:  (MIRROR_HORIZONTAL, ROTATE_270  ),  # Mirrored horizontal then rotated 90 CCW

    82

            6:  (MIRROR_NONE,       ROTATE_90   ),  # Rotated 90 CW

    83

            7:  (MIRROR_HORIZONTAL, ROTATE_90   ),  # Mirrored horizontal then rotated 90 CW

    84

            8:  (MIRROR_NONE,       ROTATE_270  ),  # Rotated 90 CCW

    85

        }.get(orientation, None)

    86

    87

try :

    88

    import pyexiv2

    89

    90

except ImportError :

    91

    PyExiv2_Handler = None

    92

    93

else :

    94

    class PyExiv2_Handler (ExifHandler) :

    95

        NAME = 'pyexiv2'

    96

    97

        def __init__ (self, file) :

    98

            """

    99

                Load as pyexiv2.Image

   100

            """

   101

   102

            # create

   103

            self.image = pyexiv2.Image(file.path)

   104

   105

            # load

   106

            self.image.readMetadata()

   107

   108

        def image_tag_value (self, tag, default=None) :

   109

            # try with likely prefixes

   110

            for prefix in ('Exif.Photo', 'Exif.Image') :

   111

                try :

   112

                    return self.image["%s.%s" % (prefix, tag)]

   113

   114

                except (IndexError, KeyError) :

   115

                    # nope...

   116

                    continue

   117

   118

            else :

   119

                # not ofund

   120

                return default

   121

   122

        def image_tag (self, tag, default=None) :

   123

            # try with likely prefixes

   124

            for prefix in ('Exif.Photo', 'Exif.Image') :

   125

                try :

   126

                    return self.image.interpretedExifValue("%s.%s" % (prefix, tag))

   127

   128

                except (IndexError, KeyError) :

   129

                    # nope...

   130

                    continue

   131

   132

            else :

   133

                # not ofund

   134

                return default

   135

   136

try :

   137

    from lib import EXIF

   138

   139

except ImportError :

   140

    EXIF_Handler = None

   141

   142

else :

   143

    class EXIF_Handler (ExifHandler) :

   144

        NAME = 'EXIFpy'

   145

   146

        def __init__ (self, file) :

   147

            """

   148

                Load using EXIF.process_file

   149

            """

   150

   151

            with file.open('rb') as fh :

   152

                self.tags = EXIF.process_file(fh)

   153

   154

        def image_tag (self, tag, default=None) :

   155

            # try with likely prefixes

   156

            for prefix in ('Image', 'EXIF') :

   157

                name = prefix + ' ' + tag

   158

   159

                if name in self.tags :

   160

                    return self.tags[name]

   161

   162

            else :

   163

                # not found

   164

                return default

   165

   166

# ExifHandler implementations to use, in preference order

   167

EXIF_HANDLERS = [

   168

    # reasonably fast, but requires the native library and extension module

   169

    PyExiv2_Handler,

   170

   171

    # pure-python, but very, very slow

   172

    EXIF_Handler,

   173

]

   174

   175

# default ExifHandler to use

   176

EXIF_HANDLER = utils.first(EXIF_HANDLERS)

   177

   178

# ExifHandler implementations by name

   179

EXIF_HANDLERS_BY_NAME = dict((h.NAME, h) for h in EXIF_HANDLERS if h)

   180

   181

def load (config, file) :

   182

    """

   183

        Load Exif data using the configured Exif handler, and return the instance.

   184

   185

        Returns None if there wasn't any Exif handler available for use.

   186

    """

   187

   188

    if config.exif_handler :

   189

        # explicit

   190

        exif_handler = config.exif_handler

   191

   192

    elif config.exif_handler_name :

   193

        # by name

   194

        exif_handler = EXIF_HANDLERS_BY_NAME[config.exif_handler_name]

   195

   196

    else :

   197

        # default

   198

        exif_handler = EXIF_HANDLER

   199

   200

    if exif_handler :

   201

        # found one, use it

   202

        return exif_handler(file)

   203

   204

    else :

   205

        # nothing :(

   206

        return None

   207