38 int d, m, frames_per_10mins;
40 if (fps && fps % 30 == 0) {
41 drop_frames = fps / 30 * 2;
42 frames_per_10mins = fps / 30 * 17982;
46 d = framenum / frames_per_10mins;
47 m = framenum % frames_per_10mins;
49 return framenum + 9
U * drop_frames * d + drop_frames * ((m - drop_frames) / (frames_per_10mins / 10));
54 unsigned fps = tc->
fps;
58 framenum += tc->
start;
62 ss = framenum / fps % 60;
63 mm = framenum / (fps*60) % 60;
64 hh = framenum / (fps*3600) % 24;
85 mm = av_clip(mm, 0, 59);
86 ss = av_clip(ss, 0, 59);
90 tc |= (ff / 10) << 28;
91 tc |= (ff % 10) << 24;
92 tc |= (ss / 10) << 20;
93 tc |= (ss % 10) << 16;
94 tc |= (mm / 10) << 12;
106 int hh, mm,
ss, ff, neg = 0;
108 framenum += tc->
start;
112 framenum = -framenum;
116 ss = framenum / fps % 60;
117 mm = framenum / (fps*60) % 60;
118 hh = framenum / (fps*3600);
123 hh, mm, ss, drop ?
';' :
':', ff);
129 unsigned low = bcd & 0xf;
130 unsigned high = bcd >> 4;
131 if (low > 9 || high > 9)
133 return low + 10*high;
138 unsigned hh =
bcd2uint(tcsmpte & 0x3f);
139 unsigned mm =
bcd2uint(tcsmpte>>8 & 0x7f);
141 unsigned ff =
bcd2uint(tcsmpte>>24 & 0x3f);
142 unsigned drop = tcsmpte & 1<<30 && !prevent_df;
148 ff += !!(tcsmpte & 1 << 7);
150 ff += !!(tcsmpte & 1 << 23);
155 hh, mm, ss, drop ?
';' :
':', ff);
168 "%02"PRIu32
":%02"PRIu32
":%02"PRIu32
"%c%02"PRIu32,
172 tc25bit & 1<<24 ?
';' :
':',
180 static const int supported_fps[] = {
181 24, 25, 30, 48, 50, 60, 100, 120, 150,
185 if (fps == supported_fps[i])
192 if ((
int)tc->
fps <= 0) {
193 av_log(log_ctx,
AV_LOG_ERROR,
"Valid timecode frame rate must be specified. Minimum value is 1\n");
197 av_log(log_ctx,
AV_LOG_ERROR,
"Drop frame is only allowed with multiples of 30000/1001 FPS\n");
209 if (!rate.
den || !rate.
num)
211 return (rate.
num + rate.
den/2) / rate.
den;
221 memset(tc, 0,
sizeof(*tc));
233 memset(tc, 0,
sizeof(*tc));
242 tc->
start = (hh*3600 + mm*60 +
ss) * tc->
fps + ff;
244 int tmins = 60*hh + mm;
245 tc->
start -= (tc->
fps / 30 * 2) * (tmins - tmins/10);
255 if (sscanf(str,
"%02u:%02u:%02u%c%02u", &hh, &mm, &ss, &c, &ff) != 5) {
257 "syntax: hh:mm:ss[:;.]ff\n");
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
#define AV_LOG_WARNING
Something somehow does not look correct.
char * av_timecode_make_mpeg_tc_string(char *buf, uint32_t tc25bit)
Get the timecode string from the 25-bit timecode format (MPEG GOP format).
static int check_timecode(void *log_ctx, AVTimecode *tc)
int av_timecode_init_from_string(AVTimecode *tc, AVRational rate, const char *str, void *log_ctx)
Parse timecode representation (hh:mm:ss[:;.
static unsigned bcd2uint(uint8_t bcd)
Undefined Behavior In the C some operations are like signed integer dereferencing freed accessing outside allocated Undefined Behavior must not occur in a C it is not safe even if the output of undefined operations is unused The unsafety may seem nit picking but Optimizing compilers have in fact optimized code on the assumption that no undefined Behavior occurs Optimizing code based on wrong assumptions can and has in some cases lead to effects beyond the output of computations The signed integer overflow problem in speed critical code Code which is highly optimized and works with signed integers sometimes has the problem that often the output of the computation does not c
int start
timecode frame start (first base frame number)
int av_timecode_init(AVTimecode *tc, AVRational rate, int flags, int frame_start, void *log_ctx)
Init a timecode struct with the passed parameters.
static int check_fps(int fps)
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
unsigned fps
frame per second; must be consistent with the rate field
#define ss(width, name, subs,...)
char * av_timecode_make_smpte_tc_string2(char *buf, AVRational rate, uint32_t tcsmpte, int prevent_df, int skip_field)
Get the timecode string from the SMPTE timecode format.
#define FF_ARRAY_ELEMS(a)
int av_timecode_adjust_ntsc_framenum2(int framenum, int fps)
Adjust frame number for NTSC drop frame time code.
timecode wraps after 24 hours
AVRational rate
frame rate in rational form
static int frame_start(MpegEncContext *s)
Rational number (pair of numerator and denominator).
char * av_timecode_make_smpte_tc_string(char *buf, uint32_t tcsmpte, int prevent_df)
Get the timecode string from the SMPTE timecode format.
#define flags(name, subs,...)
static int fps_from_frame_rate(AVRational rate)
char * av_timecode_make_string(const AVTimecode *tc, char *buf, int framenum)
Load timecode string in buf.
static int av_cmp_q(AVRational a, AVRational b)
Compare two rationals.
negative time values are allowed
int av_timecode_init_from_components(AVTimecode *tc, AVRational rate, int flags, int hh, int mm, int ss, int ff, void *log_ctx)
Init a timecode struct from the passed timecode components.
int av_timecode_check_frame_rate(AVRational rate)
Check if the timecode feature is available for the given frame rate.
uint32_t av_timecode_get_smpte(AVRational rate, int drop, int hh, int mm, int ss, int ff)
Convert sei info to SMPTE 12M binary representation.
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later.That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another.Frame references ownership and permissions
uint32_t flags
flags such as drop frame, +24 hours support, ...
#define AV_TIMECODE_STR_SIZE
uint32_t av_timecode_get_smpte_from_framenum(const AVTimecode *tc, int framenum)
Convert frame number to SMPTE 12M binary representation.