From patchwork Mon Jun 5 17:31:10 2017 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Aaron Colwell X-Patchwork-Id: 3842 Delivered-To: ffmpegpatchwork@gmail.com Received: by 10.103.10.2 with SMTP id 2csp1464048vsk; Mon, 5 Jun 2017 10:31:34 -0700 (PDT) X-Received: by 10.223.173.23 with SMTP id p23mr6201538wrc.56.1496683894424; Mon, 05 Jun 2017 10:31:34 -0700 (PDT) ARC-Seal: i=1; a=rsa-sha256; t=1496683894; cv=none; d=google.com; s=arc-20160816; b=soSQnZgRHz3X+/t5gprKceblFgfKRYO5lSTf6k414/2LTFtiGMIqEsBCKgrn24woy9 JuZaSB9PatPk7P7CZgA1fOj8IsRNy7fyZoRs31I1Y4E6kO8kSdE3DyQZwJ4L34dusGmc /UnNojqNeB2Jn3/Y9KirQuqXTCg6nBiRuLlBzAXuWuKVLNprc9tQlshaLH3KSAgh7luX rtGu69m5gn1xHpC5t7EECzPxWeNkygzYPUWF89aTGwjks7qQAIMmexO51yEwQTApLfnX Lp1mcDHJmEr7Zi9K8bdTOb2cAv38Bj4zNnFteeOvI1vZgEo1GNjQjxGTxg/vbSvWs00/ eOCg== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=arc-20160816; h=sender:errors-to:reply-to:list-subscribe:list-help:list-post :list-archive:list-unsubscribe:list-id:precedence:subject:to :message-id:date:from:mime-version:dkim-signature:delivered-to :arc-authentication-results; bh=wlHZZ1o7/0Ldxs0to9cLdadpkQ8WlYBdB2DArw9EmkE=; b=AMWmp7kIomvDCUHlacZIxHrQiHchzZiTUCt+lzoGAUEGIeWfVGpz0kbssV9WQ5s4sw nY4oXl+Efe2u4WScdbV21Ay1eNCfuqI9/G/7+qogNod9M0F27RvgN7mUx3eG3rhuEReQ 2fY1PYAu7Pxakd+MDrV50c42XAY7q58DJxtSfb9g9lzQQmqinLTyO/y6RnP4QyJE0s4U ZF0leKbh9t6HoFkzd+O12ZOA4KBdw99gFYtSWqJYvefpOh61QhvjwRG/L9gne0ogyARX HdP3yvbooxtJdJFFCVrvs4jl2yf8cljSS03pL2+j8bVmdEJzV0QNOttCXEBQyVCN3lW+ NwJg== ARC-Authentication-Results: i=1; mx.google.com; dkim=neutral (body hash did not verify) header.i=@google.com; spf=pass (google.com: domain of ffmpeg-devel-bounces@ffmpeg.org designates 79.124.17.100 as permitted sender) smtp.mailfrom=ffmpeg-devel-bounces@ffmpeg.org Return-Path: Received: from ffbox0-bg.mplayerhq.hu (ffbox0-bg.ffmpeg.org. [79.124.17.100]) by mx.google.com with ESMTP id r139si4734319wmb.66.2017.06.05.10.31.33; Mon, 05 Jun 2017 10:31:34 -0700 (PDT) Received-SPF: pass (google.com: domain of ffmpeg-devel-bounces@ffmpeg.org designates 79.124.17.100 as permitted sender) client-ip=79.124.17.100; Authentication-Results: mx.google.com; dkim=neutral (body hash did not verify) header.i=@google.com; spf=pass (google.com: domain of ffmpeg-devel-bounces@ffmpeg.org designates 79.124.17.100 as permitted sender) smtp.mailfrom=ffmpeg-devel-bounces@ffmpeg.org Received: from [127.0.1.1] (localhost [127.0.0.1]) by ffbox0-bg.mplayerhq.hu (Postfix) with ESMTP id 54A34689C07; Mon, 5 Jun 2017 20:31:24 +0300 (EEST) X-Original-To: ffmpeg-devel@ffmpeg.org Delivered-To: ffmpeg-devel@ffmpeg.org Received: from mail-ot0-f175.google.com (mail-ot0-f175.google.com [74.125.82.175]) by ffbox0-bg.mplayerhq.hu (Postfix) with ESMTPS id 16A596898AF for ; Mon, 5 Jun 2017 20:31:17 +0300 (EEST) Received: by mail-ot0-f175.google.com with SMTP id i31so94042ota.3 for ; Mon, 05 Jun 2017 10:31:23 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=20161025; h=mime-version:from:date:message-id:subject:to; bh=cIaND1cP/GFSPeTcNM2GtWih/mC3rkkG89EECQeVq3k=; b=JLzoxPYWYhomvfdG3g5HQSk10jBpc2BHfVgnwEXQ38MBY4JTnJ8xuxKXhmn3qFCdHh F94tSBFweZkLZzg3tthyPiwCWN9n+cscBm0U4uK4SeJi5H8wJ+3Kc3IGfa9SanuNuq46 4QkFmeGQhUtVlLpyXGclpaLj8r/aW1MPaq6COWJNctZR+IuDHpSO6i8scbu4n6hrH80Z peBpIl80bZ/rrv/YhZ7NTEmPwORnFwyo9jqNZdtNGqDN9Gl9YUQgRkbXHFo+KJv5osf/ tNS9zDnl6zb+ePynnWmZVVvzCy4rLE9ne73peQf7qksZIIPhk4D5HlepzJit99PuEw71 G9ag== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:mime-version:from:date:message-id:subject:to; bh=cIaND1cP/GFSPeTcNM2GtWih/mC3rkkG89EECQeVq3k=; b=T8+836zsF9aZaXN6+26MoLRnUPJEYJMTf8/+6A5tmWSru50M0Mc4UK9Iy8HvZJVyUl YEUiZI3PutR5hOj3bQkOHym4CqMZ8k2Tyjrzqxjj3utWKL+sZQdl48vLq736GC6gbhHg gdkOZXdFurvc/2vjkO3BeyLHWMyXIZYAACVJDRabc/ssVZJ93naHMNORZj0bAhjOV6B0 lDfEC0U6y5dM7ofgrRd2QNtzr9qO1Ib9K2zhKKNbIMpmtVHjIEUzLdBKS3LFNyP79g1u f8CQ0KUjcW+Yta8+Du2x/siA7rjpZ/zwpvfoLMqI9t0U8f1EiX0+VMyJOPgKxMKFtD6h doRA== X-Gm-Message-State: AKS2vOy3fhy54RnOqyJhfanx1qQM3l6B7VUy92jCdWFDfR/ieqE0+Ti0 xpKsn9VNCWG1mWSBRJfVi6aXYXSQDXX/eGs= X-Received: by 10.157.9.73 with SMTP id 67mr10917650otp.79.1496683882109; Mon, 05 Jun 2017 10:31:22 -0700 (PDT) MIME-Version: 1.0 From: Aaron Colwell Date: Mon, 05 Jun 2017 17:31:10 +0000 Message-ID: To: FFmpeg development discussions and patches X-Content-Filtered-By: Mailman/MimeDel 2.1.20 Subject: [FFmpeg-devel] [PATCH] Add spherical_mapping command-line argument to ffmpeg. X-BeenThere: ffmpeg-devel@ffmpeg.org X-Mailman-Version: 2.1.20 Precedence: list List-Id: FFmpeg development discussions and patches List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Reply-To: FFmpeg development discussions and patches Errors-To: ffmpeg-devel-bounces@ffmpeg.org Sender: "ffmpeg-devel" Add spherical_mapping command-line argument to ffmpeg. This allows adding AVSphericalMapping information to files that don't already have it. From eaa84a5f86d37e7de8bd0d6f72a308af57f3ef1d Mon Sep 17 00:00:00 2001 From: Aaron Colwell Date: Fri, 2 Jun 2017 16:11:21 -0700 Subject: [PATCH] Add spherical_mapping command-line argument to ffmpeg. This allows adding AVSphericalMapping information to files that don't already have it. --- ffmpeg.h | 3 ++ ffmpeg_opt.c | 29 ++++++++++++- libavutil/spherical.c | 113 ++++++++++++++++++++++++++++++++++++++++++++++++++ libavutil/spherical.h | 14 +++++++ 4 files changed, 158 insertions(+), 1 deletion(-) diff --git a/ffmpeg.h b/ffmpeg.h index a806445e0d..43a28d874f 100644 --- a/ffmpeg.h +++ b/ffmpeg.h @@ -44,6 +44,7 @@ #include "libavutil/fifo.h" #include "libavutil/pixfmt.h" #include "libavutil/rational.h" +#include "libavutil/spherical.h" #include "libavutil/threadmessage.h" #include "libswresample/swresample.h" @@ -228,6 +229,8 @@ typedef struct OptionsContext { int nb_time_bases; SpecifierOpt *enc_time_bases; int nb_enc_time_bases; + SpecifierOpt *spherical_mappings; + int nb_spherical_mappings; } OptionsContext; typedef struct InputFilter { diff --git a/ffmpeg_opt.c b/ffmpeg_opt.c index c997ea8faf..666b3791b7 100644 --- a/ffmpeg_opt.c +++ b/ffmpeg_opt.c @@ -1514,12 +1514,29 @@ static void check_streamcopy_filters(OptionsContext *o, AVFormatContext *oc, } } +static int set_spherical_mapping(const char* opt, AVStream* st) { + size_t spherical_mapping_size = 0; + AVSphericalMapping *spherical_mapping = NULL; + + int ret = av_spherical_parse_option(opt, &spherical_mapping, + &spherical_mapping_size); + if (ret >= 0) { + ret = av_stream_add_side_data(st, AV_PKT_DATA_SPHERICAL, spherical_mapping, spherical_mapping_size); + + if (ret < 0) { + av_freep(&spherical_mapping); + } + } + + return ret; +} + static OutputStream *new_video_stream(OptionsContext *o, AVFormatContext *oc, int source_index) { AVStream *st; OutputStream *ost; AVCodecContext *video_enc; - char *frame_rate = NULL, *frame_aspect_ratio = NULL; + char *frame_rate = NULL, *frame_aspect_ratio = NULL, *spherical_mapping = NULL; ost = new_output_stream(o, oc, AVMEDIA_TYPE_VIDEO, source_index); st = ost->st; @@ -1546,6 +1563,12 @@ static OutputStream *new_video_stream(OptionsContext *o, AVFormatContext *oc, in MATCH_PER_STREAM_OPT(filter_scripts, str, ost->filters_script, oc, st); MATCH_PER_STREAM_OPT(filters, str, ost->filters, oc, st); + MATCH_PER_STREAM_OPT(spherical_mappings, str, spherical_mapping, oc, st); + + if (spherical_mapping && set_spherical_mapping(spherical_mapping, st) < 0) { + av_log(NULL, AV_LOG_FATAL, "Invalid spherical_mapping: %s\n", spherical_mapping); + exit_program(1); + } if (!ost->stream_copy) { const char *p = NULL; @@ -3569,6 +3592,10 @@ const OptionDef options[] = { "automatically insert correct rotate filters" }, { "hwaccel_lax_profile_check", OPT_BOOL | OPT_EXPERT, { &hwaccel_lax_profile_check}, "attempt to decode anyway if HW accelerated decoder's supported profiles do not exactly match the stream" }, + { "spherical_mapping", OPT_VIDEO | HAS_ARG | OPT_STRING | OPT_SPEC | + OPT_OUTPUT, { .off = OFFSET(spherical_mappings) }, + "set spherical mapping for video stream", "spherical_mapping" }, + /* audio options */ { "aframes", OPT_AUDIO | HAS_ARG | OPT_PERFILE | OPT_OUTPUT, { .func_arg = opt_audio_frames }, diff --git a/libavutil/spherical.c b/libavutil/spherical.c index 4be55f36cf..508584d61f 100644 --- a/libavutil/spherical.c +++ b/libavutil/spherical.c @@ -19,6 +19,7 @@ */ #include "mem.h" +#include "opt.h" #include "spherical.h" AVSphericalMapping *av_spherical_alloc(size_t *size) @@ -77,3 +78,115 @@ int av_spherical_from_name(const char *name) return -1; } + +static const char *spherical_mapping_context_to_name(void *ptr) +{ + return "spherical_mapping"; +} + +typedef struct { + const AVClass* spherical_class; + int projection; + + double yaw; + double pitch; + double roll; + + int64_t bound_left; + int64_t bound_top; + int64_t bound_right; + int64_t bound_bottom; + + int64_t padding; +} SphericalMappingContext; + +#define OFFSET(x) offsetof(SphericalMappingContext, x) +#define DEFAULT 0 +#define FLAGS AV_OPT_FLAG_VIDEO_PARAM + +static const AVOption spherical_mapping_options[] = { + { "projection", "projection", OFFSET(projection), AV_OPT_TYPE_INT, + { .i64 = -1 }, -1, AV_SPHERICAL_EQUIRECTANGULAR_TILE, FLAGS, "projection" }, + { "equirectangular", "equirectangular projection", OFFSET(projection), AV_OPT_TYPE_CONST, + { .i64 = AV_SPHERICAL_EQUIRECTANGULAR }, INT_MIN, INT_MAX, FLAGS, "projection" }, + { "cubemap", "cubemap projection", 0, AV_OPT_TYPE_CONST, + { .i64 = AV_SPHERICAL_CUBEMAP }, INT_MIN, INT_MAX, FLAGS, "projection" }, + { "equirectangular_tile", "tiled equirectangular projection", OFFSET(projection), AV_OPT_TYPE_CONST, + { .i64 = AV_SPHERICAL_EQUIRECTANGULAR_TILE }, INT_MIN, INT_MAX, FLAGS, "projection" }, + { "yaw", "initial yaw orientation in degrees", OFFSET(yaw), AV_OPT_TYPE_DOUBLE, + { .dbl = 0.0 }, -180.0, 180.0, FLAGS }, + { "pitch", "initial pitch orientation in degrees", OFFSET(pitch), AV_OPT_TYPE_DOUBLE, + { .dbl = 0.0 }, -90.0, 90.0, FLAGS }, + { "roll", "initial roll orientation in degrees", OFFSET(roll), AV_OPT_TYPE_DOUBLE, + { .dbl = 0.0 }, -180.0, 180.0, FLAGS }, + { "bound_left", "tiled equirectangular left bound", OFFSET(bound_left), AV_OPT_TYPE_INT64, + { .i64 = 0 }, 0, UINT_MAX, FLAGS }, + { "bound_top", "tiled equirectangular top bound", OFFSET(bound_top), AV_OPT_TYPE_INT64, + { .i64 = 0 }, 0, UINT_MAX, FLAGS }, + { "bound_right", "tiled equirectangular right bound", OFFSET(bound_right), AV_OPT_TYPE_INT64, + { .i64 = 0 }, 0, UINT_MAX, FLAGS }, + { "bound_bottom", "tiled equirectangular bottom bound", OFFSET(bound_bottom), AV_OPT_TYPE_INT64, + { .i64 = 0 }, 0, UINT_MAX, FLAGS }, + { "padding", "cubemap padding in pixels", OFFSET(padding), AV_OPT_TYPE_INT64, + { .i64 = 0 }, 0, UINT_MAX, FLAGS }, + { NULL } +}; + +static const AVClass av_spherical_mapping_class = { + .class_name = "AVSphericalMapping", + .item_name = spherical_mapping_context_to_name, + .option = spherical_mapping_options, + .version = LIBAVUTIL_VERSION_INT, +}; + +int av_spherical_parse_option(const char* opts, AVSphericalMapping **spherical_mapping, + size_t *spherical_mapping_size) { + SphericalMappingContext ctx = { + .spherical_class = &av_spherical_mapping_class + }; + int ret; + + if (!opts) + return AVERROR(EINVAL); + + av_opt_set_defaults(&ctx); + ret = av_set_options_string(&ctx, opts, "=", ","); + if (ret < 0) + return ret; + + if (ctx.projection == -1) { + av_log(NULL, AV_LOG_ERROR, "projection must be specified\n"); + return AVERROR(EINVAL); + } + + if (ctx.padding > 0 && ctx.projection != AV_SPHERICAL_CUBEMAP) { + av_log(NULL, AV_LOG_ERROR, "padding only allowed for AV_SPHERICAL_CUBEMAP projection.\n"); + return AVERROR(EINVAL); + } + + if ((ctx.bound_left > 0 || ctx.bound_top > 0 || ctx.bound_right > 0 || + ctx.bound_bottom > 0) && ctx.projection != AV_SPHERICAL_EQUIRECTANGULAR_TILE) { + av_log(NULL, AV_LOG_ERROR, "bounds only allowed for AV_SPHERICAL_EQUIRECTANGULAR_TILE projection.\n"); + return AVERROR(EINVAL); + } + + *spherical_mapping = av_spherical_alloc(spherical_mapping_size); + if (!*spherical_mapping) + return AVERROR(ENOMEM); + + (*spherical_mapping)->projection = (enum AVSphericalProjection)ctx.projection; + (*spherical_mapping)->yaw = (int32_t)(ctx.yaw * (1 << 16)); + (*spherical_mapping)->pitch = (int32_t)(ctx.pitch * (1 << 16)); + (*spherical_mapping)->roll = (int32_t)(ctx.roll * (1 << 16)); + + if (ctx.projection == AV_SPHERICAL_CUBEMAP) { + (*spherical_mapping)->padding = (uint32_t)ctx.padding; + } else if (ctx.projection == AV_SPHERICAL_EQUIRECTANGULAR_TILE) { + (*spherical_mapping)->bound_left = (uint32_t)ctx.bound_left; + (*spherical_mapping)->bound_top = (uint32_t)ctx.bound_top; + (*spherical_mapping)->bound_right = (uint32_t)ctx.bound_right; + (*spherical_mapping)->bound_bottom = (uint32_t)ctx.bound_bottom; + } + + return ret; +} diff --git a/libavutil/spherical.h b/libavutil/spherical.h index cef759cf27..643cff7f44 100644 --- a/libavutil/spherical.h +++ b/libavutil/spherical.h @@ -190,6 +190,20 @@ typedef struct AVSphericalMapping { */ AVSphericalMapping *av_spherical_alloc(size_t *size); +/** + * Parses a command-line option into an AVSphericalMapping object. + * + * @param opts String containing comma separated list of key=value pairs. + * @param spherical_mapping Output parameter for the AVSphericalMapping created by this function. + * @param spherical_mapping_size Output parameter for indicating the size of the struct + * referenced by *spherical_mapping. + * + * @return 0 on success and *spherical_mapping and *spherical_mapping_size contain valid information. + * <0 on failure and *spherical_mapping and *spherical_mapping_size state is undefined. + */ +int av_spherical_parse_option(const char* opt, AVSphericalMapping **spherical_mapping, + size_t *spherical_mapping_size); + /** * Convert the @ref bounding fields from an AVSphericalVideo * from 0.32 fixed point to pixels. -- 2.13.0.506.g27d5fe0cd-goog