spliter_reader.c.svn-base

A Flash Player with ActionScript support. Write in C and C++. It have two part, one is Player and an

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <memory.h>
#include <fcntl.h>
#include <zlib.h>
#include <glib.h>
#include "config.h"
#if WITH_DMALLOC
#include <dmalloc.h>
#endif
#define ZLIB_BUFFER_SIZE 16384
#include "spliter_reader.h"

/* ---------------------------- file reader ------------------------------- */
#define FILE_BUFFER_SIZE 8192
struct fileread_t {
    int handle;
    unsigned char readbuffer[FILE_BUFFER_SIZE];
    int pos;
    int length;
};

static int reader_readbuf(struct reader_t*reader ,void *data, int len) {
    struct fileread_t*fr = reader->internal;

    int ret;
    if (fr->pos == fr->length) {
        fr->length = read(fr->handle,(void*)(&fr->readbuffer[0]), FILE_BUFFER_SIZE);
        fr->pos=0;
    }
    if ( len > (fr->length - fr->pos)) {
        ret = fr->length - fr->pos;
        memcpy(data,&fr->readbuffer[fr->pos],ret);
        fr->pos = fr->length;
        return ret;
    } else {
        memcpy(data,&fr->readbuffer[fr->pos],len);
        fr->pos += len;
        return len;
    }
}

static int reader_fileread(struct reader_t*reader, void* data, int len) {
    //struct fileread_t*fr = reader->internal;

    int ret;
    int pos;
    int oldret=0;
    pos=len;
    while(pos) {
        ret=reader_readbuf(reader, data+len-pos, pos);
        if (ret<=0) {
            if (ret==0) {
                return oldret;
            }
            return ret;
        }
        oldret+=ret;
        pos-=ret;
    }
    reader->pos += len;
    if (((void *)(&reader->mybyte))!=data) {
        reader->bitpos = 8;
    }
    return len;
}

void reader_init_filereader(struct reader_t*r, int handle) {
    struct fileread_t	*fr = g_new0(struct fileread_t,1);
    fr->handle = handle;
    r->read = reader_fileread;
    r->internal = (void*)fr;
    r->type = READER_TYPE_FILE;
    r->mybyte = 0;
    r->bitpos = 8;
    r->pos = 0;
}

/* ---------------------------- mem reader ------------------------------- */
struct memread_t {
    unsigned char*data;
    int length;
};

static int reader_memread(struct reader_t*reader, void* data, int len) {
    struct memread_t*mr = (struct memread_t*)reader->internal;

    if(mr->length - reader->pos > len) {
        memcpy(data, &mr->data[reader->pos], len);
        reader->pos += len;
        return len;
    } else {
        memcpy(data, &mr->data[reader->pos], mr->length - reader->pos);
        reader->pos = mr->length;
        return mr->length - reader->pos;
    }
}

void reader_init_memreader(struct reader_t*r, void*newdata, int newlength) {
    struct memread_t*mr = malloc(sizeof(struct memread_t));
    mr->data = newdata;
    mr->length = newlength;
    r->read = reader_memread;
    r->internal = (void*)mr;
    r->type = READER_TYPE_MEM;
    r->mybyte = 0;
    r->bitpos = 8;
    r->pos = 0;
}

/* ---------------------------- zlib reader ------------------------------- */
struct zlibinflate_t {
    z_stream zs;
    struct reader_t*input;
    unsigned char readbuffer[ZLIB_BUFFER_SIZE];
};

static void zlib_error(int ret, char* msg, z_stream*zs) {
    fprintf(stderr, "%s: zlib error (%d): last zlib error: %s\n",
            msg,
            ret,
            zs->msg?zs->msg:"unknown");
    perror("errno:");
    exit(1);
}

static int reader_zlibinflate(struct reader_t*reader, void* data, int len) {
    struct zlibinflate_t*z = (struct zlibinflate_t*)reader->internal;
    int ret;
    if(!z) {
        return 0;
    }
    if(!len)
        return 0;

    z->zs.next_out = data;
    z->zs.avail_out = len;

    while(1) {
        if(!z->zs.avail_in) {
            z->zs.avail_in = z->input->read(z->input, z->readbuffer, ZLIB_BUFFER_SIZE);
            z->zs.next_in = z->readbuffer;
        }
        if(z->zs.avail_in) {
            ret = inflate(&z->zs, Z_NO_FLUSH);
        } else {
            ret = inflate(&z->zs, Z_FINISH);
        }

        if (ret != Z_OK &&
                ret != Z_STREAM_END)
            zlib_error(ret, "bitio:inflate_inflate", &z->zs);

        if (ret == Z_STREAM_END) {
            int pos = z->zs.next_out - (Bytef*)data;
            ret = inflateEnd(&z->zs);
            if (ret != Z_OK)
                zlib_error(ret, "bitio:inflate_end", &z->zs);
            free(reader->internal);
            reader->internal = 0;
            reader->pos += pos;
            return pos;
        }
        if(!z->zs.avail_out) {
            break;
        }
    }
    reader->pos += len;
    if (((void *)(&reader->mybyte))!=data) {
        reader->bitpos = 8;
    }
    return len;
}

void reader_init_zlibinflate(struct reader_t*r, struct reader_t*input) {
    struct zlibinflate_t*z;
    int ret;
    memset(r, 0, sizeof(struct reader_t));
    z = (struct zlibinflate_t*)malloc(sizeof(struct zlibinflate_t));
    memset(z, 0, sizeof(struct zlibinflate_t));
    r->internal = z;
    r->read = reader_zlibinflate;
    r->type = READER_TYPE_ZLIB;
    r->pos = 0;
    z->input = input;
    memset(&z->zs,0,sizeof(z_stream));
    z->zs.zalloc = Z_NULL;
    z->zs.zfree  = Z_NULL;
    z->zs.opaque = Z_NULL;
    ret = inflateInit(&z->zs);
    if (ret != Z_OK)
        zlib_error(ret, "bitio:inflate_init", &z->zs);
    reader_resetbits(r);
}

/* ----------------------------------------------------------- */
unsigned int reader_readbit(struct reader_t*r) {
    if(r->bitpos==8) {
        r->bitpos=0;
        r->read(r, &r->mybyte, 1);
    }
    return (r->mybyte>>(7-r->bitpos++))&1;
}
unsigned int reader_readbits(struct reader_t*r, int num) {
    int t;
    int val = 0;
    for(t=0;t<num;t++) {
        val<<=1;
        val|=reader_readbit(r);
    }
    return val;
}
void reader_resetbits(struct reader_t*r) {
    r->mybyte = 0;
    r->bitpos = 8;
}