mirror of https://github.com/FFmpeg/FFmpeg.git
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
232 lines
7.8 KiB
232 lines
7.8 KiB
/* |
|
* Copyright (c) 2016 Vittorio Giovara <vittorio.giovara@gmail.com> |
|
* |
|
* 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 |
|
*/ |
|
|
|
/** |
|
* @file |
|
* Spherical video |
|
*/ |
|
|
|
#ifndef AVUTIL_SPHERICAL_H |
|
#define AVUTIL_SPHERICAL_H |
|
|
|
#include <stddef.h> |
|
#include <stdint.h> |
|
|
|
/** |
|
* @addtogroup lavu_video |
|
* @{ |
|
* |
|
* @defgroup lavu_video_spherical Spherical video mapping |
|
* @{ |
|
*/ |
|
|
|
/** |
|
* @addtogroup lavu_video_spherical |
|
* A spherical video file contains surfaces that need to be mapped onto a |
|
* sphere. Depending on how the frame was converted, a different distortion |
|
* transformation or surface recomposition function needs to be applied before |
|
* the video should be mapped and displayed. |
|
*/ |
|
|
|
/** |
|
* Projection of the video surface(s) on a sphere. |
|
*/ |
|
enum AVSphericalProjection { |
|
/** |
|
* Video represents a sphere mapped on a flat surface using |
|
* equirectangular projection. |
|
*/ |
|
AV_SPHERICAL_EQUIRECTANGULAR, |
|
|
|
/** |
|
* Video frame is split into 6 faces of a cube, and arranged on a |
|
* 3x2 layout. Faces are oriented upwards for the front, left, right, |
|
* and back faces. The up face is oriented so the top of the face is |
|
* forwards and the down face is oriented so the top of the face is |
|
* to the back. |
|
*/ |
|
AV_SPHERICAL_CUBEMAP, |
|
|
|
/** |
|
* Video represents a portion of a sphere mapped on a flat surface |
|
* using equirectangular projection. The @ref bounding fields indicate |
|
* the position of the current video in a larger surface. |
|
*/ |
|
AV_SPHERICAL_EQUIRECTANGULAR_TILE, |
|
}; |
|
|
|
/** |
|
* This structure describes how to handle spherical videos, outlining |
|
* information about projection, initial layout, and any other view modifier. |
|
* |
|
* @note The struct must be allocated with av_spherical_alloc() and |
|
* its size is not a part of the public ABI. |
|
*/ |
|
typedef struct AVSphericalMapping { |
|
/** |
|
* Projection type. |
|
*/ |
|
enum AVSphericalProjection projection; |
|
|
|
/** |
|
* @name Initial orientation |
|
* @{ |
|
* There fields describe additional rotations applied to the sphere after |
|
* the video frame is mapped onto it. The sphere is rotated around the |
|
* viewer, who remains stationary. The order of transformation is always |
|
* yaw, followed by pitch, and finally by roll. |
|
* |
|
* The coordinate system matches the one defined in OpenGL, where the |
|
* forward vector (z) is coming out of screen, and it is equivalent to |
|
* a rotation matrix of R = r_y(yaw) * r_x(pitch) * r_z(roll). |
|
* |
|
* A positive yaw rotates the portion of the sphere in front of the viewer |
|
* toward their right. A positive pitch rotates the portion of the sphere |
|
* in front of the viewer upwards. A positive roll tilts the portion of |
|
* the sphere in front of the viewer to the viewer's right. |
|
* |
|
* These values are exported as 16.16 fixed point. |
|
* |
|
* See this equirectangular projection as example: |
|
* |
|
* @code{.unparsed} |
|
* Yaw |
|
* -180 0 180 |
|
* 90 +-------------+-------------+ 180 |
|
* | | | up |
|
* P | | | y| forward |
|
* i | ^ | | /z |
|
* t 0 +-------------X-------------+ 0 Roll | / |
|
* c | | | | / |
|
* h | | | 0|/_____right |
|
* | | | x |
|
* -90 +-------------+-------------+ -180 |
|
* |
|
* X - the default camera center |
|
* ^ - the default up vector |
|
* @endcode |
|
*/ |
|
int32_t yaw; ///< Rotation around the up vector [-180, 180]. |
|
int32_t pitch; ///< Rotation around the right vector [-90, 90]. |
|
int32_t roll; ///< Rotation around the forward vector [-180, 180]. |
|
/** |
|
* @} |
|
*/ |
|
|
|
/** |
|
* @name Bounding rectangle |
|
* @anchor bounding |
|
* @{ |
|
* These fields indicate the location of the current tile, and where |
|
* it should be mapped relative to the original surface. They are |
|
* exported as 0.32 fixed point, and can be converted to classic |
|
* pixel values with av_spherical_bounds(). |
|
* |
|
* @code{.unparsed} |
|
* +----------------+----------+ |
|
* | |bound_top | |
|
* | +--------+ | |
|
* | bound_left |tile | | |
|
* +<---------->| |<--->+bound_right |
|
* | +--------+ | |
|
* | | | |
|
* | bound_bottom| | |
|
* +----------------+----------+ |
|
* @endcode |
|
* |
|
* If needed, the original video surface dimensions can be derived |
|
* by adding the current stream or frame size to the related bounds, |
|
* like in the following example: |
|
* |
|
* @code{c} |
|
* original_width = tile->width + bound_left + bound_right; |
|
* original_height = tile->height + bound_top + bound_bottom; |
|
* @endcode |
|
* |
|
* @note These values are valid only for the tiled equirectangular |
|
* projection type (@ref AV_SPHERICAL_EQUIRECTANGULAR_TILE), |
|
* and should be ignored in all other cases. |
|
*/ |
|
uint32_t bound_left; ///< Distance from the left edge |
|
uint32_t bound_top; ///< Distance from the top edge |
|
uint32_t bound_right; ///< Distance from the right edge |
|
uint32_t bound_bottom; ///< Distance from the bottom edge |
|
/** |
|
* @} |
|
*/ |
|
|
|
/** |
|
* Number of pixels to pad from the edge of each cube face. |
|
* |
|
* @note This value is valid for only for the cubemap projection type |
|
* (@ref AV_SPHERICAL_CUBEMAP), and should be ignored in all other |
|
* cases. |
|
*/ |
|
uint32_t padding; |
|
} AVSphericalMapping; |
|
|
|
/** |
|
* Allocate a AVSphericalVideo structure and initialize its fields to default |
|
* values. |
|
* |
|
* @return the newly allocated struct or NULL on failure |
|
*/ |
|
AVSphericalMapping *av_spherical_alloc(size_t *size); |
|
|
|
/** |
|
* Convert the @ref bounding fields from an AVSphericalVideo |
|
* from 0.32 fixed point to pixels. |
|
* |
|
* @param map The AVSphericalVideo map to read bound values from. |
|
* @param width Width of the current frame or stream. |
|
* @param height Height of the current frame or stream. |
|
* @param left Pixels from the left edge. |
|
* @param top Pixels from the top edge. |
|
* @param right Pixels from the right edge. |
|
* @param bottom Pixels from the bottom edge. |
|
*/ |
|
void av_spherical_tile_bounds(AVSphericalMapping *map, |
|
size_t width, size_t height, |
|
size_t *left, size_t *top, |
|
size_t *right, size_t *bottom); |
|
|
|
/** |
|
* Provide a human-readable name of a given AVSphericalProjection. |
|
* |
|
* @param projection The input AVSphericalProjection. |
|
* |
|
* @return The name of the AVSphericalProjection, or "unknown". |
|
*/ |
|
const char *av_spherical_projection_name(enum AVSphericalProjection projection); |
|
|
|
/** |
|
* Get the AVSphericalProjection form a human-readable name. |
|
* |
|
* @param name The input string. |
|
* |
|
* @return The AVSphericalProjection value, or AVERROR if not found. |
|
*/ |
|
int av_spherical_from_name(const char *name); |
|
/** |
|
* @} |
|
* @} |
|
*/ |
|
|
|
#endif /* AVUTIL_SPHERICAL_H */
|
|
|