Unified · Split
| @@ -651,66 +651,6 @@ void close_output_stream(OutputStream *ost) · 650 unmodified lines | ||
| 651 | 651 | sq_send(of->sq_encode, ost->sq_idx_encode, SQFRAME(NULL)); |
| 652 | 652 | } |
| 653 | 653 | |
| 654 | −/** | |
| 655 | − * Get and encode new output from any of the filtergraphs, without causing | |
| 656 | − * activity. | |
| 657 | − * | |
| 658 | − * @return 0 for success, <0 for severe errors | |
| 659 | − */ | |
| 660 | −static int reap_filters(int flush) | |
| 661 | −{ | |
| 662 | − AVFrame *filtered_frame = NULL; | |
| 663 | − | |
| 664 | − /* Reap all buffers present in the buffer sinks */ | |
| 665 | − for (OutputStream *ost = ost_iter(NULL); ost; ost = ost_iter(ost)) { | |
| 666 | − AVFilterContext *filter; | |
| 667 | − int ret = 0; | |
| 668 | − | |
| 669 | − if (!ost->filter || !ost->filter->graph->graph) | |
| 670 | − continue; | |
| 671 | − filter = ost->filter->filter; | |
| 672 | − | |
| 673 | − filtered_frame = ost->filtered_frame; | |
| 674 | − | |
| 675 | − while (1) { | |
| 676 | − ret = av_buffersink_get_frame_flags(filter, filtered_frame, | |
| 677 | − AV_BUFFERSINK_FLAG_NO_REQUEST); | |
| 678 | − if (ret < 0) { | |
| 679 | − if (ret != AVERROR(EAGAIN) && ret != AVERROR_EOF) { | |
| 680 | − av_log(NULL, AV_LOG_WARNING, | |
| 681 | − "Error in av_buffersink_get_frame_flags(): %s\n", av_err2str(ret)); | |
| 682 | − } else if (flush && ret == AVERROR_EOF) { | |
| 683 | − if (av_buffersink_get_type(filter) == AVMEDIA_TYPE_VIDEO) | |
| 684 | − enc_frame(ost, NULL); | |
| 685 | − } | |
| 686 | − break; | |
| 687 | − } | |
| 688 | − if (ost->finished) { | |
| 689 | − av_frame_unref(filtered_frame); | |
| 690 | − continue; | |
| 691 | − } | |
| 692 | − | |
| 693 | − if (filtered_frame->pts != AV_NOPTS_VALUE) { | |
| 694 | − AVRational tb = av_buffersink_get_time_base(filter); | |
| 695 | − ost->filter->last_pts = av_rescale_q(filtered_frame->pts, tb, | |
| 696 | − AV_TIME_BASE_Q); | |
| 697 | − filtered_frame->time_base = tb; | |
| 698 | − | |
| 699 | − if (debug_ts) | |
| 700 | − av_log(NULL, AV_LOG_INFO, "filter_raw -> pts:%s pts_time:%s time_base:%d/%d\n", | |
| 701 | − av_ts2str(filtered_frame->pts), | |
| 702 | − av_ts2timestr(filtered_frame->pts, &tb), | |
| 703 | − tb.num, tb.den); | |
| 704 | − } | |
| 705 | − | |
| 706 | − enc_frame(ost, filtered_frame); | |
| 707 | − av_frame_unref(filtered_frame); | |
| 708 | − } | |
| 709 | − } | |
| 710 | − | |
| 711 | − return 0; | |
| 712 | −} | |
| 713 | − | |
| 714 | 654 | static void print_report(int is_last_report, int64_t timer_start, int64_t cur_time) |
| 715 | 655 | { |
| 716 | 656 | AVBPrint buf, buf_script; |
| @@ -914,112 +854,6 @@ int ifilter_has_all_input_formats(FilterGraph *fg) · 197 unmodified lines | ||
| 914 | 854 | return 1; |
| 915 | 855 | } |
| 916 | 856 | |
| 917 | −static int ifilter_send_frame(InputFilter *ifilter, AVFrame *frame, int keep_reference) | |
| 918 | −{ | |
| 919 | − FilterGraph *fg = ifilter->graph; | |
| 920 | − AVFrameSideData *sd; | |
| 921 | − int need_reinit, ret; | |
| 922 | − int buffersrc_flags = AV_BUFFERSRC_FLAG_PUSH; | |
| 923 | − | |
| 924 | − if (keep_reference) | |
| 925 | − buffersrc_flags |= AV_BUFFERSRC_FLAG_KEEP_REF; | |
| 926 | − | |
| 927 | − /* determine if the parameters for this input changed */ | |
| 928 | − need_reinit = ifilter->format != frame->format; | |
| 929 | − | |
| 930 | − switch (ifilter->ist->par->codec_type) { | |
| 931 | − case AVMEDIA_TYPE_AUDIO: | |
| 932 | − need_reinit |= ifilter->sample_rate != frame->sample_rate || | |
| 933 | − av_channel_layout_compare(&ifilter->ch_layout, &frame->ch_layout); | |
| 934 | − break; | |
| 935 | − case AVMEDIA_TYPE_VIDEO: | |
| 936 | − need_reinit |= ifilter->width != frame->width || | |
| 937 | − ifilter->height != frame->height; | |
| 938 | − break; | |
| 939 | − } | |
| 940 | − | |
| 941 | − if (!ifilter->ist->reinit_filters && fg->graph) | |
| 942 | − need_reinit = 0; | |
| 943 | − | |
| 944 | − if (!!ifilter->hw_frames_ctx != !!frame->hw_frames_ctx || | |
| 945 | − (ifilter->hw_frames_ctx && ifilter->hw_frames_ctx->data != frame->hw_frames_ctx->data)) | |
| 946 | − need_reinit = 1; | |
| 947 | − | |
| 948 | − if (sd = av_frame_get_side_data(frame, AV_FRAME_DATA_DISPLAYMATRIX)) { | |
| 949 | − if (!ifilter->displaymatrix || memcmp(sd->data, ifilter->displaymatrix, sizeof(int32_t) * 9)) | |
| 950 | − need_reinit = 1; | |
| 951 | − } else if (ifilter->displaymatrix) | |
| 952 | − need_reinit = 1; | |
| 953 | − | |
| 954 | − if (need_reinit) { | |
| 955 | − ret = ifilter_parameters_from_frame(ifilter, frame); | |
| 956 | − if (ret < 0) | |
| 957 | − return ret; | |
| 958 | − } | |
| 959 | − | |
| 960 | − /* (re)init the graph if possible, otherwise buffer the frame and return */ | |
| 961 | − if (need_reinit || !fg->graph) { | |
| 962 | − if (!ifilter_has_all_input_formats(fg)) { | |
| 963 | − AVFrame *tmp = av_frame_clone(frame); | |
| 964 | − if (!tmp) | |
| 965 | − return AVERROR(ENOMEM); | |
| 966 | − | |
| 967 | − ret = av_fifo_write(ifilter->frame_queue, &tmp, 1); | |
| 968 | − if (ret < 0) | |
| 969 | − av_frame_free(&tmp); | |
| 970 | − | |
| 971 | − return ret; | |
| 972 | − } | |
| 973 | − | |
| 974 | − ret = reap_filters(1); | |
| 975 | − if (ret < 0 && ret != AVERROR_EOF) { | |
| 976 | − av_log(NULL, AV_LOG_ERROR, "Error while filtering: %s\n", av_err2str(ret)); | |
| 977 | − return ret; | |
| 978 | − } | |
| 979 | − | |
| 980 | − ret = configure_filtergraph(fg); | |
| 981 | − if (ret < 0) { | |
| 982 | − av_log(NULL, AV_LOG_ERROR, "Error reinitializing filters!\n"); | |
| 983 | − return ret; | |
| 984 | − } | |
| 985 | − } | |
| 986 | − | |
| 987 | − ret = av_buffersrc_add_frame_flags(ifilter->filter, frame, buffersrc_flags); | |
| 988 | − if (ret < 0) { | |
| 989 | − if (ret != AVERROR_EOF) | |
| 990 | − av_log(NULL, AV_LOG_ERROR, "Error while filtering: %s\n", av_err2str(ret)); | |
| 991 | − return ret; | |
| 992 | − } | |
| 993 | − | |
| 994 | − return 0; | |
| 995 | −} | |
| 996 | − | |
| 997 | −static int ifilter_send_eof(InputFilter *ifilter, int64_t pts) | |
| 998 | −{ | |
| 999 | − int ret; | |
| 1000 | − | |
| 1001 | − ifilter->eof = 1; | |
| 1002 | − | |
| 1003 | − if (ifilter->filter) { | |
| 1004 | − ret = av_buffersrc_close(ifilter->filter, pts, AV_BUFFERSRC_FLAG_PUSH); | |
| 1005 | − if (ret < 0) | |
| 1006 | − return ret; | |
| 1007 | − } else { | |
| 1008 | − // the filtergraph was never configured | |
| 1009 | − if (ifilter->format < 0) { | |
| 1010 | − ret = ifilter_parameters_from_codecpar(ifilter, ifilter->ist->par); | |
| 1011 | − if (ret < 0) | |
| 1012 | − return ret; | |
| 1013 | − } | |
| 1014 | − if (ifilter->format < 0 && (ifilter->type == AVMEDIA_TYPE_AUDIO || ifilter->type == AVMEDIA_TYPE_VIDEO)) { | |
| 1015 | − av_log(NULL, AV_LOG_ERROR, "Cannot determine format of input stream %d:%d after EOF\n", ifilter->ist->file_index, ifilter->ist->st->index); | |
| 1016 | − return AVERROR_INVALIDDATA; | |
| 1017 | − } | |
| 1018 | − } | |
| 1019 | − | |
| 1020 | − return 0; | |
| 1021 | −} | |
| 1022 | − | |
| 1023 | 857 | // This does not quite work like avcodec_decode_audio4/avcodec_decode_video2. |
| 1024 | 858 | // There is the following difference: if you got a frame, you must call |
| 1025 | 859 | // it again with pkt=NULL. pkt==NULL is treated differently from pkt->size==0 |
| @@ -2262,54 +2096,6 @@ discard_packet: · 1236 unmodified lines | ||
| 2262 | 2096 | return 0; |
| 2263 | 2097 | } |
| 2264 | 2098 | |
| 2265 | −/** | |
| 2266 | − * Perform a step of transcoding for the specified filter graph. | |
| 2267 | − * | |
| 2268 | − * @param[in] graph filter graph to consider | |
| 2269 | − * @param[out] best_ist input stream where a frame would allow to continue | |
| 2270 | − * @return 0 for success, <0 for error | |
| 2271 | − */ | |
| 2272 | −static int transcode_from_filter(FilterGraph *graph, InputStream **best_ist) | |
| 2273 | −{ | |
| 2274 | − int i, ret; | |
| 2275 | − int nb_requests, nb_requests_max = 0; | |
| 2276 | − InputFilter *ifilter; | |
| 2277 | − InputStream *ist; | |
| 2278 | − | |
| 2279 | − *best_ist = NULL; | |
| 2280 | − ret = avfilter_graph_request_oldest(graph->graph); | |
| 2281 | − if (ret >= 0) | |
| 2282 | − return reap_filters(0); | |
| 2283 | − | |
| 2284 | − if (ret == AVERROR_EOF) { | |
| 2285 | − ret = reap_filters(1); | |
| 2286 | − for (i = 0; i < graph->nb_outputs; i++) | |
| 2287 | − close_output_stream(graph->outputs[i]->ost); | |
| 2288 | − return ret; | |
| 2289 | − } | |
| 2290 | − if (ret != AVERROR(EAGAIN)) | |
| 2291 | − return ret; | |
| 2292 | − | |
| 2293 | − for (i = 0; i < graph->nb_inputs; i++) { | |
| 2294 | − ifilter = graph->inputs[i]; | |
| 2295 | − ist = ifilter->ist; | |
| 2296 | − if (input_files[ist->file_index]->eagain || | |
| 2297 | − input_files[ist->file_index]->eof_reached) | |
| 2298 | − continue; | |
| 2299 | − nb_requests = av_buffersrc_get_nb_failed_requests(ifilter->filter); | |
| 2300 | − if (nb_requests > nb_requests_max) { | |
| 2301 | − nb_requests_max = nb_requests; | |
| 2302 | − *best_ist = ist; | |
| 2303 | − } | |
| 2304 | − } | |
| 2305 | − | |
| 2306 | − if (!*best_ist) | |
| 2307 | − for (i = 0; i < graph->nb_outputs; i++) | |
| 2308 | − graph->outputs[i]->ost->unavailable = 1; | |
| 2309 | − | |
| 2310 | − return 0; | |
| 2311 | −} | |
| 2312 | − | |
| 2313 | 2099 | /** |
| 2314 | 2100 | * Run a single step of transcoding. |
| 2315 | 2101 | * |
| @@ -2343,7 +2129,7 @@ static int transcode_step(void) · 27 unmodified lines | ||
| 2343 | 2129 | } |
| 2344 | 2130 | |
| 2345 | 2131 | if (ost->filter && ost->filter->graph->graph) { |
| 2346 | − if ((ret = transcode_from_filter(ost->filter->graph, &ist)) < 0) | |
| 2132 | + if ((ret = fg_transcode_step(ost->filter->graph, &ist)) < 0) | |
| 2347 | 2133 | return ret; |
| 2348 | 2134 | if (!ist) |
| 2349 | 2135 | return 0; |
| @@ -799,6 +799,9 @@ int init_complex_filtergraph(FilterGraph *fg); · 798 unmodified lines | ||
| 799 | 799 | |
| 800 | 800 | void sub2video_update(InputStream *ist, int64_t heartbeat_pts, AVSubtitle *sub); |
| 801 | 801 | |
| 802 | +int ifilter_send_frame(InputFilter *ifilter, AVFrame *frame, int keep_reference); | |
| 803 | +int ifilter_send_eof(InputFilter *ifilter, int64_t pts); | |
| 804 | + | |
| 802 | 805 | int ifilter_parameters_from_frame(InputFilter *ifilter, const AVFrame *frame); |
| 803 | 806 | int ifilter_parameters_from_codecpar(InputFilter *ifilter, AVCodecParameters *par); |
| 804 | 807 | int ifilter_has_all_input_formats(FilterGraph *fg); |
| @@ -811,6 +814,23 @@ int ifilter_has_all_input_formats(FilterGraph *fg); · 6 unmodified lines | ||
| 811 | 814 | */ |
| 812 | 815 | FilterGraph *fg_create(char *graph_desc); |
| 813 | 816 | |
| 817 | +/** | |
| 818 | + * Perform a step of transcoding for the specified filter graph. | |
| 819 | + * | |
| 820 | + * @param[in] graph filter graph to consider | |
| 821 | + * @param[out] best_ist input stream where a frame would allow to continue | |
| 822 | + * @return 0 for success, <0 for error | |
| 823 | + */ | |
| 824 | +int fg_transcode_step(FilterGraph *graph, InputStream **best_ist); | |
| 825 | + | |
| 826 | +/** | |
| 827 | + * Get and encode new output from any of the filtergraphs, without causing | |
| 828 | + * activity. | |
| 829 | + * | |
| 830 | + * @return 0 for success, <0 for severe errors | |
| 831 | + */ | |
| 832 | +int reap_filters(int flush); | |
| 833 | + | |
| 814 | 834 | int ffmpeg_parse_options(int argc, char **argv); |
| 815 | 835 | |
| 816 | 836 | void enc_stats_write(OutputStream *ost, EncStats *es, |
| @@ -36,6 +36,7 @@ · 35 unmodified lines | ||
| 36 | 36 | #include "libavutil/pixfmt.h" |
| 37 | 37 | #include "libavutil/imgutils.h" |
| 38 | 38 | #include "libavutil/samplefmt.h" |
| 39 | +#include "libavutil/timestamp.h" | |
| 39 | 40 | |
| 40 | 41 | // FIXME: YUV420P etc. are actually supported with full color range, |
| 41 | 42 | // yet the latter information isn't available here. |
| @@ -1300,3 +1301,204 @@ int filtergraph_is_simple(FilterGraph *fg) · 1258 unmodified lines | ||
| 1300 | 1301 | { |
| 1301 | 1302 | return !fg->graph_desc; |
| 1302 | 1303 | } |
| 1304 | + | |
| 1305 | +int reap_filters(int flush) | |
| 1306 | +{ | |
| 1307 | + AVFrame *filtered_frame = NULL; | |
| 1308 | + | |
| 1309 | + /* Reap all buffers present in the buffer sinks */ | |
| 1310 | + for (OutputStream *ost = ost_iter(NULL); ost; ost = ost_iter(ost)) { | |
| 1311 | + AVFilterContext *filter; | |
| 1312 | + int ret = 0; | |
| 1313 | + | |
| 1314 | + if (!ost->filter || !ost->filter->graph->graph) | |
| 1315 | + continue; | |
| 1316 | + filter = ost->filter->filter; | |
| 1317 | + | |
| 1318 | + filtered_frame = ost->filtered_frame; | |
| 1319 | + | |
| 1320 | + while (1) { | |
| 1321 | + ret = av_buffersink_get_frame_flags(filter, filtered_frame, | |
| 1322 | + AV_BUFFERSINK_FLAG_NO_REQUEST); | |
| 1323 | + if (ret < 0) { | |
| 1324 | + if (ret != AVERROR(EAGAIN) && ret != AVERROR_EOF) { | |
| 1325 | + av_log(NULL, AV_LOG_WARNING, | |
| 1326 | + "Error in av_buffersink_get_frame_flags(): %s\n", av_err2str(ret)); | |
| 1327 | + } else if (flush && ret == AVERROR_EOF) { | |
| 1328 | + if (av_buffersink_get_type(filter) == AVMEDIA_TYPE_VIDEO) | |
| 1329 | + enc_frame(ost, NULL); | |
| 1330 | + } | |
| 1331 | + break; | |
| 1332 | + } | |
| 1333 | + if (ost->finished) { | |
| 1334 | + av_frame_unref(filtered_frame); | |
| 1335 | + continue; | |
| 1336 | + } | |
| 1337 | + | |
| 1338 | + if (filtered_frame->pts != AV_NOPTS_VALUE) { | |
| 1339 | + AVRational tb = av_buffersink_get_time_base(filter); | |
| 1340 | + ost->filter->last_pts = av_rescale_q(filtered_frame->pts, tb, | |
| 1341 | + AV_TIME_BASE_Q); | |
| 1342 | + filtered_frame->time_base = tb; | |
| 1343 | + | |
| 1344 | + if (debug_ts) | |
| 1345 | + av_log(NULL, AV_LOG_INFO, "filter_raw -> pts:%s pts_time:%s time_base:%d/%d\n", | |
| 1346 | + av_ts2str(filtered_frame->pts), | |
| 1347 | + av_ts2timestr(filtered_frame->pts, &tb), | |
| 1348 | + tb.num, tb.den); | |
| 1349 | + } | |
| 1350 | + | |
| 1351 | + enc_frame(ost, filtered_frame); | |
| 1352 | + av_frame_unref(filtered_frame); | |
| 1353 | + } | |
| 1354 | + } | |
| 1355 | + | |
| 1356 | + return 0; | |
| 1357 | +} | |
| 1358 | + | |
| 1359 | +int ifilter_send_eof(InputFilter *ifilter, int64_t pts) | |
| 1360 | +{ | |
| 1361 | + int ret; | |
| 1362 | + | |
| 1363 | + ifilter->eof = 1; | |
| 1364 | + | |
| 1365 | + if (ifilter->filter) { | |
| 1366 | + ret = av_buffersrc_close(ifilter->filter, pts, AV_BUFFERSRC_FLAG_PUSH); | |
| 1367 | + if (ret < 0) | |
| 1368 | + return ret; | |
| 1369 | + } else { | |
| 1370 | + // the filtergraph was never configured | |
| 1371 | + if (ifilter->format < 0) { | |
| 1372 | + ret = ifilter_parameters_from_codecpar(ifilter, ifilter->ist->par); | |
| 1373 | + if (ret < 0) | |
| 1374 | + return ret; | |
| 1375 | + } | |
| 1376 | + if (ifilter->format < 0 && (ifilter->type == AVMEDIA_TYPE_AUDIO || ifilter->type == AVMEDIA_TYPE_VIDEO)) { | |
| 1377 | + av_log(NULL, AV_LOG_ERROR, "Cannot determine format of input stream %d:%d after EOF\n", ifilter->ist->file_index, ifilter->ist->st->index); | |
| 1378 | + return AVERROR_INVALIDDATA; | |
| 1379 | + } | |
| 1380 | + } | |
| 1381 | + | |
| 1382 | + return 0; | |
| 1383 | +} | |
| 1384 | + | |
| 1385 | +int ifilter_send_frame(InputFilter *ifilter, AVFrame *frame, int keep_reference) | |
| 1386 | +{ | |
| 1387 | + FilterGraph *fg = ifilter->graph; | |
| 1388 | + AVFrameSideData *sd; | |
| 1389 | + int need_reinit, ret; | |
| 1390 | + int buffersrc_flags = AV_BUFFERSRC_FLAG_PUSH; | |
| 1391 | + | |
| 1392 | + if (keep_reference) | |
| 1393 | + buffersrc_flags |= AV_BUFFERSRC_FLAG_KEEP_REF; | |
| 1394 | + | |
| 1395 | + /* determine if the parameters for this input changed */ | |
| 1396 | + need_reinit = ifilter->format != frame->format; | |
| 1397 | + | |
| 1398 | + switch (ifilter->ist->par->codec_type) { | |
| 1399 | + case AVMEDIA_TYPE_AUDIO: | |
| 1400 | + need_reinit |= ifilter->sample_rate != frame->sample_rate || | |
| 1401 | + av_channel_layout_compare(&ifilter->ch_layout, &frame->ch_layout); | |
| 1402 | + break; | |
| 1403 | + case AVMEDIA_TYPE_VIDEO: | |
| 1404 | + need_reinit |= ifilter->width != frame->width || | |
| 1405 | + ifilter->height != frame->height; | |
| 1406 | + break; | |
| 1407 | + } | |
| 1408 | + | |
| 1409 | + if (!ifilter->ist->reinit_filters && fg->graph) | |
| 1410 | + need_reinit = 0; | |
| 1411 | + | |
| 1412 | + if (!!ifilter->hw_frames_ctx != !!frame->hw_frames_ctx || | |
| 1413 | + (ifilter->hw_frames_ctx && ifilter->hw_frames_ctx->data != frame->hw_frames_ctx->data)) | |
| 1414 | + need_reinit = 1; | |
| 1415 | + | |
| 1416 | + if (sd = av_frame_get_side_data(frame, AV_FRAME_DATA_DISPLAYMATRIX)) { | |
| 1417 | + if (!ifilter->displaymatrix || memcmp(sd->data, ifilter->displaymatrix, sizeof(int32_t) * 9)) | |
| 1418 | + need_reinit = 1; | |
| 1419 | + } else if (ifilter->displaymatrix) | |
| 1420 | + need_reinit = 1; | |
| 1421 | + | |
| 1422 | + if (need_reinit) { | |
| 1423 | + ret = ifilter_parameters_from_frame(ifilter, frame); | |
| 1424 | + if (ret < 0) | |
| 1425 | + return ret; | |
| 1426 | + } | |
| 1427 | + | |
| 1428 | + /* (re)init the graph if possible, otherwise buffer the frame and return */ | |
| 1429 | + if (need_reinit || !fg->graph) { | |
| 1430 | + if (!ifilter_has_all_input_formats(fg)) { | |
| 1431 | + AVFrame *tmp = av_frame_clone(frame); | |
| 1432 | + if (!tmp) | |
| 1433 | + return AVERROR(ENOMEM); | |
| 1434 | + | |
| 1435 | + ret = av_fifo_write(ifilter->frame_queue, &tmp, 1); | |
| 1436 | + if (ret < 0) | |
| 1437 | + av_frame_free(&tmp); | |
| 1438 | + | |
| 1439 | + return ret; | |
| 1440 | + } | |
| 1441 | + | |
| 1442 | + ret = reap_filters(1); | |
| 1443 | + if (ret < 0 && ret != AVERROR_EOF) { | |
| 1444 | + av_log(NULL, AV_LOG_ERROR, "Error while filtering: %s\n", av_err2str(ret)); | |
| 1445 | + return ret; | |
| 1446 | + } | |
| 1447 | + | |
| 1448 | + ret = configure_filtergraph(fg); | |
| 1449 | + if (ret < 0) { | |
| 1450 | + av_log(NULL, AV_LOG_ERROR, "Error reinitializing filters!\n"); | |
| 1451 | + return ret; | |
| 1452 | + } | |
| 1453 | + } | |
| 1454 | + | |
| 1455 | + ret = av_buffersrc_add_frame_flags(ifilter->filter, frame, buffersrc_flags); | |
| 1456 | + if (ret < 0) { | |
| 1457 | + if (ret != AVERROR_EOF) | |
| 1458 | + av_log(NULL, AV_LOG_ERROR, "Error while filtering: %s\n", av_err2str(ret)); | |
| 1459 | + return ret; | |
| 1460 | + } | |
| 1461 | + | |
| 1462 | + return 0; | |
| 1463 | +} | |
| 1464 | + | |
| 1465 | +int fg_transcode_step(FilterGraph *graph, InputStream **best_ist) | |
| 1466 | +{ | |
| 1467 | + int i, ret; | |
| 1468 | + int nb_requests, nb_requests_max = 0; | |
| 1469 | + InputFilter *ifilter; | |
| 1470 | + InputStream *ist; | |
| 1471 | + | |
| 1472 | + *best_ist = NULL; | |
| 1473 | + ret = avfilter_graph_request_oldest(graph->graph); | |
| 1474 | + if (ret >= 0) | |
| 1475 | + return reap_filters(0); | |
| 1476 | + | |
| 1477 | + if (ret == AVERROR_EOF) { | |
| 1478 | + ret = reap_filters(1); | |
| 1479 | + for (i = 0; i < graph->nb_outputs; i++) | |
| 1480 | + close_output_stream(graph->outputs[i]->ost); | |
| 1481 | + return ret; | |
| 1482 | + } | |
| 1483 | + if (ret != AVERROR(EAGAIN)) | |
| 1484 | + return ret; | |
| 1485 | + | |
| 1486 | + for (i = 0; i < graph->nb_inputs; i++) { | |
| 1487 | + ifilter = graph->inputs[i]; | |
| 1488 | + ist = ifilter->ist; | |
| 1489 | + if (input_files[ist->file_index]->eagain || | |
| 1490 | + input_files[ist->file_index]->eof_reached) | |
| 1491 | + continue; | |
| 1492 | + nb_requests = av_buffersrc_get_nb_failed_requests(ifilter->filter); | |
| 1493 | + if (nb_requests > nb_requests_max) { | |
| 1494 | + nb_requests_max = nb_requests; | |
| 1495 | + *best_ist = ist; | |
| 1496 | + } | |
| 1497 | + } | |
| 1498 | + | |
| 1499 | + if (!*best_ist) | |
| 1500 | + for (i = 0; i < graph->nb_outputs; i++) | |
| 1501 | + graph->outputs[i]->ost->unavailable = 1; | |
| 1502 | + | |
| 1503 | + return 0; | |
| 1504 | +} | |