From c1114e2a540071902e8ad8ff9d3765fd54f32877 Mon Sep 17 00:00:00 2001
From: hMatoba <hiroaki.mtb@outlook.com>
Date: Wed, 3 Jan 2018 21:05:13 +0900
Subject: [PATCH 01/11] Add test for WebP.

---
 .gitignore                 |   3 +-
 piexif.pyproj              |  10 ++
 piexif/__init__.py         |   1 +
 piexif/_webp.py            | 350 +++++++++++++++++++++++++++++++++++++
 tests/images/pil1.webp     | Bin 0 -> 80 bytes
 tests/images/pil2.webp     | Bin 0 -> 34 bytes
 tests/images/pil3.webp     | Bin 0 -> 98 bytes
 tests/images/pil_rgb.webp  | Bin 0 -> 34 bytes
 tests/images/pil_rgba.webp | Bin 0 -> 34 bytes
 tests/images/tool1.webp    | Bin 0 -> 978 bytes
 tests/s_test.py            |  64 ++++++-
 11 files changed, 424 insertions(+), 4 deletions(-)
 create mode 100644 piexif/_webp.py
 create mode 100644 tests/images/pil1.webp
 create mode 100644 tests/images/pil2.webp
 create mode 100644 tests/images/pil3.webp
 create mode 100644 tests/images/pil_rgb.webp
 create mode 100644 tests/images/pil_rgba.webp
 create mode 100644 tests/images/tool1.webp

diff --git a/.gitignore b/.gitignore
index a52a765..23d0025 100644
--- a/.gitignore
+++ b/.gitignore
@@ -100,4 +100,5 @@ load_sample.py
 *.suo
 doc/_build/
 run_coverage.bat
-up2pypi.bat
\ No newline at end of file
+up2pypi.bat
+out/
diff --git a/piexif.pyproj b/piexif.pyproj
index 20c6cde..0c788fa 100644
--- a/piexif.pyproj
+++ b/piexif.pyproj
@@ -29,6 +29,7 @@
     <Folder Include="tests\" />
     <Folder Include="piexif\" />
     <Folder Include="tests\images\" />
+    <Folder Include="tests\images\out\" />
   </ItemGroup>
   <ItemGroup>
     <Compile Include="piexif\_common.py" />
@@ -46,6 +47,9 @@
     </Compile>
     <Compile Include="piexif\_remove.py" />
     <Compile Include="piexif\_transplant.py" />
+    <Compile Include="piexif\_webp.py">
+      <SubType>Code</SubType>
+    </Compile>
     <Compile Include="piexif\__init__.py" />
     <Compile Include="tests\s_test.py" />
   </ItemGroup>
@@ -57,6 +61,12 @@
     <Content Include="tests\images\L02.jpg" />
     <Content Include="tests\images\noapp01.jpg" />
     <Content Include="tests\images\noexif.jpg" />
+    <Content Include="tests\images\pil1.webp" />
+    <Content Include="tests\images\pil2.webp" />
+    <Content Include="tests\images\pil3.webp" />
+    <Content Include="tests\images\pil_rgb.webp" />
+    <Content Include="tests\images\pil_rgba.webp" />
+    <Content Include="tests\images\tool1.webp" />
   </ItemGroup>
   <!-- Uncomment the CoreCompile target to enable the Build command in
        Visual Studio and specify your pre- and post-build commands in
diff --git a/piexif/__init__.py b/piexif/__init__.py
index 600f499..7f51456 100644
--- a/piexif/__init__.py
+++ b/piexif/__init__.py
@@ -7,4 +7,5 @@
 from ._exceptions import *
 
 
+
 VERSION = '1.0.13'
