FFmpeg coverage

Directory: ../../../ffmpeg/
File: src/fftools/ffmpeg_hw.c
Date: 2021-09-24 20:55:06
Exec Total Coverage
Lines: 45 316 14.2%
Branches: 18 180 10.0%
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 "libavutil/avstring.h"
22 #include "libavutil/pixdesc.h"
23 #include "libavfilter/buffersink.h"
24
25 #include "ffmpeg.h"
26
27 static int nb_hw_devices;
28 static HWDevice **hw_devices;
29
30 1605 static HWDevice *hw_device_get_by_type(enum AVHWDeviceType type)
31 {
32 1605 HWDevice *found = NULL;
33 int i;
34
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1605 times.
 1605 for (i = 0; i < nb_hw_devices; i++) {
35 ✗ if (hw_devices[i]->type == type) {
36 ✗ if (found)
37 ✗ return NULL;
38 ✗ found = hw_devices[i];
39 }
40 }
41 1605 return found;
42 }
43
44 ✗ HWDevice *hw_device_get_by_name(const char *name)
45 {
46 int i;
47 ✗ for (i = 0; i < nb_hw_devices; i++) {
48 ✗ if (!strcmp(hw_devices[i]->name, name))
49 ✗ return hw_devices[i];
50 }
51 ✗ return NULL;
52 }
53
54 ✗ static HWDevice *hw_device_add(void)
55 {
56 int err;
57 ✗ err = av_reallocp_array(&hw_devices, nb_hw_devices + 1,
58 sizeof(*hw_devices));
59 ✗ if (err) {
60 ✗ nb_hw_devices = 0;
61 ✗ return NULL;
62 }
63 ✗ hw_devices[nb_hw_devices] = av_mallocz(sizeof(HWDevice));
64 ✗ if (!hw_devices[nb_hw_devices])
65 ✗ return NULL;
66 ✗ return hw_devices[nb_hw_devices++];
67 }
68
69 ✗ static char *hw_device_default_name(enum AVHWDeviceType type)
70 {
71 // Make an automatic name of the form "type%d". We arbitrarily
72 // limit at 1000 anonymous devices of the same type - there is
73 // probably something else very wrong if you get to this limit.
74 ✗ const char *type_name = av_hwdevice_get_type_name(type);
75 char *name;
76 size_t index_pos;
77 ✗ int index, index_limit = 1000;
78 ✗ index_pos = strlen(type_name);
79 ✗ name = av_malloc(index_pos + 4);
80 ✗ if (!name)
81 ✗ return NULL;
82 ✗ for (index = 0; index < index_limit; index++) {
83 ✗ snprintf(name, index_pos + 4, "%s%d", type_name, index);
84 ✗ if (!hw_device_get_by_name(name))
85 ✗ break;
86 }
87 ✗ if (index >= index_limit) {
88 ✗ av_freep(&name);
89 ✗ return NULL;
90 }
91 ✗ return name;
92 }
93
94 ✗ int hw_device_init_from_string(const char *arg, HWDevice **dev_out)
95 {
96 // "type=name"
97 // "type=name,key=value,key2=value2"
98 // "type=name:device,key=value,key2=value2"
99 // "type:device,key=value,key2=value2"
100 // -> av_hwdevice_ctx_create()
101 // "type=name@name"
102 // "type@name"
103 // -> av_hwdevice_ctx_create_derived()
104
105 ✗ AVDictionary *options = NULL;
106 ✗ const char *type_name = NULL, *name = NULL, *device = NULL;
107 enum AVHWDeviceType type;
108 HWDevice *dev, *src;
109 ✗ AVBufferRef *device_ref = NULL;
110 int err;
111 const char *errmsg, *p, *q;
112 size_t k;
113
114 ✗ k = strcspn(arg, ":=@");
115 ✗ p = arg + k;
116
117 ✗ type_name = av_strndup(arg, k);
118 ✗ if (!type_name) {
119 ✗ err = AVERROR(ENOMEM);
120 ✗ goto fail;
121 }
122 ✗ type = av_hwdevice_find_type_by_name(type_name);
123 ✗ if (type == AV_HWDEVICE_TYPE_NONE) {
124 ✗ errmsg = "unknown device type";
125 ✗ goto invalid;
126 }
127
128 ✗ if (*p == '=') {
129 ✗ k = strcspn(p + 1, ":@,");
130
131 ✗ name = av_strndup(p + 1, k);
132 ✗ if (!name) {
133 ✗ err = AVERROR(ENOMEM);
134 ✗ goto fail;
135 }
136 ✗ if (hw_device_get_by_name(name)) {
137 ✗ errmsg = "named device already exists";
138 ✗ goto invalid;
139 }
140
141 ✗ p += 1 + k;
142 } else {
143 ✗ name = hw_device_default_name(type);
144 ✗ if (!name) {
145 ✗ err = AVERROR(ENOMEM);
146 ✗ goto fail;
147 }
148 }
149
150 ✗ if (!*p) {
151 // New device with no parameters.
152 ✗ err = av_hwdevice_ctx_create(&device_ref, type,
153 NULL, NULL, 0);
154 ✗ if (err < 0)
155 ✗ goto fail;
156
157 ✗ } else if (*p == ':') {
158 // New device with some parameters.
159 ✗ ++p;
160 ✗ q = strchr(p, ',');
161 ✗ if (q) {
162 ✗ if (q - p > 0) {
163 ✗ device = av_strndup(p, q - p);
164 ✗ if (!device) {
165 ✗ err = AVERROR(ENOMEM);
166 ✗ goto fail;
167 }
168 }
169 ✗ err = av_dict_parse_string(&options, q + 1, "=", ",", 0);
170 ✗ if (err < 0) {
171 ✗ errmsg = "failed to parse options";
172 ✗ goto invalid;
173 }
174 }
175
176 ✗ err = av_hwdevice_ctx_create(&device_ref, type,
177 ✗ q ? device : p[0] ? p : NULL,
178 options, 0);
179 ✗ if (err < 0)
180 ✗ goto fail;
181
182 ✗ } else if (*p == '@') {
183 // Derive from existing device.
184
185 ✗ src = hw_device_get_by_name(p + 1);
186 ✗ if (!src) {
187 ✗ errmsg = "invalid source device name";
188 ✗ goto invalid;
189 }
190
191 ✗ err = av_hwdevice_ctx_create_derived(&device_ref, type,
192 src->device_ref, 0);
193 ✗ if (err < 0)
194 ✗ goto fail;
195 ✗ } else if (*p == ',') {
196 ✗ err = av_dict_parse_string(&options, p + 1, "=", ",", 0);
197
198 ✗ if (err < 0) {
199 ✗ errmsg = "failed to parse options";
200 ✗ goto invalid;
201 }
202
203 ✗ err = av_hwdevice_ctx_create(&device_ref, type,
204 NULL, options, 0);
205 ✗ if (err < 0)
206 ✗ goto fail;
207 } else {
208 ✗ errmsg = "parse error";
209 ✗ goto invalid;
210 }
211
212 ✗ dev = hw_device_add();
213 ✗ if (!dev) {
214 ✗ err = AVERROR(ENOMEM);
215 ✗ goto fail;
216 }
217
218 ✗ dev->name = name;
219 ✗ dev->type = type;
220 ✗ dev->device_ref = device_ref;
221
222 ✗ if (dev_out)
223 ✗ *dev_out = dev;
224
225 ✗ name = NULL;
226 ✗ err = 0;
227 ✗ done:
228 ✗ av_freep(&type_name);
229 ✗ av_freep(&name);
230 ✗ av_freep(&device);
231 ✗ av_dict_free(&options);
232 ✗ return err;
233 ✗ invalid:
234 ✗ av_log(NULL, AV_LOG_ERROR,
235 "Invalid device specification \"%s\": %s\n", arg, errmsg);
236 ✗ err = AVERROR(EINVAL);
237 ✗ goto done;
238 ✗ fail:
239 ✗ av_log(NULL, AV_LOG_ERROR,
240 "Device creation failed: %d.\n", err);
241 ✗ av_buffer_unref(&device_ref);
242 ✗ goto done;
243 }
244
245 ✗ static int hw_device_init_from_type(enum AVHWDeviceType type,
246 const char *device,
247 HWDevice **dev_out)
248 {
249 ✗ AVBufferRef *device_ref = NULL;
250 HWDevice *dev;
251 char *name;
252 int err;
253
254 ✗ name = hw_device_default_name(type);
255 ✗ if (!name) {
256 ✗ err = AVERROR(ENOMEM);
257 ✗ goto fail;
258 }
259
260 ✗ err = av_hwdevice_ctx_create(&device_ref, type, device, NULL, 0);
261 ✗ if (err < 0) {
262 ✗ av_log(NULL, AV_LOG_ERROR,
263 "Device creation failed: %d.\n", err);
264 ✗ goto fail;
265 }
266
267 ✗ dev = hw_device_add();
268 ✗ if (!dev) {
269 ✗ err = AVERROR(ENOMEM);
270 ✗ goto fail;
271 }
272
273 ✗ dev->name = name;
274 ✗ dev->type = type;
275 ✗ dev->device_ref = device_ref;
276
277 ✗ if (dev_out)
278 ✗ *dev_out = dev;
279
280 ✗ return 0;
281
282 ✗ fail:
283 ✗ av_freep(&name);
284 ✗ av_buffer_unref(&device_ref);
285 ✗ return err;
286 }
287
288 6014 void hw_device_free_all(void)
289 {
290 int i;
291
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 6014 times.
 6014 for (i = 0; i < nb_hw_devices; i++) {
292 ✗ av_freep(&hw_devices[i]->name);
293 ✗ av_buffer_unref(&hw_devices[i]->device_ref);
294 ✗ av_freep(&hw_devices[i]);
295 }
296 6014 av_freep(&hw_devices);
297 6014 nb_hw_devices = 0;
298 6014 }
299
300 5828 static HWDevice *hw_device_match_by_codec(const AVCodec *codec)
301 {
302 const AVCodecHWConfig *config;
303 HWDevice *dev;
304 int i;
305 5828 for (i = 0;; i++) {
306 7433 config = avcodec_get_hw_config(codec, i);
307
2/2
✓ Branch 0 taken 5828 times.
✓ Branch 1 taken 1605 times.
 7433 if (!config)
308 5828 return NULL;
309
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1605 times.
 1605 if (!(config->methods & AV_CODEC_HW_CONFIG_METHOD_HW_DEVICE_CTX))
310 ✗ continue;
311 1605 dev = hw_device_get_by_type(config->device_type);
312
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1605 times.
 1605 if (dev)
313 ✗ return dev;
314 }
315 }
316
317 5828 int hw_device_setup_for_decode(InputStream *ist)
318 {
319 const AVCodecHWConfig *config;
320 enum AVHWDeviceType type;
321 5828 HWDevice *dev = NULL;
322 5828 int err, auto_device = 0;
323
324
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 5828 times.
 5828 if (ist->hwaccel_device) {
325 ✗ dev = hw_device_get_by_name(ist->hwaccel_device);
326 ✗ if (!dev) {
327 ✗ if (ist->hwaccel_id == HWACCEL_AUTO) {
328 ✗ auto_device = 1;
329 ✗ } else if (ist->hwaccel_id == HWACCEL_GENERIC) {
330 ✗ type = ist->hwaccel_device_type;
331 ✗ err = hw_device_init_from_type(type, ist->hwaccel_device,
332 &dev);
333 } else {
334 // This will be dealt with by API-specific initialisation
335 // (using hwaccel_device), so nothing further needed here.
336 ✗ return 0;
337 }
338 } else {
339 ✗ if (ist->hwaccel_id == HWACCEL_AUTO) {
340 ✗ ist->hwaccel_device_type = dev->type;
341 ✗ } else if (ist->hwaccel_device_type != dev->type) {
342 ✗ av_log(ist->dec_ctx, AV_LOG_ERROR, "Invalid hwaccel device "
343 "specified for decoder: device %s of type %s is not "
344 ✗ "usable with hwaccel %s.\n", dev->name,
345 ✗ av_hwdevice_get_type_name(dev->type),
346 av_hwdevice_get_type_name(ist->hwaccel_device_type));
347 ✗ return AVERROR(EINVAL);
348 }
349 }
350 } else {
351
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 5828 times.
 5828 if (ist->hwaccel_id == HWACCEL_AUTO) {
352 ✗ auto_device = 1;
353
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 5828 times.
 5828 } else if (ist->hwaccel_id == HWACCEL_GENERIC) {
354 ✗ type = ist->hwaccel_device_type;
355 ✗ dev = hw_device_get_by_type(type);
356
357 // When "-qsv_device device" is used, an internal QSV device named
358 // as "__qsv_device" is created. Another QSV device is created too
359 // if "-init_hw_device qsv=name:device" is used. There are 2 QSV devices
360 // if both "-qsv_device device" and "-init_hw_device qsv=name:device"
361 // are used, hw_device_get_by_type(AV_HWDEVICE_TYPE_QSV) returns NULL.
362 // To keep back-compatibility with the removed ad-hoc libmfx setup code,
363 // call hw_device_get_by_name("__qsv_device") to select the internal QSV
364 // device.
365 ✗ if (!dev && type == AV_HWDEVICE_TYPE_QSV)
366 ✗ dev = hw_device_get_by_name("__qsv_device");
367
368 ✗ if (!dev)
369 ✗ err = hw_device_init_from_type(type, NULL, &dev);
370 } else {
371 5828 dev = hw_device_match_by_codec(ist->dec);
372
1/2
✓ Branch 0 taken 5828 times.
✗ Branch 1 not taken.
 5828 if (!dev) {
373 // No device for this codec, but not using generic hwaccel
374 // and therefore may well not need one - ignore.
375 5828 return 0;
376 }
377 }
378 }
379
380 ✗ if (auto_device) {
381 int i;
382 ✗ if (!avcodec_get_hw_config(ist->dec, 0)) {
383 // Decoder does not support any hardware devices.
384 ✗ return 0;
385 }
386 ✗ for (i = 0; !dev; i++) {
387 ✗ config = avcodec_get_hw_config(ist->dec, i);
388 ✗ if (!config)
389 ✗ break;
390 ✗ type = config->device_type;
391 ✗ dev = hw_device_get_by_type(type);
392 ✗ if (dev) {
393 ✗ av_log(ist->dec_ctx, AV_LOG_INFO, "Using auto "
394 "hwaccel type %s with existing device %s.\n",
395 ✗ av_hwdevice_get_type_name(type), dev->name);
396 }
397 }
398 ✗ for (i = 0; !dev; i++) {
399 ✗ config = avcodec_get_hw_config(ist->dec, i);
400 ✗ if (!config)
401 ✗ break;
402 ✗ type = config->device_type;
403 // Try to make a new device of this type.
404 ✗ err = hw_device_init_from_type(type, ist->hwaccel_device,
405 &dev);
406 ✗ if (err < 0) {
407 // Can't make a device of this type.
408 ✗ continue;
409 }
410 ✗ if (ist->hwaccel_device) {
411 ✗ av_log(ist->dec_ctx, AV_LOG_INFO, "Using auto "
412 "hwaccel type %s with new device created "
413 "from %s.\n", av_hwdevice_get_type_name(type),
414 ist->hwaccel_device);
415 } else {
416 ✗ av_log(ist->dec_ctx, AV_LOG_INFO, "Using auto "
417 "hwaccel type %s with new default device.\n",
418 av_hwdevice_get_type_name(type));
419 }
420 }
421 ✗ if (dev) {
422 ✗ ist->hwaccel_device_type = type;
423 } else {
424 ✗ av_log(ist->dec_ctx, AV_LOG_INFO, "Auto hwaccel "
425 "disabled: no device found.\n");
426 ✗ ist->hwaccel_id = HWACCEL_NONE;
427 ✗ return 0;
428 }
429 }
430
431 ✗ if (!dev) {
432 ✗ av_log(ist->dec_ctx, AV_LOG_ERROR, "No device available "
433 "for decoder: device type %s needed for codec %s.\n",
434 ✗ av_hwdevice_get_type_name(type), ist->dec->name);
435 ✗ return err;
436 }
437
438 ✗ ist->dec_ctx->hw_device_ctx = av_buffer_ref(dev->device_ref);
439 ✗ if (!ist->dec_ctx->hw_device_ctx)
440 ✗ return AVERROR(ENOMEM);
441
442 ✗ return 0;
443 }
444
445 5854 int hw_device_setup_for_encode(OutputStream *ost)
446 {
447 const AVCodecHWConfig *config;
448 5854 HWDevice *dev = NULL;
449 5854 AVBufferRef *frames_ref = NULL;
450 int i;
451
452
2/2
✓ Branch 0 taken 5820 times.
✓ Branch 1 taken 34 times.
 5854 if (ost->filter) {
453 5820 frames_ref = av_buffersink_get_hw_frames_ctx(ost->filter->filter);
454
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 5820 times.
 5820 if (frames_ref &&
455 ✗ ((AVHWFramesContext*)frames_ref->data)->format ==
456 ✗ ost->enc_ctx->pix_fmt) {
457 // Matching format, will try to use hw_frames_ctx.
458 } else {
459 5820 frames_ref = NULL;
460 }
461 }
462
463 5854 for (i = 0;; i++) {
464 5854 config = avcodec_get_hw_config(ost->enc, i);
465
1/2
✓ Branch 0 taken 5854 times.
✗ Branch 1 not taken.
 5854 if (!config)
466 5854 break;
467
468 ✗ if (frames_ref &&
469 ✗ config->methods & AV_CODEC_HW_CONFIG_METHOD_HW_FRAMES_CTX &&
470 ✗ (config->pix_fmt == AV_PIX_FMT_NONE ||
471 ✗ config->pix_fmt == ost->enc_ctx->pix_fmt)) {
472 ✗ av_log(ost->enc_ctx, AV_LOG_VERBOSE, "Using input "
473 "frames context (format %s) with %s encoder.\n",
474 ✗ av_get_pix_fmt_name(ost->enc_ctx->pix_fmt),
475 ✗ ost->enc->name);
476 ✗ ost->enc_ctx->hw_frames_ctx = av_buffer_ref(frames_ref);
477 ✗ if (!ost->enc_ctx->hw_frames_ctx)
478 ✗ return AVERROR(ENOMEM);
479 ✗ return 0;
480 }
481
482 ✗ if (!dev &&
483 ✗ config->methods & AV_CODEC_HW_CONFIG_METHOD_HW_DEVICE_CTX)
484 ✗ dev = hw_device_get_by_type(config->device_type);
485 }
486
487
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 5854 times.
 5854 if (dev) {
488 ✗ av_log(ost->enc_ctx, AV_LOG_VERBOSE, "Using device %s "
489 "(type %s) with %s encoder.\n", dev->name,
490 ✗ av_hwdevice_get_type_name(dev->type), ost->enc->name);
491 ✗ ost->enc_ctx->hw_device_ctx = av_buffer_ref(dev->device_ref);
492 ✗ if (!ost->enc_ctx->hw_device_ctx)
493 ✗ return AVERROR(ENOMEM);
494 } else {
495 // No device required, or no device available.
496 }
497 5854 return 0;
498 }
499
500 ✗ static int hwaccel_retrieve_data(AVCodecContext *avctx, AVFrame *input)
501 {
502 ✗ InputStream *ist = avctx->opaque;
503 ✗ AVFrame *output = NULL;
504 ✗ enum AVPixelFormat output_format = ist->hwaccel_output_format;
505 int err;
506
507 ✗ if (input->format == output_format) {
508 // Nothing to do.
509 ✗ return 0;
510 }
511
512 ✗ output = av_frame_alloc();
513 ✗ if (!output)
514 ✗ return AVERROR(ENOMEM);
515
516 ✗ output->format = output_format;
517
518 ✗ err = av_hwframe_transfer_data(output, input, 0);
519 ✗ if (err < 0) {
520 ✗ av_log(avctx, AV_LOG_ERROR, "Failed to transfer data to "
521 "output frame: %d.\n", err);
522 ✗ goto fail;
523 }
524
525 ✗ err = av_frame_copy_props(output, input);
526 ✗ if (err < 0) {
527 ✗ av_frame_unref(output);
528 ✗ goto fail;
529 }
530
531 ✗ av_frame_unref(input);
532 ✗ av_frame_move_ref(input, output);
533 ✗ av_frame_free(&output);
534
535 ✗ return 0;
536
537 ✗ fail:
538 ✗ av_frame_free(&output);
539 ✗ return err;
540 }
541
542 ✗ int hwaccel_decode_init(AVCodecContext *avctx)
543 {
544 ✗ InputStream *ist = avctx->opaque;
545
546 ✗ ist->hwaccel_retrieve_data = &hwaccel_retrieve_data;
547
548 ✗ return 0;
549 }
550
551 5858 int hw_device_setup_for_filter(FilterGraph *fg)
552 {
553 HWDevice *dev;
554 int i;
555
556 // Pick the last hardware device if the user doesn't pick the device for
557 // filters explicitly with the filter_hw_device option.
558
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 5858 times.
 5858 if (filter_hw_device)
559 ✗ dev = filter_hw_device;
560
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 5858 times.
 5858 else if (nb_hw_devices > 0) {
561 ✗ dev = hw_devices[nb_hw_devices - 1];
562
563 ✗ if (nb_hw_devices > 1)
564 ✗ av_log(NULL, AV_LOG_WARNING, "There are %d hardware devices. device "
565 "%s of type %s is picked for filters by default. Set hardware "
566 "device explicitly with the filter_hw_device option if device "
567 "%s is not usable for filters.\n",
568 nb_hw_devices, dev->name,
569 av_hwdevice_get_type_name(dev->type), dev->name);
570 } else
571 5858 dev = NULL;
572
573
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 5858 times.
 5858 if (dev) {
574 ✗ for (i = 0; i < fg->graph->nb_filters; i++) {
575 ✗ fg->graph->filters[i]->hw_device_ctx =
576 ✗ av_buffer_ref(dev->device_ref);
577 ✗ if (!fg->graph->filters[i]->hw_device_ctx)
578 ✗ return AVERROR(ENOMEM);
579 }
580 }
581
582 5858 return 0;
583 }
584