FFmpeg 7.1.1
Loading...
Searching...
No Matches
spherical.h
Go to the documentation of this file.
1/*
2 * Copyright (c) 2016 Vittorio Giovara <vittorio.giovara@gmail.com>
3 *
4 * This file is part of FFmpeg.
5 *
6 * FFmpeg is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
10 *
11 * FFmpeg is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
15 *
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with FFmpeg; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
19 */
20
21/**
22 * @file
23 * @ingroup lavu_video_spherical
24 * Spherical video
25 */
26
27#ifndef AVUTIL_SPHERICAL_H
28#define AVUTIL_SPHERICAL_H
29
30#include <stddef.h>
31#include <stdint.h>
32
33/**
34 * @defgroup lavu_video_spherical Spherical video mapping
35 * @ingroup lavu_video
36 *
37 * A spherical video file contains surfaces that need to be mapped onto a
38 * sphere. Depending on how the frame was converted, a different distortion
39 * transformation or surface recomposition function needs to be applied before
40 * the video should be mapped and displayed.
41 * @{
42 */
43
44/**
45 * Projection of the video surface(s) on a sphere.
46 */
48 /**
49 * Video represents a sphere mapped on a flat surface using
50 * equirectangular projection.
51 */
53
54 /**
55 * Video frame is split into 6 faces of a cube, and arranged on a
56 * 3x2 layout. Faces are oriented upwards for the front, left, right,
57 * and back faces. The up face is oriented so the top of the face is
58 * forwards and the down face is oriented so the top of the face is
59 * to the back.
60 */
62
63 /**
64 * Video represents a portion of a sphere mapped on a flat surface
65 * using equirectangular projection. The @ref bounding fields indicate
66 * the position of the current video in a larger surface.
67 */
69
70 /**
71 * Video frame displays as a 180 degree equirectangular projection.
72 */
74
75 /**
76 * Video frame displays on a flat, rectangular 2D surface.
77 */
79
80 /**
81 * Fisheye projection (Apple).
82 * See: https://developer.apple.com/documentation/coremedia/cmprojectiontype/fisheye
83 */
85};
86
87/**
88 * This structure describes how to handle spherical videos, outlining
89 * information about projection, initial layout, and any other view modifier.
90 *
91 * @note The struct must be allocated with av_spherical_alloc() and
92 * its size is not a part of the public ABI.
93 */
94typedef struct AVSphericalMapping {
95 /**
96 * Projection type.
97 */
99
100 /**
101 * @name Initial orientation
102 * @{
103 * There fields describe additional rotations applied to the sphere after
104 * the video frame is mapped onto it. The sphere is rotated around the
105 * viewer, who remains stationary. The order of transformation is always
106 * yaw, followed by pitch, and finally by roll.
107 *
108 * The coordinate system matches the one defined in OpenGL, where the
109 * forward vector (z) is coming out of screen, and it is equivalent to
110 * a rotation matrix of R = r_y(yaw) * r_x(pitch) * r_z(roll).
111 *
112 * A positive yaw rotates the portion of the sphere in front of the viewer
113 * toward their right. A positive pitch rotates the portion of the sphere
114 * in front of the viewer upwards. A positive roll tilts the portion of
115 * the sphere in front of the viewer to the viewer's right.
116 *
117 * These values are exported as 16.16 fixed point.
118 *
119 * See this equirectangular projection as example:
120 *
121 * @code{.unparsed}
122 * Yaw
123 * -180 0 180
124 * 90 +-------------+-------------+ 180
125 * | | | up
126 * P | | | y| forward
127 * i | ^ | | /z
128 * t 0 +-------------X-------------+ 0 Roll | /
129 * c | | | | /
130 * h | | | 0|/_____right
131 * | | | x
132 * -90 +-------------+-------------+ -180
133 *
134 * X - the default camera center
135 * ^ - the default up vector
136 * @endcode
137 */
138 int32_t yaw; ///< Rotation around the up vector [-180, 180].
139 int32_t pitch; ///< Rotation around the right vector [-90, 90].
140 int32_t roll; ///< Rotation around the forward vector [-180, 180].
141 /**
142 * @}
143 */
144
145 /**
146 * @name Bounding rectangle
147 * @anchor bounding
148 * @{
149 * These fields indicate the location of the current tile, and where
150 * it should be mapped relative to the original surface. They are
151 * exported as 0.32 fixed point, and can be converted to classic
152 * pixel values with av_spherical_bounds().
153 *
154 * @code{.unparsed}
155 * +----------------+----------+
156 * | |bound_top |
157 * | +--------+ |
158 * | bound_left |tile | |
159 * +<---------->| |<--->+bound_right
160 * | +--------+ |
161 * | | |
162 * | bound_bottom| |
163 * +----------------+----------+
164 * @endcode
165 *
166 * If needed, the original video surface dimensions can be derived
167 * by adding the current stream or frame size to the related bounds,
168 * like in the following example:
169 *
170 * @code{c}
171 * original_width = tile->width + bound_left + bound_right;
172 * original_height = tile->height + bound_top + bound_bottom;
173 * @endcode
174 *
175 * @note These values are valid only for the tiled equirectangular
176 * projection type (@ref AV_SPHERICAL_EQUIRECTANGULAR_TILE),
177 * and should be ignored in all other cases.
178 */
179 uint32_t bound_left; ///< Distance from the left edge
180 uint32_t bound_top; ///< Distance from the top edge
181 uint32_t bound_right; ///< Distance from the right edge
182 uint32_t bound_bottom; ///< Distance from the bottom edge
183 /**
184 * @}
185 */
186
187 /**
188 * Number of pixels to pad from the edge of each cube face.
189 *
190 * @note This value is valid for only for the cubemap projection type
191 * (@ref AV_SPHERICAL_CUBEMAP), and should be ignored in all other
192 * cases.
193 */
194 uint32_t padding;
196
197/**
198 * Allocate a AVSphericalVideo structure and initialize its fields to default
199 * values.
200 *
201 * @return the newly allocated struct or NULL on failure
202 */
204
205/**
206 * Convert the @ref bounding fields from an AVSphericalVideo
207 * from 0.32 fixed point to pixels.
208 *
209 * @param map The AVSphericalVideo map to read bound values from.
210 * @param width Width of the current frame or stream.
211 * @param height Height of the current frame or stream.
212 * @param left Pixels from the left edge.
213 * @param top Pixels from the top edge.
214 * @param right Pixels from the right edge.
215 * @param bottom Pixels from the bottom edge.
216 */
218 size_t width, size_t height,
219 size_t *left, size_t *top,
220 size_t *right, size_t *bottom);
221
222/**
223 * Provide a human-readable name of a given AVSphericalProjection.
224 *
225 * @param projection The input AVSphericalProjection.
226 *
227 * @return The name of the AVSphericalProjection, or "unknown".
228 */
230
231/**
232 * Get the AVSphericalProjection form a human-readable name.
233 *
234 * @param name The input string.
235 *
236 * @return The AVSphericalProjection value, or -1 if not found.
237 */
238int av_spherical_from_name(const char *name);
239/**
240 * @}
241 */
242
243#endif /* AVUTIL_SPHERICAL_H */
static int width
static int height
AVSphericalMapping * av_spherical_alloc(size_t *size)
Allocate a AVSphericalVideo structure and initialize its fields to default values.
int av_spherical_from_name(const char *name)
Get the AVSphericalProjection form a human-readable name.
AVSphericalProjection
Projection of the video surface(s) on a sphere.
Definition spherical.h:47
const char * av_spherical_projection_name(enum AVSphericalProjection projection)
Provide a human-readable name of a given AVSphericalProjection.
void av_spherical_tile_bounds(const AVSphericalMapping *map, size_t width, size_t height, size_t *left, size_t *top, size_t *right, size_t *bottom)
Convert the bounding fields from an AVSphericalVideo from 0.32 fixed point to pixels.
@ AV_SPHERICAL_RECTILINEAR
Video frame displays on a flat, rectangular 2D surface.
Definition spherical.h:78
@ AV_SPHERICAL_EQUIRECTANGULAR
Video represents a sphere mapped on a flat surface using equirectangular projection.
Definition spherical.h:52
@ AV_SPHERICAL_EQUIRECTANGULAR_TILE
Video represents a portion of a sphere mapped on a flat surface using equirectangular projection.
Definition spherical.h:68
@ AV_SPHERICAL_CUBEMAP
Video frame is split into 6 faces of a cube, and arranged on a 3x2 layout.
Definition spherical.h:61
@ AV_SPHERICAL_HALF_EQUIRECTANGULAR
Video frame displays as a 180 degree equirectangular projection.
Definition spherical.h:73
@ AV_SPHERICAL_FISHEYE
Fisheye projection (Apple).
Definition spherical.h:84
This structure describes how to handle spherical videos, outlining information about projection,...
Definition spherical.h:94
uint32_t bound_left
Distance from the left edge.
Definition spherical.h:179
enum AVSphericalProjection projection
Projection type.
Definition spherical.h:98
uint32_t bound_top
Distance from the top edge.
Definition spherical.h:180
uint32_t bound_bottom
Distance from the bottom edge.
Definition spherical.h:182
uint32_t bound_right
Distance from the right edge.
Definition spherical.h:181
int32_t pitch
Rotation around the right vector [-90, 90].
Definition spherical.h:139
int32_t roll
Rotation around the forward vector [-180, 180].
Definition spherical.h:140
int32_t yaw
Rotation around the up vector [-180, 180].
Definition spherical.h:138
uint32_t padding
Number of pixels to pad from the edge of each cube face.
Definition spherical.h:194