diff --git a/piexif/_webp.py b/piexif/_webp.py
new file mode 100644
index 0000000..91cffcf
--- /dev/null
+++ b/piexif/_webp.py
@@ -0,0 +1,350 @@
+
+import struct
+
+
+def split(data):
+    if data[0:4] != b"RIFF" or data[8:12] != b"WEBP":
+        raise ValueError("Not WebP")
+
+    webp_length_bytes = data[4:8]
+    webp_length = struct.unpack("<L", webp_length_bytes)[0]
+    print("webp length: {0}, {1}".format(webp_length, len(data[8:])))
+    RIFF_HEADER_SIZE = 8
+    file_size = RIFF_HEADER_SIZE + webp_length
+
+    start = 12
+    pointer = start
+    CHUNK_FOURCC_LENGTH = 4
+    LENGTH_BYTES_LENGTH = 4
+
+    chunks = []
+    while pointer + CHUNK_FOURCC_LENGTH + LENGTH_BYTES_LENGTH < file_size:
+        fourcc = data[pointer:pointer + CHUNK_FOURCC_LENGTH]
+        pointer += CHUNK_FOURCC_LENGTH
+        chunk_length_bytes = data[pointer:pointer + LENGTH_BYTES_LENGTH]
+        chunk_length = struct.unpack("<L", chunk_length_bytes)[0]
+        pointer += LENGTH_BYTES_LENGTH
+
+
+
+        chunk_data = data[pointer:pointer + chunk_length]
+        chunks.append({"fourcc":fourcc, "length_bytes":chunk_length_bytes, "data":chunk_data})
+
+        print("{0} {1} {2} {3}".format(fourcc, chunk_length, len(chunk_data), chunk_data[-2:]))
+
+
+        padding = 1 if chunk_length % 2 else 0
+
+
+        pointer += chunk_length + padding
+    return chunks
+
+def merge_chunks(chunks):
+    merged = b"".join([chunk["fourcc"] 
+                       + chunk["length_bytes"]
+                       + chunk["data"]
+                       + (len(chunk["data"]) % 2) * b"\x00"
+                        for chunk in chunks])
+    return merged
+
+
+def _get_size_from_vp8x(chunk):
+    width_minus_one_bytes = chunk["data"][-6:-3] + b"\x00"
+    width_minus_one = struct.unpack("<L", width_minus_one_bytes)[0]
+    width = width_minus_one + 1
+    height_minus_one_bytes = chunk["data"][-3:] + b"\x00"
+    height_minus_one = struct.unpack("<L", height_minus_one_bytes)[0]
+    height = height_minus_one + 1
+    return (width, height)
+
+def _get_size_from_vp8(chunk):
+    BEGIN_CODE = b"\x9d\x01\x2a"
+    begin_index = chunk["data"].find(BEGIN_CODE)
+    if begin_index == -1:
+        ValueError("wrong VP8")
+    else:
+        BEGIN_CODE_LENGTH = len(BEGIN_CODE)
+        LENGTH_BYTES_LENGTH = 2
+        length_start = begin_index + BEGIN_CODE_LENGTH
+        width_bytes = chunk["data"][length_start:length_start + LENGTH_BYTES_LENGTH]
+        width = struct.unpack("<H", width_bytes)[0]
+        height_bytes = chunk["data"][length_start + LENGTH_BYTES_LENGTH:length_start + 2 * LENGTH_BYTES_LENGTH]
+        height = struct.unpack("<H", height_bytes)[0]
+        return (width, height)
+
+def _vp8L_contains_alpha(chunk_data):
+    flag = ord(chunk_data[4:5]) >> 5-1 & ord(b"\x01")
+    contains = 1 * flag
+    return contains
+
+def _get_size_from_vp8L(chunk):
+    b1 = chunk["data"][1:2]
+    b2 = chunk["data"][2:3]
+    b3 = chunk["data"][3:4]
+    b4 = chunk["data"][4:5]
+
+    width_minus_one = (ord(b2) & ord(b"\x3F")) << 8 | ord(b1)
+    width = width_minus_one + 1
+
+    height_minus_one = (ord(b4) & ord(b"\x0F")) << 10 | ord(b3) << 2 | (ord(b2) & ord(b"\xC0")) >> 6
+    height = height_minus_one + 1
+
+    return (width, height)
+
+def _get_size_from_anmf(chunk):
+    width_minus_one_bytes = chunk["data"][6:9] + b"\x00"
+    width_minus_one = struct.unpack("<L", width_minus_one_bytes)[0]
+    width = width_minus_one + 1
+    height_minus_one_bytes = chunk["data"][9:12] + b"\x00"
+    height_minus_one = struct.unpack("<L", height_minus_one_bytes)[0]
+    height = height_minus_one + 1
+    return (width, height)
+    
+def set_vp8x(chunks):
+
+    width = None
+    height = None
+    flags = [b"0", b"0", b"0", b"0", b"0", b"0", b"0", b"0"]  # [0, 0, ICC, Alpha, EXIF, XMP, Anim, 0]
+
+    for chunk in chunks:
+        if chunk["fourcc"] == b"VP8X":
+            width, height = _get_size_from_vp8x(chunk)
+        elif chunk["fourcc"] == b"VP8 ":
+            width, height = _get_size_from_vp8(chunk)
+        elif chunk["fourcc"] == b"VP8L":
+            is_rgba = _vp8L_contains_alpha(chunk["data"])
+            if is_rgba:
+                flags[3] = b"1"
+            width, height = _get_size_from_vp8L(chunk)
+        elif chunk["fourcc"] == b"ANMF":
+            width, height = _get_size_from_anmf(chunk)
+        elif chunk["fourcc"] == b"ICCP":
+            flags[2] = b"1"
+        elif chunk["fourcc"] == b"ALPH":
+            flags[3] = b"1"
+        elif chunk["fourcc"] == b"EXIF":
+            flags[4] = b"1"
+        elif chunk["fourcc"] == b"XMP ":
+            flags[5] = b"1"
+        elif chunk["fourcc"] == b"ANIM":
+            flags[6] = b"1"
+    width_minus_one = width - 1
+    height_minus_one = height - 1
+
+    if chunks[0]["fourcc"] == b"VP8X":
+        chunks.pop(0)
+
+    print(b"".join(flags))
+
+    header_bytes = b"VP8X"
+    length_bytes = b"\x0a\x00\x00\x00"
+    flags_bytes = struct.pack("B", int(b"".join(flags), 2))
+    padding_bytes = b"\x00\x00\x00"
+    width_bytes = struct.pack("<L", width_minus_one)[:3]
+    height_bytes = struct.pack("<L", height_minus_one)[:3]
+
+    data_bytes = flags_bytes + padding_bytes + width_bytes + height_bytes
+
+    vp8x_chunk = {"fourcc":header_bytes, "length_bytes":length_bytes, "data":data_bytes}
+    chunks.insert(0, vp8x_chunk)
+
+    return chunks
+
+def get_file_header(chunks):
+    padded = False
+    WEBP_HEADER_LENGTH = 4
+    FOURCC_LENGTH = 4
+    LENGTH_BYTES_LENGTH = 4
+
+    length = WEBP_HEADER_LENGTH
+    for chunk in chunks:
+        data_length = struct.unpack("<L", chunk["length_bytes"])[0]
+        data_length += 1 if data_length % 2 else 0
+        length += FOURCC_LENGTH + LENGTH_BYTES_LENGTH + data_length
+    if length % 2:
+        length += 1
+        padded = True
+    length_bytes = struct.pack("<L", length)
+    riff = b"RIFF"
+    webp_header = b"WEBP"
+    file_header = riff + length_bytes + webp_header
+    return (file_header, padded)
+
+
+
+def get_exif(data):
+    if data[0:4] != b"RIFF" or data[8:12] != b"WEBP":
+        raise ValueError("Not WebP")
+
+    if data[12:16] != b"VP8X":
+        raise ValueError("don't have exif")
+
+    webp_length_bytes = data[4:8]
+    webp_length = struct.unpack("<L", webp_length_bytes)[0]
+    RIFF_HEADER_SIZE = 8
+    file_size = RIFF_HEADER_SIZE + webp_length
+
+    start = 12
+    pointer = start
+    CHUNK_FOURCC_LENGTH = 4
+    LENGTH_BYTES_LENGTH = 4
+
+    chunks = []
+    exif = b""
+    while pointer < file_size:
+        fourcc = data[pointer:pointer + CHUNK_FOURCC_LENGTH]
+        pointer += CHUNK_FOURCC_LENGTH
+        chunk_length_bytes = data[pointer:pointer + LENGTH_BYTES_LENGTH]
+        chunk_length = struct.unpack("<L", chunk_length_bytes)[0]
+        pointer += LENGTH_BYTES_LENGTH
+        if fourcc == b"EXIF":
+            exif = data[pointer:pointer + chunk_length]
+            break
+        pointer += chunk_length
+    return exif
+
+
+def insert_exif_into_chunks(chunks, exif_bytes):
+    EXIF_HEADER = b"EXIF"
+    exif_length_bytes = struct.pack("<L", len(exif_bytes))
+    exif_chunk = {"fourcc":EXIF_HEADER, "length_bytes":exif_length_bytes, "data":exif_bytes}
+
+    xmp_index = None
+    animation_index = None
+
+    for index, chunk in enumerate(chunks):
+        if chunk["fourcc"] == b"EXIF":
+            chunks.pop(index)
+
+    for index, chunk in enumerate(chunks):
+        if chunk["fourcc"] == b"XMP ":
+            xmp_index = index
+        elif chunk["fourcc"] == b"ANIM":
+            animation_index = index
+    if xmp_index is not None:
+        chunks.insert(xmp_index, exif_chunk)
+    elif animation_index is not None:
+        chunks.insert(animation_index, exif_chunk)
+    else:
+        chunks.append(exif_chunk)
+    return chunks
+
+
+def insert(webp_bytes, exif_bytes):
+    chunks = split(data)
+    chunks = insert_exif_into_chunks(chunks, exif_bytes)
+    chunks = set_vp8x(chunks)
+    file_header, padded = get_file_header(chunks)
+    print(b" ".join([chunk["fourcc"] for chunk in chunks]))
+    merged = merge_chunks(chunks)
+    if padded:
+        merged += b"\x00"
+    new_webp_bytes = file_header + merged
+    print(file_header)
+    return new_webp_bytes
+
+
+def remove(webp_bytes):
+    chunks = split(data)
+    for index, chunk in enumerate(chunks):
+        if chunk["fourcc"] == b"EXIF":
+            chunks.pop(index)
+    chunks = set_vp8x(chunks)
+    file_header, padded = get_file_header(chunks)
+    print(b" ".join([chunk["fourcc"] for chunk in chunks]))
+    merged = merge_chunks(chunks)
+    if padded:
+        merged += b"\x00"
+    new_webp_bytes = file_header + merged
+    print(file_header)
+    return new_webp_bytes
+
+if __name__ == "__main__":
+    import glob
+    import piexif
+    from PIL import Image
+
+    IMAGE_DIR = "images/"
+    OUT_DIR = "images/out/"
+    files = [
+        "web1.webp",
+        "web2.webp",
+        "web3.webp",
+        "web4.webp",
+        "tool1.webp",
+        "pil1.webp",
+        "pil2.webp",
+        "pil3.webp",
+        "pil_rgb.webp",
+        "pil_rgba.webp",
+    ]
+
+
+    exif_dict = {
+        "0th":{
+            piexif.ImageIFD.Software: b"PIL",
+            piexif.ImageIFD.Make: b"Make",
+        }
+    }
+
+    for filename in files:
+        print("\n\n\n**********\n" + filename)
+        Image.open(IMAGE_DIR + filename)
+
+        print("  -----------\n")
+        with open(IMAGE_DIR + filename, "rb") as f:
+            data = f.read()
+
+        chunks = split(data)
+        print(b" ".join([chunk["fourcc"] for chunk in chunks]))
+        file_header, padded = get_file_header(chunks)
+        merged = merge_chunks(chunks)
+        if padded:
+            merged += b"\x00"
+        new_webp_bytes = file_header + merged
+        print(file_header)
+        with open(OUT_DIR + "raw_" + filename, "wb") as f:
+            f.write(new_webp_bytes)
+        try:
+            Image.open(OUT_DIR + "raw_" + filename)
+        except Exception as e:
+            print(e.args)
+
+        print("  -----------\n")
+        exif_bytes = piexif.dump(exif_dict)
+        exif_inserted = insert(data, exif_bytes)
+        with open(OUT_DIR + "i_" + filename, "wb") as f:
+            f.write(exif_inserted)
+        try:
+            Image.open(OUT_DIR + "i_" + filename)
+        except Exception as e:
+            print(e.args)
+
+
+        print("  -----------\n")
+        with open(OUT_DIR + "i_" + filename, "rb") as f:
+            data = f.read()
+        exif_removed = remove(data)
+        with open(OUT_DIR + "r_" + filename, "wb") as f:
+            f.write(exif_removed)
+        try:
+            Image.open(OUT_DIR + "r_" + filename)
+        except Exception as e:
+            print(e.args)
+
+    files = glob.glob(OUT_DIR + "*.webp")
+    result = ""
+    for filename in files:
+        print("\n========================" + filename)
+        with open(filename, "rb") as f:
+            data = f.read()
+        split(data)
+        try:
+            Image.open(filename)
+            result += "-"
+        except Exception as e:
+            print(e.args)
+            result += "!"
+    print(result)
+
+    print("xxxxxxxxxxxxxxxxxxxxxxxx")
\ No newline at end of file
diff --git a/tests/images/pil1.webp b/tests/images/pil1.webp
new file mode 100644
index 0000000000000000000000000000000000000000..e8ef57474b8ddd24df025ac8838934f9f15cfbfa
GIT binary patch
literal 80
zcmWIYbaV4yU|<M$bqWXzu!!ISvIT&c35*<l0z5c@JVtf_LBWoWf9woEH3||y5d%hs
axr|!O49pCS4r;1P7?=wf{{1z}U;qI4d=0<=

literal 0
HcmV?d00001

diff --git a/tests/images/pil2.webp b/tests/images/pil2.webp
new file mode 100644
index 0000000000000000000000000000000000000000..ba64b2c0941f967e0efbc9feb4d78f4807820f1d
GIT binary patch
literal 34
ocmWIYbaRtpU|<M$bqWXzu<+ppvh|r77zEe_1O+=f{;@Lv0C7SFwg3PC

literal 0
HcmV?d00001

diff --git a/tests/images/pil3.webp b/tests/images/pil3.webp
new file mode 100644
index 0000000000000000000000000000000000000000..56a292069b6ec9c62e9f63e00cf9b9edd08f9648
GIT binary patch
literal 98
zcmWIYbaRVhU|<M$bqWXzu!!ISvL%3+35<XuKD<DlK2rmO0K0&oU`NM4b_Ul7Pd8Pd
lsB1-L8Uur`FM}44!@<DF$Pd!SzzW1tK+KSvn4QYN008j94a)!k

