stream.h

Go to the documentation of this file.

// Copyright (C) 2004-2026 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_STREAM_H
#define MUPDF_FITZ_STREAM_H
 
#include "mupdf/fitz/system.h"
#include "mupdf/fitz/context.h"
#include "mupdf/fitz/buffer.h"

int fz_file_exists(fz_context *ctx, const char *path);

typedef struct fz_stream fz_stream;

fz_stream *fz_open_file(fz_context *ctx, const char *filename);

fz_stream *fz_open_file_autodelete(fz_context *ctx, const char *filename);

fz_stream *fz_try_open_file(fz_context *ctx, const char *name);
 
#ifdef _WIN32
fz_stream *fz_open_file_w(fz_context *ctx, const wchar_t *filename);
#endif /* _WIN32 */

const char *fz_stream_filename(fz_context *ctx, fz_stream *stm);

fz_stream *fz_open_memory(fz_context *ctx, const unsigned char *data, size_t len);

fz_stream *fz_open_buffer(fz_context *ctx, fz_buffer *buf);

fz_stream *fz_open_leecher(fz_context *ctx, fz_stream *chain, fz_buffer *buf);

fz_stream *fz_keep_stream(fz_context *ctx, fz_stream *stm);

void fz_drop_stream(fz_context *ctx, fz_stream *stm);

int64_t fz_tell(fz_context *ctx, fz_stream *stm);

void fz_seek(fz_context *ctx, fz_stream *stm, int64_t offset, int whence);

size_t fz_read(fz_context *ctx, fz_stream *stm, unsigned char *data, size_t len);

size_t fz_skip(fz_context *ctx, fz_stream *stm, size_t len);

fz_buffer *fz_read_all(fz_context *ctx, fz_stream *stm, size_t initial);

fz_buffer *fz_read_file(fz_context *ctx, const char *filename);

fz_buffer *fz_try_read_file(fz_context *ctx, const char *filename);

char *fz_read_text_file(fz_context *ctx, const char *filename);

uint16_t fz_read_uint16(fz_context *ctx, fz_stream *stm);
uint32_t fz_read_uint24(fz_context *ctx, fz_stream *stm);
uint32_t fz_read_uint32(fz_context *ctx, fz_stream *stm);
uint64_t fz_read_uint64(fz_context *ctx, fz_stream *stm);
 
uint16_t fz_read_uint16_le(fz_context *ctx, fz_stream *stm);
uint32_t fz_read_uint24_le(fz_context *ctx, fz_stream *stm);
uint32_t fz_read_uint32_le(fz_context *ctx, fz_stream *stm);
uint64_t fz_read_uint64_le(fz_context *ctx, fz_stream *stm);
 
int16_t fz_read_int16(fz_context *ctx, fz_stream *stm);
int32_t fz_read_int32(fz_context *ctx, fz_stream *stm);
int64_t fz_read_int64(fz_context *ctx, fz_stream *stm);
 
int16_t fz_read_int16_le(fz_context *ctx, fz_stream *stm);
int32_t fz_read_int32_le(fz_context *ctx, fz_stream *stm);
int64_t fz_read_int64_le(fz_context *ctx, fz_stream *stm);
 
float fz_read_float_le(fz_context *ctx, fz_stream *stm);
float fz_read_float(fz_context *ctx, fz_stream *stm);

void fz_read_string(fz_context *ctx, fz_stream *stm, char *buffer, int len);

int fz_read_rune(fz_context *ctx, fz_stream *in);

int fz_read_utf16_le(fz_context *ctx, fz_stream *stm);
int fz_read_utf16_be(fz_context *ctx, fz_stream *stm);

typedef int (fz_stream_next_fn)(fz_context *ctx, fz_stream *stm, size_t max);

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

typedef void (fz_stream_seek_fn)(fz_context *ctx, fz_stream *stm, int64_t offset, int whence);
 
struct fz_stream
{
    int refs;
    int error;
    int eof;
    int progressive;
    int64_t pos;
    int avail;
    int bits;
    unsigned char *rp, *wp;
    void *state;
    fz_stream_next_fn *next;
    fz_stream_drop_fn *drop;
    fz_stream_seek_fn *seek;
};

fz_stream *fz_new_stream(fz_context *ctx, void *state, fz_stream_next_fn *next, fz_stream_drop_fn *drop);

fz_buffer *fz_read_best(fz_context *ctx, fz_stream *stm, size_t initial, int *truncated, size_t worst_case);

char *fz_read_line(fz_context *ctx, fz_stream *stm, char *buf, size_t max);

int fz_skip_string(fz_context *ctx, fz_stream *stm, const char *str);

