Unified · Split
| @@ -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 | ||
| 457 | static void filter_samples(AVFilterLink *inlink, AVFilterBufferRef *buf) | 455 | static 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 | ||
| 482 | fail: | ||
| 481 | avfilter_unref_buffer(buf); | 483 | avfilter_unref_buffer(buf); |
| 484 | |||
| 485 | return ret; | ||
| 482 | } | 486 | } |
| 483 | 487 | ||
| 484 | static int init(AVFilterContext *ctx, const char *args) | 488 | static int init(AVFilterContext *ctx, const char *args) |
| @@ -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 | ||
| 146 | static void write_to_fifo(ASyncContext *s, AVFilterBufferRef *buf) | 145 | static 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 | ||
| 159 | static void filter_samples(AVFilterLink *inlink, AVFilterBufferRef *buf) | 159 | static 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 have | 183 | /* 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 | |||
| 231 | fail: | ||
| 228 | avfilter_unref_buffer(buf); | 232 | avfilter_unref_buffer(buf); |
| 233 | |||
| 234 | return ret; | ||
| 229 | } | 235 | } |
| 230 | 236 | ||
| 231 | AVFilter avfilter_af_asyncts = { | 237 | AVFilter avfilter_af_asyncts = { |
| @@ -313,7 +313,7 @@ static int channelmap_query_formats(AVFilterContext *ctx) · 312 unmodified lines | |||
| 313 | return 0; | 313 | return 0; |
| 314 | } | 314 | } |
| 315 | 315 | ||
| 316 | static void channelmap_filter_samples(AVFilterLink *inlink, AVFilterBufferRef *buf) | 316 | static 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 | ||
| 359 | static int channelmap_config_input(AVFilterLink *inlink) | 361 | static int channelmap_config_input(AVFilterLink *inlink) |
| @@ -110,24 +110,29 @@ static int query_formats(AVFilterContext *ctx) · 109 unmodified lines | |||
| 110 | return 0; | 110 | return 0; |
| 111 | } | 111 | } |
| 112 | 112 | ||
| 113 | static void filter_samples(AVFilterLink *inlink, AVFilterBufferRef *buf) | 113 | static 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 | ||
| 133 | AVFilter avfilter_af_channelsplit = { | 138 | AVFilter avfilter_af_channelsplit = { |
| @@ -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 | ||
| 95 | static void filter_samples(AVFilterLink *link, AVFilterBufferRef *buf) | 95 | static 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 | ||
| 109 | static int parse_maps(AVFilterContext *ctx) | 111 | static 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 | ||
| 477 | fail: | 479 | fail: |
| 478 | avfilter_unref_buffer(buf); | 480 | avfilter_unref_buffer(buf); |
| @@ -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 | ||
| 166 | static void filter_samples(AVFilterLink *inlink, AVFilterBufferRef *buf) | 165 | static 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 | |||
| 225 | fail: | ||
| 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 | ||
| 222 | AVFilter avfilter_af_resample = { | 235 | AVFilter avfilter_af_resample = { |
| @@ -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 | ||
| 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 | } | ||
| 23 | 26 | ||
| 24 | AVFilter avfilter_asink_anullsink = { | 27 | AVFilter avfilter_asink_anullsink = { |
| 25 | .name = "anullsink", | 28 | .name = "anullsink", |
| @@ -146,15 +146,15 @@ fail: · 145 unmodified lines | |||
| 146 | return NULL; | 146 | return NULL; |
| 147 | } | 147 | } |
| 148 | 148 | ||
| 149 | static void default_filter_samples(AVFilterLink *link, | 149 | static 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 | ||
| 155 | void ff_filter_samples(AVFilterLink *link, AVFilterBufferRef *samplesref) | 155 | int 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 | } else | 185 | } 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 | ||
| @@ -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. The | 49 | * @param samplesref a reference to the buffer of audio samples being sent. The |
| 50 | * receiving filter will free this reference when it no longer | 50 | * 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 | */ |
| 53 | void ff_filter_samples(AVFilterLink *link, AVFilterBufferRef *samplesref); | 56 | int ff_filter_samples(AVFilterLink *link, AVFilterBufferRef *samplesref); |
| 54 | 57 | ||
| 55 | #endif /* AVFILTER_AUDIO_H */ | 58 | #endif /* AVFILTER_AUDIO_H */ |
| @@ -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 available | 299 | * Frame poll callback. This returns the number of immediately available |
| @@ -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 | ||
| 59 | static int filter_samples(AVFilterLink *link, AVFilterBufferRef *buf) | ||
| 60 | { | ||
| 61 | start_frame(link, buf); | ||
| 62 | return 0; | ||
| 63 | } | ||
| 64 | |||
| 59 | int av_buffersink_read(AVFilterContext *ctx, AVFilterBufferRef **buf) | 65 | int 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 }}, |
| @@ -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 | ||
| 341 | static int poll_frame(AVFilterLink *link) | 342 | static int poll_frame(AVFilterLink *link) |
| @@ -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 | ||
| 75 | static void add_to_queue(AVFilterLink *inlink, AVFilterBufferRef *buf) | 75 | static 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 | |||
| 91 | static void start_frame(AVFilterLink *inlink, AVFilterBufferRef *buf) | ||
| 92 | { | ||
| 93 | add_to_queue(inlink, buf); | ||
| 82 | } | 94 | } |
| 83 | 95 | ||
| 84 | static void queue_pop(FifoContext *s) | 96 | static 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 | ||
| 218 | static int request_frame(AVFilterLink *outlink) | 228 | static 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 | ||
| 252 | AVFilter avfilter_vf_fifo = { | 262 | AVFilter 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, }, |
| @@ -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 available | 122 | * Frame poll callback. This returns the number of immediately available |
| @@ -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 | ||
| 113 | static void filter_samples(AVFilterLink *inlink, AVFilterBufferRef *samplesref) | 113 | static 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 | ||
| 124 | AVFilter avfilter_af_asplit = { | 128 | AVFilter avfilter_af_asplit = { |