FFmpeg: libavutil/timecode.c Source File

FFmpeg

[フレーム]

libavutil

timecode.c

Go to the documentation of this file.

1 /*

4 *

5 * This file is part of FFmpeg.

6 *

7 * FFmpeg is free software; you can redistribute it and/or

8 * modify it under the terms of the GNU Lesser General Public

9 * License as published by the Free Software Foundation; either

10 * version 2.1 of the License, or (at your option) any later version.

11 *

12 * FFmpeg is distributed in the hope that it will be useful,

13 * but WITHOUT ANY WARRANTY; without even the implied warranty of

14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU

15 * Lesser General Public License for more details.

16 *

17 * You should have received a copy of the GNU Lesser General Public

18 * License along with FFmpeg; if not, write to the Free Software

19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA

20 */

22 /**

23 * @file

24 * Timecode helpers

25 * @see https://en.wikipedia.org/wiki/SMPTE_time_code

26 * @see http://www.dropframetimecode.org

27 */

29 #include <stdio.h>

30 #include "common.h"

31 #include "timecode.h"

32 #include "timecode_internal.h"

33 #include "log.h"

34 #include "error.h"

36 int av_timecode_adjust_ntsc_framenum2(int framenum, int fps)

37 {

38 /* only works for multiples of NTSC 29.97 */

39 int drop_frames = 0;

40 int d, m, frames_per_10mins;

42 if (fps && fps % 30 == 0) {

43 drop_frames = fps / 30 * 2;

44 frames_per_10mins = fps / 30 * 17982;

45 } else

46 return framenum;

48 d = framenum / frames_per_10mins;

49 m = framenum % frames_per_10mins;

51 return framenum + 9U * drop_frames * d + drop_frames * ((m - drop_frames) / (frames_per_10mins / 10));

52 }

54 uint32_t av_timecode_get_smpte_from_framenum(const AVTimecode *tc, int framenum)

55 {

56 unsigned fps = tc->fps;

57 int drop = !!(tc->flags & AV_TIMECODE_FLAG_DROPFRAME);

58 int hh, mm, ss, ff;

60 framenum += tc->start;

61 if (drop)

62 framenum = av_timecode_adjust_ntsc_framenum2(framenum, tc->fps);

63 ff = framenum % fps;

64 ss = framenum / fps % 60;

65 mm = framenum / (fps*60LL) % 60;

66 hh = framenum / (fps*3600LL) % 24;

67 return av_timecode_get_smpte(tc->rate, drop, hh, mm, ss, ff);

68 }

70 uint32_t av_timecode_get_smpte(AVRational rate, int drop, int hh, int mm, int ss, int ff)

71 {

72 uint32_t tc = 0;

74 /* For SMPTE 12-M timecodes, frame count is a special case if > 30 FPS.

75 See SMPTE ST 12-1:2014 Sec 12.1 for more info. */

76 if (av_cmp_q(rate, (AVRational) {30, 1}) == 1) {

77 if (ff % 2 == 1) {

78 if (av_cmp_q(rate, (AVRational) {50, 1}) == 0)

79 tc |= (1 << 7);

80 else

81 tc |= (1 << 23);

82 }

83 ff /= 2;

84 }

86 hh = hh % 24;

87 mm = av_clip(mm, 0, 59);

88 ss = av_clip(ss, 0, 59);

89 ff = ff % 40;

91 tc |= drop << 30;

92 tc |= (ff / 10) << 28;

93 tc |= (ff % 10) << 24;

94 tc |= (ss / 10) << 20;

95 tc |= (ss % 10) << 16;

96 tc |= (mm / 10) << 12;

97 tc |= (mm % 10) << 8;

98 tc |= (hh / 10) << 4;

99 tc |= (hh % 10);

100

101 return tc;

102 }

103

104 char *av_timecode_make_string(const AVTimecode *tc, char *buf, int framenum_arg)

105 {

106 unsigned fps = tc->fps;

107 int drop = tc->flags & AV_TIMECODE_FLAG_DROPFRAME;

108 int hh, mm, ss, ff, ff_len, neg = 0;

109 int64_t framenum = framenum_arg;

110

111 framenum += tc->start;

112 if (drop)

113 framenum = av_timecode_adjust_ntsc_framenum2(framenum, fps);

114 if (framenum < 0) {

115 framenum = -framenum;

116 neg = tc->flags & AV_TIMECODE_FLAG_ALLOWNEGATIVE;

117 }

118 ff = framenum % fps;

119 ss = framenum / fps % 60;

120 mm = framenum / (fps*60LL) % 60;

121 hh = framenum / (fps*3600LL);

122 if (tc->flags & AV_TIMECODE_FLAG_24HOURSMAX)

123 hh = hh % 24;

124 ff_len = fps > 10000 ? 5 : fps > 1000 ? 4 : fps > 100 ? 3 : fps > 10 ? 2 : 1;

125 snprintf(buf, AV_TIMECODE_STR_SIZE, "%s%02d:%02d:%02d%c%0*d",

126 neg ? "-" : "",

127 hh, mm, ss, drop ? ';' : ':', ff_len, ff);

128 return buf;

129 }

