Author: ods15
Date: Sat Nov 18 12:57:30 2006
New Revision: 233
Modified:
trunk/libnut/demuxer.c
Log:
fix up get_headers() to be more robust and correct by making
it more like
the first loop described in the nut spec
Modified: trunk/libnut/demuxer.c
============================================================
==================
--- trunk/libnut/demuxer.c (original)
+++ trunk/libnut/demuxer.c Sat Nov 18 12:57:30 2006
 -302,15
+302,17
return err;
}
-static int get_stream_header(nut_context_t * nut, int id) {
+static int get_stream_header(nut_context_t * nut) {
input_buffer_t itmp, * tmp = new_mem_buffer(&itmp);
- stream_context_t * sc = &nut->sc[id];
+ stream_context_t * sc;
int i, err = 0;
CHECK(get_header(nut->i, tmp));
GET_V(tmp, i);
- ERROR(i != id, NUT_ERR_BAD_STREAM_ORDER);
+ ERROR(i > nut->stream_count,
NUT_ERR_BAD_STREAM_ORDER);
+ sc = &nut->sc[i];
+ if (sc->sh.type != -1) return 0; // we've already taken
care of this stream
GET_V(tmp, sc->sh.type);
CHECK(get_vb(nut->alloc, tmp,
&sc->sh.fourcc_len, &sc->sh.fourcc));
-337,6
+339,9
GET_V(tmp, sc->sh.channel_count); // ### is channel
count staying in spec
break;
}
+
+ SAFE_CALLOC(nut->alloc, sc->pts_cache,
sizeof(int64_t), sc->sh.decode_delay);
+ for (i = 0; i < sc->sh.decode_delay; i++)
sc->pts_cache[i] = -1;
err_out:
return err;
}
-403,59
+408,6
return err;
}
-static int skip_reserved_headers(nut_context_t * nut,
uint64_t stop_startcode) {
- int err;
- uint64_t tmp;
- CHECK(get_bytes(nut->i, 8, &tmp));
- while (tmp != SYNCPOINT_STARTCODE && tmp !=
stop_startcode) {
- ERROR(tmp >> 56 != 'N', NUT_ERR_NOT_FRAME_NOT_N);
- CHECK(get_header(nut->i, NULL));
- CHECK(get_bytes(nut->i, 8, &tmp));
- }
- nut->i->buf_ptr -= 8;
-err_out:
- return err;
-}
-
-static int get_headers(nut_context_t * nut, int read_info)
{
- int i, err;
- uint64_t tmp;
-
- CHECK(get_bytes(nut->i, 8, &tmp));
- 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);
-
- for (i = 0; i < nut->stream_count; i++) {
- int j;
- CHECK(skip_reserved_headers(nut, STREAM_STARTCODE));
- CHECK(get_bytes(nut->i, 8, &tmp));
- ERROR(tmp != STREAM_STARTCODE,
NUT_ERR_NOSTREAM_STARTCODE);
- CHECK(get_stream_header(nut, i));
- SAFE_CALLOC(nut->alloc, nut->sc[i].pts_cache,
sizeof(int64_t), nut->sc[i].sh.decode_delay);
- for (j = 0; j < nut->sc[i].sh.decode_delay; j++)
nut->sc[i].pts_cache[j] = -1;
- }
- if (read_info) {
- // FIXME this skip_reserved_headers() will skip
INDEX_STARTCODE
- CHECK(skip_reserved_headers(nut, INFO_STARTCODE));
- CHECK(get_bytes(nut->i, 8, &tmp));
- while (tmp == INFO_STARTCODE) {
- nut->info_count++;
- 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));
- CHECK(get_info_header(nut,
&nut->info[nut->info_count - 1]));
- CHECK(skip_reserved_headers(nut, INFO_STARTCODE));
- CHECK(get_bytes(nut->i, 8, &tmp));
- }
- nut->info[nut->info_count].count = -1;
- nut->i->buf_ptr -= 8;
- }
-err_out:
- assert(err != NUT_ERR_EAGAIN); // EAGAIN is illegal here!!
- return err;
-}
-
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;
int i, j, err = 0;
-566,24
+518,20
static int get_index(nut_context_t * nut) {
input_buffer_t itmp, * tmp = new_mem_buffer(&itmp);
- int err = 0;
+ int i, err = 0;
+ uint64_t max_pts;
syncpoint_list_t * sl = &nut->syncpoints;
- uint64_t x;
- int i;
-
- CHECK(get_bytes(nut->i, 8, &x));
- ERROR(x != INDEX_STARTCODE, NUT_ERR_GENERAL_ERROR);
CHECK(get_header(nut->i, tmp));
- GET_V(tmp, x);
+ GET_V(tmp, max_pts);
for (i = 0; i < nut->stream_count; i++) {
- TO_PTS(max, x)
+ TO_PTS(max, max_pts)
nut->sc[i].sh.max_pts = convert_ts(max_p,
nut->tb[max_t], TO_TB(i));
}
- GET_V(tmp, x);
- sl->alloc_len = sl->len = x;
+ 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->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);
-602,6
+550,7
uint64_t last_pts = 0; // all of pts[] array is off by
one. using 0 for last pts is equivalent to -1 in spec.
for (j = 0; j < sl->len; ) {
int type, n, flag;
+ uint64_t x;
GET_V(tmp, x);
type = x & 1;
x >>= 1;
-665,8
+614,12
CHECK(get_bytes(nut->i, 1, &tmp));
break;
case MAIN_STARTCODE:
+ while (tmp != SYNCPOINT_STARTCODE) {
+ ERROR(tmp >> 56 != 'N',
NUT_ERR_NOT_FRAME_NOT_N);
+ CHECK(get_header(nut->i, NULL));
+ CHECK(get_bytes(nut->i, 8, &tmp));
+ }
nut->i->buf_ptr -= 8;
- CHECK(skip_reserved_headers(nut, SYNCPOINT_STARTCODE));
return -1;
case INFO_STARTCODE: if (nut->dopts.new_info
&& !nut->seek_status) {
CHECK(get_info_header(nut, &info));
-784,10
+737,9
if ((err = get_header(nut->i, NULL)) ==
NUT_ERR_EAGAIN) goto err_out;
if (err) { tmp = err = 0; break; } // bad
- if ((err = get_bytes(nut->i, 8, &tmp)) ==
NUT_ERR_EAGAIN) goto err_out;
- assert(!err || err == NUT_ERR_EOF); // the only
possibilities
// EOF is a legal error here - when reading the last
headers in file
- if (err == NUT_ERR_EOF) { err = 0; tmp =
SYNCPOINT_STARTCODE; }
+ if ((err = get_bytes(nut->i, 8, &tmp)) ==
NUT_ERR_EOF) { err = 0; tmp = SYNCPOINT_STARTCODE; }
+ ERROR(err, err); // if get_bytes returns EAGAIN or a
memory error, check for that
} while (tmp != SYNCPOINT_STARTCODE);
if (tmp == SYNCPOINT_STARTCODE) { // success!
nut->last_headers = pos;
-901,25
+853,58
return err;
}
-int nut_read_headers(nut_context_t * nut,
nut_stream_header_t * s [], nut_info_packet_t * info []) {
+static int get_headers(nut_context_t * nut, int read_info)
{
int i, err = 0;
uint64_t tmp;
- syncpoint_t sp;
- if (!nut->sc) { // we already have headers, we were
called just for index
- if (!nut->last_headers) CHECK(find_main_headers(nut));
- CHECK(get_headers(nut, !!info));
+ CHECK(get_bytes(nut->i, 8, &tmp));
+ assert(tmp == MAIN_STARTCODE); // sanity, get_headers
should only be called in this situation
+ CHECK(get_main_header(nut));
- if (nut->dopts.read_index) { // check for index right
after main headers
- CHECK(skip_reserved_headers(nut, INDEX_STARTCODE));
- CHECK(get_bytes(nut->i, 8, &tmp));
- nut->i->buf_ptr -= 8;
- if (tmp == INDEX_STARTCODE) nut->seek_status = 2; //
signals to not seek to find index
- flush_buf(nut->i);
+ SAFE_CALLOC(nut->alloc, nut->sc,
sizeof(stream_context_t), nut->stream_count);
+ for (i = 0; i < nut->stream_count; i++)
nut->sc[i].sh.type = -1;
+
+ CHECK(get_bytes(nut->i, 8, &tmp));
+
+ while (tmp != SYNCPOINT_STARTCODE) {
+ ERROR(tmp >> 56 != 'N', NUT_ERR_NOT_FRAME_NOT_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));
+ 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) {
+ CHECK(get_index(nut)); // usually you don't care about
get_index() errors, but nothing except a memory error can
happen here
+ } else {
+ CHECK(get_header(nut->i, NULL));
}
+ // EOF is a legal error here - when reading the last
headers in file
+ if ((err = get_bytes(nut->i, 8, &tmp)) ==
NUT_ERR_EOF) { tmp = err = 0; break; }
+ ERROR(err, err); // it's just barely possible for
get_bytes to return a memory error, check for that
}
+ if (tmp == SYNCPOINT_STARTCODE) nut->i->buf_ptr -=
8;
+
+ for (i = 0; i < nut->stream_count; i++)
ERROR(nut->sc[i].sh.type == -1,
NUT_ERR_NOSTREAM_STARTCODE);
+
+err_out:
+ assert(err != NUT_ERR_EAGAIN); // EAGAIN is illegal here!!
+ return err;
+}
+
+int nut_read_headers(nut_context_t * nut,
nut_stream_header_t * s [], nut_info_packet_t * info []) {
+ int i, err = 0;
+ syncpoint_t sp;
+
+ // step 1 - find headers and load to memory
+ if (!nut->last_headers) CHECK(find_main_headers(nut));
- if (nut->dopts.read_index & 1) { // we already have
index, we were called just for the final syncpoint search
+ // step 2 - parse headers
+ if (!nut->sc) CHECK(get_headers(nut, !!info));
+
+ // step 3 - search for index if necessary
+ if (nut->dopts.read_index & 1) {
uint64_t idx_ptr;
if (nut->seek_status <= 1) {
if (nut->seek_status == 0) {
-934,17
+919,22
if (nut->dopts.read_index) {
if (nut->seek_status == 1) seek_buf(nut->i,
idx_ptr, SEEK_SET);
nut->seek_status = 2;
- // only EAGAIN from get_index is interesting
- if ((err = get_index(nut)) == NUT_ERR_EAGAIN) goto
err_out;
+ CHECK(get_bytes(nut->i, 8, &idx_ptr));
+ if (idx_ptr != INDEX_STARTCODE) err = 1;
+ else {
+ // only EAGAIN from get_index is interesting
+ if ((err = get_index(nut)) == NUT_ERR_EAGAIN) goto
err_out;
+ }
if (err) nut->dopts.read_index = 0;
else nut->dopts.read_index = 2;
err = 0;
}
- if (nut->before_seek) seek_buf(nut->i,
nut->before_seek, SEEK_SET);
+ if (nut->before_seek && nut->last_headers
<= 1024) seek_buf(nut->i, nut->before_seek,
SEEK_SET);
nut->before_seek = 0;
+ nut->seek_status = 0;
}
- // last step - find the first syncpoint in file
+ // step 4 - find the first syncpoint in file
if (nut->last_headers > 1024 &&
!nut->seek_status) {
// the headers weren't found in begginning of file
assert(nut->i->isc.seek);
_______________________________________________
NUT-devel mailing list
NUT-develmplayerhq.hu
http://lists.mplayerhq.hu/mailman/listinfo/nut-devel
|