/* * This file is part of mpv. * * mpv 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. * * mpv 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 mpv. If not, see . */ #include #include #include #include #include #include #include #include #include #include #include "config.h" #include "options/m_config.h" #include "options/m_option.h" #include "mpv_talloc.h" #include "common/msg.h" #include "common/global.h" #include "osdep/threads.h" #include "stream/stream.h" #include "demux.h" #include "timeline.h" #include "stheader.h" #include "cue.h" // Demuxer list extern const struct demuxer_desc demuxer_desc_edl; extern const struct demuxer_desc demuxer_desc_cue; extern const demuxer_desc_t demuxer_desc_rawaudio; extern const demuxer_desc_t demuxer_desc_rawvideo; extern const demuxer_desc_t demuxer_desc_tv; extern const demuxer_desc_t demuxer_desc_mf; extern const demuxer_desc_t demuxer_desc_matroska; extern const demuxer_desc_t demuxer_desc_lavf; extern const demuxer_desc_t demuxer_desc_playlist; extern const demuxer_desc_t demuxer_desc_disc; extern const demuxer_desc_t demuxer_desc_rar; extern const demuxer_desc_t demuxer_desc_libarchive; extern const demuxer_desc_t demuxer_desc_null; extern const demuxer_desc_t demuxer_desc_timeline; /* Please do not add any new demuxers here. If you want to implement a new * demuxer, add it to libavformat, except for wrappers around external * libraries and demuxers requiring binary support. */ const demuxer_desc_t *const demuxer_list[] = { &demuxer_desc_disc, &demuxer_desc_edl, &demuxer_desc_cue, &demuxer_desc_rawaudio, &demuxer_desc_rawvideo, #if HAVE_TV &demuxer_desc_tv, #endif &demuxer_desc_matroska, #if HAVE_LIBARCHIVE &demuxer_desc_libarchive, #endif &demuxer_desc_rar, &demuxer_desc_lavf, &demuxer_desc_mf, &demuxer_desc_playlist, &demuxer_desc_null, NULL }; struct demux_opts { int64_t max_bytes; int64_t max_bytes_bw; double min_secs; int force_seekable; double min_secs_cache; int access_references; int seekable_cache; int create_ccs; }; #define OPT_BASE_STRUCT struct demux_opts const struct m_sub_options demux_conf = { .opts = (const struct m_option[]){ OPT_DOUBLE("demuxer-readahead-secs", min_secs, M_OPT_MIN, .min = 0), OPT_BYTE_SIZE("demuxer-max-bytes", max_bytes, 0, 0, INT_MAX), OPT_BYTE_SIZE("demuxer-max-back-bytes", max_bytes_bw, 0, 0, INT_MAX), OPT_FLAG("force-seekable", force_seekable, 0), OPT_DOUBLE("cache-secs", min_secs_cache, M_OPT_MIN, .min = 0), OPT_FLAG("access-references", access_references, 0), OPT_CHOICE("demuxer-seekable-cache", seekable_cache, 0, ({"auto", -1}, {"no", 0}, {"yes", 1})), OPT_FLAG("sub-create-cc-track", create_ccs, 0), {0} }, .size = sizeof(struct demux_opts), .defaults = &(const struct demux_opts){ .max_bytes = 150 * 1024 * 1024, .max_bytes_bw = 50 * 1024 * 1024, .min_secs = 1.0, .min_secs_cache = 10.0 * 60 * 60, .seekable_cache = -1, .access_references = 1, }, }; struct demux_internal { struct mp_log *log; // The demuxer runs potentially in another thread, so we keep two demuxer // structs; the real demuxer can access the shadow struct only. // Since demuxer and user threads both don't use locks, a third demuxer // struct d_buffer is used to copy data between them in a synchronized way. struct demuxer *d_thread; // accessed by demuxer impl. (producer) struct demuxer *d_user; // accessed by player (consumer) struct demuxer *d_buffer; // protected by lock; used to sync d_user/thread // The lock protects the packet queues (struct demux_stream), d_buffer, // and the fields below. pthread_mutex_t lock; pthread_cond_t wakeup; pthread_t thread; // -- All the following fields are protected by lock. bool thread_terminate; bool threading; void (*wakeup_cb)(void *ctx); void *wakeup_cb_ctx; struct sh_stream **streams; int num_streams; int events; bool warned_queue_overflow; bool last_eof; // last actual global EOF status bool eof; // whether we're in EOF state (reset for retry) bool idle; bool autoselect; double min_secs; int max_bytes; int max_bytes_bw; bool seekable_cache; // At least one decoder actually requested data since init or the last seek. // Do this to allow the decoder thread to select streams before starting. bool reading; // Set if we know that we are at the start of the file. This is used to // avoid a redundant initial seek after enabling streams. We could just // allow it, but to avoid buggy seeking affecting normal playback, we don't. bool initial_state; bool tracks_switched; // thread needs to inform demuxer of this bool seeking; // there's a seek queued int seek_flags; // flags for next seek (if seeking==true) double seek_pts; // (fields for debugging) double seeking_in_progress; // low level seek state int low_level_seeks; // number of started low level seeks double demux_ts; // last demuxed DTS or PTS double ts_offset; // timestamp offset to apply to everything void (*run_fn)(void *); // if non-NULL, function queued to be run on void *run_fn_arg; // the thread as run_fn(run_fn_arg) // (sorted by least recent use: index 0 is least recently used) struct demux_cached_range **ranges; int num_ranges; size_t total_bytes; // total sum of packet data buffered size_t fw_bytes; // sum of forward packet data in current_range // Range from which decoder is reading, and to which demuxer is appending. // This is never NULL. This is always ranges[num_ranges - 1]. struct demux_cached_range *current_range; double highest_av_pts; // highest non-subtitle PTS seen - for duration bool blocked; // Cached state. bool force_cache_update; struct mp_tags *stream_metadata; struct stream_cache_info stream_cache_info; int64_t stream_size; // Updated during init only. char *stream_base_filename; }; // A continuous range of cached packets for all enabled streams. // (One demux_queue for each known stream.) struct demux_cached_range { // streams[] is indexed by demux_stream->index struct demux_queue **streams; int num_streams; // Computed from the stream queue's values. These fields (unlike as with // demux_queue) are always either NOPTS, or fully valid. double seek_start, seek_end; bool is_bof; // set if the file begins with this range bool is_eof; // set if the file ends with this range }; #define MAX_INDEX_ENTRIES 16 // A continuous list of cached packets for a single stream/range. There is one // for each stream and range. Also contains some state for use during demuxing // (keeping it across seeks makes it easier to resume demuxing). struct demux_queue { struct demux_stream *ds; struct demux_cached_range *range; struct demux_packet *head; struct demux_packet *tail; struct demux_packet *next_prune_target; // cached value for faster pruning bool correct_dts; // packet DTS is strictly monotonically increasing bool correct_pos; // packet pos is strictly monotonically increasing int64_t last_pos; // for determining correct_pos double last_dts; // for determining correct_dts double last_ts; // timestamp of the last packet added to queue // for incrementally determining seek PTS range double keyframe_pts, keyframe_end_pts; struct demux_packet *keyframe_latest; // incrementally maintained seek range, possibly invalid double seek_start, seek_end; double last_pruned; // timestamp of last pruned keyframe bool is_bof; // started demuxing at beginning of file bool is_eof; // received true EOF here // incomplete index to somewhat speed up seek operations // the entries in index[] must be in packet queue append/removal order int num_index; // valid index[] entries double index_distance; // minimum keyframe distance to add index element struct demux_packet *index[MAX_INDEX_ENTRIES]; }; struct demux_stream { struct demux_internal *in; struct sh_stream *sh; // ds->sh->ds == ds enum stream_type type; // equals to sh->type int index; // equals to sh->index // --- all fields are protected by in->lock void (*wakeup_cb)(void *ctx); void *wakeup_cb_ctx; // demuxer state bool selected; // user wants packets from this stream bool eager; // try to keep at least 1 packet queued // if false, this stream is disabled, or passively // read (like subtitles) bool refreshing; // finding old position after track switches bool eof; // end of demuxed stream? (true if no more packets) bool global_correct_dts;// all observed so far bool global_correct_pos; // current queue - used both for reading and demuxing (this is never NULL) struct demux_queue *queue; // reader (decoder) state (bitrate calculations are part of it because we // want to return the bitrate closest to the "current position") double base_ts; // timestamp of the last packet returned to decoder double last_br_ts; // timestamp of last packet bitrate was calculated size_t last_br_bytes; // summed packet sizes since last bitrate calculation double bitrate; size_t fw_packs; // number of packets in buffer (forward) size_t fw_bytes; // total bytes of packets in buffer (forward) struct demux_packet *reader_head; // points at current decoder position bool skip_to_keyframe; bool attached_picture_added; bool need_wakeup; // call wakeup_cb on next reader_head state change // for refresh seeks: pos/dts of last packet returned to reader int64_t last_ret_pos; double last_ret_dts; // for closed captions (demuxer_feed_caption) struct sh_stream *cc; bool ignore_eof; // ignore stream in underrun detection }; // Return "a", or if that is NOPTS, return "def". #define PTS_OR_DEF(a, def) ((a) == MP_NOPTS_VALUE ? (def) : (a)) // If one of the values is NOPTS, always pick the other one. #define MP_PTS_MIN(a, b) MPMIN(PTS_OR_DEF(a, b), PTS_OR_DEF(b, a)) #define MP_PTS_MAX(a, b) MPMAX(PTS_OR_DEF(a, b), PTS_OR_DEF(b, a)) #define MP_ADD_PTS(a, b) ((a) == MP_NOPTS_VALUE ? (a) : ((a) + (b))) static void demuxer_sort_chapters(demuxer_t *demuxer); static void *demux_thread(void *pctx); static void update_cache(struct demux_internal *in); #if 0 // very expensive check for redundant cached queue state static void check_queue_consistency(struct demux_internal *in) { size_t total_bytes = 0; size_t total_fw_bytes = 0; assert(in->current_range && in->num_ranges > 0); assert(in->current_range == in->ranges[in->num_ranges - 1]); for (int n = 0; n < in->num_ranges; n++) { struct demux_cached_range *range = in->ranges[n]; int range_num_packets = 0; assert(range->num_streams == in->num_streams); for (int i = 0; i < range->num_streams; i++) { struct demux_queue *queue = range->streams[i]; assert(queue->range == range); size_t fw_bytes = 0; size_t fw_packs = 0; bool is_forward = false; bool kf_found = false; bool npt_found = false; int next_index = 0; for (struct demux_packet *dp = queue->head; dp; dp = dp->next) { is_forward |= dp == queue->ds->reader_head; kf_found |= dp == queue->keyframe_latest; npt_found |= dp == queue->next_prune_target; size_t bytes = demux_packet_estimate_total_size(dp); total_bytes += bytes; if (is_forward) { fw_bytes += bytes; fw_packs += 1; assert(range == in->current_range); assert(queue->ds->queue == queue); } range_num_packets += 1; if (!dp->next) assert(queue->tail == dp); if (next_index < queue->num_index && queue->index[next_index] == dp) next_index += 1; } if (!queue->head) assert(!queue->tail); assert(next_index == queue->num_index); // If the queue is currently used... if (queue->ds->queue == queue) { // ...reader_head and others must be in the queue. assert(is_forward == !!queue->ds->reader_head); assert(kf_found == !!queue->keyframe_latest); } assert(npt_found == !!queue->next_prune_target); total_fw_bytes += fw_bytes; if (range == in->current_range) { assert(queue->ds->fw_bytes == fw_bytes); assert(queue->ds->fw_packs == fw_packs); } else { assert(fw_bytes == 0 && fw_packs == 0); } if (queue->keyframe_latest) assert(queue->keyframe_latest->keyframe); } // Invariant needed by pruning; violation has worse effects than just // e.g. broken seeking due to incorrect seek ranges. if (range->seek_start != MP_NOPTS_VALUE) assert(range_num_packets > 0); } assert(in->total_bytes == total_bytes); assert(in->fw_bytes == total_fw_bytes); } #endif static void recompute_buffers(struct demux_stream *ds) { ds->fw_packs = 0; ds->fw_bytes = 0; for (struct demux_packet *dp = ds->reader_head; dp; dp = dp->next) { ds->fw_bytes += demux_packet_estimate_total_size(dp); ds->fw_packs++; } } // (this doesn't do most required things for a switch, like updating ds->queue) static void set_current_range(struct demux_internal *in, struct demux_cached_range *range) { in->current_range = range; // Move to in->ranges[in->num_ranges-1] (for LRU sorting/invariant) for (int n = 0; n < in->num_ranges; n++) { if (in->ranges[n] == range) { MP_TARRAY_REMOVE_AT(in->ranges, in->num_ranges, n); break; } } MP_TARRAY_APPEND(in, in->ranges, in->num_ranges, range); } // Refresh range->seek_start/end. static void update_seek_ranges(struct demux_cached_range *range) { range->seek_start = range->seek_end = MP_NOPTS_VALUE; range->is_bof = true; range->is_eof = true; for (int n = 0; n < range->num_streams; n++) { struct demux_queue *queue = range->streams[n]; if (queue->ds->selected && queue->ds->eager) { range->seek_start = MP_PTS_MAX(range->seek_start, queue->seek_start); range->seek_end = MP_PTS_MIN(range->seek_end, queue->seek_end); range->is_eof &= queue->is_eof; range->is_bof &= queue->is_bof; if (queue->seek_start >= queue->seek_end) { range->seek_start = range->seek_end = MP_NOPTS_VALUE; break; } } } // Sparse stream behavior is not very clearly defined, but usually we don't // want it to restrict the range of other streams, unless // This is incorrect in any of these cases: // - sparse streams only (it's unknown how to determine an accurate range) // - if sparse streams have non-keyframe packets (we set queue->last_pruned // to the start of the pruned keyframe range - we'd need the end or so) // We also assume that ds->eager equals to a stream being sparse (usually // true, except if only sparse streams are selected). // We also rely on the fact that the demuxer position will always be ahead // of the seek_end for audio/video, because they need to prefetch at least // 1 packet to detect the end of a keyframe range. This means that we're // relatively guaranteed to have all sparse (subtitle) packets within the // seekable range. for (int n = 0; n < range->num_streams; n++) { struct demux_queue *queue = range->streams[n]; if (queue->ds->selected && !queue->ds->eager && queue->last_pruned != MP_NOPTS_VALUE && range->seek_start != MP_NOPTS_VALUE) { // (last_pruned is _exclusive_ to the seekable range, so add a small // value to exclude it from the valid range.) range->seek_start = MP_PTS_MAX(range->seek_start, queue->last_pruned + 0.1); } } if (range->seek_start >= range->seek_end) range->seek_start = range->seek_end = MP_NOPTS_VALUE; } // Remove queue->head from the queue. Does not update in->fw_bytes/in->fw_packs. static void remove_head_packet(struct demux_queue *queue) { struct demux_packet *dp = queue->head; assert(queue->ds->reader_head != dp); if (queue->next_prune_target == dp) queue->next_prune_target = NULL; if (queue->keyframe_latest == dp) queue->keyframe_latest = NULL; queue->is_bof = false; queue->ds->in->total_bytes -= demux_packet_estimate_total_size(dp); if (queue->num_index && queue->index[0] == dp) MP_TARRAY_REMOVE_AT(queue->index, queue->num_index, 0); queue->head = dp->next; if (!queue->head) queue->tail = NULL; talloc_free(dp); } static void clear_queue(struct demux_queue *queue) { struct demux_stream *ds = queue->ds; struct demux_internal *in = ds->in; struct demux_packet *dp = queue->head; while (dp) { struct demux_packet *dn = dp->next; in->total_bytes -= demux_packet_estimate_total_size(dp); assert(ds->reader_head != dp); talloc_free(dp); dp = dn; } queue->head = queue->tail = NULL; queue->next_prune_target = NULL; queue->keyframe_latest = NULL; queue->seek_start = queue->seek_end = queue->last_pruned = MP_NOPTS_VALUE; queue->num_index = 0; queue->index_distance = 1.0; queue->correct_dts = queue->correct_pos = true; queue->last_pos = -1; queue->last_ts = queue->last_dts = MP_NOPTS_VALUE; queue->keyframe_latest = NULL; queue->keyframe_pts = queue->keyframe_end_pts = MP_NOPTS_VALUE; queue->is_eof = false; queue->is_bof = false; } static void clear_cached_range(struct demux_internal *in, struct demux_cached_range *range) { for (int n = 0; n < range->num_streams; n++) clear_queue(range->streams[n]); update_seek_ranges(range); } // Remove ranges with no data (except in->current_range). Also remove excessive // ranges. static void free_empty_cached_ranges(struct demux_internal *in) { assert(in->current_range && in->num_ranges > 0); assert(in->current_range == in->ranges[in->num_ranges - 1]); while (1) { struct demux_cached_range *worst = NULL; for (int n = in->num_ranges - 2; n >= 0; n--) { struct demux_cached_range *range = in->ranges[n]; if (range->seek_start == MP_NOPTS_VALUE || !in->seekable_cache) { clear_cached_range(in, range); MP_TARRAY_REMOVE_AT(in->ranges, in->num_ranges, n); } else { if (!worst || (range->seek_end - range->seek_start < worst->seek_end - worst->seek_start)) worst = range; } } if (in->num_ranges <= MAX_SEEK_RANGES) break; clear_cached_range(in, worst); } } static void ds_clear_reader_queue_state(struct demux_stream *ds) { ds->in->fw_bytes -= ds->fw_bytes; ds->reader_head = NULL; ds->fw_bytes = 0; ds->fw_packs = 0; ds->eof = false; ds->need_wakeup = true; } static void ds_clear_reader_state(struct demux_stream *ds) { ds_clear_reader_queue_state(ds); ds->base_ts = ds->last_br_ts = MP_NOPTS_VALUE; ds->last_br_bytes = 0; ds->bitrate = -1; ds->skip_to_keyframe = false; ds->attached_picture_added = false; ds->last_ret_pos = -1; ds->last_ret_dts = MP_NOPTS_VALUE; } // Call if the observed reader state on this stream somehow changes. The wakeup // is skipped if the reader successfully read a packet, because that means we // expect it to come back and ask for more. static void wakeup_ds(struct demux_stream *ds) { if (ds->need_wakeup) { if (ds->wakeup_cb) { ds->wakeup_cb(ds->wakeup_cb_ctx); } else if (ds->in->wakeup_cb) { ds->in->wakeup_cb(ds->in->wakeup_cb_ctx); } ds->need_wakeup = false; pthread_cond_signal(&ds->in->wakeup); } } static void update_stream_selection_state(struct demux_internal *in, struct demux_stream *ds) { ds->eof = false; ds->refreshing = false; ds_clear_reader_state(ds); // We still have to go over the whole stream list to update ds->eager for // other streams too, because they depend on other stream's selections. bool any_av_streams = false; bool any_streams = false; for (int n = 0; n < in->num_streams; n++) { struct demux_stream *s = in->streams[n]->ds; s->eager = s->selected && !s->sh->attached_picture; if (s->eager) any_av_streams |= s->type != STREAM_SUB; any_streams |= s->selected; } // Subtitles are only eagerly read if there are no other eagerly read // streams. if (any_av_streams) { for (int n = 0; n < in->num_streams; n++) { struct demux_stream *s = in->streams[n]->ds; if (s->type == STREAM_SUB) s->eager = false; } } if (!any_streams) in->blocked = false; // Make sure any stream reselection or addition is reflected in the seek // ranges, and also get rid of data that is not needed anymore (or // rather, which can't be kept consistent). This has to happen after we've // updated all the subtle state (like s->eager). for (int n = 0; n < in->num_ranges; n++) { struct demux_cached_range *range = in->ranges[n]; if (!ds->selected) clear_queue(range->streams[ds->index]); update_seek_ranges(range); } free_empty_cached_ranges(in); wakeup_ds(ds); } void demux_set_ts_offset(struct demuxer *demuxer, double offset) { struct demux_internal *in = demuxer->in; pthread_mutex_lock(&in->lock); in->ts_offset = offset; pthread_mutex_unlock(&in->lock); } static void add_missing_streams(struct demux_internal *in, struct demux_cached_range *range) { for (int n = range->num_streams; n < in->num_streams; n++) { struct demux_stream *ds = in->streams[n]->ds; struct demux_queue *queue = talloc_ptrtype(range, queue); *queue = (struct demux_queue){ .ds = ds, .range = range, }; clear_queue(queue); MP_TARRAY_APPEND(range, range->streams, range->num_streams, queue); assert(range->streams[ds->index] == queue); } } // Allocate a new sh_stream of the given type. It either has to be released // with talloc_free(), or added to a demuxer with demux_add_sh_stream(). You // cannot add or read packets from the stream before it has been added. struct sh_stream *demux_alloc_sh_stream(enum stream_type type) { struct sh_stream *sh = talloc_ptrtype(NULL, sh); *sh = (struct sh_stream) { .type = type, .index = -1, .ff_index = -1, // may be overwritten by demuxer .demuxer_id = -1, // ... same .codec = talloc_zero(sh, struct mp_codec_params), .tags = talloc_zero(sh, struct mp_tags), }; sh->codec->type = type; return sh; } // Add a new sh_stream to the demuxer. Note that as soon as the stream has been // added, it must be immutable, and must not be released (this will happen when // the demuxer is destroyed). static void demux_add_sh_stream_locked(struct demux_internal *in, struct sh_stream *sh) { assert(!sh->ds); // must not be added yet sh->index = in->num_streams; sh->ds = talloc(sh, struct demux_stream); *sh->ds = (struct demux_stream) { .in = in, .sh = sh, .type = sh->type, .index = sh->index, .selected = in->autoselect, .global_correct_dts = true, .global_correct_pos = true, }; if (!sh->codec->codec) sh->codec->codec = ""; if (sh->ff_index < 0) sh->ff_index = sh->index; if (sh->demuxer_id < 0) { sh->demuxer_id = 0; for (int n = 0; n < in->num_streams; n++) { if (in->streams[n]->type == sh->type) sh->demuxer_id += 1; } } MP_TARRAY_APPEND(in, in->streams, in->num_streams, sh); assert(in->streams[sh->index] == sh); for (int n = 0; n < in->num_ranges; n++) add_missing_streams(in, in->ranges[n]); sh->ds->queue = in->current_range->streams[sh->ds->index]; update_stream_selection_state(in, sh->ds); in->events |= DEMUX_EVENT_STREAMS; if (in->wakeup_cb) in->wakeup_cb(in->wakeup_cb_ctx); } // For demuxer implementations only. void demux_add_sh_stream(struct demuxer *demuxer, struct sh_stream *sh) { struct demux_internal *in = demuxer->in; pthread_mutex_lock(&in->lock); demux_add_sh_stream_locked(in, sh); pthread_mutex_unlock(&in->lock); } // Update sh->tags (lazily). This must be called by demuxers which update // stream tags after init. (sh->tags can be accessed by the playback thread, // which means the demuxer thread cannot write or read it directly.) // Before init is finished, sh->tags can still be accessed freely. // Ownership of tags goes to the function. void demux_set_stream_tags(struct demuxer *demuxer, struct sh_stream *sh, struct mp_tags *tags) { struct demux_internal *in = demuxer->in; assert(demuxer == in->d_thread); if (sh->ds) { while (demuxer->num_update_stream_tags <= sh->index) { MP_TARRAY_APPEND(demuxer, demuxer->update_stream_tags, demuxer->num_update_stream_tags, NULL); } talloc_free(demuxer->update_stream_tags[sh->index]); demuxer->update_stream_tags[sh->index] = talloc_steal(demuxer, tags); demux_changed(demuxer, DEMUX_EVENT_METADATA); } else { // not added yet talloc_free(sh->tags); sh->tags = talloc_steal(sh, tags); } } // Return a stream with the given index. Since streams can only be added during // the lifetime of the demuxer, it is guaranteed that an index within the valid // range [0, demux_get_num_stream()) always returns a valid sh_stream pointer, // which will be valid until the demuxer is destroyed. struct sh_stream *demux_get_stream(struct demuxer *demuxer, int index) { struct demux_internal *in = demuxer->in; pthread_mutex_lock(&in->lock); assert(index >= 0 && index < in->num_streams); struct sh_stream *r = in->streams[index]; pthread_mutex_unlock(&in->lock); return r; } // See demux_get_stream(). int demux_get_num_stream(struct demuxer *demuxer) { struct demux_internal *in = demuxer->in; pthread_mutex_lock(&in->lock); int r = in->num_streams; pthread_mutex_unlock(&in->lock); return r; } void free_demuxer(demuxer_t *demuxer) { if (!demuxer) return; struct demux_internal *in = demuxer->in; assert(demuxer == in->d_user); demux_stop_thread(demuxer); if (demuxer->desc->close) demuxer->desc->close(in->d_thread); demux_flush(demuxer); assert(in->total_bytes == 0); for (int n = 0; n < in->num_streams; n++) talloc_free(in->streams[n]); pthread_mutex_destroy(&in->lock); pthread_cond_destroy(&in->wakeup); talloc_free(demuxer); } void free_demuxer_and_stream(struct demuxer *demuxer) { if (!demuxer) return; struct stream *s = demuxer->stream; free_demuxer(demuxer); free_stream(s); } // Start the demuxer thread, which reads ahead packets on its own. void demux_start_thread(struct demuxer *demuxer) { struct demux_internal *in = demuxer->in; assert(demuxer == in->d_user); if (!in->threading) { in->threading = true; if (pthread_create(&in->thread, NULL, demux_thread, in)) in->threading = false; } } void demux_stop_thread(struct demuxer *demuxer) { struct demux_internal *in = demuxer->in; assert(demuxer == in->d_user); if (in->threading) { pthread_mutex_lock(&in->lock); in->thread_terminate = true; pthread_cond_signal(&in->wakeup); pthread_mutex_unlock(&in->lock); pthread_join(in->thread, NULL); in->threading = false; in->thread_terminate = false; } } // The demuxer thread will call cb(ctx) if there's a new packet, or EOF is reached. void demux_set_wakeup_cb(struct demuxer *demuxer, void (*cb)(void *ctx), void *ctx) { struct demux_internal *in = demuxer->in; pthread_mutex_lock(&in->lock); in->wakeup_cb = cb; in->wakeup_cb_ctx = ctx; pthread_mutex_unlock(&in->lock); } const char *stream_type_name(enum stream_type type) { switch (type) { case STREAM_VIDEO: return "video"; case STREAM_AUDIO: return "audio"; case STREAM_SUB: return "sub"; default: return "unknown"; } } static struct sh_stream *demuxer_get_cc_track_locked(struct sh_stream *stream) { struct sh_stream *sh = stream->ds->cc; if (!sh) { sh = demux_alloc_sh_stream(STREAM_SUB); if (!sh) return NULL; sh->codec->codec = "eia_608"; sh->default_track = true; stream->ds->cc = sh; demux_add_sh_stream_locked(stream->ds->in, sh); sh->ds->ignore_eof = true; } return sh; } void demuxer_feed_caption(struct sh_stream *stream, demux_packet_t *dp) { struct demux_internal *in = stream->ds->in; pthread_mutex_lock(&in->lock); struct sh_stream *sh = demuxer_get_cc_track_locked(stream); if (!sh) { pthread_mutex_unlock(&in->lock); talloc_free(dp); return; } dp->pts = MP_ADD_PTS(dp->pts, -in->ts_offset); dp->dts = MP_ADD_PTS(dp->dts, -in->ts_offset); pthread_mutex_unlock(&in->lock); demux_add_packet(sh, dp); } // Add the keyframe to the end of the index. Not all packets are actually added. static void add_index_entry(struct demux_queue *queue, struct demux_packet *dp) { assert(dp->keyframe && dp->kf_seek_pts != MP_NOPTS_VALUE); if (queue->num_index) { double prev = queue->index[queue->num_index - 1]->kf_seek_pts; if (dp->kf_seek_pts < prev + queue->index_distance) return; } if (queue->num_index == MAX_INDEX_ENTRIES) { for (int n = 0; n < MAX_INDEX_ENTRIES / 2; n++) queue->index[n] = queue->index[n * 2]; queue->num_index = MAX_INDEX_ENTRIES / 2; queue->index_distance *= 2; } queue->index[queue->num_index++] = dp; } // Check whether the next range in the list is, and if it appears to overlap, // try joining it into a single range. static void attempt_range_joining(struct demux_internal *in) { struct demux_cached_range *next = NULL; double next_dist = INFINITY; assert(in->current_range && in->num_ranges > 0); assert(in->current_range == in->ranges[in->num_ranges - 1]); for (int n = 0; n < in->num_ranges - 1; n++) { struct demux_cached_range *range = in->ranges[n]; if (in->current_range->seek_start <= range->seek_start) { // This uses ">" to get some non-0 overlap. double dist = in->current_range->seek_end - range->seek_start; if (dist > 0 && dist < next_dist) { next = range; next_dist = dist; } } } if (!next) return; MP_VERBOSE(in, "going to join ranges %f-%f + %f-%f\n", in->current_range->seek_start, in->current_range->seek_end, next->seek_start, next->seek_end); // Try to find a join point, where packets obviously overlap. (It would be // better and faster to do this incrementally, but probably too complex.) // The current range can overlap arbitrarily with the next one, not only by // by the seek overlap, but for arbitrary packet readahead as well. // We also drop the overlapping packets (if joining fails, we discard the // entire next range anyway, so this does no harm). for (int n = 0; n < in->num_streams; n++) { struct demux_stream *ds = in->streams[n]->ds; struct demux_queue *q1 = in->current_range->streams[n]; struct demux_queue *q2 = next->streams[n]; if (!ds->global_correct_pos && !ds->global_correct_dts) { MP_WARN(in, "stream %d: ranges unjoinable\n", n); goto failed; } struct demux_packet *end = q1->tail; bool join_point_found = !end; // no packets yet -> joining will work if (end) { while (q2->head) { struct demux_packet *dp = q2->head; // Some weird corner-case. We'd have to search the equivalent // packet in q1 to update it correctly. Better just give up. if (dp == q2->keyframe_latest) { MP_VERBOSE(in, "stream %d: not enough keyframes for join\n", n); goto failed; } if ((ds->global_correct_dts && dp->dts == end->dts) || (ds->global_correct_pos && dp->pos == end->pos)) { // Do some additional checks as a (imperfect) sanity check // in case pos/dts are not "correct" across the ranges (we // never actually check that). if (dp->dts != end->dts || dp->pos != end->pos || dp->pts != end->pts || dp->len != end->len) { MP_WARN(in, "stream %d: weird demuxer behavior\n", n); goto failed; } // q1 usually meets q2 at a keyframe. q1 will end on a key- // frame (because it tries joining when reading a keyframe). // Obviously, q1 can not know the kf_seek_pts yet; it would // have to read packets after it to compute it. Ideally, // we'd remove it and use q2's packet, but the linked list // makes this hard, so copy this missing metadata instead. end->kf_seek_pts = dp->kf_seek_pts; remove_head_packet(q2); join_point_found = true; break; } // This happens if the next range misses the end packet. For // normal streams (ds->eager==true), this is a failure to find // an overlap. For subtitles, this can mean the current_range // has a subtitle somewhere before the end of its range, and // next has another subtitle somewhere after the start of its // range. if ((ds->global_correct_dts && dp->dts > end->dts) || (ds->global_correct_pos && dp->pos > end->pos)) break; remove_head_packet(q2); } } // For enabled non-sparse streams, always require an overlap packet. if (ds->eager && !join_point_found) { MP_WARN(in, "stream %d: no joint point found\n", n); goto failed; } } // Actually join the ranges. Now that we think it will work, mutate the // data associated with the current range. in->fw_bytes = 0; for (int n = 0; n < in->num_streams; n++) { struct demux_queue *q1 = in->current_range->streams[n]; struct demux_queue *q2 = next->streams[n]; struct demux_stream *ds = in->streams[n]->ds; if (q2->head) { if (q1->head) { q1->tail->next = q2->head; } else { q1->head = q2->head; } q1->tail = q2->tail; } q1->seek_end = q2->seek_end; q1->correct_dts &= q2->correct_dts; q1->correct_pos &= q2->correct_pos; q1->last_pos = q2->last_pos; q1->last_dts = q2->last_dts; q1->last_ts = q2->last_ts; q1->keyframe_pts = q2->keyframe_pts; q1->keyframe_end_pts = q2->keyframe_end_pts; q1->keyframe_latest = q2->keyframe_latest; q1->is_eof = q2->is_eof; q2->head = q2->tail = NULL; q2->next_prune_target = NULL; q2->keyframe_latest = NULL; for (int i = 0; i < q2->num_index; i++) add_index_entry(q1, q2->index[i]); q2->num_index = 0; recompute_buffers(ds); in->fw_bytes += ds->fw_bytes; // For moving demuxer position. ds->refreshing = ds->selected; } update_seek_ranges(in->current_range); // Move demuxing position to after the current range. in->seeking = true; in->seek_flags = SEEK_HR; in->seek_pts = next->seek_end - 1.0; MP_VERBOSE(in, "ranges joined!\n"); failed: clear_cached_range(in, next); free_empty_cached_ranges(in); } // Determine seekable range when a packet is added. If dp==NULL, treat it as // EOF (i.e. closes the current block). // This has to deal with a number of corner cases, such as demuxers potentially // starting output at non-keyframes. // Can join seek ranges, which messes with in->current_range and all. static void adjust_seek_range_on_packet(struct demux_stream *ds, struct demux_packet *dp) { struct demux_queue *queue = ds->queue; bool attempt_range_join = false; if (!ds->in->seekable_cache) return; if (!dp || dp->keyframe) { if (queue->keyframe_latest) { queue->keyframe_latest->kf_seek_pts = queue->keyframe_pts; double old_end = queue->range->seek_end; if (queue->seek_start == MP_NOPTS_VALUE) queue->seek_start = queue->keyframe_pts; if (queue->keyframe_end_pts != MP_NOPTS_VALUE) queue->seek_end = queue->keyframe_end_pts; queue->is_eof = !dp; update_seek_ranges(queue->range); attempt_range_join = queue->range->seek_end > old_end; if (queue->keyframe_latest->kf_seek_pts != MP_NOPTS_VALUE) add_index_entry(queue, queue->keyframe_latest); } queue->keyframe_latest = dp; queue->keyframe_pts = queue->keyframe_end_pts = MP_NOPTS_VALUE; } if (dp) { dp->kf_seek_pts = MP_NOPTS_VALUE; double ts = PTS_OR_DEF(dp->pts, dp->dts); if (dp->segmented && (ts < dp->start || ts > dp->end)) ts = MP_NOPTS_VALUE; queue->keyframe_pts = MP_PTS_MIN(queue->keyframe_pts, ts); queue->keyframe_end_pts = MP_PTS_MAX(queue->keyframe_end_pts, ts); if (queue->is_eof) { queue->is_eof = false; update_seek_ranges(queue->range); } } if (attempt_range_join) attempt_range_joining(ds->in); } void demux_add_packet(struct sh_stream *stream, demux_packet_t *dp) { struct demux_stream *ds = stream ? stream->ds : NULL; if (!dp || !dp->len || !ds) { talloc_free(dp); return; } struct demux_internal *in = ds->in; pthread_mutex_lock(&in->lock); in->initial_state = false; double ts = dp->dts == MP_NOPTS_VALUE ? dp->pts : dp->dts; if (dp->segmented) ts = MP_PTS_MIN(ts, dp->end); if (ts != MP_NOPTS_VALUE) in->demux_ts = ts; struct demux_queue *queue = ds->queue; bool drop = !ds->selected || in->seeking || ds->sh->attached_picture; if (!drop && ds->refreshing) { // Resume reading once the old position was reached (i.e. we start // returning packets where we left off before the refresh). // If it's the same position, drop, but continue normally next time. if (queue->correct_dts) { ds->refreshing = dp->dts < queue->last_dts; } else if (queue->correct_pos) { ds->refreshing = dp->pos < queue->last_pos; } else { ds->refreshing = false; // should not happen MP_WARN(in, "stream %d: demux refreshing failed\n", ds->index); } drop = true; } if (drop) { pthread_mutex_unlock(&in->lock); talloc_free(dp); return; } queue->correct_pos &= dp->pos >= 0 && dp->pos > queue->last_pos; queue->correct_dts &= dp->dts != MP_NOPTS_VALUE && dp->dts > queue->last_dts; queue->last_pos = dp->pos; queue->last_dts = dp->dts; ds->global_correct_pos &= queue->correct_pos; ds->global_correct_dts &= queue->correct_dts; dp->stream = stream->index; dp->next = NULL; // (keep in mind that even if the reader went out of data, the queue is not // necessarily empty due to the backbuffer) if (!ds->reader_head && (!ds->skip_to_keyframe || dp->keyframe)) { ds->reader_head = dp; ds->skip_to_keyframe = false; } size_t bytes = demux_packet_estimate_total_size(dp); ds->in->total_bytes += bytes; if (ds->reader_head) { ds->fw_packs++; ds->fw_bytes += bytes; in->fw_bytes += bytes; } if (queue->tail) { // next packet in stream queue->tail->next = dp; queue->tail = dp; } else { // first packet in stream queue->head = queue->tail = dp; } if (!ds->ignore_eof) { // obviously not true anymore ds->eof = false; in->last_eof = in->eof = false; } // For video, PTS determination is not trivial, but for other media types // distinguishing PTS and DTS is not useful. if (stream->type != STREAM_VIDEO && dp->pts == MP_NOPTS_VALUE) dp->pts = dp->dts; if (ts != MP_NOPTS_VALUE && (ts > queue->last_ts || ts + 10 < queue->last_ts)) queue->last_ts = ts; if (ds->base_ts == MP_NOPTS_VALUE) ds->base_ts = queue->last_ts; MP_TRACE(in, "append packet to %s: size=%d pts=%f dts=%f pos=%"PRIi64" " "[num=%zd size=%zd]\n", stream_type_name(stream->type), dp->len, dp->pts, dp->dts, dp->pos, ds->fw_packs, ds->fw_bytes); adjust_seek_range_on_packet(ds, dp); // Possible update duration based on highest TS demuxed (but ignore subs). if (stream->type != STREAM_SUB) { if (dp->segmented) ts = MP_PTS_MIN(ts, dp->end); if (ts > in->highest_av_pts) { in->highest_av_pts = ts; double duration = in->highest_av_pts - in->d_thread->start_time; if (duration > in->d_thread->duration) { in->d_thread->duration = duration; // (Don't wakeup like like demux_changed(), would be too noisy.) in->d_thread->events |= DEMUX_EVENT_DURATION; in->d_buffer->duration = duration; in->d_buffer->events |= DEMUX_EVENT_DURATION; } } } wakeup_ds(ds); pthread_mutex_unlock(&in->lock); } // Returns true if there was "progress" (lock was released temporarily). static bool read_packet(struct demux_internal *in) { in->eof = false; in->idle = true; if (!in->reading || in->blocked) return false; // Check if we need to read a new packet. We do this if all queues are below // the minimum, or if a stream explicitly needs new packets. Also includes // safe-guards against packet queue overflow. bool read_more = false, prefetch_more = false, refresh_more = false; for (int n = 0; n < in->num_streams; n++) { struct demux_stream *ds = in->streams[n]->ds; read_more |= ds->eager && !ds->reader_head; refresh_more |= ds->refreshing; if (ds->eager && ds->queue->last_ts != MP_NOPTS_VALUE && in->min_secs > 0 && ds->base_ts != MP_NOPTS_VALUE && ds->queue->last_ts >= ds->base_ts) prefetch_more |= ds->queue->last_ts - ds->base_ts < in->min_secs; } MP_TRACE(in, "bytes=%zd, read_more=%d prefetch_more=%d, refresh_more=%d\n", in->fw_bytes, read_more, prefetch_more, refresh_more); if (in->fw_bytes >= in->max_bytes) { // if we hit the limit just by prefetching, simply stop prefetching if (!read_more) return false; if (!in->warned_queue_overflow) { in->warned_queue_overflow = true; MP_WARN(in, "Too many packets in the demuxer packet queues:\n"); for (int n = 0; n < in->num_streams; n++) { struct demux_stream *ds = in->streams[n]->ds; if (ds->selected) { MP_WARN(in, " %s/%d: %zd packets, %zd bytes%s%s\n", stream_type_name(ds->type), n, ds->fw_packs, ds->fw_bytes, ds->eager ? "" : " (lazy)", ds->refreshing ? " (refreshing)" : ""); } } } for (int n = 0; n < in->num_streams; n++) { struct demux_stream *ds = in->streams[n]->ds; bool eof = !ds->reader_head; if (eof && ds->eof) wakeup_ds(ds); ds->eof |= eof; } return false; } if (!read_more && !prefetch_more && !refresh_more) return false; if (in->initial_state) { for (int n = 0; n < in->num_streams; n++) in->current_range->streams[n]->is_bof = in->streams[n]->ds->selected; } // Actually read a packet. Drop the lock while doing so, because waiting // for disk or network I/O can take time. in->idle = false; in->initial_state = false; pthread_mutex_unlock(&in->lock); struct demuxer *demux = in->d_thread; bool eof = true; if (demux->desc->fill_buffer && !demux_cancel_test(demux)) eof = demux->desc->fill_buffer(demux) <= 0; update_cache(in); pthread_mutex_lock(&in->lock); if (!in->seeking) { if (eof) { for (int n = 0; n < in->num_streams; n++) { struct demux_stream *ds = in->streams[n]->ds; if (!ds->eof) adjust_seek_range_on_packet(ds, NULL); ds->eof = true; if (!in->last_eof && ds->wakeup_cb) wakeup_ds(ds); } // If we had EOF previously, then don't wakeup (avoids wakeup loop) if (!in->last_eof) { if (in->wakeup_cb) in->wakeup_cb(in->wakeup_cb_ctx); pthread_cond_signal(&in->wakeup); MP_VERBOSE(in, "EOF reached.\n"); } } in->eof = in->last_eof = eof; } return true; } static void prune_old_packets(struct demux_internal *in) { assert(in->current_range == in->ranges[in->num_ranges - 1]); // It's not clear what the ideal way to prune old packets is. For now, we // prune the oldest packet runs, as long as the total cache amount is too // big. size_t max_bytes = in->seekable_cache ? in->max_bytes_bw : 0; while (in->total_bytes - in->fw_bytes > max_bytes) { // (Start from least recently used range.) struct demux_cached_range *range = in->ranges[0]; double earliest_ts = MP_NOPTS_VALUE; struct demux_stream *earliest_stream = NULL; for (int n = 0; n < range->num_streams; n++) { struct demux_queue *queue = range->streams[n]; struct demux_stream *ds = queue->ds; if (queue->head && queue->head != ds->reader_head) { struct demux_packet *dp = queue->head; double ts = dp->kf_seek_pts; // Note: in obscure cases, packets might have no timestamps set, // in which case we still need to prune _something_. bool prune_always = !in->seekable_cache || ts == MP_NOPTS_VALUE || !dp->keyframe; if (prune_always || !earliest_stream || ts < earliest_ts) { earliest_ts = ts; earliest_stream = ds; if (prune_always) break; } } } assert(earliest_stream); // incorrect accounting of buffered sizes? struct demux_stream *ds = earliest_stream; struct demux_queue *queue = range->streams[ds->index]; // Prune all packets until the next keyframe or reader_head. Keeping // those packets would not help with seeking at all, so we strictly // drop them. // In addition, we need to find the new possibly min. seek target, // which in the worst case could be inside the forward buffer. The fact // that many keyframe ranges without keyframes exist (audio packets) // makes this much harder. if (in->seekable_cache && !queue->next_prune_target) { // (Has to be _after_ queue->head to drop at least 1 packet.) struct demux_packet *prev = queue->head; if (queue->seek_start != MP_NOPTS_VALUE) queue->last_pruned = queue->seek_start; queue->seek_start = MP_NOPTS_VALUE; queue->next_prune_target = queue->tail; // (prune all if none found) while (prev->next) { struct demux_packet *dp = prev->next; // Note that the next back_pts might be above the lowest buffered // packet, but it will still be only viable lowest seek target. if (dp->keyframe && dp->kf_seek_pts != MP_NOPTS_VALUE) { queue->seek_start = dp->kf_seek_pts; queue->next_prune_target = prev; break; } prev = prev->next; } update_seek_ranges(range); } bool done = false; while (!done && queue->head && queue->head != ds->reader_head) { done = queue->next_prune_target == queue->head; remove_head_packet(queue); } if (range != in->current_range && range->seek_start == MP_NOPTS_VALUE) free_empty_cached_ranges(in); } } static void execute_trackswitch(struct demux_internal *in) { in->tracks_switched = false; bool any_selected = false; for (int n = 0; n < in->num_streams; n++) any_selected |= in->streams[n]->ds->selected; pthread_mutex_unlock(&in->lock); if (in->d_thread->desc->control) in->d_thread->desc->control(in->d_thread, DEMUXER_CTRL_SWITCHED_TRACKS, 0); stream_control(in->d_thread->stream, STREAM_CTRL_SET_READAHEAD, &(int){any_selected}); pthread_mutex_lock(&in->lock); } static void execute_seek(struct demux_internal *in) { int flags = in->seek_flags; double pts = in->seek_pts; in->seeking = false; in->seeking_in_progress = pts; in->demux_ts = MP_NOPTS_VALUE; in->low_level_seeks += 1; in->initial_state = false; pthread_mutex_unlock(&in->lock); MP_VERBOSE(in, "execute seek (to %f flags %d)\n", pts, flags); if (in->d_thread->desc->seek) in->d_thread->desc->seek(in->d_thread, pts, flags); MP_VERBOSE(in, "seek done\n"); pthread_mutex_lock(&in->lock); in->seeking_in_progress = MP_NOPTS_VALUE; } // Make demuxing progress. Return whether progress was made. static bool thread_work(struct demux_internal *in) { if (in->run_fn) { in->run_fn(in->run_fn_arg); in->run_fn = NULL; pthread_cond_signal(&in->wakeup); return true; } if (in->tracks_switched) { execute_trackswitch(in); return true; } if (in->seeking) { execute_seek(in); return true; } if (!in->eof) { if (read_packet(in)) return true; // read_packet unlocked, so recheck conditions } if (in->force_cache_update) { pthread_mutex_unlock(&in->lock); update_cache(in); pthread_mutex_lock(&in->lock); in->force_cache_update = false; return true; } return false; } static void *demux_thread(void *pctx) { struct demux_internal *in = pctx; mpthread_set_name("demux"); pthread_mutex_lock(&in->lock); while (!in->thread_terminate) { if (thread_work(in)) continue; pthread_cond_signal(&in->wakeup); pthread_cond_wait(&in->wakeup, &in->lock); } pthread_mutex_unlock(&in->lock); return NULL; } static struct demux_packet *dequeue_packet(struct demux_stream *ds) { if (ds->sh->attached_picture) { ds->eof = true; if (ds->attached_picture_added) return NULL; ds->attached_picture_added = true; struct demux_packet *pkt = demux_copy_packet(ds->sh->attached_picture); if (!pkt) abort(); pkt->stream = ds->sh->index; return pkt; } if (!ds->reader_head || ds->in->blocked) return NULL; struct demux_packet *pkt = ds->reader_head; ds->reader_head = pkt->next; // Update cached packet queue state. ds->fw_packs--; size_t bytes = demux_packet_estimate_total_size(pkt); ds->fw_bytes -= bytes; ds->in->fw_bytes -= bytes; ds->last_ret_pos = pkt->pos; ds->last_ret_dts = pkt->dts; // The returned packet is mutated etc. and will be owned by the user. pkt = demux_copy_packet(pkt); if (!pkt) abort(); pkt->next = NULL; double ts = PTS_OR_DEF(pkt->dts, pkt->pts); if (ts != MP_NOPTS_VALUE) ds->base_ts = ts; if (pkt->keyframe && ts != MP_NOPTS_VALUE) { // Update bitrate - only at keyframe points, because we use the // (possibly) reordered packet timestamps instead of realtime. double d = ts - ds->last_br_ts; if (ds->last_br_ts == MP_NOPTS_VALUE || d < 0) { ds->bitrate = -1; ds->last_br_ts = ts; ds->last_br_bytes = 0; } else if (d >= 0.5) { // a window of least 500ms for UI purposes ds->bitrate = ds->last_br_bytes / d; ds->last_br_ts = ts; ds->last_br_bytes = 0; } } ds->last_br_bytes += pkt->len; // This implies this function is actually called from "the" user thread. if (pkt->pos >= ds->in->d_user->filepos) ds->in->d_user->filepos = pkt->pos; pkt->pts = MP_ADD_PTS(pkt->pts, ds->in->ts_offset); pkt->dts = MP_ADD_PTS(pkt->dts, ds->in->ts_offset); if (pkt->segmented) { pkt->start = MP_ADD_PTS(pkt->start, ds->in->ts_offset); pkt->end = MP_ADD_PTS(pkt->end, ds->in->ts_offset); } prune_old_packets(ds->in); return pkt; } // Read a packet from the given stream. The returned packet belongs to the // caller, who has to free it with talloc_free(). Might block. Returns NULL // on EOF. struct demux_packet *demux_read_packet(struct sh_stream *sh) { struct demux_stream *ds = sh ? sh->ds : NULL; if (!ds) return NULL; struct demux_internal *in = ds->in; pthread_mutex_lock(&in->lock); if (ds->eager) { const char *t = stream_type_name(ds->type); MP_DBG(in, "reading packet for %s\n", t); in->eof = false; // force retry ds->need_wakeup = true; while (ds->selected && !ds->reader_head && !in->blocked) { in->reading = true; // Note: the following code marks EOF if it can't continue if (in->threading) { MP_VERBOSE(in, "waiting for demux thread (%s)\n", t); pthread_cond_signal(&in->wakeup); pthread_cond_wait(&in->wakeup, &in->lock); } else { thread_work(in); } if (ds->eof) break; } } struct demux_packet *pkt = dequeue_packet(ds); pthread_cond_signal(&in->wakeup); // possibly read more pthread_mutex_unlock(&in->lock); return pkt; } // Poll the demuxer queue, and if there's a packet, return it. Otherwise, just // make the demuxer thread read packets for this stream, and if there's at // least one packet, call the wakeup callback. // Unlike demux_read_packet(), this always enables readahead (except for // interleaved subtitles). // Returns: // < 0: EOF was reached, *out_pkt=NULL // == 0: no new packet yet, but maybe later, *out_pkt=NULL // > 0: new packet read, *out_pkt is set // Note: when reading interleaved subtitles, the demuxer won't try to forcibly // read ahead to get the next subtitle packet (as the next packet could be // minutes away). In this situation, this function will just return -1. int demux_read_packet_async(struct sh_stream *sh, struct demux_packet **out_pkt) { struct demux_stream *ds = sh ? sh->ds : NULL; int r = -1; *out_pkt = NULL; if (!ds) return r; if (ds->in->threading) { pthread_mutex_lock(&ds->in->lock); *out_pkt = dequeue_packet(ds); if (ds->eager) { r = *out_pkt ? 1 : (ds->eof ? -1 : 0); ds->in->reading = true; // enable readahead ds->in->eof = false; // force retry pthread_cond_signal(&ds->in->wakeup); // possibly read more } else { r = *out_pkt ? 1 : -1; } ds->need_wakeup = r != 1; pthread_mutex_unlock(&ds->in->lock); } else { if (ds->in->blocked) { r = 0; } else { *out_pkt = demux_read_packet(sh); r = *out_pkt ? 1 : -1; } ds->need_wakeup = r != 1; } return r; } // Return whether a packet is queued. Never blocks, never forces any reads. bool demux_has_packet(struct sh_stream *sh) { bool has_packet = false; if (sh) { pthread_mutex_lock(&sh->ds->in->lock); has_packet = sh->ds->reader_head; pthread_mutex_unlock(&sh->ds->in->lock); } return has_packet; } // Read and return any packet we find. NULL means EOF. struct demux_packet *demux_read_any_packet(struct demuxer *demuxer) { struct demux_internal *in = demuxer->in; assert(!in->threading); // doesn't work with threading bool read_more = true; while (read_more && !in->blocked) { for (int n = 0; n < in->num_streams; n++) { in->reading = true; // force read_packet() to read struct demux_packet *pkt = dequeue_packet(in->streams[n]->ds); if (pkt) return pkt; } // retry after calling this pthread_mutex_lock(&in->lock); // lock only because thread_work unlocks read_more = thread_work(in); read_more &= !in->eof; pthread_mutex_unlock(&in->lock); } return NULL; } void demuxer_help(struct mp_log *log) { int i; mp_info(log, "Available demuxers:\n"); mp_info(log, " demuxer: info:\n"); for (i = 0; demuxer_list[i]; i++) { mp_info(log, "%10s %s\n", demuxer_list[i]->name, demuxer_list[i]->desc); } } static const char *d_level(enum demux_check level) { switch (level) { case DEMUX_CHECK_FORCE: return "force"; case DEMUX_CHECK_UNSAFE: return "unsafe"; case DEMUX_CHECK_REQUEST:return "request"; case DEMUX_CHECK_NORMAL: return "normal"; } abort(); } static int decode_float(char *str, float *out) { char *rest; float dec_val; dec_val = strtod(str, &rest); if (!rest || (rest == str) || !isfinite(dec_val)) return -1; *out = dec_val; return 0; } static int decode_gain(struct mp_log *log, struct mp_tags *tags, const char *tag, float *out) { char *tag_val = NULL; float dec_val; tag_val = mp_tags_get_str(tags, tag); if (!tag_val) return -1; if (decode_float(tag_val, &dec_val) < 0) { mp_msg(log, MSGL_ERR, "Invalid replaygain value\n"); return -1; } *out = dec_val; return 0; } static int decode_peak(struct mp_log *log, struct mp_tags *tags, const char *tag, float *out) { char *tag_val = NULL; float dec_val; *out = 1.0; tag_val = mp_tags_get_str(tags, tag); if (!tag_val) return 0; if (decode_float(tag_val, &dec_val) < 0 || dec_val <= 0.0) return -1; *out = dec_val; return 0; } static struct replaygain_data *decode_rgain(struct mp_log *log, struct mp_tags *tags) { struct replaygain_data rg = {0}; if (decode_gain(log, tags, "REPLAYGAIN_TRACK_GAIN", &rg.track_gain) >= 0 && decode_peak(log, tags, "REPLAYGAIN_TRACK_PEAK", &rg.track_peak) >= 0) { if (decode_gain(log, tags, "REPLAYGAIN_ALBUM_GAIN", &rg.album_gain) < 0 || decode_peak(log, tags, "REPLAYGAIN_ALBUM_PEAK", &rg.album_peak) < 0) { rg.album_gain = rg.track_gain; rg.album_peak = rg.track_peak; } return talloc_dup(NULL, &rg); } if (decode_gain(log, tags, "REPLAYGAIN_GAIN", &rg.track_gain) >= 0 && decode_peak(log, tags, "REPLAYGAIN_PEAK", &rg.track_peak) >= 0) { rg.album_gain = rg.track_gain; rg.album_peak = rg.track_peak; return talloc_dup(NULL, &rg); } return NULL; } static void demux_update_replaygain(demuxer_t *demuxer) { struct demux_internal *in = demuxer->in; for (int n = 0; n < in->num_streams; n++) { struct sh_stream *sh = in->streams[n]; if (sh->type == STREAM_AUDIO && !sh->codec->replaygain_data) { struct replaygain_data *rg = decode_rgain(demuxer->log, sh->tags); if (!rg) rg = decode_rgain(demuxer->log, demuxer->metadata); if (rg) sh->codec->replaygain_data = talloc_steal(in, rg); } } } // Copy all fields from src to dst, depending on event flags. static void demux_copy(struct demuxer *dst, struct demuxer *src) { if (src->events & DEMUX_EVENT_INIT) { // Note that we do as shallow copies as possible. We expect the data // that is not-copied (only referenced) to be immutable. // This implies e.g. that no chapters are added after initialization. dst->chapters = src->chapters; dst->num_chapters = src->num_chapters; dst->editions = src->editions; dst->num_editions = src->num_editions; dst->edition = src->edition; dst->attachments = src->attachments; dst->num_attachments = src->num_attachments; dst->matroska_data = src->matroska_data; dst->playlist = src->playlist; dst->seekable = src->seekable; dst->partially_seekable = src->partially_seekable; dst->filetype = src->filetype; dst->ts_resets_possible = src->ts_resets_possible; dst->fully_read = src->fully_read; dst->start_time = src->start_time; dst->duration = src->duration; dst->is_network = src->is_network; dst->priv = src->priv; } if (src->events & DEMUX_EVENT_METADATA) { talloc_free(dst->metadata); dst->metadata = mp_tags_dup(dst, src->metadata); if (dst->num_update_stream_tags != src->num_update_stream_tags) { dst->num_update_stream_tags = src->num_update_stream_tags; talloc_free(dst->update_stream_tags); dst->update_stream_tags = talloc_zero_array(dst, struct mp_tags *, dst->num_update_stream_tags); } for (int n = 0; n < dst->num_update_stream_tags; n++) { talloc_free(dst->update_stream_tags[n]); dst->update_stream_tags[n] = talloc_steal(dst->update_stream_tags, src->update_stream_tags[n]); src->update_stream_tags[n] = NULL; } } if (src->events & DEMUX_EVENT_DURATION) dst->duration = src->duration; dst->events |= src->events; src->events = 0; } // This is called by demuxer implementations if certain parameters change // at runtime. // events is one of DEMUX_EVENT_* // The code will copy the fields references by the events to the user-thread. void demux_changed(demuxer_t *demuxer, int events) { assert(demuxer == demuxer->in->d_thread); // call from demuxer impl. only struct demux_internal *in = demuxer->in; demuxer->events |= events; update_cache(in); pthread_mutex_lock(&in->lock); if (demuxer->events & DEMUX_EVENT_INIT) demuxer_sort_chapters(demuxer); demux_copy(in->d_buffer, demuxer); if (in->wakeup_cb) in->wakeup_cb(in->wakeup_cb_ctx); pthread_mutex_unlock(&in->lock); } // Called locked, with user demuxer. static void update_final_metadata(demuxer_t *demuxer) { assert(demuxer == demuxer->in->d_user); struct demux_internal *in = demuxer->in; int num_streams = MPMIN(in->num_streams, demuxer->num_update_stream_tags); for (int n = 0; n < num_streams; n++) { struct mp_tags *tags = demuxer->update_stream_tags[n]; demuxer->update_stream_tags[n] = NULL; if (tags) { struct sh_stream *sh = in->streams[n]; talloc_free(sh->tags); sh->tags = talloc_steal(sh, tags); } } // Often for useful audio-only files, which have metadata in the audio track // metadata instead of the main metadata, but can also have cover art // metadata (which libavformat likes to treat as video streams). int astreams = 0; int astream_id = -1; int vstreams = 0; for (int n = 0; n < in->num_streams; n++) { struct sh_stream *sh = in->streams[n]; if (sh->type == STREAM_VIDEO && !sh->attached_picture) vstreams += 1; if (sh->type == STREAM_AUDIO) { astreams += 1; astream_id = n; } } if (vstreams == 0 && astreams == 1) mp_tags_merge(demuxer->metadata, in->streams[astream_id]->tags); if (in->stream_metadata) mp_tags_merge(demuxer->metadata, in->stream_metadata); } // Called by the user thread (i.e. player) to update metadata and other things // from the demuxer thread. void demux_update(demuxer_t *demuxer) { assert(demuxer == demuxer->in->d_user); struct demux_internal *in = demuxer->in; if (!in->threading) update_cache(in); pthread_mutex_lock(&in->lock); demux_copy(demuxer, in->d_buffer); demuxer->events |= in->events; in->events = 0; if (demuxer->events & DEMUX_EVENT_METADATA) update_final_metadata(demuxer); if (demuxer->events & (DEMUX_EVENT_METADATA | DEMUX_EVENT_STREAMS)) demux_update_replaygain(demuxer); pthread_mutex_unlock(&in->lock); } static void demux_init_cache(struct demuxer *demuxer) { struct demux_internal *in = demuxer->in; struct stream *stream = demuxer->stream; char *base = NULL; stream_control(stream, STREAM_CTRL_GET_BASE_FILENAME, &base); in->stream_base_filename = talloc_steal(demuxer, base); } static void demux_init_cuesheet(struct demuxer *demuxer) { char *cue = mp_tags_get_str(demuxer->metadata, "cuesheet"); if (cue && !demuxer->num_chapters) { struct cue_file *f = mp_parse_cue(bstr0(cue)); if (f) { if (mp_check_embedded_cue(f) < 0) { MP_WARN(demuxer, "Embedded cue sheet references more than one file. " "Ignoring it.\n"); } else { for (int n = 0; n < f->num_tracks; n++) { struct cue_track *t = &f->tracks[n]; int idx = demuxer_add_chapter(demuxer, "", t->start, -1); mp_tags_merge(demuxer->chapters[idx].metadata, t->tags); } } } talloc_free(f); } } static void demux_maybe_replace_stream(struct demuxer *demuxer) { struct demux_internal *in = demuxer->in; assert(!in->threading && demuxer == in->d_user); if (demuxer->fully_read) { MP_VERBOSE(demuxer, "assuming demuxer read all data; closing stream\n"); free_stream(demuxer->stream); demuxer->stream = open_memory_stream(NULL, 0); // dummy in->d_thread->stream = demuxer->stream; in->d_buffer->stream = demuxer->stream; if (demuxer->desc->control) demuxer->desc->control(in->d_thread, DEMUXER_CTRL_REPLACE_STREAM, NULL); } } static void demux_init_ccs(struct demuxer *demuxer, struct demux_opts *opts) { struct demux_internal *in = demuxer->in; if (!opts->create_ccs) return; pthread_mutex_lock(&in->lock); for (int n = 0; n < in->num_streams; n++) { struct sh_stream *sh = in->streams[n]; if (sh->type == STREAM_VIDEO) demuxer_get_cc_track_locked(sh); } pthread_mutex_unlock(&in->lock); } static struct demuxer *open_given_type(struct mpv_global *global, struct mp_log *log, const struct demuxer_desc *desc, struct stream *stream, struct demuxer_params *params, enum demux_check check) { if (mp_cancel_test(stream->cancel)) return NULL; struct demuxer *demuxer = talloc_ptrtype(NULL, demuxer); struct demux_opts *opts = mp_get_config_group(demuxer, global, &demux_conf); *demuxer = (struct demuxer) { .desc = desc, .stream = stream, .seekable = stream->seekable, .filepos = -1, .global = global, .log = mp_log_new(demuxer, log, desc->name), .glog = log, .filename = talloc_strdup(demuxer, stream->url), .is_network = stream->is_network, .access_references = opts->access_references, .events = DEMUX_EVENT_ALL, .duration = -1, }; demuxer->seekable = stream->seekable; if (demuxer->stream->underlying && !demuxer->stream->underlying->seekable) demuxer->seekable = false; struct demux_internal *in = demuxer->in = talloc_ptrtype(demuxer, in); *in = (struct demux_internal){ .log = demuxer->log, .d_thread = talloc(demuxer, struct demuxer), .d_buffer = talloc(demuxer, struct demuxer), .d_user = demuxer, .min_secs = opts->min_secs, .max_bytes = opts->max_bytes, .max_bytes_bw = opts->max_bytes_bw, .initial_state = true, .highest_av_pts = MP_NOPTS_VALUE, .seeking_in_progress = MP_NOPTS_VALUE, .demux_ts = MP_NOPTS_VALUE, }; pthread_mutex_init(&in->lock, NULL); pthread_cond_init(&in->wakeup, NULL); in->current_range = talloc_ptrtype(in, in->current_range); *in->current_range = (struct demux_cached_range){ .seek_start = MP_NOPTS_VALUE, .seek_end = MP_NOPTS_VALUE, }; MP_TARRAY_APPEND(in, in->ranges, in->num_ranges, in->current_range); *in->d_thread = *demuxer; *in->d_buffer = *demuxer; in->d_thread->metadata = talloc_zero(in->d_thread, struct mp_tags); in->d_user->metadata = talloc_zero(in->d_user, struct mp_tags); in->d_buffer->metadata = talloc_zero(in->d_buffer, struct mp_tags); mp_dbg(log, "Trying demuxer: %s (force-level: %s)\n", desc->name, d_level(check)); // not for DVD/BD/DVB in particular if (stream->seekable && (!params || !params->timeline)) stream_seek(stream, 0); // Peek this much data to avoid that stream_read() run by some demuxers // will flush previous peeked data. stream_peek(stream, STREAM_BUFFER_SIZE); in->d_thread->params = params; // temporary during open() int ret = demuxer->desc->open(in->d_thread, check); if (ret >= 0) { in->d_thread->params = NULL; if (in->d_thread->filetype) mp_verbose(log, "Detected file format: %s (%s)\n", in->d_thread->filetype, desc->desc); else mp_verbose(log, "Detected file format: %s\n", desc->desc); if (!in->d_thread->seekable) mp_verbose(log, "Stream is not seekable.\n"); if (!in->d_thread->seekable && opts->force_seekable) { mp_warn(log, "Not seekable, but enabling seeking on user request.\n"); in->d_thread->seekable = true; in->d_thread->partially_seekable = true; } demux_init_cuesheet(in->d_thread); demux_init_cache(demuxer); demux_init_ccs(demuxer, opts); demux_changed(in->d_thread, DEMUX_EVENT_ALL); demux_update(demuxer); stream_control(demuxer->stream, STREAM_CTRL_SET_READAHEAD, &(int){params ? params->initial_readahead : false}); int seekable = opts->seekable_cache; if (demuxer->is_network || stream->caching) { in->min_secs = MPMAX(in->min_secs, opts->min_secs_cache); if (seekable < 0) seekable = 1; } in->seekable_cache = seekable == 1; if (!(params && params->disable_timeline)) { struct timeline *tl = timeline_load(global, log, demuxer); if (tl) { struct demuxer_params params2 = {0}; params2.timeline = tl; struct demuxer *sub = open_given_type(global, log, &demuxer_desc_timeline, stream, ¶ms2, DEMUX_CHECK_FORCE); if (sub) { demuxer = sub; } else { timeline_destroy(tl); } } } return demuxer; } free_demuxer(demuxer); return NULL; } static const int d_normal[] = {DEMUX_CHECK_NORMAL, DEMUX_CHECK_UNSAFE, -1}; static const int d_request[] = {DEMUX_CHECK_REQUEST, -1}; static const int d_force[] = {DEMUX_CHECK_FORCE, -1}; // params can be NULL struct demuxer *demux_open(struct stream *stream, struct demuxer_params *params, struct mpv_global *global) { const int *check_levels = d_normal; const struct demuxer_desc *check_desc = NULL; struct mp_log *log = mp_log_new(NULL, global->log, "!demux"); struct demuxer *demuxer = NULL; char *force_format = params ? params->force_format : NULL; if (!force_format) force_format = stream->demuxer; if (force_format && force_format[0]) { check_levels = d_request; if (force_format[0] == '+') { force_format += 1; check_levels = d_force; } for (int n = 0; demuxer_list[n]; n++) { if (strcmp(demuxer_list[n]->name, force_format) == 0) check_desc = demuxer_list[n]; } if (!check_desc) { mp_err(log, "Demuxer %s does not exist.\n", force_format); goto done; } } // Test demuxers from first to last, one pass for each check_levels[] entry for (int pass = 0; check_levels[pass] != -1; pass++) { enum demux_check level = check_levels[pass]; mp_verbose(log, "Trying demuxers for level=%s.\n", d_level(level)); for (int n = 0; demuxer_list[n]; n++) { const struct demuxer_desc *desc = demuxer_list[n]; if (!check_desc || desc == check_desc) { demuxer = open_given_type(global, log, desc, stream, params, level); if (demuxer) { talloc_steal(demuxer, log); log = NULL; goto done; } } } } done: talloc_free(log); return demuxer; } // Convenience function: open the stream, enable the cache (according to params // and global opts.), open the demuxer. // (use free_demuxer_and_stream() to free the underlying stream too) // Also for some reason may close the opened stream if it's not needed. struct demuxer *demux_open_url(const char *url, struct demuxer_params *params, struct mp_cancel *cancel, struct mpv_global *global) { struct demuxer_params dummy = {0}; if (!params) params = &dummy; struct stream *s = stream_create(url, STREAM_READ | params->stream_flags, cancel, global); if (!s) return NULL; if (!params->disable_cache) stream_enable_cache_defaults(&s); struct demuxer *d = demux_open(s, params, global); if (d) { demux_maybe_replace_stream(d); } else { params->demuxer_failed = true; free_stream(s); } return d; } // called locked, from user thread only static void clear_reader_state(struct demux_internal *in) { for (int n = 0; n < in->num_streams; n++) ds_clear_reader_state(in->streams[n]->ds); in->warned_queue_overflow = false; in->d_user->filepos = -1; // implicitly synchronized in->blocked = false; assert(in->fw_bytes == 0); } // clear the packet queues void demux_flush(demuxer_t *demuxer) { struct demux_internal *in = demuxer->in; assert(demuxer == in->d_user); pthread_mutex_lock(&demuxer->in->lock); clear_reader_state(in); for (int n = 0; n < in->num_ranges; n++) clear_cached_range(in, in->ranges[n]); free_empty_cached_ranges(in); pthread_mutex_unlock(&demuxer->in->lock); } // Does some (but not all) things for switching to another range. static void switch_current_range(struct demux_internal *in, struct demux_cached_range *range) { struct demux_cached_range *old = in->current_range; assert(old != range); set_current_range(in, range); // Remove packets which can't be used when seeking back to the range. for (int n = 0; n < in->num_streams; n++) { struct demux_queue *queue = old->streams[n]; // Remove all packets from head up until including next_prune_target. while (queue->next_prune_target) remove_head_packet(queue); } // Exclude weird corner cases that break resuming. for (int n = 0; n < in->num_streams; n++) { struct demux_stream *ds = in->streams[n]->ds; // This is needed to resume or join the range at all. if (ds->selected && !(ds->global_correct_dts || ds->global_correct_pos)) { MP_VERBOSE(in, "discarding old range, due to stream %d: " "correct_dts=%d correct_pos=%d\n", n, ds->global_correct_dts, ds->global_correct_pos); clear_cached_range(in, old); break; } } // Set up reading from new range (as well as writing to it). for (int n = 0; n < in->num_streams; n++) { struct demux_stream *ds = in->streams[n]->ds; ds->queue = range->streams[n]; ds->refreshing = false; ds->eof = false; } // No point in keeping any junk (especially if old current_range is empty). free_empty_cached_ranges(in); } static struct demux_packet *find_seek_target(struct demux_queue *queue, double pts, int flags) { struct demux_packet *start = queue->head; for (int n = 0; n < queue->num_index; n++) { if (queue->index[n]->kf_seek_pts > pts) break; start = queue->index[n]; } struct demux_packet *target = NULL; double target_diff = MP_NOPTS_VALUE; for (struct demux_packet *dp = start; dp; dp = dp->next) { double range_pts = dp->kf_seek_pts; if (!dp->keyframe || range_pts == MP_NOPTS_VALUE) continue; double diff = range_pts - pts; if (flags & SEEK_FORWARD) { diff = -diff; if (diff > 0) continue; } if (target) { if (diff <= 0) { if (target_diff <= 0 && diff <= target_diff) continue; } else if (diff >= target_diff) continue; } target_diff = diff; target = dp; if (range_pts > pts) break; } return target; } // must be called locked static struct demux_cached_range *find_cache_seek_target(struct demux_internal *in, double pts, int flags) { // Note about queued low level seeks: in->seeking can be true here, and it // might come from a previous resume seek to the current range. If we end // up seeking into the current range (i.e. just changing time offset), the // seek needs to continue. Otherwise, we override the queued seek anyway. if ((flags & SEEK_FACTOR) || !in->seekable_cache) return NULL; for (int n = 0; n < in->num_ranges; n++) { struct demux_cached_range *r = in->ranges[n]; if (r->seek_start != MP_NOPTS_VALUE) { MP_VERBOSE(in, "cached range %d: %f <-> %f (bof=%d, eof=%d)\n", n, r->seek_start, r->seek_end, r->is_bof, r->is_eof); if ((pts >= r->seek_start || r->is_bof) && (pts <= r->seek_end || r->is_eof)) { MP_VERBOSE(in, "...using this range for in-cache seek.\n"); return r; } } } return NULL; } // must be called locked // range must be non-NULL and from find_cache_seek_target() using the same pts // and flags, before any other changes to the cached state static void execute_cache_seek(struct demux_internal *in, struct demux_cached_range *range, double pts, int flags) { // Adjust the seek target to the found video key frames. Otherwise the // video will undershoot the seek target, while audio will be closer to it. // The player frontend will play the additional video without audio, so // you get silent audio for the amount of "undershoot". Adjusting the seek // target will make the audio seek to the video target or before. // (If hr-seeks are used, it's better to skip this, as it would only mean // that more audio data than necessary would have to be decoded.) if (!(flags & SEEK_HR)) { for (int n = 0; n < in->num_streams; n++) { struct demux_stream *ds = in->streams[n]->ds; struct demux_queue *queue = range->streams[n]; if (ds->selected && ds->type == STREAM_VIDEO) { struct demux_packet *target = find_seek_target(queue, pts, flags); if (target) { double target_pts = target->kf_seek_pts; if (target_pts != MP_NOPTS_VALUE) { MP_VERBOSE(in, "adjust seek target %f -> %f\n", pts, target_pts); // (We assume the find_seek_target() will return the // same target for the video stream.) pts = target_pts; flags &= ~SEEK_FORWARD; } } break; } } } for (int n = 0; n < in->num_streams; n++) { struct demux_stream *ds = in->streams[n]->ds; struct demux_queue *queue = range->streams[n]; struct demux_packet *target = find_seek_target(queue, pts, flags); ds->reader_head = target; ds->skip_to_keyframe = !target; if (ds->reader_head) ds->base_ts = PTS_OR_DEF(ds->reader_head->pts, ds->reader_head->dts); recompute_buffers(ds); in->fw_bytes += ds->fw_bytes; MP_VERBOSE(in, "seeking stream %d (%s) to ", n, stream_type_name(ds->type)); if (target) { MP_VERBOSE(in, "packet %f/%f\n", target->pts, target->dts); } else { MP_VERBOSE(in, "nothing\n"); } } // If we seek to another range, we want to seek the low level demuxer to // there as well, because reader and demuxer queue must be the same. if (in->current_range != range) { switch_current_range(in, range); in->seeking = true; in->seek_flags = SEEK_HR; in->seek_pts = range->seek_end - 1.0; // When new packets are being appended, they could overlap with the old // range due to demuxer seek imprecisions, or because the queue contains // packets past the seek target but before the next seek target. Don't // append them twice, instead skip them until new packets are found. for (int n = 0; n < in->num_streams; n++) { struct demux_stream *ds = in->streams[n]->ds; ds->refreshing = ds->selected; } MP_VERBOSE(in, "resuming demuxer to end of cached range\n"); } } // Create a new blank cache range, and backup the old one. If the seekable // demuxer cache is disabled, merely reset the current range to a blank state. static void switch_to_fresh_cache_range(struct demux_internal *in) { if (!in->seekable_cache) { clear_cached_range(in, in->current_range); return; } struct demux_cached_range *range = talloc_ptrtype(in, range); *range = (struct demux_cached_range){ .seek_start = MP_NOPTS_VALUE, .seek_end = MP_NOPTS_VALUE, }; MP_TARRAY_APPEND(in, in->ranges, in->num_ranges, range); add_missing_streams(in, range); switch_current_range(in, range); } int demux_seek(demuxer_t *demuxer, double seek_pts, int flags) { struct demux_internal *in = demuxer->in; assert(demuxer == in->d_user); int res = 0; pthread_mutex_lock(&in->lock); if (seek_pts == MP_NOPTS_VALUE) goto done; MP_VERBOSE(in, "queuing seek to %f%s\n", seek_pts, in->seeking ? " (cascade)" : ""); if (!(flags & SEEK_FACTOR)) seek_pts = MP_ADD_PTS(seek_pts, -in->ts_offset); bool require_cache = flags & SEEK_CACHED; flags &= ~(unsigned)SEEK_CACHED; struct demux_cached_range *cache_target = find_cache_seek_target(in, seek_pts, flags); if (!cache_target) { if (require_cache) { MP_VERBOSE(demuxer, "Cached seek not possible.\n"); goto done; } if (!demuxer->seekable) { MP_WARN(demuxer, "Cannot seek in this file.\n"); goto done; } } clear_reader_state(in); in->eof = false; in->last_eof = false; in->idle = true; in->reading = false; if (cache_target) { execute_cache_seek(in, cache_target, seek_pts, flags); } else { switch_to_fresh_cache_range(in); in->seeking = true; in->seek_flags = flags; in->seek_pts = seek_pts; } for (int n = 0; n < in->num_streams; n++) wakeup_ds(in->streams[n]->ds); if (!in->threading && in->seeking) execute_seek(in); res = 1; done: pthread_cond_signal(&in->wakeup); pthread_mutex_unlock(&in->lock); return res; } struct sh_stream *demuxer_stream_by_demuxer_id(struct demuxer *d, enum stream_type t, int id) { int num = demux_get_num_stream(d); for (int n = 0; n < num; n++) { struct sh_stream *s = demux_get_stream(d, n); if (s->type == t && s->demuxer_id == id) return s; } return NULL; } // An obscure mechanism to get stream switching to be executed "faster" (as // perceived by the user), by making the stream return packets from the // current position // On a switch, it seeks back, and then grabs all packets that were // "missing" from the packet queue of the newly selected stream. static void initiate_refresh_seek(struct demux_internal *in, struct demux_stream *stream, double start_ts) { struct demuxer *demux = in->d_thread; bool seekable = demux->desc->seek && demux->seekable && !demux->partially_seekable; bool normal_seek = true; bool refresh_possible = true; for (int n = 0; n < in->num_streams; n++) { struct demux_stream *ds = in->streams[n]->ds; if (!ds->selected) continue; if (ds->type == STREAM_VIDEO || ds->type == STREAM_AUDIO) start_ts = MP_PTS_MIN(start_ts, ds->base_ts); // If there were no other streams selected, we can use a normal seek. normal_seek &= stream == ds; refresh_possible &= ds->queue->correct_dts || ds->queue->correct_pos; } if (start_ts == MP_NOPTS_VALUE || !seekable) return; if (!normal_seek) { if (!refresh_possible) { MP_VERBOSE(in, "can't issue refresh seek\n"); return; } for (int n = 0; n < in->num_streams; n++) { struct demux_stream *ds = in->streams[n]->ds; bool correct_pos = ds->queue->correct_pos; bool correct_dts = ds->queue->correct_dts; // We need to re-read all packets anyway, so discard the buffered // data. (In theory, we could keep the packets, and be able to use // it for seeking if partially read streams are deselected again, // but this causes other problems like queue overflows when // selecting a new stream.) ds_clear_reader_queue_state(ds); clear_queue(ds->queue); // Streams which didn't have any packets yet will return all packets, // other streams return packets only starting from the last position. if (ds->selected && (ds->last_ret_pos != -1 || ds->last_ret_dts != MP_NOPTS_VALUE)) { ds->refreshing = true; ds->queue->correct_dts = correct_dts; ds->queue->correct_pos = correct_pos; ds->queue->last_pos = ds->last_ret_pos; ds->queue->last_dts = ds->last_ret_dts; } update_seek_ranges(in->current_range); } start_ts -= 1.0; // small offset to get correct overlap } MP_VERBOSE(in, "refresh seek to %f\n", start_ts); in->seeking = true; in->seek_flags = SEEK_HR; in->seek_pts = start_ts; } // Set whether the given stream should return packets. // ref_pts is used only if the stream is enabled. Then it serves as approximate // start pts for this stream (in the worst case it is ignored). void demuxer_select_track(struct demuxer *demuxer, struct sh_stream *stream, double ref_pts, bool selected) { struct demux_internal *in = demuxer->in; struct demux_stream *ds = stream->ds; pthread_mutex_lock(&in->lock); // don't flush buffers if stream is already selected / unselected if (ds->selected != selected) { MP_VERBOSE(in, "%sselect track %d\n", selected ? "" : "de", stream->index); ds->selected = selected; update_stream_selection_state(in, ds); in->tracks_switched = true; if (ds->selected && !in->initial_state) initiate_refresh_seek(in, ds, MP_ADD_PTS(ref_pts, -in->ts_offset)); if (in->threading) { pthread_cond_signal(&in->wakeup); } else { execute_trackswitch(in); } } pthread_mutex_unlock(&in->lock); } void demux_set_stream_autoselect(struct demuxer *demuxer, bool autoselect) { assert(!demuxer->in->threading); // laziness demuxer->in->autoselect = autoselect; } // This is for demuxer implementations only. demuxer_select_track() sets the // logical state, while this function returns the actual state (in case the // demuxer attempts to cache even unselected packets for track switching - this // will potentially be done in the future). bool demux_stream_is_selected(struct sh_stream *stream) { if (!stream) return false; bool r = false; pthread_mutex_lock(&stream->ds->in->lock); r = stream->ds->selected; pthread_mutex_unlock(&stream->ds->in->lock); return r; } void demux_set_stream_wakeup_cb(struct sh_stream *sh, void (*cb)(void *ctx), void *ctx) { pthread_mutex_lock(&sh->ds->in->lock); sh->ds->wakeup_cb = cb; sh->ds->wakeup_cb_ctx = ctx; sh->ds->need_wakeup = true; pthread_mutex_unlock(&sh->ds->in->lock); } int demuxer_add_attachment(demuxer_t *demuxer, char *name, char *type, void *data, size_t data_size) { if (!(demuxer->num_attachments % 32)) demuxer->attachments = talloc_realloc(demuxer, demuxer->attachments, struct demux_attachment, demuxer->num_attachments + 32); struct demux_attachment *att = &demuxer->attachments[demuxer->num_attachments]; att->name = talloc_strdup(demuxer->attachments, name); att->type = talloc_strdup(demuxer->attachments, type); att->data = talloc_memdup(demuxer->attachments, data, data_size); att->data_size = data_size; return demuxer->num_attachments++; } static int chapter_compare(const void *p1, const void *p2) { struct demux_chapter *c1 = (void *)p1; struct demux_chapter *c2 = (void *)p2; if (c1->pts > c2->pts) return 1; else if (c1->pts < c2->pts) return -1; return c1->original_index > c2->original_index ? 1 :-1; // never equal } static void demuxer_sort_chapters(demuxer_t *demuxer) { qsort(demuxer->chapters, demuxer->num_chapters, sizeof(struct demux_chapter), chapter_compare); } int demuxer_add_chapter(demuxer_t *demuxer, char *name, double pts, uint64_t demuxer_id) { struct demux_chapter new = { .original_index = demuxer->num_chapters, .pts = pts, .metadata = talloc_zero(demuxer, struct mp_tags), .demuxer_id = demuxer_id, }; mp_tags_set_str(new.metadata, "TITLE", name); MP_TARRAY_APPEND(demuxer, demuxer->chapters, demuxer->num_chapters, new); return demuxer->num_chapters - 1; } void demux_disable_cache(demuxer_t *demuxer) { struct demux_internal *in = demuxer->in; assert(demuxer == in->d_user); pthread_mutex_lock(&in->lock); if (in->seekable_cache) { MP_VERBOSE(demuxer, "disabling persistent packet cache\n"); in->seekable_cache = false; // Get rid of potential buffered ranges floating around. free_empty_cached_ranges(in); // Get rid of potential old packets in the current range. prune_old_packets(in); } pthread_mutex_unlock(&in->lock); } // Disallow reading any packets and make readers think there is no new data // yet, until a seek is issued. void demux_block_reading(struct demuxer *demuxer, bool block) { struct demux_internal *in = demuxer->in; assert(demuxer == in->d_user); pthread_mutex_lock(&in->lock); in->blocked = block; for (int n = 0; n < in->num_streams; n++) { in->streams[n]->ds->need_wakeup = true; wakeup_ds(in->streams[n]->ds); } pthread_cond_signal(&in->wakeup); pthread_mutex_unlock(&in->lock); } // must be called not locked static void update_cache(struct demux_internal *in) { struct demuxer *demuxer = in->d_thread; struct stream *stream = demuxer->stream; // Don't lock while querying the stream. struct mp_tags *stream_metadata = NULL; struct stream_cache_info stream_cache_info = {.size = -1}; int64_t stream_size = stream_get_size(stream); stream_control(stream, STREAM_CTRL_GET_METADATA, &stream_metadata); stream_control(stream, STREAM_CTRL_GET_CACHE_INFO, &stream_cache_info); pthread_mutex_lock(&in->lock); in->stream_size = stream_size; in->stream_cache_info = stream_cache_info; if (stream_metadata) { talloc_free(in->stream_metadata); in->stream_metadata = talloc_steal(in, stream_metadata); in->d_buffer->events |= DEMUX_EVENT_METADATA; } pthread_mutex_unlock(&in->lock); } // must be called locked static int cached_stream_control(struct demux_internal *in, int cmd, void *arg) { // If the cache is active, wake up the thread to possibly update cache state. if (in->stream_cache_info.size >= 0) { in->force_cache_update = true; pthread_cond_signal(&in->wakeup); } switch (cmd) { case STREAM_CTRL_GET_CACHE_INFO: if (in->stream_cache_info.size < 0) return STREAM_UNSUPPORTED; *(struct stream_cache_info *)arg = in->stream_cache_info; return STREAM_OK; case STREAM_CTRL_GET_SIZE: if (in->stream_size < 0) return STREAM_UNSUPPORTED; *(int64_t *)arg = in->stream_size; return STREAM_OK; case STREAM_CTRL_GET_BASE_FILENAME: if (!in->stream_base_filename) return STREAM_UNSUPPORTED; *(char **)arg = talloc_strdup(NULL, in->stream_base_filename); return STREAM_OK; } return STREAM_ERROR; } // must be called locked static int cached_demux_control(struct demux_internal *in, int cmd, void *arg) { switch (cmd) { case DEMUXER_CTRL_STREAM_CTRL: { struct demux_ctrl_stream_ctrl *c = arg; int r = cached_stream_control(in, c->ctrl, c->arg); if (r == STREAM_ERROR) break; c->res = r; return CONTROL_OK; } case DEMUXER_CTRL_GET_BITRATE_STATS: { double *rates = arg; for (int n = 0; n < STREAM_TYPE_COUNT; n++) rates[n] = -1; for (int n = 0; n < in->num_streams; n++) { struct demux_stream *ds = in->streams[n]->ds; if (ds->selected && ds->bitrate >= 0) rates[ds->type] = MPMAX(0, rates[ds->type]) + ds->bitrate; } return CONTROL_OK; } case DEMUXER_CTRL_GET_READER_STATE: { struct demux_ctrl_reader_state *r = arg; *r = (struct demux_ctrl_reader_state){ .eof = in->last_eof, .ts_reader = MP_NOPTS_VALUE, .ts_end = MP_NOPTS_VALUE, .ts_duration = -1, .total_bytes = in->total_bytes, .fw_bytes = in->fw_bytes, .seeking = in->seeking_in_progress, .low_level_seeks = in->low_level_seeks, .ts_last = in->demux_ts, }; bool any_packets = false; for (int n = 0; n < in->num_streams; n++) { struct demux_stream *ds = in->streams[n]->ds; if (ds->eager && !(!ds->queue->head && ds->eof) && !ds->ignore_eof) { r->underrun |= !ds->reader_head && !ds->eof; r->ts_reader = MP_PTS_MAX(r->ts_reader, ds->base_ts); r->ts_end = MP_PTS_MAX(r->ts_end, ds->queue->last_ts); any_packets |= !!ds->reader_head; } } r->idle = (in->idle && !r->underrun) || r->eof; r->underrun &= !r->idle; r->ts_reader = MP_ADD_PTS(r->ts_reader, in->ts_offset); r->ts_end = MP_ADD_PTS(r->ts_end, in->ts_offset); if (r->ts_reader != MP_NOPTS_VALUE && r->ts_reader <= r->ts_end) r->ts_duration = r->ts_end - r->ts_reader; if (in->seeking || !any_packets) r->ts_duration = 0; for (int n = 0; n < MPMIN(in->num_ranges, MAX_SEEK_RANGES); n++) { struct demux_cached_range *range = in->ranges[n]; if (range->seek_start != MP_NOPTS_VALUE) { r->seek_ranges[r->num_seek_ranges++] = (struct demux_seek_range){ .start = MP_ADD_PTS(range->seek_start, in->ts_offset), .end = MP_ADD_PTS(range->seek_end, in->ts_offset), }; } } return CONTROL_OK; } } return CONTROL_UNKNOWN; } struct demux_control_args { struct demuxer *demuxer; int cmd; void *arg; int *r; }; static void thread_demux_control(void *p) { struct demux_control_args *args = p; struct demuxer *demuxer = args->demuxer; int cmd = args->cmd; void *arg = args->arg; struct demux_internal *in = demuxer->in; int r = CONTROL_UNKNOWN; if (cmd == DEMUXER_CTRL_STREAM_CTRL) { struct demux_ctrl_stream_ctrl *c = arg; if (in->threading) MP_VERBOSE(demuxer, "blocking for STREAM_CTRL %d\n", c->ctrl); c->res = stream_control(demuxer->stream, c->ctrl, c->arg); if (c->res != STREAM_UNSUPPORTED) r = CONTROL_OK; } if (r != CONTROL_OK) { if (in->threading) MP_VERBOSE(demuxer, "blocking for DEMUXER_CTRL %d\n", cmd); if (demuxer->desc->control) r = demuxer->desc->control(demuxer->in->d_thread, cmd, arg); } *args->r = r; } int demux_control(demuxer_t *demuxer, int cmd, void *arg) { struct demux_internal *in = demuxer->in; assert(demuxer == in->d_user); if (in->threading) { pthread_mutex_lock(&in->lock); int cr = cached_demux_control(in, cmd, arg); pthread_mutex_unlock(&in->lock); if (cr != CONTROL_UNKNOWN) return cr; } int r = 0; struct demux_control_args args = {demuxer, cmd, arg, &r}; if (in->threading) { MP_VERBOSE(in, "blocking on demuxer thread\n"); pthread_mutex_lock(&in->lock); while (in->run_fn) pthread_cond_wait(&in->wakeup, &in->lock); in->run_fn = thread_demux_control; in->run_fn_arg = &args; pthread_cond_signal(&in->wakeup); while (in->run_fn) pthread_cond_wait(&in->wakeup, &in->lock); pthread_mutex_unlock(&in->lock); } else { thread_demux_control(&args); } return r; } int demux_stream_control(demuxer_t *demuxer, int ctrl, void *arg) { struct demux_ctrl_stream_ctrl c = {ctrl, arg, STREAM_UNSUPPORTED}; demux_control(demuxer, DEMUXER_CTRL_STREAM_CTRL, &c); return c.res; } bool demux_cancel_test(struct demuxer *demuxer) { return mp_cancel_test(demuxer->stream->cancel); } struct demux_chapter *demux_copy_chapter_data(struct demux_chapter *c, int num) { struct demux_chapter *new = talloc_array(NULL, struct demux_chapter, num); for (int n = 0; n < num; n++) { new[n] = c[n]; new[n].metadata = mp_tags_dup(new, new[n].metadata); } return new; }