History

lavfi: add error handling to filter_samples().

Anton Khirnov committed 14 years ago

Commit cd991461 parent 8d18bc515 files · +136 −69Browse files

Unified · Split

15 files
  1. libavfilter/af_amix.c +13 −9
  2. libavfilter/af_asyncts.c +22 −16
  3. libavfilter/af_channelmap.c +6 −4
  4. libavfilter/af_channelsplit.c +10 −5
  5. libavfilter/af_join.c +5 −3
  6. libavfilter/af_resample.c +19 −6
  7. libavfilter/asink_anullsink.c +4 −1
  8. libavfilter/audio.c +6 −6
  9. libavfilter/audio.h +4 −1
  10. libavfilter/avfilter.h +5 −1
  11. libavfilter/buffersink.c +7 −1
  12. libavfilter/buffersrc.c +3 −2
  13. libavfilter/fifo.c +18 −8
  14. libavfilter/internal.h +5 −1
  15. libavfilter/split.c +9 −5
libavfilter/af_amix.c+13−9
@@ -311,9 +311,7 @@ static int output_frame(AVFilterLink *outlink, int nb_samples) · 310 unmodified lines
311 if (s->next_pts != AV_NOPTS_VALUE)311 if (s->next_pts != AV_NOPTS_VALUE)
312 s->next_pts += nb_samples;312 s->next_pts += nb_samples;
313 313
314 ff_filter_samples(outlink, out_buf);314 return ff_filter_samples(outlink, out_buf);
315
316 return 0;
317}315}
318 316
319/**317/**
@@ -454,31 +452,37 @@ static int request_frame(AVFilterLink *outlink) · 134 unmodified lines
454 return output_frame(outlink, available_samples);452 return output_frame(outlink, available_samples);
455}453}
456 454
457static void filter_samples(AVFilterLink *inlink, AVFilterBufferRef *buf)455static int filter_samples(AVFilterLink *inlink, AVFilterBufferRef *buf)
458{456{
459 AVFilterContext *ctx = inlink->dst;457 AVFilterContext *ctx = inlink->dst;
460 MixContext *s = ctx->priv;458 MixContext *s = ctx->priv;
461 AVFilterLink *outlink = ctx->outputs[0];459 AVFilterLink *outlink = ctx->outputs[0];
462 int i;460 int i, ret = 0;
463 461
464 for (i = 0; i < ctx->nb_inputs; i++)462 for (i = 0; i < ctx->nb_inputs; i++)
465 if (ctx->inputs[i] == inlink)463 if (ctx->inputs[i] == inlink)
466 break;464 break;
467 if (i >= ctx->nb_inputs) {465 if (i >= ctx->nb_inputs) {
468 av_log(ctx, AV_LOG_ERROR, "unknown input link\n");466 av_log(ctx, AV_LOG_ERROR, "unknown input link\n");
469 return;467 ret = AVERROR(EINVAL);
468 goto fail;
470 }469 }
471 470
472 if (i == 0) {471 if (i == 0) {
473 int64_t pts = av_rescale_q(buf->pts, inlink->time_base,472 int64_t pts = av_rescale_q(buf->pts, inlink->time_base,
474 outlink->time_base);473 outlink->time_base);
475 frame_list_add_frame(s->frame_list, buf->audio->nb_samples, pts);474 ret = frame_list_add_frame(s->frame_list, buf->audio->nb_samples, pts);
475 if (ret < 0)
476 goto fail;
476 }477 }
477 478
478 av_audio_fifo_write(s->fifos[i], (void **)buf->extended_data,479 ret = av_audio_fifo_write(s->fifos[i], (void **)buf->extended_data,
479 buf->audio->nb_samples);480 buf->audio->nb_samples);
480 481
482fail:
481 avfilter_unref_buffer(buf);483 avfilter_unref_buffer(buf);
484
485 return ret;
482}486}
483 487
484static int init(AVFilterContext *ctx, const char *args)488static int init(AVFilterContext *ctx, const char *args)
libavfilter/af_asyncts.c+22−16
@@ -136,18 +136,18 @@ static int request_frame(AVFilterLink *link) · 135 unmodified lines
136 avresample_convert(s->avr, (void**)buf->extended_data, buf->linesize[0],136 avresample_convert(s->avr, (void**)buf->extended_data, buf->linesize[0],
137 nb_samples, NULL, 0, 0);137 nb_samples, NULL, 0, 0);
138 buf->pts = s->pts;138 buf->pts = s->pts;
139 ff_filter_samples(link, buf);139 return ff_filter_samples(link, buf);
140 return 0;
141 }140 }
142 141
143 return ret;142 return ret;
144}143}
145 144
146static void write_to_fifo(ASyncContext *s, AVFilterBufferRef *buf)145static int write_to_fifo(ASyncContext *s, AVFilterBufferRef *buf)
147{146{
148 avresample_convert(s->avr, NULL, 0, 0, (void**)buf->extended_data,147 int ret = avresample_convert(s->avr, NULL, 0, 0, (void**)buf->extended_data,
149 buf->linesize[0], buf->audio->nb_samples);148 buf->linesize[0], buf->audio->nb_samples);
150 avfilter_unref_buffer(buf);149 avfilter_unref_buffer(buf);
150 return ret;
151}151}
152 152
153/* get amount of data currently buffered, in samples */153/* get amount of data currently buffered, in samples */
@@ -156,7 +156,7 @@ static int64_t get_delay(ASyncContext *s) · 2 unmodified lines
156 return avresample_available(s->avr) + avresample_get_delay(s->avr);156 return avresample_available(s->avr) + avresample_get_delay(s->avr);
157}157}
158 158
159static void filter_samples(AVFilterLink *inlink, AVFilterBufferRef *buf)159static int filter_samples(AVFilterLink *inlink, AVFilterBufferRef *buf)
160{160{
161 AVFilterContext *ctx = inlink->dst;161 AVFilterContext *ctx = inlink->dst;
162 ASyncContext *s = ctx->priv;162 ASyncContext *s = ctx->priv;
@@ -164,7 +164,7 @@ static void filter_samples(AVFilterLink *inlink, AVFilterBufferRef *buf) · 1 unmodified line
164 int nb_channels = av_get_channel_layout_nb_channels(buf->audio->channel_layout);164 int nb_channels = av_get_channel_layout_nb_channels(buf->audio->channel_layout);
165 int64_t pts = (buf->pts == AV_NOPTS_VALUE) ? buf->pts :165 int64_t pts = (buf->pts == AV_NOPTS_VALUE) ? buf->pts :
166 av_rescale_q(buf->pts, inlink->time_base, outlink->time_base);166 av_rescale_q(buf->pts, inlink->time_base, outlink->time_base);
167 int out_size;167 int out_size, ret;
168 int64_t delta;168 int64_t delta;
169 169
170 /* buffer data until we get the first timestamp */170 /* buffer data until we get the first timestamp */
@@ -172,14 +172,12 @@ static void filter_samples(AVFilterLink *inlink, AVFilterBufferRef *buf) · 1 unmodified line
172 if (pts != AV_NOPTS_VALUE) {172 if (pts != AV_NOPTS_VALUE) {
173 s->pts = pts - get_delay(s);173 s->pts = pts - get_delay(s);
174 }174 }
175 write_to_fifo(s, buf);175 return write_to_fifo(s, buf);
176 return;
177 }176 }
178 177
179 /* now wait for the next timestamp */178 /* now wait for the next timestamp */
180 if (pts == AV_NOPTS_VALUE) {179 if (pts == AV_NOPTS_VALUE) {
181 write_to_fifo(s, buf);180 return write_to_fifo(s, buf);
182 return;
183 }181 }
184 182
185 /* when we have two timestamps, compute how many samples would we have183 /* when we have two timestamps, compute how many samples would we have
@@ -202,8 +200,10 @@ static void filter_samples(AVFilterLink *inlink, AVFilterBufferRef *buf) · 16 unmodified lines
202 if (out_size > 0) {200 if (out_size > 0) {
203 AVFilterBufferRef *buf_out = ff_get_audio_buffer(outlink, AV_PERM_WRITE,201 AVFilterBufferRef *buf_out = ff_get_audio_buffer(outlink, AV_PERM_WRITE,
204 out_size);202 out_size);
205 if (!buf_out)203 if (!buf_out) {
206 return;204 ret = AVERROR(ENOMEM);
205 goto fail;
206 }
207 207
208 avresample_read(s->avr, (void**)buf_out->extended_data, out_size);208 avresample_read(s->avr, (void**)buf_out->extended_data, out_size);
209 buf_out->pts = s->pts;209 buf_out->pts = s->pts;
@@ -212,7 +212,9 @@ static void filter_samples(AVFilterLink *inlink, AVFilterBufferRef *buf) · 2 unmodified lines
212 av_samples_set_silence(buf_out->extended_data, out_size - delta,212 av_samples_set_silence(buf_out->extended_data, out_size - delta,
213 delta, nb_channels, buf->format);213 delta, nb_channels, buf->format);
214 }214 }
215 ff_filter_samples(outlink, buf_out);215 ret = ff_filter_samples(outlink, buf_out);
216 if (ret < 0)
217 goto fail;
216 s->got_output = 1;218 s->got_output = 1;
217 } else {219 } else {
218 av_log(ctx, AV_LOG_WARNING, "Non-monotonous timestamps, dropping "220 av_log(ctx, AV_LOG_WARNING, "Non-monotonous timestamps, dropping "
@@ -223,9 +225,13 @@ static void filter_samples(AVFilterLink *inlink, AVFilterBufferRef *buf) · 4 unmodified lines
223 avresample_read(s->avr, NULL, avresample_available(s->avr));225 avresample_read(s->avr, NULL, avresample_available(s->avr));
224 226
225 s->pts = pts - avresample_get_delay(s->avr);227 s->pts = pts - avresample_get_delay(s->avr);
226 avresample_convert(s->avr, NULL, 0, 0, (void**)buf->extended_data,228 ret = avresample_convert(s->avr, NULL, 0, 0, (void**)buf->extended_data,
227 buf->linesize[0], buf->audio->nb_samples);229 buf->linesize[0], buf->audio->nb_samples);
230
231fail:
228 avfilter_unref_buffer(buf);232 avfilter_unref_buffer(buf);
233
234 return ret;
229}235}
230 236
231AVFilter avfilter_af_asyncts = {237AVFilter avfilter_af_asyncts = {
libavfilter/af_channelmap.c+6−4
@@ -313,7 +313,7 @@ static int channelmap_query_formats(AVFilterContext *ctx) · 312 unmodified lines
313 return 0;313 return 0;
314}314}
315 315
316static void channelmap_filter_samples(AVFilterLink *inlink, AVFilterBufferRef *buf)316static int channelmap_filter_samples(AVFilterLink *inlink, AVFilterBufferRef *buf)
317{317{
318 AVFilterContext *ctx = inlink->dst;318 AVFilterContext *ctx = inlink->dst;
319 AVFilterLink *outlink = ctx->outputs[0];319 AVFilterLink *outlink = ctx->outputs[0];
@@ -330,8 +330,10 @@ static void channelmap_filter_samples(AVFilterLink *inlink, AVFilterBufferRef *b · 10 unmodified lines
330 if (nch_out > FF_ARRAY_ELEMS(buf->data)) {330 if (nch_out > FF_ARRAY_ELEMS(buf->data)) {
331 uint8_t **new_extended_data =331 uint8_t **new_extended_data =
332 av_mallocz(nch_out * sizeof(*buf->extended_data));332 av_mallocz(nch_out * sizeof(*buf->extended_data));
333 if (!new_extended_data)333 if (!new_extended_data) {
334 return;334 avfilter_unref_buffer(buf);
335 return AVERROR(ENOMEM);
336 }
335 if (buf->extended_data == buf->data) {337 if (buf->extended_data == buf->data) {
336 buf->extended_data = new_extended_data;338 buf->extended_data = new_extended_data;
337 } else {339 } else {
@@ -353,7 +355,7 @@ static void channelmap_filter_samples(AVFilterLink *inlink, AVFilterBufferRef *b · 15 unmodified lines
353 memcpy(buf->data, buf->extended_data,355 memcpy(buf->data, buf->extended_data,
354 FFMIN(FF_ARRAY_ELEMS(buf->data), nch_out) * sizeof(buf->data[0]));356 FFMIN(FF_ARRAY_ELEMS(buf->data), nch_out) * sizeof(buf->data[0]));
355 357
356 ff_filter_samples(outlink, buf);358 return ff_filter_samples(outlink, buf);
357}359}
358 360
359static int channelmap_config_input(AVFilterLink *inlink)361static int channelmap_config_input(AVFilterLink *inlink)
libavfilter/af_channelsplit.c+10−5
@@ -110,24 +110,29 @@ static int query_formats(AVFilterContext *ctx) · 109 unmodified lines
110 return 0;110 return 0;
111}111}
112 112
113static void filter_samples(AVFilterLink *inlink, AVFilterBufferRef *buf)113static int filter_samples(AVFilterLink *inlink, AVFilterBufferRef *buf)
114{114{
115 AVFilterContext *ctx = inlink->dst;115 AVFilterContext *ctx = inlink->dst;
116 int i;116 int i, ret = 0;
117 117
118 for (i = 0; i < ctx->nb_outputs; i++) {118 for (i = 0; i < ctx->nb_outputs; i++) {
119 AVFilterBufferRef *buf_out = avfilter_ref_buffer(buf, ~AV_PERM_WRITE);119 AVFilterBufferRef *buf_out = avfilter_ref_buffer(buf, ~AV_PERM_WRITE);
120 120
121 if (!buf_out)121 if (!buf_out) {
122 return;122 ret = AVERROR(ENOMEM);
123 break;
124 }
123 125
124 buf_out->data[0] = buf_out->extended_data[0] = buf_out->extended_data[i];126 buf_out->data[0] = buf_out->extended_data[0] = buf_out->extended_data[i];
125 buf_out->audio->channel_layout =127 buf_out->audio->channel_layout =
126 av_channel_layout_extract_channel(buf->audio->channel_layout, i);128 av_channel_layout_extract_channel(buf->audio->channel_layout, i);
127 129
128 ff_filter_samples(ctx->outputs[i], buf_out);130 ret = ff_filter_samples(ctx->outputs[i], buf_out);
131 if (ret < 0)
132 break;
129 }133 }
130 avfilter_unref_buffer(buf);134 avfilter_unref_buffer(buf);
135 return ret;
131}136}
132 137
133AVFilter avfilter_af_channelsplit = {138AVFilter avfilter_af_channelsplit = {
libavfilter/af_join.c+5−3
@@ -92,7 +92,7 @@ static const AVClass join_class = { · 91 unmodified lines
92 .version = LIBAVUTIL_VERSION_INT,92 .version = LIBAVUTIL_VERSION_INT,
93};93};
94 94
95static void filter_samples(AVFilterLink *link, AVFilterBufferRef *buf)95static int filter_samples(AVFilterLink *link, AVFilterBufferRef *buf)
96{96{
97 AVFilterContext *ctx = link->dst;97 AVFilterContext *ctx = link->dst;
98 JoinContext *s = ctx->priv;98 JoinContext *s = ctx->priv;
@@ -104,6 +104,8 @@ static void filter_samples(AVFilterLink *link, AVFilterBufferRef *buf) · 5 unmodified lines
104 av_assert0(i < ctx->nb_inputs);104 av_assert0(i < ctx->nb_inputs);
105 av_assert0(!s->input_frames[i]);105 av_assert0(!s->input_frames[i]);
106 s->input_frames[i] = buf;106 s->input_frames[i] = buf;
107
108 return 0;
107}109}
108 110
109static int parse_maps(AVFilterContext *ctx)111static int parse_maps(AVFilterContext *ctx)
@@ -468,11 +470,11 @@ static int join_request_frame(AVFilterLink *outlink) · 358 unmodified lines
468 priv->nb_in_buffers = ctx->nb_inputs;470 priv->nb_in_buffers = ctx->nb_inputs;
469 buf->buf->priv = priv;471 buf->buf->priv = priv;
470 472
471 ff_filter_samples(outlink, buf);473 ret = ff_filter_samples(outlink, buf);
472 474
473 memset(s->input_frames, 0, sizeof(*s->input_frames) * ctx->nb_inputs);475 memset(s->input_frames, 0, sizeof(*s->input_frames) * ctx->nb_inputs);
474 476
475 return 0;477 return ret;
476 478
477fail:479fail:
478 avfilter_unref_buffer(buf);480 avfilter_unref_buffer(buf);
libavfilter/af_resample.c+19−6
@@ -157,21 +157,21 @@ static int request_frame(AVFilterLink *outlink) · 156 unmodified lines
157 }157 }
158 158
159 buf->pts = s->next_pts;159 buf->pts = s->next_pts;
160 ff_filter_samples(outlink, buf);160 return ff_filter_samples(outlink, buf);
161 return 0;
162 }161 }
163 return ret;162 return ret;
164}163}
165 164
166static void filter_samples(AVFilterLink *inlink, AVFilterBufferRef *buf)165static int filter_samples(AVFilterLink *inlink, AVFilterBufferRef *buf)
167{166{
168 AVFilterContext *ctx = inlink->dst;167 AVFilterContext *ctx = inlink->dst;
169 ResampleContext *s = ctx->priv;168 ResampleContext *s = ctx->priv;
170 AVFilterLink *outlink = ctx->outputs[0];169 AVFilterLink *outlink = ctx->outputs[0];
170 int ret;
171 171
172 if (s->avr) {172 if (s->avr) {
173 AVFilterBufferRef *buf_out;173 AVFilterBufferRef *buf_out;
174 int delay, nb_samples, ret;174 int delay, nb_samples;
175 175
176 /* maximum possible samples lavr can output */176 /* maximum possible samples lavr can output */
177 delay = avresample_get_delay(s->avr);177 delay = avresample_get_delay(s->avr);
@@ -180,10 +180,19 @@ static void filter_samples(AVFilterLink *inlink, AVFilterBufferRef *buf) · 2 unmodified lines
180 AV_ROUND_UP);180 AV_ROUND_UP);
181 181
182 buf_out = ff_get_audio_buffer(outlink, AV_PERM_WRITE, nb_samples);182 buf_out = ff_get_audio_buffer(outlink, AV_PERM_WRITE, nb_samples);
183 if (!buf_out) {
184 ret = AVERROR(ENOMEM);
185 goto fail;
186 }
187
183 ret = avresample_convert(s->avr, (void**)buf_out->extended_data,188 ret = avresample_convert(s->avr, (void**)buf_out->extended_data,
184 buf_out->linesize[0], nb_samples,189 buf_out->linesize[0], nb_samples,
185 (void**)buf->extended_data, buf->linesize[0],190 (void**)buf->extended_data, buf->linesize[0],
186 buf->audio->nb_samples);191 buf->audio->nb_samples);
192 if (ret < 0) {
193 avfilter_unref_buffer(buf_out);
194 goto fail;
195 }
187 196
188 av_assert0(!avresample_available(s->avr));197 av_assert0(!avresample_available(s->avr));
189 198
@@ -209,14 +218,18 @@ static void filter_samples(AVFilterLink *inlink, AVFilterBufferRef *buf) · 19 unmodified lines
209 218
210 s->next_pts = buf_out->pts + buf_out->audio->nb_samples;219 s->next_pts = buf_out->pts + buf_out->audio->nb_samples;
211 220
212 ff_filter_samples(outlink, buf_out);221 ret = ff_filter_samples(outlink, buf_out);
213 s->got_output = 1;222 s->got_output = 1;
214 }223 }
224
225fail:
215 avfilter_unref_buffer(buf);226 avfilter_unref_buffer(buf);
216 } else {227 } else {
217 ff_filter_samples(outlink, buf);228 ret = ff_filter_samples(outlink, buf);
218 s->got_output = 1;229 s->got_output = 1;
219 }230 }
231
232 return ret;
220}233}
221 234
222AVFilter avfilter_af_resample = {235AVFilter avfilter_af_resample = {
libavfilter/asink_anullsink.c+4−1
@@ -19,7 +19,10 @@ · 18 unmodified lines
19#include "avfilter.h"19#include "avfilter.h"
20#include "internal.h"20#include "internal.h"
21 21
22static void null_filter_samples(AVFilterLink *link, AVFilterBufferRef *samplesref) { }22static int null_filter_samples(AVFilterLink *link, AVFilterBufferRef *samplesref)
23{
24 return 0;
25}
23 26
24AVFilter avfilter_asink_anullsink = {27AVFilter avfilter_asink_anullsink = {
25 .name = "anullsink",28 .name = "anullsink",
libavfilter/audio.c+6−6
@@ -146,15 +146,15 @@ fail: · 145 unmodified lines
146 return NULL;146 return NULL;
147}147}
148 148
149static void default_filter_samples(AVFilterLink *link,149static int default_filter_samples(AVFilterLink *link,
150 AVFilterBufferRef *samplesref)150 AVFilterBufferRef *samplesref)
151{151{
152 ff_filter_samples(link->dst->outputs[0], samplesref);152 return ff_filter_samples(link->dst->outputs[0], samplesref);
153}153}
154 154
155void ff_filter_samples(AVFilterLink *link, AVFilterBufferRef *samplesref)155int ff_filter_samples(AVFilterLink *link, AVFilterBufferRef *samplesref)
156{156{
157 void (*filter_samples)(AVFilterLink *, AVFilterBufferRef *);157 int (*filter_samples)(AVFilterLink *, AVFilterBufferRef *);
158 AVFilterPad *dst = link->dstpad;158 AVFilterPad *dst = link->dstpad;
159 AVFilterBufferRef *buf_out;159 AVFilterBufferRef *buf_out;
160 160
@@ -185,6 +185,6 @@ void ff_filter_samples(AVFilterLink *link, AVFilterBufferRef *samplesref) · 24 unmodified lines
185 } else185 } else
186 buf_out = samplesref;186 buf_out = samplesref;
187 187
188 filter_samples(link, buf_out);188 return filter_samples(link, buf_out);
189}189}
190 190
libavfilter/audio.h+4−1
@@ -49,7 +49,10 @@ AVFilterBufferRef *ff_get_audio_buffer(AVFilterLink *link, int perms, · 48 unmodified lines
49 * @param samplesref a reference to the buffer of audio samples being sent. The49 * @param samplesref a reference to the buffer of audio samples being sent. The
50 * receiving filter will free this reference when it no longer50 * receiving filter will free this reference when it no longer
51 * needs it or pass it on to the next filter.51 * needs it or pass it on to the next filter.
52 *
53 * @return >= 0 on success, a negative AVERROR on error. The receiving filter
54 * is responsible for unreferencing samplesref in case of error.
52 */55 */
53void ff_filter_samples(AVFilterLink *link, AVFilterBufferRef *samplesref);56int ff_filter_samples(AVFilterLink *link, AVFilterBufferRef *samplesref);
54 57
55#endif /* AVFILTER_AUDIO_H */58#endif /* AVFILTER_AUDIO_H */
libavfilter/avfilter.h+5−1
@@ -288,8 +288,12 @@ struct AVFilterPad { · 287 unmodified lines
288 * and should do its processing.288 * and should do its processing.
289 *289 *
290 * Input audio pads only.290 * Input audio pads only.
291 *
292 * @return >= 0 on success, a negative AVERROR on error. This function
293 * must ensure that samplesref is properly unreferenced on error if it
294 * hasn't been passed on to another filter.
291 */295 */
292 void (*filter_samples)(AVFilterLink *link, AVFilterBufferRef *samplesref);296 int (*filter_samples)(AVFilterLink *link, AVFilterBufferRef *samplesref);
293 297
294 /**298 /**
295 * Frame poll callback. This returns the number of immediately available299 * Frame poll callback. This returns the number of immediately available
libavfilter/buffersink.c+7−1
@@ -56,6 +56,12 @@ static void start_frame(AVFilterLink *link, AVFilterBufferRef *buf) · 55 unmodified lines
56 link->cur_buf = NULL;56 link->cur_buf = NULL;
57};57};
58 58
59static int filter_samples(AVFilterLink *link, AVFilterBufferRef *buf)
60{
61 start_frame(link, buf);
62 return 0;
63}
64
59int av_buffersink_read(AVFilterContext *ctx, AVFilterBufferRef **buf)65int av_buffersink_read(AVFilterContext *ctx, AVFilterBufferRef **buf)
60{66{
61 BufferSinkContext *s = ctx->priv;67 BufferSinkContext *s = ctx->priv;
@@ -160,7 +166,7 @@ AVFilter avfilter_asink_abuffer = { · 98 unmodified lines
160 166
161 .inputs = (AVFilterPad[]) {{ .name = "default",167 .inputs = (AVFilterPad[]) {{ .name = "default",
162 .type = AVMEDIA_TYPE_AUDIO,168 .type = AVMEDIA_TYPE_AUDIO,
163 .filter_samples = start_frame,169 .filter_samples = filter_samples,
164 .min_perms = AV_PERM_READ,170 .min_perms = AV_PERM_READ,
165 .needs_fifo = 1 },171 .needs_fifo = 1 },
166 { .name = NULL }},172 { .name = NULL }},
libavfilter/buffersrc.c+3−2
@@ -312,6 +312,7 @@ static int request_frame(AVFilterLink *link) · 311 unmodified lines
312{312{
313 BufferSourceContext *c = link->src->priv;313 BufferSourceContext *c = link->src->priv;
314 AVFilterBufferRef *buf;314 AVFilterBufferRef *buf;
315 int ret = 0;
315 316
316 if (!av_fifo_size(c->fifo)) {317 if (!av_fifo_size(c->fifo)) {
317 if (c->eof)318 if (c->eof)
@@ -327,7 +328,7 @@ static int request_frame(AVFilterLink *link) · 9 unmodified lines
327 ff_end_frame(link);328 ff_end_frame(link);
328 break;329 break;
329 case AVMEDIA_TYPE_AUDIO:330 case AVMEDIA_TYPE_AUDIO:
330 ff_filter_samples(link, avfilter_ref_buffer(buf, ~0));331 ret = ff_filter_samples(link, avfilter_ref_buffer(buf, ~0));
331 break;332 break;
332 default:333 default:
333 return AVERROR(EINVAL);334 return AVERROR(EINVAL);
@@ -335,7 +336,7 @@ static int request_frame(AVFilterLink *link) · 1 unmodified line
335 336
336 avfilter_unref_buffer(buf);337 avfilter_unref_buffer(buf);
337 338
338 return 0;339 return ret;
339}340}
340 341
341static int poll_frame(AVFilterLink *link)342static int poll_frame(AVFilterLink *link)
libavfilter/fifo.c+18−8
@@ -72,13 +72,25 @@ static av_cold void uninit(AVFilterContext *ctx) · 71 unmodified lines
72 avfilter_unref_buffer(fifo->buf_out);72 avfilter_unref_buffer(fifo->buf_out);
73}73}
74 74
75static void add_to_queue(AVFilterLink *inlink, AVFilterBufferRef *buf)75static int add_to_queue(AVFilterLink *inlink, AVFilterBufferRef *buf)
76{76{
77 FifoContext *fifo = inlink->dst->priv;77 FifoContext *fifo = inlink->dst->priv;
78 78
79 fifo->last->next = av_mallocz(sizeof(Buf));79 fifo->last->next = av_mallocz(sizeof(Buf));
80 if (!fifo->last->next) {
81 avfilter_unref_buffer(buf);
82 return AVERROR(ENOMEM);
83 }
84
80 fifo->last = fifo->last->next;85 fifo->last = fifo->last->next;
81 fifo->last->buf = buf;86 fifo->last->buf = buf;
87
88 return 0;
89}
90
91static void start_frame(AVFilterLink *inlink, AVFilterBufferRef *buf)
92{
93 add_to_queue(inlink, buf);
82}94}
83 95
84static void queue_pop(FifoContext *s)96static void queue_pop(FifoContext *s)
@@ -210,15 +222,13 @@ static int return_audio_frame(AVFilterContext *ctx) · 125 unmodified lines
210 buf_out = s->buf_out;222 buf_out = s->buf_out;
211 s->buf_out = NULL;223 s->buf_out = NULL;
212 }224 }
213 ff_filter_samples(link, buf_out);225 return ff_filter_samples(link, buf_out);
214
215 return 0;
216}226}
217 227
218static int request_frame(AVFilterLink *outlink)228static int request_frame(AVFilterLink *outlink)
219{229{
220 FifoContext *fifo = outlink->src->priv;230 FifoContext *fifo = outlink->src->priv;
221 int ret;231 int ret = 0;
222 232
223 if (!fifo->root.next) {233 if (!fifo->root.next) {
224 if ((ret = ff_request_frame(outlink->src->inputs[0])) < 0)234 if ((ret = ff_request_frame(outlink->src->inputs[0])) < 0)
@@ -238,7 +248,7 @@ static int request_frame(AVFilterLink *outlink) · 13 unmodified lines
238 if (outlink->request_samples) {248 if (outlink->request_samples) {
239 return return_audio_frame(outlink->src);249 return return_audio_frame(outlink->src);
240 } else {250 } else {
241 ff_filter_samples(outlink, fifo->root.next->buf);251 ret = ff_filter_samples(outlink, fifo->root.next->buf);
242 queue_pop(fifo);252 queue_pop(fifo);
243 }253 }
244 break;254 break;
@@ -246,7 +256,7 @@ static int request_frame(AVFilterLink *outlink) · 1 unmodified line
246 return AVERROR(EINVAL);256 return AVERROR(EINVAL);
247 }257 }
248 258
249 return 0;259 return ret;
250}260}
251 261
252AVFilter avfilter_vf_fifo = {262AVFilter avfilter_vf_fifo = {
@@ -261,7 +271,7 @@ AVFilter avfilter_vf_fifo = { · 8 unmodified lines
261 .inputs = (AVFilterPad[]) {{ .name = "default",271 .inputs = (AVFilterPad[]) {{ .name = "default",
262 .type = AVMEDIA_TYPE_VIDEO,272 .type = AVMEDIA_TYPE_VIDEO,
263 .get_video_buffer= ff_null_get_video_buffer,273 .get_video_buffer= ff_null_get_video_buffer,
264 .start_frame = add_to_queue,274 .start_frame = start_frame,
265 .draw_slice = draw_slice,275 .draw_slice = draw_slice,
266 .end_frame = end_frame,276 .end_frame = end_frame,
267 .rej_perms = AV_PERM_REUSE2, },277 .rej_perms = AV_PERM_REUSE2, },
libavfilter/internal.h+5−1
@@ -111,8 +111,12 @@ struct AVFilterPad { · 110 unmodified lines
111 * and should do its processing.111 * and should do its processing.
112 *112 *
113 * Input audio pads only.113 * Input audio pads only.
114 *
115 * @return >= 0 on success, a negative AVERROR on error. This function
116 * must ensure that samplesref is properly unreferenced on error if it
117 * hasn't been passed on to another filter.
114 */118 */
115 void (*filter_samples)(AVFilterLink *link, AVFilterBufferRef *samplesref);119 int (*filter_samples)(AVFilterLink *link, AVFilterBufferRef *samplesref);
116 120
117 /**121 /**
118 * Frame poll callback. This returns the number of immediately available122 * Frame poll callback. This returns the number of immediately available
libavfilter/split.c+9−5
@@ -110,15 +110,19 @@ AVFilter avfilter_vf_split = { · 109 unmodified lines
110 .outputs = (AVFilterPad[]) {{ .name = NULL}},110 .outputs = (AVFilterPad[]) {{ .name = NULL}},
111};111};
112 112
113static void filter_samples(AVFilterLink *inlink, AVFilterBufferRef *samplesref)113static int filter_samples(AVFilterLink *inlink, AVFilterBufferRef *samplesref)
114{114{
115 AVFilterContext *ctx = inlink->dst;115 AVFilterContext *ctx = inlink->dst;
116 int i;116 int i, ret = 0;
117 117
118 for (i = 0; i < ctx->nb_outputs; i++)118 for (i = 0; i < ctx->nb_outputs; i++) {
119 ff_filter_samples(inlink->dst->outputs[i],119 ret = ff_filter_samples(inlink->dst->outputs[i],
120 avfilter_ref_buffer(samplesref, ~AV_PERM_WRITE));120 avfilter_ref_buffer(samplesref, ~AV_PERM_WRITE));
121 if (ret < 0)
122 break;
123 }
121 avfilter_unref_buffer(samplesref);124 avfilter_unref_buffer(samplesref);
125 return ret;
122}126}
123 127
124AVFilter avfilter_af_asplit = {128AVFilter avfilter_af_asplit = {

Keyboard shortcuts

General

Show keyboard shortcuts
?
Focus the current search
/

Issues and pull requests

Open filters
f

Issues, pull requests and Inbox

Select next item
j↓
Select previous item
k↑
Open selected item
Enter
Dismiss filters or clear selection
Esc

Repository code

Go to file
t