Author: ods15
Date: Sat Sep 23 20:34:54 2006
New Revision: 142
Modified:
trunk/libnut/demuxer.c
trunk/libnut/muxer.c
trunk/libnut/nut.h
trunk/libnut/priv.h
trunk/libnut/reorder.c
Log:
big change to user malloc
Modified: trunk/libnut/demuxer.c
==============================================================================
--- trunk/libnut/demuxer.c (original)
+++ trunk/libnut/demuxer.c Sat Sep 23 20:34:54 2006
@@ -30,7 +30,7 @@
amount += 10; // ### + PREALLOC_SIZE ?
if (bc->write_len - pos < amount) {
bc->write_len = amount + pos + PREALLOC_SIZE;
- bc->buf = realloc(bc->buf, bc->write_len);
+ bc->buf = bc->alloc->realloc(bc->buf, bc->write_len);
bc->buf_ptr = bc->buf + pos;
}
bc->read_len += bc->isc.read(bc->isc.priv, amount - (bc->read_len - pos), bc->buf + bc->read_len);
@@ -87,11 +87,13 @@
bc->file_pos = 0;
bc->filesize = 0;
bc->buf_ptr = bc->buf = NULL;
+ bc->alloc = NULL;
return bc;
}
-static input_buffer_t * new_input_buffer(nut_input_stream_t isc) {
- input_buffer_t * bc = new_mem_buffer(malloc(sizeof(input_buffer_t)));
+static input_buffer_t * new_input_buffer(nut_alloc_t * alloc, nut_input_stream_t isc) {
+ input_buffer_t * bc = new_mem_buffer(alloc->malloc(sizeof(input_buffer_t)));
+ bc->alloc = alloc;
bc->is_mem = 0;
bc->isc = isc;
bc->file_pos = isc.file_pos;
@@ -104,10 +106,10 @@
}
static void free_buffer(input_buffer_t * bc) {
- assert(!bc->is_mem);
if (!bc) return;
- free(bc->buf);
- free(bc);
+ assert(!bc->is_mem);
+ bc->alloc->free(bc->buf);
+ bc->alloc->free(bc);
}
static int get_bytes(input_buffer_t * bc, int count, uint64_t * val) {
@@ -194,12 +196,12 @@
return len;
}
-static int get_vb(input_buffer_t * in, int * len, uint8_t ** buf) {
+static int get_vb(nut_alloc_t * alloc, input_buffer_t * in, int * len, uint8_t ** buf) {
uint64_t tmp;
int err;
if ((err = get_v(in, &tmp))) return err;
*len = tmp;
- *buf = realloc(*buf, tmp);
+ *buf = alloc->realloc(*buf, tmp);
if (get_data(in, tmp, *buf) != tmp) return buf_eof(in);
return 0;
}
@@ -242,7 +244,7 @@
if (nut->max_distance > 65536) nut->max_distance = 65536;
GET_V(tmp, nut->timebase_count);
- nut->tb = realloc(nut->tb, nut->timebase_count * sizeof(nut_timebase_t));
+ nut->tb = nut->alloc->realloc(nut->tb, nut->timebase_count * sizeof(nut_timebase_t));
for (i = 0; i < nut->timebase_count; i++) {
GET_V(tmp, nut->tb[i].nom);
GET_V(tmp, nut->tb[i].den);
@@ -293,7 +295,7 @@
ERROR(i != id, -ERR_BAD_STREAM_ORDER);
GET_V(tmp, sc->sh.type);
- CHECK(get_vb(tmp, &sc->sh.fourcc_len, &sc->sh.fourcc));
+ CHECK(get_vb(nut->alloc, tmp, &sc->sh.fourcc_len, &sc->sh.fourcc));
GET_V(tmp, sc->timebase_id);
sc->sh.time_base = nut->tb[sc->timebase_id];
GET_V(tmp, sc->msb_pts_shift);
@@ -301,7 +303,7 @@
GET_V(tmp, sc->sh.decode_delay);
GET_V(tmp, i); // stream_flags
sc->sh.fixed_fps = i & 1;
- CHECK(get_vb(tmp, &sc->sh.codec_specific_len, &sc->sh.codec_specific));
+ CHECK(get_vb(nut->alloc, tmp, &sc->sh.codec_specific_len, &sc->sh.codec_specific));
switch (sc->sh.type) {
case NUT_VIDEO_CLASS:
@@ -345,9 +347,9 @@
i++;
if (sl->len + 1 > sl->alloc_len) {
sl->alloc_len += PREALLOC_SIZE/4;
- sl->s = realloc(sl->s, sl->alloc_len * sizeof(syncpoint_t));
- sl->pts = realloc(sl->pts, sl->alloc_len * nut->stream_count * sizeof(uint64_t));
- sl->eor = realloc(sl->eor, sl->alloc_len * nut->stream_count * sizeof(uint64_t));
+ sl->s = nut->alloc->realloc(sl->s, sl->alloc_len * sizeof(syncpoint_t));
+ sl->pts = nut->alloc->realloc(sl->pts, sl->alloc_len * nut->stream_count * sizeof(uint64_t));
+ sl->eor = nut->alloc->realloc(sl->eor, sl->alloc_len * nut->stream_count * sizeof(uint64_t));
}
memmove(sl->s + i + 1, sl->s + i, (sl->len - i) * sizeof(syncpoint_t));
memmove(sl->pts + (i + 1) * nut->stream_count, sl->pts + i * nut->stream_count, (sl->len - i) * nut->stream_count * sizeof(uint64_t));
@@ -436,9 +438,9 @@
GET_V(tmp, x);
sl->alloc_len = sl->len = x;
- sl->s = realloc(sl->s, sl->alloc_len * sizeof(syncpoint_t));
- sl->pts = realloc(sl->pts, sl->alloc_len * sizeof(uint64_t) * nut->stream_count);
- sl->eor = realloc(sl->eor, sl->alloc_len * sizeof(uint64_t) * nut->stream_count);
+ sl->s = nut->alloc->realloc(sl->s, sl->alloc_len * sizeof(syncpoint_t));
+ sl->pts = nut->alloc->realloc(sl->pts, sl->alloc_len * sizeof(uint64_t) * nut->stream_count);
+ sl->eor = nut->alloc->realloc(sl->eor, sl->alloc_len * sizeof(uint64_t) * nut->stream_count);
for (i = 0; i < sl->len; i++) {
GET_V(tmp, sl->s[i].pos);
@@ -718,7 +720,7 @@
CHECK(get_main_header(nut));
if (!nut->sc) {
- nut->sc = malloc(sizeof(stream_context_t) * nut->stream_count);
+ nut->sc = nut->alloc->malloc(sizeof(stream_context_t) * nut->stream_count);
for (i = 0; i < nut->stream_count; i++) {
nut->sc[i].last_pts = 0;
nut->sc[i].last_dts = 0;
@@ -742,7 +744,7 @@
}
CHECK(get_stream_header(nut, i));
if (!nut->sc[i].pts_cache) {
- nut->sc[i].pts_cache = malloc(nut->sc[i].sh.decode_delay * sizeof(int64_t));
+ nut->sc[i].pts_cache = nut->alloc->malloc(nut->sc[i].sh.decode_delay * sizeof(int64_t));
for (j = 0; j < nut->sc[i].sh.decode_delay; j++)
nut->sc[i].pts_cache[j] = -1;
}
@@ -784,17 +786,17 @@
if (nut->before_seek) seek_buf(nut->i, nut->before_seek, SEEK_SET);
nut->before_seek = 0;
}
- *s = malloc(sizeof(nut_stream_header_t) * (nut->stream_count + 1));
+ *s = nut->alloc->malloc(sizeof(nut_stream_header_t) * (nut->stream_count + 1));
for (i = 0; i < nut->stream_count; i++) (*s)[i] = nut->sc[i].sh;
(*s)[i].type = -1;
err_out:
if (err && err != 2 && !nut->seek_status) {
if (nut->sc) for (i = 0; i < nut->stream_count; i++) {
- free(nut->sc[i].sh.fourcc);
- free(nut->sc[i].sh.codec_specific);
- free(nut->sc[i].pts_cache);
+ nut->alloc->free(nut->sc[i].sh.fourcc);
+ nut->alloc->free(nut->sc[i].sh.codec_specific);
+ nut->alloc->free(nut->sc[i].pts_cache);
}
- free(nut->sc);
+ nut->alloc->free(nut->sc);
nut->sc = NULL;
nut->stream_count = 0;
}
@@ -1225,19 +1227,20 @@
if (err != 2) { // unless EAGAIN
flush_buf(nut->i);
nut->before_seek = 0;
- free(nut->seek_state);
+ nut->alloc->free(nut->seek_state);
nut->seek_state = NULL;
} else {
- if (!nut->seek_state) nut->seek_state = malloc(sizeof state);
+ if (!nut->seek_state) nut->seek_state = nut->alloc->malloc(sizeof state);
memcpy(nut->seek_state, state, sizeof state);
}
return err;
}
nut_context_t * nut_demuxer_init(nut_demuxer_opts_t * dopts) {
- nut_context_t * nut = malloc(sizeof(nut_context_t));
+ nut_context_t * nut;
- nut->i = new_input_buffer(dopts->input);
+ if (dopts->alloc.malloc) nut = dopts->alloc.malloc(sizeof(nut_context_t));
+ else nut = malloc(sizeof(nut_context_t));
nut->syncpoints.len = 0;
nut->syncpoints.alloc_len = 0;
@@ -1254,6 +1257,17 @@
nut->before_seek = 0;
nut->last_syncpoint = 0;
nut->seek_state = NULL;
+
+ nut->alloc = &nut->dopts.alloc;
+
+ if (!nut->alloc->malloc) {
+ nut->alloc->malloc = malloc;
+ nut->alloc->realloc = realloc;
+ nut->alloc->free = free;
+ }
+
+ nut->i = new_input_buffer(nut->alloc, dopts->input);
+
return nut;
}
@@ -1261,19 +1275,19 @@
int i;
if (!nut) return;
for (i = 0; i < nut->stream_count; i++) {
- free(nut->sc[i].sh.fourcc);
- free(nut->sc[i].sh.codec_specific);
- free(nut->sc[i].pts_cache);
+ nut->alloc->free(nut->sc[i].sh.fourcc);
+ nut->alloc->free(nut->sc[i].sh.codec_specific);
+ nut->alloc->free(nut->sc[i].pts_cache);
}
- free(nut->syncpoints.s);
- free(nut->syncpoints.pts);
- free(nut->syncpoints.eor);
- free(nut->sc);
- free(nut->tb);
- free(nut->seek_state);
+ nut->alloc->free(nut->syncpoints.s);
+ nut->alloc->free(nut->syncpoints.pts);
+ nut->alloc->free(nut->syncpoints.eor);
+ nut->alloc->free(nut->sc);
+ nut->alloc->free(nut->tb);
+ nut->alloc->free(nut->seek_state);
free_buffer(nut->i);
- free(nut);
+ nut->alloc->free(nut);
}
const char * nut_error(int error) {
Modified: trunk/libnut/muxer.c
==============================================================================
--- trunk/libnut/muxer.c (original)
+++ trunk/libnut/muxer.c Sat Sep 23 20:34:54 2006
@@ -23,29 +23,30 @@
if (bc->is_mem) {
int tmp = bc->buf_ptr - bc->buf;
bc->write_len = tmp + amount + PREALLOC_SIZE;
- bc->buf = realloc(bc->buf, bc->write_len);
+ bc->buf = bc->alloc->realloc(bc->buf, bc->write_len);
bc->buf_ptr = bc->buf + tmp;
} else {
flush_buf(bc);
if (bc->write_len < amount) {
- free(bc->buf);
+ bc->alloc->free(bc->buf);
bc->write_len = amount + PREALLOC_SIZE;
- bc->buf_ptr = bc->buf = malloc(bc->write_len);
+ bc->buf_ptr = bc->buf = bc->alloc->malloc(bc->write_len);
}
}
}
-static output_buffer_t * new_mem_buffer() {
- output_buffer_t * bc = malloc(sizeof(output_buffer_t));
+static output_buffer_t * new_mem_buffer(nut_alloc_t * alloc) {
+ output_buffer_t * bc = alloc->malloc(sizeof(output_buffer_t));
+ bc->alloc = alloc;
bc->write_len = PREALLOC_SIZE;
bc->is_mem = 1;
bc->file_pos = 0;
- bc->buf_ptr = bc->buf = malloc(bc->write_len);
+ bc->buf_ptr = bc->buf = alloc->malloc(bc->write_len);
return bc;
}
-static output_buffer_t * new_output_buffer(nut_output_stream_t osc) {
- output_buffer_t * bc = new_mem_buffer();
+static output_buffer_t * new_output_buffer(nut_alloc_t * alloc, nut_output_stream_t osc) {
+ output_buffer_t * bc = new_mem_buffer(alloc);
bc->is_mem = 0;
bc->osc = osc;
if (!bc->osc.write) bc->osc.write = stream_write;
@@ -55,8 +56,8 @@
static void free_buffer(output_buffer_t * bc) {
if (!bc) return;
if (!bc->is_mem) flush_buf(bc);
- free(bc->buf);
- free(bc);
+ bc->alloc->free(bc->buf);
+ bc->alloc->free(bc);
}
static output_buffer_t * clear_buffer(output_buffer_t * bc) {
@@ -282,9 +283,9 @@
if (s->alloc_len <= s->len) {
s->alloc_len += PREALLOC_SIZE;
- s->s = realloc(s->s, s->alloc_len * sizeof(syncpoint_t));
- s->pts = realloc(s->pts, s->alloc_len * nut->stream_count * sizeof(uint64_t));
- s->eor = realloc(s->eor, s->alloc_len * nut->stream_count * sizeof(uint64_t));
+ s->s = nut->alloc->realloc(s->s, s->alloc_len * sizeof(syncpoint_t));
+ s->pts = nut->alloc->realloc(s->pts, s->alloc_len * nut->stream_count * sizeof(uint64_t));
+ s->eor = nut->alloc->realloc(s->eor, s->alloc_len * nut->stream_count * sizeof(uint64_t));
}
for (i = 0; i < nut->stream_count; i++) {
@@ -487,16 +488,28 @@
}
nut_context_t * nut_muxer_init(const nut_muxer_opts_t * mopts, const nut_stream_header_t s[], const nut_info_packet_t info[]) {
- nut_context_t * nut = malloc(sizeof(nut_context_t));
+ nut_context_t * nut;
int i;
// TODO check that all input is valid
- nut->o = new_output_buffer(mopts->output);
- nut->tmp_buffer = new_mem_buffer(); // general purpose buffer
- nut->tmp_buffer2 = new_mem_buffer(); // for packet_headers
- nut->max_distance = mopts->max_distance;
+ if (mopts->alloc.malloc) nut = mopts->alloc.malloc(sizeof(nut_context_t));
+ else nut = malloc(sizeof(nut_context_t));
+
nut->mopts = *mopts;
+ nut->alloc = &nut->mopts.alloc;
+
+ if (!nut->alloc->malloc) {
+ nut->alloc->malloc = malloc;
+ nut->alloc->realloc = realloc;
+ nut->alloc->free = free;
+ }
+
+ nut->o = new_output_buffer(nut->alloc, mopts->output);
+ nut->tmp_buffer = new_mem_buffer(nut->alloc); // general purpose buffer
+ nut->tmp_buffer2 = new_mem_buffer(nut->alloc); // for packet_headers
+ nut->max_distance = mopts->max_distance;
+
if (nut->max_distance > 65536) nut->max_distance = 65536;
{
@@ -542,8 +555,8 @@
for (nut->stream_count = 0; s[nut->stream_count].type >= 0; nut->stream_count++);
- nut->sc = malloc(sizeof(stream_context_t) * nut->stream_count);
- nut->tb = malloc(sizeof(nut_timebase_t) * nut->stream_count);
+ nut->sc = nut->alloc->malloc(sizeof(stream_context_t) * nut->stream_count);
+ nut->tb = nut->alloc->malloc(sizeof(nut_timebase_t) * nut->stream_count);
nut->timebase_count = 0;
for (i = 0; i < nut->stream_count; i++) {
@@ -557,20 +570,20 @@
nut->sc[i].sh = s[i];
nut->sc[i].sh.max_pts = 0;
- nut->sc[i].sh.fourcc = malloc(s[i].fourcc_len);
+ nut->sc[i].sh.fourcc = nut->alloc->malloc(s[i].fourcc_len);
memcpy(nut->sc[i].sh.fourcc, s[i].fourcc, s[i].fourcc_len);
- nut->sc[i].sh.codec_specific = malloc(s[i].codec_specific_len);
+ nut->sc[i].sh.codec_specific = nut->alloc->malloc(s[i].codec_specific_len);
memcpy(nut->sc[i].sh.codec_specific, s[i].codec_specific, s[i].codec_specific_len);
- nut->sc[i].pts_cache = malloc(nut->sc[i].sh.decode_delay * sizeof(int64_t));
+ nut->sc[i].pts_cache = nut->alloc->malloc(nut->sc[i].sh.decode_delay * sizeof(int64_t));
for (j = 0; j < nut->timebase_count; j++) if (compare_ts(nut, 1, s[i].time_base, 1, nut->tb[j]) == 0) break;
if (j == nut->timebase_count) nut->tb[nut->timebase_count++] = s[i].time_base;
nut->sc[i].timebase_id = j;
// reorder.c
- nut->sc[i].reorder_pts_cache = malloc(nut->sc[i].sh.decode_delay * sizeof(int64_t));
+ nut->sc[i].reorder_pts_cache = nut->alloc->malloc(nut->sc[i].sh.decode_delay * sizeof(int64_t));
for (j = 0; j < nut->sc[i].sh.decode_delay; j++) nut->sc[i].reorder_pts_cache[j] = nut->sc[i].pts_cache[j] = -1;
nut->sc[i].next_pts = 0;
nut->sc[i].packets = NULL;
@@ -585,16 +598,16 @@
if (info) {
for (nut->info_count = 0; info[nut->info_count].count >= 0; nut->info_count++);
- nut->info = malloc(sizeof(nut_info_packet_t) * nut->info_count);
+ nut->info = nut->alloc->malloc(sizeof(nut_info_packet_t) * nut->info_count);
for (i = 0; i < nut->info_count; i++) {
int j;
nut->info[i] = info[i];
- nut->info[i].fields = malloc(sizeof(nut_info_field_t) * info[i].count);
+ nut->info[i].fields = nut->alloc->malloc(sizeof(nut_info_field_t) * info[i].count);
for (j = 0; j < info[i].count; j++) {
nut->info[i].fields[j] = info[i].fields[j];
if (info[i].fields[j].data) {
- nut->info[i].fields[j].data = malloc(info[i].fields[j].val);
+ nut->info[i].fields[j].data = nut->alloc->malloc(info[i].fields[j].val);
memcpy(nut->info[i].fields[j].data, info[i].fields[j].data, info[i].fields[j].val);
}
}
@@ -631,31 +644,31 @@
fprintf(stderr, "packet size: %.2lf ", (double)nut->sc[i].tot_size / nut->sc[i].total_frames);
fprintf(stderr, "packet overhead: %.2lf\n", (double)nut->sc[i].overhead / nut->sc[i].total_frames);
- free(nut->sc[i].sh.fourcc);
- free(nut->sc[i].sh.codec_specific);
- free(nut->sc[i].pts_cache);
- free(nut->sc[i].reorder_pts_cache);
+ nut->alloc->free(nut->sc[i].sh.fourcc);
+ nut->alloc->free(nut->sc[i].sh.codec_specific);
+ nut->alloc->free(nut->sc[i].pts_cache);
+ nut->alloc->free(nut->sc[i].reorder_pts_cache);
}
- free(nut->sc);
- free(nut->tb);
+ nut->alloc->free(nut->sc);
+ nut->alloc->free(nut->tb);
for (i = 0; i < nut->info_count; i++) {
int j;
- for (j = 0; j < nut->info[i].count; j++) free(nut->info[i].fields[j].data);
- free(nut->info[i].fields);
+ for (j = 0; j < nut->info[i].count; j++) nut->alloc->free(nut->info[i].fields[j].data);
+ nut->alloc->free(nut->info[i].fields);
}
- free(nut->info);
+ nut->alloc->free(nut->info);
fprintf(stderr, "Syncpoints: %d size: %d\n", nut->syncpoints.len, nut->sync_overhead);
- free(nut->syncpoints.s);
- free(nut->syncpoints.pts);
- free(nut->syncpoints.eor);
+ nut->alloc->free(nut->syncpoints.s);
+ nut->alloc->free(nut->syncpoints.pts);
+ nut->alloc->free(nut->syncpoints.eor);
free_buffer(nut->tmp_buffer);
free_buffer(nut->tmp_buffer2);
fprintf(stderr, "TOTAL: %d bytes data, %d bytes overhead, %.2lf%% overhead\n", total,
(int)bctello(nut->o) - total, (double)(bctello(nut->o) - total) / total*100);
free_buffer(nut->o); // flushes file
- free(nut);
+ nut->alloc->free(nut);
}
Modified: trunk/libnut/nut.h
==============================================================================
--- trunk/libnut/nut.h (original)
+++ trunk/libnut/nut.h Sat Sep 23 20:34:54 2006
@@ -66,7 +66,14 @@
} frame_table_input_t;
typedef struct {
+ void * (*malloc)(size_t size);
+ void * (*realloc)(void *ptr, size_t size);
+ void (*free)(void *ptr);
+} nut_alloc_t;
+
+typedef struct {
nut_output_stream_t output;
+ nut_alloc_t alloc;
int write_index;
int max_distance;
frame_table_input_t * fti;
@@ -74,6 +81,7 @@
typedef struct {
nut_input_stream_t input;
+ nut_alloc_t alloc;
int read_index;
//int cache_syncpoints;
} nut_demuxer_opts_t;
Modified: trunk/libnut/priv.h
==============================================================================
--- trunk/libnut/priv.h (original)
+++ trunk/libnut/priv.h Sat Sep 23 20:34:54 2006
@@ -62,6 +62,7 @@
int read_len; // data in memory
off_t file_pos;
off_t filesize;
+ nut_alloc_t * alloc;
} input_buffer_t;
typedef struct {
@@ -71,6 +72,7 @@
uint8_t * buf_ptr;
int write_len; // memory allocated
off_t file_pos;
+ nut_alloc_t * alloc;
} output_buffer_t;
typedef struct {
@@ -136,6 +138,7 @@
struct nut_context_s {
nut_muxer_opts_t mopts;
nut_demuxer_opts_t dopts;
+ nut_alloc_t * alloc;
input_buffer_t * i;
output_buffer_t * o;
output_buffer_t * tmp_buffer;
Modified: trunk/libnut/reorder.c
==============================================================================
--- trunk/libnut/reorder.c (original)
+++ trunk/libnut/reorder.c Sat Sep 23 20:34:54 2006
@@ -12,13 +12,13 @@
assert(amount <= s->num_packets);
for (i = 0; i < amount; i++) {
nut_write_frame(nut, &s->packets[i].p, s->packets[i].buf);
- free(s->packets[i].buf); // FIXME
+ nut->alloc->free(s->packets[i].buf); // FIXME
}
if (s->next_pts != -2) s->next_pts = s->packets[i - 1].p.next_pts;
s->num_packets -= amount;
memmove(s->packets, s->packets + amount, s->num_packets * sizeof(reorder_packet_t));
- s->packets = realloc(s->packets, s->num_packets * sizeof(reorder_packet_t));
+ s->packets = nut->alloc->realloc(s->packets, s->num_packets * sizeof(reorder_packet_t));
}
static void flushcheck_frames(nut_context_t * nut) {
@@ -67,7 +67,7 @@
flushcheck_frames(nut);
for (i = 0; i < nut->stream_count; i++) {
assert(!nut->sc[i].num_packets);
- free(nut->sc[i].packets);
+ nut->alloc->free(nut->sc[i].packets);
nut->sc[i].packets = NULL;
}
nut_muxer_uninit(nut);
@@ -81,11 +81,11 @@
}
s->num_packets++;
- s->packets = realloc(s->packets, s->num_packets * sizeof(reorder_packet_t));
+ s->packets = nut->alloc->realloc(s->packets, s->num_packets * sizeof(reorder_packet_t));
s->packets[s->num_packets - 1].p = *p;
s->packets[s->num_packets - 1].dts = get_dts(s->sh.decode_delay, s->reorder_pts_cache, p->pts);
- s->packets[s->num_packets - 1].buf = malloc(p->len); // FIXME
+ s->packets[s->num_packets - 1].buf = nut->alloc->malloc(p->len); // FIXME
memcpy(s->packets[s->num_packets - 1].buf, buf, p->len);
flushcheck_frames(nut);
