blob: 1282673a51ed23832eb8ce25645e372f2dd0f8b6 [file]
/*
* GPAC - Multimedia Framework C SDK
*
* Authors: Jean Le Feuvre
* Copyright (c) Telecom ParisTech 2017-2026
* All rights reserved
*
* This file is part of GPAC / force reframer filter
*
* GPAC 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, or (at your option)
* any later version.
*
* GPAC 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 this library; see the file COPYING. If not, write to
* the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
*
*/
#include <gpac/avparse.h>
#include <gpac/constants.h>
#include <gpac/filters.h>
#ifndef GPAC_DISABLE_REFRAMER
GF_OPT_ENUM (GF_RealTimeRegulationMode,
REFRAME_RT_OFF = 0,
REFRAME_RT_ON,
REFRAME_RT_SYNC,
REFRAME_RT_ALIGN,
);
GF_OPT_ENUM (GF_ExtractionStartAdjustment,
REFRAME_ROUND_BEFORE=0,
REFRAME_ROUND_SEEK,
REFRAME_ROUND_AFTER,
REFRAME_ROUND_CLOSEST,
);
GF_OPT_ENUM (GF_WaitSegmentState,
WAIT_SEG_BOUNDARY_NONE=0,
WAIT_SEG_BOUNDARY_ACTIVE,
WAIT_SEG_BOUNDARY_DONE,
);
enum
{
RANGE_NONE=0,
RANGE_CLOSED,
RANGE_OPEN,
RANGE_DONE
};
GF_OPT_ENUM (GF_UTCReferenceMode,
UTCREF_LOCAL=0,
UTCREF_ANY,
UTCREF_MEDIA,
UTCREF_TC,
);
enum
{
EXTRACT_NONE=0,
EXTRACT_RANGE,
EXTRACT_SAP,
EXTRACT_SIZE,
EXTRACT_DUR,
};
GF_OPT_ENUM (GF_ForceInputDecodingMode,
RAW_AV=0,
RAW_AUDIO,
RAW_VIDEO,
RAW_NONE,
);
#define RT_PRECISION_US 2000
typedef struct
{
GF_FilterPid *ipid, *opid;
u32 timescale;
u64 cts_us_at_init;
u64 sys_clock_at_init;
u32 nb_frames;
Bool can_split;
Bool all_saps;
Bool needs_adjust;
Bool use_blocking_refs;
u64 ts_at_range_start_plus_one;
u64 ts_at_range_end;
GF_List *pck_queue;
//0: not computed, 1: computed and valid TS, 2: end of stream on pid
u32 range_start_computed;
u64 range_end_reached_ts;
u64 prev_sap_ts;
u32 prev_sap_frame_idx;
u32 nb_frames_range;
u64 sap_ts_plus_one;
Bool first_pck_sent;
GF_Fraction segdur;
GF_WaitSegmentState wait_seg_boundary;
//only positive delay here
u64 tk_delay;
//only media skip (video, audio priming)
u32 ts_sub;
Bool in_eos;
u32 split_start;
u32 split_end;
GF_FilterPacket *split_pck;
GF_FilterPacket *reinsert_single_pck;
Bool is_playing;
Bool is_raw;
u32 codec_id, stream_type;
u32 nb_ch, sample_rate, abps;
Bool audio_planar;
//for uncompressed audio, number of audio samples to keep from split frame / trash from next split frame
//for seek mode, duration of media to keep from split frame / trash from next split frame
u32 audio_samples_to_keep;
u32 nb_frames_until_start;
Bool seek_mode;
u64 probe_ref_frame_ts;
Bool fetch_done;
u64 last_utc_ref, last_utc_ref_ts;
u64 last_ts_sent;
u32 ts_disc_idx;
} RTStream;
typedef struct
{
//args
Bool exporter;
GF_PropUIntList saps;
GF_PropIntList frames;
Bool refs;
GF_RealTimeRegulationMode rt;
Double speed;
GF_ForceInputDecodingMode raw;
GF_PropStringList xs, xe;
Bool nosap, splitrange, xadjust, tcmdrw, no_audio_seek, probe_ref, xots, xdts;
GF_Fraction chkdisc;
GF_ExtractionStartAdjustment xround;
GF_UTCReferenceMode utc_ref;
u32 utc_probe;
Double seeksafe;
GF_PropStringList props;
Bool copy, rmseek;
u32 cues;
u32 sapcue;
//internal
Bool filter_sap1;
Bool filter_sap2;
Bool filter_sap3;
Bool filter_sap4;
Bool filter_sap_none;
GF_List *streams;
RTStream *clock;
Double rt_speed;
u64 reschedule_in;
u64 clock_val;
u32 range_type;
u32 cur_range_idx;
//if cur_start.den is 0, cur_start.num is UTC start time in milliseconds
//if cur_end.den. is 0, cur_start.num is UTC stop time, only if cur_start uses UTC
GF_Fraction64 cur_start, cur_end;
GF_TimeCode *cur_start_tc, *cur_end_tc;
Bool cur_start_valid, cur_end_valid;
u64 start_frame_idx_plus_one, end_frame_idx_plus_one;
GF_Fraction64 ts_tc_offset;
//when we are waiting for segment boundary, we want other PIDs to
//short circuit and start sending when one of them can
GF_Fraction64 wait_seg_boundary_ts;
Bool in_range;
Bool load_sei;
Bool seekable;
GF_Fraction64 extract_dur;
u32 extract_mode;
Bool is_range_extraction;
u32 file_idx;
u64 min_ts_computed;
u32 min_ts_scale;
u64 split_size;
u64 est_file_size;
u64 prev_min_ts_computed;
u32 prev_min_ts_scale;
u32 wait_video_range_adjust;
Bool has_seen_eos;
u32 eos_state;
u32 nb_non_saps;
u32 nb_video_frames_since_start_at_range_start;
u32 nb_video_frames_since_start;
Bool flush_samples;
u64 cumulated_size;
u64 last_ts;
u64 flush_max_ts;
u32 flush_max_ts_scale;
u64 last_utc_time_s;
u32 last_clock_probe;
u32 nb_align_pending;
u64 next_cts_align;
} GF_ReframerCtx;
static void reframer_reset_stream(GF_ReframerCtx *ctx, RTStream *st, Bool do_free)
{
if (st->pck_queue) {
while (gf_list_count(st->pck_queue)) {
GF_FilterPacket *pck = gf_list_pop_front(st->pck_queue);
gf_filter_pck_unref(pck);
}
if (do_free)
gf_list_del(st->pck_queue);
}
if (st->split_pck) gf_filter_pck_unref(st->split_pck);
st->split_pck = NULL;
if (st->reinsert_single_pck) gf_filter_pck_unref(st->reinsert_single_pck);
st->reinsert_single_pck = NULL;
if (ctx->clock == st)
ctx->clock = NULL;
if (do_free)
gf_free(st);
}
static void reframer_push_props(GF_ReframerCtx *ctx, RTStream *st)
{
gf_filter_pid_reset_properties(st->opid);
gf_filter_pid_copy_properties(st->opid, st->ipid);
//if range processing, we drop frames not in the target playback range so do not forward delay
if (ctx->range_type && ((st->tk_delay>0) || (!st->tk_delay && !st->ts_sub)) ){
gf_filter_pid_set_property(st->opid, GF_PROP_PID_DELAY, NULL);
}
if (ctx->filter_sap1 || ctx->filter_sap2)
gf_filter_pid_set_property(st->opid, GF_PROP_PID_HAS_SYNC, &PROP_BOOL(GF_FALSE)); //false: all samples are sync
//seek mode, signal we have sample-accurate seek info for the pid
if (st->seek_mode)
gf_filter_pid_set_property(st->opid, GF_PROP_PID_HAS_SKIP_BEGIN, &PROP_BOOL(GF_TRUE));
//for old arch compat, signal we must remove edits
if (gf_sys_old_arch_compat()) {
gf_filter_pid_set_property_str(st->opid, "reframer_rem_edits", &PROP_BOOL(GF_TRUE) );
}
}
GF_Err reframer_configure_pid(GF_Filter *filter, GF_FilterPid *pid, Bool is_remove)
{
u32 i;
const GF_PropertyValue *p;
GF_ReframerCtx *ctx = gf_filter_get_udta(filter);
RTStream *st = gf_filter_pid_get_udta(pid);
if (is_remove) {
if (st) {
if (st->opid) {
gf_filter_pid_remove(st->opid);
gf_filter_pid_set_udta(st->opid, NULL);
}
gf_list_del_item(ctx->streams, st);
if (st->ipid)
gf_filter_pid_set_udta(st->ipid, NULL);
reframer_reset_stream(ctx, st, GF_TRUE);
}
return GF_OK;
}
if (!gf_filter_pid_check_caps(pid))
return GF_NOT_SUPPORTED;
if (!st) {
GF_SAFEALLOC(st, RTStream);
if (!st) return GF_OUT_OF_MEM;
gf_list_add(ctx->streams, st);
st->opid = gf_filter_pid_new(filter);
gf_filter_pid_set_udta(pid, st);
gf_filter_pid_set_udta(st->opid, st);
st->ipid = pid;
st->pck_queue = gf_list_new();
st->all_saps = GF_TRUE;
} else if (ctx->chkdisc.num<0) {
//check if we had no dsi previsously and got one - if so, do not consider this a discontinuity
Bool has_dsi=GF_FALSE, had_dsi=GF_FALSE;
p = gf_filter_pid_get_property(pid, GF_PROP_PID_DECODER_CONFIG);
if (!p) p = gf_filter_pid_get_property(pid, GF_PROP_PID_DECODER_CONFIG_ENHANCEMENT);
if (p) has_dsi = GF_TRUE;
p = gf_filter_pid_get_property(st->opid, GF_PROP_PID_DECODER_CONFIG);
if (!p) p = gf_filter_pid_get_property(st->opid, GF_PROP_PID_DECODER_CONFIG_ENHANCEMENT);
if (p) had_dsi = GF_TRUE;
if (has_dsi == had_dsi)
return GF_OK;
}
p = gf_filter_pid_get_property(pid, GF_PROP_PID_TIMESCALE);
if (p) st->timescale = p->value.uint;
else st->timescale = 1000;
if (!st->all_saps) {
ctx->nb_non_saps--;
st->all_saps = GF_TRUE;
}
st->can_split = GF_FALSE;
p = gf_filter_pid_get_property(pid, GF_PROP_PID_STREAM_TYPE);
st->stream_type = p ? p->value.uint : 0;
switch (st->stream_type) {
case GF_STREAM_TEXT:
case GF_STREAM_METADATA:
st->can_split = GF_TRUE;
break;
}
p = gf_filter_pid_get_property(pid, GF_PROP_PID_CODECID);
st->codec_id = p ? p->value.uint : 0;
st->nb_ch = st->abps = st->sample_rate = 0;
st->audio_planar = GF_FALSE;
st->is_raw = (st->codec_id==GF_CODECID_RAW) ? GF_TRUE : GF_FALSE;
if (st->is_raw && (st->stream_type==GF_STREAM_AUDIO)) {
p = gf_filter_pid_get_property(pid, GF_PROP_PID_AUDIO_FORMAT);
if (p) st->abps = gf_audio_fmt_bit_depth(p->value.uint) / 8;
p = gf_filter_pid_get_property(pid, GF_PROP_PID_NUM_CHANNELS);
if (p) st->nb_ch = p->value.uint;
p = gf_filter_pid_get_property(pid, GF_PROP_PID_SAMPLE_RATE);
st->sample_rate = p ? p->value.uint : st->timescale;
st->abps *= st->nb_ch;
p = gf_filter_pid_get_property(pid, GF_PROP_PID_AUDIO_FORMAT);
if (p && (p->value.uint>GF_AUDIO_FMT_LAST_PACKED))
st->audio_planar = GF_TRUE;
}
//if non SAP1 detected and xadjust, move directly to needs_adjust=TRUE
//otherwise consider we don't need to probe for next sap, this will be updated
//if one packet is not sap
st->needs_adjust = (ctx->xadjust && !st->all_saps) ? GF_TRUE : GF_FALSE;
st->tk_delay = 0;
st->ts_sub = 0;
p = gf_filter_pid_get_property(pid, GF_PROP_PID_DELAY);
if (p) {
//delay negative is skip: this is CTS adjustment for B-frames: we keep that notif in the stream
if (p->value.longsint<=0) {
st->tk_delay = 0;
st->ts_sub = (u32) -p->value.longsint;
}
//delay positive is delay, we keep the value for RT regulation and range
else {
st->tk_delay = (u64) p->value.longsint;
}
}
p = gf_filter_pid_get_property(pid, GF_PROP_PID_PLAYBACK_MODE);
if (!p || (p->value.uint < GF_PLAYBACK_MODE_FASTFORWARD))
ctx->seekable = GF_FALSE;
//trigger SEI loading if needed
if (ctx->load_sei) {
switch (st->codec_id) {
case GF_CODECID_AVC:
case GF_CODECID_SVC:
case GF_CODECID_MVC:
case GF_CODECID_HEVC:
case GF_CODECID_LHVC:
case GF_CODECID_VVC:
case GF_CODECID_AV1:
p = gf_filter_pid_get_property(pid, GF_PROP_PID_SEI_LOADED);
if (!p)
gf_filter_pid_negotiate_property(pid, GF_PROP_PID_SEI_LOADED, &PROP_BOOL(GF_TRUE) );
}
}
ctx->filter_sap1 = ctx->filter_sap2 = ctx->filter_sap3 = ctx->filter_sap4 = ctx->filter_sap_none = GF_FALSE;
for (i=0; i<ctx->saps.nb_items; i++) {
switch (ctx->saps.vals[i]) {
case 1:
ctx->filter_sap1 = GF_TRUE;
gf_filter_pid_set_property(st->opid, GF_PROP_PID_HAS_SYNC, &PROP_BOOL(GF_FALSE)); //false: all samples are sync
break;
case 2:
ctx->filter_sap2 = GF_TRUE;
gf_filter_pid_set_property(st->opid, GF_PROP_PID_HAS_SYNC, &PROP_BOOL(GF_FALSE)); //false: all samples are sync
break;
case 3: ctx->filter_sap3 = GF_TRUE; break;
case 4: ctx->filter_sap4 = GF_TRUE; break;
default: ctx->filter_sap_none = GF_TRUE; break;
}
}
gf_filter_pid_set_framing_mode(pid, GF_TRUE);
//NEVER use seek mode for uncompressed audio, packets are splitted anyway
if (ctx->extract_mode==EXTRACT_RANGE) {
if (st->abps) {
st->seek_mode = GF_FALSE;
}
//use seek if seek is forced
else if (ctx->xround==REFRAME_ROUND_SEEK) {
st->seek_mode = GF_TRUE;
}
//use seek mode for compressed audio with or without priming
else if (st->stream_type==GF_STREAM_AUDIO) {
st->seek_mode = ctx->no_audio_seek ? GF_FALSE : GF_TRUE;
} else {
st->seek_mode = GF_FALSE;
}
} else {
st->seek_mode = GF_FALSE;
}
reframer_push_props(ctx, st);
if (ctx->cur_range_idx && (ctx->cur_range_idx <= ctx->props.nb_items)) {
gf_filter_pid_push_properties(st->opid, ctx->props.vals[ctx->cur_range_idx-1], GF_FALSE, GF_FALSE);
}
return GF_OK;
}
static Bool reframer_parse_date(GF_ReframerCtx *ctx, char *date, GF_Fraction64 *value, u64 *frame_idx_plus_one, u32 *extract_mode, Bool *is_dur, GF_TimeCode **as_timecode)
{
u64 v;
*as_timecode = NULL;
value->num =0;
value->den = 0;
if (extract_mode)
*extract_mode = EXTRACT_RANGE;
if (is_dur)
*is_dur = GF_FALSE;
if (*as_timecode)
gf_free(*as_timecode);
if (strlen(date)>2 && date[0]=='T' && date[1]=='C') {
u32 h=0, m=0, s=0, n_frames=0;
if (sscanf(date, "TC%u:%u:%u:%u", &h, &m, &s, &n_frames) != 4) {
goto exit;
}
//we use timecodes, load SEI
ctx->load_sei = GF_TRUE;
// Express timecode as timestamp
// cur_start/end will be overwritten later. This ensures checks after this parser can work
v = h*3600 + m*60 + s;
v *= 1000;
v += n_frames;
value->num = v;
value->den = 1000;
// Encode timecode as 4 bytes
GF_SAFEALLOC(*as_timecode, GF_TimeCode);
(*as_timecode)->hours = h;
(*as_timecode)->minutes = m;
(*as_timecode)->seconds = s;
(*as_timecode)->n_frames = n_frames;
return GF_TRUE;
}
if (date[0] == 'T') {
u32 h=0, m=0, s=0, ms=0;
if (strchr(date, '.')) {
if (sscanf(date, "T%u:%u:%u.%u", &h, &m, &s, &ms) != 4) {
h = 0;
if (sscanf(date, "T%u:%u.%u", &m, &s, &ms) != 3) {
m = 0;
if (sscanf(date, "T%u.%u", &s, &ms) != 2) {
goto exit;
}
}
}
if (ms>=1000) ms=0;
} else {
if (sscanf(date, "T%u:%u:%u", &h, &m, &s) != 3) {
h = 0;
if (sscanf(date, "T%u:%u", &m, &s) != 2) {
goto exit;
}
}
}
v = h*3600 + m*60 + s;
v *= 1000;
v += ms;
value->num = v;
value->den = 1000;
return GF_TRUE;
}
if ((date[0]=='F') || (date[0]=='f')) {
*frame_idx_plus_one = 1 + atoi(date+1);
return GF_TRUE;
}
if (!strcmp(date, "RAP") || !strcmp(date, "SAP")) {
if (extract_mode)
*extract_mode = EXTRACT_SAP;
value->num = 0;
value->den = 1000;
return GF_TRUE;
}
if ((date[0]=='D') || (date[0]=='d')) {
if (extract_mode)
*extract_mode = EXTRACT_DUR;
if (is_dur)
*is_dur = GF_TRUE;
if (sscanf(date+1, LLD"/"LLU, &value->num, &value->den)==2) {
return GF_TRUE;
}
if (strchr(date+1, '.')) {
Double res = atof(date+1);
value->den = 1000000;
value->num = (s64) (res * value->den);
return GF_TRUE;
}
if (sscanf(date+1, LLU, &v)==1) {
value->num = v;
value->den = 1;
return GF_TRUE;
}
}
if ((date[0]=='S') || (date[0]=='s')) {
GF_PropertyValue p;
if (extract_mode)
*extract_mode = EXTRACT_SIZE;
p = gf_props_parse_value(GF_PROP_LUINT, "size", date+1, NULL, ',');
if (p.type==GF_PROP_LUINT) {
value->den = p.value.longuint;
return GF_TRUE;
}
}
if (strchr(date, 'T')) {
value->num = gf_net_parse_date(date);
value->den = 0;
return GF_TRUE;
}
if (gf_parse_lfrac(date, value)) {
return GF_TRUE;
}
exit:
GF_LOG(GF_LOG_WARNING, GF_LOG_MEDIA, ("[Reframer] Unrecognized date format %s, expecting TCHH:MM:SS:FFF, THH:MM:SS[.ms], TMM:SS[.ms], TSS[.ms], INT or FRAC\n", date));
if (extract_mode)
*extract_mode = EXTRACT_NONE;
return GF_FALSE;
}
static void reframer_load_range(GF_ReframerCtx *ctx)
{
u32 i, count;
Bool do_seek = ctx->seekable;
Bool reset_asplit = GF_TRUE;
u64 prev_frame = ctx->start_frame_idx_plus_one;
GF_Fraction64 prev_end;
char *start_date=NULL, *end_date=NULL;
ctx->cur_start_valid = GF_TRUE;
ctx->cur_end_valid = GF_TRUE;
ctx->nb_video_frames_since_start_at_range_start = ctx->nb_video_frames_since_start;
if (ctx->extract_mode==EXTRACT_DUR) {
ctx->cur_start.num += (ctx->extract_dur.num * ctx->cur_start.den) / ctx->extract_dur.den;
ctx->cur_end.num += (ctx->extract_dur.num * ctx->cur_end.den) / ctx->extract_dur.den;
ctx->file_idx++;
return;
}
if ((ctx->extract_mode==EXTRACT_SAP) || (ctx->extract_mode==EXTRACT_SIZE)) {
ctx->cur_start = ctx->cur_end;
if (!ctx->cur_start.den) ctx->cur_start.den = 1;
ctx->min_ts_computed = 0;
ctx->min_ts_scale = 0;
ctx->file_idx++;
return;
}
prev_end = ctx->cur_end;
ctx->start_frame_idx_plus_one = 0;
ctx->end_frame_idx_plus_one = 0;
ctx->cur_start.num = 0;
ctx->cur_start.den = 0;
ctx->cur_end.num = 0;
ctx->cur_end.den = 0;
count = ctx->xs.nb_items;
if (!count) {
if (ctx->range_type) goto range_done;
return;
}
if (ctx->cur_range_idx>=count) {
goto range_done;
} else {
start_date = ctx->xs.vals[ctx->cur_range_idx];
end_date = NULL;
if (ctx->cur_range_idx < ctx->xe.nb_items)
end_date = ctx->xe.vals[ctx->cur_range_idx];
else if (ctx->cur_range_idx + 1 < ctx->xs.nb_items)
end_date = ctx->xs.vals[ctx->cur_range_idx+1];
if (end_date && !end_date[0]) end_date = NULL;
}
if (!start_date)
goto range_done;
ctx->cur_range_idx++;
if (!end_date) ctx->range_type = RANGE_OPEN;
else ctx->range_type = RANGE_CLOSED;
if (!reframer_parse_date(ctx, start_date, &ctx->cur_start, &ctx->start_frame_idx_plus_one, &ctx->extract_mode, NULL, &ctx->cur_start_tc)) {
GF_LOG(GF_LOG_WARNING, GF_LOG_MEDIA, ("[Reframer] cannot parse start date, assuming end of ranges\n"));
//done
ctx->range_type = RANGE_DONE;
return;
}
//start will be adjusted
if (ctx->cur_start_tc || ctx->utc_ref==UTCREF_TC)
ctx->cur_start_valid = GF_FALSE;
//range in frame
if (ctx->start_frame_idx_plus_one) {
//either range is before or prev range was not frame-based
if (ctx->start_frame_idx_plus_one > prev_frame)
do_seek = GF_TRUE;
}
//range is time based, prev was frame-based, seek
else if (!prev_end.den) {
do_seek = GF_TRUE;
} else {
//cur start is before previous end, need to seek
if (ctx->cur_start.num * prev_end.den < prev_end.num * ctx->cur_start.den) {
do_seek = GF_TRUE;
}
//cur start is less than our seek safety from previous end, do not seek
if (ctx->cur_start.num * prev_end.den < (prev_end.num + ctx->seeksafe*prev_end.den) * ctx->cur_start.den)
do_seek = GF_FALSE;
}
//do not issue seek on first range, done when catching play requests
if (ctx->cur_range_idx==1) {
do_seek = GF_FALSE;
}
if (!ctx->cur_start.den)
do_seek = GF_FALSE;
if (!ctx->seekable && do_seek) {
GF_LOG(GF_LOG_ERROR, GF_LOG_MEDIA, ("[Reframer] ranges not in order and input not seekable, aborting extraction\n"));
goto range_done;
}
ctx->is_range_extraction = ((ctx->extract_mode==EXTRACT_RANGE) || (ctx->extract_mode==EXTRACT_DUR)) ? GF_TRUE : GF_FALSE;
if (ctx->extract_mode != EXTRACT_RANGE) {
end_date = NULL;
if (ctx->extract_mode==EXTRACT_DUR) {
ctx->extract_dur = ctx->cur_start;
ctx->cur_start.num = 0;
ctx->cur_start.den = ctx->extract_dur.den;
ctx->cur_end = ctx->extract_dur;
ctx->range_type = RANGE_CLOSED;
ctx->file_idx = 1;
ctx->splitrange = GF_TRUE;
ctx->xadjust = GF_TRUE;
}
else if (ctx->extract_mode==EXTRACT_SIZE) {
ctx->splitrange = GF_TRUE;
ctx->split_size = ctx->cur_start.den;
if (!ctx->split_size) {
GF_LOG(GF_LOG_WARNING, GF_LOG_MEDIA, ("[Reframer] invalid split size %d\n", ctx->split_size));
goto range_done;
}
ctx->file_idx = 1;
}
else if (ctx->extract_mode==EXTRACT_SAP) {
ctx->splitrange = GF_TRUE;
}
}
if (end_date) {
Bool is_dur = GF_FALSE;
ctx->end_frame_idx_plus_one = 0;
if (!reframer_parse_date(ctx, end_date, &ctx->cur_end, &ctx->end_frame_idx_plus_one, NULL, &is_dur, &ctx->cur_end_tc)) {
GF_LOG(GF_LOG_WARNING, GF_LOG_MEDIA, ("[Reframer] cannot parse end date, assuming open range\n"));
ctx->range_type = RANGE_OPEN;
} else {
//end will be adjusted
if (ctx->cur_end_tc)
ctx->cur_end_valid = GF_FALSE;
if (is_dur) {
ctx->cur_end.num = gf_timestamp_rescale(ctx->cur_end.num, ctx->cur_end.den, ctx->cur_start.den);
ctx->cur_end.den = ctx->cur_start.den;
ctx->cur_end.num += ctx->cur_start.num;
}
if (!ctx->end_frame_idx_plus_one && gf_timestamp_greater_or_equal(ctx->cur_start.num, ctx->cur_start.den, ctx->cur_end.num, ctx->cur_end.den) ) {
GF_LOG(GF_LOG_WARNING, GF_LOG_MEDIA, ("[Reframer] End range before start range, assuming open range\n"));
ctx->range_type = RANGE_OPEN;
}
}
}
if (prev_end.den && (prev_end.num * ctx->cur_start.den == prev_end.den * ctx->cur_start.num))
reset_asplit = GF_FALSE;
//reset realtime range and issue seek requests
if (ctx->rt || do_seek || reset_asplit) {
Double start_range = 0;
if (do_seek) {
start_range = (Double) ctx->cur_start.num;
start_range /= ctx->cur_start.den;
if (start_range > ctx->seeksafe)
start_range -= ctx->seeksafe;
else
start_range = 0;
ctx->has_seen_eos = GF_FALSE;
ctx->nb_video_frames_since_start_at_range_start = 0;
ctx->nb_video_frames_since_start = 0;
}
count = gf_list_count(ctx->streams);
for (i=0; i<count; i++) {
RTStream *st = gf_list_get(ctx->streams, i);
if (ctx->rt) {
st->cts_us_at_init = 0;
st->sys_clock_at_init = 0;
}
if (do_seek) {
GF_FilterEvent evt;
GF_FEVT_INIT(evt, GF_FEVT_STOP, st->ipid);
gf_filter_pid_send_event(st->ipid, &evt);
GF_FEVT_INIT(evt, GF_FEVT_PLAY, st->ipid);
evt.play.start_range = start_range;
evt.play.speed = 1;
gf_filter_pid_send_event(st->ipid, &evt);
st->nb_frames = 0;
}
if (reset_asplit) {
st->audio_samples_to_keep = 0;
}
}
}
if (ctx->cur_range_idx && (ctx->cur_range_idx <= ctx->props.nb_items)) {
count = gf_list_count(ctx->streams);
for (i=0; i<count; i++) {
RTStream *st = gf_list_get(ctx->streams, i);
reframer_push_props(ctx, st);
gf_filter_pid_push_properties(st->opid, ctx->props.vals[ctx->cur_range_idx-1], GF_FALSE, GF_FALSE);
gf_filter_pid_set_property_str(st->opid, "period_resume", &PROP_STRING("") );
}
}
return;
range_done:
//done
ctx->range_type = RANGE_DONE;
count = gf_list_count(ctx->streams);
for (i=0; i<count; i++) {
GF_FilterEvent evt;
RTStream *st = gf_list_get(ctx->streams, i);
gf_filter_pid_set_discard(st->ipid, GF_TRUE);
GF_FEVT_INIT(evt, GF_FEVT_STOP, st->ipid);
gf_filter_pid_send_event(st->ipid, &evt);
gf_filter_pid_set_eos(st->opid);
}
}
void reframer_drop_packet(GF_ReframerCtx *ctx, RTStream *st, GF_FilterPacket *pck, Bool pck_is_ref)
{
if (pck_is_ref) {
gf_list_rem(st->pck_queue, 0);
gf_filter_pck_unref(pck);
} else {
gf_filter_pid_drop_packet(st->ipid);
}
}
void reframer_copy_raw_audio(RTStream *st, const u8 *src, u32 src_size, u32 offset, u8 *dst, u32 nb_samp)
{
if (st->audio_planar) {
u32 i, bps, stride;
stride = src_size / st->nb_ch;
bps = st->abps / st->nb_ch;
for (i=0; i<st->nb_ch; i++) {
memcpy(dst + i*bps*nb_samp, src + i*stride + offset * bps, nb_samp * bps);
}
} else {
memcpy(dst, src + offset * st->abps, nb_samp * st->abps);
}
}
Bool reframer_send_packet(GF_Filter *filter, GF_ReframerCtx *ctx, RTStream *st, GF_FilterPacket *pck, Bool pck_is_ref)
{
Bool do_send = GF_FALSE;
if (!ctx->rt) {
do_send = GF_TRUE;
} else {
u64 cts_us = gf_filter_pck_get_dts(pck);
if (cts_us==GF_FILTER_NO_TS)
cts_us = gf_filter_pck_get_cts(pck);
if (cts_us==GF_FILTER_NO_TS) {
do_send = GF_TRUE;
} else if (ctx->rt==REFRAME_RT_ALIGN) {
Bool do_align = GF_FALSE;
RTStream *st_clock = st;
cts_us += st->tk_delay;
cts_us = gf_timestamp_rescale(cts_us, st->timescale, 1000000);
if (!ctx->clock) ctx->clock = st;
st_clock = ctx->clock;
//very first packet sent
if (!st_clock->sys_clock_at_init) {
st_clock->sys_clock_at_init = cts_us+1;
do_align = GF_TRUE;
}
//no more packets and the stream is the next to be scheduled
else if (!ctx->nb_align_pending && ((st->cts_us_at_init == ctx->next_cts_align) || !ctx->next_cts_align) ) {
st_clock->sys_clock_at_init = st->cts_us_at_init;
do_align = GF_TRUE;
} else if (cts_us <= st_clock->sys_clock_at_init - 1) {
do_send = GF_TRUE;
}
//ahead of clock, signal first time we see this
else if (ctx->nb_align_pending && st->cts_us_at_init != cts_us+1) {
//remember last cts
st->cts_us_at_init = cts_us+1;
ctx->nb_align_pending--;
//select as clock for next regulation period if less than next align time
if (!ctx->next_cts_align || (cts_us < ctx->next_cts_align-1))
ctx->next_cts_align = cts_us+1;
}
if (do_align) {
ctx->next_cts_align = 0;
ctx->nb_align_pending = 0;
u32 i;
for (i=0; i<gf_list_count(ctx->streams); i++) {
RTStream *ast = gf_list_get(ctx->streams, i);
//reset last cts, and increment nb_align_pending for all playing streams
ast->cts_us_at_init = 0;
if (ast->in_eos) continue;
if (!ast->is_playing) continue;
ctx->nb_align_pending++;
}
do_send = GF_TRUE;
}
} else {
RTStream *st_clock = st;
u64 clock = ctx->clock_val;
cts_us += st->tk_delay;
cts_us = gf_timestamp_rescale(cts_us, st->timescale, 1000000);
if (ctx->rt==REFRAME_RT_SYNC) {
if (!ctx->clock) ctx->clock = st;
st_clock = ctx->clock;
}
if (!st_clock->sys_clock_at_init) {
st_clock->cts_us_at_init = cts_us;
st_clock->sys_clock_at_init = clock;
do_send = GF_TRUE;
} else if (cts_us < st_clock->cts_us_at_init) {
GF_LOG(GF_LOG_WARNING, GF_LOG_MEDIA, ("[Reframer] CTS less than CTS used to initialize clock by %d ms, not delaying\n", (u32) (st_clock->cts_us_at_init - cts_us)/1000));
do_send = GF_TRUE;
} else {
u64 diff = cts_us - st_clock->cts_us_at_init;
if (ctx->rt_speed>0) diff = (u64) ( diff / ctx->rt_speed);
else if (ctx->rt_speed<0) diff = (u64) ( diff / -ctx->rt_speed);
clock -= st_clock->sys_clock_at_init;
if (clock + RT_PRECISION_US >= diff) {
do_send = GF_TRUE;
if (clock > diff) {
GF_LOG(GF_LOG_DEBUG, GF_LOG_MEDIA, ("[Reframer] Sending packet "LLU" us too late (clock diff "LLU" - CTS diff "LLU")\n", 1000+clock - diff, clock, diff));
}
} else {
diff -= clock;
if (!ctx->reschedule_in)
ctx->reschedule_in = diff;
else if (ctx->reschedule_in > diff)
ctx->reschedule_in = diff;
}
}
}
}
if (!ctx->range_type && ctx->frames.nb_items) {
u32 i;
Bool found=GF_FALSE;
s32 max_f=0;
for (i=0; i<ctx->frames.nb_items; i++) {
s32 v = ctx->frames.vals[i];
if (v>=0) {
if (!max_f || (max_f<v))
max_f = v;
if (v == st->nb_frames + 1) {
found=GF_TRUE;
break;
}
} else {
if (st->nb_frames % (-v) == 0) {
found=GF_TRUE;
break;
}
}
}
if (!found) {
//drop
gf_filter_pid_drop_packet(st->ipid);
st->nb_frames++;
if (max_f && ((u32) max_f < st->nb_frames + 1)) {
GF_FilterEvent evt;
GF_FEVT_INIT(evt, GF_FEVT_STOP, st->ipid);
gf_filter_pid_send_event(st->ipid, &evt);
gf_filter_pid_set_eos(st->opid);
}
return GF_TRUE;
}
}
if (!do_send)
return GF_FALSE;
Bool is_ts_disc = GF_FALSE;
if (!ctx->is_range_extraction && ctx->chkdisc.num>0) {
u64 ts = gf_filter_pck_get_dts(pck);
if (ts==GF_FILTER_NO_TS)
ts = gf_filter_pck_get_cts(pck);
if (ts!=GF_FILTER_NO_TS) {
ts = gf_timestamp_rescale(ts, st->timescale, ctx->chkdisc.den);
if (!st->last_ts_sent) {
} else if (ts < st->last_ts_sent) {
is_ts_disc = GF_TRUE;
} else if (ts > st->last_ts_sent + ctx->chkdisc.num) {
is_ts_disc = GF_TRUE;
}
if (is_ts_disc) {
st->ts_disc_idx++;
GF_LOG(GF_LOG_WARNING, GF_LOG_MEDIA, ("[Reframer] Detected time discontinuity on pid %s (timestamps: old "LLU", new "LLU")\n", gf_filter_pid_get_name(st->ipid), st->last_ts_sent, ts));
gf_filter_pid_set_property(st->opid, GF_PROP_PID_TIME_DISCONTINUITY, &PROP_UINT(st->ts_disc_idx));
//reset real-time regulation
st->cts_us_at_init = 0;
st->sys_clock_at_init = 0;
}
st->last_ts_sent = ts;
}
}
//range processing
if (st->ts_at_range_start_plus_one) {
Bool is_split = GF_FALSE;
s64 ts;
s32 ts_adj = 0;
u32 cts_offset=0;
u32 dur=0;
GF_FilterPacket *new_pck;
//tmcd, rewrite sample
if (ctx->tcmdrw && (st->codec_id==GF_CODECID_TMCD) && st->split_start && ctx->nb_video_frames_since_start_at_range_start) {
GF_BitStream *bs;
u32 nb_frames;
u8 *tcmd_data = NULL;
new_pck = gf_filter_pck_new_copy(st->opid, pck, &tcmd_data);
if (!new_pck) return GF_FALSE;
bs = gf_bs_new(tcmd_data, 4, GF_BITSTREAM_READ);
nb_frames = gf_bs_read_u32(bs);
gf_bs_del(bs);
bs = gf_bs_new(tcmd_data, 4, GF_BITSTREAM_WRITE);
gf_bs_seek(bs, 0);
gf_bs_write_u32(bs, nb_frames+ctx->nb_video_frames_since_start_at_range_start);
gf_bs_del(bs);
dur = gf_filter_pck_get_duration(pck);
if (dur > st->split_start)
dur -= st->split_start;
if (st->split_end && (dur > st->split_end - st->split_start))
dur = st->split_end - st->split_start;
ts_adj = st->split_start;
} else if ((pck == st->split_pck) && st->audio_samples_to_keep) {
const u8 *data;
u32 pck_size;
data = gf_filter_pck_get_data(pck, &pck_size);
if (st->abps) {
if (st->audio_samples_to_keep * st->abps <= pck_size) {
u8 *output;
new_pck = gf_filter_pck_new_alloc(st->opid, st->audio_samples_to_keep * st->abps, &output);
if (!new_pck) return GF_FALSE;
reframer_copy_raw_audio(st, data, pck_size, 0, output, st->audio_samples_to_keep);
} else {
GF_LOG(GF_LOG_WARNING, GF_LOG_MEDIA, ("[Reframer] Broken raw audio frame size/duration: %d samples to keep but packet is smaller (%d samples)\n", st->audio_samples_to_keep, pck_size/st->abps));
st->audio_samples_to_keep = 0;
new_pck = gf_filter_pck_new_ref(st->opid, 0, 0, pck);
if (!new_pck) return GF_FALSE;
}
} else {
new_pck = gf_filter_pck_new_ref(st->opid, 0, 0, pck);
if (!new_pck) return GF_FALSE;
}
dur = st->audio_samples_to_keep;
} else if (st->audio_samples_to_keep) {
u8 *output;
const u8 *data;
u32 pck_size;
data = gf_filter_pck_get_data(pck, &pck_size);
if (st->abps) {
if (pck_size < st->audio_samples_to_keep * st->abps) {
GF_LOG(GF_LOG_WARNING, GF_LOG_MEDIA, ("[Reframer] Broken raw audio frame size/duration: %d samples to keep but packet is smaller (%d samples)\n", st->audio_samples_to_keep, pck_size/st->abps));
st->audio_samples_to_keep = 0;
}
new_pck = gf_filter_pck_new_alloc(st->opid, pck_size - st->audio_samples_to_keep * st->abps, &output);
if (!new_pck) return GF_FALSE;
reframer_copy_raw_audio(st, data, pck_size, st->audio_samples_to_keep, output, pck_size/st->abps - st->audio_samples_to_keep);
dur = pck_size/st->abps - st->audio_samples_to_keep;
cts_offset = st->audio_samples_to_keep;
//if first range, add CTS offset to ts at range start
if (ctx->cur_range_idx==1)
st->ts_at_range_start_plus_one += cts_offset;
} else {
new_pck = gf_filter_pck_new_ref(st->opid, 0, 0, pck);
if (!new_pck) return GF_FALSE;
dur = gf_filter_pck_get_duration(pck);
gf_filter_pck_set_property(new_pck, GF_PROP_PCK_SKIP_BEGIN, &PROP_UINT( st->audio_samples_to_keep ) );
}
st->audio_samples_to_keep = 0;
} else {
new_pck = gf_filter_pck_new_ref(st->opid, 0, 0, pck);
if (!new_pck) return GF_FALSE;
}
gf_filter_pck_merge_properties(pck, new_pck);
if (cts_offset || dur) {
if (st->abps && (st->timescale!=st->sample_rate)) {
cts_offset = (u32) gf_timestamp_rescale(cts_offset, st->sample_rate, st->timescale);
dur *= st->timescale;
dur /= st->sample_rate;
}
gf_filter_pck_set_duration(new_pck, dur);
}
//signal chunk start boundary
if (!st->first_pck_sent) {
u64 start_t, end_t;
char szFileSuf[1000];
u32 i, len;
char *file_suf_name = NULL;
char *start = ctx->xs.vals[ctx->cur_range_idx-1];
char *end = NULL;
if ((ctx->range_type==1) && (ctx->cur_range_idx<ctx->xe.nb_items+1)) {
end = ctx->xe.vals[ctx->cur_range_idx-1];
}
st->first_pck_sent = GF_TRUE;
if (ctx->extract_mode==EXTRACT_RANGE) {
gf_filter_pck_set_property(new_pck, GF_PROP_PCK_FILENUM, &PROP_UINT(ctx->cur_range_idx) );
if (strchr(start, '/')) {
start_t = ctx->cur_start.num;
start_t /= ctx->cur_start.den;
if (ctx->cur_end.den) {
end_t = ctx->cur_end.num;
end_t /= ctx->cur_end.den;
sprintf(szFileSuf, LLU"-"LLU, start_t, end_t);
} else {
sprintf(szFileSuf, LLU, start_t);
}
gf_filter_pck_set_property(new_pck, GF_PROP_PCK_FILESUF, &PROP_STRING(szFileSuf) );
} else {
gf_dynstrcat(&file_suf_name, start, NULL);
if (end)
gf_dynstrcat(&file_suf_name, end, "_");
if (file_suf_name) {
len = (u32) strlen(file_suf_name);
//replace : and / characters
for (i=0; i<len; i++) {
switch (file_suf_name[i]) {
case ':':
case '/':
file_suf_name[i] = '.';
break;
}
}
gf_filter_pck_set_property(new_pck, GF_PROP_PCK_FILESUF, &PROP_STRING_NO_COPY(file_suf_name) );
}
}
} else {
gf_filter_pck_set_property(new_pck, GF_PROP_PCK_FILENUM, &PROP_UINT(ctx->file_idx) );
start_t = ctx->cur_start.num * 1000;
start_t /= ctx->cur_start.den;
if (ctx->cur_end.den) {
end_t = ctx->cur_end.num * 1000;
end_t /= ctx->cur_end.den;
sprintf(szFileSuf, LLU"-"LLU, start_t, end_t);
} else {
sprintf(szFileSuf, LLU, start_t);
}
gf_filter_pck_set_property(new_pck, GF_PROP_PCK_FILESUF, &PROP_STRING(szFileSuf) );
}
if (st->nb_frames) {
const GF_PropertyValue *p = gf_filter_pid_get_property(st->ipid, GF_PROP_PID_NB_FRAMES);
if (p) {
gf_filter_pid_set_property(st->opid, GF_PROP_PID_FRAME_OFFSET, &PROP_UINT(st->nb_frames) );
}
}
if (ctx->file_idx>1) {
gf_filter_pid_set_property(st->opid, GF_PROP_PID_DELAY, NULL);
}
}
//rewrite timestamps
ts = gf_filter_pck_get_cts(pck) + cts_offset;
if (ts != GF_FILTER_NO_TS) {
if (ctx->is_range_extraction
&& st->seek_mode
&& gf_timestamp_less(ts + ts_adj - st->ts_sub, st->timescale, ctx->cur_start.num, ctx->cur_start.den)
) {
gf_filter_pck_set_seek_flag(new_pck, GF_TRUE);
gf_filter_pck_set_property(new_pck, GF_PROP_PCK_SKIP_BEGIN, NULL);
if (st->stream_type!=GF_STREAM_VISUAL) {
u32 pck_dur = gf_filter_pck_get_duration(new_pck);
if (gf_timestamp_greater(ts + ts_adj + pck_dur - st->ts_sub, st->timescale, ctx->cur_start.num, ctx->cur_start.den)) {
u32 ts_diff = (u32) ( gf_timestamp_rescale(ctx->cur_start.num, ctx->cur_start.den, st->timescale) - (ts + ts_adj - st->ts_sub));
gf_filter_pck_set_property(new_pck, GF_PROP_PCK_SKIP_BEGIN, &PROP_UINT(ts_diff));
gf_filter_pck_set_seek_flag(new_pck, GF_FALSE);
}
}
}
if (!ctx->xots) {
ts += st->tk_delay;
ts += st->ts_at_range_end;
ts -= st->ts_at_range_start_plus_one - 1;
ts += gf_timestamp_rescale(ctx->ts_tc_offset.num, ctx->ts_tc_offset.den, st->timescale);
if (ts<0) {
GF_LOG(GF_LOG_WARNING, GF_LOG_MEDIA, ("[Reframer] Negative TS while splitting, something went wrong during range estimation, forcing to 0\n"));
ts = 0;
}
}
if (st->probe_ref_frame_ts && (gf_filter_pck_get_dts(pck) + st->tk_delay + 1 == st->probe_ref_frame_ts)) {
gf_filter_pck_set_property(new_pck, GF_PROP_PCK_SKIP_PRES, &PROP_BOOL(GF_TRUE));
}
gf_filter_pck_set_cts(new_pck, (u64) ts);
if (st->is_raw) {
gf_filter_pck_set_dts(new_pck, ts);
}
}
if (!st->is_raw && !ctx->xots) {
ts = gf_filter_pck_get_dts(pck) + cts_offset;
if (ts != GF_FILTER_NO_TS) {
ts += st->tk_delay;
ts -= st->ts_at_range_start_plus_one - 1;
ts += st->ts_at_range_end;
ts += gf_timestamp_rescale(ctx->ts_tc_offset.num, ctx->ts_tc_offset.den, st->timescale);
gf_filter_pck_set_dts(new_pck, (u64) ts);
}
}
//packet was split or was re-inserted
if (st->split_start) {
if (!dur) {
u32 pck_dur = gf_filter_pck_get_duration(pck);
//can happen if source packet is less than split period duration, we just copy with no timing adjustment
if (pck_dur > st->split_start)
pck_dur -= st->split_start;
gf_filter_pck_set_duration(new_pck, pck_dur);
}
st->ts_at_range_start_plus_one += st->split_start;
st->split_start = 0;
is_split = GF_TRUE;
}
//last packet and forced duration
if (st->split_end && (gf_list_count(st->pck_queue)==1)) {
if (!dur) {
gf_filter_pck_set_duration(new_pck, st->split_end);
}
st->split_end = 0;
is_split = GF_TRUE;
}
//packet reinserted (not split), adjust duration and store offset in split start
if (!st->can_split && !is_split && st->reinsert_single_pck) {
dur = gf_filter_pck_get_duration(pck);
//only for closed range
if (st->range_end_reached_ts) {
u64 ndur = st->range_end_reached_ts;
ndur -= st->ts_at_range_start_plus_one-1;
if (ndur && (ndur < dur))
gf_filter_pck_set_duration(new_pck, (u32) ndur);
st->split_start = (u32) ndur;
}
}
if (ctx->rmseek)
gf_filter_pck_set_seek_flag(new_pck, GF_FALSE);
// forward SAPs as cue points
u32 sap = gf_filter_pck_get_sap(new_pck);
if (sap > 0 && sap <= ctx->sapcue)
gf_filter_pck_set_property(new_pck, GF_PROP_PCK_CUE_START, &PROP_BOOL(GF_TRUE));
//if all saps, using the the final timestamp, decide if we should send the packet
if (st->all_saps && !ctx->nosap && st->stream_type==GF_STREAM_VISUAL
&& st->wait_seg_boundary==WAIT_SEG_BOUNDARY_ACTIVE && st->segdur.den>0) {
GF_Fraction fps = {0};
const GF_PropertyValue *p = gf_filter_pid_get_property(st->ipid, GF_PROP_PID_FPS);
u64 cts = gf_filter_pck_get_cts(new_pck);
if (p) fps = p->value.frac;
if (fps.den==0 || fps.num==0) {
GF_LOG(GF_LOG_ERROR, GF_LOG_MEDIA, ("[Reframer] Invalid FPS %d/%u when looking for UTCREF_TC segment boundary\n", fps.num, fps.den));
}
else if (cts != GF_FILTER_NO_TS) {
u32 seg_nframes = st->segdur.num * fps.num / (st->segdur.den * fps.den);
assert(ctx->ts_tc_offset.den == st->timescale);
u32 diff_nframes = (cts - ctx->ts_tc_offset.num - ctx->cur_start.num) * fps.num / (st->timescale * fps.den);
Bool is_seg_boundary = diff_nframes % seg_nframes == 0;
//fallback, check if other tracks are currently sending
if (!is_seg_boundary && ctx->wait_seg_boundary_ts.den>0) {
is_seg_boundary = gf_timestamp_greater_or_equal(ts, st->timescale, ctx->wait_seg_boundary_ts.num, ctx->wait_seg_boundary_ts.den);
}
if (is_seg_boundary) {
// first packet to be sent adjusts the start time
if (ctx->wait_seg_boundary_ts.den==0 || gf_timestamp_less(cts, st->timescale, ctx->wait_seg_boundary_ts.num, ctx->wait_seg_boundary_ts.den)) {
ctx->wait_seg_boundary_ts.num = cts;
ctx->wait_seg_boundary_ts.den = st->timescale;
}
st->wait_seg_boundary = WAIT_SEG_BOUNDARY_DONE;
} else {
// this frame wouldn't be considered as sap because it's within the segment duration
gf_filter_pck_discard(new_pck);
new_pck = NULL;
}
}
}
if (new_pck) gf_filter_pck_send(new_pck);
} else {
GF_FilterPacket *dst = ctx->copy ? gf_filter_pck_new_copy(st->opid, pck, NULL) : gf_filter_pck_new_ref(st->opid, 0, 0, pck);
if (dst) {
gf_filter_pck_merge_properties(pck, dst);
if (ctx->rmseek)
gf_filter_pck_set_seek_flag(dst, GF_FALSE);
// forward SAPs as cue points
u32 sap = gf_filter_pck_get_sap(dst);
if (sap > 0 && sap <= ctx->sapcue)
gf_filter_pck_set_property(dst, GF_PROP_PCK_CUE_START, &PROP_BOOL(GF_TRUE));
gf_filter_pck_send(dst);
}
}
reframer_drop_packet(ctx, st, pck, pck_is_ref);
st->nb_frames++;
if (st->stream_type==GF_STREAM_VISUAL) {
if (st->nb_frames > ctx->nb_video_frames_since_start) {
ctx->nb_video_frames_since_start = st->nb_frames;
}
}
return GF_TRUE;
}
static u32 reframer_check_pck_range(GF_Filter *filter, GF_ReframerCtx *ctx, RTStream *st, GF_FilterPacket *pck, u64 ts, u32 dur, u32 frame_idx, u32 *nb_audio_samples_to_keep)
{
if (ctx->start_frame_idx_plus_one) {
//frame not after our range start
if (frame_idx+1<ctx->start_frame_idx_plus_one) {
return 0;
} else {
//closed range, check
if ((ctx->range_type!=RANGE_OPEN) && (frame_idx>=ctx->end_frame_idx_plus_one)) {
return 2;
}
return 1;
}
return 0;
}
Bool before = GF_FALSE;
Bool after = GF_FALSE;
if (!ctx->cur_start.den) {
u64 now=0;
if (ctx->utc_ref) {
//check sender NTP on packet
const GF_PropertyValue *date = gf_filter_pck_get_property(pck, GF_PROP_PCK_SENDER_NTP);
if (date) {
now = gf_net_ntp_to_utc(date->value.longuint);
st->last_utc_ref = now;
st->last_utc_ref_ts = ts;
}
//otherwise check UTC date mapping
else {
date = gf_filter_pck_get_property(pck, GF_PROP_PCK_UTC_TIME);
if (date) {
ctx->last_clock_probe=0;
st->last_utc_ref = date->value.longuint;
st->last_utc_ref_ts = ts;
}
//otherwise interpolate from last mapping
else if (st->last_utc_ref && st->last_utc_ref_ts) {
s64 diff_ms = (s64) ts;
diff_ms -= (s64) st->last_utc_ref_ts;
diff_ms = gf_timestamp_rescale_signed(diff_ms, st->timescale, 1000);
now = st->last_utc_ref;
now += diff_ms;
}
}
if (!now && !st->last_utc_ref) {
if (!ctx->last_clock_probe) ctx->last_clock_probe = gf_sys_clock();
else if (gf_sys_clock() - ctx->last_clock_probe > ctx->utc_probe) {
if (ctx->utc_ref==UTCREF_ANY) {
now = gf_net_get_utc();
ctx->utc_ref = UTCREF_LOCAL;
GF_LOG(GF_LOG_WARNING, GF_LOG_APP, ("[Reframer] Failed to acquire UTC mapping from media, will use local host\n"));
} else {
GF_LOG(GF_LOG_ERROR, GF_LOG_APP, ("[Reframer] Failed to acquire UTC mapping from media, aborting\n"));
ctx->cur_range_idx = ctx->xs.nb_items;
return 2;
}
}
}
//time not yet known, consider we are before
if (!now)
return 0;
} else {
now = gf_net_get_utc();
}
if (now < (u64) ctx->cur_start.num) {
before = GF_TRUE;
u64 time = (ctx->cur_start.num - now) / 1000;
if (!ctx->last_utc_time_s || (ctx->last_utc_time_s-2>time)) {
u32 h, m, s;
char szStatus[100];
ctx->last_utc_time_s = time+2;
h = (u32) (time/3600);
m = (u32) (time/60 - h*60);
s = (u32) (time - m*60 - h*3660);
if (h>24) {
u32 days = h/24;
sprintf(szStatus, "Next range start in %d days", days);
} else {
sprintf(szStatus, "Next range start in %02d:%02d:%02d", h, m, s);
}
if (gf_filter_reporting_enabled(filter)) {
gf_filter_update_status(filter, 0, szStatus);
} else {
GF_LOG(GF_LOG_INFO, GF_LOG_APP, ("[Reframer] %s\r", szStatus));
}
}
} else if (ctx->last_utc_time_s!=1) {
ctx->last_utc_time_s = 1;
if (gf_filter_reporting_enabled(filter)) {
gf_filter_update_status(filter, 0, "");
} else {
GF_LOG(GF_LOG_INFO, GF_LOG_APP, (" \r"));
}
}
if (ctx->cur_end.num) {
u64 end;
if (ctx->cur_end.den)
end = ctx->cur_start.num + (ctx->cur_end.num*1000) / ctx->cur_end.den;
else
end = ctx->cur_end.num;
if (now>end)
after = GF_TRUE;
}
} else {
//check ts not after our range start:
//if round_seek mode, check TS+dur is less than or equal to desired start, and we will notify the duration of data to skip from the packet
//otherwise, check TS is strictly less than desired start
if (st->seek_mode) {
if (gf_timestamp_less_or_equal(ts+dur, st->timescale, ctx->cur_start.num, ctx->cur_start.den)) {
before = GF_TRUE;
if ((st->stream_type==GF_STREAM_AUDIO) && st->ts_sub) {
if (gf_timestamp_greater(ts+st->ts_sub, st->timescale, ctx->cur_start.num, ctx->cur_start.den)) {
before = GF_FALSE;
}
}
}
}
else if (gf_timestamp_less(ts, st->timescale, ctx->cur_start.num, ctx->cur_start.den)) {
before = GF_TRUE;
if (st->abps && gf_timestamp_greater(ts+dur, st->timescale, ctx->cur_start.num, ctx->cur_start.den)) {
u64 nb_samp = gf_timestamp_rescale(ctx->cur_start.num, ctx->cur_start.den, st->timescale) - ts;
if (st->timescale != st->sample_rate) {
nb_samp = gf_timestamp_rescale(nb_samp, st->timescale, st->sample_rate);
}
*nb_audio_samples_to_keep = (u32) nb_samp;
before = GF_FALSE;
}
}
//consider after if time+duration is STRICTLY greater than cut point
if ((ctx->range_type!=RANGE_OPEN) && gf_timestamp_greater(ts+dur, st->timescale, ctx->cur_end.num, ctx->cur_end.den)) {
if ((st->abps || st->seek_mode )
&& gf_timestamp_less(ts, st->timescale, ctx->cur_end.num, ctx->cur_end.den)
) {
u64 nb_samp = gf_timestamp_rescale(ctx->cur_end.num, ctx->cur_end.den, st->timescale) - ts;
if (st->abps && (st->timescale != st->sample_rate)) {
nb_samp = gf_timestamp_rescale(nb_samp, st->timescale, st->sample_rate);
}
*nb_audio_samples_to_keep = (u32)nb_samp;
}
after = GF_TRUE;
}
}
if (before) {
if (!after) {
if (gf_filter_reporting_enabled(filter)) {
char szStatus[1024];
sprintf(szStatus, "wait info=\"packet time "LLU"/%u waiting for range start "LLU"/"LLU"\"", ts, st->timescale, ctx->cur_start.num, ctx->cur_start.den);
gf_filter_update_status(filter, 0, szStatus);
}
return 0;
}
//long duration samples (typically text) can both start before and end after the target range
//fallthrough
}
if (gf_filter_reporting_enabled(filter)) {
gf_filter_update_status(filter, 0, NULL);
}
if (after)
return 2;
return 1;
}
void reframer_purge_queues(GF_ReframerCtx *ctx, u64 ts, u32 timescale)
{
u32 i, count = gf_list_count(ctx->streams);
for (i=0; i<count; i++) {
RTStream *st = gf_list_get(ctx->streams, i);
u64 ts_rescale = ts;
if (st->reinsert_single_pck)
continue;
if (st->timescale != timescale) {
ts_rescale *= st->timescale;
ts_rescale /= timescale;
}
while (1) {
GF_FilterPacket *pck = gf_list_get(st->pck_queue, 0);
if (!pck) break;
u64 dts = gf_filter_pck_get_dts(pck);
if (dts==GF_FILTER_NO_TS)
dts = gf_filter_pck_get_cts(pck);
dts += gf_filter_pck_get_duration(pck);
if (dts >= ts_rescale) break;
gf_list_rem(st->pck_queue, 0);
gf_filter_pck_unref(pck);
st->nb_frames++;
}
}
}
//#define DEBUG_RF_MEM_USAGE
#ifdef DEBUG_RF_MEM_USAGE
static void reframer_dump_mem(GF_ReframerCtx *ctx, char *status)
{
u32 i, count = gf_list_count(ctx->streams);
u32 mem_pck = 0;
u64 mem_size = 0;
u32 mem_saps = 0;
//check all streams have reached min ts
for (i=0; i<count; i++) {
u32 j, nb_pck;
RTStream *st = gf_list_get(ctx->streams, i);
nb_pck = gf_list_count(st->pck_queue);
for (j=0; j<nb_pck; j++) {
u32 size;
GF_FilterPacket *pck = gf_list_get(st->pck_queue, j);
gf_filter_pck_get_data(pck, &size);
mem_size += size;
if (gf_filter_pck_get_sap(pck)) mem_saps++;
mem_pck++;
}
}
fprintf(stderr, "%s, mem state: %d pck "LLU" KB %d saps\n", status, mem_pck, mem_size/1000, mem_saps);
}
#endif
static void check_gop_split(GF_ReframerCtx *ctx)
{
u32 i, count = gf_list_count(ctx->streams);
Bool flush_all = GF_FALSE;
if (!ctx->min_ts_scale) {
u64 min_ts = 0;
u32 min_timescale=0;
u64 min_ts_a = 0;
u32 min_timescale_a=0;
u32 nb_eos = 0;
Bool has_empty_streams = GF_FALSE;
Bool wait_for_sap = GF_FALSE;
Bool size_split = (ctx->extract_mode==EXTRACT_SIZE) ? GF_TRUE : GF_FALSE;
ctx->flush_max_ts = 0;
for (i=0; i<count; i++) {
u32 j, nb_pck, nb_sap;
u64 last_sap_ts=0;
u64 before_last_sap_ts=0;
RTStream *st = gf_list_get(ctx->streams, i);
nb_pck = gf_list_count(st->pck_queue);
nb_sap = 0;
if (st->in_eos) {
nb_eos++;
if (!nb_pck) {
has_empty_streams = GF_TRUE;
continue;
}
}
for (j=0; j<nb_pck; j++) {
u64 ts;
GF_FilterPacket *pck;
//size split, reverse walk the packet list
if (size_split) {
pck = gf_list_get(st->pck_queue, nb_pck - j - 1);
} else {
pck = gf_list_get(st->pck_queue, j);
}
if (!st->is_raw && !gf_filter_pck_get_sap(pck) ) {
continue;
}
ts = gf_filter_pck_get_dts(pck);
if (ts==GF_FILTER_NO_TS)
ts = gf_filter_pck_get_cts(pck);
ts += st->tk_delay;
nb_sap++;
//size split, get the last and before last SAP times
if (size_split) {
if (nb_sap == 1) {
last_sap_ts = ts;
}
else if (nb_sap == 2) {
before_last_sap_ts = ts;
break;
}
}
//regular split, get the second SAP time
else {
if (nb_sap <= 1) {
continue;
}
last_sap_ts = ts;
break;
}
}
//size split, if only one SAP in queue, don't take any decision yet
if (size_split && !before_last_sap_ts)
last_sap_ts = 0;
//in SAP split, flush as soon as we no longer have 2 consecutive saps
if (!last_sap_ts) {
if (st->in_eos && !flush_all && !st->reinsert_single_pck) {
flush_all = GF_TRUE;
} else if (!st->all_saps) {
wait_for_sap = GF_TRUE;
}
}
if (before_last_sap_ts) {
if (!ctx->flush_max_ts || gf_timestamp_less(before_last_sap_ts, st->timescale, ctx->flush_max_ts, ctx->flush_max_ts_scale)) {
ctx->flush_max_ts = before_last_sap_ts;
ctx->flush_max_ts_scale = st->timescale;
}
}
if (st->all_saps) {
if (!min_ts_a || gf_timestamp_less(last_sap_ts, st->timescale, min_ts_a, min_timescale_a) ) {
min_ts_a = last_sap_ts;
min_timescale_a = st->timescale;
}
} else {
if (!min_ts || gf_timestamp_less(last_sap_ts, st->timescale, min_ts, min_timescale) ) {
min_ts = last_sap_ts;
min_timescale = st->timescale;
}
}
}
//in size split, flush as soon as one stream is in eos
if (nb_eos && has_empty_streams) {
flush_all = GF_TRUE;
}
//if flush, get timestamp + dur of last packet in each stream and use this as final end time
if (flush_all) {
for (i=0; i<count; i++) {
u64 ts;
GF_FilterPacket *pck;
RTStream *st = gf_list_get(ctx->streams, i);
if (!st->in_eos)
return;
pck = gf_list_last(st->pck_queue);
if (!pck) continue;
u32 dur = gf_filter_pck_get_duration(pck);
if (!dur) dur=1;
ts = gf_filter_pck_get_dts(pck);
if (ts==GF_FILTER_NO_TS)
ts = gf_filter_pck_get_cts(pck);
ts += st->tk_delay;
ts += dur;
if (!min_ts || gf_timestamp_greater(ts, st->timescale, min_ts, min_timescale) ) {
min_ts = ts;
min_timescale = st->timescale;
}
}
}
ctx->flush_samples = GF_FALSE;
if (!min_ts) {
//video not ready, need more input
if (wait_for_sap)
return;
min_ts = min_ts_a;
min_timescale = min_timescale_a;
}
if (!min_ts) {
//other streams not ready, need more input
if (nb_eos<count)
return;
} else {
ctx->min_ts_scale = min_timescale;
ctx->min_ts_computed = min_ts;
}
}
//check all streams have reached min ts unless we are in final flush
if (!flush_all) {
for (i=0; i<count; i++) {
u64 ts;
GF_FilterPacket *pck;
RTStream *st = gf_list_get(ctx->streams, i);
if (st->range_start_computed==2) continue;
if (st->reinsert_single_pck) continue;
//do not check for timestamp if in EOS, implicitly flush the range
if (st->in_eos) continue;
pck = gf_list_last(st->pck_queue);
if (!pck) continue;
ts = gf_filter_pck_get_dts(pck);
if (ts==GF_FILTER_NO_TS)
ts = gf_filter_pck_get_cts(pck);
ts += st->tk_delay;
if (gf_timestamp_less(ts, st->timescale, ctx->min_ts_computed, ctx->min_ts_scale)) {
return;
}
}
}
//check condition
if (ctx->extract_mode==EXTRACT_SIZE) {
u32 nb_stop_at_min_ts = 0;
u64 cumulated_size = ctx->cumulated_size;
Bool use_prev = GF_FALSE;
u32 nb_eos = 0;
//check all streams have reached min ts
for (i=0; i<count; i++) {
u32 j, nb_pck;
Bool found=GF_FALSE;
RTStream *st = gf_list_get(ctx->streams, i);
nb_pck = gf_list_count(st->pck_queue);
for (j=0; j<nb_pck; j++) {
u64 ts;
u32 size;
GF_FilterPacket *pck = gf_list_get(st->pck_queue, j);
ts = gf_filter_pck_get_dts(pck);
if (ts==GF_FILTER_NO_TS)
ts = gf_filter_pck_get_cts(pck);
ts += st->tk_delay;
if ((ctx->prev_min_ts_computed < ctx->min_ts_computed)
&& gf_timestamp_greater_or_equal(ts, st->timescale, ctx->min_ts_computed, ctx->min_ts_scale)
) {
nb_stop_at_min_ts ++;
found = GF_TRUE;
break;
}
gf_filter_pck_get_data(pck, &size);
cumulated_size += size;
}
if ((j==nb_pck) && st->in_eos && !found) {
nb_eos++;
}
}
if ((nb_stop_at_min_ts + nb_eos) < count) {
ctx->flush_samples = GF_FALSE;
}
//not done yet (estimated size less than target split)
if (
(cumulated_size < ctx->split_size)
&& ctx->min_ts_scale
//do this only if first time we estimate this chunk size, or if previous estimated min_ts is not the same as current min_ts
&& (!ctx->prev_min_ts_computed || (ctx->prev_min_ts_computed < ctx->min_ts_computed))
) {
if ((nb_stop_at_min_ts + nb_eos) == count) {
ctx->est_file_size = cumulated_size;
//flush everything until prev_min_ts_computed
if (ctx->flush_max_ts) {
#ifdef DEBUG_RF_MEM_USAGE
reframer_dump_mem(ctx, "Requesting sample flush");
#endif
ctx->flush_samples = GF_TRUE;
//if first flush, setup streams
if (!ctx->cumulated_size) {
for (i=0; i<count; i++) {
u64 ts;
RTStream *st = gf_list_get(ctx->streams, i);
GF_FilterPacket *pck = gf_list_get(st->pck_queue, 0);
st->range_end_reached_ts = 0;
st->first_pck_sent = GF_FALSE;
if (pck) {
ts = gf_filter_pck_get_dts(pck);
if (ts==GF_FILTER_NO_TS)
ts = gf_filter_pck_get_cts(pck);
ts += st->tk_delay;
st->ts_at_range_start_plus_one = ts + 1;
}
}
}
}
ctx->prev_min_ts_computed = ctx->min_ts_computed;
ctx->prev_min_ts_scale = ctx->min_ts_scale;
ctx->min_ts_computed = 0;
ctx->min_ts_scale = 0;
}
return;
}
if (ctx->min_ts_computed && (ctx->prev_min_ts_computed == ctx->min_ts_computed)) {
//not end of stream, if size still not reached continue
if (!nb_eos) {
if (cumulated_size < ctx->split_size) {
ctx->min_ts_computed = 0;
ctx->min_ts_scale = 0;
return;
}
} else if (nb_eos == count) {
//end of stream, force final flush
ctx->in_range = GF_TRUE;
return;
} else if (ctx->min_ts_computed == ctx->prev_min_ts_computed) {
ctx->in_range = GF_TRUE;
return;
}
}
//decide which split size we use
if (ctx->xround<=REFRAME_ROUND_SEEK) {
use_prev = GF_TRUE;
} else if (ctx->xround==REFRAME_ROUND_AFTER) {
use_prev = GF_FALSE;
} else {
s64 diff_prev = (s64) ctx->split_size;
s64 diff_cur = (s64) ctx->split_size;
diff_prev -= (s64) ctx->est_file_size;
diff_cur -= (s64) cumulated_size;
if (ABS(diff_cur)<ABS(diff_prev))
use_prev = GF_FALSE;
else
use_prev = GF_TRUE;
}
if (!ctx->prev_min_ts_scale)
use_prev = GF_FALSE;
if (use_prev) {
//ctx->est_file_size = ctx->est_file_size;
ctx->min_ts_computed = ctx->prev_min_ts_computed;
ctx->min_ts_scale = ctx->prev_min_ts_scale;
} else {
ctx->est_file_size = cumulated_size;
}
GF_LOG(GF_LOG_INFO, GF_LOG_MEDIA, ("[Reframer] split computed using %s estimation of file size ("LLU")\n", use_prev ? "previous" : "current", ctx->est_file_size));
ctx->prev_min_ts_computed = 0;
ctx->prev_min_ts_scale = 0;
ctx->flush_samples = GF_FALSE;
}
//good to go
ctx->in_range = GF_TRUE;
for (i=0; i<count; i++) {
u64 ts;
RTStream *st = gf_list_get(ctx->streams, i);
GF_FilterPacket *pck = gf_list_get(st->pck_queue, 0);
st->range_end_reached_ts = (ctx->min_ts_computed * st->timescale);
if (ctx->min_ts_scale)
st->range_end_reached_ts /= ctx->min_ts_scale;
st->range_end_reached_ts += 1;
if ((ctx->extract_mode==EXTRACT_SIZE) && ctx->cumulated_size)
continue;
st->first_pck_sent = GF_FALSE;
if (pck) {
ts = gf_filter_pck_get_dts(pck);
if (ts==GF_FILTER_NO_TS)
ts = gf_filter_pck_get_cts(pck);
ts += st->tk_delay;
st->ts_at_range_start_plus_one = ts + 1;
} else {
//this will be a eos signal
st->range_end_reached_ts = 0;
gf_assert((st->range_start_computed==2) || st->in_eos);
}
}
ctx->cur_end.num = ctx->min_ts_computed;
ctx->cur_end.den = ctx->min_ts_scale;
ctx->cumulated_size = 0;
}
GF_Err reframer_process(GF_Filter *filter)
{
GF_ReframerCtx *ctx = gf_filter_get_udta(filter);
u32 i, nb_eos, nb_end_of_range, count = gf_filter_get_ipid_count(filter);
if (ctx->eos_state) {
return (ctx->eos_state==2) ? GF_NOT_SUPPORTED : GF_EOS;
}
if (ctx->rt) {
ctx->reschedule_in = 0;
ctx->clock_val = gf_sys_clock_high_res();
}
/*active range, process as follows:
- if stream is marked as "start reached" or "end reached" do nothing
- queue up packets until we reach start range:
- if packet is in range:
- queue it (ref &nd detach from pid)
- if pck is SAP and first SAP after start and context is not yet marked "in range":
- check if we start from this SAP or from previous SAP (possibly before start) according to xround
- and mark stream as "start ready"
- if stream is video and xadjust is set, prevent all other stream processing
- if packet is out of range
- do NOT enqueue packet
- if stream was not marked as "start ready" (no SAP in active range), use previous SAP before start and mark as active
- mark as end of range reached
- if stream is video and xadjust is set, re-enable all other stream processing
Once all streams are marked as "start ready"
- compute min time at which we will adjust the start range for all streams
- purge all packets before this time
- mark global context as "in range"
The regular (non-range) process is then adjusted as follows:
- if context is "in range" get packet from internal queue
- if no more packets in internal queue, mark stream as "range done"
Once all streams are marked as "range done"
- adjust next_ts of each stream
- mark each stream as not "start ready" and not "range done"
- mark context as not "in range"
- load next range and let the algo loop
*/
if (ctx->range_type && (ctx->range_type!=RANGE_DONE)) {
u32 nb_start_range_reached = 0;
u32 nb_not_playing = 0;
Bool check_split = GF_FALSE;
Bool check_sync = GF_TRUE;
u32 nb_streams_fetched=0;
for (i=0; i<count; i++) {
GF_FilterPid *ipid = gf_filter_get_ipid(filter, i);
RTStream *st = gf_filter_pid_get_udta(ipid);
st->fetch_done = GF_FALSE;
if (ctx->cur_start_valid && ctx->cur_end_valid)
continue;
//try to get the timecode
GF_FilterPacket *pck = gf_filter_pid_get_packet(ipid);
if (!pck)
return GF_OK;
const GF_PropertyValue *p = gf_filter_pck_get_property(pck, GF_PROP_PCK_TIMECODE);
if (!p || !p->value.data.ptr || !p->value.data.size)
continue;
GF_TimeCode *pck_tc = (GF_TimeCode*) p->value.data.ptr;
u64 pck_cts = gf_filter_pck_get_cts(pck);
u32 pck_ts = gf_filter_pck_get_timescale(pck);
//get the pid fps
GF_Fraction fps = {0};
p = gf_filter_pid_get_property(ipid, GF_PROP_PID_FPS);
if (p) fps = p->value.frac;
if (!fps.num || !fps.den) {
fps.num = 25;
fps.den = 1;
}
//signal the epoch time
if (!ctx->cur_start.den) {
u64 epoch_time;
if (ctx->cur_start_tc) {
time_t utc_now = (time_t) (gf_net_get_utc() / 1000);
struct tm *tm = gf_gmtime(&utc_now);
epoch_time = gf_net_get_utc_ts(tm->tm_year + 1900, tm->tm_mon, tm->tm_mday, ctx->cur_start_tc->hours, ctx->cur_start_tc->minutes, ctx->cur_start_tc->seconds);
} else {
// ctx->cur_start.num already has milliseconds since 1970
epoch_time = ctx->cur_start.num;
}
//convert base to 1904
epoch_time /= 1000;
epoch_time += (66*365 + 17) * 24 * 3600;
gf_filter_pid_set_property_str(st->opid, "isom:creation_date", &PROP_LONGUINT(epoch_time));
gf_filter_pid_set_property_str(st->opid, "isom:modification_date", &PROP_LONGUINT(epoch_time));
}
//calculate the correct cts for packet
u64 ts = pck_cts + st->tk_delay;
if (ts > st->ts_sub) ts -= st->ts_sub;
else ts = 0;
//process both start and end timestamps/timecodes
GF_TimeCode *tc_list[2] = {ctx->cur_start_tc, ctx->cur_end_tc};
GF_Fraction64 *ts_list[2] = {&ctx->cur_start, &ctx->cur_end};
Bool *valid_list[2] = {&ctx->cur_start_valid, &ctx->cur_end_valid};
for (int tc_idx = 0; tc_idx < 2; tc_idx++) {
Bool *valid = valid_list[tc_idx];
if (*valid)
continue;
GF_TimeCode *tc = tc_list[tc_idx];
GF_Fraction64 *frac = ts_list[tc_idx];
u64 cur_ts, target_ts;
Bool use_tc_as_utc = (ctx->utc_ref == UTCREF_TC);
if (use_tc_as_utc) {
//convert timecode to UTC: timecode don't contain the day so consider today
time_t utc_now = (time_t) (gf_net_get_utc() / 1000);
struct tm *tm = gf_gmtime(&utc_now);
//use a better 180k accuracy timescale as it allows dealing with high fps.num (up to 60000)
u64 nowIn180k = 180 * gf_net_get_utc_ts(tm->tm_year + 1900, tm->tm_mon, tm->tm_mday, pck_tc->hours, pck_tc->minutes, pck_tc->seconds);
nowIn180k += gf_timestamp_rescale(pck_tc->n_frames * 180000, fps.num, fps.den);
cur_ts = gf_timestamp_rescale(nowIn180k, 180000, pck_ts);
target_ts = gf_timestamp_rescale(ctx->cur_start.num, 1000, pck_ts);
st->last_utc_ref = gf_timestamp_rescale(nowIn180k, 180000, 1000);
st->last_utc_ref_ts = ts;
} else {
tc->max_fps = pck_tc->max_fps;
cur_ts = gf_timecode_to_timestamp(pck_tc, pck_ts);
target_ts = gf_timecode_to_timestamp(tc, pck_ts);
}
// Common logic for both modes
Bool tc_out_of_bounds = use_tc_as_utc ? (target_ts < cur_ts) : gf_timecode_less_or_equal(tc, pck_tc);
if (tc_out_of_bounds) {
// Start from the first frame since timecode is out-of-bounds
frac->num = ts;
frac->den = pck_ts;
if (tc == ctx->cur_start_tc) {
ctx->ts_tc_offset.num = cur_ts - target_ts;
ctx->ts_tc_offset.den = pck_ts;
}
} else {
frac->num = ts + (target_ts - cur_ts);
frac->den = pck_ts;
if (tc == ctx->cur_start_tc) {
ctx->ts_tc_offset.num = 0;
ctx->ts_tc_offset.den = pck_ts;
}
}
*valid = GF_TRUE;
}
}
if (!ctx->cur_start_valid || !ctx->cur_end_valid) {
GF_LOG(GF_LOG_ERROR, GF_LOG_MEDIA, ("[Reframer] No timecode for the first packet in the range, aborting\n"));
gf_filter_abort(filter);
return GF_BAD_PARAM;
}
refetch_streams:
//fetch input packets
for (i=0; i<count; i++) {
u64 ts, check_ts;
u32 nb_audio_samples_to_keep = 0;
u32 pck_in_range, dur;
Bool is_sap;
Bool drop_input = GF_TRUE;
GF_FilterPacket *pck;
GF_FilterPid *ipid = gf_filter_get_ipid(filter, i);
RTStream *st = gf_filter_pid_get_udta(ipid);
if (st->fetch_done) continue;
if (!st->is_playing) {
nb_start_range_reached++;
nb_not_playing++;
st->fetch_done = GF_TRUE;
continue;
}
if (st->range_start_computed && !ctx->wait_video_range_adjust) {
nb_start_range_reached++;
st->fetch_done = GF_TRUE;
continue;
}
//if eos is marked we are flushing so don't check range_end
if (!ctx->has_seen_eos && st->range_end_reached_ts) {
st->fetch_done = GF_TRUE;
continue;
}
if (st->split_pck) {
pck = st->split_pck;
drop_input = GF_FALSE;
} else {
pck = gf_filter_pid_get_packet(ipid);
}
if (!pck) {
if (gf_filter_pid_is_eos(ipid)) {
//special case for PIDs with a single packet, we reinsert them at the beginning of each extracted range
//this allows dealing with BIFS/OD/JPEG/PNG tracks
if (st->reinsert_single_pck) {
if (!ctx->in_range && !st->range_start_computed) {
st->range_start_computed = 3;
if (!gf_list_count(st->pck_queue)) {
pck = st->reinsert_single_pck;
gf_filter_pck_ref(&pck);
gf_list_add(st->pck_queue, pck);
if (!ctx->is_range_extraction) {
check_split = GF_TRUE;
}
}
}
if (st->range_start_computed) {
nb_start_range_reached++;
}
if (!ctx->is_range_extraction) {
if (!st->in_eos && ctx->nb_align_pending) {
ctx->nb_align_pending--;
if (st->cts_us_at_init == ctx->next_cts_align)
ctx->next_cts_align = 0;
}
st->in_eos = GF_TRUE;
}
continue;
}
if (!ctx->is_range_extraction) {
check_split = GF_TRUE;
if (!st->in_eos && ctx->nb_align_pending) {
ctx->nb_align_pending--;
if (st->cts_us_at_init == ctx->next_cts_align)
ctx->next_cts_align = 0;
}
st->in_eos = GF_TRUE;
} else {
st->range_start_computed = 2;
if (ctx->wait_video_range_adjust && ctx->xadjust && st->needs_adjust) {
ctx->wait_video_range_adjust = GF_FALSE;
ctx->flush_max_ts_scale = 0;
}
}
if (st->range_start_computed) {
nb_start_range_reached++;
}
//force flush in case of extract dur to avoid creating file with only a few samples of one track only
if (st->is_playing && (ctx->extract_mode==EXTRACT_DUR)) {
ctx->has_seen_eos = GF_TRUE;
}
}
st->fetch_done = GF_TRUE;
continue;
}
ts = gf_filter_pck_get_dts(pck);
if (ts==GF_FILTER_NO_TS)
ts = gf_filter_pck_get_cts(pck);
ts += st->tk_delay;
if (gf_timestamp_greater(ts, st->timescale, ctx->last_ts, 1000)) {
if (check_sync) {
if (st->range_start_computed) nb_start_range_reached++;
continue;
} else {
ctx->last_ts = gf_timestamp_rescale(ts, st->timescale, 1000);
}
} else {
st->fetch_done = GF_TRUE;
}
st->nb_frames_range++;
if (ctx->xdts) {
check_ts = gf_filter_pck_get_dts(pck);
}
//in range extraction we target the presentation time, use CTS and apply delay
else if (ctx->is_range_extraction) {
check_ts = gf_filter_pck_get_cts(pck) + st->tk_delay;
if (check_ts > st->ts_sub) check_ts -= st->ts_sub;
else check_ts = 0;
} else {
check_ts = ts;
}
//if nosap is set, consider all packet SAPs
if (ctx->nosap || st->is_raw) {
is_sap = GF_TRUE;
} else {
GF_FilterSAPType sap = gf_filter_pck_get_sap(pck);
if ((sap==GF_FILTER_SAP_1) || (sap==GF_FILTER_SAP_2) || (sap==GF_FILTER_SAP_3)) {
is_sap = GF_TRUE;
} else if ((st->stream_type==GF_STREAM_AUDIO) && (sap==GF_FILTER_SAP_4)) {
is_sap = GF_TRUE;
} else {
is_sap = GF_FALSE;
}
}
if (!is_sap) {
if (st->all_saps) {
st->all_saps = GF_FALSE;
ctx->nb_non_saps++;
if (ctx->nb_non_saps>1) {
GF_LOG(GF_LOG_WARNING, GF_LOG_MEDIA, ("[Reframer] %d streams using predictive coding, results may be undefined or broken when aligning SAP, consider remuxing the source\n", ctx->nb_non_saps));
}
if (ctx->xadjust) {
st->needs_adjust = GF_TRUE;
if (st->range_start_computed==1) {
if (ctx->is_range_extraction) {
ctx->wait_video_range_adjust = GF_TRUE;
}
}
}
}
}
//SAP or size split, push packet in queue and ask for gop split check
if (!ctx->is_range_extraction) {
if (gf_filter_pck_is_blocking_ref(pck)) {
GF_LOG(GF_LOG_ERROR, GF_LOG_MEDIA, ("[Reframer] cannot perform size/duration extraction with an input using blocking packet references (PID %s)\n\tCheck filter `%s` settings to allow for data copy\n", gf_filter_pid_get_name(st->ipid), gf_filter_pid_get_source_filter_name(st->ipid) ));
ctx->eos_state = 2;
return GF_NOT_SUPPORTED;
}
//add packet
gf_filter_pck_ref(&pck);
gf_filter_pid_drop_packet(st->ipid);
gf_list_add(st->pck_queue, pck);
check_split = GF_TRUE;
//keep ref to first packet until we see a second one, except if blocking ref
//if blocking ref we assume the source is sending enough packets and we won't reinsert any
if (!gf_filter_pck_is_blocking_ref(pck) && (st->nb_frames_range==1)) {
gf_filter_pck_ref(&pck);
st->reinsert_single_pck = pck;
} else if (st->reinsert_single_pck) {
gf_filter_pck_unref(st->reinsert_single_pck);
st->reinsert_single_pck = NULL;
}
nb_streams_fetched++;
continue;
}
dur = gf_filter_pck_get_duration(pck);
//dur split or range extraction but we wait for video end range to be adjusted, don't enqueue packet
if (ctx->wait_video_range_adjust && !st->needs_adjust) {
if (!ctx->flush_max_ts_scale
|| gf_timestamp_greater_or_equal(ts, st->timescale, ctx->flush_max_ts, ctx->flush_max_ts_scale)
) {
if (st->range_start_computed) nb_start_range_reached++;
continue;
}
}
//check if packet is in our range
pck_in_range = reframer_check_pck_range(filter, ctx, st, pck, check_ts, dur, st->nb_frames_range, &nb_audio_samples_to_keep);
//SAP packet, decide if we cut here or at previous SAP
if (is_sap) {
//if streamtype is video or we have only one pid, purge all packets in all streams before this time
//
//for more complex cases we keep packets because we don't know if we will need SAP packets before the final
//decided start range
if (!pck_in_range && ((count==1) || !st->all_saps) ) {
reframer_purge_queues(ctx, ts, st->timescale);
}
//packet in range and global context not yet in range, mark which SAP will be the beginning of our range
if (!ctx->in_range && (pck_in_range==1)) {
if (!st->range_start_computed) {
u32 ts_adj = nb_audio_samples_to_keep;
if (ts_adj && (st->sample_rate!=st->timescale)) {
ts_adj *= st->timescale;
ts_adj /= st->sample_rate;
}
if (ctx->xround==REFRAME_ROUND_CLOSEST) {
Bool cur_closer = GF_FALSE;
//check which frame is closer
if (ctx->start_frame_idx_plus_one) {
s64 diff_prev = ctx->start_frame_idx_plus_one-1;
s64 diff_cur = ctx->start_frame_idx_plus_one-1;
diff_prev -= st->prev_sap_frame_idx;
diff_cur -= st->nb_frames_range;
if (ABS(diff_cur) < ABS(diff_prev)) cur_closer = GF_TRUE;
} else {
s64 diff_prev, diff_cur;
u64 start_range_ts = gf_timestamp_rescale(ctx->cur_start.num, ctx->cur_start.den, st->timescale);
diff_prev = diff_cur = start_range_ts;
diff_prev -= st->prev_sap_ts;
diff_cur -= ts+ts_adj;
if (ABS(diff_cur) < ABS(diff_prev)) cur_closer = GF_TRUE;
}
if (cur_closer) {
st->sap_ts_plus_one = ts+ts_adj+1;
st->nb_frames_until_start = 0;
} else {
st->sap_ts_plus_one = st->prev_sap_ts + 1;
}
} else if (ctx->xround<=REFRAME_ROUND_SEEK) {
st->sap_ts_plus_one = (ctx->nosap ? ts : st->prev_sap_ts) + 1;
if ((ctx->extract_mode==EXTRACT_RANGE) && !ctx->start_frame_idx_plus_one) {
u64 start_range_ts = gf_timestamp_rescale(ctx->cur_start.num, ctx->cur_start.den, st->timescale);
if (ts + ts_adj == start_range_ts) {
st->sap_ts_plus_one = ts+ts_adj+1;
st->nb_frames_until_start = 0;
}
}
} else {
st->sap_ts_plus_one = ts+ts_adj+1;
st->nb_frames_until_start = 0;
}
st->range_start_computed = 1;
}
nb_start_range_reached++;
}
//remember prev sap time
ctx->flush_max_ts_scale = 0;
if (pck_in_range!=2) {
u64 before_prev_sap_ts = st->prev_sap_ts;
st->prev_sap_ts = ts;
st->prev_sap_frame_idx = st->nb_frames_range;
if (!st->range_start_computed && (ctx->xround==REFRAME_ROUND_SEEK) )
st->nb_frames_until_start = 1;
if (ctx->wait_video_range_adjust && before_prev_sap_ts && !st->all_saps) {
ctx->flush_max_ts = before_prev_sap_ts;
ctx->flush_max_ts_scale = st->timescale;
}
}
//video stream start and xadjust set, prevent all other streams from being processed until we determine the end of the video range
//and re-enable other streams processing
if (!ctx->wait_video_range_adjust && ctx->xadjust && st->needs_adjust && !st->all_saps) {
ctx->wait_video_range_adjust = GF_TRUE;
}
} else if (st->range_start_computed) {
nb_start_range_reached++;
}
if ((ctx->extract_mode==EXTRACT_DUR) && ctx->has_seen_eos && (pck_in_range==2))
pck_in_range = 1;
if (!pck_in_range && st->nb_frames_until_start)
st->nb_frames_until_start++;
//video stream and not adjusting to next SAP:, packet was not sap, probe for P/B reference frame :
//we include this frame in the output but mark it as skip
if (ctx->probe_ref && !ctx->xadjust && (pck_in_range==2) && (st->stream_type==GF_STREAM_VISUAL)) {
if (!st->probe_ref_frame_ts) {
pck_in_range = 1;
st->probe_ref_frame_ts = ts+1;
} else {
ts = st->probe_ref_frame_ts - 1;
st->probe_ref_frame_ts = 0;
}
}
//after range: whether SAP or not, mark end of range reached
if (pck_in_range==2) {
if (!ctx->xadjust || is_sap) {
Bool enqueue = GF_FALSE;
st->split_end = 0;
if (!st->range_start_computed) {
st->sap_ts_plus_one = st->prev_sap_ts + 1;
st->range_start_computed = 1;
nb_start_range_reached++;
//for UTC case, if range is empty discard everything
if (!ctx->cur_start.den) {
reframer_reset_stream(ctx, st, GF_FALSE);
} else if (st->prev_sap_ts == ts) {
enqueue = GF_TRUE;
}
}
//remember the timestamp of first packet after range
st->range_end_reached_ts = ts + 1;
//time-based extraction or dur split, try to clone packet
if (st->can_split && !ctx->start_frame_idx_plus_one) {
if (gf_timestamp_less(ts, st->timescale, ctx->cur_end.num, ctx->cur_end.den)) {
//force enqueuing this packet
enqueue = GF_TRUE;
st->split_end = (u32) ( (ctx->cur_end.num * st->timescale) / ctx->cur_end.den - ts);
st->range_end_reached_ts += st->split_end;
//and remember it for next chunk - note that we dequeue the input to get proper eos notification
gf_filter_pck_ref(&pck);
st->split_pck = pck;
}
}
else if (nb_audio_samples_to_keep && !ctx->start_frame_idx_plus_one) {
enqueue = GF_TRUE;
gf_filter_pck_ref(&pck);
st->split_pck = pck;
st->audio_samples_to_keep = nb_audio_samples_to_keep;
}
//video stream end detected and xadjust set, adjust cur_end to match the video stream end range
//and re-enable other streams processing
if (ctx->wait_video_range_adjust && ctx->xadjust && st->needs_adjust) {
ctx->cur_end.num = st->range_end_reached_ts-1;
ctx->cur_end.den = st->timescale;
ctx->wait_video_range_adjust = GF_FALSE;
ctx->flush_max_ts_scale = 0;
}
//do NOT enqueue packet
if (!enqueue)
break;
}
}
nb_streams_fetched++;
//add packet unless blocking ref
if (gf_filter_pck_is_blocking_ref(pck) && !pck_in_range) {
st->use_blocking_refs = GF_TRUE;
if (drop_input)
gf_filter_pid_drop_packet(st->ipid);
continue;
}
gf_filter_pck_ref(&pck);
gf_list_add(st->pck_queue, pck);
if (drop_input) {
gf_filter_pid_drop_packet(st->ipid);
//keep ref to first packet until we see a second one, except if blocking ref
//if blocking ref we assume the source is sending enough packets and we won't reinsert any
if (!gf_filter_pck_is_blocking_ref(pck) && (st->nb_frames_range==1)) {
gf_filter_pck_ref(&pck);
st->reinsert_single_pck = pck;
} else if (st->reinsert_single_pck) {
gf_filter_pck_unref(st->reinsert_single_pck);
st->reinsert_single_pck = NULL;
}
} else {
gf_assert(pck == st->split_pck);
gf_filter_pck_unref(st->split_pck);
st->split_pck = NULL;
}
}
if (check_sync && !nb_streams_fetched && (!nb_start_range_reached || (nb_start_range_reached<count))) {
check_sync = GF_FALSE;
nb_start_range_reached=0;
goto refetch_streams;
}
if (check_split) {
check_gop_split(ctx);
}
//all streams reached the start range, compute min ts
if (!ctx->in_range
&& (nb_start_range_reached==count)
&& (nb_not_playing<count)
&& ctx->is_range_extraction
) {
u64 min_ts = 0;
u32 min_timescale=0;
u64 min_ts_a = 0;
u32 min_timescale_a=0;
u64 min_ts_split = 0;
u32 min_timescale_split=0;
Bool purge_all = GF_FALSE;
for (i=0; i<count; i++) {
GF_FilterPid *ipid = gf_filter_get_ipid(filter, i);
RTStream *st = gf_filter_pid_get_udta(ipid);
if (!st->is_playing) continue;
gf_assert(st->range_start_computed || st->in_eos);
//eos and no packets queued
if (!gf_list_count(st->pck_queue) && (st->range_start_computed==2)) {
continue;
}
//packet will be reinserted at cut time, do not check its timestamp
if (st->range_start_computed==3)
continue;
if (st->can_split) {
if (!min_ts_split || gf_timestamp_less(st->sap_ts_plus_one-1, st->timescale, min_ts_split, min_timescale_split) ) {
min_ts_split = st->sap_ts_plus_one;
min_timescale_split = st->timescale;
}
}
else if (st->all_saps) {
if (!min_ts_a || gf_timestamp_less(st->sap_ts_plus_one-1, st->timescale, min_ts_a, min_timescale_a) ) {
min_ts_a = st->sap_ts_plus_one;
min_timescale_a = st->timescale;
}
} else {
if (!min_ts || gf_timestamp_less(st->sap_ts_plus_one-1, st->timescale, min_ts, min_timescale) ) {
min_ts = st->sap_ts_plus_one;
min_timescale = st->timescale;
}
}
}
if (!min_ts) {
min_ts = min_ts_a;
min_timescale = min_timescale_a;
if (!min_ts && min_ts_split) {
if (ctx->start_frame_idx_plus_one) {
min_ts = min_ts_split;
min_timescale = min_timescale_split;
} else {
min_ts = ctx->cur_start.num+1;
min_timescale = (u32) ctx->cur_start.den;
}
}
}
if (!min_ts) {
purge_all = GF_TRUE;
if (ctx->extract_mode==EXTRACT_RANGE) {
if (ctx->cur_start_tc) {
char tcBuf[100];
GF_LOG(GF_LOG_WARNING, GF_LOG_MEDIA, ("[Reframer] All streams in end of stream for desired start range %s\n", gf_format_timecode(ctx->cur_start_tc, tcBuf)));
} else {
GF_LOG(GF_LOG_WARNING, GF_LOG_MEDIA, ("[Reframer] All streams in end of stream for desired start range "LLD"/"LLU"\n", ctx->cur_start.num, ctx->cur_start.den));
}
}
ctx->eos_state = 1;
} else {
min_ts -= 1;
if (ctx->cur_start.den && (ctx->extract_mode==EXTRACT_RANGE) && (ctx->xround!=REFRAME_ROUND_SEEK)) {
ctx->cur_start.num = min_ts;
ctx->cur_start.den = min_timescale;
}
}
//purge everything before min ts
for (i=0; i<count; i++) {
Bool start_found = GF_FALSE;
GF_FilterPid *ipid = gf_filter_get_ipid(filter, i);
RTStream *st = gf_filter_pid_get_udta(ipid);
if (!st->is_playing) continue;
while (gf_list_count(st->pck_queue)) {
GF_FilterPacket *pck = gf_list_get(st->pck_queue, 0);
if (!purge_all) {
u32 is_start = 0;
u64 ts, ots, check_ts;
u64 dur, odur;
Bool check_priming = GF_FALSE;
ts = gf_filter_pck_get_dts(pck);
if (ts==GF_FILTER_NO_TS)
ts = gf_filter_pck_get_cts(pck);
ts += st->tk_delay;
odur = dur = (u64) gf_filter_pck_get_duration(pck);
if (!dur) dur=1;
check_ts = ots = ts;
if (st->seek_mode && (st->stream_type==GF_STREAM_AUDIO) && st->ts_sub) {
check_priming = GF_TRUE;
check_ts += st->ts_sub;
}
if (min_timescale != st->timescale) {
ts = gf_timestamp_rescale(ts, st->timescale, min_timescale);
if (check_priming) {
check_ts = gf_timestamp_rescale(check_ts, st->timescale, min_timescale);
}
dur = gf_timestamp_rescale(dur, st->timescale, min_timescale);
}
if (ts >= min_ts) {
is_start = 1;
}
else if (st->can_split && (ts+dur > min_ts)) {
is_start = 2;
}
else if (check_priming && (check_ts >= min_ts)) {
is_start = 1;
}
else if ((st->abps || st->seek_mode) && (ts+dur >= min_ts) && (st->stream_type==GF_STREAM_AUDIO)) {
u64 diff;
diff = gf_timestamp_rescale(min_ts, min_timescale, st->timescale);
diff -= ots;
if (st->abps) {
if (st->sample_rate != st->timescale) {
diff = gf_timestamp_rescale(diff, st->timescale, st->sample_rate);
}
}
if (diff < odur) {
st->audio_samples_to_keep = (u32) diff;
is_start = 1;
}
}
else if (st->range_start_computed==3) {
is_start = 1;
}
if (is_start) {
//remember TS at range start
s64 orig = min_ts;
if (st->timescale != min_timescale) {
orig = gf_timestamp_rescale(orig, min_timescale, st->timescale);
}
st->split_start = 0;
if (is_start==2) {
st->split_start = (u32) (min_ts - ts);
if (min_timescale != st->timescale) {
st->split_start = (u32) gf_timestamp_rescale(st->split_start, min_timescale, st->timescale);
}
}
st->ts_at_range_start_plus_one = ots + 1;
if ((st->range_start_computed==1)
&& (orig < (s64) ots)
&& ctx->splitrange
&& (ctx->cur_range_idx>1)
) {
s64 delay = (s64) ots - (s64) orig;
gf_filter_pid_set_property(st->opid, GF_PROP_PID_DELAY, &PROP_LONGSINT(delay) );
}
start_found = GF_TRUE;
break;
}
}
gf_list_rem(st->pck_queue, 0);
gf_filter_pck_unref(pck);
st->nb_frames++;
}
//we couldn't find a sample with dts >= to our min_ts - this happens when the min_ts
//is located a few seconds AFTER the target split point
//so force stream to reevaluate and enqueue more packets
if (ctx->cur_start.den && !start_found && !st->use_blocking_refs) {
st->range_start_computed = 0;
return GF_OK;
}
}
//OK every stream has now packets starting at the min_ts, ready to go
const GF_PropertyValue *chap_times=NULL, *chap_names=NULL;
ctx->nb_video_frames_since_start = 0;
for (i=0; i<count; i++) {
GF_FilterPid *ipid = gf_filter_get_ipid(filter, i);
RTStream *st = gf_filter_pid_get_udta(ipid);
//reset start range computed
st->range_start_computed = 0;
if (ctx->extract_mode==EXTRACT_DUR) {
st->first_pck_sent = GF_FALSE;
} else {
st->first_pck_sent = ctx->splitrange ? GF_FALSE : GF_TRUE;
}
if (purge_all && (ctx->extract_mode!=EXTRACT_RANGE)) {
gf_filter_pid_get_packet(st->ipid);
gf_filter_pid_set_eos(st->opid);
}
if ((st->stream_type==GF_STREAM_VISUAL) && (st->nb_frames > ctx->nb_video_frames_since_start)) {
ctx->nb_video_frames_since_start = st->nb_frames;
if (st->nb_frames_until_start) {
ctx->nb_video_frames_since_start += st->nb_frames_until_start-1;
st->nb_frames_until_start = 0;
}
}
if (!chap_times && ctx->cur_start.den) {
chap_times = gf_filter_pid_get_property(st->ipid, GF_PROP_PID_CHAP_TIMES);
chap_names = gf_filter_pid_get_property(st->ipid, GF_PROP_PID_CHAP_NAMES);
if (!chap_times || !chap_names || (chap_times->value.uint_list.nb_items!=chap_names->value.string_list.nb_items))
chap_times = chap_names = NULL;
}
}
ctx->nb_video_frames_since_start_at_range_start = ctx->nb_video_frames_since_start;
if (purge_all) {
if (ctx->extract_mode!=EXTRACT_RANGE)
return GF_EOS;
goto load_next_range;
}
//we are in the range
ctx->in_range = GF_TRUE;
#ifdef DEBUG_RF_MEM_USAGE
reframer_dump_mem(ctx, "Starting new range");
#endif
if (chap_times) {
GF_PropertyValue ch;
GF_PropUIntList new_times;
GF_PropStringList new_names;
u32 first_chap_idx=0, last_chap_idx=chap_times->value.uint_list.nb_items;
u32 cut_time = (u32) gf_timestamp_rescale(min_ts, min_timescale, 1000);
u32 out_time = 0;
if (ctx->range_type == RANGE_CLOSED) {
out_time = (u32) gf_timestamp_rescale(ctx->cur_end.num, ctx->cur_end.den, 1000);
}
for (i=0; i<chap_times->value.uint_list.nb_items; i++) {
if (chap_times->value.uint_list.vals[i] <= cut_time)
first_chap_idx = i;
if (!out_time) continue;
if (chap_times->value.uint_list.vals[i] == out_time)
break;
if (chap_times->value.uint_list.vals[i] > out_time) {
last_chap_idx = i+1;
break;
}
}
new_times.nb_items = last_chap_idx - first_chap_idx;
new_times.vals = gf_malloc(sizeof(u32)*new_times.nb_items);
new_names.nb_items = new_times.nb_items;
new_names.vals = gf_malloc(sizeof(char *)*new_names.nb_items);
u32 k=0;
for (i=first_chap_idx; i<last_chap_idx; i++) {
s64 time = chap_times->value.uint_list.vals[i];
time -= cut_time;
if (time<0) time = 0;
new_times.vals[k] = (u32) time;
new_names.vals[k] = gf_strdup(chap_names->value.string_list.vals[i]);
k++;
}
//set chapter properties
for (i=0; i<count; i++) {
GF_FilterPid *ipid = gf_filter_get_ipid(filter, i);
RTStream *st = gf_filter_pid_get_udta(ipid);
ch.type = GF_PROP_UINT_LIST;
ch.value.uint_list = new_times;
gf_filter_pid_set_property(st->opid, GF_PROP_PID_CHAP_TIMES, &ch);
ch.type = GF_PROP_STRING_LIST_COPY;
ch.value.string_list = new_names;
gf_filter_pid_set_property(st->opid, GF_PROP_PID_CHAP_NAMES, &ch);
}
gf_free(new_times.vals);
ch.type = GF_PROP_STRING_LIST;
ch.value.string_list = new_names;
gf_props_reset_single(&ch);
}
}
if (!ctx->in_range && !ctx->flush_samples)
return GF_OK;
}
#ifdef DEBUG_RF_MEM_USAGE
reframer_dump_mem(ctx, "Processing range");
#endif
nb_eos = 0;
nb_end_of_range = 0;
for (i=0; i<count; i++) {
GF_FilterPid *ipid = gf_filter_get_ipid(filter, i);
RTStream *st = gf_filter_pid_get_udta(ipid);
while (1) {
Bool forward = GF_TRUE;
Bool pck_is_ref = GF_FALSE;
GF_FilterPacket *pck;
//dequeue packet
if (ctx->range_type && (ctx->range_type!=RANGE_DONE) ) {
pck = gf_list_get(st->pck_queue, 0);
pck_is_ref = GF_TRUE;
if (pck && !ctx->is_range_extraction && st->range_end_reached_ts) {
u64 ts;
ts = gf_filter_pck_get_dts(pck);
if (ts==GF_FILTER_NO_TS)
ts = gf_filter_pck_get_cts(pck);
ts += st->tk_delay;
if (ts>= st->range_end_reached_ts-1) {
nb_end_of_range++;
break;
}
}
} else {
pck = gf_filter_pid_get_packet(ipid);
}
if (!pck) {
if (st->range_end_reached_ts) {
nb_end_of_range++;
break;
}
if (!st->is_playing) {
nb_eos++;
} else {
//force a eos check if this was a split pid
if (st->can_split)
gf_filter_pid_get_packet(st->ipid);
if (gf_filter_pid_is_eos(ipid)) {
gf_filter_pid_set_eos(st->opid);
if (!st->in_eos && ctx->nb_align_pending) {
ctx->nb_align_pending--;
if (st->cts_us_at_init == ctx->next_cts_align)
ctx->next_cts_align = 0;
st->in_eos = GF_TRUE;
}
nb_eos++;
}
}
break;
}
//size split, flushing
if (ctx->flush_samples) {
u32 size;
u64 cts;
cts = gf_filter_pck_get_dts(pck);
if (cts==GF_FILTER_NO_TS)
cts = gf_filter_pck_get_cts(pck);
cts += st->tk_delay;
if (gf_timestamp_greater_or_equal(cts, st->timescale, ctx->flush_max_ts, ctx->flush_max_ts_scale)) {
break;
}
gf_filter_pck_get_data(pck, &size);
ctx->cumulated_size += size;
} else {
//if not doing range extraction, avoid dispatching too fast (in range extraction we control pid timing)
if (!ctx->range_type && gf_filter_pid_would_block(st->opid))
break;
}
if (ctx->refs) {
u8 deps = gf_filter_pck_get_dependency_flags(pck);
deps >>= 2;
deps &= 0x3;
//not used as reference, don't forward
if (deps==2)
forward = GF_FALSE;
}
if (ctx->saps.nb_items) {
u32 sap = gf_filter_pck_get_sap(pck);
switch (sap) {
case GF_FILTER_SAP_1:
if (!ctx->filter_sap1) forward = GF_FALSE;
break;
case GF_FILTER_SAP_2:
if (!ctx->filter_sap2) forward = GF_FALSE;
break;
case GF_FILTER_SAP_3:
if (!ctx->filter_sap3) forward = GF_FALSE;
break;
case GF_FILTER_SAP_4:
case GF_FILTER_SAP_4_PROL:
if (!ctx->filter_sap4) forward = GF_FALSE;
break;
default:
if (!ctx->filter_sap_none) forward = GF_FALSE;
break;
}
}
if (ctx->cues) {
forward = GF_FALSE;
const GF_PropertyValue *p = gf_filter_pck_get_property(pck, GF_PROP_PCK_CUE_START);
if (p && p->value.boolean) forward = GF_TRUE;
else if (ctx->cues==2) {
p = gf_filter_pck_get_property(pck, GF_PROP_PCK_FRAG_START);
if (p) forward = GF_TRUE;
}
}
if (ctx->range_type==RANGE_DONE)
forward = GF_FALSE;
if (!forward) {
reframer_drop_packet(ctx, st, pck, pck_is_ref);
st->nb_frames++;
continue;
}
if (! reframer_send_packet(filter, ctx, st, pck, pck_is_ref))
break;
}
}
//end of range
if (nb_end_of_range + nb_eos == count) {
load_next_range:
nb_end_of_range = 0;
nb_eos=0;
for (i=0; i<count; i++) {
GF_FilterPid *ipid = gf_filter_get_ipid(filter, i);
RTStream *st = gf_filter_pid_get_udta(ipid);
//we reinsert the same PCK, so the ts_at_range_start_plus is always the packet cts
//we therefore need to compute the ts at and as the target end time minus the target start time
if (st->reinsert_single_pck && ctx->cur_start.den) {
u64 start = gf_timestamp_rescale(ctx->cur_start.num, ctx->cur_start.den, st->timescale);
//closed range, compute TS at range end
if (ctx->cur_end.num && ctx->cur_end.den) {
st->ts_at_range_end = gf_timestamp_rescale(ctx->cur_end.num, ctx->cur_end.den, st->timescale);
st->ts_at_range_end -= start;
}
} else {
st->ts_at_range_end += (st->range_end_reached_ts - 1) - (st->ts_at_range_start_plus_one - 1);
}
st->ts_at_range_start_plus_one = 0;
st->range_end_reached_ts = 0;
st->range_start_computed = 0;
if (st->in_eos) {
if (gf_list_count(st->pck_queue)) {
nb_end_of_range++;
} else {
gf_filter_pid_set_eos(st->opid);
nb_eos++;
}
} else if (st->split_pck) {
nb_end_of_range++;
}
}
//and load next range
ctx->in_range = GF_FALSE;
reframer_load_range(ctx);
if (nb_end_of_range)
gf_filter_post_process_task(filter);
}
if (nb_eos==count) return GF_EOS;
if (ctx->rt) {
//while technically correct this increases the CPU load by shuffling the task around and querying gf_sys_clock_high_res too often
//needs more investigation
//using a simple callback every RT_PRECISION_US is a good workaround
#if 0
u32 rsus = 0;
if (ctx->reschedule_in > RT_PRECISION_US) {
rsus = (u32) (ctx->reschedule_in - RT_PRECISION_US);
if (rsus<RT_PRECISION_US) rsus = RT_PRECISION_US;
} else if (ctx->reschedule_in>1000) {
rsus = (u32) (ctx->reschedule_in / 2);
}
if (rsus) {
gf_filter_ask_rt_reschedule(filter, rsus);
}
#else
if (ctx->reschedule_in) {
gf_filter_ask_rt_reschedule(filter, RT_PRECISION_US);
}
#endif
}
return GF_OK;
}
static const GF_FilterCapability ReframerCaps_RAW_AV[] =
{
//raw audio and video only
CAP_UINT(GF_CAPS_INPUT_OUTPUT, GF_PROP_PID_STREAM_TYPE, GF_STREAM_AUDIO),
CAP_UINT(GF_CAPS_INPUT_OUTPUT, GF_PROP_PID_STREAM_TYPE, GF_STREAM_VISUAL),
CAP_UINT(GF_CAPS_INPUT_OUTPUT, GF_PROP_PID_CODECID, GF_CODECID_RAW),
{0},
//no restriction for media other than audio and video - cf regular caps for comments
CAP_UINT(GF_CAPS_IN_OUT_EXCLUDED, GF_PROP_PID_STREAM_TYPE, GF_STREAM_AUDIO),
CAP_UINT(GF_CAPS_IN_OUT_EXCLUDED, GF_PROP_PID_STREAM_TYPE, GF_STREAM_VISUAL),
CAP_UINT(GF_CAPS_IN_OUT_EXCLUDED, GF_PROP_PID_STREAM_TYPE, GF_STREAM_ENCRYPTED),
CAP_UINT(GF_CAPS_IN_OUT_EXCLUDED, GF_PROP_PID_STREAM_TYPE, GF_STREAM_FILE),
CAP_BOOL(GF_CAPS_INPUT_EXCLUDED, GF_PROP_PID_UNFRAMED, GF_TRUE),
CAP_UINT(GF_CAPS_OUTPUT_EXCLUDED, GF_PROP_PID_CODECID, GF_CODECID_RAW),
CAP_UINT(GF_CAPS_OUTPUT_LOADED_FILTER, GF_PROP_PID_CODECID, GF_CODECID_RAW)
};
static const GF_FilterCapability ReframerCaps_RAW_A[] =
{
//raw audio only
CAP_UINT(GF_CAPS_INPUT_OUTPUT, GF_PROP_PID_STREAM_TYPE, GF_STREAM_AUDIO),
CAP_UINT(GF_CAPS_INPUT_OUTPUT, GF_PROP_PID_CODECID, GF_CODECID_RAW),
{0},
//no restriction for media other than audio - cf regular caps for comments
CAP_UINT(GF_CAPS_IN_OUT_EXCLUDED, GF_PROP_PID_STREAM_TYPE, GF_STREAM_AUDIO),
CAP_UINT(GF_CAPS_IN_OUT_EXCLUDED, GF_PROP_PID_STREAM_TYPE, GF_STREAM_ENCRYPTED),
CAP_UINT(GF_CAPS_IN_OUT_EXCLUDED, GF_PROP_PID_STREAM_TYPE, GF_STREAM_FILE),
CAP_BOOL(GF_CAPS_INPUT_EXCLUDED, GF_PROP_PID_UNFRAMED, GF_TRUE),
CAP_UINT(GF_CAPS_OUTPUT_EXCLUDED, GF_PROP_PID_CODECID, GF_CODECID_RAW),
CAP_UINT(GF_CAPS_OUTPUT_LOADED_FILTER, GF_PROP_PID_CODECID, GF_CODECID_RAW)
};
static const GF_FilterCapability ReframerCaps_RAW_V[] =
{
//raw video only
CAP_UINT(GF_CAPS_INPUT_OUTPUT, GF_PROP_PID_STREAM_TYPE, GF_STREAM_VISUAL),
CAP_UINT(GF_CAPS_INPUT_OUTPUT, GF_PROP_PID_CODECID, GF_CODECID_RAW),
{0},
//no restriction for media other than video - cf regular caps for comments
CAP_UINT(GF_CAPS_IN_OUT_EXCLUDED, GF_PROP_PID_STREAM_TYPE, GF_STREAM_VISUAL),
CAP_UINT(GF_CAPS_IN_OUT_EXCLUDED, GF_PROP_PID_STREAM_TYPE, GF_STREAM_ENCRYPTED),
CAP_UINT(GF_CAPS_IN_OUT_EXCLUDED, GF_PROP_PID_STREAM_TYPE, GF_STREAM_FILE),
CAP_BOOL(GF_CAPS_INPUT_EXCLUDED, GF_PROP_PID_UNFRAMED, GF_TRUE),
CAP_UINT(GF_CAPS_OUTPUT_EXCLUDED, GF_PROP_PID_CODECID, GF_CODECID_RAW),
CAP_UINT(GF_CAPS_OUTPUT_LOADED_FILTER, GF_PROP_PID_CODECID, GF_CODECID_RAW)
};
static GF_Err reframer_initialize(GF_Filter *filter)
{
GF_Err e;
GF_ReframerCtx *ctx = gf_filter_get_udta(filter);
ctx->streams = gf_list_new();
ctx->seekable = GF_TRUE;
if ((ctx->xs.nb_items>1) && (ctx->xround==REFRAME_ROUND_SEEK)) {
GF_LOG(GF_LOG_ERROR, GF_LOG_MEDIA, ("[Reframer] `xround=seek` can only be used for single range extraction\n"));
return GF_BAD_PARAM;
}
if (ctx->speed != 0)
ctx->rt_speed = ctx->speed;
if ((ctx->xs.nb_items==0) && (ctx->xe.nb_items)) {
if (ctx->xe.nb_items==1) {
ctx->xs.nb_items = 1;
ctx->xs.vals = gf_malloc(sizeof(char *));
ctx->xs.vals[0] = gf_strdup("0");
} else {
GF_LOG(GF_LOG_ERROR, GF_LOG_MEDIA, ("[Reframer] Multiple `xe` set but no `xs`, cannot extract range\n"));
return GF_BAD_PARAM;
}
}
reframer_load_range(ctx);
if (ctx->utc_ref==UTCREF_TC) {
GF_LOG(GF_LOG_INFO, GF_LOG_MEDIA, ("[Reframer] using timecodes: the considered day for comparisons will be today /!\\\n"));
//we use timecodes, load SEI
ctx->load_sei = GF_TRUE;
}
switch (ctx->raw) {
case RAW_AV:
e = gf_filter_override_caps(filter, ReframerCaps_RAW_AV, GF_ARRAY_LENGTH(ReframerCaps_RAW_AV));
break;
case RAW_VIDEO:
e = gf_filter_override_caps(filter, ReframerCaps_RAW_V, GF_ARRAY_LENGTH(ReframerCaps_RAW_V));
break;
case RAW_AUDIO:
e = gf_filter_override_caps(filter, ReframerCaps_RAW_A, GF_ARRAY_LENGTH(ReframerCaps_RAW_A));
break;
default:
e = GF_OK;
}
return e;
}
static Bool reframer_process_event(GF_Filter *filter, const GF_FilterEvent *evt)
{
GF_ReframerCtx *ctx = gf_filter_get_udta(filter);
GF_FilterEvent fevt;
RTStream *st;
if (!evt->base.on_pid) return GF_FALSE;
st = gf_filter_pid_get_udta(evt->base.on_pid);
if (!st) return GF_TRUE;
//if we have a PID, we always cancel the event and forward the same event to the associated input pid
fevt = *evt;
fevt.base.on_pid = st->ipid;
//if range extraction based on time, adjust start range
if (evt->base.type==GF_FEVT_PLAY) {
if (ctx->range_type && !ctx->start_frame_idx_plus_one && ctx->cur_start.den) {
Double start_range = (Double) ctx->cur_start.num;
start_range /= ctx->cur_start.den;
//rewind safety offset
if (start_range > ctx->seeksafe)
start_range -= ctx->seeksafe;
else
start_range = 0.0;
fevt.play.start_range = start_range;
}
st->in_eos = GF_FALSE;
st->is_playing = GF_TRUE;
if (ctx->eos_state==1)
ctx->eos_state = 0;
if (ctx->speed==0)
ctx->rt_speed = evt->play.speed;
} else if (evt->base.type==GF_FEVT_STOP) {
st->is_playing = GF_FALSE;
st->cts_us_at_init = 0;
st->sys_clock_at_init = 0;
} else if (evt->base.type==GF_FEVT_RESUME) {
st->cts_us_at_init = 0;
st->sys_clock_at_init = 0;
} else if (evt->base.type==GF_FEVT_SET_SPEED) {
st->cts_us_at_init = 0;
st->sys_clock_at_init = 0;
if (ctx->speed==0)
ctx->rt_speed = evt->play.speed;
} else if (evt->base.type==GF_FEVT_TRANSPORT_HINTS) {
if (evt->transport_hints.wait_seg_boundary) {
//this applies to all streams
u32 ipid_count = gf_filter_get_ipid_count(filter);
for (u32 i=0; i<ipid_count; i++) {
GF_FilterPid *ipid = gf_filter_get_ipid(filter, i);
RTStream *ist = gf_filter_pid_get_udta(ipid);
if (ist && ist->wait_seg_boundary==WAIT_SEG_BOUNDARY_NONE) {
ist->wait_seg_boundary = WAIT_SEG_BOUNDARY_ACTIVE;
ist->segdur = evt->transport_hints.seg_duration;
}
}
}
}
gf_filter_pid_send_event(st->ipid, &fevt);
return GF_TRUE;
}
static void reframer_finalize(GF_Filter *filter)
{
GF_ReframerCtx *ctx = gf_filter_get_udta(filter);
while (gf_list_count(ctx->streams)) {
RTStream *st = gf_list_pop_back(ctx->streams);
reframer_reset_stream(ctx, st, GF_TRUE);
}
gf_list_del(ctx->streams);
if (ctx->cur_start_tc)
gf_free(ctx->cur_start_tc);
if (ctx->cur_end_tc)
gf_free(ctx->cur_end_tc);
}
static GF_Err reframer_update_arg(GF_Filter *filter, const char *arg_name, const GF_PropertyValue *new_val)
{
//for real-time control, reset clock
if (!strcmp(arg_name, "rt") || !strcmp(arg_name, "speed")) {
GF_ReframerCtx *ctx = gf_filter_get_udta(filter);
u32 i, count = gf_list_count(ctx->streams);
for (i=0;i<count;i++) {
RTStream *st = gf_list_get(ctx->streams, i);
st->cts_us_at_init = 0;
st->sys_clock_at_init = 0;
}
}
return GF_OK;
}
static const GF_FilterCapability ReframerCaps[] =
{
CAP_UINT(GF_CAPS_INPUT_EXCLUDED, GF_PROP_PID_STREAM_TYPE, GF_STREAM_FILE),
//we do accept everything, including raw streams
CAP_UINT(GF_CAPS_INPUT_EXCLUDED, GF_PROP_PID_CODECID, GF_CODECID_NONE),
CAP_BOOL(GF_CAPS_INPUT_EXCLUDED, GF_PROP_PID_UNFRAMED, GF_TRUE),
//we don't accept files as input so don't output them
CAP_UINT(GF_CAPS_OUTPUT_EXCLUDED, GF_PROP_PID_STREAM_TYPE, GF_STREAM_FILE),
//we don't produce RAW streams during dynamic chain resolution - this will avoid loading the filter for compositor/other raw access
CAP_UINT(GF_CAPS_OUTPUT_EXCLUDED, GF_PROP_PID_CODECID, GF_CODECID_RAW),
//but we may produce raw streams when filter is explicitly loaded (media exporter)
CAP_UINT(GF_CAPS_OUTPUT_LOADED_FILTER|GF_CAPFLAG_OPTIONAL, GF_PROP_PID_CODECID, GF_CODECID_RAW)
};
#define OFFS(_n) #_n, offsetof(GF_ReframerCtx, _n)
static const GF_FilterArgs ReframerArgs[] =
{
{ OFFS(exporter), "compatibility with old exporter, displays export results", GF_PROP_BOOL, "false", NULL, GF_FS_ARG_HINT_ADVANCED},
{ OFFS(rt), "real-time regulation mode of input\n"
"- off: disable real-time regulation\n"
"- on: enable real-time regulation, one clock per PID\n"
"- sync: enable real-time regulation, one clock for all PIDs\n"
"- align: send packets in DTS order following one clock for all PIDs (undo input packet bursts), no real-time regulation", GF_PROP_UINT, "off", "off|on|sync|align", GF_FS_ARG_HINT_NORMAL|GF_FS_ARG_UPDATE},
{ OFFS(saps), "list of SAP types (0,1,2,3,4) to forward, other packets are dropped (forwarding only sap 0 will break the decoding)", GF_PROP_UINT_LIST, NULL, "0|1|2|3|4", GF_FS_ARG_HINT_NORMAL|GF_FS_ARG_UPDATE},
{ OFFS(refs), "forward only frames used as reference frames, if indicated in the input stream", GF_PROP_BOOL, "false", NULL, GF_FS_ARG_HINT_NORMAL|GF_FS_ARG_UPDATE},
{ OFFS(speed), "speed for real-time regulation mode, a value of 0 uses speed from play commands", GF_PROP_DOUBLE, "0.0", NULL, GF_FS_ARG_HINT_ADVANCED|GF_FS_ARG_UPDATE},
{ OFFS(raw), "force input AV streams to be in raw format\n"
"- no: do not force decoding of inputs\n"
"- av: force decoding of audio and video inputs\n"
"- a: force decoding of audio inputs\n"
"- v: force decoding of video inputs", GF_PROP_UINT, "no", "av|a|v|no", GF_FS_ARG_HINT_NORMAL},
{ OFFS(frames), "drop all except listed frames (first being 1). A negative value `-V` keeps only first frame every `V` frames", GF_PROP_SINT_LIST, NULL, NULL, GF_FS_ARG_HINT_ADVANCED|GF_FS_ARG_UPDATE},
{ OFFS(xs), "extraction start time(s). If not set and an extraction end time is set, 0 is used", GF_PROP_STRING_LIST, NULL, NULL, GF_FS_ARG_HINT_NORMAL},
{ OFFS(xe), "extraction end time(s). If less values than start times, the last time interval extracted is an open range", GF_PROP_STRING_LIST, NULL, NULL, GF_FS_ARG_HINT_NORMAL},
{ OFFS(xround), "adjust start time of extraction range to I-frame\n"
"- before: use first I-frame preceding or matching range start\n"
"- seek: see filter help\n"
"- after: use first I-frame (if any) following or matching range start\n"
"- closest: use I-frame closest to range start", GF_PROP_UINT, "before", "before|seek|after|closest", GF_FS_ARG_HINT_ADVANCED},
{ OFFS(xadjust), "adjust end time of extraction range to be before next I-frame", GF_PROP_BOOL, "false", NULL, GF_FS_ARG_HINT_EXPERT},
{ OFFS(xots), "keep original timestamps after extraction", GF_PROP_BOOL, "false", NULL, GF_FS_ARG_HINT_EXPERT},
{ OFFS(xdts), "compute start times based on DTS and not CTS", GF_PROP_BOOL, "false", NULL, GF_FS_ARG_HINT_EXPERT},
{ OFFS(nosap), "do not cut at SAP when extracting range (may result in broken streams)", GF_PROP_BOOL, "false", NULL, GF_FS_ARG_HINT_EXPERT},
{ OFFS(splitrange), "signal file boundary at each extraction first packet for template-base file generation", GF_PROP_BOOL, "false", NULL, GF_FS_ARG_HINT_EXPERT},
{ OFFS(seeksafe), "rewind play requests by given seconds (to make sure the I-frame preceding start is catched)", GF_PROP_DOUBLE, "10.0", NULL, GF_FS_ARG_HINT_EXPERT},
{ OFFS(tcmdrw), "rewrite TCMD samples when splitting", GF_PROP_BOOL, "true", NULL, GF_FS_ARG_HINT_EXPERT},
{ OFFS(props), "extra output PID properties per extraction range", GF_PROP_STRING_LIST, NULL, NULL, GF_FS_ARG_HINT_EXPERT},
{ OFFS(no_audio_seek), "disable seek mode on audio streams (no change of priming duration)", GF_PROP_BOOL, "false", NULL, GF_FS_ARG_HINT_EXPERT},
{ OFFS(probe_ref), "allow extracted range to be longer in case of B-frames with reference frames presented outside of range", GF_PROP_BOOL, "false", NULL, GF_FS_ARG_HINT_EXPERT},
{ OFFS(utc_ref), "set reference mode for UTC range extraction\n"
"- local: use UTC of local host\n"
"- any: use UTC of media, or UTC of local host if not found in media after probing time\n"
"- media: use UTC of media (abort if none found)\n"
"- tc: use timecode of media (be careful: considered day will be today)", GF_PROP_UINT, "any", "local|any|media|tc", GF_FS_ARG_HINT_ADVANCED},
{ OFFS(utc_probe), "timeout in milliseconds to try to acquire UTC reference from media", GF_PROP_UINT, "5000", NULL, GF_FS_ARG_HINT_EXPERT},
{ OFFS(copy), "try copying frame interface into packets", GF_PROP_BOOL, "false", NULL, GF_FS_ARG_HINT_EXPERT|GF_FS_ARG_UPDATE},
{ OFFS(cues), "cue filtering mode\n"
"- no: do no filter frames based on cue info\n"
"- segs: only forward frames marked as segment start\n"
"- frags: only forward frames marked as fragment start", GF_PROP_UINT, "no", "no|segs|frags", GF_FS_ARG_HINT_EXPERT|GF_FS_ARG_UPDATE},
{ OFFS(sapcue), "treat SAPs smaller than or equal to this value as cue points", GF_PROP_UINT, "0", NULL, GF_FS_ARG_HINT_EXPERT },
{ OFFS(rmseek), "remove seek flag of all sent packets", GF_PROP_BOOL, "false", NULL, GF_FS_ARG_HINT_EXPERT|GF_FS_ARG_UPDATE},
{ OFFS(chkdisc), "discontinuity detection in milliseconds - see filter help", GF_PROP_FRACTION, "0/1", NULL, GF_FS_ARG_HINT_EXPERT|GF_FS_ARG_UPDATE},
{0}
};
GF_FilterRegister ReframerRegister = {
.name = "reframer",
GF_FS_SET_DESCRIPTION("Media reframer")
GF_FS_SET_HELP("This filter provides various tools on inputs:\n"
"- ensure reframing (1 packet = 1 Access Unit)\n"
"- optionally force decoding\n"
"- real-time regulation\n"
"- packet filtering based on SAP types or frame numbers\n"
"- time-range extraction and splitting\n"
" \n"
"This filter forces input PIDs to be properly framed (1 packet = 1 Access Unit).\n"
"It is typically needed to force remultiplexing in file to file operations when source and destination files use the same format.\n"
" \n"
"# SAP filtering\n"
"The filter can remove packets based on their SAP types using [-saps]() option.\n"
"For example, this can be used to extract only the key frame (SAP 1,2,3) of a video to create a trick mode version.\n"
" \n"
"# Frame filtering\n"
"This filter can keep only specific Access Units of the source using [-frames]() option.\n"
"For example, this can be used to extract only specific key pictures of a video to create a HEIF collection.\n"
" \n"
"# Frame decoding\n"
"This filter can force input media streams to be decoded using the [-raw]() option.\n"
"EX gpac -i m.mp4 reframer:raw=av [dst]\n"
"# Real-time Regulation\n"
"The filter can perform real-time regulation of input packets, based on their timescale and timestamps.\n"
"For example to simulate a live DASH:\n"
"EX gpac -i m.mp4 reframer:rt=on -o live.mpd:dynamic\n"
" \n"
"# Range extraction\n"
"The filter can perform time range extraction of the source using [-xs]() and [-xe]() options.\n"
"The formats allowed for times specifiers are:\n"
"- 'TC'HH:MM:SS:FF: specify time in timecode\n"
"- 'T'H:M:S, 'T'M:S: specify time in hours, minutes, seconds\n"
"- 'T'H:M:S.MS, 'T'M:S.MS, 'T'S.MS: specify time in hours, minutes, seconds and milliseconds\n"
"- INT, FLOAT, NUM/DEN: specify time in seconds (number or fraction)\n"
"- 'D'INT, 'D'FLOAT, 'D'NUM/DEN: specify end time as offset to start time in seconds (number or fraction) - only valid for [-xe]()\n"
"- 'F'NUM: specify time as frame number, 1 being first\n"
"- XML DateTime: specify absolute UTC time\n"
" \n"
"In this mode, the timestamps are rewritten to form a continuous timeline, unless [-xots]() is set.\n"
"When multiple ranges are given, the filter will try to seek if needed and supported by source.\n"
"\n"
"EX gpac -i m.mp4 reframer:xs=T00:00:10,T00:01:10,T00:02:00:xe=T00:00:20,T00:01:20 [dst]\n"
"This will extract the time ranges [10s,20s], [1m10s,1m20s] and all media starting from 2m\n"
"\n"
"If no end range is found for a given start range:\n"
"- if a following start range is set, the end range is set to this next start\n"
"- otherwise, the end range is open\n"
"\n"
"EX gpac -i m.mp4 reframer:xs=0,10,25:xe=5,20 [dst]\n"
"This will extract the time ranges [0s,5s], [10s,20s] and all media starting from 25s\n"
"EX gpac -i m.mp4 reframer:xs=0,10,25 [dst]\n"
"This will extract the time ranges [0s,10s], [10s,25s] and all media starting from 25s\n"
"\n"
"It is possible to signal range boundaries in output packets using [-splitrange]().\n"
"This will expose on the first packet of each range in each PID the following properties:\n"
"- `FileNumber`: starting at 1 for the first range, to be used as replacement for $num$ in templates\n"
"- `FileSuffix`: corresponding to `StartRange_EndRange` or `StartRange` for open ranges, to be used as replacement for $FS$ in templates\n"
"\n"
"EX gpac -i m.mp4 reframer:xs=T00:00:10,T00:01:10:xe=T00:00:20:splitrange -o dump_$FS$.264 [dst]\n"
"This will create two output files dump_T00.00.10_T00.02.00.264 and dump_T00.01.10.264.\n"
"Note: The `:` and `/` characters are replaced by `.` in `FileSuffix` property.\n"
"\n"
"It is possible to modify PID properties per range using [-props](). Each set of property must be specified using the active separator set.\n"
"Warning: The option must be escaped using double separators in order to be parsed properly.\n"
"EX gpac -i m.mp4 reframer:xs=0,30::props=#Period=P1,#Period=P2:#foo=bar [dst]\n"
"This will assign to output PIDs\n"
"- during the range [0,30]: property `Period` to `P1`\n"
"- during the range [30, end]: properties `Period` to `P2` and property `foo` to `bar`\n"
"\n"
"For uncompressed audio PIDs, input frame will be split to closest audio sample number.\n"
"\n"
"When [-xround]() is set to `seek`, the following applies:\n"
"- a single range shall be specified\n"
"- the first I-frame preceding or matching the range start is used as split point\n"
"- all packets before range start are marked as seek points\n"
"- packets overlapping range start are forwarded with a `SkipBegin` property set to the amount of media to skip\n"
"- packets overlapping range end are forwarded with an adjusted duration to match the range end\n"
"This mode is typically used to extract a range in a frame/sample accurate way, rather than a GOP-aligned way.\n"
"\n"
"When [-xround]() is not set to `seek`, compressed audio streams will still use seek mode.\n"
"Consequently, these streams will have modified edit lists in ISOBMFF which might not be properly handled by players.\n"
"This can be avoided using [-no_audio_seek](), but this will introduce audio delay.\n"
"\n"
"# UTC-based range extraction\n"
"The filter can perform range extraction based on UTC time rather than media time. In this mode, the end time must be:\n"
"- a UTC date: range extraction will stop after this date\n"
"- a time in second: range extraction will stop after the specified duration\n"
"\n"
"The UTC reference is specified using [-utc_ref]().\n"
"If UTC signal from media source is used, the filter will probe for [-utc_probe]() before considering the source has no UTC signal.\n"
"\n"
"The properties `SenderNTP` and, if absent, `UTC` of source packets are checked for establishing the UTC reference.\n"
"# Other split actions\n"
"The filter can perform splitting of the source using [-xs]() option.\n"
"The additional formats allowed for [-xs]() option are:\n"
"- `SAP`: split source at each SAP/RAP\n"
"- `D`VAL: split source by chunks of `VAL` seconds\n"
"- `D`NUM/DEN: split source by chunks of `NUM/DEN` seconds\n"
"- `S`VAL: split source by chunks of estimated size `VAL` bytes (can use property multipliers, e.g. `m`)\n"
"\n"
"Note: In these modes, [-splitrange]() and [-xadjust]() are implicitly set.\n"
"\n"
"# Handling stream discontinuities\n"
"Discontinuities may happen quite often in streaming sessions due to resolution switching, codec change, etc ...\n"
"While GPAC handles these discontinuities internally, it may be desired to ignore them, for example when a source is known to have no discontinuity but GPAC detects some due to network errors or other changing properties that should be ignored.\n"
"A negative value for [-chkdisc]() option allows removing all discontinuities once a stream is setup.\n"
"Warning: Make sure you know what you are doing as using this option could make the stream not playable (ignoring a codec config change).\n"
"EX gpac -i SOMEURL reframer:chkdisc=-1 -o DASH_ORIGIN\n"
"In this example, the dasher filter will never trigger a period switch due to input stream discontinuity.\n"
"\n"
"A value of 0 for [-chkdisc]() option does not change the behaviour of the filter.\n"
"\n"
"A positive value for [-chkdisc]() option will check timestamp continuity in input stream.\n"
"A Discontinuity is triggered when:\n"
"- current packet decoding is strictly less than previous packet deocding time\n"
"- current packet decoding is strictly more than previous packet deocding time plus [-chkdisc]()\n"
"\n"
"When triggered, the PID property `Discontinuity` is updated, allowing next filters to decide what to do.\n"
)
.private_size = sizeof(GF_ReframerCtx),
.max_extra_pids = (u32) -1,
.args = ReframerArgs,
//reframer is explicit only, so we don't load the reframer during resolution process
.flags = GF_FS_REG_EXPLICIT_ONLY|GF_FS_REG_ALLOW_CYCLIC|GF_FS_REG_TEMP_INIT,
SETCAPS(ReframerCaps),
.initialize = reframer_initialize,
.finalize = reframer_finalize,
.configure_pid = reframer_configure_pid,
.process = reframer_process,
.process_event = reframer_process_event,
.update_arg = reframer_update_arg,
.hint_class_type = GF_FS_CLASS_STREAM
};
const GF_FilterRegister *reframer_register(GF_FilterSession *session)
{
return &ReframerRegister;
}
#else
const GF_FilterRegister *reframer_register(GF_FilterSession *session)
{
return NULL;
}
#endif //GPAC_DISABLE_REFRAMER