Not yet enabled for any device types.
---
Makefile | 2 +-
avconv.c | 22 ++++
avconv.h | 16 +++
avconv_hw.c | 391 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
avconv_opt.c | 8 ++
5 files changed, 438 insertions(+), 1 deletion(-)
create mode 100644 avconv_hw.c
diff --git a/Makefile b/Makefile
index 98eb3ab1d..fc661c546 100644
--- a/Makefile
+++ b/Makefile
@@ -81,7 +81,7 @@ ALLAVPROGS = $(AVBASENAMES:%=%$(EXESUF))
$(foreach prog,$(AVBASENAMES),$(eval OBJS-$(prog) += cmdutils.o))
-OBJS-avconv += avconv_opt.o avconv_filter.o
+OBJS-avconv += avconv_opt.o avconv_filter.o avconv_hw.o
OBJS-avconv-$(CONFIG_LIBMFX) += avconv_qsv.o
OBJS-avconv-$(CONFIG_VAAPI) += avconv_vaapi.o
OBJS-avconv-$(CONFIG_VDA) += avconv_vda.o
diff --git a/avconv.c b/avconv.c
index 5c36761c1..3f5806788 100644
--- a/avconv.c
+++ b/avconv.c
@@ -1704,6 +1704,17 @@ static int init_input_stream(int ist_index, char *error,
int error_len)
if (!av_dict_get(ist->decoder_opts, "threads", NULL, 0))
av_dict_set(&ist->decoder_opts, "threads", "auto", 0);
+
+ ret = hw_device_setup_for_decode(ist);
+ if (ret < 0) {
+ char errbuf[128];
+ av_strerror(ret, errbuf, sizeof(errbuf));
+ snprintf(error, error_len, "Device setup failed for "
+ "decoder on input stream #%d:%d : %s",
+ ist->file_index, ist->st->index, errbuf);
+ return ret;
+ }
+
if ((ret = avcodec_open2(ist->dec_ctx, codec, &ist->decoder_opts)) <
0) {
char errbuf[128];
if (ret == AVERROR_EXPERIMENTAL)
@@ -2046,6 +2057,16 @@ static int init_output_stream(OutputStream *ost, char
*error, int error_len)
ost->enc_ctx->hw_frames_ctx =
av_buffer_ref(ost->filter->filter->inputs[0]->hw_frames_ctx);
if (!ost->enc_ctx->hw_frames_ctx)
return AVERROR(ENOMEM);
+ } else {
+ ret = hw_device_setup_for_encode(ost);
+ if (ret < 0) {
+ char errbuf[128];
+ av_strerror(ret, errbuf, sizeof(errbuf));
+ snprintf(error, error_len, "Device setup failed for "
+ "encoder on output stream #%d:%d : %s",
+ ost->file_index, ost->index, errbuf);
+ return ret;
+ }
}
if ((ret = avcodec_open2(ost->enc_ctx, codec, &ost->encoder_opts)) <
0) {
@@ -2795,6 +2816,7 @@ static int transcode(void)
}
av_buffer_unref(&hw_device_ctx);
+ hw_device_free_all();
/* finished ! */
ret = 0;
diff --git a/avconv.h b/avconv.h
index 3c3f0ef65..4c87e77b3 100644
--- a/avconv.h
+++ b/avconv.h
@@ -40,6 +40,7 @@
#include "libavutil/avutil.h"
#include "libavutil/dict.h"
#include "libavutil/fifo.h"
+#include "libavutil/hwcontext.h"
#include "libavutil/pixfmt.h"
#include "libavutil/rational.h"
@@ -65,6 +66,12 @@ typedef struct HWAccel {
enum AVPixelFormat pix_fmt;
} HWAccel;
+typedef struct HWDevice {
+ char *name;
+ enum AVHWDeviceType type;
+ AVBufferRef *device_ref;
+} HWDevice;
+
/* select an input stream for an output stream */
typedef struct StreamMap {
int disabled; /* 1 is this mapping is disabled by a negative map
*/
@@ -510,4 +517,13 @@ int qsv_transcode_init(OutputStream *ost);
int vaapi_decode_init(AVCodecContext *avctx);
int vaapi_device_init(const char *device);
+HWDevice *hw_device_get_by_name(const char *name);
+int hw_device_init_from_string(const char *arg, HWDevice **dev);
+void hw_device_free_all(void);
+
+int hw_device_setup_for_decode(InputStream *ist);
+int hw_device_setup_for_encode(OutputStream *ost);
+
+int hwaccel_decode_init(AVCodecContext *avctx);
+
#endif /* AVCONV_H */
diff --git a/avconv_hw.c b/avconv_hw.c
new file mode 100644
index 000000000..dc712c524
--- /dev/null
+++ b/avconv_hw.c
@@ -0,0 +1,391 @@
+/*
+ * This file is part of Libav.
+ *
+ * Libav is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * Libav is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with Libav; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#include <string.h>
+
+#include "avconv.h"
+
+static int nb_hw_devices;
+static HWDevice **hw_devices;
+
+typedef struct HWDeviceType {
+ const char *name;
+ enum AVHWDeviceType type;
+ enum HWAccelID hwaccel_id;
+} HWDeviceType;
+
+const HWDeviceType hw_device_types[] = {
+};
+
+static const HWDeviceType *hw_device_get_type_by_name(const char *name)
+{
+ enum AVHWDeviceType type;
+ int i;
+ type = av_hwdevice_find_type_by_name(name);
+ if (type < 0)
+ return NULL;
+ for (i = 0; i < FF_ARRAY_ELEMS(hw_device_types); i++) {
+ if (hw_device_types[i].type == type)
+ return &hw_device_types[i];
+ }
+ return NULL;
+}
+
+static HWDevice *hw_device_get_by_type(enum AVHWDeviceType type)
+{
+ HWDevice *found = NULL;
+ int i;
+ for (i = 0; i < nb_hw_devices; i++) {
+ if (hw_devices[i]->type == type) {
+ if (found)
+ return NULL;
+ found = hw_devices[i];
+ }
+ }
+ return found;
+}
+
+HWDevice *hw_device_get_by_name(const char *name)
+{
+ int i;
+ for (i = 0; i < nb_hw_devices; i++) {
+ if (!strcmp(hw_devices[i]->name, name))
+ return hw_devices[i];
+ }
+ return NULL;
+}
+
+static HWDevice *hw_device_new(void)
+{
+ int err;
+ err = av_reallocp_array(&hw_devices, nb_hw_devices + 1,
+ sizeof(*hw_devices));
+ if (err) {
+ nb_hw_devices = 0;
+ return NULL;
+ }
+ hw_devices[nb_hw_devices] = av_mallocz(sizeof(HWDevice));
+ if (!hw_devices[nb_hw_devices])
+ return NULL;
+ return hw_devices[nb_hw_devices++];
+}
+
+int hw_device_init_from_string(const char *arg, HWDevice **dev_out)
+{
+ // "type=name:device,key=value,key2=value2"
+ // "type:device,key=value,key2=value2"
+ // -> av_hwdevice_ctx_create()
+ // "type=name@name"
+ // "type@name"
+ // -> av_hwdevice_ctx_create_derived()
+
+ AVDictionary *options = NULL;
+ char *type_name = NULL, *name = NULL, *device = NULL;
+ const HWDeviceType *type;
+ HWDevice *dev, *src;
+ AVBufferRef *device_ref;
+ int err;
+ const char *errmsg, *p, *q;
+
+ for (p = arg; *p && *p != ':' && *p != '=' && *p != '@'; p++);
+
+ type_name = av_strndup(arg, p - arg);
+ if (!type_name) {
+ err = AVERROR(ENOMEM);
+ goto fail;
+ }
+ type = hw_device_get_type_by_name(type_name);
+ if (!type) {
+ errmsg = "unknown device type";
+ goto invalid;
+ }
+
+ if (*p == '=') {
+ for (q = ++p; *q && *q != ':' && *q != '@'; q++);
+
+ name = av_strndup(p, q - p);
+ if (!name) {
+ err = AVERROR(ENOMEM);
+ goto fail;
+ }
+ if (hw_device_get_by_name(name)) {
+ errmsg = "named device already exists";
+ goto invalid;
+ }
+
+ p = q;
+ } else {
+ // Give the device an automatic name of the form "type%d".
+ // We arbitrarily limit at 1000 anonymous devices of the same
+ // type - there is probably something else very wrong if you
+ // get to this limit.
+ size_t index_pos;
+ int index, index_limit = 1000;
+ index_pos = strlen(type->name);
+ name = av_malloc(index_pos + 4);
+ if (!name) {
+ err = AVERROR(ENOMEM);
+ goto fail;
+ }
+ for (index = 0; index < index_limit; index++) {
+ snprintf(name, index_pos + 4, "%s%d", type->name, index);
+ if (!hw_device_get_by_name(name))
+ break;
+ }
+ if (index >= index_limit) {
+ errmsg = "too many devices";
+ goto invalid;
+ }
+ }
+
+ if (!*p) {
+ // New device with no parameters.
+ err = av_hwdevice_ctx_create(&device_ref, type->type,
+ NULL, NULL, 0);
+ if (err < 0)
+ goto fail;
+
+ } else if (*p == ':') {
+ // New device with some parameters.
+ ++p;
+ q = strchr(p, ',');
+ if (q) {
+ device = av_strndup(p, q - p);
+ if (!device) {
+ err = AVERROR(ENOMEM);
+ goto fail;
+ }
+ err = av_dict_parse_string(&options, q + 1, "=", ",", 0);
+ if (err < 0) {
+ errmsg = "failed to parse options";
+ goto invalid;
+ }
+ }
+
+ err = av_hwdevice_ctx_create(&device_ref, type->type,
+ device ? device : p, options, 0);
+ if (err < 0)
+ goto fail;
+
+ } else if (*p == '@') {
+ // Derive from existing device.
+
+ src = hw_device_get_by_name(p + 1);
+ if (!src) {
+ errmsg = "invalid source device name";
+ goto invalid;
+ }
+
+ err = av_hwdevice_ctx_create_derived(&device_ref, type->type,
+ src->device_ref, 0);
+ if (err < 0)
+ goto fail;
+ } else {
+ errmsg = "parse error";
+ goto invalid;
+ }
+
+ dev = hw_device_new();
+ if (!dev) {
+ err = AVERROR(ENOMEM);
+ goto fail;
+ }
+
+ dev->name = name;
+ dev->type = type->type;
+ dev->device_ref = device_ref;
+
+ if (dev_out)
+ *dev_out = dev;
+
+ name = NULL;
+ err = 0;
+done:
+ av_freep(&type_name);
+ av_freep(&name);
+ av_freep(&device);
+ av_dict_free(&options);
+ return err;
+invalid:
+ av_log(NULL, AV_LOG_ERROR,
+ "Invalid device specification \"%s\": %s\n", arg, errmsg);
+ err = AVERROR(EINVAL);
+ goto done;
+fail:
+ av_log(NULL, AV_LOG_ERROR,
+ "Device creation failed: %d.\n", err);
+ goto done;
+}
+
+void hw_device_free_all(void)
+{
+ int i;
+ for (i = 0; i < nb_hw_devices; i++) {
+ av_freep(&hw_devices[i]->name);
+ av_buffer_unref(&hw_devices[i]->device_ref);
+ av_freep(&hw_devices[i]);
+ }
+ av_freep(&hw_devices);
+ nb_hw_devices = 0;
+}
+
+static const HWDeviceType *hw_device_match_type_by_hwaccel(enum HWAccelID
hwaccel_id)
+{
+ int i;
+ if (hwaccel_id == HWACCEL_NONE)
+ return NULL;
+ for (i = 0; i < FF_ARRAY_ELEMS(hw_device_types); i++) {
+ if (hw_device_types[i].hwaccel_id == hwaccel_id)
+ return &hw_device_types[i];
+ }
+ return NULL;
+}
+
+static const HWDeviceType *hw_device_match_type_in_name(const char *codec_name)
+{
+ int i;
+ for (i = 0; i < FF_ARRAY_ELEMS(hw_device_types); i++) {
+ if (strstr(hw_device_types[i].name, codec_name))
+ return &hw_device_types[i];
+ }
+ return NULL;
+}
+
+int hw_device_setup_for_decode(InputStream *ist)
+{
+ const HWDeviceType *type;
+ HWDevice *dev;
+ int err;
+
+ if (ist->hwaccel_device) {
+ dev = hw_device_get_by_name(ist->hwaccel_device);
+ if (!dev) {
+ char *tmp;
+ size_t len;
+ type = hw_device_match_type_by_hwaccel(ist->hwaccel_id);
+ if (!type) {
+ // No match - this isn't necessarily invalid, though,
+ // because an explicit device might not be needed or
+ // the hwaccel setup could be handled elsewhere.
+ return 0;
+ }
+ len = strlen(type->name) + 1 +
+ strlen(ist->hwaccel_device) + 1;
+ tmp = av_malloc(len);
+ if (!tmp)
+ return AVERROR(ENOMEM);
+ snprintf(tmp, len, "%s:%s", type->name, ist->hwaccel_device);
+ err = hw_device_init_from_string(tmp, &dev);
+ av_free(tmp);
+ if (err < 0)
+ return err;
+ }
+ } else {
+ if (ist->hwaccel_id != HWACCEL_NONE)
+ type = hw_device_match_type_by_hwaccel(ist->hwaccel_id);
+ else
+ type = hw_device_match_type_in_name(ist->dec->name);
+ if (type) {
+ dev = hw_device_get_by_type(type->type);
+ } else {
+ // Hopefully we don't need a device.
+ return 0;
+ }
+ }
+
+ if (!dev)
+ return AVERROR(ENODEV);
+
+ ist->dec_ctx->hw_device_ctx = av_buffer_ref(dev->device_ref);
+ if (!ist->dec_ctx->hw_device_ctx)
+ return AVERROR(ENOMEM);
+
+ return 0;
+}
+
+int hw_device_setup_for_encode(OutputStream *ost)
+{
+ const HWDeviceType *type;
+ HWDevice *dev;
+
+ type = hw_device_match_type_in_name(ost->enc->name);
+ if (type) {
+ dev = hw_device_get_by_type(type->type);
+ if (!dev)
+ return AVERROR(ENODEV);
+ ost->enc_ctx->hw_device_ctx = av_buffer_ref(dev->device_ref);
+ if (!ost->enc_ctx->hw_device_ctx)
+ return AVERROR(ENOMEM);
+ return 0;
+ } else {
+ // Hopefully we don't need a device.
+ return 0;
+ }
+}
+
+static int hwaccel_retrieve_data(AVCodecContext *avctx, AVFrame *input)
+{
+ InputStream *ist = avctx->opaque;
+ AVFrame *output = 0;
+ enum AVPixelFormat output_format = ist->hwaccel_output_format;
+ int err;
+
+ if (input->format == output_format) {
+ // Nothing to do.
+ return 0;
+ }
+
+ output = av_frame_alloc();
+ if (!output)
+ return AVERROR(ENOMEM);
+
+ output->format = output_format;
+
+ err = av_hwframe_transfer_data(output, input, 0);
+ if (err < 0) {
+ av_log(avctx, AV_LOG_ERROR, "Failed to transfer data to "
+ "output frame: %d.\n", err);
+ goto fail;
+ }
+
+ err = av_frame_copy_props(output, input);
+ if (err < 0) {
+ av_frame_unref(output);
+ goto fail;
+ }
+
+ av_frame_unref(input);
+ av_frame_move_ref(input, output);
+ av_frame_free(&output);
+
+ return 0;
+
+fail:
+ if (output)
+ av_frame_free(&output);
+ return err;
+}
+
+int hwaccel_decode_init(AVCodecContext *avctx)
+{
+ InputStream *ist = avctx->opaque;
+
+ ist->hwaccel_retrieve_data = &hwaccel_retrieve_data;
+
+ return 0;
+}
diff --git a/avconv_opt.c b/avconv_opt.c
index e078a0b89..e6b7a9528 100644
--- a/avconv_opt.c
+++ b/avconv_opt.c
@@ -337,6 +337,11 @@ static int opt_vaapi_device(void *optctx, const char *opt,
const char *arg)
}
#endif
+static int opt_init_hw_device(void *optctx, const char *opt, const char *arg)
+{
+ return hw_device_init_from_string(arg, NULL);
+}
+
/**
* Parse a metadata specifier passed as 'arg' parameter.
* @param arg metadata string to parse
@@ -2741,5 +2746,8 @@ const OptionDef options[] = {
"set VAAPI hardware device (DRM path or X11 display name)", "device" },
#endif
+ { "init_hw_device", HAS_ARG | OPT_EXPERT, { .func_arg = opt_init_hw_device
},
+ "initialise hardware device", "args" },
+
{ NULL, },
};
--
2.11.0
_______________________________________________
libav-devel mailing list
[email protected]
https://lists.libav.org/mailman/listinfo/libav-devel
