Author: ods15
Date: Thu Nov 16 07:59:44 2006
New Revision: 214
Modified:
trunk/libnut/demuxer.c
trunk/libnut/libnut.h
trunk/libnut/priv.h
Log:
change all error numbers to be public, rename to NUT_ERR_*,
and remove the negative mess
Modified: trunk/libnut/demuxer.c
============================================================
==================
--- trunk/libnut/demuxer.c (original)
+++ trunk/libnut/demuxer.c Thu Nov 16 07:59:44 2006
 -66,9
+66,9
}
static int buf_eof(input_buffer_t * bc) {
- if (bc->is_mem) return -ERR_BAD_EOF;
- if (!bc->isc.eof || bc->isc.eof(bc->isc.priv))
return 1;
- return 2;
+ if (bc->is_mem) return NUT_ERR_BAD_EOF;
+ 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) {
-135,7
+135,7
len = ready_read_buf(bc, 16);
for (i = 0; i < len; i++) if (*bc->buf_ptr++ !=
0x80) break;
- if (i == len) { if (len >= 16 &&
!bc->is_mem) return -ERR_VLC_TOO_LONG; }
+ if (i == len) { if (len >= 16 &&
!bc->is_mem) return NUT_ERR_VLC_TOO_LONG; }
else { bc->buf_ptr--; break; }
} while (len >= 16);
-145,7
+145,7
*val = (*val << 7) | (tmp & 0x7F);
if (!(tmp & 0x80)) return 0;
}
- if (len >= 16) return -ERR_VLC_TOO_LONG;
+ if (len >= 16) return NUT_ERR_VLC_TOO_LONG;
else return buf_eof(bc);
}
-186,14
+186,14
#define GET_V(bc, v) do { uint64_t _tmp; CHECK(get_v_((bc),
&_tmp, #v)); (v) = _tmp; } while(0)
#define GET_S(bc, v) do { int64_t _tmp; CHECK(get_s_((bc),
&_tmp, #v)); (v) = _tmp; } while(0)
#define SAFE_CALLOC(alloc, var, a, b) do {
- ERROR(SIZE_MAX/(a) < (b), -ERR_OUT_OF_MEM);
- ERROR(!((var) = (alloc)->malloc((a) * (b))),
-ERR_OUT_OF_MEM);
+ ERROR(SIZE_MAX/(a) < (b), NUT_ERR_OUT_OF_MEM);
+ ERROR(!((var) = (alloc)->malloc((a) * (b))),
NUT_ERR_OUT_OF_MEM);
memset((var), 0, (a) * (b));
} while(0)
#define SAFE_REALLOC(alloc, var, a, b) do {
void * _tmp;
- ERROR(SIZE_MAX/(a) < (b), -ERR_OUT_OF_MEM);
- ERROR(!((_tmp) = (alloc)->realloc((var), (a) * (b))),
-ERR_OUT_OF_MEM);
+ ERROR(SIZE_MAX/(a) < (b), NUT_ERR_OUT_OF_MEM);
+ ERROR(!((_tmp) = (alloc)->realloc((var), (a) * (b))),
NUT_ERR_OUT_OF_MEM);
(var) = _tmp;
} while(0)
-218,8
+218,8
if ((err = get_v(in, &tmp))) return err;
if (!*len) {
*buf = alloc->malloc(tmp);
- if (!*buf) return -ERR_OUT_OF_MEM;
- } else if (*len < tmp) return -ERR_OUT_OF_MEM;
+ if (!*buf) return NUT_ERR_OUT_OF_MEM;
+ } else if (*len < tmp) return NUT_ERR_OUT_OF_MEM;
*len = tmp;
if (get_data(in, *len, *buf) != *len) return buf_eof(in);
return 0;
-233,11
+233,11
GET_V(in, forward_ptr);
if (forward_ptr > 4096) {
CHECK(skip_buffer(in, 4)); // header_checksum
- ERROR(crc32(get_buf(in, start), bctello(in) - start),
-ERR_BAD_CHECKSUM);
+ ERROR(crc32(get_buf(in, start), bctello(in) - start),
NUT_ERR_BAD_CHECKSUM);
}
CHECK(skip_buffer(in, forward_ptr));
- ERROR(crc32(in->buf_ptr - forward_ptr, forward_ptr),
-ERR_BAD_CHECKSUM);
+ ERROR(crc32(in->buf_ptr - forward_ptr, forward_ptr),
NUT_ERR_BAD_CHECKSUM);
if (out) {
assert(out->is_mem);
-257,16
+257,16
CHECK(get_header(nut->i, tmp));
GET_V(tmp, i);
- ERROR(i != NUT_VERSION, -ERR_BAD_VERSION);
+ ERROR(i != NUT_VERSION, NUT_ERR_BAD_VERSION);
GET_V(tmp, nut->stream_count);
GET_V(tmp, nut->max_distance);
if (nut->max_distance > 65536) nut->max_distance
= 65536;
GET_V(tmp, nut->timebase_count);
nut->alloc->free(nut->tb); nut->tb = NULL;
- ERROR(SIZE_MAX/sizeof(nut_timebase_t) <
nut->timebase_count, -ERR_OUT_OF_MEM);
+ 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(!nut->tb, -ERR_OUT_OF_MEM);
+ ERROR(!nut->tb, NUT_ERR_OUT_OF_MEM);
for (i = 0; i < nut->timebase_count; i++) {
GET_V(tmp, nut->tb[i].nom);
GET_V(tmp, nut->tb[i].den);
-314,7
+314,7
CHECK(get_header(nut->i, tmp));
GET_V(tmp, i);
- ERROR(i != id, -ERR_BAD_STREAM_ORDER);
+ ERROR(i != id, NUT_ERR_BAD_STREAM_ORDER);
GET_V(tmp, sc->sh.type);
CHECK(get_vb(nut->alloc, tmp,
&sc->sh.fourcc_len, &sc->sh.fourcc));
-435,7
+435,7
int j;
CHECK(skip_reserved_headers(nut, STREAM_STARTCODE));
CHECK(get_bytes(nut->i, 8, &tmp));
- ERROR(tmp != STREAM_STARTCODE, -ERR_NOSTREAM_STARTCODE);
+ 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;
-453,7
+453,7
nut->i->buf_ptr -= 8;
}
err_out:
- assert(err != 2); // EAGAIN is illegal here!!
+ assert(err != NUT_ERR_EAGAIN); // EAGAIN is illegal here!!
return err;
}
-573,7
+573,7
int i;
CHECK(get_bytes(nut->i, 8, &x));
- ERROR(x != INDEX_STARTCODE, -ERR_GENERAL_ERROR);
+ ERROR(x != INDEX_STARTCODE, NUT_ERR_GENERAL_ERROR);
CHECK(get_header(nut->i, tmp));
-683,7
+683,7
start = bctello(nut->i) - 1;
flags = nut->ft[tmp].flags;
- ERROR(flags & FLAG_INVALID, -ERR_NOT_FRAME_NOT_N);
+ ERROR(flags & FLAG_INVALID, NUT_ERR_NOT_FRAME_NOT_N);
if (flags & FLAG_CODED) {
int coded_flags;
-695,7
+695,7
if (flags & FLAG_STREAM_ID) GET_V(nut->i,
pd->stream);
else pd->stream = nut->ft[tmp].stream;
- ERROR(pd->stream >= nut->stream_count,
-ERR_NOT_FRAME_NOT_N);
+ ERROR(pd->stream >= nut->stream_count,
NUT_ERR_NOT_FRAME_NOT_N);
if (flags & FLAG_CODED_PTS) {
uint64_t coded_pts;
-724,15
+724,15
if (flags & FLAG_CHECKSUM) {
CHECK(skip_buffer(nut->i, 4)); // header_checksum
- ERROR(crc32(nut->i->buf_ptr - (bctello(nut->i) -
start), bctello(nut->i) - start), -ERR_BAD_CHECKSUM);
+ ERROR(crc32(nut->i->buf_ptr - (bctello(nut->i) -
start), bctello(nut->i) - start), NUT_ERR_BAD_CHECKSUM);
checksum = 1;
}
// error checking - max distance
- ERROR(!after_sync && bctello(nut->i) +
pd->len - nut->last_syncpoint >
nut->max_distance, -ERR_MAX_SYNCPOINT_DISTANCE);
- ERROR(!checksum && pd->len >
2*nut->max_distance, -ERR_MAX_DISTANCE);
+ ERROR(!after_sync && bctello(nut->i) +
pd->len - nut->last_syncpoint >
nut->max_distance, NUT_ERR_MAX_SYNCPOINT_DISTANCE);
+ ERROR(!checksum && pd->len >
2*nut->max_distance, NUT_ERR_MAX_DISTANCE);
// error checking - max pts distance
- ERROR(!checksum && ABS((int64_t)pd->pts -
(int64_t)nut->sc[pd->stream].last_pts) >
nut->sc[pd->stream].max_pts_distance,
-ERR_MAX_PTS_DISTANCE);
+ ERROR(!checksum && ABS((int64_t)pd->pts -
(int64_t)nut->sc[pd->stream].last_pts) >
nut->sc[pd->stream].max_pts_distance,
NUT_ERR_MAX_PTS_DISTANCE);
// error checking - out of order dts
for (i = 0; i < nut->stream_count; i++) {
if (nut->sc[i].last_dts == -1) continue;
-740,7
+740,7
fprintf(stderr, "%lld %d (%f) %lld %d (%f)
n",
pd->pts, pd->stream, TO_DOUBLE(pd->stream,
pd->pts),
nut->sc[i].last_dts, i, TO_DOUBLE(i,
nut->sc[i].last_dts));
- ERROR(compare_ts(pd->pts, TO_TB(pd->stream),
nut->sc[i].last_dts, TO_TB(i)) < 0,
-ERR_OUT_OF_ORDER);
+ ERROR(compare_ts(pd->pts, TO_TB(pd->stream),
nut->sc[i].last_dts, TO_TB(i)) < 0,
NUT_ERR_OUT_OF_ORDER);
}
if (saw_syncpoint) *saw_syncpoint = !!after_sync;
-775,7
+775,7
tmp = (tmp << 8) | *(nut->i->buf_ptr++);
if (tmp == MAIN_STARTCODE) break;
}
- ERROR(tmp != MAIN_STARTCODE, -ERR_NO_HEADERS);
+ ERROR(tmp != MAIN_STARTCODE, NUT_ERR_NO_HEADERS);
nut->i->buf_ptr -= 8;
nut->last_headers = bctello(nut->i);
flush_buf(nut->i);
-805,7
+805,7
input_buffer_t itmp, * tmp = new_mem_buffer(&itmp);
res->pos = bctello(nut->i) - 8;
- if ((err = get_header(nut->i, tmp)) == 2) goto
err_out;
+ if ((err = get_header(nut->i, tmp)) ==
NUT_ERR_EAGAIN) goto err_out;
if (err) { err = 0; continue; }
GET_V(tmp, res->pts);
-846,7
+846,7
int nut_read_next_packet(nut_context_t * nut, nut_packet_t
* pd) {
int err = 0;
- ERROR(!nut->last_headers, -ERR_NO_HEADERS); //
paranoia, old API
+ ERROR(!nut->last_headers, NUT_ERR_NO_HEADERS); //
paranoia, old API
if (nut->seek_status) { // in error mode!
syncpoint_t s;
-871,7
+871,7
if (!err) push_frame(nut, pd);
err_out:
- if (err != 2) flush_buf(nut->i); // unless EAGAIN
+ if (err != NUT_ERR_EAGAIN) flush_buf(nut->i); // unless
EAGAIN
else nut->i->buf_ptr = nut->i->buf; // rewind
return err;
}
-914,7
+914,7
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)) == 2) goto err_out;
+ 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;
-934,7
+934,7
nut->tmp_buffer = (void*)*s;
if (info) *info = nut->info;
err_out:
- if (err != 2) flush_buf(nut->i); // unless EAGAIN
+ if (err != NUT_ERR_EAGAIN) flush_buf(nut->i); // unless
EAGAIN
else nut->i->buf_ptr = nut->i->buf; // rewind
return err;
}
-1000,7
+1000,7
CHECK(find_basic_syncpoints(nut));
// sl->len MUST be >=2, which is the first and last
syncpoints in the file
- ERROR(sl->len < 2, -ERR_NOT_SEEKABLE);
+ ERROR(sl->len < 2, NUT_ERR_NOT_SEEKABLE);
for (i = 0; i < sl->len; i++) {
TO_PTS(tmp, sl->s[i].pts)
-1190,7
+1190,7
}
// after ALL this, we ended up in a worse position than
where we were...
- ERROR(!backwards && min_pos <
nut->before_seek, -ERR_NOT_SEEKABLE);
+ ERROR(!backwards && min_pos <
nut->before_seek, NUT_ERR_NOT_SEEKABLE);
// FIXME we're counting on syncpoint cache
dopts.cache_syncpoints
for (i = 1; i < sl->len; i++) if (sl->s[i].pos
> min_pos) break;
-1211,9
+1211,9
}
err_out:
- if (err != 2) { // unless EAGAIN
+ if (err != NUT_ERR_EAGAIN) { // unless EAGAIN
if (err) {
- if (err == -ERR_NOT_SEEKABLE) { // a failed seek - then
go back to before everything started
+ if (err == NUT_ERR_NOT_SEEKABLE) { // a failed seek -
then go back to before everything started
for (i = 0; i < nut->stream_count; i++)
nut->sc[i].last_pts = state[i].old_last_pts;
seek_buf(nut->i, nut->before_seek, SEEK_SET);
} else { // some NUT error, let's just go back to last
good syncpoint
-1238,7
+1238,7
int backwards = flags & 1 ? time_pos < 0 : 1;
syncpoint_t stopper = { 0, 0, 0, 0, 0 };
- if (!nut->i->isc.seek) return -ERR_NOT_SEEKABLE;
+ if (!nut->i->isc.seek) return NUT_ERR_NOT_SEEKABLE;
if (!nut->before_seek) nut->before_seek =
bctello(nut->i);
-1328,7
+1328,7
}
fprintf(stderr, "DONE SEEKn");
err_out:
- if (err != 2) { // unless EAGAIN
+ if (err != NUT_ERR_EAGAIN) { // unless EAGAIN
syncpoint_list_t * sl = &nut->syncpoints;
flush_buf(nut->i);
nut->before_seek = 0;
-1342,7
+1342,7
}
} else {
if (!nut->seek_state) nut->seek_state =
nut->alloc->malloc(sizeof state);
- if (!nut->seek_state) return -ERR_OUT_OF_MEM;
+ if (!nut->seek_state) return NUT_ERR_OUT_OF_MEM;
memcpy(nut->seek_state, state, sizeof state);
}
return err;
-1425,22
+1425,22
}
const char * nut_error(int error) {
- switch((enum errors)error) {
- case ERR_GENERAL_ERROR: return "General
Error.";
- case ERR_BAD_VERSION: return "Bad NUT
Version.";
- case ERR_NOT_FRAME_NOT_N: return "Invalid
Framecode.";
- case ERR_BAD_CHECKSUM: return "Bad Checksum.";
- case ERR_MAX_SYNCPOINT_DISTANCE: return
"max_distance syncpoint";
- case ERR_MAX_DISTANCE: return "max_distance";
- case ERR_NO_HEADERS: return "No headers
found!";
- case ERR_NOT_SEEKABLE: return "Cannot seek to that
position.";
- case ERR_OUT_OF_ORDER: return "out of order
dts";
- case ERR_MAX_PTS_DISTANCE: return "Pts difference
higher than max_pts_distance.";
- case ERR_BAD_STREAM_ORDER: return "Stream headers
are stored in wrong order.";
- case ERR_NOSTREAM_STARTCODE: return "Expected stream
startcode not found.";
- case ERR_BAD_EOF: return "Invalid
forward_ptr!";
- case ERR_VLC_TOO_LONG: return "VLC too long";
- case ERR_OUT_OF_MEM: return "Out of memory";
+ switch((enum nut_errors)error) {
+ case NUT_ERR_GENERAL_ERROR: return "General
Error.";
+ case NUT_ERR_BAD_VERSION: return "Bad NUT
Version.";
+ case NUT_ERR_NOT_FRAME_NOT_N: return "Invalid
Framecode.";
+ case NUT_ERR_BAD_CHECKSUM: return "Bad
Checksum.";
+ case NUT_ERR_MAX_SYNCPOINT_DISTANCE: return
"max_distance syncpoint";
+ case NUT_ERR_MAX_DISTANCE: return
"max_distance";
+ case NUT_ERR_NO_HEADERS: return "No headers
found!";
+ case NUT_ERR_NOT_SEEKABLE: return "Cannot seek to
that position.";
+ case NUT_ERR_OUT_OF_ORDER: return "out of order
dts";
+ case NUT_ERR_MAX_PTS_DISTANCE: return "Pts
difference higher than max_pts_distance.";
+ case NUT_ERR_BAD_STREAM_ORDER: return "Stream
headers are stored in wrong order.";
+ case NUT_ERR_NOSTREAM_STARTCODE: return "Expected
stream startcode not found.";
+ case NUT_ERR_BAD_EOF: return "Invalid
forward_ptr!";
+ case NUT_ERR_VLC_TOO_LONG: return "VLC too
long";
+ case NUT_ERR_OUT_OF_MEM: return "Out of
memory";
}
return NULL;
}
Modified: trunk/libnut/libnut.h
============================================================
==================
--- trunk/libnut/libnut.h (original)
+++ trunk/libnut/libnut.h Thu Nov 16 07:59:44 2006
-119,6
+119,27
typedef struct nut_context_s nut_context_t;
+enum nut_errors {
+ NUT_ERR_NO_ERROR = 0,
+ NUT_ERR_EOF = 1,
+ NUT_ERR_EAGAIN = 2,
+ NUT_ERR_GENERAL_ERROR,
+ NUT_ERR_BAD_VERSION,
+ NUT_ERR_NOT_FRAME_NOT_N,
+ NUT_ERR_BAD_CHECKSUM,
+ NUT_ERR_MAX_SYNCPOINT_DISTANCE,
+ NUT_ERR_MAX_DISTANCE,
+ NUT_ERR_NO_HEADERS,
+ NUT_ERR_NOT_SEEKABLE,
+ NUT_ERR_OUT_OF_ORDER,
+ NUT_ERR_MAX_PTS_DISTANCE,
+ NUT_ERR_VLC_TOO_LONG,
+ NUT_ERR_BAD_STREAM_ORDER,
+ NUT_ERR_NOSTREAM_STARTCODE,
+ NUT_ERR_BAD_EOF,
+ NUT_ERR_OUT_OF_MEM,
+};
+
// Muxer
/** allocs nut context, writes headers to file */
-147,7
+168,7
0 success
1 unexpected or expected EOF.
2 EAGAIN.
-negative number: error, detailed error in nut_error(-1 *
ret);
+other: error, detailed error in nut_error(ret);
All errors except EAGAIN or ERR_NOT_SEEKABLE from nut_seek
are fatal.
The only legal operation after a fatal error is
nut_demuxer_uninit().
Modified: trunk/libnut/priv.h
============================================================
==================
--- trunk/libnut/priv.h (original)
+++ trunk/libnut/priv.h Thu Nov 16 07:59:44 2006
-36,24
+36,6
#define MAX(a,b) ((a) > (b) ? (a) : (b))
#define ABS(a) ((a) > 0 ? (a) : -(a))
-enum errors {
- ERR_GENERAL_ERROR = 1,
- ERR_BAD_VERSION,
- ERR_NOT_FRAME_NOT_N,
- ERR_BAD_CHECKSUM,
- ERR_MAX_SYNCPOINT_DISTANCE,
- ERR_MAX_DISTANCE,
- ERR_NO_HEADERS,
- ERR_NOT_SEEKABLE,
- ERR_OUT_OF_ORDER,
- ERR_MAX_PTS_DISTANCE,
- ERR_VLC_TOO_LONG,
- ERR_BAD_STREAM_ORDER,
- ERR_NOSTREAM_STARTCODE,
- ERR_BAD_EOF,
- ERR_OUT_OF_MEM,
-};
-
typedef struct {
nut_input_stream_t isc;
int is_mem;
_______________________________________________
NUT-devel mailing list
NUT-develmplayerhq.hu
http://lists.mplayerhq.hu/mailman/listinfo/nut-devel
|