git.sesse.net Git - ffmpeg/blob - ffmpeg_hw.c

   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
  23 #include "ffmpeg.h"
  24
  25 static int nb_hw_devices;
  26 static HWDevice **hw_devices;
  27
  28 static HWDevice *hw_device_get_by_type(enum AVHWDeviceType type)
  29 {
  30     HWDevice *found = NULL;
  31     int i;
  32     for (i = 0; i < nb_hw_devices; i++) {
  33         if (hw_devices[i]->type == type) {
  34             if (found)
  35                 return NULL;
  36             found = hw_devices[i];
  37         }
  38     }
  39     return found;
  40 }
  41
  42 HWDevice *hw_device_get_by_name(const char *name)
  43 {
  44     int i;
  45     for (i = 0; i < nb_hw_devices; i++) {
  46         if (!strcmp(hw_devices[i]->name, name))
  47             return hw_devices[i];
  48     }
  49     return NULL;
  50 }
  51
  52 static HWDevice *hw_device_add(void)
  53 {
  54     int err;
  55     err = av_reallocp_array(&hw_devices, nb_hw_devices + 1,
  56                             sizeof(*hw_devices));
  57     if (err) {
  58         nb_hw_devices = 0;
  59         return NULL;
  60     }
  61     hw_devices[nb_hw_devices] = av_mallocz(sizeof(HWDevice));
  62     if (!hw_devices[nb_hw_devices])
  63         return NULL;
  64     return hw_devices[nb_hw_devices++];
  65 }
  66
  67 int hw_device_init_from_string(const char *arg, HWDevice **dev_out)
  68 {
  69     // "type=name:device,key=value,key2=value2"
  70     // "type:device,key=value,key2=value2"
  71     // -> av_hwdevice_ctx_create()
  72     // "type=name@name"
  73     // "type@name"
  74     // -> av_hwdevice_ctx_create_derived()
  75
  76     AVDictionary *options = NULL;
  77     char *type_name = NULL, *name = NULL, *device = NULL;
  78     enum AVHWDeviceType type;
  79     HWDevice *dev, *src;
  80     AVBufferRef *device_ref = NULL;
  81     int err;
  82     const char *errmsg, *p, *q;
  83     size_t k;
  84
  85     k = strcspn(arg, ":=@");
  86     p = arg + k;
  87
  88     type_name = av_strndup(arg, k);
  89     if (!type_name) {
  90         err = AVERROR(ENOMEM);
  91         goto fail;
  92     }
  93     type = av_hwdevice_find_type_by_name(type_name);
  94     if (type == AV_HWDEVICE_TYPE_NONE) {
  95         errmsg = "unknown device type";
  96         goto invalid;
  97     }
  98
  99     if (*p == '=') {
 100         k = strcspn(p + 1, ":@");
 101
 102         name = av_strndup(p + 1, k);
 103         if (!name) {
 104             err = AVERROR(ENOMEM);
 105             goto fail;
 106         }
 107         if (hw_device_get_by_name(name)) {
 108             errmsg = "named device already exists";
 109             goto invalid;
 110         }
 111
 112         p += 1 + k;
 113     } else {
 114         // Give the device an automatic name of the form "type%d".
 115         // We arbitrarily limit at 1000 anonymous devices of the same
 116         // type - there is probably something else very wrong if you
 117         // get to this limit.
 118         size_t index_pos;
 119         int index, index_limit = 1000;
 120         index_pos = strlen(type_name);
 121         name = av_malloc(index_pos + 4);
 122         if (!name) {
 123             err = AVERROR(ENOMEM);
 124             goto fail;
 125         }
 126         for (index = 0; index < index_limit; index++) {
 127             snprintf(name, index_pos + 4, "%s%d", type_name, index);
 128             if (!hw_device_get_by_name(name))
 129                 break;
 130         }
 131         if (index >= index_limit) {
 132             errmsg = "too many devices";
 133             goto invalid;
 134         }
 135     }
 136
 137     if (!*p) {
 138         // New device with no parameters.
 139         err = av_hwdevice_ctx_create(&device_ref, type,
 140                                      NULL, NULL, 0);
 141         if (err < 0)
 142             goto fail;
 143
 144     } else if (*p == ':') {
 145         // New device with some parameters.
 146         ++p;
 147         q = strchr(p, ',');
 148         if (q) {
 149             device = av_strndup(p, q - p);
 150             if (!device) {
 151                 err = AVERROR(ENOMEM);
 152                 goto fail;
 153             }
 154             err = av_dict_parse_string(&options, q + 1, "=", ",", 0);
 155             if (err < 0) {
 156                 errmsg = "failed to parse options";
 157                 goto invalid;
 158             }
 159         }
 160
 161         err = av_hwdevice_ctx_create(&device_ref, type,
 162                                      device ? device : p, options, 0);
 163         if (err < 0)
 164             goto fail;
 165
 166     } else if (*p == '@') {
 167         // Derive from existing device.
 168
 169         src = hw_device_get_by_name(p + 1);
 170         if (!src) {
 171             errmsg = "invalid source device name";
 172             goto invalid;
 173         }
 174
 175         err = av_hwdevice_ctx_create_derived(&device_ref, type,
 176                                              src->device_ref, 0);
 177         if (err < 0)
 178             goto fail;
 179     } else {
 180         errmsg = "parse error";
 181         goto invalid;
 182     }
 183
 184     dev = hw_device_add();
 185     if (!dev) {
 186         err = AVERROR(ENOMEM);
 187         goto fail;
 188     }
 189
 190     dev->name = name;
 191     dev->type = type;
 192     dev->device_ref = device_ref;
 193
 194     if (dev_out)
 195         *dev_out = dev;
 196
 197     name = NULL;
 198     err = 0;
 199 done:
 200     av_freep(&type_name);
 201     av_freep(&name);
 202     av_freep(&device);
 203     av_dict_free(&options);
 204     return err;
 205 invalid:
 206     av_log(NULL, AV_LOG_ERROR,
 207            "Invalid device specification \"%s\": %s\n", arg, errmsg);
 208     err = AVERROR(EINVAL);
 209     goto done;
 210 fail:
 211     av_log(NULL, AV_LOG_ERROR,
 212            "Device creation failed: %d.\n", err);
 213     av_buffer_unref(&device_ref);
 214     goto done;
 215 }
 216
 217 void hw_device_free_all(void)
 218 {
 219     int i;
 220     for (i = 0; i < nb_hw_devices; i++) {
 221         av_freep(&hw_devices[i]->name);
 222         av_buffer_unref(&hw_devices[i]->device_ref);
 223         av_freep(&hw_devices[i]);
 224     }
 225     av_freep(&hw_devices);
 226     nb_hw_devices = 0;
 227 }
 228
 229 static enum AVHWDeviceType hw_device_match_type_by_hwaccel(enum HWAccelID hwaccel_id)
 230 {
 231     int i;
 232     if (hwaccel_id == HWACCEL_NONE)
 233         return AV_HWDEVICE_TYPE_NONE;
 234     for (i = 0; hwaccels[i].name; i++) {
 235         if (hwaccels[i].id == hwaccel_id)
 236             return hwaccels[i].device_type;
 237     }
 238     return AV_HWDEVICE_TYPE_NONE;
 239 }
 240
 241 static enum AVHWDeviceType hw_device_match_type_in_name(const char *codec_name)
 242 {
 243     const char *type_name;
 244     enum AVHWDeviceType type;
 245     for (type = av_hwdevice_iterate_types(AV_HWDEVICE_TYPE_NONE);
 246          type != AV_HWDEVICE_TYPE_NONE;
 247          type = av_hwdevice_iterate_types(type)) {
 248         type_name = av_hwdevice_get_type_name(type);
 249         if (strstr(codec_name, type_name))
 250             return type;
 251     }
 252     return AV_HWDEVICE_TYPE_NONE;
 253 }
 254
 255 int hw_device_setup_for_decode(InputStream *ist)
 256 {
 257     enum AVHWDeviceType type;
 258     HWDevice *dev;
 259     int err;
 260
 261     if (ist->hwaccel_device) {
 262         dev = hw_device_get_by_name(ist->hwaccel_device);
 263         if (!dev) {
 264             char *tmp;
 265             type = hw_device_match_type_by_hwaccel(ist->hwaccel_id);
 266             if (type == AV_HWDEVICE_TYPE_NONE) {
 267                 // No match - this isn't necessarily invalid, though,
 268                 // because an explicit device might not be needed or
 269                 // the hwaccel setup could be handled elsewhere.
 270                 return 0;
 271             }
 272             tmp = av_asprintf("%s:%s", av_hwdevice_get_type_name(type),
 273                               ist->hwaccel_device);
 274             if (!tmp)
 275                 return AVERROR(ENOMEM);
 276             err = hw_device_init_from_string(tmp, &dev);
 277             av_free(tmp);
 278             if (err < 0)
 279                 return err;
 280         }
 281     } else {
 282         if (ist->hwaccel_id != HWACCEL_NONE)
 283             type = hw_device_match_type_by_hwaccel(ist->hwaccel_id);
 284         else
 285             type = hw_device_match_type_in_name(ist->dec->name);
 286         if (type != AV_HWDEVICE_TYPE_NONE) {
 287             dev = hw_device_get_by_type(type);
 288             if (!dev) {
 289                 hw_device_init_from_string(av_hwdevice_get_type_name(type),
 290                                            &dev);
 291             }
 292         } else {
 293             // No device required.
 294             return 0;
 295         }
 296     }
 297
 298     if (!dev) {
 299         av_log(ist->dec_ctx, AV_LOG_WARNING, "No device available "
 300                "for decoder (device type %s for codec %s).\n",
 301                av_hwdevice_get_type_name(type), ist->dec->name);
 302         return 0;
 303     }
 304
 305     ist->dec_ctx->hw_device_ctx = av_buffer_ref(dev->device_ref);
 306     if (!ist->dec_ctx->hw_device_ctx)
 307         return AVERROR(ENOMEM);
 308
 309     return 0;
 310 }
 311
 312 int hw_device_setup_for_encode(OutputStream *ost)
 313 {
 314     enum AVHWDeviceType type;
 315     HWDevice *dev;
 316
 317     type = hw_device_match_type_in_name(ost->enc->name);
 318     if (type != AV_HWDEVICE_TYPE_NONE) {
 319         dev = hw_device_get_by_type(type);
 320         if (!dev) {
 321             av_log(ost->enc_ctx, AV_LOG_WARNING, "No device available "
 322                    "for encoder (device type %s for codec %s).\n",
 323                    av_hwdevice_get_type_name(type), ost->enc->name);
 324             return 0;
 325         }
 326         ost->enc_ctx->hw_device_ctx = av_buffer_ref(dev->device_ref);
 327         if (!ost->enc_ctx->hw_device_ctx)
 328             return AVERROR(ENOMEM);
 329         return 0;
 330     } else {
 331         // No device required.
 332         return 0;
 333     }
 334 }
 335
 336 static int hwaccel_retrieve_data(AVCodecContext *avctx, AVFrame *input)
 337 {
 338     InputStream *ist = avctx->opaque;
 339     AVFrame *output = NULL;
 340     enum AVPixelFormat output_format = ist->hwaccel_output_format;
 341     int err;
 342
 343     if (input->format == output_format) {
 344         // Nothing to do.
 345         return 0;
 346     }
 347
 348     output = av_frame_alloc();
 349     if (!output)
 350         return AVERROR(ENOMEM);
 351
 352     output->format = output_format;
 353
 354     err = av_hwframe_transfer_data(output, input, 0);
 355     if (err < 0) {
 356         av_log(avctx, AV_LOG_ERROR, "Failed to transfer data to "
 357                "output frame: %d.\n", err);
 358         goto fail;
 359     }
 360
 361     err = av_frame_copy_props(output, input);
 362     if (err < 0) {
 363         av_frame_unref(output);
 364         goto fail;
 365     }
 366
 367     av_frame_unref(input);
 368     av_frame_move_ref(input, output);
 369     av_frame_free(&output);
 370
 371     return 0;
 372
 373 fail:
 374     av_frame_free(&output);
 375     return err;
 376 }
 377
 378 int hwaccel_decode_init(AVCodecContext *avctx)
 379 {
 380     InputStream *ist = avctx->opaque;
 381
 382     ist->hwaccel_retrieve_data = &hwaccel_retrieve_data;
 383
 384     return 0;
 385 }