Author: ods15 Date: Thu Sep 14 12:10:20 2006 New Revision: 130 Modified: trunk/libnut/demuxer.c trunk/libnut/priv.h Log: deobfuscate linear seeking algo using proper struct fix bug related to find_syncpoint and EAGAIN Modified: trunk/libnut/demuxer.c ============================================================================== --- trunk/libnut/demuxer.c (original) +++ trunk/libnut/demuxer.c Thu Sep 14 12:10:20 2006 @@ -375,7 +375,10 @@ int after_seek = nut->last_syncpoint ? 0 : 1; input_buffer_t itmp, * tmp = new_mem_buffer(&itmp); - nut->last_syncpoint = s.pos = bctello(nut->i) - 8; + s.pos = bctello(nut->i) - 8; + + if (nut->last_syncpoint == s.pos) after_seek = 1; // don't go through the same syncpoint twice + nut->last_syncpoint = s.pos; CHECK(get_header(nut->i, tmp)); @@ -973,26 +976,19 @@ return err; } -static int linear_search_seek(nut_context_t * nut, int backwards, uint64_t * pts, off_t start, off_t end, syncpoint_t * stopper) { +static int linear_search_seek(nut_context_t * nut, int backwards, seek_state_t * state, off_t start, off_t end, syncpoint_t * stopper) { syncpoint_list_t * sl = &nut->syncpoints; int i, err = 0; - off_t good_key[nut->stream_count]; // lsb is "has pts been found bigger than requested pts" off_t min_pos = 0; - uint64_t old_last_pts[nut->stream_count]; off_t buf_before = 0; off_t stopper_syncpoint = 0; - for (i = 0; i < nut->stream_count; i++) { - good_key[i] = nut->seek_state ? nut->seek_state[i].good_key : 0; - old_last_pts[i] = nut->seek_state ? nut->seek_state[i].old_last_pts : nut->sc[i].last_pts; - } - if (nut->seek_status <= 1) { syncpoint_t 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 by back_ptr... - // FIXME EAGAIN you should rewind here + buf_before = bctello(nut->i); CHECK(find_syncpoint(nut, 0, &s, 0)); clear_dts_cache(nut); nut->last_syncpoint = 0; // last_key is invalid @@ -1010,31 +1006,24 @@ } } if (back_ptr > (nut->seek_status>>1)) stopper = NULL; // bad stopper, it points to a different back_ptr FIXME so?.. + if (stopper_syncpoint > bctello(nut->i)) stopper_syncpoint = 0; // don't premature } if (!(nut->seek_status & 1)) while (bctello(nut->i) < end || !end) { int saw_syncpoint; nut_packet_t pd; buf_before = bctello(nut->i); - CHECK(get_packet(nut, &pd, &saw_syncpoint)); // FIXME we're counting on syncpoint cache!! + CHECK(get_packet(nut, &pd, &saw_syncpoint)); // FIXME we're counting on syncpoint cache!! for the good_key later, and stopper_syncpoint if (saw_syncpoint) { - int dont_flush = 0; - if (stopper) { - if ((!stopper_syncpoint && buf_before > stopper->pos - stopper->back_ptr + 15) || stopper_syncpoint == buf_before) { - int n = 1; - stopper_syncpoint = buf_before; - for (i = 0; i < nut->stream_count; i++) { - if (!(pts[i] & 1)) { - if (good_key[i]>>1) n = 0; - else good_key[i] |= 1; // flag that we don't care about this stream - } - } - if (n) break; // no inactive streams, stop now - dont_flush = 1; // give it a chance, we might be able to do this in a single seek - } + if (stopper && !stopper_syncpoint && buf_before > stopper->pos - stopper->back_ptr + 15) { + int n = 1; + stopper_syncpoint = buf_before; + for (i = 0; i < nut->stream_count; i++) if (!state[i].active && state[i].good_key) n = 0; + if (n) break; // no inactive streams have keyframes between stopper and stopper_syncpoint, stop now } - if (!dont_flush) { // flush at every syncpoint + if (buf_before != stopper_syncpoint) { // flush at every syncpoint - except stopper_syncpoint + // give it a chance, we might be able to do this in a single seek int header_size = bctello(nut->i) - buf_before; nut->i->buf_ptr -= header_size; flush_buf(nut->i); @@ -1042,42 +1031,41 @@ } } - if (pts[pd.stream] & 1) { // active stream - if (end && pd.pts > pts[pd.stream]>>1) { + if (state[pd.stream].active) { + if (end && pd.pts > state[pd.stream].pts) { // higher than requested pts int n = 1; - good_key[pd.stream] |= 1; - for (i = 0; i < nut->stream_count; i++) { - if ((pts[i] & 1) && !(good_key[i] & 1)) n = 0; - } + state[pd.stream].pts_higher = 1; + for (i = 0; i < nut->stream_count; i++) if (state[i].active && !state[i].pts_higher) n = 0; if (n) break; // pts for all active streams higher than requested pts } if (pd.flags & NUT_FLAG_KEY) { - if (pd.pts <= pts[pd.stream]>>1) { - good_key[pd.stream] = buf_before<<1; - if (pd.flags & NUT_FLAG_EOR) good_key[pd.stream] = 0; + if (pd.pts <= state[pd.stream].pts) { + state[pd.stream].good_key = buf_before; + if (pd.flags & NUT_FLAG_EOR) state[pd.stream].good_key = 0; } - if (!end && pd.pts >= pts[pd.stream]>>1) { // forward seek end - if (saw_syncpoint) nut->last_syncpoint = 0; + if (!end && pd.pts >= state[pd.stream].pts) { // forward seek end nut->i->buf_ptr -= bctello(nut->i) - buf_before; break; } } - } else if (stopper && pd.flags&NUT_FLAG_KEY && !(good_key[pd.stream]&1)) { + } else if (stopper && pd.flags&NUT_FLAG_KEY) { + off_t back_ptr = stopper->pos - stopper->back_ptr; TO_PTS(stopper, stopper->pts) - if (compare_ts(nut, stopper_p, nut->tb[stopper_t], pd.pts, TO_TB(pd.stream)) > 0) { - good_key[pd.stream] = buf_before<<1; - if (stopper_syncpoint) { + // only relavent if pts is smaller than stopper, and we passed stopper's back_ptr + if (compare_ts(nut, pd.pts, TO_TB(pd.stream), stopper_p, nut->tb[stopper_t]) < 0 && buf_before >= back_ptr) { + if (!stopper_syncpoint) state[pd.stream].good_key = 1; + else if (state[pd.stream].good_key) { int n = 1; - for (i = 0; i < nut->stream_count; i++) { - if (!(pts[i] & 1) && !(good_key[i]&1) && good_key[i]>>1 < stopper_syncpoint) n = 0; - } - // smart linear search stop, keyframe for every inactive stream after stopper_syncpoint + state[pd.stream].good_key = 0; + for (i = 0; i < nut->stream_count; i++) if (!state[i].active && state[i].good_key) n = 0; + // smart linear search stop + // keyframe for every inactive stream (which had a keyframe in stopper area), after stopper_syncpoint if (n) break; } } } // dts higher than requested pts - if (end && peek_dts(nut->sc[pd.stream].sh.decode_delay, nut->sc[pd.stream].pts_cache, pd.pts) > (int64_t)(pts[pd.stream]>>1)) break; + if (end && peek_dts(nut->sc[pd.stream].sh.decode_delay, nut->sc[pd.stream].pts_cache, pd.pts) > (int64_t)state[pd.stream].pts) break; CHECK(skip_buffer(nut->i, pd.len)); push_frame(nut, &pd); @@ -1085,12 +1073,12 @@ if (!end) goto err_out; // forward seek for (i = 0; i < nut->stream_count; i++) { - if (!(pts[i] & 1)) continue; - if (good_key[i]>>1 && (!min_pos || good_key[i]>>1 < min_pos)) min_pos = good_key[i]>>1; + if (!state[i].active) continue; + if (state[i].good_key && (!min_pos || state[i].good_key < min_pos)) min_pos = state[i].good_key; } if (!min_pos) { fprintf(stderr, "BIG FAT WARNING\n"); - for (i = 0; i < nut->stream_count; i++) fprintf(stderr, "%d: %d\n", i, (int)good_key[i]); + for (i = 0; i < nut->stream_count; i++) fprintf(stderr, "%d: %d\n", i, (int)state[i].good_key); min_pos = nut->seek_status >> 1; } @@ -1118,9 +1106,7 @@ if (err != 2) { // unless EAGAIN if (err) { if (err == -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 = old_last_pts[i]; - } + 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 err = 0; @@ -1130,61 +1116,55 @@ clear_dts_cache(nut); } nut->seek_status = 0; - free(nut->seek_state); - nut->seek_state = NULL; - } else { - // for EAGAIN, store state - if (!nut->seek_state) nut->seek_state = malloc(nut->stream_count * 2 * sizeof(*nut->seek_state)); - for (i = 0; i < nut->stream_count; i++) { - nut->seek_state[i].good_key = good_key[i]; - nut->seek_state[i].old_last_pts = old_last_pts[i]; - } - if (buf_before) nut->i->buf_ptr -= bctello(nut->i) - buf_before; // rewind + } else if (buf_before) { + nut->i->buf_ptr -= bctello(nut->i) - buf_before; // rewind + if (nut->i->buf_ptr < nut->i->buf) nut->i->buf_ptr = nut->i->buf; // special case, possible with find_syncpoint } return err; } -static void req_to_pts(nut_context_t * nut, double * time_pos, int flags, uint64_t * pts, const int * active_streams) { - uint64_t orig_pts = 0; - int orig_timebase = 0; - int i; - - for (i = 0; i < nut->stream_count; i++) pts[i] = 0; - if (active_streams) for (i = 0; active_streams[i] != -1; i++) pts[active_streams[i]] = 1; - else for (i = 0; i < nut->stream_count; i++) pts[i] = 1; - - if (flags & 1) { - for (i = 0; i < nut->stream_count; i++) { - uint64_t dts = nut->sc[i].last_dts != -1 ? nut->sc[i].last_dts : nut->sc[i].last_pts; - int FIXME; // this is completely wrong with EAGAIN - if (!pts[i]) continue; - if (compare_ts(nut, orig_pts, nut->tb[orig_timebase], dts, TO_TB(i)) < 0) { - orig_pts = dts; - orig_timebase = nut->sc[i].timebase_id; - } - } - *time_pos += TO_DOUBLE(orig_timebase, orig_pts); - } - if (*time_pos < 0.) *time_pos = 0.; - - for (i = 0; i < nut->stream_count; i++) { - pts[i] |= (uint64_t)(*time_pos / TO_TB(i).nom * TO_TB(i).den) << 1; - } -} - int nut_seek(nut_context_t * nut, double time_pos, int flags, const int * active_streams) { int err = 0; off_t start = 0, end = 0; - uint64_t pts[nut->stream_count]; + seek_state_t state[nut->stream_count]; 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; - req_to_pts(nut, &time_pos, flags, pts, active_streams); - if (!nut->before_seek) nut->before_seek = bctello(nut->i); + if (!nut->seek_state) { + int i; + for (i = 0; i < nut->stream_count; i++) { + state[i].old_last_pts = nut->sc[i].last_pts; + state[i].active = active_streams ? 0 : 1; + state[i].good_key = state[i].pts_higher = 0; + } + if (active_streams) for (i = 0; active_streams[i] != -1; i++) state[active_streams[i]].active = 1; + + if (flags & 1) { // relative seek + uint64_t orig_pts = 0; + int orig_timebase = 0; + for (i = 0; i < nut->stream_count; i++) { + uint64_t dts = nut->sc[i].last_dts != -1 ? nut->sc[i].last_dts : nut->sc[i].last_pts; + if (!state[i].active) continue; + if (compare_ts(nut, orig_pts, nut->tb[orig_timebase], dts, TO_TB(i)) < 0) { + orig_pts = dts; + orig_timebase = nut->sc[i].timebase_id; + } + } + time_pos += TO_DOUBLE(orig_timebase, orig_pts); + } + if (time_pos < 0.) time_pos = 0.; + + for (i = 0; i < nut->stream_count; i++) state[i].pts = (uint64_t)(time_pos / TO_TB(i).nom * TO_TB(i).den); + nut->seek_time_pos = time_pos; + } else { + memcpy(state, nut->seek_state, sizeof state); + time_pos = nut->seek_time_pos; + } + if (nut->syncpoints.len) { syncpoint_list_t * sl = &nut->syncpoints; int i; @@ -1199,18 +1179,18 @@ if (!sl->s[i].pts_valid) continue; for (j = 0; j < nut->stream_count; j++) { uint64_t tmp; - if (!(pts[j]&1)) continue; + if (!state[j].active) continue; tmp = sl->pts[i * nut->stream_count + j]; if (tmp--) { // -- because all pts array os off-by-one. zero indicate no keyframe. - if (tmp > (pts[j]>>1)) { if (!last_sync) last_sync = i; } + if (tmp > state[j].pts) { if (!last_sync) last_sync = i; } else sync[j] = (i-1); } tmp = sl->eor[i * nut->stream_count + j]; - if (tmp--) if (tmp <= (pts[j]>>1)) sync[j] = -(i+1); // flag stream eor + if (tmp--) if (tmp <= state[j].pts) sync[j] = -(i+1); // flag stream eor } } for (i = 0; i < nut->stream_count; i++) { - if (!(pts[i] & 1)) continue; + if (!state[i].active) continue; if (sync[i] < -1) { backup = MAX(backup, -sync[i] - 1); continue; } // eor stream if (good_sync == -2 || good_sync > sync[i]) good_sync = sync[i]; } @@ -1232,9 +1212,9 @@ if (start) { // "unsuccessful" seek needs no linear search if (!(flags & 2)) { // regular seek - CHECK(linear_search_seek(nut, backwards, pts, start, end, stopper.pos ? &stopper : NULL)); + CHECK(linear_search_seek(nut, backwards, state, start, end, stopper.pos ? &stopper : NULL)); } else { // forwards seek, find keyframe - CHECK(linear_search_seek(nut, backwards, pts, end, 0, NULL)); + CHECK(linear_search_seek(nut, backwards, state, end, 0, NULL)); } } fprintf(stderr, "DONE SEEK\n"); @@ -1242,6 +1222,11 @@ if (err != 2) { // unless EAGAIN flush_buf(nut->i); nut->before_seek = 0; + free(nut->seek_state); + nut->seek_state = NULL; + } else { + if (!nut->seek_state) nut->seek_state = malloc(sizeof state); + memcpy(nut->seek_state, state, sizeof state); } return err; } Modified: trunk/libnut/priv.h ============================================================================== --- trunk/libnut/priv.h (original) +++ trunk/libnut/priv.h Thu Sep 14 12:10:20 2006 @@ -122,6 +122,14 @@ int total_frames; } stream_context_t; +typedef struct { + int active; + uint64_t pts; // requested pts; + uint64_t old_last_pts; + off_t good_key; + int pts_higher; // for active streams +} seek_state_t; + struct nut_context_s { nut_muxer_opts_t mopts; nut_demuxer_opts_t dopts; @@ -147,10 +155,8 @@ off_t before_seek; // position before any seek mess off_t seek_status; - struct { - off_t good_key; - uint64_t old_last_pts; - } * seek_state; // for linear search, so we can go back as if nothing happenned + seek_state_t * seek_state; // array per stream count + double seek_time_pos; syncpoint_list_t syncpoints;