store.h

Go to the documentation of this file.

// Copyright (C) 2004-2021 Artifex Software, Inc.
//
// This file is part of MuPDF.
//
// MuPDF is free software: you can redistribute it and/or modify it under the
// terms of the GNU Affero General Public License as published by the Free
// Software Foundation, either version 3 of the License, or (at your option)
// any later version.
//
// MuPDF is distributed in the hope that it will be useful, but WITHOUT ANY
// WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
// FOR A PARTICULAR PURPOSE. See the GNU Affero General Public License for more
// details.
//
// You should have received a copy of the GNU Affero General Public License
// along with MuPDF. If not, see <https://www.gnu.org/licenses/agpl-3.0.en.html>
//
// Alternative licensing terms are available from the licensor.
// For commercial licensing, see <https://www.artifex.com/> or contact
// Artifex Software, Inc., 39 Mesa Street, Suite 108A, San Francisco,
// CA 94129, USA, for further information.
 
#ifndef MUPDF_FITZ_STORE_H
#define MUPDF_FITZ_STORE_H
 
#include "mupdf/fitz/system.h"
#include "mupdf/fitz/context.h"
#include "mupdf/fitz/output.h"
#include "mupdf/fitz/log.h"
#include "mupdf/fitz/types.h"

typedef struct fz_storable fz_storable;

typedef void (fz_store_drop_fn)(fz_context *, fz_storable *);

typedef int (fz_store_droppable_fn)(fz_context *, fz_storable *);

struct fz_storable {
    int refs;
    fz_store_drop_fn *drop;
    fz_store_droppable_fn *droppable;
};

typedef struct
{
    fz_storable storable;
    short store_key_refs;
} fz_key_storable;

#define FZ_INIT_STORABLE(S_,RC,DROP) \
    do { fz_storable *S = &(S_)->storable; S->refs = (RC); \
    S->drop = (DROP); S->droppable = NULL; \
    } while (0)
 
#define FZ_INIT_AWKWARD_STORABLE(S_,RC,DROP,DROPPABLE) \
    do { fz_storable *S = &(S_)->storable; S->refs = (RC); \
    S->drop = (DROP); S->droppable = (DROPPABLE); \
    } while (0)

#define FZ_INIT_KEY_STORABLE(KS_,RC,DROP) \
    do { fz_key_storable *KS = &(KS_)->key_storable; KS->store_key_refs = 0;\
    FZ_INIT_STORABLE(KS,RC,DROP); \
    } while (0)

void *fz_keep_storable(fz_context *, const fz_storable *);

void fz_drop_storable(fz_context *, const fz_storable *);

void *fz_keep_key_storable(fz_context *, const fz_key_storable *);

void fz_drop_key_storable(fz_context *, const fz_key_storable *);

void *fz_keep_key_storable_key(fz_context *, const fz_key_storable *);

void fz_drop_key_storable_key(fz_context *, const fz_key_storable *);

typedef struct
{
    fz_store_drop_fn *drop;
    union
    {
        struct
        {
            const void *ptr;
            int i;
        } pi; /* 8 or 12 bytes */
        struct
        {
            const void *ptr;
            int i;
            fz_irect r;
        } pir; /* 24 or 28 bytes */
        struct
        {
            int id;
            char has_shape;
            char has_group_alpha;
            float m[4];
            void *ptr;
            int doc_id;
        } im; /* 32 or 36 bytes */
        struct
        {
            unsigned char src_md5[16];
            unsigned char dst_md5[16];
            unsigned int ri:2;
            unsigned int bp:1;
            unsigned int format:1;
            unsigned int proof:1;
            unsigned int src_extras:5;
            unsigned int dst_extras:5;
            unsigned int copy_spots:1;
            unsigned int bgr:1;
        } link; /* 36 bytes */
    } u;
    /* 0 or 4 bytes padding */
} fz_store_hash; /* 40 or 48 bytes */

typedef struct
{
    const char *name;
    int (*make_hash_key)(fz_context *ctx, fz_store_hash *hash, void *key);
    void *(*keep_key)(fz_context *ctx, void *key);
    void (*drop_key)(fz_context *ctx, void *key);
    int (*cmp_key)(fz_context *ctx, void *a, void *b);
    void (*format_key)(fz_context *ctx, char *buf, size_t size, void *key);
    int (*needs_reap)(fz_context *ctx, void *key);
} fz_store_type;

void fz_new_store_context(fz_context *ctx, size_t max);

fz_store *fz_keep_store_context(fz_context *ctx);

void fz_drop_store_context(fz_context *ctx);

void *fz_store_item(fz_context *ctx, void *key, void *val, size_t itemsize, const fz_store_type *type);

void *fz_find_item(fz_context *ctx, fz_store_drop_fn *drop, void *key, const fz_store_type *type);

void fz_remove_item(fz_context *ctx, fz_store_drop_fn *drop, void *key, const fz_store_type *type);

void fz_empty_store(fz_context *ctx);

int fz_store_scavenge(fz_context *ctx, size_t size, int *phase);

int fz_store_scavenge_external(fz_context *ctx, size_t size, int *phase);

int fz_shrink_store(fz_context *ctx, unsigned int percent);

typedef int (fz_store_filter_fn)(fz_context *ctx, void *arg, void *key);

void fz_filter_store(fz_context *ctx, fz_store_filter_fn *fn, void *arg, const fz_store_type *type);

void fz_drop_drawn_tiles_for_document(fz_context *ctx, fz_document *doc);

void fz_debug_store(fz_context *ctx, fz_output *out);

void fz_defer_reap_start(fz_context *ctx);

void fz_defer_reap_end(fz_context *ctx);
 
#ifdef ENABLE_STORE_LOGGING
 
void fz_log_dump_store(fz_context *ctx, const char *fmt, ...);
 
#define FZ_LOG_STORE(CTX, ...) fz_log_module(CTX, "STORE", __VA_ARGS__)
#define FZ_LOG_DUMP_STORE(...) fz_log_dump_store(__VA_ARGS__)
 
#else
 
#define FZ_LOG_STORE(...) do {} while (0)
#define FZ_LOG_DUMP_STORE(...) do {} while (0)
 
#endif
 
#endif