void fz_skip_space(fz_context *ctx, fz_stream *stm);

static inline size_t fz_available(fz_context *ctx, fz_stream *stm, size_t max)
{
    size_t len = stm->wp - stm->rp;
    int c = EOF;
 
    if (len)
        return len;
    if (stm->eof)
        return 0;
 
    fz_try(ctx)
        c = stm->next(ctx, stm, max);
    fz_catch(ctx)
    {
        fz_rethrow_if(ctx, FZ_ERROR_TRYLATER);
        fz_report_error(ctx);
        fz_warn(ctx, "read error; treating as end of file");
        stm->error = 1;
        c = EOF;
    }
    if (c == EOF)
    {
        stm->eof = 1;
        return 0;
    }
    stm->rp--;
    return stm->wp - stm->rp;
}

static inline int fz_read_byte(fz_context *ctx, fz_stream *stm)
{
    int c = EOF;
 
    if (stm->rp != stm->wp)
        return *stm->rp++;
    if (stm->eof)
        return EOF;
    fz_try(ctx)
        c = stm->next(ctx, stm, 1);
    fz_catch(ctx)
    {
        fz_rethrow_if(ctx, FZ_ERROR_TRYLATER);
        fz_report_error(ctx);
        fz_warn(ctx, "read error; treating as end of file");
        stm->error = 1;
        c = EOF;
    }
    if (c == EOF)
        stm->eof = 1;
    return c;
}

static inline int fz_peek_byte(fz_context *ctx, fz_stream *stm)
{
    int c = EOF;
 
    if (stm->rp != stm->wp)
        return *stm->rp;
    if (stm->eof)
        return EOF;
 
    fz_try(ctx)
    {
        c = stm->next(ctx, stm, 1);
        if (c != EOF)
            stm->rp--;
    }
    fz_catch(ctx)
    {
        fz_rethrow_if(ctx, FZ_ERROR_TRYLATER);
        fz_report_error(ctx);
        fz_warn(ctx, "read error; treating as end of file");
        stm->error = 1;
        c = EOF;
    }
    if (c == EOF)
        stm->eof = 1;
    return c;
}

static inline void fz_unread_byte(fz_context *ctx FZ_UNUSED, fz_stream *stm)
{
    stm->rp--;
}

static inline int fz_is_eof(fz_context *ctx, fz_stream *stm)
{
    if (stm->rp == stm->wp)
    {
        if (stm->eof)
            return 1;
        return fz_peek_byte(ctx, stm) == EOF;
    }
    return 0;
}

static inline unsigned int fz_read_bits(fz_context *ctx, fz_stream *stm, int n)
{
    unsigned int x;
 
    if (n <= stm->avail)
    {
        stm->avail -= n;
        x = (stm->bits >> stm->avail) & ((1 << n) - 1);
    }
    else
    {
        x = stm->bits & ((1 << stm->avail) - 1);
        n -= stm->avail;
        stm->avail = 0;
 
        while (n > 8)
        {
            x = (x << 8) | fz_read_byte(ctx, stm);
            n -= 8;
        }
 
        if (n > 0)
        {
            stm->bits = fz_read_byte(ctx, stm);
            stm->avail = 8 - n;
            x = (x << n) | (stm->bits >> stm->avail);
        }
    }
 
    return x;
}

static inline unsigned int fz_read_rbits(fz_context *ctx, fz_stream *stm, int n)
{
    int x;
 
    if (n <= stm->avail)
    {
        x = stm->bits & ((1 << n) - 1);
        stm->avail -= n;
        stm->bits = stm->bits >> n;
    }
    else
    {
        unsigned int used = 0;
 
        x = stm->bits & ((1 << stm->avail) - 1);
        n -= stm->avail;
        used = stm->avail;
        stm->avail = 0;
 
        while (n > 8)
        {
            x = (fz_read_byte(ctx, stm) << used) | x;
            n -= 8;
            used += 8;
        }
 
        if (n > 0)
        {
            stm->bits = fz_read_byte(ctx, stm);
            x = ((stm->bits & ((1 << n) - 1)) << used) | x;
            stm->avail = 8 - n;
            stm->bits = stm->bits >> n;
        }
    }
 
    return x;
}

static inline void fz_sync_bits(fz_context *ctx FZ_UNUSED, fz_stream *stm)
{
    stm->avail = 0;
}

static inline int fz_is_eof_bits(fz_context *ctx, fz_stream *stm)
{
    return fz_is_eof(ctx, stm) && (stm->avail == 0 || stm->bits == EOF);
}
 
/* Implementation details: subject to change. */

fz_stream *fz_open_file_ptr_no_close(fz_context *ctx, FILE *file);
 
#endif