130

131 char *av_timecode_make_smpte_tc_string2(char *buf, AVRational rate, uint32_t tcsmpte, int prevent_df, int skip_field)

132 {

133 unsigned hh, mm, ss, ff, drop;

134 ff_timecode_set_smpte(&drop, &hh, &mm, &ss, &ff, rate, tcsmpte, prevent_df, skip_field);

135

136 snprintf(buf, AV_TIMECODE_STR_SIZE, "%02u:%02u:%02u%c%02u",

137 hh, mm, ss, drop ? ';' : ':', ff);

138 return buf;

139

140 }

141

142 char *av_timecode_make_smpte_tc_string(char *buf, uint32_t tcsmpte, int prevent_df)

143 {

144 return av_timecode_make_smpte_tc_string2(buf, (AVRational){30, 1}, tcsmpte, prevent_df, 1);

145 }

146

147 char *av_timecode_make_mpeg_tc_string(char *buf, uint32_t tc25bit)

148 {

149 snprintf(buf, AV_TIMECODE_STR_SIZE,

150 "%02"PRIu32":%02"PRIu32":%02"PRIu32"%c%02"PRIu32,

151 tc25bit>>19 & 0x1f, // 5-bit hours

152 tc25bit>>13 & 0x3f, // 6-bit minutes

153 tc25bit>>6 & 0x3f, // 6-bit seconds

154 tc25bit & 1<<24 ? ';' : ':', // 1-bit drop flag

155 tc25bit & 0x3f); // 6-bit frames

156 return buf;

157 }

158

159 static int check_fps(int fps)

160 {

161 int i;

162 static const int supported_fps[] = {

163 24, 25, 30, 48, 50, 60, 100, 120, 150,

164 };

165

166 for (i = 0; i < FF_ARRAY_ELEMS(supported_fps); i++)

167 if (fps == supported_fps[i])

168 return 0;

169 return -1;

170 }

171

172 static int check_timecode(void *log_ctx, AVTimecode *tc)

173 {

174 if ((int)tc->fps <= 0) {

175 av_log(log_ctx, AV_LOG_ERROR, "Valid timecode frame rate must be specified. Minimum value is 1\n");

176 return AVERROR(EINVAL);

177 }

178 if ((tc->flags & AV_TIMECODE_FLAG_DROPFRAME) && tc->fps % 30 != 0) {

179 av_log(log_ctx, AV_LOG_ERROR, "Drop frame is only allowed with multiples of 30000/1001 FPS\n");

180 return AVERROR(EINVAL);

181 }

182 if (check_fps(tc->fps) < 0) {

183 av_log(log_ctx, AV_LOG_WARNING, "Using non-standard frame rate %d/%d\n",

184 tc->rate.num, tc->rate.den);

185 }

186 return 0;

187 }

188

189 static int fps_from_frame_rate(AVRational rate)

190 {

191 if (!rate.den || !rate.num)

192 return -1;

193 return (rate.num + rate.den/2LL) / rate.den;

194 }

195

196 int av_timecode_check_frame_rate(AVRational rate)

197 {

198 return check_fps(fps_from_frame_rate(rate));

199 }

200

201 int av_timecode_init(AVTimecode *tc, AVRational rate, int flags, int frame_start, void *log_ctx)

202 {

203 memset(tc, 0, sizeof(*tc));

204 tc->start = frame_start;

205 tc->flags = flags;

206 tc->rate = rate;

207 tc->fps = fps_from_frame_rate(rate);

208 return check_timecode(log_ctx, tc);

209 }

210

211 int av_timecode_init_from_components(AVTimecode *tc, AVRational rate, int flags, int hh, int mm, int ss, int ff, void *log_ctx)

