Subversion Repositories eduke32

Rev

Rev 6158 | Go to most recent revision | Blame | Compare with Previous | Last modification | View Log | RSS feed

/* Extended Module Player
 * Copyright (C) 1996-2016 Claudio Matsuoka and Hipolito Carraro Jr
 *
 * Permission is hereby granted, free of charge, to any person obtaining a
 * copy of this software and associated documentation files (the "Software"),
 * to deal in the Software without restriction, including without limitation
 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
 * and/or sell copies of the Software, and to permit persons to whom the
 * Software is furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 * THE SOFTWARE.
 */


#include <errno.h>
#include "common.h"


#define read_byte(x) do {               \
        (x) = fgetc(f);                 \
        if ((x) < 0)  goto error;       \
} while (0)


#define set_error(x) do {               \
        if (err != NULL) *err = (x);    \
} while (0)



#ifdef EDUKE32_DISABLED
uint8 read8(FILE *f, int *err)
{
        int a;

        read_byte(a);
        set_error(0);
        return a;

   error:
        set_error(ferror(f) ? errno : EOF);
        return 0xff;
}

int8 read8s(FILE *f, int *err)
{
        int a;

        read_byte(a);
        set_error(0);
        return (int8)a;

   error:
        set_error(ferror(f) ? errno : EOF);
        return 0;
}

uint16 read16l(FILE *f, int *err)
{
        int a, b;

        read_byte(a);
        read_byte(b);

        set_error(0);
        return ((uint16)b << 8) | a;

    error:
        set_error(ferror(f) ? errno : EOF);
        return 0xffff;
}

uint16 read16b(FILE *f, int *err)
{
        int a, b;

        read_byte(a);
        read_byte(b);

        set_error(0);
        return (a << 8) | b;

    error:
        set_error(ferror(f) ? errno : EOF);
        return 0xffff;
}

uint32 read24l(FILE *f, int *err)
{
        int a, b, c;

        read_byte(a);
        read_byte(b);
        read_byte(c);
       
        set_error(0);
        return (c << 16) | (b << 8) | a;

    error:
        set_error(ferror(f) ? errno : EOF);
        return 0xffffff;
}

uint32 read24b(FILE *f, int *err)
{
        int a, b, c;

        read_byte(a);
        read_byte(b);
        read_byte(c);
       
        set_error(0);
        return (a << 16) | (b << 8) | c;

    error:
        set_error(ferror(f) ? errno : EOF);
        return 0xffffff;
}

uint32 read32l(FILE *f, int *err)
{
        int a, b, c, d;

        read_byte(a);
        read_byte(b);
        read_byte(c);
        read_byte(d);

        set_error(0);
        return (d << 24) | (c << 16) | (b << 8) | a;

    error:
        set_error(ferror(f) ? errno : EOF);
        return 0xffffffff;
}

uint32 read32b(FILE *f, int *err)
{
        int a, b, c, d;

        read_byte(a);
        read_byte(b);
        read_byte(c);
        read_byte(d);

        set_error(0);
        return (a << 24) | (b << 16) | (c << 8) | d;

    error:
        set_error(ferror(f) ? errno : EOF);
        return 0xffffffff;
}
#endif

uint16 readmem16l(const uint8 *m)
{
        uint32 a, b;

        a = m[0];
        b = m[1];

        return (b << 8) | a;
}

uint16 readmem16b(const uint8 *m)
{
        uint32 a, b;

        a = m[0];
        b = m[1];

        return (a << 8) | b;
}

uint32 readmem24l(const uint8 *m)
{
        uint32 a, b, c;

        a = m[0];
        b = m[1];
        c = m[2];

        return (c << 16) | (b << 8) | a;
}

uint32 readmem24b(const uint8 *m)
{
        uint32 a, b, c;

        a = m[0];
        b = m[1];
        c = m[2];

        return (a << 16) | (b << 8) | c;
}

uint32 readmem32l(const uint8 *m)
{
        uint32 a, b, c, d;

        a = m[0];
        b = m[1];
        c = m[2];
        d = m[3];

        return (d << 24) | (c << 16) | (b << 8) | a;
}

uint32 readmem32b(const uint8 *m)
{
        uint32 a, b, c, d;

        a = m[0];
        b = m[1];
        c = m[2];
        d = m[3];

        return (a << 24) | (b << 16) | (c << 8) | d;
}

#ifndef LIBXMP_CORE_PLAYER

void write16l(FILE *f, uint16 w)
{
        write8(f, w & 0x00ff);
        write8(f, (w & 0xff00) >> 8);
}

void write16b(FILE *f, uint16 w)
{
        write8(f, (w & 0xff00) >> 8);
        write8(f, w & 0x00ff);
}

void write32l(FILE *f, uint32 w)
{
        write8(f, w & 0x000000ff);
        write8(f, (w & 0x0000ff00) >> 8);
        write8(f, (w & 0x00ff0000) >> 16);
        write8(f, (w & 0xff000000) >> 24);
}

void write32b(FILE *f, uint32 w)
{
        write8(f, (w & 0xff000000) >> 24);
        write8(f, (w & 0x00ff0000) >> 16);
        write8(f, (w & 0x0000ff00) >> 8);
        write8(f, w & 0x000000ff);
}

int move_data(FILE *out, FILE *in, int len)
{
        uint8 buf[1024];
        int l;

        do {
                l = fread(buf, 1, len > 1024 ? 1024 : len, in);
                fwrite(buf, 1, l, out);
                len -= l;
        } while (l > 0 && len > 0);

        return 0;
}

#endif