1 |
|
|
/* |
2 |
|
|
* Copyright (c) 2013 Nicolas George |
3 |
|
|
* |
4 |
|
|
* This file is part of FFmpeg. |
5 |
|
|
* |
6 |
|
|
* FFmpeg is free software; you can redistribute it and/or |
7 |
|
|
* modify it under the terms of the GNU Lesser General Public License |
8 |
|
|
* as published by the Free Software Foundation; either |
9 |
|
|
* version 2.1 of the License, or (at your option) any later version. |
10 |
|
|
* |
11 |
|
|
* FFmpeg is distributed in the hope that it will be useful, |
12 |
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of |
13 |
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
14 |
|
|
* GNU Lesser General Public License for more details. |
15 |
|
|
* |
16 |
|
|
* You should have received a copy of the GNU Lesser General Public License |
17 |
|
|
* along with FFmpeg; if not, write to the Free Software Foundation, Inc., |
18 |
|
|
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA |
19 |
|
|
*/ |
20 |
|
|
|
21 |
|
|
#include "libavutil/avassert.h" |
22 |
|
|
#include "libavutil/opt.h" |
23 |
|
|
#include "avfilter.h" |
24 |
|
|
#include "filters.h" |
25 |
|
|
#include "framesync.h" |
26 |
|
|
#include "internal.h" |
27 |
|
|
|
28 |
|
|
#define OFFSET(member) offsetof(FFFrameSync, member) |
29 |
|
|
#define FLAGS AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_FILTERING_PARAM |
30 |
|
|
|
31 |
|
|
static const char *framesync_name(void *ptr) |
32 |
|
|
{ |
33 |
|
|
return "framesync"; |
34 |
|
|
} |
35 |
|
|
|
36 |
|
|
static const AVOption framesync_options[] = { |
37 |
|
|
{ "eof_action", "Action to take when encountering EOF from secondary input ", |
38 |
|
|
OFFSET(opt_eof_action), AV_OPT_TYPE_INT, { .i64 = EOF_ACTION_REPEAT }, |
39 |
|
|
EOF_ACTION_REPEAT, EOF_ACTION_PASS, .flags = FLAGS, "eof_action" }, |
40 |
|
|
{ "repeat", "Repeat the previous frame.", 0, AV_OPT_TYPE_CONST, { .i64 = EOF_ACTION_REPEAT }, .flags = FLAGS, "eof_action" }, |
41 |
|
|
{ "endall", "End both streams.", 0, AV_OPT_TYPE_CONST, { .i64 = EOF_ACTION_ENDALL }, .flags = FLAGS, "eof_action" }, |
42 |
|
|
{ "pass", "Pass through the main input.", 0, AV_OPT_TYPE_CONST, { .i64 = EOF_ACTION_PASS }, .flags = FLAGS, "eof_action" }, |
43 |
|
|
{ "shortest", "force termination when the shortest input terminates", OFFSET(opt_shortest), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, FLAGS }, |
44 |
|
|
{ "repeatlast", "extend last frame of secondary streams beyond EOF", OFFSET(opt_repeatlast), AV_OPT_TYPE_BOOL, { .i64 = 1 }, 0, 1, FLAGS }, |
45 |
|
|
{ NULL } |
46 |
|
|
}; |
47 |
|
|
static const AVClass framesync_class = { |
48 |
|
|
.version = LIBAVUTIL_VERSION_INT, |
49 |
|
|
.class_name = "framesync", |
50 |
|
|
.item_name = framesync_name, |
51 |
|
|
.category = AV_CLASS_CATEGORY_FILTER, |
52 |
|
|
.option = framesync_options, |
53 |
|
|
.parent_log_context_offset = OFFSET(parent), |
54 |
|
|
}; |
55 |
|
|
|
56 |
|
|
const AVClass *ff_framesync_child_class_iterate(void **iter) |
57 |
|
|
{ |
58 |
|
|
const AVClass *c = *iter ? NULL : &framesync_class; |
59 |
|
|
*iter = (void *)(uintptr_t)c; |
60 |
|
|
return c; |
61 |
|
|
} |
62 |
|
|
|
63 |
|
|
enum { |
64 |
|
|
STATE_BOF, |
65 |
|
|
STATE_RUN, |
66 |
|
|
STATE_EOF, |
67 |
|
|
}; |
68 |
|
|
|
69 |
|
|
static int consume_from_fifos(FFFrameSync *fs); |
70 |
|
|
|
71 |
|
264 |
const AVClass *ff_framesync_get_class(void) |
72 |
|
|
{ |
73 |
|
264 |
return &framesync_class; |
74 |
|
|
} |
75 |
|
|
|
76 |
|
86 |
void ff_framesync_preinit(FFFrameSync *fs) |
77 |
|
|
{ |
78 |
✓✓ |
86 |
if (fs->class) |
79 |
|
28 |
return; |
80 |
|
58 |
fs->class = &framesync_class; |
81 |
|
58 |
av_opt_set_defaults(fs); |
82 |
|
|
} |
83 |
|
|
|
84 |
|
34 |
int ff_framesync_init(FFFrameSync *fs, AVFilterContext *parent, unsigned nb_in) |
85 |
|
|
{ |
86 |
|
|
/* For filters with several outputs, we will not be able to assume which |
87 |
|
|
output is relevant for ff_outlink_frame_wanted() and |
88 |
|
|
ff_outlink_set_status(). To be designed when needed. */ |
89 |
✗✓ |
34 |
av_assert0(parent->nb_outputs == 1); |
90 |
|
|
|
91 |
|
34 |
ff_framesync_preinit(fs); |
92 |
|
34 |
fs->parent = parent; |
93 |
|
34 |
fs->nb_in = nb_in; |
94 |
|
|
|
95 |
|
34 |
fs->in = av_calloc(nb_in, sizeof(*fs->in)); |
96 |
✗✓ |
34 |
if (!fs->in) |
97 |
|
|
return AVERROR(ENOMEM); |
98 |
|
34 |
return 0; |
99 |
|
|
} |
100 |
|
|
|
101 |
|
46 |
static void framesync_eof(FFFrameSync *fs) |
102 |
|
|
{ |
103 |
|
46 |
fs->eof = 1; |
104 |
|
46 |
fs->frame_ready = 0; |
105 |
|
46 |
ff_outlink_set_status(fs->parent->outputs[0], AVERROR_EOF, AV_NOPTS_VALUE); |
106 |
|
46 |
} |
107 |
|
|
|
108 |
|
90 |
static void framesync_sync_level_update(FFFrameSync *fs) |
109 |
|
|
{ |
110 |
|
90 |
unsigned i, level = 0; |
111 |
|
|
|
112 |
✓✓ |
268 |
for (i = 0; i < fs->nb_in; i++) |
113 |
✓✗ |
178 |
if (fs->in[i].state != STATE_EOF) |
114 |
|
178 |
level = FFMAX(level, fs->in[i].sync); |
115 |
✗✓ |
90 |
av_assert0(level <= fs->sync_level); |
116 |
✓✓ |
90 |
if (level < fs->sync_level) |
117 |
|
66 |
av_log(fs, AV_LOG_VERBOSE, "Sync level %u\n", level); |
118 |
✓✓ |
90 |
if (level) |
119 |
|
67 |
fs->sync_level = level; |
120 |
|
|
else |
121 |
|
23 |
framesync_eof(fs); |
122 |
|
90 |
} |
123 |
|
|
|
124 |
|
34 |
int ff_framesync_configure(FFFrameSync *fs) |
125 |
|
|
{ |
126 |
|
|
unsigned i; |
127 |
|
|
|
128 |
✓✗✗✓
|
34 |
if (!fs->opt_repeatlast || fs->opt_eof_action == EOF_ACTION_PASS) { |
129 |
|
|
fs->opt_repeatlast = 0; |
130 |
|
|
fs->opt_eof_action = EOF_ACTION_PASS; |
131 |
|
|
} |
132 |
✓✗✗✓
|
34 |
if (fs->opt_shortest || fs->opt_eof_action == EOF_ACTION_ENDALL) { |
133 |
|
|
fs->opt_shortest = 1; |
134 |
|
|
fs->opt_eof_action = EOF_ACTION_ENDALL; |
135 |
|
|
} |
136 |
✗✓ |
34 |
if (!fs->opt_repeatlast) { |
137 |
|
|
for (i = 1; i < fs->nb_in; i++) { |
138 |
|
|
fs->in[i].after = EXT_NULL; |
139 |
|
|
fs->in[i].sync = 0; |
140 |
|
|
} |
141 |
|
|
} |
142 |
✗✓ |
34 |
if (fs->opt_shortest) { |
143 |
|
|
for (i = 0; i < fs->nb_in; i++) |
144 |
|
|
fs->in[i].after = EXT_STOP; |
145 |
|
|
} |
146 |
|
|
|
147 |
✓✗ |
34 |
if (!fs->time_base.num) { |
148 |
✓✓ |
101 |
for (i = 0; i < fs->nb_in; i++) { |
149 |
✓✗ |
67 |
if (fs->in[i].sync) { |
150 |
✓✓ |
67 |
if (fs->time_base.num) { |
151 |
|
33 |
fs->time_base = av_gcd_q(fs->time_base, fs->in[i].time_base, |
152 |
|
33 |
AV_TIME_BASE / 2, AV_TIME_BASE_Q); |
153 |
|
|
} else { |
154 |
|
34 |
fs->time_base = fs->in[i].time_base; |
155 |
|
|
} |
156 |
|
|
} |
157 |
|
|
} |
158 |
✗✓ |
34 |
if (!fs->time_base.num) { |
159 |
|
|
av_log(fs, AV_LOG_ERROR, "Impossible to set time base\n"); |
160 |
|
|
return AVERROR(EINVAL); |
161 |
|
|
} |
162 |
|
34 |
av_log(fs, AV_LOG_VERBOSE, "Selected %d/%d time base\n", |
163 |
|
|
fs->time_base.num, fs->time_base.den); |
164 |
|
|
} |
165 |
|
|
|
166 |
✓✓ |
101 |
for (i = 0; i < fs->nb_in; i++) |
167 |
|
67 |
fs->in[i].pts = fs->in[i].pts_next = AV_NOPTS_VALUE; |
168 |
|
34 |
fs->sync_level = UINT_MAX; |
169 |
|
34 |
framesync_sync_level_update(fs); |
170 |
|
|
|
171 |
|
34 |
return 0; |
172 |
|
|
} |
173 |
|
|
|
174 |
|
3434 |
static int framesync_advance(FFFrameSync *fs) |
175 |
|
|
{ |
176 |
|
|
unsigned i; |
177 |
|
|
int64_t pts; |
178 |
|
|
int ret; |
179 |
|
|
|
180 |
✓✓✓✓
|
4963 |
while (!(fs->frame_ready || fs->eof)) { |
181 |
|
3651 |
ret = consume_from_fifos(fs); |
182 |
✓✓ |
3651 |
if (ret <= 0) |
183 |
|
2100 |
return ret; |
184 |
|
|
|
185 |
|
1551 |
pts = INT64_MAX; |
186 |
✓✓ |
4602 |
for (i = 0; i < fs->nb_in; i++) |
187 |
✓✗✓✓
|
3051 |
if (fs->in[i].have_next && fs->in[i].pts_next < pts) |
188 |
|
1755 |
pts = fs->in[i].pts_next; |
189 |
✓✓ |
1551 |
if (pts == INT64_MAX) { |
190 |
|
22 |
framesync_eof(fs); |
191 |
|
22 |
break; |
192 |
|
|
} |
193 |
✓✓ |
4536 |
for (i = 0; i < fs->nb_in; i++) { |
194 |
✓✓ |
3007 |
if (fs->in[i].pts_next == pts || |
195 |
✓✓ |
774 |
(fs->in[i].before == EXT_INFINITY && |
196 |
✗✓ |
210 |
fs->in[i].state == STATE_BOF)) { |
197 |
|
2233 |
av_frame_free(&fs->in[i].frame); |
198 |
|
2233 |
fs->in[i].frame = fs->in[i].frame_next; |
199 |
|
2233 |
fs->in[i].pts = fs->in[i].pts_next; |
200 |
|
2233 |
fs->in[i].frame_next = NULL; |
201 |
|
2233 |
fs->in[i].pts_next = AV_NOPTS_VALUE; |
202 |
|
2233 |
fs->in[i].have_next = 0; |
203 |
✓✓ |
2233 |
fs->in[i].state = fs->in[i].frame ? STATE_RUN : STATE_EOF; |
204 |
✓✓✓✗
|
2233 |
if (fs->in[i].sync == fs->sync_level && fs->in[i].frame) |
205 |
|
1402 |
fs->frame_ready = 1; |
206 |
✓✓ |
2233 |
if (fs->in[i].state == STATE_EOF && |
207 |
✓✗ |
1 |
fs->in[i].after == EXT_STOP) |
208 |
|
1 |
framesync_eof(fs); |
209 |
|
|
} |
210 |
|
|
} |
211 |
✓✓ |
1529 |
if (fs->frame_ready) |
212 |
✓✓ |
3856 |
for (i = 0; i < fs->nb_in; i++) |
213 |
✓✓ |
2554 |
if ((fs->in[i].state == STATE_BOF && |
214 |
✗✓ |
4 |
fs->in[i].before == EXT_STOP)) |
215 |
|
|
fs->frame_ready = 0; |
216 |
|
1529 |
fs->pts = pts; |
217 |
|
|
} |
218 |
|
1334 |
return 0; |
219 |
|
|
} |
220 |
|
|
|
221 |
|
1 |
static int64_t framesync_pts_extrapolate(FFFrameSync *fs, unsigned in, |
222 |
|
|
int64_t pts) |
223 |
|
|
{ |
224 |
|
|
/* Possible enhancement: use the link's frame rate */ |
225 |
|
1 |
return pts + 1; |
226 |
|
|
} |
227 |
|
|
|
228 |
|
2232 |
static void framesync_inject_frame(FFFrameSync *fs, unsigned in, AVFrame *frame) |
229 |
|
|
{ |
230 |
|
|
int64_t pts; |
231 |
|
|
|
232 |
✗✓ |
2232 |
av_assert0(!fs->in[in].have_next); |
233 |
✗✓ |
2232 |
av_assert0(frame); |
234 |
|
2232 |
pts = av_rescale_q(frame->pts, fs->in[in].time_base, fs->time_base); |
235 |
|
2232 |
frame->pts = pts; |
236 |
|
2232 |
fs->in[in].frame_next = frame; |
237 |
|
2232 |
fs->in[in].pts_next = pts; |
238 |
|
2232 |
fs->in[in].have_next = 1; |
239 |
|
2232 |
} |
240 |
|
|
|
241 |
|
56 |
static void framesync_inject_status(FFFrameSync *fs, unsigned in, int status, int64_t pts) |
242 |
|
|
{ |
243 |
✗✓ |
56 |
av_assert0(!fs->in[in].have_next); |
244 |
✓✓ |
56 |
pts = fs->in[in].state != STATE_RUN || fs->in[in].after == EXT_INFINITY |
245 |
✓✗ |
112 |
? INT64_MAX : framesync_pts_extrapolate(fs, in, fs->in[in].pts); |
246 |
|
56 |
fs->in[in].sync = 0; |
247 |
|
56 |
framesync_sync_level_update(fs); |
248 |
|
56 |
fs->in[in].frame_next = NULL; |
249 |
|
56 |
fs->in[in].pts_next = pts; |
250 |
|
56 |
fs->in[in].have_next = 1; |
251 |
|
56 |
} |
252 |
|
|
|
253 |
|
2554 |
int ff_framesync_get_frame(FFFrameSync *fs, unsigned in, AVFrame **rframe, |
254 |
|
|
unsigned get) |
255 |
|
|
{ |
256 |
|
|
AVFrame *frame; |
257 |
|
2554 |
unsigned need_copy = 0, i; |
258 |
|
|
int64_t pts_next; |
259 |
|
|
int ret; |
260 |
|
|
|
261 |
✓✓ |
2554 |
if (!fs->in[in].frame) { |
262 |
|
4 |
*rframe = NULL; |
263 |
|
4 |
return 0; |
264 |
|
|
} |
265 |
|
2550 |
frame = fs->in[in].frame; |
266 |
✓✓ |
2550 |
if (get) { |
267 |
|
|
/* Find out if we need to copy the frame: is there another sync |
268 |
|
|
stream, and do we know if its current frame will outlast this one? */ |
269 |
✓✓ |
1152 |
pts_next = fs->in[in].have_next ? fs->in[in].pts_next : INT64_MAX; |
270 |
✓✓✓✗
|
3456 |
for (i = 0; i < fs->nb_in && !need_copy; i++) |
271 |
✓✓✓✓
|
2304 |
if (i != in && fs->in[i].sync && |
272 |
✓✓✓✗
|
922 |
(!fs->in[i].have_next || fs->in[i].pts_next < pts_next)) |
273 |
|
922 |
need_copy = 1; |
274 |
✓✓ |
1152 |
if (need_copy) { |
275 |
✗✓ |
922 |
if (!(frame = av_frame_clone(frame))) |
276 |
|
|
return AVERROR(ENOMEM); |
277 |
✗✓ |
922 |
if ((ret = av_frame_make_writable(frame)) < 0) { |
278 |
|
|
av_frame_free(&frame); |
279 |
|
|
return ret; |
280 |
|
|
} |
281 |
|
|
} else { |
282 |
|
230 |
fs->in[in].frame = NULL; |
283 |
|
|
} |
284 |
|
1152 |
fs->frame_ready = 0; |
285 |
|
|
} |
286 |
|
2550 |
*rframe = frame; |
287 |
|
2550 |
return 0; |
288 |
|
|
} |
289 |
|
|
|
290 |
|
65 |
void ff_framesync_uninit(FFFrameSync *fs) |
291 |
|
|
{ |
292 |
|
|
unsigned i; |
293 |
|
|
|
294 |
✓✓ |
132 |
for (i = 0; i < fs->nb_in; i++) { |
295 |
|
67 |
av_frame_free(&fs->in[i].frame); |
296 |
|
67 |
av_frame_free(&fs->in[i].frame_next); |
297 |
|
|
} |
298 |
|
|
|
299 |
|
65 |
av_freep(&fs->in); |
300 |
|
65 |
} |
301 |
|
|
|
302 |
|
3651 |
static int consume_from_fifos(FFFrameSync *fs) |
303 |
|
|
{ |
304 |
|
3651 |
AVFilterContext *ctx = fs->parent; |
305 |
|
3651 |
AVFrame *frame = NULL; |
306 |
|
|
int64_t pts; |
307 |
|
|
unsigned i, nb_active, nb_miss; |
308 |
|
|
int ret, status; |
309 |
|
|
|
310 |
|
3651 |
nb_active = nb_miss = 0; |
311 |
✓✓ |
10852 |
for (i = 0; i < fs->nb_in; i++) { |
312 |
✓✓✗✓
|
7201 |
if (fs->in[i].have_next || fs->in[i].state == STATE_EOF) |
313 |
|
2019 |
continue; |
314 |
|
5182 |
nb_active++; |
315 |
|
5182 |
ret = ff_inlink_consume_frame(ctx->inputs[i], &frame); |
316 |
✗✓ |
5182 |
if (ret < 0) |
317 |
|
|
return ret; |
318 |
✓✓ |
5182 |
if (ret) { |
319 |
✗✓ |
2232 |
av_assert0(frame); |
320 |
|
2232 |
framesync_inject_frame(fs, i, frame); |
321 |
|
|
} else { |
322 |
|
2950 |
ret = ff_inlink_acknowledge_status(ctx->inputs[i], &status, &pts); |
323 |
✓✓ |
2950 |
if (ret > 0) { |
324 |
|
56 |
framesync_inject_status(fs, i, status, pts); |
325 |
✓✗ |
2894 |
} else if (!ret) { |
326 |
|
2894 |
nb_miss++; |
327 |
|
|
} |
328 |
|
|
} |
329 |
|
|
} |
330 |
✓✓ |
3651 |
if (nb_miss) { |
331 |
✓✓✓✓
|
2100 |
if (nb_miss == nb_active && !ff_outlink_frame_wanted(ctx->outputs[0])) |
332 |
|
2 |
return FFERROR_NOT_READY; |
333 |
✓✓ |
6244 |
for (i = 0; i < fs->nb_in; i++) |
334 |
✓✓✓✗
|
4146 |
if (!fs->in[i].have_next && fs->in[i].state != STATE_EOF) |
335 |
|
2892 |
ff_inlink_request_frame(ctx->inputs[i]); |
336 |
|
2098 |
return 0; |
337 |
|
|
} |
338 |
|
1551 |
return 1; |
339 |
|
|
} |
340 |
|
|
|
341 |
|
3434 |
int ff_framesync_activate(FFFrameSync *fs) |
342 |
|
|
{ |
343 |
|
|
int ret; |
344 |
|
|
|
345 |
|
3434 |
ret = framesync_advance(fs); |
346 |
✓✓ |
3434 |
if (ret < 0) |
347 |
|
2 |
return ret; |
348 |
✓✓✓✓
|
3432 |
if (fs->eof || !fs->frame_ready) |
349 |
|
2130 |
return 0; |
350 |
|
1302 |
ret = fs->on_event(fs); |
351 |
✗✓ |
1302 |
if (ret < 0) |
352 |
|
|
return ret; |
353 |
|
1302 |
fs->frame_ready = 0; |
354 |
|
|
|
355 |
|
1302 |
return 0; |
356 |
|
|
} |
357 |
|
|
|
358 |
|
31 |
int ff_framesync_init_dualinput(FFFrameSync *fs, AVFilterContext *parent) |
359 |
|
|
{ |
360 |
|
|
int ret; |
361 |
|
|
|
362 |
|
31 |
ret = ff_framesync_init(fs, parent, 2); |
363 |
✗✓ |
31 |
if (ret < 0) |
364 |
|
|
return ret; |
365 |
|
31 |
fs->in[0].time_base = parent->inputs[0]->time_base; |
366 |
|
31 |
fs->in[1].time_base = parent->inputs[1]->time_base; |
367 |
|
31 |
fs->in[0].sync = 2; |
368 |
|
31 |
fs->in[0].before = EXT_STOP; |
369 |
|
31 |
fs->in[0].after = EXT_INFINITY; |
370 |
|
31 |
fs->in[1].sync = 1; |
371 |
|
31 |
fs->in[1].before = EXT_NULL; |
372 |
|
31 |
fs->in[1].after = EXT_INFINITY; |
373 |
|
31 |
return 0; |
374 |
|
|
} |
375 |
|
|
|
376 |
|
1152 |
int ff_framesync_dualinput_get(FFFrameSync *fs, AVFrame **f0, AVFrame **f1) |
377 |
|
|
{ |
378 |
|
1152 |
AVFilterContext *ctx = fs->parent; |
379 |
|
1152 |
AVFrame *mainpic = NULL, *secondpic = NULL; |
380 |
|
|
int ret; |
381 |
|
|
|
382 |
✓✗✗✓
|
2304 |
if ((ret = ff_framesync_get_frame(fs, 0, &mainpic, 1)) < 0 || |
383 |
|
1152 |
(ret = ff_framesync_get_frame(fs, 1, &secondpic, 0)) < 0) { |
384 |
|
|
av_frame_free(&mainpic); |
385 |
|
|
return ret; |
386 |
|
|
} |
387 |
✗✓ |
1152 |
av_assert0(mainpic); |
388 |
|
1152 |
mainpic->pts = av_rescale_q(fs->pts, fs->time_base, ctx->outputs[0]->time_base); |
389 |
✗✓ |
1152 |
if (ctx->is_disabled) |
390 |
|
|
secondpic = NULL; |
391 |
|
1152 |
*f0 = mainpic; |
392 |
|
1152 |
*f1 = secondpic; |
393 |
|
1152 |
return 0; |
394 |
|
|
} |
395 |
|
|
|
396 |
|
1142 |
int ff_framesync_dualinput_get_writable(FFFrameSync *fs, AVFrame **f0, AVFrame **f1) |
397 |
|
|
{ |
398 |
|
|
int ret; |
399 |
|
|
|
400 |
|
1142 |
ret = ff_framesync_dualinput_get(fs, f0, f1); |
401 |
✗✓ |
1142 |
if (ret < 0) |
402 |
|
|
return ret; |
403 |
|
1142 |
ret = ff_inlink_make_frame_writable(fs->parent->inputs[0], f0); |
404 |
✗✓ |
1142 |
if (ret < 0) { |
405 |
|
|
av_frame_free(f0); |
406 |
|
|
*f1 = NULL; |
407 |
|
|
return ret; |
408 |
|
|
} |
409 |
|
1142 |
return 0; |
410 |
|
|
} |