literal 0
HcmV?d00001

diff --git a/tests/images/pil_rgb.webp b/tests/images/pil_rgb.webp
new file mode 100644
index 0000000000000000000000000000000000000000..cb7a9e09d8673027b3020890046676784c7a2434
GIT binary patch
literal 34
ocmWIYbaRtpU|<M$bqWXzu<+pnvh^7q7#P?E1po58xcp}Z0B?r|)&Kwi

literal 0
HcmV?d00001

diff --git a/tests/images/pil_rgba.webp b/tests/images/pil_rgba.webp
new file mode 100644
index 0000000000000000000000000000000000000000..2365f48ee8016658f27e39157735ccab9f9c6d61
GIT binary patch
literal 34
ocmWIYbaRtpU|<M$bqWXzu<+ppvh^7q7zEe_1O+=f{;@Lv0B$t~bpQYW

literal 0
HcmV?d00001

diff --git a/tests/images/tool1.webp b/tests/images/tool1.webp
new file mode 100644
index 0000000000000000000000000000000000000000..7515c7cfb7d3f74ee8541d2409d943bd89f29bc9
GIT binary patch
literal 978
zcmWIYbaOk!%)k)t>J$(bU=hK^z`(!(#P(nW6j8`yVqn<7%P^Nw%Yngx!EU0%EN|7t
zixihg@Gxu;;&c%En|Siqwi!*na@opyuCsj}He9;3{jDqebF~Af>J~4x)<0dAxjA#|
ziN#XNy<Izlmfy+}4qvo)_5;?_oBy7X%c)Xy=+F%~a=mo-tDUL0H6AP7+I}nk)cGsn
z-i-|m{~B`hwS_h`{E2^@yuT(}=gBOM)1tHY7Jl6S+~{3tYDh&<))`K($Frxd`!i+L
zHjdp>+BYqje>PZd^DWs$F8LuQzh8DtoK*Ipdj|XL=VyWry*aCy$URT+e~TY)&fU8!
z7p|XeYhFAx|9!zL>p4+nU+Zo&tKZnI8q~YWckaT%Wi}QI8urgP^htw_DesDjxFN6c
zy|=a<E_w^(4&Q$E#8g=4$ATlQr*4MVI86V#_T6k5l~b0VTQA;cZ&y^Es=;GF>sqxP
zuU&+y(B3W~smGVNUVCwd?cuPSJ@e)97ALiavbuQrDSk74>b|(qA2CT_VqKzWzSqM@
z_fW^%Rk!a)uen)#Z|Q66=d<*a*RwmQO}5*(Q}%}6+WULv?rh0^_h`e@D@r#VyUWzI
z|Mzg8XZTxmPiOAKbuQK2R<7rN@BZ-i(yb*=OC+wwBu+T@GCp(eX_tSk5kVW)xZV?%
zTd^g7@l8`3A+Pmof4(zm(~Aq8#`5)~-i}4Q?oaI;m^P<eQjQZ3QfFWPy@@q-jsNCv
ztgaEq+<$c}I-Zv!vh_tw=4*Bl{lDSsymT*>@A%)m_f8h8S6;G9e(3G1&jJ=*dT&{p
zyRt>}Ww)>R`{dnszD|n>@N7E#uJoLz!@&m!4f-s<|1SG~QzGE|x+AuKIc0aRW3-yv
z{-e-5DeVix)&p0+b6qW9aE<VEGh<|6@bzWT0w+ffMt%lhDr8^<;ygwHFdLLmOBkiV
zVnDSFb&S$*b{nGx129c9FoIMv8iLge0{MOInG7soaR!D3OH9Dxl0X$QKrx13f4@iu
z22USnS6%ZUUn7t*9f(>8U67cWSE84fTB2a0XP{?j36x`NngzG>UDI4R`&)-P*nTF)
z2@DJqn8Egl0M-AS#0e2+5MW@K#068&C<K%P0gyjZfEesXBLhQoD+5z214{)X11lpl
pD`Qij6mtuZ0Q%j{Rl(9AH&?;UNY6sSH!-;=U%_3$KRB3y0Ra1@X4?P&

literal 0
HcmV?d00001

diff --git a/tests/s_test.py b/tests/s_test.py
index 8baf3e2..447cbd2 100644
--- a/tests/s_test.py
+++ b/tests/s_test.py
@@ -12,6 +12,7 @@
 from PIL import Image
 import piexif
 from piexif import _common, ImageIFD, ExifIFD, GPSIFD, TAGS, InvalidImageDataError
+from piexif import _webp
 from piexif import helper
 
 
@@ -855,11 +856,68 @@ def test_decode_bad_encoding(self):
         self.assertRaises(ValueError, helper.UserComment.load, b'hello world')
 
 
+class WebpTests(unittest.TestCase):
+    def test_merge_chunks(self):
+        """Can PIL open our output WebP?"""
+        IMAGE_DIR = "tests/images/"
+        OUT_DIR = "tests/images/out/"
+        files = [
+            "tool1.webp",
+            "pil1.webp",
+            "pil2.webp",
+            "pil3.webp",
+            "pil_rgb.webp",
+            "pil_rgba.webp",
+        ]
+
+        exif_dict = {
+            "0th":{
+                piexif.ImageIFD.Software: b"PIL",
+                piexif.ImageIFD.Make: b"Make",
+            }
+        }
+
+        for filename in files:
+            Image.open(IMAGE_DIR + filename)
+
+            with open(IMAGE_DIR + filename, "rb") as f:
+                data = f.read()
+
+            chunks = _webp.split(data)
+            file_header, padded = _webp.get_file_header(chunks)
+            merged = _webp.merge_chunks(chunks)
+            if padded:
+                merged += b"\x00"
+            new_webp_bytes = file_header + merged
+            with open(OUT_DIR + "raw_" + filename, "wb") as f:
+                f.write(new_webp_bytes)
+            try:
+                Image.open(OUT_DIR + "raw_" + filename)
+            except Exception as e:
+                print(e.args)
+
+
+        files = glob.glob(OUT_DIR + "raw_*.webp")
+        result = ""
+        for filename in files:
+            with open(filename, "rb") as f:
+                data = f.read()
+            _webp.split(data)
+            try:
+                Image.open(filename)
+                result += "-"
+            except Exception as e:
+                print(e.args)
+                result += "!"
+
 def suite():
     suite = unittest.TestSuite()
-    suite.addTests([unittest.makeSuite(UTests),
-                    unittest.makeSuite(ExifTests),
-                    unittest.makeSuite(HelperTests)])
+    suite.addTests([
+        unittest.makeSuite(UTests),
+        unittest.makeSuite(ExifTests),
+        unittest.makeSuite(HelperTests),
+        unittest.makeSuite(WebpTests),
+    ])
     return suite
 
 

From 34326ad3d574254b07334c3c03c9fbe480579d93 Mon Sep 17 00:00:00 2001
From: hMatoba <hiroaki.mtb@outlook.com>
Date: Thu, 4 Jan 2018 00:27:38 +0900
Subject: [PATCH 02/11] load, insert and remove support WebP.

---
 piexif/_insert.py |  20 +++++--
 piexif/_load.py   |  20 ++++---
 piexif/_remove.py |  33 ++++++++---
 piexif/_webp.py   | 130 ++++------------------------------------
 tests/s_test.py   | 148 +++++++++++++++++++++++++++++++++++-----------
 5 files changed, 178 insertions(+), 173 deletions(-)

diff --git a/piexif/_insert.py b/piexif/_insert.py
index 6e390c7..6608dab 100644
--- a/piexif/_insert.py
+++ b/piexif/_insert.py
@@ -3,7 +3,7 @@
 
 from ._common import *
 from ._exceptions import InvalidImageDataError
-
+from piexif import _webp
 
 def insert(exif, image, new_file=None):
     """
@@ -21,14 +21,26 @@ def insert(exif, image, new_file=None):
     output_file = False
     if image[0:2] == b"\xff\xd8":
         image_data = image
+        file_type = "jpeg"
+    elif image[0:4] == b"RIFF" and image[8:12] == b"WEBP":
+        image_data = image
+        file_type = "webp"
     else:
         with open(image, 'rb') as f:
             image_data = f.read()
-        if image_data[0:2] != b"\xff\xd8":
+        if image_data[0:2] == b"\xff\xd8":
+            file_type = "jpeg"
+        elif image_data[0:4] == b"RIFF" and image_data[8:12] == b"WEBP":
+            file_type = "webp"
+        else:
             raise InvalidImageDataError
         output_file = True
-    segments = split_into_segments(image_data)
-    new_data = merge_segments(segments, exif)
+
+    if file_type == "jpeg":
+        segments = split_into_segments(image_data)
+        new_data = merge_segments(segments, exif)
+    elif file_type == "webp":
+        new_data = _webp.insert(image_data, exif)
 
     if isinstance(new_file, io.BytesIO):
         new_file.write(new_data)
diff --git a/piexif/_load.py b/piexif/_load.py
index 7d3b088..f944b10 100644
--- a/piexif/_load.py
+++ b/piexif/_load.py
@@ -3,7 +3,7 @@
 from ._common import *
 from ._exceptions import InvalidImageDataError
 from ._exif import *
-
+from piexif import _webp
 
 LITTLE_ENDIAN = b"\x49\x49"
 
@@ -73,14 +73,13 @@ def __init__(self, data):
                 self.tiftag = None
         elif data[0:2] in (b"\x49\x49", b"\x4d\x4d"):  # TIFF
             self.tiftag = data
+        elif data[0:4] == b"RIFF" and data[8:12] == b"WEBP":
+            self.tiftag = _webp.get_exif(data)
         elif data[0:4] == b"Exif":  # Exif
             self.tiftag = data[6:]
         else:
-            try:
-                with open(data, 'rb') as f:
-                    magic_number = f.read(2)
-            except:
-                raise ValueError("Got invalid value.")
+            with open(data, 'rb') as f:
+                magic_number = f.read(2)
             if magic_number == b"\xff\xd8":  # JPEG
                 app1 = read_exif_from_file(data)
                 if app1:
@@ -91,7 +90,14 @@ def __init__(self, data):
                 with open(data, 'rb') as f:
                     self.tiftag = f.read()
             else:
-                raise InvalidImageDataError("Given file is neither JPEG nor TIFF.")
+                with open(data, 'rb') as f:
+                    header = f.read(12)
+                if header[0:4] == b"RIFF"and header[8:12] == b"WEBP":
+                    with open(data, 'rb') as f:
+                        file_data = f.read()
+                    self.tiftag = _webp.get_exif(file_data)
+                else:
+                    raise InvalidImageDataError("Given file is neither JPEG nor TIFF.")
 
     def get_ifd_dict(self, pointer, ifd_name, read_unknown=False):
         ifd_dict = {}
diff --git a/piexif/_remove.py b/piexif/_remove.py
index ff51cc4..575ee7c 100644
--- a/piexif/_remove.py
+++ b/piexif/_remove.py
@@ -1,7 +1,7 @@
 import io
 
 from ._common import *
-
+from piexif import _webp
 
 def remove(src, new_file=None):
     """
@@ -14,17 +14,34 @@ def remove(src, new_file=None):
     output_is_file = False
     if src[0:2] == b"\xff\xd8":
         src_data = src
+        file_type = "jpeg"
+    elif src[0:4] == b"RIFF" and src[8:12] == b"WEBP":
+        src_data = src
+        file_type = "webp"
     else:
         with open(src, 'rb') as f:
             src_data = f.read()
         output_is_file = True
-    segments = split_into_segments(src_data)
-    exif = get_exif_seg(segments)
+        if src_data[0:2] == b"\xff\xd8":
+            file_type = "jpeg"
+        elif src_data[0:4] == b"RIFF" and src_data[8:12] == b"WEBP":
+            file_type = "webp"
 
-    if exif:
-        new_data = src_data.replace(exif, b"")
-    else:
-        new_data = src_data
+    if file_type == "jpeg":
+        segments = split_into_segments(src_data)
+        exif = get_exif_seg(segments)
+        if exif:
+            new_data = src_data.replace(exif, b"")
+        else:
+            new_data = src_data
+    elif file_type == "webp":
+        try:
+            new_data = _webp.remove(src_data)
+        except ValueError:
+            new_data = src_data
+        except e:
+            print(e.args)
+            raise ValueError("Error ocured.")
 
     if isinstance(new_file, io.BytesIO):
         new_file.write(new_data)
@@ -36,4 +53,4 @@ def remove(src, new_file=None):
         with open(src, "wb+") as f:
             f.write(new_data)
     else:
-        raise ValueError("Give a 2nd argment to 'remove' to output file")
\ No newline at end of file
+        raise ValueError("Give a second argment to 'remove' to output file")
\ No newline at end of file
diff --git a/piexif/_webp.py b/piexif/_webp.py
index 91cffcf..f9cc42e 100644
--- a/piexif/_webp.py
+++ b/piexif/_webp.py
@@ -8,7 +8,6 @@ def split(data):
 
     webp_length_bytes = data[4:8]
     webp_length = struct.unpack("<L", webp_length_bytes)[0]
-    print("webp length: {0}, {1}".format(webp_length, len(data[8:])))
     RIFF_HEADER_SIZE = 8
     file_size = RIFF_HEADER_SIZE + webp_length
 
@@ -25,17 +24,11 @@ def split(data):
         chunk_length = struct.unpack("<L", chunk_length_bytes)[0]
         pointer += LENGTH_BYTES_LENGTH
 
-
-
         chunk_data = data[pointer:pointer + chunk_length]
         chunks.append({"fourcc":fourcc, "length_bytes":chunk_length_bytes, "data":chunk_data})
 
-        print("{0} {1} {2} {3}".format(fourcc, chunk_length, len(chunk_data), chunk_data[-2:]))
-
-
         padding = 1 if chunk_length % 2 else 0
 
-
         pointer += chunk_length + padding
     return chunks
 
@@ -134,8 +127,6 @@ def set_vp8x(chunks):
     if chunks[0]["fourcc"] == b"VP8X":
         chunks.pop(0)
 
-    print(b"".join(flags))
-
     header_bytes = b"VP8X"
     length_bytes = b"\x0a\x00\x00\x00"
     flags_bytes = struct.pack("B", int(b"".join(flags), 2))
@@ -151,7 +142,6 @@ def set_vp8x(chunks):
     return chunks
 
 def get_file_header(chunks):
-    padded = False
     WEBP_HEADER_LENGTH = 4
     FOURCC_LENGTH = 4
     LENGTH_BYTES_LENGTH = 4
@@ -161,14 +151,11 @@ def get_file_header(chunks):
         data_length = struct.unpack("<L", chunk["length_bytes"])[0]
         data_length += 1 if data_length % 2 else 0
         length += FOURCC_LENGTH + LENGTH_BYTES_LENGTH + data_length
-    if length % 2:
-        length += 1
-        padded = True
     length_bytes = struct.pack("<L", length)
     riff = b"RIFF"
     webp_header = b"WEBP"
     file_header = riff + length_bytes + webp_header
-    return (file_header, padded)
+    return file_header
 
 
 
@@ -177,7 +164,7 @@ def get_exif(data):
         raise ValueError("Not WebP")
 
     if data[12:16] != b"VP8X":
-        raise ValueError("don't have exif")
+        raise ValueError("doesnot have exif")
 
     webp_length_bytes = data[4:8]
     webp_length = struct.unpack("<L", webp_length_bytes)[0]
@@ -196,12 +183,13 @@ def get_exif(data):
         pointer += CHUNK_FOURCC_LENGTH
         chunk_length_bytes = data[pointer:pointer + LENGTH_BYTES_LENGTH]
         chunk_length = struct.unpack("<L", chunk_length_bytes)[0]
+        if chunk_length % 2:
+            chunk_length += 1
         pointer += LENGTH_BYTES_LENGTH
         if fourcc == b"EXIF":
-            exif = data[pointer:pointer + chunk_length]
-            break
+            return data[pointer:pointer + chunk_length]
         pointer += chunk_length
-    return exif
+    return None  # if there isn't exif, return None.
 
 
 def insert_exif_into_chunks(chunks, exif_bytes):
@@ -231,120 +219,22 @@ def insert_exif_into_chunks(chunks, exif_bytes):
 
 
 def insert(webp_bytes, exif_bytes):
-    chunks = split(data)
+    chunks = split(webp_bytes)
     chunks = insert_exif_into_chunks(chunks, exif_bytes)
     chunks = set_vp8x(chunks)
-    file_header, padded = get_file_header(chunks)
-    print(b" ".join([chunk["fourcc"] for chunk in chunks]))
+    file_header = get_file_header(chunks)
     merged = merge_chunks(chunks)
-    if padded:
-        merged += b"\x00"
     new_webp_bytes = file_header + merged
-    print(file_header)
     return new_webp_bytes
 
 
 def remove(webp_bytes):
-    chunks = split(data)
+    chunks = split(webp_bytes)
     for index, chunk in enumerate(chunks):
         if chunk["fourcc"] == b"EXIF":
             chunks.pop(index)
     chunks = set_vp8x(chunks)
-    file_header, padded = get_file_header(chunks)
-    print(b" ".join([chunk["fourcc"] for chunk in chunks]))
+    file_header = get_file_header(chunks)
     merged = merge_chunks(chunks)
-    if padded:
-        merged += b"\x00"
     new_webp_bytes = file_header + merged
-    print(file_header)
     return new_webp_bytes
-
-if __name__ == "__main__":
-    import glob
-    import piexif
-    from PIL import Image
-
-    IMAGE_DIR = "images/"
-    OUT_DIR = "images/out/"
-    files = [
-        "web1.webp",
-        "web2.webp",
-        "web3.webp",
-        "web4.webp",
-        "tool1.webp",
-        "pil1.webp",
-        "pil2.webp",
-        "pil3.webp",
-        "pil_rgb.webp",
-        "pil_rgba.webp",
-    ]
-
-
-    exif_dict = {
-        "0th":{
-            piexif.ImageIFD.Software: b"PIL",
-            piexif.ImageIFD.Make: b"Make",
-        }
-    }
-
-    for filename in files:
-        print("\n\n\n**********\n" + filename)
-        Image.open(IMAGE_DIR + filename)
-
-        print("  -----------\n")
-        with open(IMAGE_DIR + filename, "rb") as f:
-            data = f.read()
-
-        chunks = split(data)
-        print(b" ".join([chunk["fourcc"] for chunk in chunks]))
-        file_header, padded = get_file_header(chunks)
-        merged = merge_chunks(chunks)
-        if padded:
-            merged += b"\x00"
-        new_webp_bytes = file_header + merged
-        print(file_header)
-        with open(OUT_DIR + "raw_" + filename, "wb") as f:
-            f.write(new_webp_bytes)
-        try:
-            Image.open(OUT_DIR + "raw_" + filename)
-        except Exception as e:
-            print(e.args)
-
-        print("  -----------\n")
-        exif_bytes = piexif.dump(exif_dict)
-        exif_inserted = insert(data, exif_bytes)
-        with open(OUT_DIR + "i_" + filename, "wb") as f:
-            f.write(exif_inserted)
-        try:
-            Image.open(OUT_DIR + "i_" + filename)
-        except Exception as e:
-            print(e.args)
-
-
-        print("  -----------\n")
-        with open(OUT_DIR + "i_" + filename, "rb") as f:
-            data = f.read()
-        exif_removed = remove(data)
-        with open(OUT_DIR + "r_" + filename, "wb") as f:
-            f.write(exif_removed)
-        try:
-            Image.open(OUT_DIR + "r_" + filename)
-        except Exception as e:
-            print(e.args)
-
-    files = glob.glob(OUT_DIR + "*.webp")
-    result = ""
-    for filename in files:
-        print("\n========================" + filename)
-        with open(filename, "rb") as f:
-            data = f.read()
-        split(data)
-        try:
-            Image.open(filename)
-            result += "-"
-        except Exception as e:
-            print(e.args)
-            result += "!"
-    print(result)
-
-    print("xxxxxxxxxxxxxxxxxxxxxxxx")
\ No newline at end of file
diff --git a/tests/s_test.py b/tests/s_test.py
index 447cbd2..cb84589 100644
--- a/tests/s_test.py
+++ b/tests/s_test.py
@@ -145,16 +145,6 @@ def test_load_tif_m(self):
         zeroth_ifd2 = exif2["0th"]
         self.assertDictEqual(zeroth_ifd, zeroth_ifd2)
 
-    def test_load_fail(self):
-        with self.assertRaises(ValueError):
-            exif = piexif.load(os.path.join("tests", "images", "note.txt"))
-
-        with self.assertRaises(ValueError):
-            exif = piexif.load(os.path.join("tests", "images", "notjpeg.jpg"))
-
-        with self.assertRaises(ValueError):
-            exif = piexif.load(os.path.join("Oh", "My", "God"))
-
     def test_load_from_pilImage_property(self):
         o = io.BytesIO()
         i = Image.open(INPUT_FILE1)
@@ -870,6 +860,31 @@ def test_merge_chunks(self):
             "pil_rgba.webp",
         ]
 
+        for filename in files:
+            with open(IMAGE_DIR + filename, "rb") as f:
+                data = f.read()
+
+            chunks = _webp.split(data)
+            file_header = _webp.get_file_header(chunks)
+            merged = _webp.merge_chunks(chunks)
+            new_webp_bytes = file_header + merged
+            with open(OUT_DIR + "raw_" + filename, "wb") as f:
+                f.write(new_webp_bytes)
+            Image.open(OUT_DIR + "raw_" + filename)
+
+    def test_insert_exif(self):
+        """Can PIL open WebP that is inserted exif?"""
+        IMAGE_DIR = "tests/images/"
+        OUT_DIR = "tests/images/out/"
+        files = [
+            "tool1.webp",
+            "pil1.webp",
+            "pil2.webp",
+            "pil3.webp",
+            "pil_rgb.webp",
+            "pil_rgba.webp",
+        ]
+
         exif_dict = {
             "0th":{
                 piexif.ImageIFD.Software: b"PIL",
@@ -878,37 +893,102 @@ def test_merge_chunks(self):
         }
 
         for filename in files:
-            Image.open(IMAGE_DIR + filename)
-
             with open(IMAGE_DIR + filename, "rb") as f:
                 data = f.read()
+            exif_bytes = piexif.dump(exif_dict)
+            exif_inserted = _webp.insert(data, exif_bytes)
+            with open(OUT_DIR + "i_" + filename, "wb") as f:
+                f.write(exif_inserted)
+            Image.open(OUT_DIR + "i_" + filename)
 
-            chunks = _webp.split(data)
-            file_header, padded = _webp.get_file_header(chunks)
-            merged = _webp.merge_chunks(chunks)
-            if padded:
-                merged += b"\x00"
-            new_webp_bytes = file_header + merged
-            with open(OUT_DIR + "raw_" + filename, "wb") as f:
-                f.write(new_webp_bytes)
-            try:
-                Image.open(OUT_DIR + "raw_" + filename)
-            except Exception as e:
-                print(e.args)
+    def test_remove_exif(self):
+        """Can PIL open WebP that is removed exif?"""
+        IMAGE_DIR = "tests/images/"
+        OUT_DIR = "tests/images/out/"
+        files = [
+            "tool1.webp",
+            "pil1.webp",
+            "pil2.webp",
+            "pil3.webp",
+            "pil_rgb.webp",
+            "pil_rgba.webp",
+        ]
 
+        for filename in files:
+            with open(IMAGE_DIR + filename, "rb") as f:
+                data = f.read()
+            exif_removed = _webp.remove(data)
+            with open(OUT_DIR + "r_" + filename, "wb") as f:
+                f.write(exif_removed)
+            Image.open(OUT_DIR + "r_" + filename)
+
+    def test_get_exif(self):
+        """Can we get exif from WebP?"""
+        IMAGE_DIR = "tests/images/"
+        OUT_DIR = "tests/images/out/"
+        files = [
+            "tool1.webp",
+        ]
 
-        files = glob.glob(OUT_DIR + "raw_*.webp")
-        result = ""
         for filename in files:
-            with open(filename, "rb") as f:
+            with open(IMAGE_DIR + filename, "rb") as f:
                 data = f.read()
-            _webp.split(data)
-            try:
-                Image.open(filename)
-                result += "-"
-            except Exception as e:
-                print(e.args)
-                result += "!"
+            exif_bytes = _webp.get_exif(data)
+            self.assertEqual(exif_bytes[0:2], b"MM")
+
+    def test_load(self):
+        """Can we get exif from WebP?"""
+        IMAGE_DIR = "tests/images/"
+        OUT_DIR = "tests/images/out/"
+        files = [
+            "tool1.webp",
+        ]
+
+        for filename in files:
+            print(piexif.load(IMAGE_DIR + filename))
+
+    def test_remove(self):
+        """Can PIL open WebP that is removed exif?"""
+        IMAGE_DIR = "tests/images/"
+        OUT_DIR = "tests/images/out/"
+        files = [
+            "tool1.webp",
+            "pil1.webp",
+            "pil2.webp",
+            "pil3.webp",
+            "pil_rgb.webp",
+            "pil_rgba.webp",
+        ]
+
+        for filename in files:
+            piexif.remove(OUT_DIR + "r_" + filename, OUT_DIR + "rr_" + filename)
+            Image.open(OUT_DIR + "rr_" + filename)
+
+    def test_insert(self):
+        """Can PIL open WebP that is inserted exif?"""
+        IMAGE_DIR = "tests/images/"
+        OUT_DIR = "tests/images/out/"
+        files = [
+            "tool1.webp",
+            "pil1.webp",
+            "pil2.webp",
+            "pil3.webp",
+            "pil_rgb.webp",
+            "pil_rgba.webp",
+        ]
+
+        exif_dict = {
+            "0th":{
+                piexif.ImageIFD.Software: b"PIL",
+                piexif.ImageIFD.Make: b"Make",
+            }
+        }
+        exif_bytes = piexif.dump(exif_dict)
+        
+        for filename in files:
+            piexif.insert(exif_bytes, IMAGE_DIR + filename, OUT_DIR + "ii_" + filename)
+            Image.open(OUT_DIR + "ii_" + filename)
+
 
 def suite():
     suite = unittest.TestSuite()

From b88b91c660c386f37c09a9e714620e81f8ccc62c Mon Sep 17 00:00:00 2001
From: hMatoba <hiroaki.mtb@outlook.com>
Date: Thu, 4 Jan 2018 00:28:23 +0900
Subject: [PATCH 03/11] Update version.

---
 piexif/__init__.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/piexif/__init__.py b/piexif/__init__.py
index 7f51456..f484be3 100644
--- a/piexif/__init__.py
+++ b/piexif/__init__.py
@@ -8,4 +8,4 @@
 
 
 
-VERSION = '1.0.13'
+VERSION = '1.1.0b'

From 6d067b4f9abea0f40fe202b6ef8079ab826d9cc3 Mon Sep 17 00:00:00 2001
From: hMatoba <hiroaki.mtb@outlook.com>
Date: Thu, 4 Jan 2018 00:30:02 +0900
Subject: [PATCH 04/11] Edit document.

---
 doc/changes.rst | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/doc/changes.rst b/doc/changes.rst
index 184358f..0425945 100644
--- a/doc/changes.rst
+++ b/doc/changes.rst
@@ -1,6 +1,11 @@
 Changelog
 =========
 
+1.1.0b
+------
+
+- "load", "insert", and "remove" support WebP format.
+
 1.0.13
 ------
 

From e1506b14d2ff39c88adce6e5e982b2326156a969 Mon Sep 17 00:00:00 2001
From: hMatoba <hiroaki.mtb@outlook.com>
Date: Thu, 4 Jan 2018 00:40:04 +0900
Subject: [PATCH 05/11] mkdir test outputs.

---
 tests/s_test.py | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/tests/s_test.py b/tests/s_test.py
index cb84589..d3f54c0 100644
--- a/tests/s_test.py
+++ b/tests/s_test.py
@@ -847,6 +847,12 @@ def test_decode_bad_encoding(self):
 
 
 class WebpTests(unittest.TestCase):
+    def setUp(self):
+        try:
+            os.mkdir("tests/images/out")
+        except:
+            pass
+
     def test_merge_chunks(self):
         """Can PIL open our output WebP?"""
         IMAGE_DIR = "tests/images/"

From a8ec8f68b431ddf0ded17aa8fea5cdd3c5426aa8 Mon Sep 17 00:00:00 2001
From: hMatoba <hiroaki.mtb@outlook.com>
Date: Thu, 4 Jan 2018 00:44:01 +0900
Subject: [PATCH 06/11] fix test.

---
 tests/s_test.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tests/s_test.py b/tests/s_test.py
index d3f54c0..cf6ebab 100644
--- a/tests/s_test.py
+++ b/tests/s_test.py
@@ -967,7 +967,7 @@ def test_remove(self):
         ]
 
         for filename in files:
-            piexif.remove(OUT_DIR + "r_" + filename, OUT_DIR + "rr_" + filename)
+            piexif.remove(IMAGE_DIR + filename, OUT_DIR + "rr_" + filename)
             Image.open(OUT_DIR + "rr_" + filename)
 
     def test_insert(self):

From 909e901c03c7ca0f89340128c655049bb8613b23 Mon Sep 17 00:00:00 2001
From: hMatoba <hiroaki.mtb@outlook.com>
Date: Thu, 4 Jan 2018 00:48:37 +0900
Subject: [PATCH 07/11] Change pillow version in test.

---
 .travis.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.travis.yml b/.travis.yml
index e8cc57e..533ef9a 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -11,7 +11,7 @@ python:
  - 3.6
 
 install:
- - pip install pillow==4.0.0
+ - pip install pillow==4.3.0
  - pip install coveralls
 
 script:

From 1e8eb03ed37e662a0d4bb947e4045d5c366968c7 Mon Sep 17 00:00:00 2001
From: hMatoba <hiroaki.mtb@outlook.com>
Date: Thu, 4 Jan 2018 00:56:50 +0900
Subject: [PATCH 08/11] Change pillow version for test.

---
 .travis.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.travis.yml b/.travis.yml
index 533ef9a..bd7258b 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -11,7 +11,7 @@ python:
  - 3.6
 
 install:
- - pip install pillow==4.3.0
+ - pip install pillow==5.0.0
  - pip install coveralls
 
 script:

From 3b26cb102d4d84d499239bad11a28d862f848700 Mon Sep 17 00:00:00 2001
From: hMatoba <hiroaki.mtb@outlook.com>
Date: Thu, 4 Jan 2018 09:22:42 +0900
Subject: [PATCH 09/11] test

---
 tests/s_test.py | 1 +
 1 file changed, 1 insertion(+)

diff --git a/tests/s_test.py b/tests/s_test.py
index cf6ebab..4d5bf4e 100644
--- a/tests/s_test.py
+++ b/tests/s_test.py
@@ -967,6 +967,7 @@ def test_remove(self):
         ]
 
         for filename in files:
+            Image.open(IMAGE_DIR + filename)
             piexif.remove(IMAGE_DIR + filename, OUT_DIR + "rr_" + filename)
             Image.open(OUT_DIR + "rr_" + filename)
 

From 4049cd70869a829127299e61f47c008391216474 Mon Sep 17 00:00:00 2001
From: hMatoba <hiroaki.mtb@outlook.com>
Date: Thu, 4 Jan 2018 09:34:37 +0900
Subject: [PATCH 10/11] Remove a test image.

---
 tests/images/tool1.webp | Bin 978 -> 0 bytes
 tests/s_test.py         |   9 ++-------
 2 files changed, 2 insertions(+), 7 deletions(-)
 delete mode 100644 tests/images/tool1.webp

diff --git a/tests/images/tool1.webp b/tests/images/tool1.webp
deleted file mode 100644
index 7515c7cfb7d3f74ee8541d2409d943bd89f29bc9..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 978
zcmWIYbaOk!%)k)t>J$(bU=hK^z`(!(#P(nW6j8`yVqn<7%P^Nw%Yngx!EU0%EN|7t
zixihg@Gxu;;&c%En|Siqwi!*na@opyuCsj}He9;3{jDqebF~Af>J~4x)<0dAxjA#|
ziN#XNy<Izlmfy+}4qvo)_5;?_oBy7X%c)Xy=+F%~a=mo-tDUL0H6AP7+I}nk)cGsn
z-i-|m{~B`hwS_h`{E2^@yuT(}=gBOM)1tHY7Jl6S+~{3tYDh&<))`K($Frxd`!i+L
zHjdp>+BYqje>PZd^DWs$F8LuQzh8DtoK*Ipdj|XL=VyWry*aCy$URT+e~TY)&fU8!
z7p|XeYhFAx|9!zL>p4+nU+Zo&tKZnI8q~YWckaT%Wi}QI8urgP^htw_DesDjxFN6c
zy|=a<E_w^(4&Q$E#8g=4$ATlQr*4MVI86V#_T6k5l~b0VTQA;cZ&y^Es=;GF>sqxP
zuU&+y(B3W~smGVNUVCwd?cuPSJ@e)97ALiavbuQrDSk74>b|(qA2CT_VqKzWzSqM@
z_fW^%Rk!a)uen)#Z|Q66=d<*a*RwmQO}5*(Q}%}6+WULv?rh0^_h`e@D@r#VyUWzI
z|Mzg8XZTxmPiOAKbuQK2R<7rN@BZ-i(yb*=OC+wwBu+T@GCp(eX_tSk5kVW)xZV?%
zTd^g7@l8`3A+Pmof4(zm(~Aq8#`5)~-i}4Q?oaI;m^P<eQjQZ3QfFWPy@@q-jsNCv
ztgaEq+<$c}I-Zv!vh_tw=4*Bl{lDSsymT*>@A%)m_f8h8S6;G9e(3G1&jJ=*dT&{p
zyRt>}Ww)>R`{dnszD|n>@N7E#uJoLz!@&m!4f-s<|1SG~QzGE|x+AuKIc0aRW3-yv
z{-e-5DeVix)&p0+b6qW9aE<VEGh<|6@bzWT0w+ffMt%lhDr8^<;ygwHFdLLmOBkiV
zVnDSFb&S$*b{nGx129c9FoIMv8iLge0{MOInG7soaR!D3OH9Dxl0X$QKrx13f4@iu
z22USnS6%ZUUn7t*9f(>8U67cWSE84fTB2a0XP{?j36x`NngzG>UDI4R`&)-P*nTF)
z2@DJqn8Egl0M-AS#0e2+5MW@K#068&C<K%P0gyjZfEesXBLhQoD+5z214{)X11lpl
pD`Qij6mtuZ0Q%j{Rl(9AH&?;UNY6sSH!-;=U%_3$KRB3y0Ra1@X4?P&

diff --git a/tests/s_test.py b/tests/s_test.py
index 4d5bf4e..0e3863d 100644
--- a/tests/s_test.py
+++ b/tests/s_test.py
@@ -858,7 +858,6 @@ def test_merge_chunks(self):
         IMAGE_DIR = "tests/images/"
         OUT_DIR = "tests/images/out/"
         files = [
-            "tool1.webp",
             "pil1.webp",
             "pil2.webp",
             "pil3.webp",
@@ -883,7 +882,6 @@ def test_insert_exif(self):
         IMAGE_DIR = "tests/images/"
         OUT_DIR = "tests/images/out/"
         files = [
-            "tool1.webp",
             "pil1.webp",
             "pil2.webp",
             "pil3.webp",
@@ -912,7 +910,6 @@ def test_remove_exif(self):
         IMAGE_DIR = "tests/images/"
         OUT_DIR = "tests/images/out/"
         files = [
-            "tool1.webp",
             "pil1.webp",
             "pil2.webp",
             "pil3.webp",
@@ -933,7 +930,7 @@ def test_get_exif(self):
         IMAGE_DIR = "tests/images/"
         OUT_DIR = "tests/images/out/"
         files = [
-            "tool1.webp",
+            "pil3.webp",
         ]
 
         for filename in files:
@@ -947,7 +944,7 @@ def test_load(self):
         IMAGE_DIR = "tests/images/"
         OUT_DIR = "tests/images/out/"
         files = [
-            "tool1.webp",
+            "pil3.webp",
         ]
 
         for filename in files:
@@ -958,7 +955,6 @@ def test_remove(self):
         IMAGE_DIR = "tests/images/"
         OUT_DIR = "tests/images/out/"
         files = [
-            "tool1.webp",
             "pil1.webp",
             "pil2.webp",
             "pil3.webp",
@@ -976,7 +972,6 @@ def test_insert(self):
         IMAGE_DIR = "tests/images/"
         OUT_DIR = "tests/images/out/"
         files = [
-            "tool1.webp",
             "pil1.webp",
             "pil2.webp",
             "pil3.webp",

From f8ab1ced0e46293fbf73b3e3aa1829ef68e9173c Mon Sep 17 00:00:00 2001
From: hMatoba <hiroaki.mtb@outlook.com>
Date: Fri, 5 Jan 2018 00:26:54 +0900
Subject: [PATCH 11/11] Edit test.

---
 tests/images/tool1.webp | Bin 0 -> 978 bytes
 tests/s_test.py         |  49 +++++++++++++++++++++++++++++++++++++---
 2 files changed, 46 insertions(+), 3 deletions(-)
 create mode 100644 tests/images/tool1.webp

diff --git a/tests/images/tool1.webp b/tests/images/tool1.webp
new file mode 100644
index 0000000000000000000000000000000000000000..7515c7cfb7d3f74ee8541d2409d943bd89f29bc9
GIT binary patch
literal 978
zcmWIYbaOk!%)k)t>J$(bU=hK^z`(!(#P(nW6j8`yVqn<7%P^Nw%Yngx!EU0%EN|7t
zixihg@Gxu;;&c%En|Siqwi!*na@opyuCsj}He9;3{jDqebF~Af>J~4x)<0dAxjA#|
ziN#XNy<Izlmfy+}4qvo)_5;?_oBy7X%c)Xy=+F%~a=mo-tDUL0H6AP7+I}nk)cGsn
z-i-|m{~B`hwS_h`{E2^@yuT(}=gBOM)1tHY7Jl6S+~{3tYDh&<))`K($Frxd`!i+L
zHjdp>+BYqje>PZd^DWs$F8LuQzh8DtoK*Ipdj|XL=VyWry*aCy$URT+e~TY)&fU8!
z7p|XeYhFAx|9!zL>p4+nU+Zo&tKZnI8q~YWckaT%Wi}QI8urgP^htw_DesDjxFN6c
zy|=a<E_w^(4&Q$E#8g=4$ATlQr*4MVI86V#_T6k5l~b0VTQA;cZ&y^Es=;GF>sqxP
zuU&+y(B3W~smGVNUVCwd?cuPSJ@e)97ALiavbuQrDSk74>b|(qA2CT_VqKzWzSqM@
z_fW^%Rk!a)uen)#Z|Q66=d<*a*RwmQO}5*(Q}%}6+WULv?rh0^_h`e@D@r#VyUWzI
z|Mzg8XZTxmPiOAKbuQK2R<7rN@BZ-i(yb*=OC+wwBu+T@GCp(eX_tSk5kVW)xZV?%
zTd^g7@l8`3A+Pmof4(zm(~Aq8#`5)~-i}4Q?oaI;m^P<eQjQZ3QfFWPy@@q-jsNCv
ztgaEq+<$c}I-Zv!vh_tw=4*Bl{lDSsymT*>@A%)m_f8h8S6;G9e(3G1&jJ=*dT&{p
zyRt>}Ww)>R`{dnszD|n>@N7E#uJoLz!@&m!4f-s<|1SG~QzGE|x+AuKIc0aRW3-yv
z{-e-5DeVix)&p0+b6qW9aE<VEGh<|6@bzWT0w+ffMt%lhDr8^<;ygwHFdLLmOBkiV
zVnDSFb&S$*b{nGx129c9FoIMv8iLge0{MOInG7soaR!D3OH9Dxl0X$QKrx13f4@iu
z22USnS6%ZUUn7t*9f(>8U67cWSE84fTB2a0XP{?j36x`NngzG>UDI4R`&)-P*nTF)
z2@DJqn8Egl0M-AS#0e2+5MW@K#068&C<K%P0gyjZfEesXBLhQoD+5z214{)X11lpl
pD`Qij6mtuZ0Q%j{Rl(9AH&?;UNY6sSH!-;=U%_3$KRB3y0Ra1@X4?P&

literal 0
HcmV?d00001

diff --git a/tests/s_test.py b/tests/s_test.py
index 0e3863d..85397dc 100644
--- a/tests/s_test.py
+++ b/tests/s_test.py
@@ -858,6 +858,7 @@ def test_merge_chunks(self):
         IMAGE_DIR = "tests/images/"
         OUT_DIR = "tests/images/out/"
         files = [
+            "tool1.webp",
             "pil1.webp",
             "pil2.webp",
             "pil3.webp",
@@ -866,6 +867,12 @@ def test_merge_chunks(self):
         ]
 
         for filename in files:
+            try:
+                Image.open(IMAGE_DIR + filename)
+            except:
+                print("Pillow can't read {0}".format(filename))
+                continue
+
             with open(IMAGE_DIR + filename, "rb") as f:
                 data = f.read()
 
@@ -882,6 +889,7 @@ def test_insert_exif(self):
         IMAGE_DIR = "tests/images/"
         OUT_DIR = "tests/images/out/"
         files = [
+            "tool1.webp",
             "pil1.webp",
             "pil2.webp",
             "pil3.webp",
@@ -897,6 +905,12 @@ def test_insert_exif(self):
         }
 
         for filename in files:
+            try:
+                Image.open(IMAGE_DIR + filename)
+            except:
+                print("Pillow can't read {0}".format(filename))
+                continue
+
             with open(IMAGE_DIR + filename, "rb") as f:
                 data = f.read()
             exif_bytes = piexif.dump(exif_dict)
@@ -910,6 +924,7 @@ def test_remove_exif(self):
         IMAGE_DIR = "tests/images/"
         OUT_DIR = "tests/images/out/"
         files = [
+            "tool1.webp",
             "pil1.webp",
             "pil2.webp",
             "pil3.webp",
@@ -918,6 +933,12 @@ def test_remove_exif(self):
         ]
 
         for filename in files:
+            try:
+                Image.open(IMAGE_DIR + filename)
+            except:
+                print("Pillow can't read {0}".format(filename))
+                continue
+
             with open(IMAGE_DIR + filename, "rb") as f:
                 data = f.read()
             exif_removed = _webp.remove(data)
@@ -930,10 +951,16 @@ def test_get_exif(self):
         IMAGE_DIR = "tests/images/"
         OUT_DIR = "tests/images/out/"
         files = [
-            "pil3.webp",
+            "tool1.webp",
         ]
 
         for filename in files:
+            try:
+                Image.open(IMAGE_DIR + filename)
+            except:
+                print("Pillow can't read {0}".format(filename))
+                continue
+
             with open(IMAGE_DIR + filename, "rb") as f:
                 data = f.read()
             exif_bytes = _webp.get_exif(data)
@@ -944,10 +971,15 @@ def test_load(self):
         IMAGE_DIR = "tests/images/"
         OUT_DIR = "tests/images/out/"
         files = [
-            "pil3.webp",
+            "tool1.webp",
         ]
 
         for filename in files:
+            try:
+                Image.open(IMAGE_DIR + filename)
+            except:
+                print("Pillow can't read {0}".format(filename))
+                continue
             print(piexif.load(IMAGE_DIR + filename))
 
     def test_remove(self):
@@ -955,6 +987,7 @@ def test_remove(self):
         IMAGE_DIR = "tests/images/"
         OUT_DIR = "tests/images/out/"
         files = [
+            "tool1.webp",
             "pil1.webp",
             "pil2.webp",
             "pil3.webp",
@@ -963,7 +996,11 @@ def test_remove(self):
         ]
 
         for filename in files:
-            Image.open(IMAGE_DIR + filename)
+            try:
+                Image.open(IMAGE_DIR + filename)
+            except:
+                print("Pillow can't read {0}".format(filename))
+                continue
             piexif.remove(IMAGE_DIR + filename, OUT_DIR + "rr_" + filename)
             Image.open(OUT_DIR + "rr_" + filename)
 
@@ -972,6 +1009,7 @@ def test_insert(self):
         IMAGE_DIR = "tests/images/"
         OUT_DIR = "tests/images/out/"
         files = [
+            "tool1.webp",
             "pil1.webp",
             "pil2.webp",
             "pil3.webp",
@@ -988,6 +1026,11 @@ def test_insert(self):
         exif_bytes = piexif.dump(exif_dict)
         
         for filename in files:
+            try:
+                Image.open(IMAGE_DIR + filename)
+            except:
+                print("Pillow can't read {0}".format(filename))
+                continue
             piexif.insert(exif_bytes, IMAGE_DIR + filename, OUT_DIR + "ii_" + filename)
             Image.open(OUT_DIR + "ii_" + filename)