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