int attribute_align_arg av_buffersink_get_frame_flags(AVFilterContext *ctx, AVFrame *frame, int flags) { BufferSinkContext *buf = ctx->priv; AVFilterLink *inlink = ctx->inputs[0]; int ret; AVFrame *cur_frame; /* no picref available, fetch it from the filterchain */ if (!av_fifo_size(buf->fifo)) { if (flags & AV_BUFFERSINK_FLAG_NO_REQUEST) return AVERROR(EAGAIN); if ((ret = ff_request_frame(inlink)) < 0) return ret; } if (!av_fifo_size(buf->fifo)) return AVERROR(EINVAL); if (flags & AV_BUFFERSINK_FLAG_PEEK) { cur_frame = *((AVFrame **)av_fifo_peek2(buf->fifo, 0)); av_frame_ref(frame, cur_frame); /* TODO check failure */ } else { av_fifo_generic_read(buf->fifo, &cur_frame, sizeof(cur_frame), NULL); av_frame_move_ref(frame, cur_frame); av_frame_free(&cur_frame); } return 0; }
static int request_frame(AVFilterLink *outlink) { AVFilterContext *ctx = outlink->src; MixContext *s = ctx->priv; int ret; int wanted_samples; ret = calc_active_inputs(s); if (ret < 0) return ret; if (!(s->input_state[0] & INPUT_ON)) return request_samples(ctx, 1); if (s->frame_list->nb_frames == 0) { ret = ff_request_frame(ctx->inputs[0]); if (ret == AVERROR_EOF) { s->input_state[0] = 0; if (s->nb_inputs == 1) return AVERROR_EOF; return output_frame(ctx->outputs[0]); } return ret; } av_assert0(s->frame_list->nb_frames > 0); wanted_samples = frame_list_next_frame_size(s->frame_list); return request_samples(ctx, wanted_samples); }
static int request_frame(AVFilterLink *outlink) { AVFilterContext *ctx = outlink->src; AudioEchoContext *s = ctx->priv; int ret; ret = ff_request_frame(ctx->inputs[0]); if (ret == AVERROR_EOF && !ctx->is_disabled && s->fade_out) { int nb_samples = FFMIN(s->fade_out, 2048); AVFrame *frame; frame = ff_get_audio_buffer(outlink, nb_samples); if (!frame) return AVERROR(ENOMEM); s->fade_out -= nb_samples; av_samples_set_silence(frame->extended_data, 0, frame->nb_samples, outlink->channels, frame->format); s->echo_samples(s, s->delayptrs, frame->data, frame->data, frame->nb_samples, outlink->channels); frame->pts = s->next_pts; if (s->next_pts != AV_NOPTS_VALUE) s->next_pts += av_rescale_q(nb_samples, (AVRational){1, outlink->sample_rate}, outlink->time_base); return ff_filter_frame(outlink, frame); } return ret; }
static int request_frame(AVFilterLink *link) { AVFilterContext *ctx = link->src; IDETContext *idet = ctx->priv; do { int ret; if (idet->eof) return AVERROR_EOF; ret = ff_request_frame(link->src->inputs[0]); if (ret == AVERROR_EOF && idet->cur) { AVFrame *next = av_frame_clone(idet->next); if (!next) return AVERROR(ENOMEM); filter_frame(link->src->inputs[0], next); idet->eof = 1; } else if (ret < 0) { return ret; } } while (!idet->cur); return 0; }
static int start_frame(AVFilterLink *inlink, AVFilterBufferRef *inpicref) { AVFilterBufferRef *outpicref = avfilter_ref_buffer(inpicref, ~0); AVFilterContext *ctx = inlink->dst; OverlayContext *over = ctx->priv; if (!outpicref) return AVERROR(ENOMEM); outpicref->pts = av_rescale_q(outpicref->pts, ctx->inputs[MAIN]->time_base, ctx->outputs[0]->time_base); if (!over->overpicref || over->overpicref->pts < outpicref->pts) { AVFilterBufferRef *old = over->overpicref; over->overpicref = NULL; ff_request_frame(ctx->inputs[OVERLAY]); if (over->overpicref) { if (old) avfilter_unref_buffer(old); } else over->overpicref = old; } return ff_start_frame(inlink->dst->outputs[0], outpicref); }
static int request_frame(AVFilterLink *outlink) { AVFilterContext *ctx = outlink->src; ResampleContext *s = ctx->priv; int ret = 0; s->got_output = 0; while (ret >= 0 && !s->got_output) ret = ff_request_frame(ctx->inputs[0]); /* flush the lavr delay buffer */ if (ret == AVERROR_EOF && s->avr) { AVFrame *frame; int nb_samples = avresample_get_out_samples(s->avr, 0); if (!nb_samples) return ret; frame = ff_get_audio_buffer(outlink, nb_samples); if (!frame) return AVERROR(ENOMEM); ret = avresample_convert(s->avr, frame->extended_data, frame->linesize[0], nb_samples, NULL, 0, 0); if (ret <= 0) { av_frame_free(&frame); return (ret == 0) ? AVERROR_EOF : ret; } frame->pts = s->next_pts; return ff_filter_frame(outlink, frame); } return ret; }
static int request_frame(AVFilterLink *link) { AVFilterContext *ctx = link->src; ASyncContext *s = ctx->priv; int ret = 0; int nb_samples; s->got_output = 0; while (ret >= 0 && !s->got_output) ret = ff_request_frame(ctx->inputs[0]); /* flush the fifo */ if (ret == AVERROR_EOF) { if (s->first_pts != AV_NOPTS_VALUE) handle_trimming(ctx); if (nb_samples = get_delay(s)) { AVFrame *buf = ff_get_audio_buffer(link, nb_samples); if (!buf) return AVERROR(ENOMEM); ret = avresample_convert(s->avr, buf->extended_data, buf->linesize[0], nb_samples, NULL, 0, 0); if (ret <= 0) { av_frame_free(&buf); return (ret < 0) ? ret : AVERROR_EOF; } buf->pts = s->pts; return ff_filter_frame(link, buf); } } return ret; }
static int request_frame(AVFilterLink *outlink) { SoxContext *sox = outlink->dst->priv; sox_effect_t *effect = sox->effect; size_t out_nb_samples = 1024; AVFrame *outsamples; int ret; ret = ff_request_frame(outlink->src->inputs[0]); if (ret == AVERROR_EOF) { /* drain cached samples */ while (0) { outsamples = ff_get_audio_buffer(outlink, out_nb_samples); ret = effect->handler.drain(sox->effect, (int32_t *)outsamples->data[0], &out_nb_samples); outsamples->nb_samples = out_nb_samples / effect->out_signal.channels; ff_filter_frame(outlink, outsamples); if (ret == SOX_EOF) break; } } return ret; }
static int request_frame(AVFilterLink *outlink) { AVFilterContext *ctx = outlink->src; ZPContext *s = ctx->priv; AVFrame *in = s->in; double zoom, dx, dy; int ret; if (in) { ret = output_single_frame(ctx, in, s->var_values, s->current_frame, &zoom, &dx, &dy); if (ret < 0) goto fail; } if (s->current_frame >= s->nb_frames) { s->x = dx; s->y = dy; s->prev_zoom = zoom; s->prev_nb_frames = s->nb_frames; s->nb_frames = 0; s->current_frame = 0; av_frame_free(&s->in); ret = 0; s->finished = 1; ret = ff_request_frame(ctx->inputs[0]); } fail: sws_freeContext(s->sws); s->sws = NULL; return ret; }
static int request_frame(AVFilterLink *outlink) { AVFilterContext *ctx = outlink->src; LADSPAContext *s = ctx->priv; AVFrame *out; int64_t t; int i; if (ctx->nb_inputs) return ff_request_frame(ctx->inputs[0]); t = av_rescale(s->pts, AV_TIME_BASE, s->sample_rate); if (s->duration >= 0 && t >= s->duration) return AVERROR_EOF; out = ff_get_audio_buffer(outlink, s->nb_samples); if (!out) return AVERROR(ENOMEM); for (i = 0; i < s->nb_outputs; i++) s->desc->connect_port(s->handles[0], s->opmap[i], (LADSPA_Data*)out->extended_data[i]); s->desc->run(s->handles[0], s->nb_samples); for (i = 0; i < s->nb_outputcontrols; i++) print_ctl_info(ctx, AV_LOG_INFO, s, i, s->ocmap, s->octlv, 1); out->sample_rate = s->sample_rate; out->pts = s->pts; s->pts += s->nb_samples; return ff_filter_frame(outlink, out); }
static int arequest_frame(AVFilterLink *outlink) { AVFilterContext *ctx = outlink->src; LoopContext *s = ctx->priv; int ret = 0; if ((!s->size) || (s->nb_samples < s->size) || (s->nb_samples >= s->size && s->loop == 0)) { int nb_samples = av_audio_fifo_size(s->left); if (s->loop == 0 && nb_samples > 0) { AVFrame *out; out = ff_get_audio_buffer(outlink, nb_samples); if (!out) return AVERROR(ENOMEM); av_audio_fifo_read(s->left, (void **)out->extended_data, nb_samples); out->pts = s->pts; s->pts += nb_samples; ret = ff_filter_frame(outlink, out); if (ret < 0) return ret; } ret = ff_request_frame(ctx->inputs[0]); } else { ret = push_samples(ctx, 1024); } if (ret == AVERROR_EOF && s->nb_samples > 0 && s->loop != 0) { ret = push_samples(ctx, outlink->sample_rate); } return ret; }
int av_buffersink_get_buffer_ref(AVFilterContext *ctx, AVFilterBufferRef **bufref, int flags) { BufferSinkContext *buf = ctx->priv; AVFilterLink *inlink = ctx->inputs[0]; int ret; *bufref = NULL; av_assert0( !strcmp(ctx->filter->name, "buffersink") || !strcmp(ctx->filter->name, "abuffersink") || !strcmp(ctx->filter->name, "ffbuffersink") || !strcmp(ctx->filter->name, "ffabuffersink")); /* no picref available, fetch it from the filterchain */ if (!av_fifo_size(buf->fifo)) { if (flags & AV_BUFFERSINK_FLAG_NO_REQUEST) return AVERROR(EAGAIN); if ((ret = ff_request_frame(inlink)) < 0) return ret; } if (!av_fifo_size(buf->fifo)) return AVERROR(EINVAL); if (flags & AV_BUFFERSINK_FLAG_PEEK) *bufref = *((AVFilterBufferRef **)av_fifo_peek2(buf->fifo, 0)); else av_fifo_generic_read(buf->fifo, bufref, sizeof(*bufref), NULL); return 0; }
/** * Requests a frame, if needed, from each input link other than the first. */ static int request_samples(AVFilterContext *ctx, int min_samples) { MixContext *s = ctx->priv; int i, ret; av_assert0(s->nb_inputs > 1); for (i = 1; i < s->nb_inputs; i++) { ret = 0; if (!(s->input_state[i] & INPUT_ON)) continue; if (av_audio_fifo_size(s->fifos[i]) >= min_samples) continue; ret = ff_request_frame(ctx->inputs[i]); if (ret == AVERROR_EOF) { s->input_state[i] |= INPUT_EOF; if (av_audio_fifo_size(s->fifos[i]) == 0) { s->input_state[i] = 0; continue; } } else if (ret < 0) return ret; } return output_frame(ctx->outputs[0]); }
int ff_request_frame(AVFilterLink *link) { int ret = -1; FF_TPRINTF_START(NULL, request_frame); ff_tlog_link(NULL, link, 1); if (link->closed) return AVERROR_EOF; av_assert0(!link->frame_requested); link->frame_requested = 1; while (link->frame_requested) { if (link->srcpad->request_frame) ret = link->srcpad->request_frame(link); else if (link->src->inputs[0]) ret = ff_request_frame(link->src->inputs[0]); if (ret == AVERROR_EOF && link->partial_buf) { AVFrame *pbuf = link->partial_buf; link->partial_buf = NULL; ret = ff_filter_frame_framed(link, pbuf); } if (ret < 0) { link->frame_requested = 0; if (ret == AVERROR_EOF) link->closed = 1; } else { av_assert0(!link->frame_requested || link->flags & FF_LINK_FLAG_REQUEST_LOOP); } } return ret; }
static int request_frame(AVFilterLink *outlink) { AVFilterContext *ctx = outlink->src; SilenceRemoveContext *s = ctx->priv; int ret; ret = ff_request_frame(ctx->inputs[0]); if (ret == AVERROR_EOF && (s->mode == SILENCE_COPY_FLUSH || s->mode == SILENCE_COPY)) { int nbs = s->stop_holdoff_end - s->stop_holdoff_offset; if (nbs) { AVFrame *frame; frame = ff_get_audio_buffer(outlink, nbs / outlink->channels); if (!frame) return AVERROR(ENOMEM); memcpy(frame->data[0], &s->stop_holdoff[s->stop_holdoff_offset], nbs * sizeof(double)); ret = ff_filter_frame(ctx->inputs[0], frame); } s->mode = SILENCE_STOP; } return ret; }
int ff_yadif_request_frame(AVFilterLink *link) { AVFilterContext *ctx = link->src; YADIFContext *yadif = ctx->priv; int ret; if (yadif->frame_pending) { return_frame(ctx, 1); return 0; } if (yadif->eof) return AVERROR_EOF; ret = ff_request_frame(ctx->inputs[0]); if (ret == AVERROR_EOF && yadif->cur) { AVFrame *next = av_frame_clone(yadif->next); if (!next) return AVERROR(ENOMEM); next->pts = yadif->next->pts * 2 - yadif->cur->pts; ff_yadif_filter_frame(ctx->inputs[0], next); yadif->eof = 1; } else if (ret < 0) { return ret; } return 0; }
static int request_frame(AVFilterLink *outlink) { FifoContext *fifo = outlink->src->priv; BufPic *tmp; int ret; if (!fifo->root.next) { if ((ret = ff_request_frame(outlink->src->inputs[0]) < 0)) return ret; } /* by doing this, we give ownership of the reference to the next filter, * so we don't have to worry about dereferencing it ourselves. */ ff_start_frame(outlink, fifo->root.next->picref); ff_draw_slice (outlink, 0, outlink->h, 1); ff_end_frame (outlink); if (fifo->last == fifo->root.next) fifo->last = &fifo->root; tmp = fifo->root.next->next; av_free(fifo->root.next); fifo->root.next = tmp; return 0; }
static int request_frame(AVFilterLink *outlink) { AVFilterContext *ctx = outlink->src; SelectContext *select = ctx->priv; AVFilterLink *inlink = outlink->src->inputs[0]; select->select = 0; if (av_fifo_size(select->pending_frames)) { AVFilterBufferRef *picref; av_fifo_generic_read(select->pending_frames, &picref, sizeof(picref), NULL); ff_start_frame(outlink, avfilter_ref_buffer(picref, ~0)); ff_draw_slice(outlink, 0, outlink->h, 1); ff_end_frame(outlink); avfilter_unref_buffer(picref); return 0; } while (!select->select) { int ret = ff_request_frame(inlink); if (ret < 0) return ret; } return 0; }
static int request_frame(AVFilterLink *outlink) { AVFilterContext *ctx = outlink->src; FPSContext *s = ctx->priv; int frames_out = s->frames_out; int ret = 0; while (ret >= 0 && s->frames_out == frames_out) ret = ff_request_frame(ctx->inputs[0]); /* flush the fifo */ if (ret == AVERROR_EOF && av_fifo_size(s->fifo)) { int i; for (i = 0; av_fifo_size(s->fifo); i++) { AVFrame *buf; av_fifo_generic_read(s->fifo, &buf, sizeof(buf), NULL); buf->pts = av_rescale_q(s->first_pts, ctx->inputs[0]->time_base, outlink->time_base) + s->frames_out; if ((ret = ff_filter_frame(outlink, buf)) < 0) return ret; s->frames_out++; } return 0; } return ret; }
static int request_frame(AVFilterLink *outlink) { AVFilterContext *ctx = outlink->src; SpectrumSynthContext *s = ctx->priv; int ret; if (!s->magnitude) { ret = ff_request_frame(ctx->inputs[0]); if (ret < 0) return ret; } if (!s->phase) { ret = ff_request_frame(ctx->inputs[1]); if (ret < 0) return ret; } return 0; }
int ff_request_frame(AVFilterLink *link) { FF_DPRINTF_START(NULL, request_frame); ff_dlog_link(NULL, link, 1); if (link->srcpad->request_frame) return link->srcpad->request_frame(link); else if (link->src->inputs[0]) return ff_request_frame(link->src->inputs[0]); else return -1; }
static int request_frame(AVFilterLink *outlink) { AVFilterContext *ctx = outlink->src; InterlaceContext *s = ctx->priv; int ret = 0; s->got_output = 0; while (ret >= 0 && !s->got_output) ret = ff_request_frame(ctx->inputs[0]); return ret; }
static int request_frame(AVFilterLink *link) { ThumbContext *thumb = link->src->priv; /* loop until a frame thumbnail is available (when a frame is queued, * thumb->n is reset to zero) */ do { int ret = ff_request_frame(link->src->inputs[0]); if (ret < 0) return ret; } while (thumb->n); return 0; }
static int request_frame(AVFilterLink *outlink) { AVFilterContext *ctx = outlink->src; BlackDetectContext *blackdetect = ctx->priv; AVFilterLink *inlink = ctx->inputs[0]; int ret = ff_request_frame(inlink); if (ret == AVERROR_EOF && blackdetect->black_started) { // FIXME: black_end should be set to last_picref_pts + last_picref_duration blackdetect->black_end = blackdetect->last_picref_pts; check_black_end(ctx); } return ret; }
static int request_frame(AVFilterLink *outlink) { AVFilterContext *ctx = outlink->src; SidechainCompressContext *s = ctx->priv; int i; /* get a frame on each input */ for (i = 0; i < 2; i++) { AVFilterLink *inlink = ctx->inputs[i]; if (!av_audio_fifo_size(s->fifo[i])) return ff_request_frame(inlink); } return 0; }
static int request_frame(AVFilterLink *outlink) { AVFilterContext *ctx = outlink->src; AlphaMergeContext *merge = ctx->priv; int in, ret; merge->frame_requested = 1; while (merge->frame_requested) { in = ff_bufqueue_peek(&merge->queue_main, 0) ? 1 : 0; ret = ff_request_frame(ctx->inputs[in]); if (ret < 0) return ret; } return 0; }
static int request_frame(AVFilterLink *outlink) { AVFilterContext *ctx = outlink->src; SelectContext *select = ctx->priv; AVFilterLink *inlink = outlink->src->inputs[0]; int out_no = FF_OUTLINK_IDX(outlink); do { int ret = ff_request_frame(inlink); if (ret < 0) return ret; } while (select->select_out != out_no); return 0; }
static int request_frame(AVFilterLink *outlink) { AVFilterContext *ctx = outlink->src; FramepackContext *s = ctx->priv; int ret, i; /* get a frame on the either input, stop as soon as a video ends */ for (i = 0; i < 2; i++) { if (!s->input_views[i]) { ret = ff_request_frame(ctx->inputs[i]); if (ret < 0) return ret; } } return 0; }
static int request_frame(AVFilterLink *outlink) { AVFilterContext *ctx = outlink->src; TrimContext *s = ctx->priv; int ret; s->got_output = 0; while (!s->got_output) { if (s->eof) return AVERROR_EOF; ret = ff_request_frame(ctx->inputs[0]); if (ret < 0) return ret; } return 0; }
int avfilter_graph_request_oldest(AVFilterGraph *graph) { while (graph->sink_links_count) { AVFilterLink *oldest = graph->sink_links[0]; int r = ff_request_frame(oldest); if (r != AVERROR_EOF) return r; av_log(oldest->dst, AV_LOG_DEBUG, "EOF on sink link %s:%s.\n", oldest->dst ? oldest->dst->name : "unknown", oldest->dstpad ? oldest->dstpad->name : "unknown"); /* EOF: remove the link from the heap */ if (oldest->age_index < --graph->sink_links_count) heap_bubble_down(graph, graph->sink_links[graph->sink_links_count], oldest->age_index); oldest->age_index = -1; } return AVERROR_EOF; }