212 {

213 int ret;

214

215 memset(tc, 0, sizeof(*tc));

216 tc->flags = flags;

217 tc->rate = rate;

218 tc->fps = fps_from_frame_rate(rate);

219

220 ret = check_timecode(log_ctx, tc);

221 if (ret < 0)

222 return ret;

223

224 tc->start = (hh*3600 + mm*60 + ss) * tc->fps + ff;

225 if (tc->flags & AV_TIMECODE_FLAG_DROPFRAME) { /* adjust frame number */

226 int tmins = 60*hh + mm;

227 tc->start -= (tc->fps / 30 * 2) * (tmins - tmins/10);

228 }

229 return 0;

230 }

231

232 int av_timecode_init_from_string(AVTimecode *tc, AVRational rate, const char *str, void *log_ctx)

233 {

234 char c;

235 int hh, mm, ss, ff, flags;

236

237 if (sscanf(str, "%d:%d:%d%c%d", &hh, &mm, &ss, &c, &ff) != 5) {

238 av_log(log_ctx, AV_LOG_ERROR, "Unable to parse timecode, "

239 "syntax: hh:mm:ss[:;.]ff\n");

240 return AVERROR_INVALIDDATA;

241 }

242 flags = c != ':' ? AV_TIMECODE_FLAG_DROPFRAME : 0; // drop if ';', '.', ...

243

244 return av_timecode_init_from_components(tc, rate, flags, hh, mm, ss, ff, log_ctx);

245 }

flags

const SwsFlags flags[]

Definition: swscale.c:61

AV_LOG_WARNING

#define AV_LOG_WARNING

Something somehow does not look correct.

Definition: log.h:216

AV_TIMECODE_STR_SIZE

#define AV_TIMECODE_STR_SIZE

Definition: timecode.h:33

av_clip

#define av_clip

Definition: common.h:100

av_timecode_check_frame_rate

int av_timecode_check_frame_rate(AVRational rate)

Check if the timecode feature is available for the given frame rate.

Definition: timecode.c:196

AVERROR

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

av_timecode_make_smpte_tc_string

char * av_timecode_make_smpte_tc_string(char *buf, uint32_t tcsmpte, int prevent_df)

Get the timecode string from the SMPTE timecode format.

Definition: timecode.c:142

frame_start

static void frame_start(MPVMainEncContext *const m)

Definition: mpegvideo_enc.c:1924

timecode_internal.h

int64_t

long long int64_t

Definition: coverity.c:34

AVTimecode::flags

uint32_t flags

flags such as drop frame, +24 hours support, ...

Definition: timecode.h:43

av_timecode_get_smpte

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.

Definition: timecode.c:70

ff_timecode_set_smpte

void ff_timecode_set_smpte(unsigned *drop, unsigned *hh, unsigned *mm, unsigned *ss, unsigned *ff, AVRational rate, uint32_t tcsmpte, int prevent_df, int skip_field)

Convert SMPTE 12M binary representation to sei info.

Definition: timecode_internal.c:33

timecode.h

AVTimecode::start

int start

timecode frame start (first base frame number)

Definition: timecode.h:42

#define ss(width, name, subs,...)

Definition: cbs_vp9.c:202

AVRational::num

int num

Numerator.

Definition: rational.h:59

check_timecode

static int check_timecode(void *log_ctx, AVTimecode *tc)

Definition: timecode.c:172

AV_LOG_ERROR

#define AV_LOG_ERROR

Something went wrong and cannot losslessly be recovered.

Definition: log.h:210

FF_ARRAY_ELEMS

#define FF_ARRAY_ELEMS(a)

Definition: sinewin_tablegen.c:29

av_timecode_init

int av_timecode_init(AVTimecode *tc, AVRational rate, int flags, int frame_start, void *log_ctx)

Init a timecode struct with the passed parameters.

Definition: timecode.c:201

av_timecode_adjust_ntsc_framenum2

int av_timecode_adjust_ntsc_framenum2(int framenum, int fps)

Adjust frame number for NTSC drop frame time code.

Definition: timecode.c:36

if(ret)

Definition: filter_design.txt:179

AVRational

Rational number (pair of numerator and denominator).

Definition: rational.h:58

AVTimecode::fps

unsigned fps

frame per second; must be consistent with the rate field

Definition: timecode.h:45

AVTimecode::rate

AVRational rate

frame rate in rational form

Definition: timecode.h:44

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

Definition: undefined.txt:32

error.h

av_timecode_init_from_components

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.

Definition: timecode.c:211

AV_TIMECODE_FLAG_24HOURSMAX

@ AV_TIMECODE_FLAG_24HOURSMAX

timecode wraps after 24 hours

Definition: timecode.h:37

av_timecode_get_smpte_from_framenum

uint32_t av_timecode_get_smpte_from_framenum(const AVTimecode *tc, int framenum)