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
311311 if (s->next_pts != AV_NOPTS_VALUE)
312312 s->next_pts += nb_samples;
313313
314− ff_filter_samples(outlink, out_buf);
315−
316− return 0;
314+ return ff_filter_samples(outlink, out_buf);
317315 }
318316
319317 /**
@@ -454,31 +452,37 @@ static int request_frame(AVFilterLink *outlink) · 134 unmodified lines
454452 return output_frame(outlink, available_samples);
455453 }
456454
457−static void filter_samples(AVFilterLink *inlink, AVFilterBufferRef *buf)
455+static int filter_samples(AVFilterLink *inlink, AVFilterBufferRef *buf)
458456 {
459457 AVFilterContext *ctx = inlink->dst;
460458 MixContext *s = ctx->priv;
461459 AVFilterLink *outlink = ctx->outputs[0];
462− int i;
460+ int i, ret = 0;
463461
464462 for (i = 0; i < ctx->nb_inputs; i++)
465463 if (ctx->inputs[i] == inlink)
466464 break;
467465 if (i >= ctx->nb_inputs) {
468466 av_log(ctx, AV_LOG_ERROR, "unknown input link\n");
469− return;
467+ ret = AVERROR(EINVAL);
468+ goto fail;
470469 }
471470
472471 if (i == 0) {
473472 int64_t pts = av_rescale_q(buf->pts, inlink->time_base,
474473 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;
476477 }
477478
478− av_audio_fifo_write(s->fifos[i], (void **)buf->extended_data,
479− buf->audio->nb_samples);
479+ ret = av_audio_fifo_write(s->fifos[i], (void **)buf->extended_data,
480+ buf->audio->nb_samples);
480481
482+fail:
481483 avfilter_unref_buffer(buf);
484+
485+ return ret;
482486 }
483487
484488 static 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
136136 avresample_convert(s->avr, (void**)buf->extended_data, buf->linesize[0],
137137 nb_samples, NULL, 0, 0);
138138 buf->pts = s->pts;
139− ff_filter_samples(link, buf);
140− return 0;
139+ return ff_filter_samples(link, buf);
141140 }
142141
143142 return ret;
144143 }
145144
146−static void write_to_fifo(ASyncContext *s, AVFilterBufferRef *buf)
145+static int write_to_fifo(ASyncContext *s, AVFilterBufferRef *buf)
147146 {
148− avresample_convert(s->avr, NULL, 0, 0, (void**)buf->extended_data,
149− buf->linesize[0], buf->audio->nb_samples);
147+ int ret = avresample_convert(s->avr, NULL, 0, 0, (void**)buf->extended_data,
148+ buf->linesize[0], buf->audio->nb_samples);
150149 avfilter_unref_buffer(buf);
150+ return ret;
151151 }
152152
153153 /* get amount of data currently buffered, in samples */
@@ -156,7 +156,7 @@ static int64_t get_delay(ASyncContext *s) · 2 unmodified lines
156156 return avresample_available(s->avr) + avresample_get_delay(s->avr);
157157 }
158158
159−static void filter_samples(AVFilterLink *inlink, AVFilterBufferRef *buf)
159+static int filter_samples(AVFilterLink *inlink, AVFilterBufferRef *buf)
160160 {
161161 AVFilterContext *ctx = inlink->dst;
162162 ASyncContext *s = ctx->priv;
@@ -164,7 +164,7 @@ static void filter_samples(AVFilterLink *inlink, AVFilterBufferRef *buf) · 1 unmodified line
164164 int nb_channels = av_get_channel_layout_nb_channels(buf->audio->channel_layout);
165165 int64_t pts = (buf->pts == AV_NOPTS_VALUE) ? buf->pts :
166166 av_rescale_q(buf->pts, inlink->time_base, outlink->time_base);
167− int out_size;
167+ int out_size, ret;
168168 int64_t delta;
169169
170170 /* buffer data until we get the first timestamp */
@@ -172,14 +172,12 @@ static void filter_samples(AVFilterLink *inlink, AVFilterBufferRef *buf) · 1 unmodified line
172172 if (pts != AV_NOPTS_VALUE) {
173173 s->pts = pts - get_delay(s);
174174 }
175− write_to_fifo(s, buf);
176− return;
175+ return write_to_fifo(s, buf);
177176 }
178177
179178 /* now wait for the next timestamp */
180179 if (pts == AV_NOPTS_VALUE) {
181− write_to_fifo(s, buf);
182− return;
180+ return write_to_fifo(s, buf);
183181 }
184182
185183 /* 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
202200 if (out_size > 0) {
203201 AVFilterBufferRef *buf_out = ff_get_audio_buffer(outlink, AV_PERM_WRITE,
204202 out_size);
205− if (!buf_out)
206− return;
203+ if (!buf_out) {
204+ ret = AVERROR(ENOMEM);
205+ goto fail;
206+ }
207207
208208 avresample_read(s->avr, (void**)buf_out->extended_data, out_size);
209209 buf_out->pts = s->pts;
@@ -212,7 +212,9 @@ static void filter_samples(AVFilterLink *inlink, AVFilterBufferRef *buf) · 2 unmodified lines
212212 av_samples_set_silence(buf_out->extended_data, out_size - delta,
213213 delta, nb_channels, buf->format);
214214 }
215− ff_filter_samples(outlink, buf_out);
215+ ret = ff_filter_samples(outlink, buf_out);
216+ if (ret < 0)
217+ goto fail;
216218 s->got_output = 1;
217219 } else {
218220 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
223225 avresample_read(s->avr, NULL, avresample_available(s->avr));
224226
225227 s->pts = pts - avresample_get_delay(s->avr);
226− avresample_convert(s->avr, NULL, 0, 0, (void**)buf->extended_data,
227− buf->linesize[0], buf->audio->nb_samples);
228+ ret = avresample_convert(s->avr, NULL, 0, 0, (void**)buf->extended_data,
229+ buf->linesize[0], buf->audio->nb_samples);
230+
231+fail:
228232 avfilter_unref_buffer(buf);
233+
234+ return ret;
229235 }
230236
231237 AVFilter avfilter_af_asyncts = {
libavfilter/af_channelmap.c+6−4
@@ -313,7 +313,7 @@ static int channelmap_query_formats(AVFilterContext *ctx) · 312 unmodified lines
313313 return 0;
314314 }
315315
316−static void channelmap_filter_samples(AVFilterLink *inlink, AVFilterBufferRef *buf)
316+static int channelmap_filter_samples(AVFilterLink *inlink, AVFilterBufferRef *buf)
317317 {
318318 AVFilterContext *ctx = inlink->dst;
319319 AVFilterLink *outlink = ctx->outputs[0];
@@ -330,8 +330,10 @@ static void channelmap_filter_samples(AVFilterLink *inlink, AVFilterBufferRef *b · 10 unmodified lines
330330 if (nch_out > FF_ARRAY_ELEMS(buf->data)) {
331331 uint8_t **new_extended_data =
332332 av_mallocz(nch_out * sizeof(*buf->extended_data));
333− if (!new_extended_data)
334− return;
333+ if (!new_extended_data) {
334+ avfilter_unref_buffer(buf);
335+ return AVERROR(ENOMEM);
336+ }
335337 if (buf->extended_data == buf->data) {
336338 buf->extended_data = new_extended_data;
337339 } else {
@@ -353,7 +355,7 @@ static void channelmap_filter_samples(AVFilterLink *inlink, AVFilterBufferRef *b · 15 unmodified lines
353355 memcpy(buf->data, buf->extended_data,
354356 FFMIN(FF_ARRAY_ELEMS(buf->data), nch_out) * sizeof(buf->data[0]));
355357
356− ff_filter_samples(outlink, buf);
358+ return ff_filter_samples(outlink, buf);
357359 }
358360
359361 static 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
110110 return 0;
111111 }
112112
113−static void filter_samples(AVFilterLink *inlink, AVFilterBufferRef *buf)
113+static int filter_samples(AVFilterLink *inlink, AVFilterBufferRef *buf)
114114 {
115115 AVFilterContext *ctx = inlink->dst;
116− int i;
116+ int i, ret = 0;
117117
118118 for (i = 0; i < ctx->nb_outputs; i++) {
119119 AVFilterBufferRef *buf_out = avfilter_ref_buffer(buf, ~AV_PERM_WRITE);
120120
121− if (!buf_out)
122− return;
121+ if (!buf_out) {
122+ ret = AVERROR(ENOMEM);
123+ break;
124+ }
123125
124126 buf_out->data[0] = buf_out->extended_data[0] = buf_out->extended_data[i];
125127 buf_out->audio->channel_layout =
126128 av_channel_layout_extract_channel(buf->audio->channel_layout, i);
127129
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;
129133 }
130134 avfilter_unref_buffer(buf);
135+ return ret;
131136 }
132137
133138 AVFilter avfilter_af_channelsplit = {
libavfilter/af_join.c+5−3
@@ -92,7 +92,7 @@ static const AVClass join_class = { · 91 unmodified lines
9292 .version = LIBAVUTIL_VERSION_INT,
9393 };
9494
95−static void filter_samples(AVFilterLink *link, AVFilterBufferRef *buf)
95+static int filter_samples(AVFilterLink *link, AVFilterBufferRef *buf)
9696 {
9797 AVFilterContext *ctx = link->dst;
9898 JoinContext *s = ctx->priv;
@@ -104,6 +104,8 @@ static void filter_samples(AVFilterLink *link, AVFilterBufferRef *buf) · 5 unmodified lines
104104 av_assert0(i < ctx->nb_inputs);
105105 av_assert0(!s->input_frames[i]);
106106 s->input_frames[i] = buf;
107+
108+ return 0;
107109 }
108110
109111 static int parse_maps(AVFilterContext *ctx)
@@ -468,11 +470,11 @@ static int join_request_frame(AVFilterLink *outlink) · 358 unmodified lines
468470 priv->nb_in_buffers = ctx->nb_inputs;
469471 buf->buf->priv = priv;
470472
471− ff_filter_samples(outlink, buf);
473+ ret = ff_filter_samples(outlink, buf);
472474
473475 memset(s->input_frames, 0, sizeof(*s->input_frames) * ctx->nb_inputs);
474476
475− return 0;
477+ return ret;
476478
477479 fail:
478480 avfilter_unref_buffer(buf);
libavfilter/af_resample.c+19−6
@@ -157,21 +157,21 @@ static int request_frame(AVFilterLink *outlink) · 156 unmodified lines
157157 }
158158
159159 buf->pts = s->next_pts;
160− ff_filter_samples(outlink, buf);
161− return 0;
160+ return ff_filter_samples(outlink, buf);
162161 }
163162 return ret;
164163 }
165164
166−static void filter_samples(AVFilterLink *inlink, AVFilterBufferRef *buf)
165+static int filter_samples(AVFilterLink *inlink, AVFilterBufferRef *buf)
167166 {
168167 AVFilterContext *ctx = inlink->dst;
169168 ResampleContext *s = ctx->priv;
170169 AVFilterLink *outlink = ctx->outputs[0];
170+ int ret;
171171
172172 if (s->avr) {
173173 AVFilterBufferRef *buf_out;
174− int delay, nb_samples, ret;
174+ int delay, nb_samples;
175175
176176 /* maximum possible samples lavr can output */
177177 delay = avresample_get_delay(s->avr);
@@ -180,10 +180,19 @@ static void filter_samples(AVFilterLink *inlink, AVFilterBufferRef *buf) · 2 unmodified lines
180180 AV_ROUND_UP);
181181
182182 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+
183188 ret = avresample_convert(s->avr, (void**)buf_out->extended_data,
184189 buf_out->linesize[0], nb_samples,
185190 (void**)buf->extended_data, buf->linesize[0],
186191 buf->audio->nb_samples);
192+ if (ret < 0) {
193+ avfilter_unref_buffer(buf_out);
194+ goto fail;
195+ }
187196
188197 av_assert0(!avresample_available(s->avr));
189198
@@ -209,14 +218,18 @@ static void filter_samples(AVFilterLink *inlink, AVFilterBufferRef *buf) · 19 unmodified lines
209218
210219 s->next_pts = buf_out->pts + buf_out->audio->nb_samples;
211220
212− ff_filter_samples(outlink, buf_out);
221+ ret = ff_filter_samples(outlink, buf_out);
213222 s->got_output = 1;
214223 }
224+
225+fail:
215226 avfilter_unref_buffer(buf);
216227 } else {
217− ff_filter_samples(outlink, buf);
228+ ret = ff_filter_samples(outlink, buf);
218229 s->got_output = 1;
219230 }
231+
232+ return ret;
220233 }
221234
222235 AVFilter avfilter_af_resample = {
libavfilter/asink_anullsink.c+4−1
@@ -19,7 +19,10 @@ · 18 unmodified lines
1919 #include "avfilter.h"
2020 #include "internal.h"
2121
22−static void null_filter_samples(AVFilterLink *link, AVFilterBufferRef *samplesref) { }
22+static int null_filter_samples(AVFilterLink *link, AVFilterBufferRef *samplesref)
23+{
24+ return 0;
25+}
2326
2427 AVFilter avfilter_asink_anullsink = {
2528 .name = "anullsink",
libavfilter/audio.c+6−6
@@ -146,15 +146,15 @@ fail: · 145 unmodified lines
146146 return NULL;
147147 }
148148
149−static void default_filter_samples(AVFilterLink *link,
150− AVFilterBufferRef *samplesref)
149+static int default_filter_samples(AVFilterLink *link,
150+ AVFilterBufferRef *samplesref)
151151 {
152− ff_filter_samples(link->dst->outputs[0], samplesref);
152+ return ff_filter_samples(link->dst->outputs[0], samplesref);
153153 }
154154
155−void ff_filter_samples(AVFilterLink *link, AVFilterBufferRef *samplesref)
155+int ff_filter_samples(AVFilterLink *link, AVFilterBufferRef *samplesref)
156156 {
157− void (*filter_samples)(AVFilterLink *, AVFilterBufferRef *);
157+ int (*filter_samples)(AVFilterLink *, AVFilterBufferRef *);
158158 AVFilterPad *dst = link->dstpad;
159159 AVFilterBufferRef *buf_out;
160160
@@ -185,6 +185,6 @@ void ff_filter_samples(AVFilterLink *link, AVFilterBufferRef *samplesref) · 24 unmodified lines
185185 } else
186186 buf_out = samplesref;
187187
188− filter_samples(link, buf_out);
188+ return filter_samples(link, buf_out);
189189 }
190190
libavfilter/audio.h+4−1
@@ -49,7 +49,10 @@ AVFilterBufferRef *ff_get_audio_buffer(AVFilterLink *link, int perms, · 48 unmodified lines
4949 * @param samplesref a reference to the buffer of audio samples being sent. The
5050 * receiving filter will free this reference when it no longer
5151 * 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.
5255 */
53−void ff_filter_samples(AVFilterLink *link, AVFilterBufferRef *samplesref);
56+int ff_filter_samples(AVFilterLink *link, AVFilterBufferRef *samplesref);
5457
5558 #endif /* AVFILTER_AUDIO_H */
libavfilter/avfilter.h+5−1
@@ -288,8 +288,12 @@ struct AVFilterPad { · 287 unmodified lines
288288 * and should do its processing.
289289 *
290290 * 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.
291295 */
292− void (*filter_samples)(AVFilterLink *link, AVFilterBufferRef *samplesref);
296+ int (*filter_samples)(AVFilterLink *link, AVFilterBufferRef *samplesref);
293297
294298 /**
295299 * 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
5656 link->cur_buf = NULL;
5757 };
5858
59+static int filter_samples(AVFilterLink *link, AVFilterBufferRef *buf)
60+{
61+ start_frame(link, buf);
62+ return 0;
63+}
64+
5965 int av_buffersink_read(AVFilterContext *ctx, AVFilterBufferRef **buf)
6066 {
6167 BufferSinkContext *s = ctx->priv;
@@ -160,7 +166,7 @@ AVFilter avfilter_asink_abuffer = { · 98 unmodified lines
160166
161167 .inputs = (AVFilterPad[]) {{ .name = "default",
162168 .type = AVMEDIA_TYPE_AUDIO,
163− .filter_samples = start_frame,
169+ .filter_samples = filter_samples,
164170 .min_perms = AV_PERM_READ,
165171 .needs_fifo = 1 },
166172 { .name = NULL }},
libavfilter/buffersrc.c+3−2
@@ -312,6 +312,7 @@ static int request_frame(AVFilterLink *link) · 311 unmodified lines
312312 {
313313 BufferSourceContext *c = link->src->priv;
314314 AVFilterBufferRef *buf;
315+ int ret = 0;
315316
316317 if (!av_fifo_size(c->fifo)) {
317318 if (c->eof)
@@ -327,7 +328,7 @@ static int request_frame(AVFilterLink *link) · 9 unmodified lines
327328 ff_end_frame(link);
328329 break;
329330 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));
331332 break;
332333 default:
333334 return AVERROR(EINVAL);
@@ -335,7 +336,7 @@ static int request_frame(AVFilterLink *link) · 1 unmodified line
335336
336337 avfilter_unref_buffer(buf);
337338
338− return 0;
339+ return ret;
339340 }
340341
341342 static int poll_frame(AVFilterLink *link)
libavfilter/fifo.c+18−8
@@ -72,13 +72,25 @@ static av_cold void uninit(AVFilterContext *ctx) · 71 unmodified lines
7272 avfilter_unref_buffer(fifo->buf_out);
7373 }
7474
75−static void add_to_queue(AVFilterLink *inlink, AVFilterBufferRef *buf)
75+static int add_to_queue(AVFilterLink *inlink, AVFilterBufferRef *buf)
7676 {
7777 FifoContext *fifo = inlink->dst->priv;
7878
7979 fifo->last->next = av_mallocz(sizeof(Buf));
80+ if (!fifo->last->next) {
81+ avfilter_unref_buffer(buf);
82+ return AVERROR(ENOMEM);
83+ }
84+
8085 fifo->last = fifo->last->next;
8186 fifo->last->buf = buf;
87+
88+ return 0;
89+}
90+
91+static void start_frame(AVFilterLink *inlink, AVFilterBufferRef *buf)
92+{
93+ add_to_queue(inlink, buf);
8294 }
8395
8496 static void queue_pop(FifoContext *s)
@@ -210,15 +222,13 @@ static int return_audio_frame(AVFilterContext *ctx) · 125 unmodified lines
210222 buf_out = s->buf_out;
211223 s->buf_out = NULL;
212224 }
213− ff_filter_samples(link, buf_out);
214−
215− return 0;
225+ return ff_filter_samples(link, buf_out);
216226 }
217227
218228 static int request_frame(AVFilterLink *outlink)
219229 {
220230 FifoContext *fifo = outlink->src->priv;
221− int ret;
231+ int ret = 0;
222232
223233 if (!fifo->root.next) {
224234 if ((ret = ff_request_frame(outlink->src->inputs[0])) < 0)
@@ -238,7 +248,7 @@ static int request_frame(AVFilterLink *outlink) · 13 unmodified lines
238248 if (outlink->request_samples) {
239249 return return_audio_frame(outlink->src);
240250 } else {
241− ff_filter_samples(outlink, fifo->root.next->buf);
251+ ret = ff_filter_samples(outlink, fifo->root.next->buf);
242252 queue_pop(fifo);
243253 }
244254 break;
@@ -246,7 +256,7 @@ static int request_frame(AVFilterLink *outlink) · 1 unmodified line
246256 return AVERROR(EINVAL);
247257 }
248258
249− return 0;
259+ return ret;
250260 }
251261
252262 AVFilter avfilter_vf_fifo = {
@@ -261,7 +271,7 @@ AVFilter avfilter_vf_fifo = { · 8 unmodified lines
261271 .inputs = (AVFilterPad[]) {{ .name = "default",
262272 .type = AVMEDIA_TYPE_VIDEO,
263273 .get_video_buffer= ff_null_get_video_buffer,
264− .start_frame = add_to_queue,
274+ .start_frame = start_frame,
265275 .draw_slice = draw_slice,
266276 .end_frame = end_frame,
267277 .rej_perms = AV_PERM_REUSE2, },
libavfilter/internal.h+5−1
@@ -111,8 +111,12 @@ struct AVFilterPad { · 110 unmodified lines
111111 * and should do its processing.
112112 *
113113 * 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.
114118 */
115− void (*filter_samples)(AVFilterLink *link, AVFilterBufferRef *samplesref);
119+ int (*filter_samples)(AVFilterLink *link, AVFilterBufferRef *samplesref);
116120
117121 /**
118122 * 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
110110 .outputs = (AVFilterPad[]) {{ .name = NULL}},
111111 };
112112
113−static void filter_samples(AVFilterLink *inlink, AVFilterBufferRef *samplesref)
113+static int filter_samples(AVFilterLink *inlink, AVFilterBufferRef *samplesref)
114114 {
115115 AVFilterContext *ctx = inlink->dst;
116− int i;
116+ int i, ret = 0;
117117
118− for (i = 0; i < ctx->nb_outputs; i++)
119− ff_filter_samples(inlink->dst->outputs[i],
120− avfilter_ref_buffer(samplesref, ~AV_PERM_WRITE));
118+ for (i = 0; i < ctx->nb_outputs; i++) {
119+ ret = ff_filter_samples(inlink->dst->outputs[i],
120+ avfilter_ref_buffer(samplesref, ~AV_PERM_WRITE));
121+ if (ret < 0)
122+ break;
123+ }
121124 avfilter_unref_buffer(samplesref);
125+ return ret;
122126 }
123127
124128 AVFilter 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