output.h

Go to the documentation of this file.

// Copyright (C) 2004-2025 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_OUTPUT_H
#define MUPDF_FITZ_OUTPUT_H
 
#include "mupdf/fitz/system.h"
#include "mupdf/fitz/context.h"
#include "mupdf/fitz/buffer.h"
#include "mupdf/fitz/string-util.h"
#include "mupdf/fitz/stream.h"


typedef void (fz_output_write_fn)(fz_context *ctx, void *state, const void *data, size_t n);

typedef void (fz_output_seek_fn)(fz_context *ctx, void *state, int64_t offset, int whence);

typedef int64_t (fz_output_tell_fn)(fz_context *ctx, void *state);

typedef void (fz_output_close_fn)(fz_context *ctx, void *state);

typedef void (fz_output_reset_fn)(fz_context *ctx, void *state);

typedef void (fz_output_drop_fn)(fz_context *ctx, void *state);

typedef fz_stream *(fz_stream_from_output_fn)(fz_context *ctx, void *state);

typedef void (fz_truncate_fn)(fz_context *ctx, void *state);
 
struct fz_output
{
    void *state;
    fz_output_write_fn *write;
    fz_output_seek_fn *seek;
    fz_output_tell_fn *tell;
    fz_output_close_fn *close;
    fz_output_drop_fn *drop;
    fz_output_reset_fn *reset;
    fz_stream_from_output_fn *as_stream;
    fz_truncate_fn *truncate;
    int closed;
    char *bp, *wp, *ep;
    /* If buffered is non-zero, then we have that many
     * bits (1-7) waiting to be written in bits. */
    int buffered;
    int bits;
};

fz_output *fz_new_output(fz_context *ctx, int bufsiz, void *state, fz_output_write_fn *write, fz_output_close_fn *close, fz_output_drop_fn *drop);

fz_output *fz_new_output_with_path(fz_context *, const char *filename, int append);

fz_output *fz_new_output_with_file_ptr(fz_context *ctx, FILE *file);

fz_output *fz_new_output_with_buffer(fz_context *ctx, fz_buffer *buf);

fz_output *fz_stdout(fz_context *ctx);

fz_output *fz_stderr(fz_context *ctx);
 
#ifdef _WIN32
fz_output *fz_stdods(fz_context *ctx);
#endif

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

fz_output *fz_stddbg(fz_context *ctx);

void fz_write_printf(fz_context *ctx, fz_output *out, const char *fmt, ...);

void fz_write_vprintf(fz_context *ctx, fz_output *out, const char *fmt, va_list ap);

void fz_seek_output(fz_context *ctx, fz_output *out, int64_t off, int whence);

int64_t fz_tell_output(fz_context *ctx, fz_output *out);

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

void fz_close_output(fz_context *, fz_output *);

void fz_reset_output(fz_context *, fz_output *);

void fz_drop_output(fz_context *, fz_output *);

int fz_output_supports_stream(fz_context *ctx, fz_output *out);

fz_stream *fz_stream_from_output(fz_context *, fz_output *);

void fz_truncate_output(fz_context *, fz_output *);

void fz_write_data(fz_context *ctx, fz_output *out, const void *data, size_t size);
void fz_write_buffer(fz_context *ctx, fz_output *out, fz_buffer *data);

void fz_write_string(fz_context *ctx, fz_output *out, const char *s);

void fz_write_int32_be(fz_context *ctx, fz_output *out, int x);
void fz_write_int32_le(fz_context *ctx, fz_output *out, int x);
void fz_write_uint32_be(fz_context *ctx, fz_output *out, unsigned int x);
void fz_write_uint32_le(fz_context *ctx, fz_output *out, unsigned int x);
void fz_write_int16_be(fz_context *ctx, fz_output *out, int x);
void fz_write_int16_le(fz_context *ctx, fz_output *out, int x);
void fz_write_uint16_be(fz_context *ctx, fz_output *out, unsigned int x);
void fz_write_uint16_le(fz_context *ctx, fz_output *out, unsigned int x);
void fz_write_char(fz_context *ctx, fz_output *out, char x);
void fz_write_byte(fz_context *ctx, fz_output *out, unsigned char x);
void fz_write_float_be(fz_context *ctx, fz_output *out, float f);
void fz_write_float_le(fz_context *ctx, fz_output *out, float f);

void fz_write_rune(fz_context *ctx, fz_output *out, int rune);

void fz_write_base64(fz_context *ctx, fz_output *out, const unsigned char *data, size_t size, int newline);

void fz_write_base64_buffer(fz_context *ctx, fz_output *out, fz_buffer *data, int newline);

void fz_write_bits(fz_context *ctx, fz_output *out, unsigned int data, int num_bits);

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

void fz_write_stream(fz_context *ctx, fz_output *out, fz_stream *in);

void fz_format_string(fz_context *ctx, void *user, void (*emit)(fz_context *ctx, void *user, int c), const char *fmt, va_list args);

size_t fz_vsnprintf(char *buffer, size_t space, const char *fmt, va_list args);

size_t fz_snprintf(char *buffer, size_t space, const char *fmt, ...);

char *fz_asprintf(fz_context *ctx, const char *fmt, ...);

void fz_save_buffer(fz_context *ctx, fz_buffer *buf, const char *filename);

 
fz_output *fz_new_asciihex_output(fz_context *ctx, fz_output *chain);
fz_output *fz_new_ascii85_output(fz_context *ctx, fz_output *chain);
fz_output *fz_new_rle_output(fz_context *ctx, fz_output *chain);
fz_output *fz_new_arc4_output(fz_context *ctx, fz_output *chain, unsigned char *key, size_t keylen);
fz_output *fz_new_deflate_output(fz_context *ctx, fz_output *chain, int effort, int raw);
 
/*
    Return whether a char is representable in an XML string.
*/
int fz_is_valid_xml_char(int c);
 
/*
    Return a char mapped into the ranges representable by XML.
    Any unrepresentable char becomes the unicode replacement
    char (0xFFFD).
*/
int
fz_range_limit_xml_char(int c);
 
/*
    Return true if all the utf-8 encoded characters in the
    string are representable within XML.
*/
int fz_is_valid_xml_string(const char *s);
 
#endif