Author: ods15 Date: Thu Dec 11 21:34:43 2008 New Revision: 661 Log: Rename all typedefs from _t to _tt for POSIX compatibility Modified: src/trunk/libnut/demuxer.c src/trunk/libnut/framecode.c src/trunk/libnut/libnut.h src/trunk/libnut/muxer.c src/trunk/libnut/priv.h src/trunk/libnut/reorder.c src/trunk/nututils/demux_avi.c src/trunk/nututils/demux_ogg.c src/trunk/nututils/framer_mp3.c src/trunk/nututils/framer_mpeg4.c src/trunk/nututils/framer_vorbis.c src/trunk/nututils/nutindex.c src/trunk/nututils/nutmerge.c src/trunk/nututils/nutmerge.h Modified: src/trunk/libnut/demuxer.c ============================================================================== --- src/trunk/libnut/demuxer.c (original) +++ src/trunk/libnut/demuxer.c Thu Dec 11 21:34:43 2008 @@ -16,7 +16,7 @@ static off_t stream_seek(void * priv, lo return ftello(priv); } -static void flush_buf(input_buffer_t *bc) { +static void flush_buf(input_buffer_tt *bc) { assert(!bc->is_mem); bc->file_pos += bc->buf_ptr - bc->buf; bc->read_len -= bc->buf_ptr - bc->buf; @@ -24,7 +24,7 @@ static void flush_buf(input_buffer_t *bc bc->buf_ptr = bc->buf; } -static int ready_read_buf(input_buffer_t * bc, int amount) { +static int ready_read_buf(input_buffer_tt * bc, int amount) { int pos = (bc->buf_ptr - bc->buf); if (bc->read_len - pos < amount && !bc->is_mem) { amount += 10; @@ -42,7 +42,7 @@ static int ready_read_buf(input_buffer_t return bc->read_len - (bc->buf_ptr - bc->buf); } -static void seek_buf(input_buffer_t * bc, long long pos, int whence) { +static void seek_buf(input_buffer_tt * bc, long long pos, int whence) { assert(!bc->is_mem); if (whence != SEEK_END) { // don't do anything when already in seeked position. but still flush_buf @@ -66,26 +66,26 @@ static void seek_buf(input_buffer_t * bc if (whence == SEEK_END) bc->filesize = bc->file_pos - pos; } -static int buf_eof(input_buffer_t * bc) { +static int buf_eof(input_buffer_tt * bc) { if (bc->is_mem) return NUT_ERR_BAD_EOF; if (!bc->alloc) return NUT_ERR_OUT_OF_MEM; if (!bc->isc.eof || bc->isc.eof(bc->isc.priv)) return NUT_ERR_EOF; return NUT_ERR_EAGAIN; } -static int skip_buffer(input_buffer_t * bc, int len) { +static int skip_buffer(input_buffer_tt * bc, int len) { if (ready_read_buf(bc, len) < len) return buf_eof(bc); bc->buf_ptr += len; return 0; } -static uint8_t * get_buf(input_buffer_t * bc, off_t start) { +static uint8_t * get_buf(input_buffer_tt * bc, off_t start) { start -= bc->file_pos; assert((unsigned)start < bc->read_len); return bc->buf + start; } -static input_buffer_t * new_mem_buffer(input_buffer_t * bc) { +static input_buffer_tt * new_mem_buffer(input_buffer_tt * bc) { if (!bc) return NULL; bc->read_len = 0; bc->write_len = 0; @@ -97,8 +97,8 @@ static input_buffer_t * new_mem_buffer(i return bc; } -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))); +static input_buffer_tt * new_input_buffer(nut_alloc_tt * alloc, nut_input_stream_tt isc) { + input_buffer_tt * bc = new_mem_buffer(alloc->malloc(sizeof(input_buffer_tt))); if (!bc) return NULL; bc->alloc = alloc; bc->is_mem = 0; @@ -112,14 +112,14 @@ static input_buffer_t * new_input_buffer return bc; } -static void free_buffer(input_buffer_t * bc) { +static void free_buffer(input_buffer_tt * bc) { if (!bc) return; 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) { +static int get_bytes(input_buffer_tt * bc, int count, uint64_t * val) { int i; if (ready_read_buf(bc, count) < count) return buf_eof(bc); *val = 0; @@ -129,7 +129,7 @@ static int get_bytes(input_buffer_t * bc return 0; } -static int get_v(input_buffer_t * bc, uint64_t * val) { +static int get_v(input_buffer_tt * bc, uint64_t * val) { int i, len; *val = 0; @@ -145,7 +145,7 @@ static int get_v(input_buffer_t * bc, ui return buf_eof(bc); } -static int get_s(input_buffer_t * bc, int64_t * val) { +static int get_s(input_buffer_tt * bc, int64_t * val) { uint64_t tmp; int err; if ((err = get_v(bc, &tmp))) return err; @@ -156,13 +156,13 @@ static int get_s(input_buffer_t * bc, in } #ifdef TRACE -static int get_v_trace(input_buffer_t * bc, uint64_t * val, char * var, char * file, int line, char * func) { +static int get_v_trace(input_buffer_tt * bc, uint64_t * val, char * var, char * file, int line, char * func) { int a = get_v(bc, val); printf("GET_V %llu to var `%s' at %s:%d, %s() (ret: %d)\n", *val, var, file, line, func, a); return a; } -static int get_s_trace(input_buffer_t * bc, int64_t * val, char * var, char * file, int line, char * func) { +static int get_s_trace(input_buffer_tt * bc, int64_t * val, char * var, char * file, int line, char * func) { int a = get_s(bc, val); printf("GET_S %lld to var `%s' at %s:%d, %s() (ret: %d)\n", *val, var, file, line, func, a); return a; @@ -193,7 +193,7 @@ static int get_s_trace(input_buffer_t * (var) = _tmp; \ } while(0) -static int get_data(input_buffer_t * bc, int len, uint8_t * buf) { +static int get_data(input_buffer_tt * bc, int len, uint8_t * buf) { int tmp; if (!len) return 0; @@ -208,7 +208,7 @@ static int get_data(input_buffer_t * bc, return len; } -static int get_vb(nut_alloc_t * alloc, input_buffer_t * in, int * len, uint8_t ** buf) { +static int get_vb(nut_alloc_tt * alloc, input_buffer_tt * in, int * len, uint8_t ** buf) { uint64_t tmp; int err; if ((err = get_v(in, &tmp))) return err; @@ -221,7 +221,7 @@ static int get_vb(nut_alloc_t * alloc, i return 0; } -static int get_header(input_buffer_t * in, input_buffer_t * out) { +static int get_header(input_buffer_tt * in, input_buffer_tt * out) { off_t start = bctello(in) - 8; // startcode int forward_ptr; int err = 0; @@ -246,8 +246,8 @@ err_out: return err; } -static int get_main_header(nut_context_t * nut) { - input_buffer_t itmp, * tmp = new_mem_buffer(&itmp); +static int get_main_header(nut_context_tt * nut) { + input_buffer_tt itmp, * tmp = new_mem_buffer(&itmp); int i, j, err = 0; int flag, fields, timestamp = 0, mul = 1, stream = 0, size, count, reserved; @@ -261,8 +261,8 @@ static int get_main_header(nut_context_t GET_V(tmp, nut->timebase_count); nut->alloc->free(nut->tb); nut->tb = NULL; - ERROR(SIZE_MAX/sizeof(nut_timebase_t) < nut->timebase_count, NUT_ERR_OUT_OF_MEM); - nut->tb = nut->alloc->malloc(nut->timebase_count * sizeof(nut_timebase_t)); + ERROR(SIZE_MAX/sizeof(nut_timebase_tt) < nut->timebase_count, NUT_ERR_OUT_OF_MEM); + nut->tb = nut->alloc->malloc(nut->timebase_count * sizeof(nut_timebase_tt)); ERROR(!nut->tb, NUT_ERR_OUT_OF_MEM); for (i = 0; i < nut->timebase_count; i++) { GET_V(tmp, nut->tb[i].num); @@ -303,9 +303,9 @@ err_out: return err; } -static int get_stream_header(nut_context_t * nut) { - input_buffer_t itmp, * tmp = new_mem_buffer(&itmp); - stream_context_t * sc; +static int get_stream_header(nut_context_tt * nut) { + input_buffer_tt itmp, * tmp = new_mem_buffer(&itmp); + stream_context_tt * sc; int i, err = 0; CHECK(get_header(nut->i, tmp)); @@ -347,14 +347,14 @@ err_out: return err; } -static void free_info_packet(nut_context_t * nut, nut_info_packet_t * info) { +static void free_info_packet(nut_context_tt * nut, nut_info_packet_tt * info) { int i; for (i = 0; i < info->count; i++) nut->alloc->free(info->fields[i].data); nut->alloc->free(info->fields); } -static int get_info_header(nut_context_t * nut, nut_info_packet_t * info) { - input_buffer_t itmp, * tmp = new_mem_buffer(&itmp); +static int get_info_header(nut_context_tt * nut, nut_info_packet_tt * info) { + input_buffer_tt itmp, * tmp = new_mem_buffer(&itmp); int i, err = 0; CHECK(get_header(nut->i, tmp)); @@ -366,11 +366,11 @@ static int get_info_header(nut_context_t GET_V(tmp, info->chapter_len); GET_V(tmp, info->count); - SAFE_CALLOC(nut->alloc, info->fields, sizeof(nut_info_field_t), info->count); + SAFE_CALLOC(nut->alloc, info->fields, sizeof(nut_info_field_tt), info->count); for (i = 0; i < info->count; i++) { int len; - nut_info_field_t * field = &info->fields[i]; + nut_info_field_tt * field = &info->fields[i]; len = sizeof(field->name) - 1; CHECK(get_vb(nut->alloc, tmp, &len, (uint8_t**)&field->name)); @@ -409,8 +409,8 @@ err_out: return err; } -static void add_existing_syncpoint(nut_context_t * nut, syncpoint_t sp, uint64_t * pts, uint64_t * eor, int i) { - syncpoint_list_t * sl = &nut->syncpoints; +static void add_existing_syncpoint(nut_context_tt * nut, syncpoint_tt sp, uint64_t * pts, uint64_t * eor, int i) { + syncpoint_list_tt * sl = &nut->syncpoints; int j; int pts_cache = nut->dopts.cache_syncpoints & 1; @@ -433,8 +433,8 @@ static void add_existing_syncpoint(nut_c if (sp.pts_valid && i) sl->s[i-1].seen_next = 1; } -static int add_syncpoint(nut_context_t * nut, syncpoint_t sp, uint64_t * pts, uint64_t * eor, int * out) { - syncpoint_list_t * sl = &nut->syncpoints; +static int add_syncpoint(nut_context_tt * nut, syncpoint_tt sp, uint64_t * pts, uint64_t * eor, int * out) { + syncpoint_list_tt * sl = &nut->syncpoints; int i, j, err = 0; int pts_cache = nut->dopts.cache_syncpoints & 1; @@ -452,13 +452,13 @@ static int add_syncpoint(nut_context_t * i++; if (sl->len + 1 > sl->alloc_len) { sl->alloc_len += PREALLOC_SIZE/4; - SAFE_REALLOC(nut->alloc, sl->s, sizeof(syncpoint_t), sl->alloc_len); + SAFE_REALLOC(nut->alloc, sl->s, sizeof(syncpoint_tt), sl->alloc_len); if (pts_cache) { SAFE_REALLOC(nut->alloc, sl->pts, nut->stream_count * sizeof(uint64_t), sl->alloc_len); SAFE_REALLOC(nut->alloc, sl->eor, nut->stream_count * sizeof(uint64_t), sl->alloc_len); } } - memmove(sl->s + i + 1, sl->s + i, (sl->len - i) * sizeof(syncpoint_t)); + memmove(sl->s + i + 1, sl->s + i, (sl->len - i) * sizeof(syncpoint_tt)); sl->s[i] = sp; if (sl->s[i].pts_valid) { if (!pts_cache) sl->s[i].pts_valid = 0; // pts_valid is not really true, only used for seen_next @@ -480,9 +480,9 @@ err_out: return err; } -static int queue_add_syncpoint(nut_context_t * nut, syncpoint_t sp, uint64_t * pts, uint64_t * eor) { - syncpoint_list_t * sl = &nut->syncpoints; - syncpoint_linked_t * s; +static int queue_add_syncpoint(nut_context_tt * nut, syncpoint_tt sp, uint64_t * pts, uint64_t * eor) { + syncpoint_list_tt * sl = &nut->syncpoints; + syncpoint_linked_tt * s; size_t malloc_size; int pts_cache = nut->dopts.cache_syncpoints & 1; int err = 0; @@ -500,7 +500,7 @@ static int queue_add_syncpoint(nut_conte return 0; } - malloc_size = sizeof(syncpoint_linked_t) - sizeof(uint64_t); + malloc_size = sizeof(syncpoint_linked_tt) - sizeof(uint64_t); if (pts_cache && sp.pts_valid) { assert(pts && eor); // code sanity check malloc_size += (nut->stream_count*2) * sizeof(uint64_t); @@ -522,11 +522,11 @@ err_out: return err; } -static int flush_syncpoint_queue(nut_context_t * nut) { - syncpoint_list_t * sl = &nut->syncpoints; +static int flush_syncpoint_queue(nut_context_tt * nut) { + syncpoint_list_tt * sl = &nut->syncpoints; int err = 0; while (sl->linked) { - syncpoint_linked_t * s = sl->linked; + syncpoint_linked_tt * s = sl->linked; CHECK(add_syncpoint(nut, s->s, s->pts_eor, s->pts_eor + nut->stream_count, NULL)); sl->linked = s->prev; nut->alloc->free(s); @@ -535,20 +535,20 @@ err_out: return err; } -static void set_global_pts(nut_context_t * nut, uint64_t pts) { +static void set_global_pts(nut_context_tt * nut, uint64_t pts) { int i; TO_PTS(timestamp, pts) for (i = 0; i < nut->stream_count; i++) { - nut->sc[i].last_pts = convert_ts(timestamp_p, nut->tb[timestamp_t], TO_TB(i)); + nut->sc[i].last_pts = convert_ts(timestamp_p, nut->tb[timestamp_tb], TO_TB(i)); } } -static int get_syncpoint(nut_context_t * nut) { +static int get_syncpoint(nut_context_tt * nut) { int err = 0; - syncpoint_t s; + syncpoint_tt s; int after_seek = nut->last_syncpoint ? 0 : 1; - input_buffer_t itmp, * tmp = new_mem_buffer(&itmp); + input_buffer_tt itmp, * tmp = new_mem_buffer(&itmp); s.pos = bctello(nut->i) - 8; @@ -584,23 +584,23 @@ err_out: return err; } -static int get_index(nut_context_t * nut) { - input_buffer_t itmp, * tmp = new_mem_buffer(&itmp); +static int get_index(nut_context_tt * nut) { + input_buffer_tt itmp, * tmp = new_mem_buffer(&itmp); int i, err = 0; uint64_t max_pts; - syncpoint_list_t * sl = &nut->syncpoints; + syncpoint_list_tt * sl = &nut->syncpoints; CHECK(get_header(nut->i, tmp)); GET_V(tmp, max_pts); for (i = 0; i < nut->stream_count; i++) { TO_PTS(max, max_pts) - nut->sc[i].sh.max_pts = convert_ts(max_p, nut->tb[max_t], TO_TB(i)); + nut->sc[i].sh.max_pts = convert_ts(max_p, nut->tb[max_tb], TO_TB(i)); } GET_V(tmp, sl->len); sl->alloc_len = sl->len; - SAFE_REALLOC(nut->alloc, sl->s, sizeof(syncpoint_t), sl->alloc_len); + SAFE_REALLOC(nut->alloc, sl->s, sizeof(syncpoint_tt), sl->alloc_len); SAFE_REALLOC(nut->alloc, sl->pts, nut->stream_count * sizeof(uint64_t), sl->alloc_len); SAFE_REALLOC(nut->alloc, sl->eor, nut->stream_count * sizeof(uint64_t), sl->alloc_len); @@ -656,7 +656,7 @@ err_out: return err; } -static void clear_dts_cache(nut_context_t * nut) { +static void clear_dts_cache(nut_context_tt * nut) { int i; for (i = 0; i < nut->stream_count; i++) { int j; @@ -665,8 +665,8 @@ static void clear_dts_cache(nut_context_ } } -static int get_packet(nut_context_t * nut, nut_packet_t * pd, int * saw_syncpoint) { - nut_info_packet_t info = { 0 }; +static int get_packet(nut_context_tt * nut, nut_packet_tt * pd, int * saw_syncpoint) { + nut_info_packet_tt info = { 0 }; uint64_t tmp; int err = 0, after_sync = 0, checksum = 0, flags, i; off_t start; @@ -769,8 +769,8 @@ err_out: return err; } -static void push_frame(nut_context_t * nut, nut_packet_t * pd) { - stream_context_t * sc = &nut->sc[pd->stream]; +static void push_frame(nut_context_tt * nut, nut_packet_tt * pd) { + stream_context_tt * sc = &nut->sc[pd->stream]; sc->last_pts = pd->pts; sc->last_dts = get_dts(sc->sh.decode_delay, sc->pts_cache, pd->pts); if (pd->flags & NUT_FLAG_KEY && !sc->last_key) sc->last_key = pd->pts + 1; @@ -778,7 +778,7 @@ static void push_frame(nut_context_t * n else sc->eor = 0; } -static int find_main_headers(nut_context_t * nut) { +static int find_main_headers(nut_context_tt * nut) { int err = 0; uint64_t tmp; int len = PREALLOC_SIZE; @@ -845,7 +845,7 @@ err_out: return err; } -static int find_syncpoint(nut_context_t * nut, syncpoint_t * res, int backwards, off_t stop) { +static int find_syncpoint(nut_context_tt * nut, syncpoint_tt * res, int backwards, off_t stop) { int read; int err = 0; uint64_t tmp; @@ -862,7 +862,7 @@ retry: tmp = (tmp << 8) | *(nut->i->buf_ptr++); if (tmp != SYNCPOINT_STARTCODE) continue; if (res) { - input_buffer_t itmp, * tmp = new_mem_buffer(&itmp); + input_buffer_tt itmp, * tmp = new_mem_buffer(&itmp); res->pos = bctello(nut->i) - 8; if ((err = get_header(nut->i, tmp)) == NUT_ERR_EAGAIN) goto err_out; @@ -904,9 +904,9 @@ err_out: return err; } -static int smart_find_syncpoint(nut_context_t * nut, syncpoint_t * sp, int backwards, off_t stop) { +static int smart_find_syncpoint(nut_context_tt * nut, syncpoint_tt * sp, int backwards, off_t stop) { struct find_syncpoint_state_s * fss = &nut->find_syncpoint_state; - syncpoint_list_t * sl = &nut->syncpoints; + syncpoint_list_tt * sl = &nut->syncpoints; int i = fss->i, err = 0; off_t pos = fss->i ? fss->pos : bctello(nut->i); @@ -960,7 +960,7 @@ static int smart_find_syncpoint(nut_cont i = tmp + 1; } - memmove(sl->s + begin, sl->s + i, (sl->len - i) * sizeof(syncpoint_t)); + memmove(sl->s + begin, sl->s + i, (sl->len - i) * sizeof(syncpoint_tt)); memmove(sl->pts + begin * nut->stream_count, sl->pts + i * nut->stream_count, (sl->len - i) * nut->stream_count * sizeof(uint64_t)); memmove(sl->eor + begin * nut->stream_count, sl->eor + i * nut->stream_count, (sl->len - i) * nut->stream_count * sizeof(uint64_t)); @@ -989,10 +989,10 @@ err_out: return err; } -int nut_read_next_packet(nut_context_t * nut, nut_packet_t * pd) { +int nut_read_next_packet(nut_context_tt * nut, nut_packet_tt * pd) { int err = 0; if (nut->seek_status) { // in error mode! - syncpoint_t s; + syncpoint_tt s; CHECK(smart_find_syncpoint(nut, &s, 0, 0)); nut->i->buf_ptr = get_buf(nut->i, s.pos); // go back to beginning of syncpoint flush_buf(nut->i); @@ -1019,7 +1019,7 @@ err_out: return err; } -static int get_headers(nut_context_t * nut, int read_info) { +static int get_headers(nut_context_tt * nut, int read_info) { int i, err = 0; uint64_t tmp; @@ -1027,7 +1027,7 @@ static int get_headers(nut_context_t * n assert(tmp == MAIN_STARTCODE); // sanity, get_headers should only be called in this situation CHECK(get_main_header(nut)); - SAFE_CALLOC(nut->alloc, nut->sc, sizeof(stream_context_t), nut->stream_count); + SAFE_CALLOC(nut->alloc, nut->sc, sizeof(stream_context_tt), nut->stream_count); for (i = 0; i < nut->stream_count; i++) nut->sc[i].sh.type = -1; CHECK(get_bytes(nut->i, 8, &tmp)); @@ -1037,8 +1037,8 @@ static int get_headers(nut_context_t * n if (tmp == STREAM_STARTCODE) { CHECK(get_stream_header(nut)); } else if (tmp == INFO_STARTCODE && read_info) { - SAFE_REALLOC(nut->alloc, nut->info, sizeof(nut_info_packet_t), ++nut->info_count + 1); - memset(&nut->info[nut->info_count - 1], 0, sizeof(nut_info_packet_t)); + SAFE_REALLOC(nut->alloc, nut->info, sizeof(nut_info_packet_tt), ++nut->info_count + 1); + memset(&nut->info[nut->info_count - 1], 0, sizeof(nut_info_packet_tt)); CHECK(get_info_header(nut, &nut->info[nut->info_count - 1])); nut->info[nut->info_count].count = -1; } else if (tmp == INDEX_STARTCODE && nut->dopts.read_index&1) { @@ -1060,9 +1060,9 @@ err_out: return err; } -int nut_read_headers(nut_context_t * nut, nut_stream_header_t * s [], nut_info_packet_t * info []) { +int nut_read_headers(nut_context_tt * nut, nut_stream_header_tt * s [], nut_info_packet_tt * info []) { int i, err = 0; - syncpoint_t sp; + syncpoint_tt sp; // step 1 - find headers and load to memory if (!nut->last_headers) CHECK(find_main_headers(nut)); @@ -1113,7 +1113,7 @@ int nut_read_headers(nut_context_t * nut nut->i->buf_ptr = get_buf(nut->i, sp.pos); // rewind to the syncpoint, this is where playback starts... nut->seek_status = 0; - SAFE_CALLOC(nut->alloc, *s, sizeof(nut_stream_header_t), nut->stream_count + 1); + SAFE_CALLOC(nut->alloc, *s, sizeof(nut_stream_header_tt), nut->stream_count + 1); for (i = 0; i < nut->stream_count; i++) (*s)[i] = nut->sc[i].sh; (*s)[i].type = -1; nut->tmp_buffer = (void*)*s; @@ -1124,7 +1124,7 @@ err_out: return err; } -int nut_read_frame(nut_context_t * nut, int * len, uint8_t * buf) { +int nut_read_frame(nut_context_tt * nut, int * len, uint8_t * buf) { int tmp = MIN(*len, nut->i->read_len - (nut->i->buf_ptr - nut->i->buf)); if (tmp) { memcpy(buf, nut->i->buf_ptr, tmp); @@ -1155,12 +1155,12 @@ static off_t seek_interpolate(int max_di return guess; } -static int binary_search_syncpoint(nut_context_t * nut, double time_pos, off_t * start, off_t * end, syncpoint_t * stopper) { +static int binary_search_syncpoint(nut_context_tt * nut, double time_pos, off_t * start, off_t * end, syncpoint_tt * stopper) { int i, err = 0; - syncpoint_t s; + syncpoint_tt s; off_t fake_hi, * guess = &nut->binary_guess; uint64_t timebases[nut->timebase_count]; - syncpoint_list_t * sl = &nut->syncpoints; + syncpoint_list_tt * sl = &nut->syncpoints; int a = 0; for (i = 0; i < nut->timebase_count; i++) timebases[i] = (uint64_t)(time_pos / nut->tb[i].num * nut->tb[i].den); assert(sl->len); // it is impossible for the first syncpoint to not have been read @@ -1181,7 +1181,7 @@ static int binary_search_syncpoint(nut_c for (i = 0; i < sl->len; i++) { TO_PTS(tmp, sl->s[i].pts) - if (timebases[tmp_t] <= tmp_p) break; + if (timebases[tmp_tb] <= tmp_p) break; } if (i == sl->len) { // there isn't any syncpoint bigger than requested @@ -1256,15 +1256,15 @@ err_out: return err; } -static int linear_search_seek(nut_context_t * nut, int backwards, off_t start, off_t end, syncpoint_t * stopper) { - syncpoint_list_t * sl = &nut->syncpoints; +static int linear_search_seek(nut_context_tt * nut, int backwards, off_t start, off_t end, syncpoint_tt * stopper) { + syncpoint_list_tt * sl = &nut->syncpoints; int i, err = 0; off_t min_pos = 0; off_t buf_before = 0; off_t stopper_syncpoint = 0; if (nut->seek_status <= 1) { - syncpoint_t s; + syncpoint_tt s; if (!nut->seek_status) seek_buf(nut->i, start, SEEK_SET); nut->seek_status = 1; // find closest syncpoint by linear search, SHOULD be one pointed to by back_ptr... @@ -1291,7 +1291,7 @@ static int linear_search_seek(nut_contex #define CHECK_break(expr) { if ((err = (expr))) { if (end && err != NUT_ERR_EAGAIN) break; else goto err_out; } } if (!(nut->seek_status & 1)) while (bctello(nut->i) < end || !end) { int saw_syncpoint; - nut_packet_t pd; + nut_packet_tt pd; buf_before = bctello(nut->i); err = get_packet(nut, &pd, &saw_syncpoint); // we're counting on syncpoint cache!! for the good_key later, and stopper_syncpoint @@ -1335,7 +1335,7 @@ static int linear_search_seek(nut_contex off_t back_ptr = stopper->pos - stopper->back_ptr; TO_PTS(stopper, stopper->pts) // only relevant if pts is smaller than stopper, and we passed stopper's back_ptr - if (compare_ts(pd.pts, TO_TB(pd.stream), stopper_p, nut->tb[stopper_t]) < 0 && buf_before >= back_ptr) { + if (compare_ts(pd.pts, TO_TB(pd.stream), stopper_p, nut->tb[stopper_tb]) < 0 && buf_before >= back_ptr) { if (!stopper_syncpoint) nut->sc[pd.stream].state.good_key = 1; else if (nut->sc[pd.stream].state.good_key) { int n = 1; @@ -1378,7 +1378,7 @@ static int linear_search_seek(nut_contex buf_before = bctello(nut->i); while (bctello(nut->i) < min_pos) { - nut_packet_t pd; + nut_packet_tt pd; while ((err = get_packet(nut, &pd, NULL)) == -1); CHECK(err); push_frame(nut, &pd); @@ -1405,11 +1405,11 @@ err_out: return err; } -int nut_seek(nut_context_t * nut, double time_pos, int flags, const int * active_streams) { +int nut_seek(nut_context_tt * nut, double time_pos, int flags, const int * active_streams) { int err = 0; off_t start = 0, end = 0; int backwards = flags & 1 ? time_pos < 0 : 1; - syncpoint_t stopper = { 0, 0, 0, 0, 0 }; + syncpoint_tt stopper = { 0, 0, 0, 0, 0 }; if (!nut->i->isc.seek) return NUT_ERR_NOT_SEEKABLE; @@ -1448,7 +1448,7 @@ int nut_seek(nut_context_t * nut, double } if (nut->syncpoints.s[nut->syncpoints.len-1].seen_next) { - syncpoint_list_t * sl = &nut->syncpoints; + syncpoint_list_tt * sl = &nut->syncpoints; int i; int sync[nut->stream_count]; int good_sync = -2; @@ -1502,7 +1502,7 @@ int nut_seek(nut_context_t * nut, double debug_msg("DONE SEEK\n"); err_out: if (err != NUT_ERR_EAGAIN) { // unless EAGAIN - syncpoint_list_t * sl = &nut->syncpoints; + syncpoint_list_tt * sl = &nut->syncpoints; flush_buf(nut->i); nut->before_seek = 0; nut->dopts.cache_syncpoints &= ~2; @@ -1515,11 +1515,11 @@ err_out: return err; } -nut_context_t * nut_demuxer_init(nut_demuxer_opts_t * dopts) { - nut_context_t * nut; +nut_context_tt * nut_demuxer_init(nut_demuxer_opts_tt * dopts) { + nut_context_tt * nut; - if (dopts->alloc.malloc) nut = dopts->alloc.malloc(sizeof(nut_context_t)); - else nut = malloc(sizeof(nut_context_t)); + if (dopts->alloc.malloc) nut = dopts->alloc.malloc(sizeof(nut_context_tt)); + else nut = malloc(sizeof(nut_context_tt)); if (!nut) return NULL; @@ -1572,7 +1572,7 @@ nut_context_t * nut_demuxer_init(nut_dem return nut; } -void nut_demuxer_uninit(nut_context_t * nut) { +void nut_demuxer_uninit(nut_context_tt * nut) { int i; if (!nut) return; for (i = 0; i < nut->stream_count; i++) { @@ -1586,7 +1586,7 @@ void nut_demuxer_uninit(nut_context_t * nut->alloc->free(nut->syncpoints.pts); nut->alloc->free(nut->syncpoints.eor); while (nut->syncpoints.linked) { - syncpoint_linked_t * s = nut->syncpoints.linked; + syncpoint_linked_tt * s = nut->syncpoints.linked; nut->syncpoints.linked = s->prev; nut->alloc->free(s); } Modified: src/trunk/libnut/framecode.c ============================================================================== --- src/trunk/libnut/framecode.c (original) +++ src/trunk/libnut/framecode.c Thu Dec 11 21:34:43 2008 @@ -7,15 +7,15 @@ #include "libnut.h" #include "priv.h" -typedef nut_frame_table_input_t fti_t; // just a shortcut +typedef nut_frame_table_input_tt fti_tt; // just a shortcut -static int count_streams(const nut_stream_header_t * s) { +static int count_streams(const nut_stream_header_tt * s) { int i; for (i = 0; s[i].type != -1; i++); return i; } -void nut_framecode_generate(const nut_stream_header_t s[], nut_frame_table_input_t fti[256]) { +void nut_framecode_generate(const nut_stream_header_tt s[], nut_frame_table_input_tt fti[256]) { int stream_count = count_streams(s); int i, n = 0, m = 0, tot_con = 0; enum { @@ -29,21 +29,21 @@ void nut_framecode_generate(const nut_st for (i = 0; i < stream_count; i++) consume[i] = e_consume_none; // the basic framecodes. flag, pts, stream, mul, size, count - fti[n++] = (fti_t){ /*invalid 0x00*/ FLAG_INVALID, 0, 0, 1, 0, 1 }; - fti[n++] = (fti_t){ NUT_FLAG_KEY|FLAG_CODED_PTS|FLAG_STREAM_ID|FLAG_SIZE_MSB, 0, 0, 1, 0, 1 }; - fti[n++] = (fti_t){ FLAG_CODED_PTS|FLAG_STREAM_ID|FLAG_SIZE_MSB, 0, 0, 1, 0, 1 }; - fti[n++] = (fti_t){ /*extreme fallback*/ FLAG_CODED, 1, 0, 1, 0, 1 }; + fti[n++] = (fti_tt){ /*invalid 0x00*/ FLAG_INVALID, 0, 0, 1, 0, 1 }; + fti[n++] = (fti_tt){ NUT_FLAG_KEY|FLAG_CODED_PTS|FLAG_STREAM_ID|FLAG_SIZE_MSB, 0, 0, 1, 0, 1 }; + fti[n++] = (fti_tt){ FLAG_CODED_PTS|FLAG_STREAM_ID|FLAG_SIZE_MSB, 0, 0, 1, 0, 1 }; + fti[n++] = (fti_tt){ /*extreme fallback*/ FLAG_CODED, 1, 0, 1, 0, 1 }; for (i = 0; i < stream_count; i++) { if (n + m > 230) break; // that's enough! don't overflow switch (s[i].type) { case NUT_VIDEO_CLASS: - fti[n++] = (fti_t){ NUT_FLAG_KEY| FLAG_SIZE_MSB, 1, i, 1, 0, 1 }; - fti[n++] = (fti_t){ NUT_FLAG_KEY|FLAG_CHECKSUM|FLAG_SIZE_MSB, 1, i, 1, 0, 1 }; - fti[n++] = (fti_t){ FLAG_CODED_PTS|FLAG_SIZE_MSB, 0, i, 1, 0, 1 }; + fti[n++] = (fti_tt){ NUT_FLAG_KEY| FLAG_SIZE_MSB, 1, i, 1, 0, 1 }; + fti[n++] = (fti_tt){ NUT_FLAG_KEY|FLAG_CHECKSUM|FLAG_SIZE_MSB, 1, i, 1, 0, 1 }; + fti[n++] = (fti_tt){ FLAG_CODED_PTS|FLAG_SIZE_MSB, 0, i, 1, 0, 1 }; if (s[i].fourcc_len == 4 && !strncmp((char*)s[i].fourcc, "mp4v", 4)) { - fti[n++] = (fti_t){ 0, 1, i, 7, 6, 1 }; - fti[n++] = (fti_t){ 0, 2, i, 7, 6, 1 }; + fti[n++] = (fti_tt){ 0, 1, i, 7, 6, 1 }; + fti[n++] = (fti_tt){ 0, 2, i, 7, 6, 1 }; consume[i] = e_consume_mpeg4; } else if (s[i].fourcc_len == 4 && !strncmp((char*)s[i].fourcc, "h264", 4)) { consume[i] = e_consume_h264; @@ -52,29 +52,29 @@ void nut_framecode_generate(const nut_st } break; case NUT_AUDIO_CLASS: - fti[n++] = (fti_t){NUT_FLAG_KEY| FLAG_SIZE_MSB, 1, i, 1, 0, 1 }; - fti[n++] = (fti_t){NUT_FLAG_KEY|FLAG_CODED_PTS|FLAG_SIZE_MSB, 0, i, 1, 0, 1 }; + fti[n++] = (fti_tt){NUT_FLAG_KEY| FLAG_SIZE_MSB, 1, i, 1, 0, 1 }; + fti[n++] = (fti_tt){NUT_FLAG_KEY|FLAG_CODED_PTS|FLAG_SIZE_MSB, 0, i, 1, 0, 1 }; if (s[i].fourcc_len == 4 && !strncmp((char*)s[i].fourcc, "mp3 ", 4)) { int j, a[] = {288,336,384,480,576,672,768,960}; for (j = 0; j < sizeof a/sizeof*a; j++) - fti[n++] = (fti_t){ NUT_FLAG_KEY, 1, i, a[j]+1, a[j], 1 }; - fti[n++] = (fti_t){ NUT_FLAG_KEY|FLAG_SIZE_MSB, 1, i, 4, 0, 1 }; - fti[n++] = (fti_t){ NUT_FLAG_KEY|FLAG_SIZE_MSB, 1, i, 4, 2, 1 }; + fti[n++] = (fti_tt){ NUT_FLAG_KEY, 1, i, a[j]+1, a[j], 1 }; + fti[n++] = (fti_tt){ NUT_FLAG_KEY|FLAG_SIZE_MSB, 1, i, 4, 0, 1 }; + fti[n++] = (fti_tt){ NUT_FLAG_KEY|FLAG_SIZE_MSB, 1, i, 4, 2, 1 }; } else if (s[i].fourcc_len == 4 && !strncmp((char*)s[i].fourcc, "vrbs", 4)) { - fti[n++] = (fti_t){ NUT_FLAG_KEY|FLAG_SIZE_MSB, 2, i, 1, 0, 1 }; - fti[n++] = (fti_t){ NUT_FLAG_KEY|FLAG_SIZE_MSB, 9, i, 1, 0, 1 }; - fti[n++] = (fti_t){ NUT_FLAG_KEY|FLAG_SIZE_MSB, 23, i, 1, 0, 1 }; - fti[n++] = (fti_t){ NUT_FLAG_KEY|FLAG_SIZE_MSB, 16, i, 6, 0, 6 }; m+=5; + fti[n++] = (fti_tt){ NUT_FLAG_KEY|FLAG_SIZE_MSB, 2, i, 1, 0, 1 }; + fti[n++] = (fti_tt){ NUT_FLAG_KEY|FLAG_SIZE_MSB, 9, i, 1, 0, 1 }; + fti[n++] = (fti_tt){ NUT_FLAG_KEY|FLAG_SIZE_MSB, 23, i, 1, 0, 1 }; + fti[n++] = (fti_tt){ NUT_FLAG_KEY|FLAG_SIZE_MSB, 16, i, 6, 0, 6 }; m+=5; consume[i] = e_consume_vorbis; } break; case NUT_SUBTITLE_CLASS: - fti[n++] = (fti_t){NUT_FLAG_KEY|FLAG_SIZE_MSB|FLAG_CODED_PTS, 0, i, 5, 0, 5 }; m+=4; - fti[n++] = (fti_t){NUT_FLAG_KEY|NUT_FLAG_EOR| FLAG_CODED_PTS, 0, i, 1, 0, 1 }; + fti[n++] = (fti_tt){NUT_FLAG_KEY|FLAG_SIZE_MSB|FLAG_CODED_PTS, 0, i, 5, 0, 5 }; m+=4; + fti[n++] = (fti_tt){NUT_FLAG_KEY|NUT_FLAG_EOR| FLAG_CODED_PTS, 0, i, 1, 0, 1 }; break; case NUT_USERDATA_CLASS: - fti[n++] = (fti_t){NUT_FLAG_KEY|FLAG_SIZE_MSB|FLAG_CODED_PTS, 0, i, 1, 0, 1 }; - fti[n++] = (fti_t){ FLAG_SIZE_MSB|FLAG_CODED_PTS, 0, i, 1, 0, 1 }; + fti[n++] = (fti_tt){NUT_FLAG_KEY|FLAG_SIZE_MSB|FLAG_CODED_PTS, 0, i, 1, 0, 1 }; + fti[n++] = (fti_tt){ FLAG_SIZE_MSB|FLAG_CODED_PTS, 0, i, 1, 0, 1 }; break; default: assert(0); @@ -93,9 +93,9 @@ void nut_framecode_generate(const nut_st int al1 = al*35/100; int al2 = al*45/100; int al3 = al-al1-al2; - fti[n++] = (fti_t){ FLAG_SIZE_MSB, 1, i, al1, 0, al1 }; m+=al1-1; - fti[n++] = (fti_t){ FLAG_SIZE_MSB, 2, i, al2, 0, al2 }; m+=al2-1; - fti[n++] = (fti_t){ FLAG_SIZE_MSB, -1, i, al3, 0, al3 }; m+=al3-1; + fti[n++] = (fti_tt){ FLAG_SIZE_MSB, 1, i, al1, 0, al1 }; m+=al1-1; + fti[n++] = (fti_tt){ FLAG_SIZE_MSB, 2, i, al2, 0, al2 }; m+=al2-1; + fti[n++] = (fti_tt){ FLAG_SIZE_MSB, -1, i, al3, 0, al3 }; m+=al3-1; break; } case e_consume_h264: { @@ -103,27 +103,27 @@ void nut_framecode_generate(const nut_st int al2 = al*35/100; int al3 = al*20/100; int al4 = al-al1-al2-al3; - fti[n++] = (fti_t){ FLAG_SIZE_MSB, 1, i, al1, 0, al1 }; m+=al1-1; - fti[n++] = (fti_t){ FLAG_SIZE_MSB, 2, i, al2, 0, al2 }; m+=al2-1; - fti[n++] = (fti_t){ FLAG_SIZE_MSB, -1, i, al3, 0, al3 }; m+=al3-1; - fti[n++] = (fti_t){ FLAG_CODED_PTS|FLAG_SIZE_MSB, 0, i, al4, 0, al4 }; m+=al4-1; + fti[n++] = (fti_tt){ FLAG_SIZE_MSB, 1, i, al1, 0, al1 }; m+=al1-1; + fti[n++] = (fti_tt){ FLAG_SIZE_MSB, 2, i, al2, 0, al2 }; m+=al2-1; + fti[n++] = (fti_tt){ FLAG_SIZE_MSB, -1, i, al3, 0, al3 }; m+=al3-1; + fti[n++] = (fti_tt){ FLAG_CODED_PTS|FLAG_SIZE_MSB, 0, i, al4, 0, al4 }; m+=al4-1; break; } case e_consume_video: - fti[n++] = (fti_t){ FLAG_SIZE_MSB, 1, i, al, 0, al }; m+=al-1; + fti[n++] = (fti_tt){ FLAG_SIZE_MSB, 1, i, al, 0, al }; m+=al-1; break; case e_consume_vorbis: { int al1 = al*70/100; int al2 = al-al1; al1 /= 2; al2 /= 2; - fti[n++] = (fti_t){ NUT_FLAG_KEY, 16, i,240+al1,240-al1, al1*2 }; m+=al1*2-1; - fti[n++] = (fti_t){ NUT_FLAG_KEY, 2, i, 65+al2, 65-al2, al2*2 }; m+=al2*2-1; + fti[n++] = (fti_tt){ NUT_FLAG_KEY, 16, i,240+al1,240-al1, al1*2 }; m+=al1*2-1; + fti[n++] = (fti_tt){ NUT_FLAG_KEY, 2, i, 65+al2, 65-al2, al2*2 }; m+=al2*2-1; break; } } } i = 255-n-m; - fti[n++] = (fti_t){ /*invalid 0xFF*/ FLAG_INVALID, 0, 0, i, 0, i }; + fti[n++] = (fti_tt){ /*invalid 0xFF*/ FLAG_INVALID, 0, 0, i, 0, i }; // the final framecode. flag, pts, stream, mul, size, count - fti[n++] = (fti_t){ -1 }; + fti[n++] = (fti_tt){ -1 }; } Modified: src/trunk/libnut/libnut.h ============================================================================== --- src/trunk/libnut/libnut.h (original) +++ src/trunk/libnut/libnut.h Thu Dec 11 21:34:43 2008 @@ -17,7 +17,7 @@ #define NUT_VERSION 2 ///< Version of NUT specification this library implements. /// Stream class values, only one can be set. Higher values are not legal. -enum nut_stream_class_t { +enum nut_stream_class_tt { NUT_VIDEO_CLASS = 0, ///< = 0 NUT_AUDIO_CLASS = 1, ///< = 1 NUT_SUBTITLE_CLASS = 2, ///< = 2 @@ -25,33 +25,33 @@ enum nut_stream_class_t { }; /// frame flags bitfield (several flags may be set at once) -enum nut_frame_flags_t { +enum nut_frame_flags_tt { NUT_FLAG_KEY = 1, ///< Marks a frame as keyframe. NUT_FLAG_EOR = 2, ///< Marks end of relevance for stream. #NUT_FLAG_KEY \b must be set together with this flag. }; /// @} -typedef struct nut_context_s nut_context_t; +typedef struct nut_context_s nut_context_tt; /// memory allocation function pointers \ingroup demuxer muxer typedef struct { void * (*malloc)(size_t size); ///< memory allocation malloc function pointer void * (*realloc)(void *ptr, size_t size); ///< memory allocation realloc function pointer void (*free)(void *ptr); ///< memory allocation free function pointer -} nut_alloc_t; +} nut_alloc_tt; /// timebase struct \ingroup demuxer muxer typedef struct { int num; ///< Example: 1001 int den; ///< Example: 24000 -} nut_timebase_t; +} nut_timebase_tt; /// stream header struct \ingroup demuxer muxer typedef struct { int type; ///< Possible values are enum ::nut_stream_class_t. A value of -1 terminates a stream header array. int fourcc_len; ///< fourcc length uint8_t * fourcc; ///< fourcc in big-endian format - nut_timebase_t time_base; ///< stream timebase + nut_timebase_tt time_base; ///< stream timebase int fixed_fps; ///< denote stream as fixed or variable fps int decode_delay; ///< decode delay of codec in this stream int codec_specific_len; ///< length of codec-specific data @@ -71,7 +71,7 @@ typedef struct { int samplerate_num; ///< audio sample rate, example: 44100 int samplerate_denom; ///< audio sample rate denominator, example: 1 int channel_count; ///< number of audio channels -} nut_stream_header_t; +} nut_stream_header_tt; /// single info field struct \ingroup demuxer muxer typedef struct { @@ -79,20 +79,20 @@ typedef struct { char name[65]; ///< NULL-terminated string, name of info field int64_t val; ///< meaning of value defined by #type int den; ///< Used if #type is "r", #val is the numerator. - nut_timebase_t tb; ///< Used if #type is "t". + nut_timebase_tt tb; ///< Used if #type is "t". uint8_t * data; ///< Used if #type is non-numeric. -} nut_info_field_t; +} nut_info_field_tt; /// single info packet struct \ingroup demuxer muxer typedef struct { int count; ///< number of info fields in #fields. int stream_id_plus1; ///< Zero indicates non-stream-specific info packet. int chapter_id; ///< subsection of the file this info packet applies to - nut_timebase_t chapter_tb; ///< timebase of #chapter_start and #chapter_len + nut_timebase_tt chapter_tb; ///< timebase of #chapter_start and #chapter_len uint64_t chapter_start; ///< start of chapter or complete file uint64_t chapter_len; ///< length of chapter or complete file - nut_info_field_t * fields; ///< Info fields, has #count elements. -} nut_info_packet_t; + nut_info_field_tt * fields; ///< Info fields, has #count elements. +} nut_info_packet_tt; /// single frame packet struct \ingroup demuxer muxer typedef struct { @@ -101,7 +101,7 @@ typedef struct { uint64_t pts; ///< presentation timestamp of frame int flags; ///< frame flags from #nut_frame_flags_t int64_t next_pts; ///< Only used in muxer. Only necessary if nut_write_frame_reorder() is used. -} nut_packet_t; +} nut_packet_tt; @@ -115,8 +115,8 @@ typedef struct { /// output stream struct typedef struct { void * priv; ///< opaque priv pointer to be passed to function calls - int (*write)(void * priv, size_t len, const uint8_t * buf); ///< If NULL, nut_output_stream_t::priv is used as FILE*. -} nut_output_stream_t; + int (*write)(void * priv, size_t len, const uint8_t * buf); ///< If NULL, nut_output_stream_tt::priv is used as FILE*. +} nut_output_stream_tt; /// NUT framecode table input typedef struct { @@ -126,38 +126,38 @@ typedef struct { int mul; ///< multiplier for coded frame size int size; ///< LSB for coded frame size int count; ///< Explicit count of framecode entry, \b should be (mul-size) in almost all cases. -} nut_frame_table_input_t; +} nut_frame_table_input_tt; /// muxer options struct typedef struct { - nut_output_stream_t output; ///< output stream function pointers - nut_alloc_t alloc; ///< memory allocation function pointers + nut_output_stream_tt output; ///< output stream function pointers + nut_alloc_tt alloc; ///< memory allocation function pointers int write_index; ///< whether or not to write an index int realtime_stream; ///< Implies no write_index. int max_distance; ///< Valid values are 32-65536, the recommended value is 32768. Lower values give better seekability and error detection and recovery but cause higher overhead. - nut_frame_table_input_t * fti; ///< Framecode table, may be NULL. -} nut_muxer_opts_t; + nut_frame_table_input_tt * fti; ///< Framecode table, may be NULL. +} nut_muxer_opts_tt; /// Allocates NUT muxer context and writes headers to file. -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_tt * nut_muxer_init(const nut_muxer_opts_tt * mopts, const nut_stream_header_tt s[], const nut_info_packet_tt info[]); /// Deallocates NUT muxer context. -void nut_muxer_uninit(nut_context_t * nut); +void nut_muxer_uninit(nut_context_tt * nut); /// Writes a single frame to a NUT file. -void nut_write_frame(nut_context_t * nut, const nut_packet_t * p, const uint8_t * buf); +void nut_write_frame(nut_context_tt * nut, const nut_packet_tt * p, const uint8_t * buf); /// Writes a single info packet to a NUT file. -void nut_write_info(nut_context_t * nut, const nut_info_packet_t * info); +void nut_write_info(nut_context_tt * nut, const nut_info_packet_tt * info); /// Buffers and sorts a single frame to be written to a NUT file. -void nut_write_frame_reorder(nut_context_t * nut, const nut_packet_t * p, const uint8_t * buf); +void nut_write_frame_reorder(nut_context_tt * nut, const nut_packet_tt * p, const uint8_t * buf); /// Flushes reorder buffer and deallocates NUT muxer context. -void nut_muxer_uninit_reorder(nut_context_t * nut); +void nut_muxer_uninit_reorder(nut_context_tt * nut); /// Creates an optimized framecode table for the NUT main header based on stream info. -void nut_framecode_generate(const nut_stream_header_t s[], nut_frame_table_input_t fti[256]); +void nut_framecode_generate(const nut_stream_header_tt s[], nut_frame_table_input_tt fti[256]); /// @} @@ -176,17 +176,17 @@ typedef struct { off_t (*seek)(void * priv, long long pos, int whence); ///< Input stream seek function, must return position in file after seek. int (*eof)(void * priv); ///< Returns if EOF has been met in stream in case of read error. off_t file_pos; ///< file position at beginning of read -} nut_input_stream_t; +} nut_input_stream_tt; /// demuxer options struct typedef struct { - nut_input_stream_t input; ///< input stream function pointers - nut_alloc_t alloc; ///< memory allocation function pointers + nut_input_stream_tt input; ///< input stream function pointers + nut_alloc_tt alloc; ///< memory allocation function pointers int read_index; ///< Seeks to end-of-file at beginning of playback to search for index. Implies cache_syncpoints. int cache_syncpoints; ///< Improves seekability and error recovery greatly, but costs some memory (0.5MB for very large files). void * info_priv; ///< opaque priv pointer to be passed to #new_info - void (*new_info)(void * priv, nut_info_packet_t * info); ///< Function to be called when info is found mid-stream. May be NULL. -} nut_demuxer_opts_t; + void (*new_info)(void * priv, nut_info_packet_tt * info); ///< Function to be called when info is found mid-stream. May be NULL. +} nut_demuxer_opts_tt; /// Possible errors given from demuxer functions. Only the first 4 errors should ever be returned, the rest are internal. enum nut_errors { @@ -211,25 +211,25 @@ enum nut_errors { }; /// Creates a NUT demuxer context. Does not read any information from file. -nut_context_t * nut_demuxer_init(nut_demuxer_opts_t * dopts); +nut_context_tt * nut_demuxer_init(nut_demuxer_opts_tt * dopts); /// Frees a NUT demuxer context. No other functions can be called after this. -void nut_demuxer_uninit(nut_context_t * nut); +void nut_demuxer_uninit(nut_context_tt * nut); /// Reads headers and index, \b must be called at init. -int nut_read_headers(nut_context_t * nut, nut_stream_header_t * s [], nut_info_packet_t * info []); +int nut_read_headers(nut_context_tt * nut, nut_stream_header_tt * s [], nut_info_packet_tt * info []); /// Gets frame header, must be called before each packet. -int nut_read_next_packet(nut_context_t * nut, nut_packet_t * pd); +int nut_read_next_packet(nut_context_tt * nut, nut_packet_tt * pd); /// Reads just the frame \b data, not the header. -int nut_read_frame(nut_context_t * nut, int * len, uint8_t * buf); +int nut_read_frame(nut_context_tt * nut, int * len, uint8_t * buf); /// Gives human readable description of the error return code of any demuxing function. const char * nut_error(int error); /// Seeks to the requested position in seconds. -int nut_seek(nut_context_t * nut, double time_pos, int flags, const int * active_streams); +int nut_seek(nut_context_tt * nut, double time_pos, int flags, const int * active_streams); /// @} @@ -272,14 +272,14 @@ int nut_seek(nut_context_t * nut, double * \par Example: * \code * char * text = "The Foobar Adventure"; - * nut_info_field_t title = { + * nut_info_field_tt title = { * .type = "UTF-8", * .name = "Title", * .val = strlen(text), * .data = text, * }; * - * nut_info_field_t rational = { + * nut_info_field_tt rational = { * .type = "r", * .name = "X-Value close to Pi", * .val = 355, @@ -288,7 +288,7 @@ int nut_seek(nut_context_t * nut, double * \endcode */ -/*! \var char nut_info_field_t::type[7] +/*! \var char nut_info_field_tt::type[7] * Type of field value * - "v" - integer value * - "s" - signed integer value @@ -298,7 +298,7 @@ int nut_seek(nut_context_t * nut, double * - Other - binary data */ -/*! \var int64_t nut_info_field_t::val +/*! \var int64_t nut_info_field_tt::val * - "v" - integer value * - "s" - integer value * - "r" - numerator of fraction @@ -309,24 +309,24 @@ int nut_seek(nut_context_t * nut, double * terminating NUL (U+0000). */ -/*! \var nut_timebase_t nut_info_field_t::tb +/*! \var nut_timebase_tt nut_info_field_tt::tb * In the muxer case, values of #tb \b must be identical to the * timebase of one of the streams. */ -/*! \var uint8_t * nut_info_field_t::data +/*! \var uint8_t * nut_info_field_tt::data * Even in the case of an UTF-8 string, this data is \b not NULL terminated. * * For the muxer, this value \b must be NULL if info field carries no binary * data. */ -/*! \var int nut_info_packet_t::count +/*! \var int nut_info_packet_tt::count * For arrays of #nut_info_packet_t, the packet with a #count of \a -1 * terminates the array. */ -/*! \var nut_info_packet_t::chapter_id +/*! \var nut_info_packet_tt::chapter_id * A value of 0 indicates that the info packet applies to the complete file. * * Positive values are real chapters. Real chapters must not overlap. The @@ -339,13 +339,13 @@ int nut_seek(nut_context_t * nut, double * of the entire file. */ -/*! \var nut_info_packet_t::chapter_tb +/*! \var nut_info_packet_tt::chapter_tb * When muxing, values #chapter_tb \b must be identical to the timebase of * one of the streams. */ /*! - * \var int nut_frame_table_input_t::flag + * \var int nut_frame_table_input_tt::flag * * This variable is a bitfield. Valid flags are: * - 1 FLAG_KEYFRAME @@ -358,40 +358,40 @@ int nut_seek(nut_context_t * nut, double * - 4096 FLAG_CODED * - 8192 FLAG_INVALID * - * The last entry of nut_frame_table_input_t \b must have flag == -1. + * The last entry of nut_frame_table_input_tt \b must have flag == -1. */ -/*! \fn nut_context_t * nut_muxer_init(const nut_muxer_opts_t * mopts, const nut_stream_header_t s[], const nut_info_packet_t info[]) +/*! \fn nut_context_tt * nut_muxer_init(const nut_muxer_opts_tt * mopts, const nut_stream_header_tt s[], const nut_info_packet_tt info[]) * \param mopts muxer options * \param s Stream header data, terminated by \a type = -1. * \param info Info packet data, terminated by \a count = -1. May be \a NULL. * \return NUT muxer context * - * In case nut_muxer_opts_t::realtime_stream is set, the first packet passed - * to the nut_output_stream_t::write() function will be all of the main + * In case nut_muxer_opts_tt::realtime_stream is set, the first packet passed + * to the nut_output_stream_tt::write() function will be all of the main * headers. This packet must be passed along exactly once with the * beginning of any stream forwarded out. */ -/*! \fn void nut_muxer_uninit(nut_context_t *nut) +/*! \fn void nut_muxer_uninit(nut_context_tt *nut) * \param nut NUT muxer context * - * Optionaly writes index if nut_muxer_opts_t::write_index is set and - * nut_muxer_opts_t::realtime_stream is unset. + * Optionaly writes index if nut_muxer_opts_tt::write_index is set and + * nut_muxer_opts_tt::realtime_stream is unset. * * \warning Must \b not be used directly if nut_write_frame_reorder() was used. * \see nut_muxer_uninit_reorder() */ -/*! \fn void nut_write_frame(nut_context_t * nut, const nut_packet_t * p, const uint8_t * buf) +/*! \fn void nut_write_frame(nut_context_tt * nut, const nut_packet_tt * p, const uint8_t * buf) * \param nut NUT muxer context * \param p information about the frame * \param buf actual frame data * - * If nut_muxer_opts_t::realtime_stream realtime_stream is unset, repeated + * If nut_muxer_opts_tt::realtime_stream realtime_stream is unset, repeated * headers will be written at some positions. Syncpoints will be written in - * accordance to the NUT spec. If nut_muxer_opts_t::realtime_stream is set, - * calling this function will result in a single nut_output_stream_t::write() + * accordance to the NUT spec. If nut_muxer_opts_tt::realtime_stream is set, + * calling this function will result in a single nut_output_stream_tt::write() * call, which will be the full frame NUT packet. If the packet starts with * a syncpoint startcode, it may be used as a start point after giving the * main headers to a new client. @@ -403,16 +403,16 @@ int nut_seek(nut_context_t * nut, double * \sa nut_write_frame_reorder() */ -/*! \fn void nut_write_info(nut_context_t * nut, const nut_info_packet_t * info) +/*! \fn void nut_write_info(nut_context_tt * nut, const nut_info_packet_tt * info) * \param nut NUT muxer context * \param info a single info packet * * The use of this function is \b illegal in non-realtime streams, and will - * do nothing if nut_muxer_opts_t::realtime_stream is not set. The result - * is a single call to nut_output_stream_t::write() with the NUT info packet. + * do nothing if nut_muxer_opts_tt::realtime_stream is not set. The result + * is a single call to nut_output_stream_tt::write() with the NUT info packet. */ -/*! \fn void nut_write_frame_reorder(nut_context_t * nut, const nut_packet_t * p, const uint8_t * buf) +/*! \fn void nut_write_frame_reorder(nut_context_tt * nut, const nut_packet_tt * p, const uint8_t * buf) * \param nut NUT muxer context * \param p information about the frame * \param buf actual frame data @@ -425,14 +425,14 @@ int nut_seek(nut_context_t * nut, double * \sa nut_muxer_uninit_reorder() */ -/*! \fn void nut_muxer_uninit_reorder(nut_context_t * nut) +/*! \fn void nut_muxer_uninit_reorder(nut_context_tt * nut) * \param nut NUT muxer context * * Must be used if nut_write_frame_reorder() was used. * \sa nut_muxer_uninit() */ -/*! \fn void nut_framecode_generate(const nut_stream_header_t s[], nut_frame_table_input_t fti[256]) +/*! \fn void nut_framecode_generate(const nut_stream_header_tt s[], nut_frame_table_input_tt fti[256]) * \param s Stream header data, terminated by \a type = -1. * \param fti Output framecode table data, must be preallocated to 256 entries. * @@ -441,7 +441,7 @@ int nut_seek(nut_context_t * nut, double * "mp3 ", and "vrbs". * * This function is used directly by nut_muxer_init() if - * nut_muxer_opts_t::fti is \a NULL. + * nut_muxer_opts_tt::fti is \a NULL. */ /*! \addtogroup demuxer @@ -458,7 +458,7 @@ int nut_seek(nut_context_t * nut, double * error and only nut_demuxer_uninit() can be called. * * \par NUT_ERR_EAGAIN - * Indicates that not enough data was returned by nut_input_stream_t::read(), + * Indicates that not enough data was returned by nut_input_stream_tt::read(), * but EOF was not reached. Whichever function returned this should be called * again with the exact same parameters when more data is available. * The exception to this is nut_read_frame(), which should be called with @@ -474,15 +474,15 @@ int nut_seek(nut_context_t * nut, double * The only legal operation after a fatal error is nut_demuxer_uninit(). */ -/*! \var size_t (*nut_input_stream_t::read)(void * priv, size_t len, uint8_t * buf) - * If NULL, nut_input_stream_t::priv is used as FILE*, and - * nut_input_stream_t::seek and nut_input_stream_t::eof are ignored. +/*! \var size_t (*nut_input_stream_tt::read)(void * priv, size_t len, uint8_t * buf) + * If NULL, nut_input_stream_tt::priv is used as FILE*, and + * nut_input_stream_tt::seek and nut_input_stream_tt::eof are ignored. */ -/*! \var off_t (*nut_input_stream_t::seek)(void * priv, long long pos, int whence) - * If NULL (and nut_input_stream_t::read is non-NULL), indicates stream is - * unseekable. This implies nut_demuxer_opts_t::read_index and - * nut_demuxer_opts_t::cache_syncpoints to be unset. Any call to +/*! \var off_t (*nut_input_stream_tt::seek)(void * priv, long long pos, int whence) + * If NULL (and nut_input_stream_tt::read is non-NULL), indicates stream is + * unseekable. This implies nut_demuxer_opts_tt::read_index and + * nut_demuxer_opts_tt::cache_syncpoints to be unset. Any call to * nut_seek() with an unseekable stream will yield #NUT_ERR_NOT_SEEKABLE * * Parameter whence must support the following libc defines: @@ -491,11 +491,11 @@ int nut_seek(nut_context_t * nut, double * - SEEK_END - pos is used as offset from end of file */ -/*! \var int (*nut_input_stream_t::eof)(void * priv) +/*! \var int (*nut_input_stream_tt::eof)(void * priv) * Only necessary if stream supports non-blocking mode. * Returns non-zero if stream is at EOF, 0 otherwise. * - * This function is called if nut_input_stream_t::read returns less data + * This function is called if nut_input_stream_tt::read returns less data * read than requested. If it returns zero, then the stream is assumed to * be lacking data and #NUT_ERR_EAGAIN is raised. Otherwise, #NUT_ERR_EOF * is raised. @@ -503,12 +503,12 @@ int nut_seek(nut_context_t * nut, double * If NULL, then any read error is assumed to be caused by EOF. */ -/*! \var off_t nut_input_stream_t::file_pos +/*! \var off_t nut_input_stream_tt::file_pos * Must contain the position in the file at which demuxing begins. Should * usually be zero. */ -/*! \fn int nut_read_headers(nut_context_t * nut, nut_stream_header_t * s [], nut_info_packet_t * info []) +/*! \fn int nut_read_headers(nut_context_tt * nut, nut_stream_header_tt * s [], nut_info_packet_tt * info []) * \param nut NUT demuxer context * \param s Pointer to stream header variable to be set to an array * \param info Pointer to info header variable, may be NULL. @@ -526,7 +526,7 @@ int nut_seek(nut_context_t * nut, double * nut_read_headers() succeeds. */ -/*! \fn int nut_read_next_packet(nut_context_t * nut, nut_packet_t * pd) +/*! \fn int nut_read_next_packet(nut_context_tt * nut, nut_packet_tt * pd) * \param nut NUT demuxer context * \param pd Pointer to frame header struct to be filled with next frame * information. @@ -534,7 +534,7 @@ int nut_seek(nut_context_t * nut, double * After a successful call to nut_read_next_packet(), nut_read_frame() * \b must be called. * - * If nut_demuxer_opts_t::new_info is non-NULL, a new info packet may be + * If nut_demuxer_opts_tt::new_info is non-NULL, a new info packet may be * seen before decoding the frame header and this function pointer will be * called (possibly even several times). * @@ -543,7 +543,7 @@ int nut_seek(nut_context_t * nut, double * the next undamaged frame in the stream. */ -/*! \fn int nut_read_frame(nut_context_t * nut, int * len, uint8_t * buf) +/*! \fn int nut_read_frame(nut_context_tt * nut, int * len, uint8_t * buf) * \param nut NUT demuxer context * \param len length of data left to be read * \param buf buffer to write the frame data @@ -559,14 +559,14 @@ int nut_seek(nut_context_t * nut, double * * \par Example: * \code - * nut_packet_t pd; + * nut_packet_tt pd; * int len = pd.len; * while((err = nut_read_frame(nut, &len, buf+pd.len-len)) == NUT_ERR_EAGAIN) * sleep(1); * \endcode */ -/*! \fn int nut_seek(nut_context_t * nut, double time_pos, int flags, const int * active_streams) +/*! \fn int nut_seek(nut_context_tt * nut, double time_pos, int flags, const int * active_streams) * \param nut NUT demuxer context * \param time_pos position to seek to in seconds * \param flags bitfield with seek options Modified: src/trunk/libnut/muxer.c ============================================================================== --- src/trunk/libnut/muxer.c (original) +++ src/trunk/libnut/muxer.c Thu Dec 11 21:34:43 2008 @@ -11,13 +11,13 @@ static int stream_write(void * priv, siz return fwrite(buf, 1, len, priv); } -static void flush_buf(output_buffer_t * bc) { +static void flush_buf(output_buffer_tt * bc) { assert(bc->osc.write); bc->file_pos += bc->osc.write(bc->osc.priv, bc->buf_ptr - bc->buf, bc->buf); bc->buf_ptr = bc->buf; } -static void ready_write_buf(output_buffer_t * bc, int amount) { +static void ready_write_buf(output_buffer_tt * bc, int amount) { if (bc->write_len - (bc->buf_ptr - bc->buf) > amount) return; if (bc->is_mem) { @@ -35,8 +35,8 @@ static void ready_write_buf(output_buffe } } -static output_buffer_t * new_mem_buffer(nut_alloc_t * alloc) { - output_buffer_t * bc = alloc->malloc(sizeof(output_buffer_t)); +static output_buffer_tt * new_mem_buffer(nut_alloc_tt * alloc) { + output_buffer_tt * bc = alloc->malloc(sizeof(output_buffer_tt)); bc->alloc = alloc; bc->write_len = PREALLOC_SIZE; bc->is_mem = 1; @@ -46,28 +46,28 @@ static output_buffer_t * new_mem_buffer( return bc; } -static output_buffer_t * new_output_buffer(nut_alloc_t * alloc, nut_output_stream_t osc) { - output_buffer_t * bc = new_mem_buffer(alloc); +static output_buffer_tt * new_output_buffer(nut_alloc_tt * alloc, nut_output_stream_tt osc) { + output_buffer_tt * bc = new_mem_buffer(alloc); bc->is_mem = 0; bc->osc = osc; if (!bc->osc.write) bc->osc.write = stream_write; return bc; } -static void free_buffer(output_buffer_t * bc) { +static void free_buffer(output_buffer_tt * bc) { if (!bc) return; if (!bc->is_mem) flush_buf(bc); bc->alloc->free(bc->buf); bc->alloc->free(bc); } -static output_buffer_t * clear_buffer(output_buffer_t * bc) { +static output_buffer_tt * clear_buffer(output_buffer_tt * bc) { assert(bc->is_mem); bc->buf_ptr = bc->buf; return bc; } -static void put_bytes(output_buffer_t * bc, int count, uint64_t val) { +static void put_bytes(output_buffer_tt * bc, int count, uint64_t val) { ready_write_buf(bc, count); for(count--; count >= 0; count--){ *(bc->buf_ptr++) = val >> (8 * count); @@ -81,7 +81,7 @@ static int v_len(uint64_t val) { return i; } -static void put_v(output_buffer_t * bc, uint64_t val) { +static void put_v(output_buffer_tt * bc, uint64_t val) { int i = v_len(val); ready_write_buf(bc, i); for(i = (i-1)*7; i; i-=7) { @@ -90,12 +90,12 @@ static void put_v(output_buffer_t * bc, *(bc->buf_ptr++)= val & 0x7F; } -static void put_s(output_buffer_t * bc, int64_t val) { +static void put_s(output_buffer_tt * bc, int64_t val) { if (val<=0) put_v(bc, -2*val ); else put_v(bc, 2*val-1); } -static void put_data(output_buffer_t * bc, int len, const void * data) { +static void put_data(output_buffer_tt * bc, int len, const void * data) { if (!len) return; assert(data); if (bc->write_len - (bc->buf_ptr - bc->buf) > len || bc->is_mem) { @@ -108,12 +108,12 @@ static void put_data(output_buffer_t * b } } -static void put_vb(output_buffer_t * bc, int len, const void * data) { +static void put_vb(output_buffer_tt * bc, int len, const void * data) { put_v(bc, len); put_data(bc, len, data); } -static void put_header(output_buffer_t * bc, output_buffer_t * in, output_buffer_t * tmp, uint64_t startcode, int index_ptr) { +static void put_header(output_buffer_tt * bc, output_buffer_tt * in, output_buffer_tt * tmp, uint64_t startcode, int index_ptr) { int forward_ptr; assert(in->is_mem); assert(tmp->is_mem); @@ -137,8 +137,8 @@ static void put_header(output_buffer_t * if (startcode != SYNCPOINT_STARTCODE) debug_msg("header/index size: %d\n", (int)(bctello(tmp) + bctello(in))); } -static void put_main_header(nut_context_t * nut) { - output_buffer_t * tmp = clear_buffer(nut->tmp_buffer); +static void put_main_header(nut_context_tt * nut) { + output_buffer_tt * tmp = clear_buffer(nut->tmp_buffer); int i; int flag, fields, timestamp = 0, mul = 1, stream = 0, size, count; @@ -187,9 +187,9 @@ static void put_main_header(nut_context_ put_header(nut->o, tmp, nut->tmp_buffer2, MAIN_STARTCODE, 0); } -static void put_stream_header(nut_context_t * nut, int id) { - output_buffer_t * tmp = clear_buffer(nut->tmp_buffer); - stream_context_t * sc = &nut->sc[id]; +static void put_stream_header(nut_context_tt * nut, int id) { + output_buffer_tt * tmp = clear_buffer(nut->tmp_buffer); + stream_context_tt * sc = &nut->sc[id]; put_v(tmp, id); put_v(tmp, sc->sh.type); @@ -219,8 +219,8 @@ static void put_stream_header(nut_contex put_header(nut->o, tmp, nut->tmp_buffer2, STREAM_STARTCODE, 0); } -static void put_info(nut_context_t * nut, const nut_info_packet_t * info) { - output_buffer_t * tmp = clear_buffer(nut->tmp_buffer); +static void put_info(nut_context_tt * nut, const nut_info_packet_tt * info) { + output_buffer_tt * tmp = clear_buffer(nut->tmp_buffer); int i; put_v(tmp, info->stream_id_plus1); @@ -231,7 +231,7 @@ static void put_info(nut_context_t * nut put_v(tmp, info->count); for(i = 0; i < info->count; i++){ - nut_info_field_t * field = &info->fields[i]; + nut_info_field_tt * field = &info->fields[i]; put_vb(tmp, strlen(field->name), field->name); if (!strcmp(field->type, "v")) { put_s(tmp, field->val); @@ -260,7 +260,7 @@ static void put_info(nut_context_t * nut put_header(nut->o, tmp, nut->tmp_buffer2, INFO_STARTCODE, 0); } -static void put_headers(nut_context_t * nut) { +static void put_headers(nut_context_tt * nut) { int i; nut->last_headers = bctello(nut->o); nut->headers_written++; @@ -270,14 +270,14 @@ static void put_headers(nut_context_t * for (i = 0; i < nut->info_count; i++) put_info(nut, &nut->info[i]); } -static void put_syncpoint(nut_context_t * nut) { - output_buffer_t * tmp = clear_buffer(nut->tmp_buffer); +static void put_syncpoint(nut_context_tt * nut) { + output_buffer_tt * tmp = clear_buffer(nut->tmp_buffer); int i; uint64_t pts = 0; int timebase = 0; int back_ptr = 0; int keys[nut->stream_count]; - syncpoint_list_t * s = &nut->syncpoints; + syncpoint_list_tt * s = &nut->syncpoints; nut->last_syncpoint = bctello(nut->o); @@ -290,7 +290,7 @@ static void put_syncpoint(nut_context_t if (s->alloc_len <= s->len) { s->alloc_len += PREALLOC_SIZE; - s->s = nut->alloc->realloc(s->s, s->alloc_len * sizeof(syncpoint_t)); + s->s = nut->alloc->realloc(s->s, s->alloc_len * sizeof(syncpoint_tt)); 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)); } @@ -317,7 +317,7 @@ static void put_syncpoint(nut_context_t back_ptr = (nut->last_syncpoint - s->s[i].pos) / 16; if (!nut->mopts.write_index) { // clear some syncpoint cache if possible s->len -= i; - memmove(s->s, s->s + i, s->len * sizeof(syncpoint_t)); + memmove(s->s, s->s + i, s->len * sizeof(syncpoint_tt)); memmove(s->pts, s->pts + i * nut->stream_count, s->len * nut->stream_count * sizeof(uint64_t)); memmove(s->eor, s->eor + i * nut->stream_count, s->len * nut->stream_count * sizeof(uint64_t)); } @@ -336,9 +336,9 @@ static void put_syncpoint(nut_context_t nut->sync_overhead += bctello(tmp) + bctello(nut->tmp_buffer2); } -static void put_index(nut_context_t * nut) { - output_buffer_t * tmp = clear_buffer(nut->tmp_buffer); - syncpoint_list_t * s = &nut->syncpoints; +static void put_index(nut_context_tt * nut) { + output_buffer_tt * tmp = clear_buffer(nut->tmp_buffer); + syncpoint_list_tt * s = &nut->syncpoints; int i; uint64_t max_pts = 0; int timebase = 0; @@ -403,8 +403,8 @@ static void put_index(nut_context_t * nu put_header(nut->o, tmp, nut->tmp_buffer2, INDEX_STARTCODE, 1); } -static int frame_header(nut_context_t * nut, output_buffer_t * tmp, const nut_packet_t * fd) { - stream_context_t * sc = &nut->sc[fd->stream]; +static int frame_header(nut_context_tt * nut, output_buffer_tt * tmp, const nut_packet_tt * fd) { + stream_context_tt * sc = &nut->sc[fd->stream]; int i, ftnum = -1, size = 0, coded_pts, coded_flags = 0, msb_pts = (1 << sc->msb_pts_shift); int checksum = 0, pts_delta = (int64_t)fd->pts - (int64_t)sc->last_pts; @@ -455,17 +455,17 @@ static int frame_header(nut_context_t * return size; } -static int add_timebase(nut_context_t * nut, nut_timebase_t tb) { +static int add_timebase(nut_context_tt * nut, nut_timebase_tt tb) { int i; for (i = 0; i < nut->timebase_count; i++) if (compare_ts(1, nut->tb[i], 1, tb) == 0) break; if (i == nut->timebase_count) { - nut->tb = nut->alloc->realloc(nut->tb, sizeof(nut_timebase_t) * ++nut->timebase_count); + nut->tb = nut->alloc->realloc(nut->tb, sizeof(nut_timebase_tt) * ++nut->timebase_count); nut->tb[i] = tb; } return i; } -static void check_header_repetition(nut_context_t * nut) { +static void check_header_repetition(nut_context_tt * nut) { if (nut->mopts.realtime_stream) return; if (bctello(nut->o) >= (1 << 23)) { int i; // ### magic value for header repetition @@ -477,9 +477,9 @@ static void check_header_repetition(nut_ } } -void nut_write_frame(nut_context_t * nut, const nut_packet_t * fd, const uint8_t * buf) { - stream_context_t * sc = &nut->sc[fd->stream]; - output_buffer_t * tmp; +void nut_write_frame(nut_context_tt * nut, const nut_packet_tt * fd, const uint8_t * buf) { + stream_context_tt * sc = &nut->sc[fd->stream]; + output_buffer_tt * tmp; int i; check_header_repetition(nut); @@ -515,7 +515,7 @@ void nut_write_frame(nut_context_t * nut if (nut->mopts.realtime_stream) flush_buf(nut->o); } -void nut_write_info(nut_context_t * nut, const nut_info_packet_t * info) { +void nut_write_info(nut_context_tt * nut, const nut_info_packet_tt * info) { if (!nut->mopts.realtime_stream) return; nut->last_headers = bctello(nut->o); // to force syncpoint writing after the info header @@ -523,14 +523,14 @@ void nut_write_info(nut_context_t * nut, if (nut->mopts.realtime_stream) flush_buf(nut->o); } -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; - nut_frame_table_input_t * fti = mopts->fti, mfti[256]; +nut_context_tt * nut_muxer_init(const nut_muxer_opts_tt * mopts, const nut_stream_header_tt s[], const nut_info_packet_tt info[]) { + nut_context_tt * nut; + nut_frame_table_input_tt * fti = mopts->fti, mfti[256]; int i, n; // TODO check that all input is valid - if (mopts->alloc.malloc) nut = mopts->alloc.malloc(sizeof(nut_context_t)); - else nut = malloc(sizeof(nut_context_t)); + if (mopts->alloc.malloc) nut = mopts->alloc.malloc(sizeof(nut_context_tt)); + else nut = malloc(sizeof(nut_context_tt)); nut->mopts = *mopts; if (nut->mopts.realtime_stream) nut->mopts.write_index = 0; @@ -590,7 +590,7 @@ nut_context_t * nut_muxer_init(const nut for (nut->stream_count = 0; s[nut->stream_count].type >= 0; nut->stream_count++); - nut->sc = nut->alloc->malloc(sizeof(stream_context_t) * nut->stream_count); + nut->sc = nut->alloc->malloc(sizeof(stream_context_tt) * nut->stream_count); nut->tb = NULL; nut->timebase_count = 0; @@ -631,12 +631,12 @@ nut_context_t * nut_muxer_init(const nut if (info) { for (nut->info_count = 0; info[nut->info_count].count >= 0; nut->info_count++); - nut->info = nut->alloc->malloc(sizeof(nut_info_packet_t) * nut->info_count); + nut->info = nut->alloc->malloc(sizeof(nut_info_packet_tt) * nut->info_count); for (i = 0; i < nut->info_count; i++) { int j; nut->info[i] = info[i]; - nut->info[i].fields = nut->alloc->malloc(sizeof(nut_info_field_t) * info[i].count); + nut->info[i].fields = nut->alloc->malloc(sizeof(nut_info_field_tt) * info[i].count); add_timebase(nut, nut->info[i].chapter_tb); for (j = 0; j < info[i].count; j++) { nut->info[i].fields[j] = info[i].fields[j]; @@ -667,7 +667,7 @@ nut_context_t * nut_muxer_init(const nut return nut; } -void nut_muxer_uninit(nut_context_t * nut) { +void nut_muxer_uninit(nut_context_tt * nut) { int i; int total = 0; if (!nut) return; Modified: src/trunk/libnut/priv.h ============================================================================== --- src/trunk/libnut/priv.h (original) +++ src/trunk/libnut/priv.h Thu Dec 11 21:34:43 2008 @@ -45,7 +45,7 @@ #define ABS(a) ((a) > 0 ? (a) : -(a)) typedef struct { - nut_input_stream_t isc; + nut_input_stream_tt isc; int is_mem; uint8_t * buf; uint8_t * buf_ptr; @@ -53,18 +53,18 @@ typedef struct { int read_len; // data in memory off_t file_pos; off_t filesize; - nut_alloc_t * alloc; -} input_buffer_t; + nut_alloc_tt * alloc; +} input_buffer_tt; typedef struct { - nut_output_stream_t osc; + nut_output_stream_tt osc; int is_mem; uint8_t * buf; uint8_t * buf_ptr; int write_len; // allocated memory off_t file_pos; - nut_alloc_t * alloc; -} output_buffer_t; + nut_alloc_tt * alloc; +} output_buffer_tt; typedef struct { uint16_t flags; @@ -73,7 +73,7 @@ typedef struct { int16_t pts_delta; uint8_t reserved; uint8_t stream; -} frame_table_t; +} frame_table_tt; typedef struct { off_t pos; @@ -81,30 +81,30 @@ typedef struct { int back_ptr:30; unsigned int seen_next:1; unsigned int pts_valid:1; -} syncpoint_t; +} syncpoint_tt; -typedef struct syncpoint_linked_s syncpoint_linked_t; +typedef struct syncpoint_linked_s syncpoint_linked_tt; struct syncpoint_linked_s { - syncpoint_linked_t * prev; - syncpoint_t s; + syncpoint_linked_tt * prev; + syncpoint_tt s; uint64_t pts_eor[1]; }; typedef struct { int len; int alloc_len; - syncpoint_t * s; + syncpoint_tt * s; uint64_t * pts; // each elem is stream_count items, +1 to real pts, 0 means there is no key uint64_t * eor; // same as pts, is the pts of last eor in syncpoint region _IF_ eor is set by syncpoint. int cached_pos; - syncpoint_linked_t * linked; // entries are entered in reverse order for speed, points to END of list -} syncpoint_list_t; + syncpoint_linked_tt * linked; // entries are entered in reverse order for speed, points to END of list +} syncpoint_list_tt; typedef struct { - nut_packet_t p; + nut_packet_tt p; uint8_t * buf; int64_t dts; -} reorder_packet_t; +} reorder_packet_tt; typedef struct { int active; @@ -112,7 +112,7 @@ typedef struct { uint64_t old_last_pts; off_t good_key; int pts_higher; // for active streams -} seek_state_t; +} seek_state_tt; typedef struct { uint64_t last_key; // muxer.c, reset to 0 on every keyframe @@ -121,41 +121,41 @@ typedef struct { int msb_pts_shift; int max_pts_distance; int timebase_id; - nut_stream_header_t sh; + nut_stream_header_tt sh; int64_t * pts_cache; int64_t eor; - seek_state_t state; + seek_state_tt state; // reorder.c int64_t next_pts; - reorder_packet_t * packets; + reorder_packet_tt * packets; int num_packets; int64_t * reorder_pts_cache; // debug stuff int overhead; int tot_size; int total_frames; -} stream_context_t; +} stream_context_tt; 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; - output_buffer_t * tmp_buffer2; + nut_muxer_opts_tt mopts; + nut_demuxer_opts_tt dopts; + nut_alloc_tt * alloc; + input_buffer_tt * i; + output_buffer_tt * o; + output_buffer_tt * tmp_buffer; + output_buffer_tt * tmp_buffer2; int timebase_count; - nut_timebase_t * tb; + nut_timebase_tt * tb; int stream_count; - stream_context_t * sc; + stream_context_tt * sc; int info_count; - nut_info_packet_t * info; + nut_info_packet_tt * info; int max_distance; - frame_table_t ft[256]; + frame_table_tt ft[256]; off_t last_syncpoint; // for checking corruption and putting syncpoints, also for back_ptr off_t last_headers; // for header repetition and state for demuxer @@ -166,7 +166,7 @@ struct nut_context_s { off_t binary_guess; double seek_time_pos; - syncpoint_list_t syncpoints; + syncpoint_list_tt syncpoints; struct find_syncpoint_state_s { int i, begin, seeked; off_t pos; @@ -192,7 +192,7 @@ static inline uint32_t crc32(uint8_t * b return crc; } -static inline uint64_t convert_ts(uint64_t sn, nut_timebase_t from, nut_timebase_t to) { +static inline uint64_t convert_ts(uint64_t sn, nut_timebase_tt from, nut_timebase_tt to) { uint64_t ln, d1, d2; ln = (uint64_t)from.num * to.den; d1 = from.den; @@ -200,7 +200,7 @@ static inline uint64_t convert_ts(uint64 return (ln / d1 * sn + (ln%d1) * sn / d1) / d2; } -static inline int compare_ts(uint64_t a, nut_timebase_t at, uint64_t b, nut_timebase_t bt) { +static inline int compare_ts(uint64_t a, nut_timebase_tt at, uint64_t b, nut_timebase_tt bt) { if (convert_ts(a, at, bt) < b) return -1; if (convert_ts(b, bt, at) < a) return 1; return 0; @@ -234,7 +234,7 @@ static inline int gcd(int a, int b) { #define bctello(bc) ((bc)->file_pos + ((bc)->buf_ptr - (bc)->buf)) #define TO_PTS(prefix, pts) \ - int prefix##_t = (pts) % nut->timebase_count; \ + int prefix##_tb = (pts) % nut->timebase_count; \ uint64_t prefix##_p = (pts) / nut->timebase_count; #define TO_DOUBLE(t, pts) ((double)(pts) / nut->tb[t].den * nut->tb[t].num) Modified: src/trunk/libnut/reorder.c ============================================================================== --- src/trunk/libnut/reorder.c (original) +++ src/trunk/libnut/reorder.c Thu Dec 11 21:34:43 2008 @@ -7,7 +7,7 @@ #include "libnut.h" #include "priv.h" -static void shift_frames(nut_context_t * nut, stream_context_t * s, int amount) { +static void shift_frames(nut_context_tt * nut, stream_context_tt * s, int amount) { int i; assert(amount <= s->num_packets); for (i = 0; i < amount; i++) { @@ -17,11 +17,11 @@ static void shift_frames(nut_context_t * 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 = nut->alloc->realloc(s->packets, s->num_packets * sizeof(reorder_packet_t)); + memmove(s->packets, s->packets + amount, s->num_packets * sizeof(reorder_packet_tt)); + s->packets = nut->alloc->realloc(s->packets, s->num_packets * sizeof(reorder_packet_tt)); } -static void flushcheck_frames(nut_context_t * nut) { +static void flushcheck_frames(nut_context_tt * nut) { int change, i; for (i = 0; i < nut->stream_count; i++) { // check if any streams are missing essential info @@ -58,7 +58,7 @@ static void flushcheck_frames(nut_contex } while (change); } -void nut_muxer_uninit_reorder(nut_context_t * nut) { +void nut_muxer_uninit_reorder(nut_context_tt * nut) { int i; if (!nut) return; @@ -73,15 +73,15 @@ void nut_muxer_uninit_reorder(nut_contex nut_muxer_uninit(nut); } -void nut_write_frame_reorder(nut_context_t * nut, const nut_packet_t * p, const uint8_t * buf) { - stream_context_t * s = &nut->sc[p->stream]; +void nut_write_frame_reorder(nut_context_tt * nut, const nut_packet_tt * p, const uint8_t * buf) { + stream_context_tt * s = &nut->sc[p->stream]; if (nut->stream_count < 2) { // do nothing nut_write_frame(nut, p, buf); return; } s->num_packets++; - s->packets = nut->alloc->realloc(s->packets, s->num_packets * sizeof(reorder_packet_t)); + s->packets = nut->alloc->realloc(s->packets, s->num_packets * sizeof(reorder_packet_tt)); 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); Modified: src/trunk/nututils/demux_avi.c ============================================================================== --- src/trunk/nututils/demux_avi.c (original) +++ src/trunk/nututils/demux_avi.c Thu Dec 11 21:34:43 2008 @@ -18,12 +18,12 @@ typedef struct riff_tree_s { struct riff_tree_s * tree; // this is an array (size is 'amount') char * data; int offset; -} riff_tree_t; +} riff_tree_tt; typedef struct { int amount; - riff_tree_t * tree; -} full_riff_tree_t; + riff_tree_tt * tree; +} full_riff_tree_tt; typedef struct { uint8_t wFormatTag[2]; @@ -33,7 +33,7 @@ typedef struct { uint16_t nBlockAlign; uint16_t wBitsPerSample; uint16_t cbSize; -} audio_header_t; +} audio_header_tt; typedef struct { uint32_t biSize; @@ -47,7 +47,7 @@ typedef struct { uint32_t biYPelsPerMeter; uint32_t biClrUsed; uint32_t biClrImportant; -} video_header_t; +} video_header_tt; typedef struct { uint32_t dwMicroSecPerFrame; @@ -64,7 +64,7 @@ typedef struct { uint32_t dwRate; uint32_t dwStart; uint32_t dwLength; -} avi_header_t; +} avi_header_tt; typedef struct { uint8_t fccType[4]; @@ -80,32 +80,32 @@ typedef struct { uint32_t dwQuality; uint32_t dwSampleSize; uint16_t rcframe[4]; -} avi_stream_header_t; +} avi_stream_header_tt; typedef struct { uint8_t ckid[4]; uint32_t dwFlags; uint32_t dwChunkOffset; uint32_t dwChunkLength; -} avi_index_entry_t; +} avi_index_entry_tt; typedef struct { int type; // 0 video, 1 audio - avi_stream_header_t * strh; - video_header_t * video; - audio_header_t * audio; + avi_stream_header_tt * strh; + video_header_tt * video; + audio_header_tt * audio; int extra_len; int last_pts; uint8_t * extra; -} avi_stream_context_t; +} avi_stream_context_tt; struct demuxer_priv_s { FILE * in; - full_riff_tree_t * riff; - stream_t * s; - avi_header_t * avih; - avi_stream_context_t * stream; // this is an array, free this - avi_index_entry_t * index; // this is an array and data + full_riff_tree_tt * riff; + stream_tt * s; + avi_header_tt * avih; + avi_stream_context_tt * stream; // this is an array, free this + avi_index_entry_tt * index; // this is an array and data int packets; int cur; }; @@ -114,7 +114,7 @@ struct demuxer_priv_s { #define READ_16(out, ptr) do { out = ((uint8_t*)ptr)[0] | (((uint8_t*)ptr)[1] << 8); ptr += 2; } while (0) #define READ_32(out, ptr) do { out = ((uint8_t*)ptr)[0] | (((uint8_t*)ptr)[1] << 8) | (((uint8_t*)ptr)[2] << 16) | (((uint8_t*)ptr)[3] << 24); ptr += 4; } while (0) -static void data_to_audio_header(void * data, audio_header_t * out) { +static void data_to_audio_header(void * data, audio_header_tt * out) { uint8_t * p = data; READ_B(out->wFormatTag, p, 2); READ_16(out->nChannels, p); @@ -125,7 +125,7 @@ static void data_to_audio_header(void * READ_16(out->cbSize, p); } -static void data_to_video_header(void * data, video_header_t * out) { +static void data_to_video_header(void * data, video_header_tt * out) { uint8_t * p = data; READ_32(out->biSize, p); READ_32(out->biWidth, p); @@ -140,7 +140,7 @@ static void data_to_video_header(void * READ_32(out->biClrImportant, p); } -static void data_to_avi_header(void * data, avi_header_t * out) { +static void data_to_avi_header(void * data, avi_header_tt * out) { uint8_t * p = data; READ_32(out->dwMicroSecPerFrame, p); READ_32(out->dwMaxBytesPerSec, p); @@ -158,7 +158,7 @@ static void data_to_avi_header(void * da READ_32(out->dwLength, p); } -static void data_to_stream_header(void * data, avi_stream_header_t * out) { +static void data_to_stream_header(void * data, avi_stream_header_tt * out) { uint8_t * p = data; READ_B(out->fccType, p, 4); READ_B(out->fccHandler, p, 4); @@ -178,7 +178,7 @@ static void data_to_stream_header(void * READ_16(out->rcframe[3], p); } -static void data_to_index_entry(void * data, avi_index_entry_t * out) { +static void data_to_index_entry(void * data, avi_index_entry_tt * out) { uint8_t * p = data; READ_B(out->ckid, p, 4); READ_32(out->dwFlags, p); @@ -186,7 +186,7 @@ static void data_to_index_entry(void * d READ_32(out->dwChunkLength, p); } -static int mk_riff_tree(FILE * in, riff_tree_t * tree) { +static int mk_riff_tree(FILE * in, riff_tree_tt * tree) { char lenc[4], * p = lenc; int left; tree->tree = NULL; @@ -210,7 +210,7 @@ static int mk_riff_tree(FILE * in, riff_ while (left > 0) { int err; tree->tree = - realloc(tree->tree, sizeof(riff_tree_t) * (tree->amount+1)); + realloc(tree->tree, sizeof(riff_tree_tt) * (tree->amount+1)); if ((err = mk_riff_tree(in, &tree->tree[tree->amount]))) return err; left -= (tree->tree[tree->amount].len + 8); @@ -227,7 +227,7 @@ static int mk_riff_tree(FILE * in, riff_ return 0; } -static void free_riff_tree(riff_tree_t * tree) { +static void free_riff_tree(riff_tree_tt * tree) { int i; if (!tree) return; @@ -238,27 +238,27 @@ static void free_riff_tree(riff_tree_t * free(tree->data); tree->data = NULL; } -static full_riff_tree_t * init_riff() { - full_riff_tree_t * full = malloc(sizeof(full_riff_tree_t)); +static full_riff_tree_tt * init_riff() { + full_riff_tree_tt * full = malloc(sizeof(full_riff_tree_tt)); full->amount = 0; full->tree = NULL; return full; } -static int get_full_riff_tree(FILE * in, full_riff_tree_t * full) { +static int get_full_riff_tree(FILE * in, full_riff_tree_tt * full) { int err = 0; while (1) { int c; if ((c = fgetc(in)) == EOF) break; ungetc(c, in); - full->tree = realloc(full->tree, sizeof(riff_tree_t) * ++full->amount); + full->tree = realloc(full->tree, sizeof(riff_tree_tt) * ++full->amount); if ((err = mk_riff_tree(in, &full->tree[full->amount - 1]))) goto err_out; } err_out: return err; } -static void uninit_riff(full_riff_tree_t * full) { +static void uninit_riff(full_riff_tree_tt * full) { int i; if (!full) return; for (i = 0; i < full->amount; i++) free_riff_tree(&full->tree[i]); @@ -266,7 +266,7 @@ static void uninit_riff(full_riff_tree_t free(full); } -static int avi_read_stream_header(avi_stream_context_t * stream, riff_tree_t * tree) { +static int avi_read_stream_header(avi_stream_context_tt * stream, riff_tree_tt * tree) { int i; assert(tree->type == 0); assert(strFOURCC(tree->listname) == mmioFOURCC('s','t','r','l')); @@ -274,7 +274,7 @@ static int avi_read_stream_header(avi_st for (i = 0; i < tree->amount; i++) { if (tree->tree[i].type == 1 && !strncmp(tree->tree[i].name, "strh", 4)) { if (tree->tree[i].len != 56) return err_avi_bad_strh_len; - stream->strh = malloc(sizeof(avi_stream_header_t)); + stream->strh = malloc(sizeof(avi_stream_header_tt)); data_to_stream_header(tree->tree[i].data, stream->strh); break; } @@ -288,7 +288,7 @@ static int avi_read_stream_header(avi_st case mmioFOURCC('v','i','d','s'): if (len < 40) return err_avi_bad_vids_len; stream->type = 0; - stream->video = malloc(sizeof(video_header_t)); + stream->video = malloc(sizeof(video_header_tt)); data_to_video_header(tree->tree[i].data, stream->video); stream->extra_len = len - 40; if (len > 40) stream->extra = (uint8_t*)tree->tree[i].data + 40; @@ -296,7 +296,7 @@ static int avi_read_stream_header(avi_st case mmioFOURCC('a','u','d','s'): if (len < 18) return err_avi_bad_auds_len; stream->type = 1; - stream->audio = malloc(sizeof(audio_header_t)); + stream->audio = malloc(sizeof(audio_header_tt)); data_to_audio_header(tree->tree[i].data, stream->audio); stream->extra_len = len - 18; if (len > 18) stream->extra = (uint8_t*)tree->tree[i].data + 18; @@ -312,7 +312,7 @@ static int avi_read_stream_header(avi_st return 0; } -static int avi_read_main_header(demuxer_priv_t * avi, const riff_tree_t * tree) { +static int avi_read_main_header(demuxer_priv_tt * avi, const riff_tree_tt * tree) { int i, tmp = 0, err; assert(tree->type == 0); assert(strFOURCC(tree->listname) == mmioFOURCC('h','d','r','l')); @@ -320,7 +320,7 @@ static int avi_read_main_header(demuxer_ for (i = 0; i < tree->amount; i++) { if (tree->tree[i].type == 1 && !strncmp(tree->tree[i].name, "avih", 4)) { if (tree->tree[i].len != 56) return err_avi_bad_avih_len; - avi->avih = malloc(sizeof(avi_header_t)); + avi->avih = malloc(sizeof(avi_header_tt)); data_to_avi_header(tree->tree[i].data, avi->avih); break; } @@ -328,7 +328,7 @@ static int avi_read_main_header(demuxer_ if (i == tree->amount) return err_avi_no_avih; if (avi->avih->dwStreams > 200) return err_avi_stream_overflow; - avi->stream = malloc(avi->avih->dwStreams * sizeof(avi_stream_context_t)); + avi->stream = malloc(avi->avih->dwStreams * sizeof(avi_stream_context_tt)); for (i = 0; i < avi->avih->dwStreams; i++) { avi->stream[i].video = NULL; avi->stream[i].audio = NULL; @@ -345,8 +345,8 @@ static int avi_read_main_header(demuxer_ return 0; } -static int avi_read_headers(demuxer_priv_t * avi) { - const riff_tree_t * tree; +static int avi_read_headers(demuxer_priv_tt * avi) { + const riff_tree_tt * tree; int i, err; if ((err = get_full_riff_tree(avi->in, avi->riff))) return err; tree = &avi->riff->tree[0]; @@ -366,7 +366,7 @@ static int avi_read_headers(demuxer_priv for (j = 0; j < tree->amount; j++) { if (tree->tree[j].type == 1 && !strncmp(tree->tree[j].name, "idx1", 4)) { avi->packets = tree->tree[j].len / 16; - avi->index = calloc(avi->packets, sizeof(avi_index_entry_t)); + avi->index = calloc(avi->packets, sizeof(avi_index_entry_tt)); for (ii = 0; ii < avi->packets; ii++) { data_to_index_entry((char*)tree->tree[j].data + 16*ii, avi->index + ii); } @@ -386,7 +386,7 @@ static int avi_read_headers(demuxer_priv return 0; } -static int read_headers(demuxer_priv_t * avi, stream_t ** streams) { +static int read_headers(demuxer_priv_tt * avi, stream_tt ** streams) { int i; if ((i = avi_read_headers(avi))) return i; for (i = 0; i < avi->avih->dwStreams; i++) { @@ -408,9 +408,9 @@ static int read_headers(demuxer_priv_t * } } - *streams = avi->s = malloc(sizeof(stream_t) * (avi->avih->dwStreams + 1)); + *streams = avi->s = malloc(sizeof(stream_tt) * (avi->avih->dwStreams + 1)); for (i = 0; i < avi->avih->dwStreams; i++) { - extern demuxer_t avi_demuxer; + extern demuxer_tt avi_demuxer; avi->s[i].stream_id = i; avi->s[i].demuxer = avi_demuxer; avi->s[i].demuxer.priv = avi; @@ -451,10 +451,10 @@ static int read_headers(demuxer_priv_t * return 0; } -static int fill_buffer(demuxer_priv_t * avi) { +static int fill_buffer(demuxer_priv_tt * avi) { char fourcc[4], lenc[4], * plen = lenc; int len; - packet_t p; + packet_tt p; if (ftell(avi->in) & 1) fgetc(avi->in); if (avi->cur >= avi->packets) return -1; @@ -487,8 +487,8 @@ static int fill_buffer(demuxer_priv_t * return 0; } -static demuxer_priv_t * init(FILE * in) { - demuxer_priv_t * avi = malloc(sizeof(demuxer_priv_t)); +static demuxer_priv_tt * init(FILE * in) { + demuxer_priv_tt * avi = malloc(sizeof(demuxer_priv_tt)); avi->avih = NULL; avi->stream = NULL; avi->index = NULL; @@ -499,7 +499,7 @@ static demuxer_priv_t * init(FILE * in) return avi; } -static void uninit(demuxer_priv_t * avi) { +static void uninit(demuxer_priv_tt * avi) { int i, streams = avi->avih ? avi->avih->dwStreams : 0; uninit_riff(avi->riff); if (avi->stream) for (i = 0; i < streams; i++) { @@ -515,7 +515,7 @@ static void uninit(demuxer_priv_t * avi) free(avi); } -demuxer_t avi_demuxer = { +demuxer_tt avi_demuxer = { "avi", init, read_headers, Modified: src/trunk/nututils/demux_ogg.c ============================================================================== --- src/trunk/nututils/demux_ogg.c (original) +++ src/trunk/nututils/demux_ogg.c Thu Dec 11 21:34:43 2008 @@ -8,7 +8,7 @@ #include "nutmerge.h" #define FREAD(file, len, var) do { if (fread((var), 1, (len), (file)) != (len)) return -1; }while(0) -typedef struct ogg_stream_s ogg_stream_t; +typedef struct ogg_stream_s ogg_stream_tt; struct ogg_stream_s { int serial; @@ -18,8 +18,8 @@ struct ogg_stream_s { struct demuxer_priv_s { FILE * in; - ogg_stream_t * os; - stream_t * s; + ogg_stream_tt * os; + stream_tt * s; int nstreams; int stream_count; // when nutmerge_streams was handed to the API ... }; @@ -29,14 +29,14 @@ static struct { enum nutmerge_codecs id; { 0, NULL, 0 } }; -static int find_stream(demuxer_priv_t * ogg, int serial) { - extern demuxer_t ogg_demuxer; +static int find_stream(demuxer_priv_tt * ogg, int serial) { + extern demuxer_tt ogg_demuxer; int i; for (i = 0; i < ogg->nstreams; i++) { if (ogg->os[i].serial == serial) return i; } - ogg->os = realloc(ogg->os, sizeof(ogg_stream_t) * ++ogg->nstreams); - ogg->s = realloc(ogg->s, sizeof(stream_t) * (ogg->nstreams+1)); + ogg->os = realloc(ogg->os, sizeof(ogg_stream_tt) * ++ogg->nstreams); + ogg->s = realloc(ogg->s, sizeof(stream_tt) * (ogg->nstreams+1)); ogg->os[i].serial = serial; ogg->os[i].leftover_buf = NULL; ogg->os[i].leftover = 0; @@ -49,8 +49,8 @@ static int find_stream(demuxer_priv_t * return i; } -static int read_page(demuxer_priv_t * ogg, int * stream) { - ogg_stream_t * os; +static int read_page(demuxer_priv_tt * ogg, int * stream) { + ogg_stream_tt * os; int i, serial, segments; char tmp_header[27]; uint8_t sizes[256]; @@ -73,7 +73,7 @@ static int read_page(demuxer_priv_t * og for (i = 0; i < segments; i++) { len += sizes[i]; if (sizes[i] != 255) { - packet_t p; + packet_tt p; p.buf = malloc(len); p.p.len = len; p.p.stream = *stream; @@ -97,7 +97,7 @@ static int read_page(demuxer_priv_t * og return 0; } -static int read_headers(demuxer_priv_t * ogg, stream_t ** streams) { +static int read_headers(demuxer_priv_tt * ogg, stream_tt ** streams) { int i; int err; @@ -120,7 +120,7 @@ static int read_headers(demuxer_priv_t * return 0; } -static int fill_buffer(demuxer_priv_t * ogg) { +static int fill_buffer(demuxer_priv_tt * ogg) { int err, dummy; if ((err = read_page(ogg, &dummy))) return err; @@ -129,8 +129,8 @@ static int fill_buffer(demuxer_priv_t * return 0; } -static demuxer_priv_t * init(FILE * in) { - demuxer_priv_t * ogg = malloc(sizeof(demuxer_priv_t)); +static demuxer_priv_tt * init(FILE * in) { + demuxer_priv_tt * ogg = malloc(sizeof(demuxer_priv_tt)); ogg->in = in; ogg->os = NULL; ogg->s = NULL; @@ -138,7 +138,7 @@ static demuxer_priv_t * init(FILE * in) return ogg; } -static void uninit(demuxer_priv_t * ogg) { +static void uninit(demuxer_priv_tt * ogg) { int i; for (i = 0; i < ogg->nstreams; i++) free(ogg->os[i].leftover_buf); free(ogg->os); @@ -147,7 +147,7 @@ static void uninit(demuxer_priv_t * ogg) free(ogg); } -demuxer_t ogg_demuxer = { +demuxer_tt ogg_demuxer = { "ogg", init, read_headers, Modified: src/trunk/nututils/framer_mp3.c ============================================================================== --- src/trunk/nututils/framer_mp3.c (original) +++ src/trunk/nututils/framer_mp3.c Thu Dec 11 21:34:43 2008 @@ -4,10 +4,10 @@ #include "nutmerge.h" struct framer_priv_s { - stream_t * stream; + stream_tt * stream; }; -static int get_packet(framer_priv_t * mp, packet_t * p) { +static int get_packet(framer_priv_tt * mp, packet_tt * p) { static const int tabsel_123[2][3][16] = { { {0,32,64,96,128,160,192,224,256,288,320,352,384,416,448,0}, {0,32,48,56, 64, 80, 96,112,128,160,192,224,256,320,384,0}, @@ -62,22 +62,22 @@ static int get_packet(framer_priv_t * mp return 0; } -static int setup_headers(framer_priv_t * mp, nut_stream_header_t * s) { +static int setup_headers(framer_priv_tt * mp, nut_stream_header_tt * s) { *s = mp->stream->sh; return 0; // nothing to do } -static framer_priv_t * init(stream_t * s) { - framer_priv_t * mp = malloc(sizeof(framer_priv_t)); +static framer_priv_tt * init(stream_tt * s) { + framer_priv_tt * mp = malloc(sizeof(framer_priv_tt)); mp->stream = s; return mp; } -static void uninit(framer_priv_t * mp) { +static void uninit(framer_priv_tt * mp) { free(mp); } -framer_t mp3_framer = { +framer_tt mp3_framer = { e_mp3, init, setup_headers, Modified: src/trunk/nututils/framer_mpeg4.c ============================================================================== --- src/trunk/nututils/framer_mpeg4.c (original) +++ src/trunk/nututils/framer_mpeg4.c Thu Dec 11 21:34:43 2008 @@ -4,7 +4,7 @@ #include "nutmerge.h" struct framer_priv_s { - stream_t * stream; + stream_tt * stream; int64_t cur_pts; }; @@ -20,8 +20,8 @@ static int find_frame_type(int len, uint #define CHECK(x) do{ if ((err = (x))) return err; }while(0) -static int get_packet(framer_priv_t * mc, packet_t * p) { - packet_t tmp_p; +static int get_packet(framer_priv_tt * mc, packet_tt * p) { + packet_tt tmp_p; int n = 0; int type, err = 0; @@ -52,23 +52,23 @@ static int get_packet(framer_priv_t * mc return 0; } -static int setup_headers(framer_priv_t * mc, nut_stream_header_t * s) { +static int setup_headers(framer_priv_tt * mc, nut_stream_header_tt * s) { *s = mc->stream->sh; return 0; // nothing to do } -static framer_priv_t * init(stream_t * s) { - framer_priv_t * mc = malloc(sizeof(framer_priv_t)); +static framer_priv_tt * init(stream_tt * s) { + framer_priv_tt * mc = malloc(sizeof(framer_priv_tt)); mc->stream = s; mc->cur_pts = 0; return mc; } -static void uninit(framer_priv_t * mc) { +static void uninit(framer_priv_tt * mc) { free(mc); } -framer_t mpeg4_framer = { +framer_tt mpeg4_framer = { e_mpeg4, init, setup_headers, Modified: src/trunk/nututils/framer_vorbis.c ============================================================================== --- src/trunk/nututils/framer_vorbis.c (original) +++ src/trunk/nututils/framer_vorbis.c Thu Dec 11 21:34:43 2008 @@ -6,7 +6,7 @@ struct framer_priv_s { int blocksize[2]; - stream_t * stream; + stream_tt * stream; int mode_count; int * modes; uint8_t * codec_specific; @@ -31,9 +31,9 @@ typedef struct bit_packer_s { int pos; int left; uint8_t * buf_ptr; -} bit_packer_t; +} bit_packer_tt; -static int get_bits(bit_packer_t * bp, int bits, uint64_t * res) { +static int get_bits(bit_packer_tt * bp, int bits, uint64_t * res) { uint64_t val = 0; int pos = 0; bp->left -= bits; @@ -65,13 +65,13 @@ static int get_bits(bit_packer_t * bp, i #define CHECK(x) do{ if ((err = (x))) goto err_out; }while(0) -static int setup_headers(framer_priv_t * vc, nut_stream_header_t * s) { - bit_packer_t bp; +static int setup_headers(framer_priv_tt * vc, nut_stream_header_tt * s) { + bit_packer_tt bp; uint64_t num; int i, err = 0, pd_read = 0; int channels, sample_rate, codec_specific_len; uint8_t * p; - packet_t pd[3]; + packet_tt pd[3]; // need first 3 packets - TODO - support working directly from good codec_specific instead of Ogg crap CHECK(get_stream_packet(vc->stream, &pd[0])); pd_read++; @@ -283,8 +283,8 @@ err_out: return err; } -static int get_packet(framer_priv_t * vc, packet_t * p) { - bit_packer_t bp; +static int get_packet(framer_priv_tt * vc, packet_tt * p) { + bit_packer_tt bp; uint64_t num; int64_t last_pts = MAX(vc->pts, 0); // -1 is not valid int mode, err = 0; @@ -319,8 +319,8 @@ err_out: return err == err_vorbis_header ? err_vorbis_packet : err; } -static framer_priv_t * init(stream_t * s) { - framer_priv_t * vc = malloc(sizeof(framer_priv_t)); +static framer_priv_tt * init(stream_tt * s) { + framer_priv_tt * vc = malloc(sizeof(framer_priv_tt)); vc->stream = s; vc->modes = NULL; vc->codec_specific = NULL; @@ -328,13 +328,13 @@ static framer_priv_t * init(stream_t * s return vc; } -static void uninit(framer_priv_t * vc) { +static void uninit(framer_priv_tt * vc) { free(vc->modes); free(vc->codec_specific); free(vc); } -framer_t vorbis_framer = { +framer_tt vorbis_framer = { e_vorbis, init, setup_headers, Modified: src/trunk/nututils/nutindex.c ============================================================================== --- src/trunk/nututils/nutindex.c (original) +++ src/trunk/nututils/nutindex.c Thu Dec 11 21:34:43 2008 @@ -43,15 +43,15 @@ typedef struct { int write_len; // allocated memory off_t file_pos; FILE * out; -} output_buffer_t; +} output_buffer_tt; -static void flush_out_buf(output_buffer_t * bc) { +static void flush_out_buf(output_buffer_tt * bc) { assert(!bc->is_mem); bc->file_pos += fwrite(bc->buf, 1, bc->buf_ptr - bc->buf, bc->out); bc->buf_ptr = bc->buf; } -static void ready_write_buf(output_buffer_t * bc, int amount) { +static void ready_write_buf(output_buffer_tt * bc, int amount) { if (bc->write_len - (bc->buf_ptr - bc->buf) > amount) return; if (bc->is_mem) { @@ -69,14 +69,14 @@ static void ready_write_buf(output_buffe } } -static void put_bytes(output_buffer_t * bc, int count, uint64_t val) { +static void put_bytes(output_buffer_tt * bc, int count, uint64_t val) { ready_write_buf(bc, count); for(count--; count >= 0; count--){ *(bc->buf_ptr++) = val >> (8 * count); } } -static output_buffer_t * new_mem_buffer(output_buffer_t * bc) { +static output_buffer_tt * new_mem_buffer(output_buffer_tt * bc) { bc->write_len = 0; bc->is_mem = 1; bc->file_pos = 0; @@ -84,7 +84,7 @@ static output_buffer_t * new_mem_buffer( return bc; } -static output_buffer_t * new_output_buffer(output_buffer_t * bc, FILE * out) { +static output_buffer_tt * new_output_buffer(output_buffer_tt * bc, FILE * out) { new_mem_buffer(bc); bc->is_mem = 0; bc->out = out; @@ -98,7 +98,7 @@ static int v_len(uint64_t val) { return i; } -static void put_v(output_buffer_t * bc, uint64_t val) { +static void put_v(output_buffer_tt * bc, uint64_t val) { int i = v_len(val); ready_write_buf(bc, i); for(i = (i-1)*7; i; i-=7) { @@ -107,7 +107,7 @@ static void put_v(output_buffer_t * bc, *(bc->buf_ptr++)= val & 0x7F; } -static void put_data(output_buffer_t * bc, int len, const uint8_t * data) { +static void put_data(output_buffer_tt * bc, int len, const uint8_t * data) { if (len + (bc->buf_ptr - bc->buf) < bc->write_len || bc->is_mem) { ready_write_buf(bc, len); memcpy(bc->buf_ptr, data, len); @@ -118,7 +118,7 @@ static void put_data(output_buffer_t * b } } -static void free_out_buffer(output_buffer_t * bc) { +static void free_out_buffer(output_buffer_tt * bc) { if (!bc) return; if (!bc->is_mem) flush_out_buf(bc); free(bc->buf); @@ -134,16 +134,16 @@ typedef struct { int read_len; // data in memory off_t file_pos; off_t filesize; -} input_buffer_t; +} input_buffer_tt; -static void flush_buf(input_buffer_t *bc) { +static void flush_buf(input_buffer_tt *bc) { bc->file_pos += bc->buf_ptr - bc->buf; bc->read_len -= bc->buf_ptr - bc->buf; memmove(bc->buf, bc->buf_ptr, bc->read_len); bc->buf_ptr = bc->buf; } -static int ready_read_buf(input_buffer_t * bc, int amount) { +static int ready_read_buf(input_buffer_tt * bc, int amount) { int pos = (bc->buf_ptr - bc->buf); if (bc->read_len - pos < amount) { amount += 10; @@ -157,7 +157,7 @@ static int ready_read_buf(input_buffer_t return bc->read_len - (bc->buf_ptr - bc->buf); } -static void seek_buf(input_buffer_t * bc, long long pos, int whence) { +static void seek_buf(input_buffer_tt * bc, long long pos, int whence) { if (whence == SEEK_CUR) pos -= bc->read_len - (bc->buf_ptr - bc->buf); fseek(bc->in, pos, whence); bc->file_pos = ftell(bc->in); @@ -166,7 +166,7 @@ static void seek_buf(input_buffer_t * bc if (whence == SEEK_END) bc->filesize = bc->file_pos - pos; } -static input_buffer_t * new_input_buffer(input_buffer_t * bc, FILE * in) { +static input_buffer_tt * new_input_buffer(input_buffer_tt * bc, FILE * in) { bc->read_len = 0; bc->write_len = 0; bc->file_pos = 0; @@ -176,18 +176,18 @@ static input_buffer_t * new_input_buffer return bc; } -static int skip_buffer(input_buffer_t * bc, int len) { +static int skip_buffer(input_buffer_tt * bc, int len) { if (ready_read_buf(bc, len) < len) return 1; bc->buf_ptr += len; return 0; } -static void free_buffer(input_buffer_t * bc) { +static void free_buffer(input_buffer_tt * bc) { if (!bc) return; free(bc->buf); } -static int get_bytes(input_buffer_t * bc, int count, uint64_t * val) { +static int get_bytes(input_buffer_tt * bc, int count, uint64_t * val) { int i; if (ready_read_buf(bc, count) < count) return 1; *val = 0; @@ -197,7 +197,7 @@ static int get_bytes(input_buffer_t * bc return 0; } -static int get_v(input_buffer_t * bc, uint64_t * val) { +static int get_v(input_buffer_tt * bc, uint64_t * val) { int i, len; *val = 0; do { @@ -211,7 +211,7 @@ static int get_v(input_buffer_t * bc, ui return 1; } -static int get_data(input_buffer_t * bc, int len, uint8_t * buf) { +static int get_data(input_buffer_tt * bc, int len, uint8_t * buf) { int tmp = MIN(len, bc->read_len - (bc->buf_ptr - bc->buf)); if (tmp) { memcpy(buf, bc->buf_ptr, tmp); @@ -230,7 +230,7 @@ static int get_data(input_buffer_t * bc, #define CHECK(expr) do { int _a; if ((_a = (expr))) return _a; } while(0) #define GET_V(bc, v) do { uint64_t _tmp; CHECK(get_v((bc), &_tmp)); (v) = _tmp; } while(0) -static int get_header(input_buffer_t * in) { +static int get_header(input_buffer_tt * in) { off_t start = bctello(in) - 8; // startcode int forward_ptr; @@ -245,7 +245,7 @@ static int get_header(input_buffer_t * i return 0; } -static int read_headers(input_buffer_t * in) { +static int read_headers(input_buffer_tt * in) { int len = strlen(ID_STRING) + 1; uint64_t tmp; assert(in->buf == in->buf_ptr); @@ -262,7 +262,7 @@ static int read_headers(input_buffer_t * return 0; } -static int find_copy_index(input_buffer_t * in, output_buffer_t * out, off_t * end) { +static int find_copy_index(input_buffer_tt * in, output_buffer_tt * out, off_t * end) { uint64_t tmp; uint64_t idx_len; uint64_t max_pts, syncpoints; @@ -326,8 +326,8 @@ static int find_copy_index(input_buffer_ int main(int argc, char * argv[]) { FILE * fin = argc>2 ? fopen(argv[1], "rb") : NULL; FILE * fout = argc>2 ? fopen(argv[2], "wb") : NULL; - input_buffer_t iin, * in; - output_buffer_t oout, * out, omem, * mem = new_mem_buffer(&omem); + input_buffer_tt iin, * in; + output_buffer_tt oout, * out, omem, * mem = new_mem_buffer(&omem); off_t end; if (!fin || !fout) { fprintf(stderr, "%s <input-nut-file> <output-nut-file>\n", argv[0]); Modified: src/trunk/nututils/nutmerge.c ============================================================================== --- src/trunk/nututils/nutmerge.c (original) +++ src/trunk/nututils/nutmerge.c Thu Dec 11 21:34:43 2008 @@ -6,37 +6,37 @@ FILE * stats = NULL; -extern demuxer_t avi_demuxer; -extern demuxer_t nut_demuxer; -extern demuxer_t ogg_demuxer; +extern demuxer_tt avi_demuxer; +extern demuxer_tt nut_demuxer; +extern demuxer_tt ogg_demuxer; -demuxer_t * ndemuxers[] = { +demuxer_tt * ndemuxers[] = { &avi_demuxer, //&nut_demuxer, &ogg_demuxer, NULL }; -extern framer_t vorbis_framer; -extern framer_t mpeg4_framer; -extern framer_t mp3_framer; +extern framer_tt vorbis_framer; +extern framer_tt mpeg4_framer; +extern framer_tt mp3_framer; -framer_t * nframers[] = { +framer_tt * nframers[] = { &vorbis_framer, &mpeg4_framer, &mp3_framer, NULL }; -void push_packet(stream_t * stream, packet_t * p) { +void push_packet(stream_tt * stream, packet_tt * p) { if (stream->npackets == stream->packets_alloc) { stream->packets_alloc += 20; - stream->packets = realloc(stream->packets, stream->packets_alloc * sizeof(packet_t)); + stream->packets = realloc(stream->packets, stream->packets_alloc * sizeof(packet_tt)); } stream->packets[stream->npackets++] = *p; } -int peek_stream_packet(stream_t * stream, packet_t * p, int n) { +int peek_stream_packet(stream_tt * stream, packet_tt * p, int n) { while (stream->npackets <= n) { int err; if ((err = stream->demuxer.fill_buffer(stream->demuxer.priv))) return err; @@ -45,18 +45,18 @@ int peek_stream_packet(stream_t * stream return 0; } -int get_stream_packet(stream_t * stream, packet_t * p) { +int get_stream_packet(stream_tt * stream, packet_tt * p) { while (!stream->npackets) { int err; if ((err = stream->demuxer.fill_buffer(stream->demuxer.priv))) return err; } *p = stream->packets[0]; stream->npackets--; - memmove(&stream->packets[0], &stream->packets[1], stream->npackets * sizeof(packet_t)); + memmove(&stream->packets[0], &stream->packets[1], stream->npackets * sizeof(packet_tt)); return 0; } -void free_streams(stream_t * streams) { +void free_streams(stream_tt * streams) { int i; if (!streams) return; for (i = 0; streams[i].stream_id >= 0; i++) { @@ -66,7 +66,7 @@ void free_streams(stream_t * streams) { } } -static int pick(stream_t * streams, int stream_count) { +static int pick(stream_tt * streams, int stream_count) { int i, n = 0; for (i = 1; i < stream_count; i++) if (streams[i].npackets > streams[n].npackets) n = i; return n; @@ -74,13 +74,13 @@ static int pick(stream_t * streams, int #define fget_packet(framer, p) (framer).get_packet((framer).priv, p) -static int convert(FILE * out, demuxer_t * demuxer, stream_t * streams, int stream_count) { - nut_context_t * nut = NULL; - nut_stream_header_t nut_stream[stream_count+1]; - nut_muxer_opts_t mopts; - framer_t framers[stream_count]; +static int convert(FILE * out, demuxer_tt * demuxer, stream_tt * streams, int stream_count) { + nut_context_tt * nut = NULL; + nut_stream_header_tt nut_stream[stream_count+1]; + nut_muxer_opts_tt mopts; + framer_tt framers[stream_count]; int i, err = 0; - packet_t p; + packet_tt p; int pts[stream_count]; memset(framers, 0, sizeof framers); @@ -96,7 +96,7 @@ static int convert(FILE * out, demuxer_t } nut_stream[i].type = -1; - mopts.output = (nut_output_stream_t){ .priv = out, .write = NULL }; + mopts.output = (nut_output_stream_tt){ .priv = out, .write = NULL }; mopts.write_index = 1; mopts.realtime_stream = 0; mopts.fti = NULL; @@ -125,8 +125,8 @@ err_out: int main(int argc, char * argv []) { FILE * in = NULL, * out = NULL; - demuxer_t demuxer = { .priv = NULL }; - stream_t * streams; + demuxer_tt demuxer = { .priv = NULL }; + stream_tt * streams; int i, err = 0; const char * extension; Modified: src/trunk/nututils/nutmerge.h ============================================================================== --- src/trunk/nututils/nutmerge.h (original) +++ src/trunk/nututils/nutmerge.h Thu Dec 11 21:34:43 2008 @@ -16,9 +16,9 @@ extern FILE * stats; -typedef struct demuxer_priv_s demuxer_priv_t; -typedef struct framer_priv_s framer_priv_t; -typedef struct stream_s stream_t; +typedef struct demuxer_priv_s demuxer_priv_tt; +typedef struct framer_priv_s framer_priv_tt; +typedef struct stream_s stream_tt; enum nutmerge_codecs { e_vorbis, @@ -27,49 +27,49 @@ enum nutmerge_codecs { }; typedef struct { - nut_packet_t p; + nut_packet_tt p; uint8_t * buf; // the demuxer mallocs this, nutmerge (or framer) eventually frees it -} packet_t; +} packet_tt; typedef struct { char * extension; - demuxer_priv_t * (*init)(FILE * in); + demuxer_priv_tt * (*init)(FILE * in); /// streams is -1 terminated, handled and freed by demuxer - int (*read_headers)(demuxer_priv_t * priv, stream_t ** streams); - int (*fill_buffer)(demuxer_priv_t * priv); - void (*uninit)(demuxer_priv_t * priv); - demuxer_priv_t * priv; -} demuxer_t; + int (*read_headers)(demuxer_priv_tt * priv, stream_tt ** streams); + int (*fill_buffer)(demuxer_priv_tt * priv); + void (*uninit)(demuxer_priv_tt * priv); + demuxer_priv_tt * priv; +} demuxer_tt; typedef struct { enum nutmerge_codecs codec_id; - framer_priv_t * (*init)(stream_t * stream); - int (*setup_headers)(framer_priv_t * priv, nut_stream_header_t * s); // fill 's' - int (*get_packet)(framer_priv_t * priv, packet_t * p); // 'p->buf' is now controlled by caller - void (*uninit)(framer_priv_t * priv); - framer_priv_t * priv; -} framer_t; + framer_priv_tt * (*init)(stream_tt * stream); + int (*setup_headers)(framer_priv_tt * priv, nut_stream_header_tt * s); // fill 's' + int (*get_packet)(framer_priv_tt * priv, packet_tt * p); // 'p->buf' is now controlled by caller + void (*uninit)(framer_priv_tt * priv); + framer_priv_tt * priv; +} framer_tt; struct stream_s { int stream_id; // -1 terminated - demuxer_t demuxer; + demuxer_tt demuxer; enum nutmerge_codecs codec_id; - nut_stream_header_t sh; + nut_stream_header_tt sh; int npackets; int packets_alloc; - packet_t * packets; + packet_tt * packets; }; -void ready_stream(stream_t * streams); // setup default stream info +void ready_stream(stream_tt * streams); // setup default stream info -void push_packet(stream_t * stream, packet_t * p); +void push_packet(stream_tt * stream, packet_tt * p); -int peek_stream_packet(stream_t * stream, packet_t * p, int n); // n = 0 means next packet, n = 1 means 1 after that -int get_stream_packet(stream_t * stream, packet_t * p); +int peek_stream_packet(stream_tt * stream, packet_tt * p, int n); // n = 0 means next packet, n = 1 means 1 after that +int get_stream_packet(stream_tt * stream, packet_tt * p); -void free_streams(stream_t * streams); // all the way to -1 terminated list, not the actual 'streams' though +void free_streams(stream_tt * streams); // all the way to -1 terminated list, not the actual 'streams' though enum nutmerge_errors { err_unexpected_eof = 1,