Directory: | ../../../ffmpeg/ |
---|---|
File: | src/fftools/ffmpeg_hw.c |
Date: | 2022-07-04 19:11:22 |
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 | 1613 | static HWDevice *hw_device_get_by_type(enum AVHWDeviceType type) | |
31 | { | ||
32 | 1613 | HWDevice *found = NULL; | |
33 | int i; | ||
34 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 1613 times.
|
1613 | 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 | 1613 | 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 | 6248 | void hw_device_free_all(void) | |
289 | { | ||
290 | int i; | ||
291 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 6248 times.
|
6248 | 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 | 6248 | av_freep(&hw_devices); | |
297 | 6248 | nb_hw_devices = 0; | |
298 | 6248 | } | |
299 | |||
300 | 6017 | static HWDevice *hw_device_match_by_codec(const AVCodec *codec) | |
301 | { | ||
302 | const AVCodecHWConfig *config; | ||
303 | HWDevice *dev; | ||
304 | int i; | ||
305 | 6017 | for (i = 0;; i++) { | |
306 | 7630 | config = avcodec_get_hw_config(codec, i); | |
307 |
2/2✓ Branch 0 taken 6017 times.
✓ Branch 1 taken 1613 times.
|
7630 | if (!config) |
308 | 6017 | return NULL; | |
309 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 1613 times.
|
1613 | if (!(config->methods & AV_CODEC_HW_CONFIG_METHOD_HW_DEVICE_CTX)) |
310 | ✗ | continue; | |
311 | 1613 | dev = hw_device_get_by_type(config->device_type); | |
312 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 1613 times.
|
1613 | if (dev) |
313 | ✗ | return dev; | |
314 | } | ||
315 | } | ||
316 | |||
317 | 6017 | int hw_device_setup_for_decode(InputStream *ist) | |
318 | { | ||
319 | const AVCodecHWConfig *config; | ||
320 | enum AVHWDeviceType type; | ||
321 | 6017 | HWDevice *dev = NULL; | |
322 | 6017 | int err, auto_device = 0; | |
323 | |||
324 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 6017 times.
|
6017 | 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 6017 times.
|
6017 | if (ist->hwaccel_id == HWACCEL_AUTO) { |
352 | ✗ | auto_device = 1; | |
353 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 6017 times.
|
6017 | } 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 | 6017 | dev = hw_device_match_by_codec(ist->dec); | |
372 |
1/2✓ Branch 0 taken 6017 times.
✗ Branch 1 not taken.
|
6017 | if (!dev) { |
373 | // No device for this codec, but not using generic hwaccel | ||
374 | // and therefore may well not need one - ignore. | ||
375 | 6017 | 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 | 6053 | int hw_device_setup_for_encode(OutputStream *ost) | |
446 | { | ||
447 | const AVCodecHWConfig *config; | ||
448 | 6053 | HWDevice *dev = NULL; | |
449 | 6053 | AVBufferRef *frames_ref = NULL; | |
450 | int i; | ||
451 | |||
452 |
2/2✓ Branch 0 taken 6017 times.
✓ Branch 1 taken 36 times.
|
6053 | if (ost->filter) { |
453 | 6017 | frames_ref = av_buffersink_get_hw_frames_ctx(ost->filter->filter); | |
454 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 6017 times.
|
6017 | 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 | 6017 | frames_ref = NULL; | |
460 | } | ||
461 | } | ||
462 | |||
463 | 6053 | for (i = 0;; i++) { | |
464 | 6053 | config = avcodec_get_hw_config(ost->enc, i); | |
465 |
1/2✓ Branch 0 taken 6053 times.
✗ Branch 1 not taken.
|
6053 | if (!config) |
466 | 6053 | 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 6053 times.
|
6053 | 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 | 6053 | 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 | 6046 | 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 6046 times.
|
6046 | if (filter_hw_device) |
559 | ✗ | dev = filter_hw_device; | |
560 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 6046 times.
|
6046 | 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 | 6046 | dev = NULL; | |
572 | |||
573 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 6046 times.
|
6046 | 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 | 6046 | return 0; | |
583 | } | ||
584 |