Fix .docx segmentation fault

update

CMakeLists.txt

@@ -4,6 +4,7 @@ project(scan)
 set(CMAKE_C_STANDARD 11)
 
 option(BUILD_TESTS "Build tests" off)
+option(SIST_FAKE_STORE "Disable IO operations of LMDB stores for debugging purposes" 0)
 
 add_subdirectory(third-party/antiword)
 add_compile_definitions(
@@ -31,7 +32,6 @@ add_library(
 set_target_properties(scan PROPERTIES LINKER_LANGUAGE C)
 
 set(CMAKE_FIND_LIBRARY_SUFFIXES .a .lib .so)
-target_link_directories(scan PUBLIC /usr/share/vcpkg/installed/x64-linux/lib/)
 
 find_package(LibArchive REQUIRED)
 find_package(BZip2 REQUIRED)
@@ -42,8 +42,6 @@ find_package(Tesseract CONFIG REQUIRED)
 find_package(OpenJPEG CONFIG REQUIRED)
 find_package(JPEG REQUIRED)
 find_package(LibXml2 REQUIRED)
-find_package(FFMPEG REQUIRED)
-#find_package(OpenSSL REQUIRED)
 find_package(LibLZMA REQUIRED)
 find_package(ZLIB REQUIRED)
 
@@ -58,7 +56,7 @@ find_library(MUPDF_LIB NAMES liblibmupdf.a)
 find_library(CMS_LIB NAMES lcms)
 find_library(JAS_LIB NAMES jasper)
 find_library(GUMBO_LIB NAMES gumbo)
-find_library(GOMP_LIB NAMES libgomp.a gomp PATHS /usr/lib/gcc/x86_64-linux-gnu/5/ /usr/lib/gcc/x86_64-linux-gnu/9/ /usr/lib/gcc/x86_64-linux-gnu/10/ /usr/lib/gcc/aarch64-linux-gnu/7/)
+find_library(GOMP_LIB NAMES libgomp.a gomp PATHS /usr/lib/gcc/x86_64-linux-gnu/5/ /usr/lib/gcc/x86_64-linux-gnu/9/ /usr/lib/gcc/x86_64-linux-gnu/10/ /usr/lib/gcc/aarch64-linux-gnu/7/ /usr/lib/gcc/aarch64-linux-gnu/9/ /usr/lib/gcc/x86_64-linux-gnu/7/)
 
 
 target_compile_options(
@@ -90,28 +88,35 @@ ExternalProject_Add(
 SET(MOBI_LIB_DIR ${CMAKE_CURRENT_BINARY_DIR}/third-party/ext_libmobi/src/libmobi/src/.libs/)
 SET(MOBI_INCLUDE_DIR ${CMAKE_CURRENT_BINARY_DIR}/third-party/ext_libmobi/src/libmobi/src/)
 
+if (SIST_DEBUG)
+    SET(FFMPEG_DEBUG "--enable-debug=3" "--disable-optimizations")
+else()
+    SET(FFMPEG_DEBUG "")
+endif()
+
 ExternalProject_Add(
         ffmpeg
         GIT_REPOSITORY https://git.ffmpeg.org/ffmpeg.git
-        GIT_TAG "master"
+        GIT_TAG "n4.3.2"
 
         UPDATE_COMMAND ""
         PATCH_COMMAND ""
         TEST_COMMAND ""
         CONFIGURE_COMMAND ./configure --disable-shared --enable-static --disable-ffmpeg --disable-ffplay
         --disable-ffprobe --disable-doc --disable-manpages --disable-postproc --disable-avfilter --disable-alsa
-        --disable-lzma --disable-xlib --disable-debug --disable-vdpau --disable-vaapi --disable-sdl2
-        --disable-network --extra-cflags=-fPIC
+        --disable-lzma --disable-xlib --disable-vdpau --disable-vaapi --disable-sdl2
+        --disable-network  ${FFMPEG_DEBUG}
         INSTALL_COMMAND ""
 
         PREFIX "third-party/ext_ffmpeg"
         SOURCE_DIR "third-party/ext_ffmpeg/src/ffmpeg"
         BINARY_DIR "third-party/ext_ffmpeg/src/ffmpeg"
 
-        BUILD_COMMAND ${MAKE_EXE} -j 8 --silent
+        BUILD_COMMAND ${MAKE_EXE} -j33 --silent
 )
 
 SET(FFMPEG_LIB_DIR ${CMAKE_CURRENT_BINARY_DIR}/third-party/ext_ffmpeg/src/ffmpeg)
+SET(FFMPEG_INCLUDE_DIR ${CMAKE_CURRENT_BINARY_DIR}/third-party/ext_ffmpeg/src/ffmpeg)
 
 add_dependencies(
         scan

libscan/comic/comic.c

@@ -12,6 +12,10 @@ void parse_comic(scan_comic_ctx_t *ctx, vfile_t *f, document_t *doc) {
     struct archive_entry *entry = NULL;
     arc_data_t arc_data;
 
+    if (ctx->tn_size <= 0) {
+        return;
+    }
+
     int ret = arc_open(&arc_ctx, f, &a, &arc_data, TRUE);
     if (ret != ARCHIVE_OK) {
         CTX_LOG_ERRORF(f->filepath, "(cbr.c) [%d] %s", ret, archive_error_string(a))
@@ -26,10 +30,10 @@ void parse_comic(scan_comic_ctx_t *ctx, vfile_t *f, document_t *doc) {
             const char *file_path = utf8_name == NULL ? archive_entry_pathname(entry) : utf8_name;
 
             char *p = strrchr(file_path, '.');
-            if (p != NULL && strcmp(p, ".png") == 0 || strcmp(p, ".jpg") == 0 || strcmp(p, ".jpeg") == 0) {
+            if (p != NULL && (strcmp(p, ".png") == 0 || strcmp(p, ".jpg") == 0 || strcmp(p, ".jpeg") == 0)) {
                 size_t entry_size = archive_entry_size(entry);
                 void *buf = malloc(entry_size);
-                int read = archive_read_data(a, buf, entry_size);
+                size_t read = archive_read_data(a, buf, entry_size);
 
                 if (read != entry_size) {
                     const char *err_str = archive_error_string(a);

libscan/ebook/ebook.c

@@ -4,6 +4,7 @@
 #include <tesseract/capi.h>
 
 #include "../media/media.h"
+#include "../arc/arc.h"
 
 #define MIN_OCR_SIZE 350
 #define MIN_OCR_LEN 10
@@ -38,16 +39,15 @@ int pixmap_is_blank(const fz_pixmap *pixmap) {
     return TRUE;
 }
 
-fz_pixmap *load_pixmap(scan_ebook_ctx_t *ctx, int page, fz_context *fzctx, fz_document *fzdoc, document_t *doc, fz_page **cover) {
+fz_pixmap *
+load_pixmap(scan_ebook_ctx_t *ctx, int page, fz_context *fzctx, fz_document *fzdoc, document_t *doc, fz_page **cover) {
 
     int err = 0;
 
     fz_var(cover);
     fz_var(err);
-    fz_try(fzctx)
-        *cover = fz_load_page(fzctx, fzdoc, page);
-    fz_catch(fzctx)
-        err = 1;
+    fz_try(fzctx)*cover = fz_load_page(fzctx, fzdoc, page);
+    fz_catch(fzctx)err = 1;
 
     if (err != 0) {
         CTX_LOG_WARNINGF(doc->filepath, "fz_load_page() returned error code [%d] %s", err, fzctx->error.message)
@@ -75,14 +75,11 @@ fz_pixmap *load_pixmap(scan_ebook_ctx_t *ctx, int page, fz_context *fzctx, fz_do
 
     fz_var(err);
     fz_try(fzctx) {
-        fz_run_page(fzctx, *cover, dev, fz_identity, NULL);
-    }
-    fz_always(fzctx) {
-        fz_close_device(fzctx, dev);
-        fz_drop_device(fzctx, dev);
-    }
-    fz_catch(fzctx)
-        err = fzctx->error.errcode;
+                fz_run_page(fzctx, *cover, dev, fz_identity, NULL);
+            } fz_always(fzctx) {
+            fz_close_device(fzctx, dev);
+            fz_drop_device(fzctx, dev);
+        } fz_catch(fzctx)err = fzctx->error.errcode;
 
     if (err != 0) {
         CTX_LOG_WARNINGF(doc->filepath, "fz_run_page() returned error code [%d] %s", err, fzctx->error.message)
@@ -131,10 +128,11 @@ int render_cover(scan_ebook_ctx_t *ctx, fz_context *fzctx, document_t *doc, fz_d
     int dst_buf_len = av_image_get_buffer_size(AV_PIX_FMT_YUV420P, pixmap->w, pixmap->h, 1);
     uint8_t *dst_buf = (uint8_t *) av_malloc(dst_buf_len);
 
-    av_image_fill_arrays(scaled_frame->data, scaled_frame->linesize, dst_buf, AV_PIX_FMT_YUV420P, pixmap->w, pixmap->h, 1);
+    av_image_fill_arrays(scaled_frame->data, scaled_frame->linesize, dst_buf, AV_PIX_FMT_YUV420P, pixmap->w, pixmap->h,
+                         1);
 
     const uint8_t *in_data[1] = {pixmap->samples};
-    int in_line_size[1] = {pixmap->stride};
+    int in_line_size[1] = {(int) pixmap->stride};
 
     sws_scale(sws_ctx,
               in_data, in_line_size,
@@ -223,7 +221,7 @@ static int read_stext_block(fz_stext_block *block, text_buffer_t *tex) {
     return 0;
 }
 
-#define IS_VALID_BPP(d) (d==1 || d==2 || d==4 || d==8 || d==16 || d==24 || d==32)
+#define IS_VALID_BPP(d) ((d)==1 || (d)==2 || (d)==4 || (d)==8 || (d)==16 || (d)==24 || (d)==32)
 
 void fill_image(fz_context *fzctx, UNUSED(fz_device *dev),
                 fz_image *img, UNUSED(fz_matrix ctm), UNUSED(float alpha),
@@ -255,9 +253,10 @@ void fill_image(fz_context *fzctx, UNUSED(fz_device *dev),
     }
 }
 
-void parse_ebook_mem(scan_ebook_ctx_t *ctx, void *buf, size_t buf_len, const char *mime_str, document_t *doc, int tn_only) {
+void
+parse_ebook_mem(scan_ebook_ctx_t *ctx, void *buf, size_t buf_len, const char *mime_str, document_t *doc, int tn_only) {
 
-    fz_context *fzctx = fz_new_context(NULL, NULL, FZ_STORE_UNLIMITED);
+    fz_context *fzctx = fz_new_context(NULL, NULL, FZ_STORE_DEFAULT);
     thread_ctx = *ctx;
 
     init_fzctx(fzctx, doc);
@@ -270,13 +269,10 @@ void parse_ebook_mem(scan_ebook_ctx_t *ctx, void *buf, size_t buf_len, const cha
     fz_var(stream);
     fz_var(err);
 
-    fz_try(fzctx)
-    {
-        stream = fz_open_memory(fzctx, buf, buf_len);
-        fzdoc = fz_open_document_with_stream(fzctx, mime_str, stream);
-    }
-    fz_catch(fzctx)
-        err = fzctx->error.errcode;
+    fz_try(fzctx) {
+                stream = fz_open_memory(fzctx, buf, buf_len);
+                fzdoc = fz_open_document_with_stream(fzctx, mime_str, stream);
+            } fz_catch(fzctx)err = fzctx->error.errcode;
 
     if (err != 0) {
         fz_drop_stream(fzctx, stream);
@@ -287,10 +283,8 @@ void parse_ebook_mem(scan_ebook_ctx_t *ctx, void *buf, size_t buf_len, const cha
 
     int page_count = -1;
     fz_var(err);
-    fz_try(fzctx)
-        page_count = fz_count_pages(fzctx, fzdoc);
-    fz_catch(fzctx)
-        err = fzctx->error.errcode;
+    fz_try(fzctx)page_count = fz_count_pages(fzctx, fzdoc);
+    fz_catch(fzctx)err = fzctx->error.errcode;
 
     if (err) {
         CTX_LOG_WARNINGF(doc->filepath, "fz_count_pages() returned error code [%d] %s", err, fzctx->error.message)
@@ -319,20 +313,16 @@ void parse_ebook_mem(scan_ebook_ctx_t *ctx, void *buf, size_t buf_len, const cha
     }
 
     char title[8192] = {'\0',};
-    fz_try(fzctx)
-                fz_lookup_metadata(fzctx, fzdoc, FZ_META_INFO_TITLE, title, sizeof(title));
-    fz_catch(fzctx)
-        ;
+    fz_try(fzctx)fz_lookup_metadata(fzctx, fzdoc, FZ_META_INFO_TITLE, title, sizeof(title));
+    fz_catch(fzctx);
 
     if (strlen(title) > 0) {
         APPEND_UTF8_META(doc, MetaTitle, title)
     }
 
     char author[4096] = {'\0',};
-    fz_try(fzctx)
-                fz_lookup_metadata(fzctx, fzdoc, FZ_META_INFO_AUTHOR, author, sizeof(author));
-    fz_catch(fzctx)
-        ;
+    fz_try(fzctx)fz_lookup_metadata(fzctx, fzdoc, FZ_META_INFO_AUTHOR, author, sizeof(author));
+    fz_catch(fzctx);
 
     if (strlen(author) > 0) {
         APPEND_UTF8_META(doc, MetaAuthor, author)
@@ -346,10 +336,8 @@ void parse_ebook_mem(scan_ebook_ctx_t *ctx, void *buf, size_t buf_len, const cha
         for (int current_page = 0; current_page < page_count; current_page++) {
             fz_page *page = NULL;
             fz_var(err);
-            fz_try(fzctx)
-                page = fz_load_page(fzctx, fzdoc, current_page);
-            fz_catch(fzctx)
-                err = fzctx->error.errcode;
+            fz_try(fzctx)page = fz_load_page(fzctx, fzdoc, current_page);
+            fz_catch(fzctx)err = fzctx->error.errcode;
             if (err != 0) {
                 CTX_LOG_WARNINGF(doc->filepath, "fz_load_page() returned error code [%d] %s", err, fzctx->error.message)
                 text_buffer_destroy(&thread_buffer);
@@ -373,15 +361,11 @@ void parse_ebook_mem(scan_ebook_ctx_t *ctx, void *buf, size_t buf_len, const cha
             }
 
             fz_var(err);
-            fz_try(fzctx)
-                fz_run_page(fzctx, page, dev, fz_identity, NULL);
-            fz_always(fzctx)
-            {
-                fz_close_device(fzctx, dev);
-                fz_drop_device(fzctx, dev);
-            }
-            fz_catch(fzctx)
-                err = fzctx->error.errcode;
+            fz_try(fzctx)fz_run_page(fzctx, page, dev, fz_identity, NULL);
+            fz_always(fzctx) {
+                    fz_close_device(fzctx, dev);
+                    fz_drop_device(fzctx, dev);
+                } fz_catch(fzctx)err = fzctx->error.errcode;
 
             if (err != 0) {
                 CTX_LOG_WARNINGF(doc->filepath, "fz_run_page() returned error code [%d] %s", err, fzctx->error.message)
@@ -424,7 +408,77 @@ void parse_ebook_mem(scan_ebook_ctx_t *ctx, void *buf, size_t buf_len, const cha
     fz_drop_context(fzctx);
 }
 
+static scan_arc_ctx_t arc_ctx = (scan_arc_ctx_t) {.passphrase = {0,}};
+
+void parse_epub_fast(scan_ebook_ctx_t *ctx, vfile_t *f, document_t *doc) {
+    struct archive *a = NULL;
+    struct archive_entry *entry = NULL;
+    arc_data_t arc_data;
+
+    text_buffer_t content_buffer = text_buffer_create(ctx->content_size);
+
+    if (ctx->tn_size <= 0) {
+        return;
+    }
+
+    int ret = arc_open(&arc_ctx, f, &a, &arc_data, TRUE);
+    if (ret != ARCHIVE_OK) {
+        CTX_LOG_ERRORF(f->filepath, "(ebook.c) [%d] %s", ret, archive_error_string(a))
+        archive_read_free(a);
+        return;
+    }
+
+    while (archive_read_next_header(a, &entry) == ARCHIVE_OK) {
+        struct stat info = *archive_entry_stat(entry);
+        if (S_ISREG(info.st_mode)) {
+            const char *utf8_name = archive_entry_pathname_utf8(entry);
+            const char *file_path = utf8_name == NULL ? archive_entry_pathname(entry) : utf8_name;
+
+            char *p = strrchr(file_path, '.');
+            if (p != NULL && (strcmp(p, ".html") == 0 || (strcmp(p, ".xhtml") == 0))) {
+                size_t entry_size = archive_entry_size(entry);
+                void *buf = malloc(entry_size + 1);
+                size_t read = archive_read_data(a, buf, entry_size);
+                *(char *) (buf + entry_size) = '\0';
+
+                if (read != entry_size) {
+                    const char *err_str = archive_error_string(a);
+                    if (err_str) {
+                        CTX_LOG_ERRORF("ebook.c", "Error while reading entry: %s", err_str)
+                    }
+                    free(buf);
+                    break;
+                }
+
+                ret = text_buffer_append_markup(&content_buffer, buf);
+                free(buf);
+
+                if (ret == TEXT_BUF_FULL) {
+                    break;
+                }
+            }
+        }
+    }
+
+    text_buffer_terminate_string(&content_buffer);
+
+    meta_line_t *meta_content = malloc(sizeof(meta_line_t) + content_buffer.dyn_buffer.cur);
+    meta_content->key = MetaContent;
+    memcpy(meta_content->str_val, content_buffer.dyn_buffer.buf, content_buffer.dyn_buffer.cur);
+    APPEND_META(doc, meta_content)
+
+    text_buffer_destroy(&content_buffer);
+
+    archive_read_free(a);
+}
+
 void parse_ebook(scan_ebook_ctx_t *ctx, vfile_t *f, const char *mime_str, document_t *doc) {
+
+    if (ctx->fast_epub_parse && is_epub(mime_str)) {
+        parse_epub_fast(ctx, f, doc);
+        return;
+    }
+
     size_t buf_len;
     void *buf = read_all(f, &buf_len);
     if (buf == NULL) {

libscan/ebook/ebook.h

@@ -13,9 +13,17 @@ typedef struct {
     log_callback_t log;
     logf_callback_t logf;
     store_callback_t store;
+    int fast_epub_parse;
 } scan_ebook_ctx_t;
 
-void parse_ebook(scan_ebook_ctx_t *ctx, vfile_t *f, const char* mime_str,  document_t *doc);
-void parse_ebook_mem(scan_ebook_ctx_t *ctx, void *buf, size_t buf_len, const char *mime_str, document_t *doc, int tn_only);
+void parse_ebook(scan_ebook_ctx_t *ctx, vfile_t *f, const char *mime_str, document_t *doc);
+
+void
+parse_ebook_mem(scan_ebook_ctx_t *ctx, void *buf, size_t buf_len, const char *mime_str, document_t *doc, int tn_only);
+
+__always_inline
+static int is_epub(const char *mime_string) {
+    return strcmp(mime_string, "application/epub+zip") == 0;
+}
 
 #endif

libscan/font/font.c

@@ -144,27 +144,28 @@ void parse_font(scan_font_ctx_t *ctx, vfile_t *f, document_t *doc) {
     }
 
     size_t buf_len = 0;
-    void * buf = read_all(f, &buf_len);
+    void *buf = read_all(f, &buf_len);
     if (buf == NULL) {
         CTX_LOG_ERROR(f->filepath, "read_all() failed")
         return;
     }
 
     FT_Face face;
-    FT_Error err = FT_New_Memory_Face(ft_lib, (unsigned char *) buf, buf_len, 0, &face);
+    FT_Error err = FT_New_Memory_Face(ft_lib, (unsigned char *) buf, (int) buf_len, 0, &face);
     if (err != 0) {
-        CTX_LOG_ERRORF(doc->filepath, "(font.c) FT_New_Memory_Face() returned error code [%d] %s", err, FT_Error_String(err))
+        CTX_LOG_ERRORF(doc->filepath, "(font.c) FT_New_Memory_Face() returned error code [%d] %s", err,
+                       FT_Error_String(err))
         free(buf);
         return;
     }
 
-    char font_name[1024];
+    char font_name[4096];
 
-    if (face->style_name == NULL || *(face->style_name) == '?') {
+    if (face->style_name == NULL || (strcmp(face->style_name, "?") == 0)) {
         if (face->family_name == NULL) {
             strcpy(font_name, "(null)");
         } else {
-            strcpy(font_name, face->family_name);
+            strncpy(font_name, face->family_name, sizeof(font_name));
         }
     } else {
         snprintf(font_name, sizeof(font_name), "%s %s", face->family_name, face->style_name);
@@ -186,7 +187,8 @@ void parse_font(scan_font_ctx_t *ctx, vfile_t *f, document_t *doc) {
 
     err = FT_Set_Pixel_Sizes(face, 0, pixel);
     if (err != 0) {
-        CTX_LOG_WARNINGF(doc->filepath, "(font.c) FT_Set_Pixel_Sizes() returned error code [%d] %s", err, FT_Error_String(err))
+        CTX_LOG_WARNINGF(doc->filepath, "(font.c) FT_Set_Pixel_Sizes() returned error code [%d] %s", err,
+                         FT_Error_String(err))
         FT_Done_Face(face);
         free(buf);
         return;
@@ -207,7 +209,8 @@ void parse_font(scan_font_ctx_t *ctx, vfile_t *f, document_t *doc) {
             c = c >= 'a' && c <= 'z' ? c - 32 : c + 32;
             err = FT_Load_Char(face, c, FT_LOAD_NO_HINTING | FT_LOAD_RENDER);
             if (err != 0) {
-                CTX_LOG_WARNINGF(doc->filepath, "(font.c) FT_Load_Char() returned error code [%d] %s", err, FT_Error_String(err))
+                CTX_LOG_WARNINGF(doc->filepath, "(font.c) FT_Load_Char() returned error code [%d] %s", err,
+                                 FT_Error_String(err))
                 continue;
             }
         }

libscan/media/media.c

@@ -119,6 +119,10 @@ static void read_subtitles(scan_media_ctx_t *ctx, AVFormatContext *pFormatCtx, i
             for (int i = 0; i < subtitle.num_rects; i++) {
                 const char *text = subtitle.rects[i]->ass;
 
+                if (text == NULL) {
+                    continue;
+                }
+
                 char *idx = strstr(text, "\\N");
                 if (idx != NULL && strlen(idx + 2) > 1) {
                     text_buffer_append_string0(&tex, idx + 2);
@@ -127,12 +131,15 @@ static void read_subtitles(scan_media_ctx_t *ctx, AVFormatContext *pFormatCtx, i
             }
             avsubtitle_free(&subtitle);
         }
+
+        av_packet_unref(&packet);
     }
 
     text_buffer_terminate_string(&tex);
 
     APPEND_STR_META(doc, MetaContent, tex.dyn_buffer.buf)
     text_buffer_destroy(&tex);
+    avcodec_free_context(&decoder);
 }
 
 __always_inline
@@ -284,26 +291,34 @@ append_video_meta(scan_media_ctx_t *ctx, AVFormatContext *pFormatCtx, AVFrame *f
 
             if (strcmp(key, "artist") == 0) {
                 append_tag_meta_if_not_exists(ctx, doc, tag, MetaArtist);
-            } else if (strcmp(tag->key, "ImageDescription") == 0) {
+            } else if (strcmp(key, "imagedescription") == 0) {
                 APPEND_TAG_META(MetaContent)
-            } else if (strcmp(tag->key, "Make") == 0) {
+            } else if (strcmp(key, "make") == 0) {
                 APPEND_TAG_META(MetaExifMake)
-            } else if (strcmp(tag->key, "Model") == 0) {
+            } else if (strcmp(key, "model") == 0) {
                 APPEND_TAG_META(MetaExifModel)
-            } else if (strcmp(tag->key, "Software") == 0) {
+            } else if (strcmp(key, "software") == 0) {
                 APPEND_TAG_META(MetaExifSoftware)
-            } else if (strcmp(tag->key, "FNumber") == 0) {
+            } else if (strcmp(key, "fnumber") == 0) {
                 APPEND_TAG_META(MetaExifFNumber)
-            } else if (strcmp(tag->key, "FocalLength") == 0) {
+            } else if (strcmp(key, "focallength") == 0) {
                 APPEND_TAG_META(MetaExifFocalLength)
-            } else if (strcmp(tag->key, "UserComment") == 0) {
+            } else if (strcmp(key, "usercomment") == 0) {
                 APPEND_TAG_META(MetaExifUserComment)
-            } else if (strcmp(tag->key, "ISOSpeedRatings") == 0) {
+            } else if (strcmp(key, "isospeedratings") == 0) {
                 APPEND_TAG_META(MetaExifIsoSpeedRatings)
-            } else if (strcmp(tag->key, "ExposureTime") == 0) {
+            } else if (strcmp(key, "exposuretime") == 0) {
                 APPEND_TAG_META(MetaExifExposureTime)
-            } else if (strcmp(tag->key, "DateTime") == 0) {
+            } else if (strcmp(key, "datetime") == 0) {
                 APPEND_TAG_META(MetaExifDateTime)
+            } else if (strcmp(key, "gpslatitude") == 0) {
+                APPEND_TAG_META(MetaExifGpsLatitudeDMS)
+            } else if (strcmp(key, "gpslatituderef") == 0) {
+                APPEND_TAG_META(MetaExifGpsLatitudeRef)
+            } else if (strcmp(key, "gpslongitude") == 0) {
+                APPEND_TAG_META(MetaExifGpsLongitudeDMS)
+            } else if (strcmp(key, "gpslongituderef") == 0) {
+                APPEND_TAG_META(MetaExifGpsLongitudeRef)
             }
         }
     }
@@ -328,7 +343,6 @@ void parse_media_format_ctx(scan_media_ctx_t *ctx, AVFormatContext *pFormatCtx,
                     APPEND_STR_META(doc, MetaMediaAudioCodec, desc->name)
                 }
 
-                append_audio_meta(pFormatCtx, doc);
                 audio_stream = i;
             }
         } else if (stream->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
@@ -366,6 +380,10 @@ void parse_media_format_ctx(scan_media_ctx_t *ctx, AVFormatContext *pFormatCtx,
         }
     }
 
+    if (audio_stream != -1) {
+        append_audio_meta(pFormatCtx, doc);
+    }
+
     if (video_stream != -1 && ctx->tn_size > 0) {
         AVStream *stream = pFormatCtx->streams[video_stream];
 

libscan/media/media.h

@@ -18,12 +18,13 @@ typedef struct {
     int tn_size;
     float tn_qscale;
     long max_media_buffer;
+    int read_subtitles;
 } scan_media_ctx_t;
 
 __always_inline
 static AVCodecContext *alloc_jpeg_encoder(int w, int h, float qscale) {
 
-    AVCodec *jpeg_codec = avcodec_find_encoder(AV_CODEC_ID_MJPEG);
+    const AVCodec *jpeg_codec = avcodec_find_encoder(AV_CODEC_ID_MJPEG);
     AVCodecContext *jpeg = avcodec_alloc_context3(jpeg_codec);
     jpeg->width = w;
     jpeg->height = h;
@@ -43,8 +44,9 @@ static AVCodecContext *alloc_jpeg_encoder(int w, int h, float qscale) {
 
 
 void parse_media(scan_media_ctx_t *ctx, vfile_t *f, document_t *doc);
+
 void init_media();
 
-int store_image_thumbnail(scan_media_ctx_t *ctx, void* buf, size_t buf_len, document_t *doc, const char *url);
+int store_image_thumbnail(scan_media_ctx_t *ctx, void *buf, size_t buf_len, document_t *doc, const char *url);
 
 #endif

libscan/ooxml/ooxml.c

@@ -47,7 +47,7 @@ int extract_text(scan_ooxml_ctx_t *ctx, xmlDoc *xml, xmlNode *node, text_buffer_
     }
 
     for (xmlNode *child = node; child; child = child->next) {
-        if (*child->name == 't' && *(child->name + 1) == '\0') {
+        if (child->name != NULL && *child->name == 't' && *(child->name + 1) == '\0') {
             xmlChar *text = xmlNodeListGetString(xml, child->xmlChildrenNode, 1);
 
             if (text) {

libscan/raw/raw.c

@@ -8,7 +8,7 @@
 #define MIN_SIZE 32
 
 int store_thumbnail_jpeg(scan_raw_ctx_t *ctx, libraw_processed_image_t *img, document_t *doc) {
-    return store_image_thumbnail((scan_media_ctx_t*)ctx, img->data, img->data_size, doc, "x.jpeg");
+    return store_image_thumbnail((scan_media_ctx_t *) ctx, img->data, img->data_size, doc, "x.jpeg");
 }
 
 int store_thumbnail_rgb24(scan_raw_ctx_t *ctx, libraw_processed_image_t *img, document_t *doc) {
@@ -36,7 +36,7 @@ int store_thumbnail_rgb24(scan_raw_ctx_t *ctx, libraw_processed_image_t *img, do
 
     AVFrame *scaled_frame = av_frame_alloc();
 
-    struct SwsContext *sws_ctx= sws_getContext(
+    struct SwsContext *sws_ctx = sws_getContext(
             img->width, img->height, AV_PIX_FMT_RGB24,
             dstW, dstH, AV_PIX_FMT_YUVJ420P,
             SIST_SWS_ALGO, 0, 0, 0
@@ -80,6 +80,8 @@ int store_thumbnail_rgb24(scan_raw_ctx_t *ctx, libraw_processed_image_t *img, do
     return TRUE;
 }
 
+#define DMS_REF(ref) (((ref) == 'S' || (ref) == 'W') ? -1 : 1)
+
 void parse_raw(scan_raw_ctx_t *ctx, vfile_t *f, document_t *doc) {
     libraw_data_t *libraw_lib = libraw_init(0);
 
@@ -99,6 +101,7 @@ void parse_raw(scan_raw_ctx_t *ctx, vfile_t *f, document_t *doc) {
     if (ret != 0) {
         CTX_LOG_ERROR(f->filepath, "Could not open raw file")
         free(buf);
+        libraw_close(libraw_lib);
         return;
     }
 
@@ -134,10 +137,24 @@ void parse_raw(scan_raw_ctx_t *ctx, vfile_t *f, document_t *doc) {
     snprintf(tmp, sizeof(tmp), "%.1f", libraw_lib->other.aperture);
     APPEND_STR_META(doc, MetaExifFNumber, tmp)
 
-    int denominator = (int)roundf(1 / libraw_lib->other.shutter);
+    int denominator = (int) roundf(1 / libraw_lib->other.shutter);
     snprintf(tmp, sizeof(tmp), "1/%d", denominator);
     APPEND_STR_META(doc, MetaExifExposureTime, tmp)
 
+    libraw_gps_info_t gps = libraw_lib->other.parsed_gps;
+    double gps_longitude_dec =
+            (gps.longtitude[0] + gps.longtitude[1] / 60 + gps.longtitude[2] / 3600) * DMS_REF(gps.longref);
+    snprintf(tmp, sizeof(tmp), "%.15f", gps_longitude_dec);
+    if (gps_longitude_dec != 0.0) {
+        APPEND_STR_META(doc, MetaExifGpsLongitudeDec, tmp)
+    }
+
+    double gps_latitude_dec = (gps.latitude[0] + gps.latitude[1] / 60 + gps.latitude[2] / 3600) * DMS_REF(gps.latref);
+    snprintf(tmp, sizeof(tmp), "%.15f", gps_latitude_dec);
+    if (gps_latitude_dec != 0.0) {
+        APPEND_STR_META(doc, MetaExifGpsLatitudeDec, tmp)
+    }
+
     APPEND_STR_META(doc, MetaMediaVideoCodec, "raw")
 
     if (ctx->tn_size <= 0) {

libscan/scan.h

@@ -13,9 +13,9 @@
 
 #define SIST_SWS_ALGO SWS_LANCZOS
 
-#define META_INT_MASK 0x80
-#define META_STR_MASK 0x40
-#define META_LONG_MASK 0x20
+#define META_INT_MASK 0x8000
+#define META_STR_MASK 0x4000
+#define META_LONG_MASK 0x2000
 
 #define UNUSED(x) __attribute__((__unused__))  x
 
@@ -85,6 +85,12 @@ enum metakey {
     MetaModifiedBy = META_STR(25),
     MetaThumbnail = META_STR(26),
     MetaPages = META_INT(27),
+    MetaExifGpsLongitudeDMS = META_STR(28),
+    MetaExifGpsLongitudeRef = META_STR(29),
+    MetaExifGpsLatitudeDMS = META_STR(30),
+    MetaExifGpsLatitudeRef = META_STR(31),
+    MetaExifGpsLatitudeDec = META_STR(32),
+    MetaExifGpsLongitudeDec = META_STR(33),
 };
 
 typedef struct meta_line {

libscan/util.h

@@ -133,11 +133,11 @@ static void dyn_buffer_write_int(dyn_buffer_t *buf, int d) {
     buf->cur += sizeof(int);
 }
 
-static void dyn_buffer_write_short(dyn_buffer_t *buf, short s) {
+static void dyn_buffer_write_short(dyn_buffer_t *buf, uint16_t s) {
     grow_buffer_small(buf);
 
-    *(short *) (buf->buf + buf->cur) = s;
-    buf->cur += sizeof(short);
+    *(uint16_t *) (buf->buf + buf->cur) = s;
+    buf->cur += sizeof(uint16_t);
 }
 
 static void dyn_buffer_write_long(dyn_buffer_t *buf, unsigned long l) {

test/main.cpp

@@ -21,6 +21,7 @@ static scan_text_ctx_t text_500_ctx;
 
 static scan_ebook_ctx_t ebook_ctx;
 static scan_ebook_ctx_t ebook_500_ctx;
+static scan_ebook_ctx_t ebook_fast_ctx;
 
 static scan_comic_ctx_t comic_ctx;
 
@@ -250,6 +251,28 @@ TEST(Ebook, Epub1) {
     cleanup(&doc, &f);
 }
 
+TEST(Ebook, EpubFastMupdfError) {
+    vfile_t f;
+    document_t doc;
+    load_doc_file("libscan-test-files/test_files/ebook/mupdf-issue-129.epub", &f, &doc);
+
+    parse_ebook(&ebook_fast_ctx, &f, "application/epub+zip", &doc);
+
+    ASSERT_NEAR(strlen(get_meta(&doc, MetaContent)->str_val), 500, 4);
+    cleanup(&doc, &f);
+}
+
+TEST(Ebook, Epub1Fast) {
+    vfile_t f;
+    document_t doc;
+    load_doc_file("libscan-test-files/test_files/ebook/epub1.epub", &f, &doc);
+
+    parse_ebook(&ebook_fast_ctx, &f, "application/epub+zip", &doc);
+
+    ASSERT_NEAR(strlen(get_meta(&doc, MetaContent)->str_val), 500, 4);
+    cleanup(&doc, &f);
+}
+
 TEST(Ebook, EpubBlankFirstPage) {
     vfile_t f;
     document_t doc;
@@ -291,6 +314,19 @@ TEST(Comic, ComicCbr) {
     cleanup(&doc, &f);
 }
 
+TEST(Comic, ComicIssue160) {
+    vfile_t f;
+    document_t doc;
+    load_doc_file("libscan-test-files/test_files/ebook/comic-segfault-issue-160.cbr", &f, &doc);
+
+    int tn_size_saved = comic_ctx.tn_size;
+    comic_ctx.tn_size = 0;
+    parse_comic(&comic_ctx, &f, &doc);
+    comic_ctx.tn_size = tn_size_saved;
+
+    cleanup(&doc, &f);
+}
+
 TEST(Comic, ComicCbrAsIs) {
     vfile_t f;
     document_t doc;
@@ -319,6 +355,22 @@ TEST(Comic, ComicCbrFilters) {
 
 /* Media (image) */
 
+TEST(MediaImage, ExifGps1) {
+    vfile_t f;
+    document_t doc;
+    load_doc_file("libscan-test-files/test_files/media/exif_GPS.jpg", &f, &doc);
+
+    parse_media(&media_ctx, &f, &doc);
+
+    ASSERT_STREQ(get_meta(&doc, MetaExifGpsLatitudeRef)->str_val, "N");
+    ASSERT_STREQ(get_meta(&doc, MetaExifGpsLatitudeDMS)->str_val, "48:1 , 56585399:1000000, 0:1");
+
+    ASSERT_STREQ(get_meta(&doc, MetaExifGpsLongitudeRef)->str_val, "E");
+    ASSERT_STREQ(get_meta(&doc, MetaExifGpsLongitudeDMS)->str_val, "9:1 , 28046900:1000000, 0:1");
+
+    cleanup(&doc, &f);
+}
+
 TEST(MediaImage, Exif1) {
     vfile_t f;
     document_t doc;
@@ -374,6 +426,36 @@ TEST(MediaImage, Mem2AsIs) {
     cleanup(&doc, &f);
 }
 
+TEST(MediaVideo, VidMkvSubDisabled) {
+    vfile_t f;
+    document_t doc;
+    load_doc_file("libscan-test-files/test_files/media/berd.mkv", &f, &doc);
+
+    size_t size_before = store_size;
+    parse_media(&media_ctx, &f, &doc);
+
+    ASSERT_NE(size_before, store_size);
+    ASSERT_EQ(get_meta(&doc, MetaContent), nullptr);
+
+    cleanup(&doc, &f);
+}
+
+TEST(MediaVideo, VidMkvSubEnabled) {
+    vfile_t f;
+    document_t doc;
+    load_doc_file("libscan-test-files/test_files/media/berd.mkv", &f, &doc);
+
+    size_t size_before = store_size;
+    media_ctx.read_subtitles = TRUE;
+    parse_media(&media_ctx, &f, &doc);
+    media_ctx.read_subtitles = FALSE;
+
+    ASSERT_NE(size_before, store_size);
+    ASSERT_NE(get_meta(&doc, MetaContent), nullptr);
+
+    cleanup(&doc, &f);
+}
+
 TEST(MediaVideo, Vid3Mp4) {
     vfile_t f;
     document_t doc;
@@ -636,6 +718,23 @@ TEST(RAW, Panasonic) {
     cleanup(&doc, &f);
 }
 
+TEST(RAW, ExifGps1) {
+    vfile_t f;
+    document_t doc;
+    load_doc_file("libscan-test-files/test_files/raw/exif_gps.DNG", &f, &doc);
+
+    size_t size_before = store_size;
+
+    parse_raw(&raw_ctx, &f, &doc);
+
+    ASSERT_NE(size_before, store_size);
+
+    ASSERT_STREQ(get_meta(&doc, MetaExifGpsLatitudeDec)->str_val, "48.943088531494141");
+    ASSERT_STREQ(get_meta(&doc, MetaExifGpsLongitudeDec)->str_val, "9.467448234558105");
+
+    cleanup(&doc, &f);
+}
+
 TEST(RAW, Nikon) {
     vfile_t f;
     document_t doc;
@@ -878,10 +977,14 @@ int main(int argc, char **argv) {
     ebook_ctx.tn_size = 500;
     ebook_ctx.log = noop_log;
     ebook_ctx.logf = noop_logf;
+    ebook_ctx.fast_epub_parse = 0;
 
     ebook_500_ctx = ebook_ctx;
     ebook_500_ctx.content_size = 500;
 
+    ebook_fast_ctx = ebook_500_ctx;
+    ebook_fast_ctx.fast_epub_parse = 1;
+
     comic_ctx.tn_qscale = 1.0;
     comic_ctx.tn_size = 500;
     comic_ctx.log = noop_log;