| /* |
| * 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 "libavutil/fifo.h" |
| #include "libavutil/intreadwrite.h" |
| #include "libavutil/opt.h" |
| #include "libavutil/timestamp.h" |
| |
| #include "libavcodec/bsf.h" |
| #include "libavcodec/bsf_internal.h" |
| |
| enum TrimType { |
| TRIM_PTS, |
| TRIM_DTS, |
| TRIM_PKT_INDEX, |
| TRIM_MSEC_PT, |
| TRIM_MSEC_DT, |
| TRIM_DUR_TS, |
| TRIM_DUR_T_MSEC, |
| }; |
| |
| /* The packet discriminant a bound is compared against; the indexes count consumed |
| * and exported packets. */ |
| enum TrimAxis { |
| AXIS_PTS, |
| AXIS_DTS, |
| AXIS_INDEX, |
| AXIS_OUT_INDEX, |
| }; |
| |
| /* An axis, a unit, and whether the value is relative; the duration types are |
| * the relative forms of pts and msec_pt. */ |
| static const struct { |
| enum TrimAxis axis; |
| int msec; |
| int relative; |
| } trim_types[] = { |
| [TRIM_PTS] = { AXIS_PTS, 0, 0 }, |
| [TRIM_DTS] = { AXIS_DTS, 0, 0 }, |
| [TRIM_PKT_INDEX] = { AXIS_INDEX, 0, 0 }, |
| [TRIM_MSEC_PT] = { AXIS_PTS, 1, 0 }, |
| [TRIM_MSEC_DT] = { AXIS_DTS, 1, 0 }, |
| [TRIM_DUR_TS] = { AXIS_PTS, 0, 1 }, |
| [TRIM_DUR_T_MSEC] = { AXIS_PTS, 1, 1 }, |
| }; |
| |
| typedef struct TrimBound { |
| /* Resolved from the options, immutable once init returns. */ |
| int active; ///< the option was set at all |
| enum TrimAxis axis; |
| int relative; ///< offset is measured from the reference packet |
| int64_t offset; ///< option value converted to axis units |
| |
| /* Rebuilt from the fields above by every reset. */ |
| int64_t value; ///< resolved bound, meaningful once pending is clear |
| int pending; ///< the reference packet has not been seen yet |
| } TrimBound; |
| |
| typedef struct TrimContext { |
| const AVClass *class; |
| |
| int64_t start; |
| int64_t end; |
| int start_type; |
| int end_type; |
| int start_rel; |
| int end_rel; |
| int trim_packets; |
| |
| TrimBound start_bound; |
| TrimBound end_bound; |
| |
| int audio; ///< trim through skip samples side data |
| int64_t pkt_idx; ///< packets consumed so far |
| int64_t out_idx; ///< packets exported so far |
| int64_t skip_carry; ///< samples of head skip left over by dropped packets |
| uint8_t skip_reason; ///< reason that head skip came with |
| |
| int preroll; |
| int preroll_size; |
| |
| AVFifo *preroll_fifo; ///< packets held since the last keyframe, NULL when off |
| AVPacket *pending; ///< in-range packet waiting for the preroll to drain |
| int preroll_full; ///< the group overflowed, so hold nothing until the next one |
| |
| int64_t nb_exported; ///< packets that left the filter |
| int64_t last_pts; ///< the last of them, kept for the closing summary |
| int64_t last_dts; |
| int last_key; |
| } TrimContext; |
| |
| /* Bounds mix option values with stream values; either can overflow. */ |
| static int add_checked(AVBSFContext *ctx, int64_t *acc, int64_t delta, |
| const char *what) |
| { |
| if ((delta > 0 && *acc > INT64_MAX - delta) || |
| (delta < 0 && *acc < INT64_MIN - delta)) { |
| av_log(ctx, AV_LOG_ERROR, "%s is not representable\n", what); |
| return AVERROR(ERANGE); |
| } |
| |
| *acc += delta; |
| |
| return 0; |
| } |
| |
| static int64_t packet_axis(const TrimContext *s, const AVPacket *pkt, |
| enum TrimAxis axis) |
| { |
| switch (axis) { |
| case AXIS_PTS: return pkt->pts; |
| case AXIS_DTS: return pkt->dts; |
| case AXIS_OUT_INDEX: return s->out_idx; |
| default: return s->pkt_idx; |
| } |
| } |
| |
| /* The dts stands in for the pts, being monotonic and never above it. */ |
| static enum TrimAxis monotonic_axis(enum TrimAxis axis) |
| { |
| return axis == AXIS_PTS ? AXIS_DTS : axis; |
| } |
| |
| /* An index counts whole packets, so only time places a bound inside one. */ |
| static int axis_is_time(enum TrimAxis axis) |
| { |
| return axis == AXIS_PTS || axis == AXIS_DTS; |
| } |
| |
| /* Nothing converted here is ever negative, so a negative result is the |
| * INT64_MIN av_rescale_q reports for one it cannot represent. */ |
| static int convert_checked(AVBSFContext *ctx, int64_t *value, AVRational from, |
| AVRational to, const char *what) |
| { |
| int64_t converted = av_rescale_q(*value, from, to); |
| |
| if (converted < 0) { |
| av_log(ctx, AV_LOG_ERROR, "%s is not representable\n", what); |
| return AVERROR(ERANGE); |
| } |
| |
| *value = converted; |
| |
| return 0; |
| } |
| |
| static int time_base_to_samples(AVBSFContext *ctx, int64_t *value, |
| const char *what) |
| { |
| return convert_checked(ctx, value, ctx->time_base_in, |
| (AVRational){ 1, ctx->par_in->sample_rate }, what); |
| } |
| |
| static int samples_to_time_base(AVBSFContext *ctx, int64_t *value, |
| const char *what) |
| { |
| return convert_checked(ctx, value, (AVRational){ 1, ctx->par_in->sample_rate }, |
| ctx->time_base_in, what); |
| } |
| |
| /* The samples a packet decodes to, zero where the codec does not give them. */ |
| static int64_t packet_samples(AVBSFContext *ctx, const AVPacket *pkt) |
| { |
| return FFMAX(av_get_audio_frame_duration2(ctx->par_in, pkt->size), 0); |
| } |
| |
| /* A skip reaching past a dropped packet only needs how much of itself that |
| * packet used up, which a duration still estimates closely enough. */ |
| static int64_t packet_skip_consumed(AVBSFContext *ctx, const AVPacket *pkt) |
| { |
| int64_t nb_samples = packet_samples(ctx, pkt); |
| |
| if (nb_samples > 0) |
| return nb_samples; |
| |
| nb_samples = av_rescale_q(pkt->duration, ctx->time_base_in, |
| (AVRational){ 1, ctx->par_in->sample_rate }); |
| |
| return FFMAX(nb_samples, 0); |
| } |
| |
| /* How far a packet reaches past its axis value. Audio reaches as far as the |
| * samples it decodes to, a duration also covering any gap after them; without |
| * them it reaches nowhere, so no bound can fall inside it. */ |
| static int packet_span(AVBSFContext *ctx, const AVPacket *pkt, |
| enum TrimAxis axis, int64_t *span) |
| { |
| TrimContext *s = ctx->priv_data; |
| |
| *span = 0; |
| |
| if (!axis_is_time(axis)) |
| return 0; |
| |
| if (s->audio) { |
| *span = packet_samples(ctx, pkt); |
| return samples_to_time_base(ctx, span, "packet span"); |
| } |
| |
| *span = FFMAX(pkt->duration, 0); |
| |
| return 0; |
| } |
| |
| static int bound_init(AVBSFContext *ctx, TrimBound *b, int active, |
| int64_t value, int type, int rel, const char *name) |
| { |
| b->active = active; |
| if (!active) |
| return 0; |
| |
| b->axis = trim_types[type].axis; |
| b->relative = rel || trim_types[type].relative; |
| |
| if (trim_types[type].relative && value < 0) { |
| av_log(ctx, AV_LOG_ERROR, "%s duration must not be negative\n", name); |
| return AVERROR(EINVAL); |
| } |
| |
| if (trim_types[type].msec) { |
| int64_t ts = av_rescale_q(value, (AVRational){ 1, 1000 }, |
| ctx->time_base_in); |
| if (ts == INT64_MIN) { |
| av_log(ctx, AV_LOG_ERROR, "%s of %"PRId64" ms is not representable " |
| "in the stream time base\n", name, value); |
| return AVERROR(ERANGE); |
| } |
| value = ts; |
| } |
| |
| b->offset = value; |
| |
| return 0; |
| } |
| |
| static void bound_reset(TrimBound *b) |
| { |
| b->value = b->offset; |
| b->pending = b->relative; |
| } |
| |
| static int bound_resolve(AVBSFContext *ctx, TrimBound *b, int64_t ref, |
| const char *name) |
| { |
| int ret = add_checked(ctx, &b->value, ref, name); |
| |
| if (ret < 0) |
| return ret; |
| |
| b->pending = 0; |
| |
| return 0; |
| } |
| |
| /* How much of the packet lies before the start bound, EAGAIN when all of it |
| * does. */ |
| static int trim_head(AVBSFContext *ctx, const AVPacket *pkt, int64_t *head) |
| { |
| TrimContext *s = ctx->priv_data; |
| int64_t v, span; |
| int ret; |
| |
| if (!s->start_bound.active) |
| return 0; |
| |
| /* A packet without the discriminant a bound uses cannot be placed. */ |
| v = packet_axis(s, pkt, s->start_bound.axis); |
| if (v == AV_NOPTS_VALUE) |
| return AVERROR(EAGAIN); |
| |
| /* The start is measured from the first packet of the stream. */ |
| if (s->start_bound.pending) { |
| ret = bound_resolve(ctx, &s->start_bound, v, "start bound"); |
| if (ret < 0) |
| return ret; |
| } |
| |
| if (v >= s->start_bound.value) |
| return 0; |
| |
| ret = packet_span(ctx, pkt, s->start_bound.axis, &span); |
| if (ret < 0) |
| return ret; |
| |
| if (!s->trim_packets || av_sat_add64(v, span) <= s->start_bound.value) |
| return AVERROR(EAGAIN); |
| *head = s->start_bound.value - v; |
| |
| return 0; |
| } |
| |
| /* How much of the packet lies past the end bound, measured from head, where it |
| * starts contributing. EAGAIN when none of it is inside, EOF once nothing later |
| * can be. */ |
| static int trim_tail(AVBSFContext *ctx, const AVPacket *pkt, int64_t head, |
| int64_t *tail) |
| { |
| TrimContext *s = ctx->priv_data; |
| int64_t v; |
| int ret; |
| |
| if (!s->end_bound.active) |
| return 0; |
| |
| /* The end is measured from the first exported packet, at the point it is |
| * trimmed to. */ |
| if (s->end_bound.pending) { |
| int64_t ref = packet_axis(s, pkt, s->end_bound.axis); |
| |
| if (ref == AV_NOPTS_VALUE) |
| return AVERROR(EAGAIN); |
| if (axis_is_time(s->end_bound.axis)) { |
| ret = add_checked(ctx, &ref, head, "end anchor"); |
| if (ret < 0) |
| return ret; |
| } |
| ret = bound_resolve(ctx, &s->end_bound, ref, "end bound"); |
| if (ret < 0) |
| return ret; |
| } |
| |
| /* Only a discriminant that cannot come back into range may end the stream. */ |
| v = packet_axis(s, pkt, monotonic_axis(s->end_bound.axis)); |
| if (v != AV_NOPTS_VALUE && v >= s->end_bound.value) |
| return AVERROR_EOF; |
| |
| v = packet_axis(s, pkt, s->end_bound.axis); |
| if (v == AV_NOPTS_VALUE) |
| return AVERROR(EAGAIN); |
| |
| /* Reordering can still bring in-range packets after this one. */ |
| if (v >= s->end_bound.value) |
| return AVERROR(EAGAIN); |
| |
| if (s->trim_packets) { |
| int64_t span, past; |
| |
| ret = packet_span(ctx, pkt, s->end_bound.axis, &span); |
| if (ret < 0) |
| return ret; |
| |
| past = av_sat_add64(v, span); |
| if (past > s->end_bound.value) |
| *tail = past - s->end_bound.value; |
| } |
| |
| return 0; |
| } |
| |
| /* Audio is trimmed in sample space through skip samples side data, leaving the |
| * timestamps untouched. */ |
| static int trim_audio(AVBSFContext *ctx, AVPacket *pkt, int64_t head, int keep) |
| { |
| TrimContext *s = ctx->priv_data; |
| int64_t nb_samples = packet_samples(ctx, pkt); |
| int64_t tail = 0, anchor, input_head; |
| int trimming = head != 0; |
| uint8_t head_reason = 0, tail_reason = 0, input_reason; |
| size_t size; |
| uint8_t *side = av_packet_get_side_data(pkt, AV_PKT_DATA_SKIP_SAMPLES, |
| &size); |
| int ret; |
| |
| ret = time_base_to_samples(ctx, &head, "head trim"); |
| if (ret < 0) |
| return ret; |
| |
| /* A decoder replaces the skip it carries with any nonzero one a packet |
| * brings, whether larger or smaller, so resolve the incoming skip first. */ |
| input_head = s->skip_carry; |
| input_reason = s->skip_reason; |
| |
| if (side && size >= 8 && AV_RL32(side)) { |
| input_head = AV_RL32(side); |
| input_reason = size >= 10 ? AV_RL8(side + 8) : 0; |
| } |
| |
| /* That skip and this filter's trim are offsets from the same boundary, so |
| * the larger wins and brings its own reason; the trim has none. */ |
| if (input_head >= head) { |
| head = input_head; |
| head_reason = input_reason; |
| } |
| |
| /* Only a trim of this filter collapses a packet; one already covered by its |
| * own skip is passed through. */ |
| if (!keep || (trimming && nb_samples > 0 && head >= nb_samples)) |
| goto drop; |
| |
| /* A bound measured from this packet is anchored past its composed skip. */ |
| anchor = head; |
| ret = samples_to_time_base(ctx, &anchor, "end anchor"); |
| if (ret < 0) |
| return ret; |
| |
| ret = trim_tail(ctx, pkt, anchor, &tail); |
| if (ret < 0) { |
| if (ret != AVERROR(EAGAIN)) |
| return ret; |
| goto drop; |
| } |
| |
| trimming |= tail != 0; |
| ret = time_base_to_samples(ctx, &tail, "tail trim"); |
| if (ret < 0) |
| return ret; |
| if (side && size >= 8 && AV_RL32(side + 4) >= tail) { |
| tail = AV_RL32(side + 4); |
| tail_reason = size >= 10 ? AV_RL8(side + 9) : 0; |
| } |
| |
| if (trimming && nb_samples > 0 && head >= nb_samples - tail) |
| goto drop; |
| |
| /* The side data below carries any excess from here on. */ |
| s->skip_carry = 0; |
| s->skip_reason = 0; |
| |
| if (!head && !tail) |
| return 0; |
| |
| if (head > UINT32_MAX || tail > UINT32_MAX) { |
| av_log(ctx, AV_LOG_ERROR, "skip samples count is not representable\n"); |
| return AVERROR(ERANGE); |
| } |
| |
| if (!side || size < 10) { |
| side = av_packet_new_side_data(pkt, AV_PKT_DATA_SKIP_SAMPLES, 10); |
| if (!side) |
| return AVERROR(ENOMEM); |
| } |
| |
| AV_WL32(side, head); |
| AV_WL32(side + 4, tail); |
| AV_WL8 (side + 8, head_reason); |
| AV_WL8 (side + 9, tail_reason); |
| |
| return 0; |
| |
| drop: |
| /* A decoder subtracts the samples of every frame it discards and carries |
| * the rest, so do the same across dropped packets. */ |
| if (head > 0) { |
| int64_t consumed = packet_skip_consumed(ctx, pkt); |
| |
| if (consumed <= 0) { |
| av_log(ctx, AV_LOG_ERROR, "cannot carry a %"PRId64" sample skip past " |
| "a dropped packet of unknown sample count\n", head); |
| return AVERROR(EINVAL); |
| } |
| s->skip_carry = FFMAX(head - consumed, 0); |
| s->skip_reason = s->skip_carry ? head_reason : 0; |
| } |
| |
| return AVERROR(EAGAIN); |
| } |
| |
| /* Everything but audio is trimmed on the timeline itself, which no side data |
| * can express. */ |
| static int trim_shift(AVBSFContext *ctx, AVPacket *pkt, int64_t head) |
| { |
| int64_t tail = 0; |
| int ret; |
| |
| ret = trim_tail(ctx, pkt, head, &tail); |
| if (ret < 0) |
| return ret; |
| |
| if (!head && !tail) |
| return 0; |
| |
| /* Bounds on different axes can select disjoint parts of one packet, and |
| * each trim is below the duration, so the subtraction cannot overflow. */ |
| if (head >= pkt->duration - tail) |
| return AVERROR(EAGAIN); |
| |
| if (pkt->pts != AV_NOPTS_VALUE) { |
| ret = add_checked(ctx, &pkt->pts, head, "packet pts"); |
| if (ret < 0) |
| return ret; |
| } |
| if (pkt->dts != AV_NOPTS_VALUE) { |
| ret = add_checked(ctx, &pkt->dts, head, "packet dts"); |
| if (ret < 0) |
| return ret; |
| } |
| pkt->duration -= head + tail; |
| |
| return 0; |
| } |
| |
| static void preroll_clear(AVBSFContext *ctx) |
| { |
| TrimContext *s = ctx->priv_data; |
| AVPacket *held; |
| |
| while (s->preroll_fifo && av_fifo_read(s->preroll_fifo, &held, 1) >= 0) |
| av_packet_free(&held); |
| } |
| |
| /* A held packet is decoded for the frames after it to reference and dropped |
| * before output, so the exported stream still begins at the bound. */ |
| static void preroll_export(AVBSFContext *ctx, AVPacket *pkt) |
| { |
| TrimContext *s = ctx->priv_data; |
| AVPacket *held; |
| |
| if (av_fifo_read(s->preroll_fifo, &held, 1) >= 0) { |
| av_packet_move_ref(pkt, held); |
| av_packet_free(&held); |
| pkt->flags |= AV_PKT_FLAG_DISCARD; |
| return; |
| } |
| |
| av_packet_move_ref(pkt, s->pending); |
| av_packet_free(&s->pending); |
| } |
| |
| static int preroll_hold(AVBSFContext *ctx, AVPacket *pkt) |
| { |
| TrimContext *s = ctx->priv_data; |
| AVPacket *held; |
| int ret; |
| |
| if (s->preroll_full) |
| return AVERROR(EAGAIN); |
| |
| held = av_packet_alloc(); |
| if (!held) |
| return AVERROR(ENOMEM); |
| |
| av_packet_move_ref(held, pkt); |
| ret = av_fifo_write(s->preroll_fifo, &held, 1); |
| if (ret < 0) { |
| av_packet_move_ref(pkt, held); |
| av_packet_free(&held); |
| if (ret != AVERROR(ENOSPC)) |
| return ret; |
| |
| /* A group too long to hold is dropped whole rather than exported as a |
| * fragment no decoder can start from. */ |
| av_log(ctx, AV_LOG_WARNING, "preroll exceeds %d packets, the first " |
| "packets in range will not be decodable\n", s->preroll_size); |
| preroll_clear(ctx); |
| s->preroll_full = 1; |
| } |
| |
| return AVERROR(EAGAIN); |
| } |
| |
| static void log_exported_packet(AVBSFContext *ctx, const char *which, |
| int64_t idx, int64_t pts, int64_t dts, int key) |
| { |
| av_log(ctx, AV_LOG_VERBOSE, "%s exported packet: output index %"PRId64", " |
| "pts %s, dts %s, keyframe %d\n", which, idx, av_ts2str(pts), |
| av_ts2str(dts), key); |
| } |
| |
| static void packet_exported(AVBSFContext *ctx, const AVPacket *pkt) |
| { |
| TrimContext *s = ctx->priv_data; |
| |
| s->last_pts = pkt->pts; |
| s->last_dts = pkt->dts; |
| s->last_key = !!(pkt->flags & AV_PKT_FLAG_KEY); |
| |
| if (!s->nb_exported++) |
| log_exported_packet(ctx, "first", 0, s->last_pts, s->last_dts, |
| s->last_key); |
| } |
| |
| /* Only the flush or close ending the stream can tell which packet was last. */ |
| static void trim_report(AVBSFContext *ctx) |
| { |
| TrimContext *s = ctx->priv_data; |
| |
| if (s->nb_exported) |
| log_exported_packet(ctx, "last", s->nb_exported - 1, s->last_pts, |
| s->last_dts, s->last_key); |
| else if (s->pkt_idx) |
| av_log(ctx, AV_LOG_WARNING, "no packet was in range, the output is " |
| "empty\n"); |
| } |
| |
| static int trim_filter(AVBSFContext *ctx, AVPacket *pkt) |
| { |
| TrimContext *s = ctx->priv_data; |
| int64_t head = 0; |
| int ret; |
| |
| /* The preroll an in-range packet needs is exported ahead of it. */ |
| if (s->pending) { |
| preroll_export(ctx, pkt); |
| packet_exported(ctx, pkt); |
| return 0; |
| } |
| |
| ret = ff_bsf_get_packet_ref(ctx, pkt); |
| if (ret < 0) |
| return ret; |
| |
| /* Only the group the start bound falls in is worth keeping, so the window |
| * starts over at every keyframe. */ |
| if (s->preroll_fifo && pkt->flags & AV_PKT_FLAG_KEY) { |
| preroll_clear(ctx); |
| s->preroll_full = 0; |
| } |
| |
| ret = trim_head(ctx, pkt, &head); |
| |
| /* A packet before the start still composes with the skip it carries, so the |
| * audio path runs on it too and is told the verdict instead. */ |
| if (s->audio && (!ret || ret == AVERROR(EAGAIN))) |
| ret = trim_audio(ctx, pkt, head, !ret); |
| else if (!ret) |
| ret = trim_shift(ctx, pkt, head); |
| else if (ret == AVERROR(EAGAIN) && s->preroll_fifo) |
| ret = preroll_hold(ctx, pkt); |
| |
| s->pkt_idx++; |
| if (ret < 0) { |
| av_packet_unref(pkt); |
| return ret; |
| } |
| |
| s->out_idx++; |
| if (s->preroll_fifo && av_fifo_can_read(s->preroll_fifo)) { |
| s->pending = av_packet_alloc(); |
| if (!s->pending) { |
| av_packet_unref(pkt); |
| return AVERROR(ENOMEM); |
| } |
| av_packet_move_ref(s->pending, pkt); |
| preroll_export(ctx, pkt); |
| } |
| |
| packet_exported(ctx, pkt); |
| |
| return 0; |
| } |
| |
| /* Runtime state is derived from the options, so a flush restores it exactly. */ |
| static void trim_reset(AVBSFContext *ctx) |
| { |
| TrimContext *s = ctx->priv_data; |
| |
| bound_reset(&s->start_bound); |
| bound_reset(&s->end_bound); |
| |
| s->pkt_idx = 0; |
| s->out_idx = 0; |
| s->nb_exported = 0; |
| s->skip_carry = 0; |
| s->skip_reason = 0; |
| |
| preroll_clear(ctx); |
| av_packet_free(&s->pending); |
| s->preroll_full = 0; |
| } |
| |
| static void trim_flush(AVBSFContext *ctx) |
| { |
| trim_report(ctx); |
| trim_reset(ctx); |
| } |
| |
| static void trim_close(AVBSFContext *ctx) |
| { |
| TrimContext *s = ctx->priv_data; |
| |
| trim_report(ctx); |
| preroll_clear(ctx); |
| av_packet_free(&s->pending); |
| av_fifo_freep2(&s->preroll_fifo); |
| } |
| |
| static int trim_init(AVBSFContext *ctx) |
| { |
| TrimContext *s = ctx->priv_data; |
| int ret; |
| |
| if (s->start == INT64_MIN && s->end == INT64_MAX) { |
| av_log(ctx, AV_LOG_ERROR, "At least one of start or end must be set\n"); |
| return AVERROR(EINVAL); |
| } |
| |
| ret = bound_init(ctx, &s->start_bound, s->start != INT64_MIN, s->start, |
| s->start_type, s->start_rel, "start"); |
| if (ret < 0) |
| return ret; |
| |
| ret = bound_init(ctx, &s->end_bound, s->end != INT64_MAX, s->end, |
| s->end_type, s->end_rel, "end"); |
| if (ret < 0) |
| return ret; |
| |
| /* A packet count measured from the first exported packet is a promise about |
| * the exported stream, so it is counted there. */ |
| if (s->end_bound.axis == AXIS_INDEX && s->end_bound.relative) |
| s->end_bound.axis = AXIS_OUT_INDEX; |
| |
| /* Shifting the timeline leaves the samples where they were, so audio with |
| * no sample space to be trimmed in cannot be trimmed at all. */ |
| if (s->trim_packets && ctx->par_in->codec_type == AVMEDIA_TYPE_AUDIO) { |
| if (ctx->par_in->sample_rate <= 0 || ctx->time_base_in.num <= 0 || |
| ctx->time_base_in.den <= 0) { |
| av_log(ctx, AV_LOG_ERROR, "audio is trimmed through skip samples " |
| "side data, which needs a sample rate and a time base\n"); |
| return AVERROR(EINVAL); |
| } |
| s->audio = 1; |
| } |
| |
| /* The window is bounded by a keyframe, which only video has. Audio needs a |
| * preroll counted in samples, which is not the one this would give. */ |
| if (s->preroll && s->start_bound.active && |
| ctx->par_in->codec_type == AVMEDIA_TYPE_VIDEO) { |
| s->preroll_fifo = av_fifo_alloc2(1, sizeof(AVPacket *), |
| AV_FIFO_FLAG_AUTO_GROW); |
| if (!s->preroll_fifo) |
| return AVERROR(ENOMEM); |
| av_fifo_auto_grow_limit(s->preroll_fifo, s->preroll_size); |
| } |
| |
| trim_reset(ctx); |
| |
| return 0; |
| } |
| |
| #define OFFSET(x) offsetof(TrimContext, x) |
| #define FLAGS (AV_OPT_FLAG_VIDEO_PARAM|AV_OPT_FLAG_AUDIO_PARAM|AV_OPT_FLAG_BSF_PARAM) |
| static const AVOption trim_options[] = { |
| { "start", "time or index marking the start of the accepted range", OFFSET(start), |
| AV_OPT_TYPE_INT64, { .i64 = INT64_MIN }, INT64_MIN, INT64_MAX, FLAGS }, |
| { "start_type", "how to interpret start", OFFSET(start_type), |
| AV_OPT_TYPE_INT, { .i64 = TRIM_PTS }, 0, TRIM_MSEC_DT, FLAGS, .unit = "start_type" }, |
| { "pts", "stream time base pts", 0, AV_OPT_TYPE_CONST, { .i64 = TRIM_PTS }, 0, 0, FLAGS, .unit = "start_type" }, |
| { "dts", "stream time base dts", 0, AV_OPT_TYPE_CONST, { .i64 = TRIM_DTS }, 0, 0, FLAGS, .unit = "start_type" }, |
| { "pkt_index", "packet index", 0, AV_OPT_TYPE_CONST, { .i64 = TRIM_PKT_INDEX }, 0, 0, FLAGS, .unit = "start_type" }, |
| { "msec_pt", "milliseconds, matched against pts", 0, AV_OPT_TYPE_CONST, { .i64 = TRIM_MSEC_PT }, 0, 0, FLAGS, .unit = "start_type" }, |
| { "msec_dt", "milliseconds, matched against dts", 0, AV_OPT_TYPE_CONST, { .i64 = TRIM_MSEC_DT }, 0, 0, FLAGS, .unit = "start_type" }, |
| { "start_rel", "interpret start relative to the first packet of the stream", OFFSET(start_rel), |
| AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, FLAGS }, |
| { "end", "time or index marking the end of the accepted range", OFFSET(end), |
| AV_OPT_TYPE_INT64, { .i64 = INT64_MAX }, INT64_MIN, INT64_MAX, FLAGS }, |
| { "end_type", "how to interpret end", OFFSET(end_type), |
| AV_OPT_TYPE_INT, { .i64 = TRIM_PTS }, 0, TRIM_DUR_T_MSEC, FLAGS, .unit = "end_type" }, |
| { "pts", "stream time base pts", 0, AV_OPT_TYPE_CONST, { .i64 = TRIM_PTS }, 0, 0, FLAGS, .unit = "end_type" }, |
| { "dts", "stream time base dts", 0, AV_OPT_TYPE_CONST, { .i64 = TRIM_DTS }, 0, 0, FLAGS, .unit = "end_type" }, |
| { "pkt_index", "packet index", 0, AV_OPT_TYPE_CONST, { .i64 = TRIM_PKT_INDEX }, 0, 0, FLAGS, .unit = "end_type" }, |
| { "msec_pt", "milliseconds, matched against pts", 0, AV_OPT_TYPE_CONST, { .i64 = TRIM_MSEC_PT }, 0, 0, FLAGS, .unit = "end_type" }, |
| { "msec_dt", "milliseconds, matched against dts", 0, AV_OPT_TYPE_CONST, { .i64 = TRIM_MSEC_DT }, 0, 0, FLAGS, .unit = "end_type" }, |
| { "dur_ts", "duration in stream time base", 0, AV_OPT_TYPE_CONST, { .i64 = TRIM_DUR_TS }, 0, 0, FLAGS, .unit = "end_type" }, |
| { "dur_t_msec", "duration in milliseconds", 0, AV_OPT_TYPE_CONST, { .i64 = TRIM_DUR_T_MSEC }, 0, 0, FLAGS, .unit = "end_type" }, |
| { "end_rel", "interpret end relative to the first exported packet", OFFSET(end_rel), |
| AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, FLAGS }, |
| { "trim_packets", "trim packets straddling a boundary instead of exporting them " |
| "untouched or dropping them", OFFSET(trim_packets), |
| AV_OPT_TYPE_BOOL, { .i64 = 1 }, 0, 1, FLAGS }, |
| { "preroll", "export the packets the first packet in range needs to be decodable, " |
| "flagged for the decoder to drop them after decoding", OFFSET(preroll), |
| AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, FLAGS }, |
| { "preroll_size", "maximum number of packets held for preroll", OFFSET(preroll_size), |
| AV_OPT_TYPE_INT, { .i64 = 300 }, 1, INT_MAX, FLAGS }, |
| { NULL }, |
| }; |
| |
| static const AVClass trim_class = { |
| .class_name = "trim", |
| .item_name = av_default_item_name, |
| .option = trim_options, |
| .version = LIBAVUTIL_VERSION_INT, |
| }; |
| |
| const FFBitStreamFilter ff_trim_bsf = { |
| .p.name = "trim", |
| .p.priv_class = &trim_class, |
| .priv_data_size = sizeof(TrimContext), |
| .init = trim_init, |
| .close = trim_close, |
| .flush = trim_flush, |
| .filter = trim_filter, |
| }; |
