Line | Branch | Exec | Source |
---|---|---|---|
1 | /* | ||
2 | * This file is part of FFmpeg. | ||
3 | * | ||
4 | * FFmpeg is free software; you can redistribute it and/or | ||
5 | * modify it under the terms of the GNU Lesser General Public | ||
6 | * License as published by the Free Software Foundation; either | ||
7 | * version 2.1 of the License, or (at your option) any later version. | ||
8 | * | ||
9 | * FFmpeg is distributed in the hope that it will be useful, | ||
10 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | ||
11 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | ||
12 | * Lesser General Public License for more details. | ||
13 | * | ||
14 | * You should have received a copy of the GNU Lesser General Public | ||
15 | * License along with FFmpeg; if not, write to the Free Software | ||
16 | * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA | ||
17 | */ | ||
18 | |||
19 | #include <string.h> | ||
20 | |||
21 | #include "config_components.h" | ||
22 | |||
23 | #include "libavutil/avassert.h" | ||
24 | #include "libavutil/log.h" | ||
25 | #include "libavutil/mem.h" | ||
26 | #include "libavutil/opt.h" | ||
27 | #include "libavutil/avstring.h" | ||
28 | #include "libavutil/bprint.h" | ||
29 | |||
30 | #include "bsf.h" | ||
31 | #include "bsf_internal.h" | ||
32 | #include "codec_desc.h" | ||
33 | #include "codec_par.h" | ||
34 | #include "packet_internal.h" | ||
35 | |||
36 | 1228678 | static av_always_inline const FFBitStreamFilter *ff_bsf(const AVBitStreamFilter *bsf) | |
37 | { | ||
38 | 1228678 | return (const FFBitStreamFilter*)bsf; | |
39 | } | ||
40 | |||
41 | typedef struct FFBSFContext { | ||
42 | AVBSFContext pub; | ||
43 | AVPacket *buffer_pkt; | ||
44 | int eof; | ||
45 | } FFBSFContext; | ||
46 | |||
47 | 1610788 | static av_always_inline FFBSFContext *ffbsfcontext(AVBSFContext *ctx) | |
48 | { | ||
49 | 1610788 | return (FFBSFContext *)ctx; | |
50 | } | ||
51 | |||
52 | 94730 | void av_bsf_free(AVBSFContext **pctx) | |
53 | { | ||
54 | AVBSFContext *ctx; | ||
55 | FFBSFContext *bsfi; | ||
56 | |||
57 |
3/4✓ Branch 0 taken 94730 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 78470 times.
✓ Branch 3 taken 16260 times.
|
94730 | if (!pctx || !*pctx) |
58 | 78470 | return; | |
59 | 16260 | ctx = *pctx; | |
60 | 16260 | bsfi = ffbsfcontext(ctx); | |
61 | |||
62 |
2/2✓ Branch 0 taken 1440 times.
✓ Branch 1 taken 14820 times.
|
16260 | if (ctx->priv_data) { |
63 |
2/2✓ Branch 1 taken 1425 times.
✓ Branch 2 taken 15 times.
|
1440 | if (ff_bsf(ctx->filter)->close) |
64 | 1425 | ff_bsf(ctx->filter)->close(ctx); | |
65 |
2/2✓ Branch 0 taken 919 times.
✓ Branch 1 taken 521 times.
|
1440 | if (ctx->filter->priv_class) |
66 | 919 | av_opt_free(ctx->priv_data); | |
67 | 1440 | av_freep(&ctx->priv_data); | |
68 | } | ||
69 | 16260 | av_packet_free(&bsfi->buffer_pkt); | |
70 | |||
71 | 16260 | avcodec_parameters_free(&ctx->par_in); | |
72 | 16260 | avcodec_parameters_free(&ctx->par_out); | |
73 | |||
74 | 16260 | av_freep(pctx); | |
75 | } | ||
76 | |||
77 | ✗ | static void *bsf_child_next(void *obj, void *prev) | |
78 | { | ||
79 | ✗ | AVBSFContext *ctx = obj; | |
80 | ✗ | if (!prev && ctx->filter->priv_class) | |
81 | ✗ | return ctx->priv_data; | |
82 | ✗ | return NULL; | |
83 | } | ||
84 | |||
85 | 5 | static const char *bsf_to_name(void *bsf) | |
86 | { | ||
87 | 5 | return ((AVBSFContext *)bsf)->filter->name; | |
88 | } | ||
89 | |||
90 | static const AVClass bsf_class = { | ||
91 | .class_name = "AVBSFContext", | ||
92 | .item_name = bsf_to_name, | ||
93 | .version = LIBAVUTIL_VERSION_INT, | ||
94 | .child_next = bsf_child_next, | ||
95 | .child_class_iterate = ff_bsf_child_class_iterate, | ||
96 | .category = AV_CLASS_CATEGORY_BITSTREAM_FILTER, | ||
97 | }; | ||
98 | |||
99 | ✗ | const AVClass *av_bsf_get_class(void) | |
100 | { | ||
101 | ✗ | return &bsf_class; | |
102 | } | ||
103 | |||
104 | 16260 | int av_bsf_alloc(const AVBitStreamFilter *filter, AVBSFContext **pctx) | |
105 | { | ||
106 | AVBSFContext *ctx; | ||
107 | FFBSFContext *bsfi; | ||
108 | int ret; | ||
109 | |||
110 | 16260 | bsfi = av_mallocz(sizeof(*bsfi)); | |
111 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 16260 times.
|
16260 | if (!bsfi) |
112 | ✗ | return AVERROR(ENOMEM); | |
113 | 16260 | ctx = &bsfi->pub; | |
114 | |||
115 | 16260 | ctx->av_class = &bsf_class; | |
116 | 16260 | ctx->filter = filter; | |
117 | |||
118 | 16260 | ctx->par_in = avcodec_parameters_alloc(); | |
119 | 16260 | ctx->par_out = avcodec_parameters_alloc(); | |
120 |
2/4✓ Branch 0 taken 16260 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 16260 times.
|
16260 | if (!ctx->par_in || !ctx->par_out) { |
121 | ✗ | ret = AVERROR(ENOMEM); | |
122 | ✗ | goto fail; | |
123 | } | ||
124 | /* allocate priv data and init private options */ | ||
125 |
2/2✓ Branch 1 taken 1440 times.
✓ Branch 2 taken 14820 times.
|
16260 | if (ff_bsf(filter)->priv_data_size) { |
126 | 1440 | ctx->priv_data = av_mallocz(ff_bsf(filter)->priv_data_size); | |
127 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 1440 times.
|
1440 | if (!ctx->priv_data) { |
128 | ✗ | ret = AVERROR(ENOMEM); | |
129 | ✗ | goto fail; | |
130 | } | ||
131 |
2/2✓ Branch 0 taken 919 times.
✓ Branch 1 taken 521 times.
|
1440 | if (filter->priv_class) { |
132 | 919 | *(const AVClass **)ctx->priv_data = filter->priv_class; | |
133 | 919 | av_opt_set_defaults(ctx->priv_data); | |
134 | } | ||
135 | } | ||
136 | 16260 | bsfi->buffer_pkt = av_packet_alloc(); | |
137 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 16260 times.
|
16260 | if (!bsfi->buffer_pkt) { |
138 | ✗ | ret = AVERROR(ENOMEM); | |
139 | ✗ | goto fail; | |
140 | } | ||
141 | |||
142 | 16260 | *pctx = ctx; | |
143 | 16260 | return 0; | |
144 | ✗ | fail: | |
145 | ✗ | av_bsf_free(&ctx); | |
146 | ✗ | return ret; | |
147 | } | ||
148 | |||
149 | 16260 | int av_bsf_init(AVBSFContext *ctx) | |
150 | { | ||
151 | int ret, i; | ||
152 | |||
153 | /* check that the codec is supported */ | ||
154 |
2/2✓ Branch 0 taken 1429 times.
✓ Branch 1 taken 14831 times.
|
16260 | if (ctx->filter->codec_ids) { |
155 |
1/2✓ Branch 0 taken 6018 times.
✗ Branch 1 not taken.
|
6018 | for (i = 0; ctx->filter->codec_ids[i] != AV_CODEC_ID_NONE; i++) |
156 |
2/2✓ Branch 0 taken 1429 times.
✓ Branch 1 taken 4589 times.
|
6018 | if (ctx->par_in->codec_id == ctx->filter->codec_ids[i]) |
157 | 1429 | break; | |
158 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 1429 times.
|
1429 | if (ctx->filter->codec_ids[i] == AV_CODEC_ID_NONE) { |
159 | ✗ | const AVCodecDescriptor *desc = avcodec_descriptor_get(ctx->par_in->codec_id); | |
160 | ✗ | av_log(ctx, AV_LOG_ERROR, "Codec '%s' (%d) is not supported by the " | |
161 | "bitstream filter '%s'. Supported codecs are: ", | ||
162 | ✗ | desc ? desc->name : "unknown", ctx->par_in->codec_id, ctx->filter->name); | |
163 | ✗ | for (i = 0; ctx->filter->codec_ids[i] != AV_CODEC_ID_NONE; i++) { | |
164 | ✗ | enum AVCodecID codec_id = ctx->filter->codec_ids[i]; | |
165 | ✗ | av_log(ctx, AV_LOG_ERROR, "%s (%d) ", | |
166 | avcodec_get_name(codec_id), codec_id); | ||
167 | } | ||
168 | ✗ | av_log(ctx, AV_LOG_ERROR, "\n"); | |
169 | ✗ | return AVERROR(EINVAL); | |
170 | } | ||
171 | } | ||
172 | |||
173 | /* initialize output parameters to be the same as input | ||
174 | * init below might overwrite that */ | ||
175 | 16260 | ret = avcodec_parameters_copy(ctx->par_out, ctx->par_in); | |
176 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 16260 times.
|
16260 | if (ret < 0) |
177 | ✗ | return ret; | |
178 | |||
179 | 16260 | ctx->time_base_out = ctx->time_base_in; | |
180 | |||
181 |
2/2✓ Branch 1 taken 1430 times.
✓ Branch 2 taken 14830 times.
|
16260 | if (ff_bsf(ctx->filter)->init) { |
182 | 1430 | ret = ff_bsf(ctx->filter)->init(ctx); | |
183 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 1430 times.
|
1430 | if (ret < 0) |
184 | ✗ | return ret; | |
185 | } | ||
186 | |||
187 | 16260 | return 0; | |
188 | } | ||
189 | |||
190 | 106 | void av_bsf_flush(AVBSFContext *ctx) | |
191 | { | ||
192 | 106 | FFBSFContext *const bsfi = ffbsfcontext(ctx); | |
193 | |||
194 | 106 | bsfi->eof = 0; | |
195 | |||
196 | 106 | av_packet_unref(bsfi->buffer_pkt); | |
197 | |||
198 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 106 times.
|
106 | if (ff_bsf(ctx->filter)->flush) |
199 | ✗ | ff_bsf(ctx->filter)->flush(ctx); | |
200 | 106 | } | |
201 | |||
202 | 404258 | int av_bsf_send_packet(AVBSFContext *ctx, AVPacket *pkt) | |
203 | { | ||
204 | 404258 | FFBSFContext *const bsfi = ffbsfcontext(ctx); | |
205 | int ret; | ||
206 | |||
207 |
5/6✓ Branch 0 taken 404116 times.
✓ Branch 1 taken 142 times.
✓ Branch 2 taken 3452 times.
✓ Branch 3 taken 400664 times.
✓ Branch 4 taken 3452 times.
✗ Branch 5 not taken.
|
404258 | if (!pkt || AVPACKET_IS_EMPTY(pkt)) { |
208 |
2/2✓ Branch 0 taken 3452 times.
✓ Branch 1 taken 142 times.
|
3594 | if (pkt) |
209 | 3452 | av_packet_unref(pkt); | |
210 | 3594 | bsfi->eof = 1; | |
211 | 3594 | return 0; | |
212 | } | ||
213 | |||
214 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 400664 times.
|
400664 | if (bsfi->eof) { |
215 | ✗ | av_log(ctx, AV_LOG_ERROR, "A non-NULL packet sent after an EOF.\n"); | |
216 | ✗ | return AVERROR(EINVAL); | |
217 | } | ||
218 | |||
219 |
2/4✓ Branch 0 taken 400664 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 400664 times.
|
400664 | if (!AVPACKET_IS_EMPTY(bsfi->buffer_pkt)) |
220 | ✗ | return AVERROR(EAGAIN); | |
221 | |||
222 | 400664 | ret = av_packet_make_refcounted(pkt); | |
223 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 400664 times.
|
400664 | if (ret < 0) |
224 | ✗ | return ret; | |
225 | 400664 | av_packet_move_ref(bsfi->buffer_pkt, pkt); | |
226 | |||
227 | 400664 | return 0; | |
228 | } | ||
229 | |||
230 | 1190317 | int av_bsf_receive_packet(AVBSFContext *ctx, AVPacket *pkt) | |
231 | { | ||
232 | 1190317 | return ff_bsf(ctx->filter)->filter(ctx, pkt); | |
233 | } | ||
234 | |||
235 | 1087 | int ff_bsf_get_packet(AVBSFContext *ctx, AVPacket **pkt) | |
236 | { | ||
237 | 1087 | FFBSFContext *const bsfi = ffbsfcontext(ctx); | |
238 | AVPacket *tmp_pkt; | ||
239 | |||
240 |
2/2✓ Branch 0 taken 9 times.
✓ Branch 1 taken 1078 times.
|
1087 | if (bsfi->eof) |
241 | 9 | return AVERROR_EOF; | |
242 | |||
243 |
3/4✓ Branch 0 taken 539 times.
✓ Branch 1 taken 539 times.
✓ Branch 2 taken 539 times.
✗ Branch 3 not taken.
|
1078 | if (AVPACKET_IS_EMPTY(bsfi->buffer_pkt)) |
244 | 539 | return AVERROR(EAGAIN); | |
245 | |||
246 | 539 | tmp_pkt = av_packet_alloc(); | |
247 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 539 times.
|
539 | if (!tmp_pkt) |
248 | ✗ | return AVERROR(ENOMEM); | |
249 | |||
250 | 539 | *pkt = bsfi->buffer_pkt; | |
251 | 539 | bsfi->buffer_pkt = tmp_pkt; | |
252 | |||
253 | 539 | return 0; | |
254 | } | ||
255 | |||
256 | 1189077 | int ff_bsf_get_packet_ref(AVBSFContext *ctx, AVPacket *pkt) | |
257 | { | ||
258 | 1189077 | FFBSFContext *const bsfi = ffbsfcontext(ctx); | |
259 | |||
260 |
2/2✓ Branch 0 taken 3600 times.
✓ Branch 1 taken 1185477 times.
|
1189077 | if (bsfi->eof) |
261 | 3600 | return AVERROR_EOF; | |
262 | |||
263 |
3/4✓ Branch 0 taken 785352 times.
✓ Branch 1 taken 400125 times.
✓ Branch 2 taken 785352 times.
✗ Branch 3 not taken.
|
1185477 | if (AVPACKET_IS_EMPTY(bsfi->buffer_pkt)) |
264 | 785352 | return AVERROR(EAGAIN); | |
265 | |||
266 | 400125 | av_packet_move_ref(pkt, bsfi->buffer_pkt); | |
267 | |||
268 | 400125 | return 0; | |
269 | } | ||
270 | |||
271 | typedef struct BSFListContext { | ||
272 | const AVClass *class; | ||
273 | |||
274 | AVBSFContext **bsfs; | ||
275 | int nb_bsfs; | ||
276 | |||
277 | unsigned idx; // index of currently processed BSF | ||
278 | |||
279 | char * item_name; | ||
280 | } BSFListContext; | ||
281 | |||
282 | |||
283 | 3 | static int bsf_list_init(AVBSFContext *bsf) | |
284 | { | ||
285 | 3 | BSFListContext *lst = bsf->priv_data; | |
286 | int ret, i; | ||
287 | 3 | const AVCodecParameters *cod_par = bsf->par_in; | |
288 | 3 | AVRational tb = bsf->time_base_in; | |
289 | |||
290 |
2/2✓ Branch 0 taken 6 times.
✓ Branch 1 taken 3 times.
|
9 | for (i = 0; i < lst->nb_bsfs; ++i) { |
291 | 6 | ret = avcodec_parameters_copy(lst->bsfs[i]->par_in, cod_par); | |
292 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 6 times.
|
6 | if (ret < 0) |
293 | ✗ | goto fail; | |
294 | |||
295 | 6 | lst->bsfs[i]->time_base_in = tb; | |
296 | |||
297 | 6 | ret = av_bsf_init(lst->bsfs[i]); | |
298 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 6 times.
|
6 | if (ret < 0) |
299 | ✗ | goto fail; | |
300 | |||
301 | 6 | cod_par = lst->bsfs[i]->par_out; | |
302 | 6 | tb = lst->bsfs[i]->time_base_out; | |
303 | } | ||
304 | |||
305 | 3 | bsf->time_base_out = tb; | |
306 | 3 | ret = avcodec_parameters_copy(bsf->par_out, cod_par); | |
307 | |||
308 | 3 | fail: | |
309 | 3 | return ret; | |
310 | } | ||
311 | |||
312 | 67 | static int bsf_list_filter(AVBSFContext *bsf, AVPacket *out) | |
313 | { | ||
314 | 67 | BSFListContext *lst = bsf->priv_data; | |
315 | 67 | int ret, eof = 0; | |
316 | |||
317 |
1/2✓ Branch 0 taken 67 times.
✗ Branch 1 not taken.
|
67 | if (!lst->nb_bsfs) |
318 | ✗ | return ff_bsf_get_packet_ref(bsf, out); | |
319 | |||
320 | while (1) { | ||
321 | /* get a packet from the previous filter up the chain */ | ||
322 |
2/2✓ Branch 0 taken 128 times.
✓ Branch 1 taken 75 times.
|
203 | if (lst->idx) |
323 | 128 | ret = av_bsf_receive_packet(lst->bsfs[lst->idx-1], out); | |
324 | else | ||
325 | 75 | ret = ff_bsf_get_packet_ref(bsf, out); | |
326 |
2/2✓ Branch 0 taken 101 times.
✓ Branch 1 taken 102 times.
|
203 | if (ret == AVERROR(EAGAIN)) { |
327 |
2/2✓ Branch 0 taken 36 times.
✓ Branch 1 taken 65 times.
|
101 | if (!lst->idx) |
328 | 36 | return ret; | |
329 | 65 | lst->idx--; | |
330 | 65 | continue; | |
331 |
2/2✓ Branch 0 taken 9 times.
✓ Branch 1 taken 93 times.
|
102 | } else if (ret == AVERROR_EOF) { |
332 | 9 | eof = 1; | |
333 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 93 times.
|
93 | } else if (ret < 0) |
334 | ✗ | return ret; | |
335 | |||
336 | /* send it to the next filter down the chain */ | ||
337 |
2/2✓ Branch 0 taken 71 times.
✓ Branch 1 taken 31 times.
|
102 | if (lst->idx < lst->nb_bsfs) { |
338 |
2/2✓ Branch 0 taken 65 times.
✓ Branch 1 taken 6 times.
|
71 | ret = av_bsf_send_packet(lst->bsfs[lst->idx], eof ? NULL : out); |
339 | av_assert1(ret != AVERROR(EAGAIN)); | ||
340 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 71 times.
|
71 | if (ret < 0) { |
341 | ✗ | av_packet_unref(out); | |
342 | ✗ | return ret; | |
343 | } | ||
344 | 71 | lst->idx++; | |
345 | 71 | eof = 0; | |
346 |
2/2✓ Branch 0 taken 3 times.
✓ Branch 1 taken 28 times.
|
31 | } else if (eof) { |
347 | 3 | return ret; | |
348 | } else { | ||
349 | 28 | return 0; | |
350 | } | ||
351 | } | ||
352 | } | ||
353 | |||
354 | ✗ | static void bsf_list_flush(AVBSFContext *bsf) | |
355 | { | ||
356 | ✗ | BSFListContext *lst = bsf->priv_data; | |
357 | |||
358 | ✗ | for (int i = 0; i < lst->nb_bsfs; i++) | |
359 | ✗ | av_bsf_flush(lst->bsfs[i]); | |
360 | ✗ | lst->idx = 0; | |
361 | ✗ | } | |
362 | |||
363 | 3 | static void bsf_list_close(AVBSFContext *bsf) | |
364 | { | ||
365 | 3 | BSFListContext *lst = bsf->priv_data; | |
366 | int i; | ||
367 | |||
368 |
2/2✓ Branch 0 taken 6 times.
✓ Branch 1 taken 3 times.
|
9 | for (i = 0; i < lst->nb_bsfs; ++i) |
369 | 6 | av_bsf_free(&lst->bsfs[i]); | |
370 | 3 | av_freep(&lst->bsfs); | |
371 | 3 | av_freep(&lst->item_name); | |
372 | 3 | } | |
373 | |||
374 | ✗ | static const char *bsf_list_item_name(void *ctx) | |
375 | { | ||
376 | static const char *null_filter_name = "null"; | ||
377 | ✗ | AVBSFContext *bsf_ctx = ctx; | |
378 | ✗ | BSFListContext *lst = bsf_ctx->priv_data; | |
379 | |||
380 | ✗ | if (!lst->nb_bsfs) | |
381 | ✗ | return null_filter_name; | |
382 | |||
383 | ✗ | if (!lst->item_name) { | |
384 | int i; | ||
385 | AVBPrint bp; | ||
386 | ✗ | av_bprint_init(&bp, 16, 128); | |
387 | |||
388 | ✗ | av_bprintf(&bp, "bsf_list("); | |
389 | ✗ | for (i = 0; i < lst->nb_bsfs; i++) | |
390 | ✗ | av_bprintf(&bp, i ? ",%s" : "%s", lst->bsfs[i]->filter->name); | |
391 | ✗ | av_bprintf(&bp, ")"); | |
392 | |||
393 | ✗ | av_bprint_finalize(&bp, &lst->item_name); | |
394 | } | ||
395 | |||
396 | ✗ | return lst->item_name; | |
397 | } | ||
398 | |||
399 | static const AVClass bsf_list_class = { | ||
400 | .class_name = "bsf_list", | ||
401 | .item_name = bsf_list_item_name, | ||
402 | .version = LIBAVUTIL_VERSION_INT, | ||
403 | }; | ||
404 | |||
405 | static const FFBitStreamFilter list_bsf = { | ||
406 | .p.name = "bsf_list", | ||
407 | .p.priv_class = &bsf_list_class, | ||
408 | .priv_data_size = sizeof(BSFListContext), | ||
409 | .init = bsf_list_init, | ||
410 | .filter = bsf_list_filter, | ||
411 | .flush = bsf_list_flush, | ||
412 | .close = bsf_list_close, | ||
413 | }; | ||
414 | |||
415 | struct AVBSFList { | ||
416 | AVBSFContext **bsfs; | ||
417 | int nb_bsfs; | ||
418 | }; | ||
419 | |||
420 | 614 | AVBSFList *av_bsf_list_alloc(void) | |
421 | { | ||
422 | 614 | return av_mallocz(sizeof(AVBSFList)); | |
423 | } | ||
424 | |||
425 | ✗ | void av_bsf_list_free(AVBSFList **lst) | |
426 | { | ||
427 | int i; | ||
428 | |||
429 | ✗ | if (!*lst) | |
430 | ✗ | return; | |
431 | |||
432 | ✗ | for (i = 0; i < (*lst)->nb_bsfs; ++i) | |
433 | ✗ | av_bsf_free(&(*lst)->bsfs[i]); | |
434 | ✗ | av_free((*lst)->bsfs); | |
435 | ✗ | av_freep(lst); | |
436 | } | ||
437 | |||
438 | 617 | int av_bsf_list_append(AVBSFList *lst, AVBSFContext *bsf) | |
439 | { | ||
440 | 617 | return av_dynarray_add_nofree(&lst->bsfs, &lst->nb_bsfs, bsf); | |
441 | } | ||
442 | |||
443 | 617 | static int bsf_list_append_internal(AVBSFList *lst, const char *bsf_name, const char *options, AVDictionary ** options_dict) | |
444 | { | ||
445 | int ret; | ||
446 | const AVBitStreamFilter *filter; | ||
447 | AVBSFContext *bsf; | ||
448 | |||
449 | 617 | filter = av_bsf_get_by_name(bsf_name); | |
450 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 617 times.
|
617 | if (!filter) |
451 | ✗ | return AVERROR_BSF_NOT_FOUND; | |
452 | |||
453 | 617 | ret = av_bsf_alloc(filter, &bsf); | |
454 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 617 times.
|
617 | if (ret < 0) |
455 | ✗ | return ret; | |
456 | |||
457 |
3/4✓ Branch 0 taken 27 times.
✓ Branch 1 taken 590 times.
✓ Branch 2 taken 27 times.
✗ Branch 3 not taken.
|
617 | if (options && filter->priv_class) { |
458 | 27 | const AVOption *opt = av_opt_next(bsf->priv_data, NULL); | |
459 | 27 | const char * shorthand[2] = {NULL}; | |
460 | |||
461 |
1/2✓ Branch 0 taken 27 times.
✗ Branch 1 not taken.
|
27 | if (opt) |
462 | 27 | shorthand[0] = opt->name; | |
463 | |||
464 | 27 | ret = av_opt_set_from_string(bsf->priv_data, options, shorthand, "=", ":"); | |
465 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 27 times.
|
27 | if (ret < 0) |
466 | ✗ | goto end; | |
467 | } | ||
468 | |||
469 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 617 times.
|
617 | if (options_dict) { |
470 | ✗ | ret = av_opt_set_dict2(bsf, options_dict, AV_OPT_SEARCH_CHILDREN); | |
471 | ✗ | if (ret < 0) | |
472 | ✗ | goto end; | |
473 | } | ||
474 | |||
475 | 617 | ret = av_bsf_list_append(lst, bsf); | |
476 | |||
477 | 617 | end: | |
478 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 617 times.
|
617 | if (ret < 0) |
479 | ✗ | av_bsf_free(&bsf); | |
480 | |||
481 | 617 | return ret; | |
482 | } | ||
483 | |||
484 | ✗ | int av_bsf_list_append2(AVBSFList *lst, const char *bsf_name, AVDictionary ** options) | |
485 | { | ||
486 | ✗ | return bsf_list_append_internal(lst, bsf_name, NULL, options); | |
487 | } | ||
488 | |||
489 | 614 | int av_bsf_list_finalize(AVBSFList **lst, AVBSFContext **bsf) | |
490 | { | ||
491 | 614 | int ret = 0; | |
492 | BSFListContext *ctx; | ||
493 | |||
494 |
2/2✓ Branch 0 taken 611 times.
✓ Branch 1 taken 3 times.
|
614 | if ((*lst)->nb_bsfs == 1) { |
495 | 611 | *bsf = (*lst)->bsfs[0]; | |
496 | 611 | av_freep(&(*lst)->bsfs); | |
497 | 611 | (*lst)->nb_bsfs = 0; | |
498 | 611 | goto end; | |
499 | } | ||
500 | |||
501 | 3 | ret = av_bsf_alloc(&list_bsf.p, bsf); | |
502 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 3 times.
|
3 | if (ret < 0) |
503 | ✗ | return ret; | |
504 | |||
505 | 3 | ctx = (*bsf)->priv_data; | |
506 | |||
507 | 3 | ctx->bsfs = (*lst)->bsfs; | |
508 | 3 | ctx->nb_bsfs = (*lst)->nb_bsfs; | |
509 | |||
510 | 614 | end: | |
511 | 614 | av_freep(lst); | |
512 | 614 | return ret; | |
513 | } | ||
514 | |||
515 | 617 | static int bsf_parse_single(char *str, AVBSFList *bsf_lst) | |
516 | { | ||
517 | char *bsf_name, *bsf_options_str; | ||
518 | |||
519 | 617 | bsf_name = av_strtok(str, "=", &bsf_options_str); | |
520 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 617 times.
|
617 | if (!bsf_name) |
521 | ✗ | return AVERROR(EINVAL); | |
522 | |||
523 | 617 | return bsf_list_append_internal(bsf_lst, bsf_name, bsf_options_str, NULL); | |
524 | } | ||
525 | |||
526 | 15432 | int av_bsf_list_parse_str(const char *str, AVBSFContext **bsf_lst) | |
527 | { | ||
528 | AVBSFList *lst; | ||
529 | int ret; | ||
530 | |||
531 |
2/2✓ Branch 0 taken 14818 times.
✓ Branch 1 taken 614 times.
|
15432 | if (!str) |
532 | 14818 | return av_bsf_get_null_filter(bsf_lst); | |
533 | |||
534 | 614 | lst = av_bsf_list_alloc(); | |
535 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 614 times.
|
614 | if (!lst) |
536 | ✗ | return AVERROR(ENOMEM); | |
537 | |||
538 | do { | ||
539 | 617 | char *bsf_str = av_get_token(&str, ","); | |
540 | 617 | ret = bsf_parse_single(bsf_str, lst); | |
541 | 617 | av_free(bsf_str); | |
542 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 617 times.
|
617 | if (ret < 0) |
543 | ✗ | goto end; | |
544 |
3/4✓ Branch 0 taken 3 times.
✓ Branch 1 taken 614 times.
✓ Branch 2 taken 3 times.
✗ Branch 3 not taken.
|
617 | } while (*str && *++str); |
545 | |||
546 | 614 | ret = av_bsf_list_finalize(&lst, bsf_lst); | |
547 | 614 | end: | |
548 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 614 times.
|
614 | if (ret < 0) |
549 | ✗ | av_bsf_list_free(&lst); | |
550 | 614 | return ret; | |
551 | } | ||
552 | |||
553 | 14818 | int av_bsf_get_null_filter(AVBSFContext **bsf) | |
554 | { | ||
555 | #if CONFIG_NULL_BSF | ||
556 | extern const FFBitStreamFilter ff_null_bsf; | ||
557 | 14818 | return av_bsf_alloc(&ff_null_bsf.p, bsf); | |
558 | #else | ||
559 | return av_bsf_alloc(&list_bsf.p, bsf); | ||
560 | #endif | ||
561 | } | ||
562 |