Mercurial > libavformat.hg
view seek.c @ 5264:323fc801aa57 libavformat
MP3 muxer: Write all metadata.
Patch by Anton Khirnov <wyskas at gmail dot com>
author | ramiro |
---|---|
date | Mon, 05 Oct 2009 16:06:00 +0000 |
parents | 44e53fe2e9ca |
children | 6f5cdb0fb3c2 |
line wrap: on
line source
/* * seek utility functions for use within format handlers * * Copyright (c) 2009 Ivan Schreter * * This file is part of FFmpeg. * * FFmpeg is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public * License as published by the Free Software Foundation; either * version 2.1 of the License, or (at your option) any later version. * * FFmpeg is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public * License along with FFmpeg; if not, write to the Free Software * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA */ #include "seek.h" #include "libavutil/mem.h" // NOTE: implementation should be moved here in another patch, to keep patches // separated. extern void av_read_frame_flush(AVFormatContext *s); /** * helper structure describing keyframe search state of one stream */ typedef struct { int64_t pos_lo; ///< position of the frame with low timestamp in file or INT64_MAX if not found (yet) int64_t ts_lo; ///< frame presentation timestamp or same as pos_lo for byte seeking int64_t pos_hi; ///< position of the frame with high timestamp in file or INT64_MAX if not found (yet) int64_t ts_hi; ///< frame presentation timestamp or same as pos_hi for byte seeking int64_t last_pos; ///< last known position of a frame, for multi-frame packets int64_t term_ts; ///< termination timestamp (which TS we already read) AVRational term_ts_tb; ///< timebase for term_ts int64_t first_ts; ///< first packet timestamp in this iteration (to fill term_ts later) AVRational first_ts_tb; ///< timebase for first_ts int terminated; ///< termination flag for the current iteration } AVSyncPoint; /** * Compare two timestamps exactly, taking their respective time bases into account. * * @param ts_a timestamp A * @param tb_a time base for timestamp A * @param ts_b timestamp B * @param tb_b time base for timestamp A * @return -1, 0 or 1 if timestamp A is less than, equal or greater than timestamp B */ static int compare_ts(int64_t ts_a, AVRational tb_a, int64_t ts_b, AVRational tb_b) { int64_t a, b, res; if (ts_a == INT64_MIN) return ts_a < ts_b ? -1 : 0; if (ts_a == INT64_MAX) return ts_a > ts_b ? 1 : 0; if (ts_b == INT64_MIN) return ts_a > ts_b ? 1 : 0; if (ts_b == INT64_MAX) return ts_a < ts_b ? -1 : 0; a = ts_a * tb_a.num * tb_b.den; b = ts_b * tb_b.num * tb_a.den; res = a - b; if (!res) return 0; else return (res >> 63) | 1; } /** * Compute a distance between timestamps. * * Distances are only comparable, if same time bases are used for computing * distances. * * @param ts_hi high timestamp * @param tb_hi high timestamp time base * @param ts_lo low timestamp * @param tb_lo low timestamp time base * @return representation of distance between high and low timestamps */ static int64_t ts_distance(int64_t ts_hi, AVRational tb_hi, int64_t ts_lo, AVRational tb_lo) { int64_t hi, lo; hi = ts_hi * tb_hi.num * tb_lo.den; lo = ts_lo * tb_lo.num * tb_hi.den; return hi - lo; } /** * Partial search for keyframes in multiple streams. * * This routine searches in each stream for the next lower and the next higher * timestamp compared to the given target timestamp. The search starts at the current * file position and ends at the file position, where all streams have already been * examined (or when all higher key frames are found in the first iteration). * * This routine is called iteratively with an exponential backoff to find the lower * timestamp. * * @param s format context * @param timestamp target timestamp (or position, if AVSEEK_FLAG_BYTE) * @param timebase time base for timestamps * @param flags seeking flags * @param sync array with information per stream * @param keyframes_to_find count of keyframes to find in total * @param found_lo ptr to the count of already found low timestamp keyframes * @param found_hi ptr to the count of already found high timestamp keyframes * @param first_iter flag for first iteration */ static void search_hi_lo_keyframes(AVFormatContext *s, int64_t timestamp, AVRational timebase, int flags, AVSyncPoint *sync, int keyframes_to_find, int *found_lo, int *found_hi, int first_iter) { AVPacket pkt; AVSyncPoint *sp; AVStream *st; int idx; int flg; int terminated_count = 0; int64_t pos; int64_t pts, dts; // PTS/DTS from stream int64_t ts; // PTS in stream-local time base or position for byte seeking AVRational ts_tb; // Time base of the stream or 1:1 for byte seeking for (;;) { if (av_read_frame(s, &pkt) < 0) { // EOF or error, make sure high flags are set for (idx = 0; idx < s->nb_streams; ++idx) { if (s->streams[idx]->discard < AVDISCARD_ALL) { sp = &sync[idx]; if (sp->pos_hi == INT64_MAX) { // no high frame exists for this stream (*found_hi)++; sp->ts_hi = INT64_MAX; sp->pos_hi = INT64_MAX - 1; } } } break; } idx = pkt.stream_index; st = s->streams[idx]; if (st->discard >= AVDISCARD_ALL) // this stream is not active, skip packet continue; sp = &sync[idx]; flg = pkt.flags; pos = pkt.pos; pts = pkt.pts; dts = pkt.dts; if (pts == AV_NOPTS_VALUE) // some formats don't provide PTS, only DTS pts = dts; av_free_packet(&pkt); // Multi-frame packets only return position for the very first frame. // Other frames are read with position == -1. Therefore, we note down // last known position of a frame and use it if a frame without // position arrives. In this way, it's possible to seek to proper // position. Additionally, for parsers not providing position at all, // an approximation will be used (starting position of this iteration). if (pos < 0) pos = sp->last_pos; else sp->last_pos = pos; // Evaluate key frames with known TS (or any frames, if AVSEEK_FLAG_ANY set). if (pts != AV_NOPTS_VALUE && ((flg & PKT_FLAG_KEY) || (flags & AVSEEK_FLAG_ANY))) { if (flags & AVSEEK_FLAG_BYTE) { // for byte seeking, use position as timestamp ts = pos; ts_tb.num = 1; ts_tb.den = 1; } else { // otherwise, get stream time_base ts = pts; ts_tb = st->time_base; } if (sp->first_ts == AV_NOPTS_VALUE) { // Note down termination timestamp for the next iteration - when // we encounter a packet with the same timestamp, we will ignore // any further packets for this stream in next iteration (as they // are already evaluated). sp->first_ts = ts; sp->first_ts_tb = ts_tb; } if (sp->term_ts != AV_NOPTS_VALUE && compare_ts(ts, ts_tb, sp->term_ts, sp->term_ts_tb) > 0) { // past the end position from last iteration, ignore packet if (!sp->terminated) { sp->terminated = 1; ++terminated_count; if (sp->pos_hi == INT64_MAX) { // no high frame exists for this stream (*found_hi)++; sp->ts_hi = INT64_MAX; sp->pos_hi = INT64_MAX - 1; } if (terminated_count == keyframes_to_find) break; // all terminated, iteration done } continue; } if (compare_ts(ts, ts_tb, timestamp, timebase) <= 0) { // keyframe found before target timestamp if (sp->pos_lo == INT64_MAX) { // found first keyframe lower than target timestamp (*found_lo)++; sp->ts_lo = ts; sp->pos_lo = pos; } else if (sp->ts_lo < ts) { // found a better match (closer to target timestamp) sp->ts_lo = ts; sp->pos_lo = pos; } } if (compare_ts(ts, ts_tb, timestamp, timebase) >= 0) { // keyframe found after target timestamp if (sp->pos_hi == INT64_MAX) { // found first keyframe higher than target timestamp (*found_hi)++; sp->ts_hi = ts; sp->pos_hi = pos; if (*found_hi >= keyframes_to_find && first_iter) { // We found high frame for all. They may get updated // to TS closer to target TS in later iterations (which // will stop at start position of previous iteration). break; } } else if (sp->ts_hi > ts) { // found a better match (actually, shouldn't happen) sp->ts_hi = ts; sp->pos_hi = pos; } } } } // Clean up the parser. av_read_frame_flush(s); } int64_t ff_gen_syncpoint_search(AVFormatContext *s, int stream_index, int64_t pos, int64_t ts_min, int64_t ts, int64_t ts_max, int flags) { AVSyncPoint *sync, *sp; AVStream *st; int i; int keyframes_to_find = 0; int64_t curpos; int64_t step; int found_lo = 0, found_hi = 0; int64_t min_distance, distance; int64_t min_pos = 0; int first_iter = 1; AVRational time_base; if (flags & AVSEEK_FLAG_BYTE) { // for byte seeking, we have exact 1:1 "timestamps" - positions time_base.num = 1; time_base.den = 1; } else { if (stream_index >= 0) { // we have a reference stream, which time base we use st = s->streams[stream_index]; time_base = st->time_base; } else { // no reference stream, use AV_TIME_BASE as reference time base time_base.num = 1; time_base.den = AV_TIME_BASE; } } // Initialize syncpoint structures for each stream. sync = av_malloc(s->nb_streams * sizeof(AVSyncPoint)); if (!sync) // cannot allocate helper structure return -1; for (i = 0; i < s->nb_streams; ++i) { st = s->streams[i]; sp = &sync[i]; sp->pos_lo = INT64_MAX; sp->ts_lo = INT64_MAX; sp->pos_hi = INT64_MAX; sp->ts_hi = INT64_MAX; sp->terminated = 0; sp->first_ts = AV_NOPTS_VALUE; sp->term_ts = ts_max; sp->term_ts_tb = time_base; sp->last_pos = pos; st->cur_dts = AV_NOPTS_VALUE; if (st->discard < AVDISCARD_ALL) ++keyframes_to_find; } if (!keyframes_to_find) { // no stream active, error av_free(sync); return -1; } // Find keyframes in all active streams with timestamp/position just before // and just after requested timestamp/position. step = s->pb->buffer_size; curpos = FFMAX(pos - step / 2, 0); for (;;) { url_fseek(s->pb, curpos, SEEK_SET); search_hi_lo_keyframes(s, ts, time_base, flags, sync, keyframes_to_find, &found_lo, &found_hi, first_iter); if (found_lo == keyframes_to_find && found_hi == keyframes_to_find) break; // have all keyframes we wanted if (!curpos) break; // cannot go back anymore curpos = pos - step; if (curpos < 0) curpos = 0; step *= 2; // switch termination positions for (i = 0; i < s->nb_streams; ++i) { st = s->streams[i]; st->cur_dts = AV_NOPTS_VALUE; sp = &sync[i]; if (sp->first_ts != AV_NOPTS_VALUE) { sp->term_ts = sp->first_ts; sp->term_ts_tb = sp->first_ts_tb; sp->first_ts = AV_NOPTS_VALUE; } sp->terminated = 0; sp->last_pos = curpos; } first_iter = 0; } // Find actual position to start decoding so that decoder synchronizes // closest to ts and between ts_min and ts_max. pos = INT64_MAX; for (i = 0; i < s->nb_streams; ++i) { st = s->streams[i]; if (st->discard < AVDISCARD_ALL) { sp = &sync[i]; min_distance = INT64_MAX; // Find timestamp closest to requested timestamp within min/max limits. if (sp->pos_lo != INT64_MAX && compare_ts(ts_min, time_base, sp->ts_lo, st->time_base) <= 0 && compare_ts(sp->ts_lo, st->time_base, ts_max, time_base) <= 0) { // low timestamp is in range min_distance = ts_distance(ts, time_base, sp->ts_lo, st->time_base); min_pos = sp->pos_lo; } if (sp->pos_hi != INT64_MAX && compare_ts(ts_min, time_base, sp->ts_hi, st->time_base) <= 0 && compare_ts(sp->ts_hi, st->time_base, ts_max, time_base) <= 0) { // high timestamp is in range, check distance distance = ts_distance(sp->ts_hi, st->time_base, ts, time_base); if (distance < min_distance) { min_distance = distance; min_pos = sp->pos_hi; } } if (min_distance == INT64_MAX) { // no timestamp is in range, cannot seek av_free(sync); return -1; } if (min_pos < pos) pos = min_pos; } } url_fseek(s->pb, pos, SEEK_SET); av_free(sync); return pos; } AVParserState *ff_store_parser_state(AVFormatContext *s) { int i; AVStream *st; AVParserStreamState *ss; AVParserState *state = av_malloc(sizeof(AVParserState)); if (!state) return NULL; state->stream_states = av_malloc(sizeof(AVParserStreamState) * s->nb_streams); if (!state->stream_states) { av_free(state); return NULL; } state->fpos = url_ftell(s->pb); // copy context structures state->cur_st = s->cur_st; state->packet_buffer = s->packet_buffer; state->raw_packet_buffer = s->raw_packet_buffer; state->raw_packet_buffer_remaining_size = s->raw_packet_buffer_remaining_size; s->cur_st = NULL; s->packet_buffer = NULL; s->raw_packet_buffer = NULL; s->raw_packet_buffer_remaining_size = RAW_PACKET_BUFFER_SIZE; // copy stream structures state->nb_streams = s->nb_streams; for (i = 0; i < s->nb_streams; i++) { st = s->streams[i]; ss = &state->stream_states[i]; ss->parser = st->parser; ss->last_IP_pts = st->last_IP_pts; ss->cur_dts = st->cur_dts; ss->reference_dts = st->reference_dts; ss->cur_ptr = st->cur_ptr; ss->cur_len = st->cur_len; ss->probe_packets = st->probe_packets; ss->cur_pkt = st->cur_pkt; st->parser = NULL; st->last_IP_pts = AV_NOPTS_VALUE; st->cur_dts = AV_NOPTS_VALUE; st->reference_dts = AV_NOPTS_VALUE; st->cur_ptr = NULL; st->cur_len = 0; st->probe_packets = MAX_PROBE_PACKETS; av_init_packet(&st->cur_pkt); } return state; } void ff_restore_parser_state(AVFormatContext *s, AVParserState *state) { int i; AVStream *st; AVParserStreamState *ss; av_read_frame_flush(s); if (!state) return; url_fseek(s->pb, state->fpos, SEEK_SET); // copy context structures s->cur_st = state->cur_st; s->packet_buffer = state->packet_buffer; s->raw_packet_buffer = state->raw_packet_buffer; s->raw_packet_buffer_remaining_size = state->raw_packet_buffer_remaining_size; // copy stream structures for (i = 0; i < state->nb_streams; i++) { st = s->streams[i]; ss = &state->stream_states[i]; st->parser = ss->parser; st->last_IP_pts = ss->last_IP_pts; st->cur_dts = ss->cur_dts; st->reference_dts = ss->reference_dts; st->cur_ptr = ss->cur_ptr; st->cur_len = ss->cur_len; st->probe_packets = ss->probe_packets; st->cur_pkt = ss->cur_pkt; } av_free(state->stream_states); av_free(state); } static void free_packet_list(AVPacketList *pktl) { AVPacketList *cur; while (pktl) { cur = pktl; pktl = cur->next; av_free_packet(&cur->pkt); av_free(cur); } } void ff_free_parser_state(AVFormatContext *s, AVParserState *state) { int i; AVParserStreamState *ss; if (!state) return; for (i = 0; i < state->nb_streams; i++) { ss = &state->stream_states[i]; if (ss->parser) av_parser_close(ss->parser); av_free_packet(&ss->cur_pkt); } free_packet_list(state->packet_buffer); free_packet_list(state->raw_packet_buffer); av_free(state->stream_states); av_free(state); }