FFmpeg: libavutil/hdr_dynamic_metadata.c Source File

FFmpeg

[フレーム]

libavutil

hdr_dynamic_metadata.c

Go to the documentation of this file.

1 /**

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 */

21 #include "avassert.h"

22 #include "hdr_dynamic_metadata.h"

23 #include "mem.h"

24 #include "libavcodec/defs.h"

25 #include "libavcodec/get_bits.h"

26 #include "libavcodec/put_bits.h"

28 static const int64_t luminance_den = 1;

29 static const int32_t peak_luminance_den = 15;

30 static const int64_t rgb_den = 100000;

31 static const int32_t fraction_pixel_den = 1000;

32 static const int32_t knee_point_den = 4095;

33 static const int32_t bezier_anchor_den = 1023;

34 static const int32_t saturation_weight_den = 8;

36 AVDynamicHDRPlus *av_dynamic_hdr_plus_alloc(size_t *size)

37 {

38 AVDynamicHDRPlus *hdr_plus = av_mallocz(sizeof(AVDynamicHDRPlus));

39 if (!hdr_plus)

40 return NULL;

42 if (size)

43 *size = sizeof(*hdr_plus);

45 return hdr_plus;

46 }

48 AVDynamicHDRPlus *av_dynamic_hdr_plus_create_side_data(AVFrame *frame)

49 {

50 AVFrameSideData *side_data = av_frame_new_side_data(frame,

51 AV_FRAME_DATA_DYNAMIC_HDR_PLUS,

52 sizeof(AVDynamicHDRPlus));

53 if (!side_data)

54 return NULL;

56 memset(side_data->data, 0, sizeof(AVDynamicHDRPlus));

58 return (AVDynamicHDRPlus *)side_data->data;

59 }

61 int av_dynamic_hdr_plus_from_t35(AVDynamicHDRPlus *s, const uint8_t *data,

62 size_t size)

63 {

64 uint8_t padded_buf[AV_HDR_PLUS_MAX_PAYLOAD_SIZE + AV_INPUT_BUFFER_PADDING_SIZE];

65 GetBitContext gbc, *gb = &gbc;

66 int ret;

68 if (!s)

69 return AVERROR(ENOMEM);

71 if (size > AV_HDR_PLUS_MAX_PAYLOAD_SIZE)

72 return AVERROR(EINVAL);

74 memcpy(padded_buf, data, size);

75 // Zero-initialize the buffer padding to avoid overreads into uninitialized data.

76 memset(padded_buf + size, 0, AV_INPUT_BUFFER_PADDING_SIZE);

78 ret = init_get_bits8(gb, padded_buf, size);

79 if (ret < 0)

80 return ret;

82 if (get_bits_left(gb) < 10)

83 return AVERROR_INVALIDDATA;

85 s->application_version = get_bits(gb, 8);

86 s->num_windows = get_bits(gb, 2);

88 if (s->num_windows < 1 || s->num_windows > 3) {

89 return AVERROR_INVALIDDATA;

90 }

92 if (get_bits_left(gb) < ((19 * 8 + 1) * (s->num_windows - 1)))

93 return AVERROR_INVALIDDATA;

95 for (int w = 1; w < s->num_windows; w++) {

96 // The corners are set to absolute coordinates here. They should be

97 // converted to the relative coordinates (in [0, 1]) in the decoder.

98 AVHDRPlusColorTransformParams *params = &s->params[w];

99 params->window_upper_left_corner_x =

100 (AVRational){get_bits(gb, 16), 1};

101 params->window_upper_left_corner_y =

102 (AVRational){get_bits(gb, 16), 1};

103 params->window_lower_right_corner_x =

104 (AVRational){get_bits(gb, 16), 1};

105 params->window_lower_right_corner_y =

106 (AVRational){get_bits(gb, 16), 1};

107

108 params->center_of_ellipse_x = get_bits(gb, 16);

109 params->center_of_ellipse_y = get_bits(gb, 16);

110 params->rotation_angle = get_bits(gb, 8);

111 params->semimajor_axis_internal_ellipse = get_bits(gb, 16);

112 params->semimajor_axis_external_ellipse = get_bits(gb, 16);

113 params->semiminor_axis_external_ellipse = get_bits(gb, 16);

114 params->overlap_process_option = get_bits1(gb);

115 }

116

117 if (get_bits_left(gb) < 28)

118 return AVERROR_INVALIDDATA;

119

120 s->targeted_system_display_maximum_luminance =

121 (AVRational){get_bits_long(gb, 27), luminance_den};

122 s->targeted_system_display_actual_peak_luminance_flag = get_bits1(gb);

123

124 if (s->targeted_system_display_actual_peak_luminance_flag) {

125 int rows, cols;

126 if (get_bits_left(gb) < 10)

127 return AVERROR_INVALIDDATA;

128 rows = get_bits(gb, 5);

129 cols = get_bits(gb, 5);

130 if (((rows < 2) || (rows > 25)) || ((cols < 2) || (cols > 25))) {

131 return AVERROR_INVALIDDATA;

132 }

133 s->num_rows_targeted_system_display_actual_peak_luminance = rows;

134 s->num_cols_targeted_system_display_actual_peak_luminance = cols;

135

136 if (get_bits_left(gb) < (rows * cols * 4))

137 return AVERROR_INVALIDDATA;

138

139 for (int i = 0; i < rows; i++) {

140 for (int j = 0; j < cols; j++) {

141 s->targeted_system_display_actual_peak_luminance[i][j] =

142 (AVRational){get_bits(gb, 4), peak_luminance_den};

143 }

144 }

145 }

146 for (int w = 0; w < s->num_windows; w++) {

147 AVHDRPlusColorTransformParams *params = &s->params[w];

148 if (get_bits_left(gb) < (3 * 17 + 17 + 4))

149 return AVERROR_INVALIDDATA;

150

151 for (int i = 0; i < 3; i++) {

152 params->maxscl[i] =

153 (AVRational){get_bits(gb, 17), rgb_den};

154 }

155 params->average_maxrgb =

156 (AVRational){get_bits(gb, 17), rgb_den};

157 params->num_distribution_maxrgb_percentiles = get_bits(gb, 4);

158

159 if (get_bits_left(gb) <

160 (params->num_distribution_maxrgb_percentiles * 24))

161 return AVERROR_INVALIDDATA;

162

163 for (int i = 0; i < params->num_distribution_maxrgb_percentiles; i++) {

164 params->distribution_maxrgb[i].percentage = get_bits(gb, 7);

165 params->distribution_maxrgb[i].percentile =

166 (AVRational){get_bits(gb, 17), rgb_den};

167 }

168

169 if (get_bits_left(gb) < 10)

170 return AVERROR_INVALIDDATA;

171

172 params->fraction_bright_pixels = (AVRational){get_bits(gb, 10), fraction_pixel_den};

173 }

174 if (get_bits_left(gb) < 1)

175 return AVERROR_INVALIDDATA;

176 s->mastering_display_actual_peak_luminance_flag = get_bits1(gb);

177 if (s->mastering_display_actual_peak_luminance_flag) {

178 int rows, cols;

179 if (get_bits_left(gb) < 10)

180 return AVERROR_INVALIDDATA;

181 rows = get_bits(gb, 5);

182 cols = get_bits(gb, 5);

183 if (((rows < 2) || (rows > 25)) || ((cols < 2) || (cols > 25))) {

184 return AVERROR_INVALIDDATA;

185 }

186 s->num_rows_mastering_display_actual_peak_luminance = rows;

187 s->num_cols_mastering_display_actual_peak_luminance = cols;

188

189 if (get_bits_left(gb) < (rows * cols * 4))

190 return AVERROR_INVALIDDATA;

191

192 for (int i = 0; i < rows; i++) {

193 for (int j = 0; j < cols; j++) {

194 s->mastering_display_actual_peak_luminance[i][j] =

195 (AVRational){get_bits(gb, 4), peak_luminance_den};

196 }

197 }

198 }

199

200 for (int w = 0; w < s->num_windows; w++) {

201 AVHDRPlusColorTransformParams *params = &s->params[w];

202 if (get_bits_left(gb) < 1)

203 return AVERROR_INVALIDDATA;

204

205 params->tone_mapping_flag = get_bits1(gb);

206 if (params->tone_mapping_flag) {

207 if (get_bits_left(gb) < 28)

208 return AVERROR_INVALIDDATA;

209

210 params->knee_point_x =

211 (AVRational){get_bits(gb, 12), knee_point_den};

212 params->knee_point_y =

213 (AVRational){get_bits(gb, 12), knee_point_den};

214 params->num_bezier_curve_anchors = get_bits(gb, 4);

215

216 if (get_bits_left(gb) < (params->num_bezier_curve_anchors * 10))

217 return AVERROR_INVALIDDATA;

218

219 for (int i = 0; i < params->num_bezier_curve_anchors; i++) {

220 params->bezier_curve_anchors[i] =

221 (AVRational){get_bits(gb, 10), bezier_anchor_den};

222 }

223 }

224

225 if (get_bits_left(gb) < 1)

226 return AVERROR_INVALIDDATA;

227 params->color_saturation_mapping_flag = get_bits1(gb);

228 if (params->color_saturation_mapping_flag) {

229 if (get_bits_left(gb) < 6)

230 return AVERROR_INVALIDDATA;

231 params->color_saturation_weight =

232 (AVRational){get_bits(gb, 6), saturation_weight_den};

233 }

234 }

235

236 return 0;

237 }

238

239 int av_dynamic_hdr_plus_to_t35(const AVDynamicHDRPlus *s, uint8_t **data, size_t *size)

240 {

241 uint8_t *buf;

242 size_t size_bits, size_bytes;

243 PutBitContext pbc, *pb = &pbc;

244

245 if (!s)

246 return AVERROR(EINVAL);

247 if ((!data || *data) && !size)

248 return AVERROR(EINVAL);

249

250 /**

251 * Buffer size per CTA-861-H p.253-254:

252 * 48 header bits (excluded from the serialized payload)

253 * 8 bits for application_mode

254 * 2 bits for num_windows

255 * 153 bits for window geometry, for each window above 1

256 * 27 bits for targeted_system_display_maximum_luminance

257 * 1-2511 bits for targeted system display peak luminance information

258 * 82-442 bits per window for pixel distribution information

259 * 1-2511 bits for mastering display peak luminance information

260 * 1-179 bits per window for tonemapping information

261 * 1-7 bits per window for color saturation mapping information

262 * Total: 123-7249 bits, excluding trimmed header bits

263 */

264 size_bits = 8;

265

266 size_bits += 2;

267

268 for (int w = 1; w < s->num_windows; w++)

269 size_bits += 153;

270

271 size_bits += 27;

272

273 size_bits += 1;

274 if (s->targeted_system_display_actual_peak_luminance_flag)

275 size_bits += 10 +

276 s->num_rows_targeted_system_display_actual_peak_luminance *

277 s->num_cols_targeted_system_display_actual_peak_luminance * 4;

278

279 for (int w = 0; w < s->num_windows; w++)

280 size_bits += 72 + s->params[w].num_distribution_maxrgb_percentiles * 24 + 10;

281

282 size_bits += 1;

283 if (s->mastering_display_actual_peak_luminance_flag)

284 size_bits += 10 +

285 s->num_rows_mastering_display_actual_peak_luminance *

286 s->num_cols_mastering_display_actual_peak_luminance * 4;

287

288 for (int w = 0; w < s->num_windows; w++) {

289 size_bits += 1;

290 if (s->params[w].tone_mapping_flag)

291 size_bits += 28 + s->params[w].num_bezier_curve_anchors * 10;

292

293 size_bits += 1;

294 if (s->params[w].color_saturation_mapping_flag)

295 size_bits += 6;

296 }

297

298 size_bytes = (size_bits + 7) / 8;

299

300 av_assert0(size_bytes <= AV_HDR_PLUS_MAX_PAYLOAD_SIZE);

301

302 if (!data) {

303 *size = size_bytes;

304 return 0;

305 } else if (*data) {

306 if (*size < size_bytes)

307 return AVERROR_BUFFER_TOO_SMALL;

308 buf = *data;

309 } else {

310 buf = av_malloc(size_bytes);

311 if (!buf)

312 return AVERROR(ENOMEM);

313 }

314

315 init_put_bits(pb, buf, size_bytes);

316

317 // application_mode is set to Application Version 1

318 put_bits(pb, 8, 1);

319

320 // Payload as per CTA-861-H p.253-254

321 put_bits(pb, 2, s->num_windows);

322

323 for (int w = 1; w < s->num_windows; w++) {

324 put_bits(pb, 16, s->params[w].window_upper_left_corner_x.num / s->params[w].window_upper_left_corner_x.den);

325 put_bits(pb, 16, s->params[w].window_upper_left_corner_y.num / s->params[w].window_upper_left_corner_y.den);

326 put_bits(pb, 16, s->params[w].window_lower_right_corner_x.num / s->params[w].window_lower_right_corner_x.den);

327 put_bits(pb, 16, s->params[w].window_lower_right_corner_y.num / s->params[w].window_lower_right_corner_y.den);

328 put_bits(pb, 16, s->params[w].center_of_ellipse_x);

329 put_bits(pb, 16, s->params[w].center_of_ellipse_y);

330 put_bits(pb, 8, s->params[w].rotation_angle);

331 put_bits(pb, 16, s->params[w].semimajor_axis_internal_ellipse);

332 put_bits(pb, 16, s->params[w].semimajor_axis_external_ellipse);

333 put_bits(pb, 16, s->params[w].semiminor_axis_external_ellipse);

334 put_bits(pb, 1, s->params[w].overlap_process_option);

335 }

336

337 put_bits(pb, 27, s->targeted_system_display_maximum_luminance.num * luminance_den /

338 s->targeted_system_display_maximum_luminance.den);

339 put_bits(pb, 1, s->targeted_system_display_actual_peak_luminance_flag);

340 if (s->targeted_system_display_actual_peak_luminance_flag) {

341 put_bits(pb, 5, s->num_rows_targeted_system_display_actual_peak_luminance);

342 put_bits(pb, 5, s->num_cols_targeted_system_display_actual_peak_luminance);

343 for (int i = 0; i < s->num_rows_targeted_system_display_actual_peak_luminance; i++) {

344 for (int j = 0; j < s->num_cols_targeted_system_display_actual_peak_luminance; j++)

345 put_bits(pb, 4, s->targeted_system_display_actual_peak_luminance[i][j].num * peak_luminance_den /

346 s->targeted_system_display_actual_peak_luminance[i][j].den);

347 }

348 }

349

350 for (int w = 0; w < s->num_windows; w++) {

351 for (int i = 0; i < 3; i++)

352 put_bits(pb, 17, s->params[w].maxscl[i].num * rgb_den / s->params[w].maxscl[i].den);

353 put_bits(pb, 17, s->params[w].average_maxrgb.num * rgb_den / s->params[w].average_maxrgb.den);

354 put_bits(pb, 4, s->params[w].num_distribution_maxrgb_percentiles);

355 for (int i = 0; i < s->params[w].num_distribution_maxrgb_percentiles; i++) {

356 put_bits(pb, 7, s->params[w].distribution_maxrgb[i].percentage);

357 put_bits(pb, 17, s->params[w].distribution_maxrgb[i].percentile.num * rgb_den /

358 s->params[w].distribution_maxrgb[i].percentile.den);

359 }

360 put_bits(pb, 10, s->params[w].fraction_bright_pixels.num * fraction_pixel_den /

361 s->params[w].fraction_bright_pixels.den);

362 }

363

364 put_bits(pb, 1, s->mastering_display_actual_peak_luminance_flag);

365 if (s->mastering_display_actual_peak_luminance_flag) {

366 put_bits(pb, 5, s->num_rows_mastering_display_actual_peak_luminance);

367 put_bits(pb, 5, s->num_cols_mastering_display_actual_peak_luminance);

368 for (int i = 0; i < s->num_rows_mastering_display_actual_peak_luminance; i++) {

369 for (int j = 0; j < s->num_cols_mastering_display_actual_peak_luminance; j++)

370 put_bits(pb, 4, s->mastering_display_actual_peak_luminance[i][j].num * peak_luminance_den /

371 s->mastering_display_actual_peak_luminance[i][j].den);

372 }

373 }

374

375 for (int w = 0; w < s->num_windows; w++) {

376 put_bits(pb, 1, s->params[w].tone_mapping_flag);

377 if (s->params[w].tone_mapping_flag) {

378 put_bits(pb, 12, s->params[w].knee_point_x.num * knee_point_den / s->params[w].knee_point_x.den);

379 put_bits(pb, 12, s->params[w].knee_point_y.num * knee_point_den / s->params[w].knee_point_y.den);

380 put_bits(pb, 4, s->params[w].num_bezier_curve_anchors);

381 for (int i = 0; i < s->params[w].num_bezier_curve_anchors; i++)

382 put_bits(pb, 10, s->params[w].bezier_curve_anchors[i].num * bezier_anchor_den /

383 s->params[w].bezier_curve_anchors[i].den);

384 put_bits(pb, 1, s->params[w].color_saturation_mapping_flag);

385 if (s->params[w].color_saturation_mapping_flag)

386 put_bits(pb, 6, s->params[w].color_saturation_weight.num * saturation_weight_den /

387 s->params[w].color_saturation_weight.den);

388 }

389 }

390

391 flush_put_bits(pb);

392

393 *data = buf;

394 if (size)

395 *size = size_bytes;

396 return 0;

397 }

AVHDRPlusColorTransformParams::average_maxrgb

AVRational average_maxrgb

The average of linearized maxRGB values in the processing window in the scene.

Definition: hdr_dynamic_metadata.h:164

get_bits_left

static int get_bits_left(GetBitContext *gb)

Definition: get_bits.h:695

AVERROR

Filter the word "frame" indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later. That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another. Frame references ownership and permissions

AVHDRPlusColorTransformParams::rotation_angle

uint8_t rotation_angle

The clockwise rotation angle in degree of arc with respect to the positive direction of the x-axis of...

Definition: hdr_dynamic_metadata.h:118

av_frame_new_side_data

AVFrameSideData * av_frame_new_side_data(AVFrame *frame, enum AVFrameSideDataType type, size_t size)

Add a new side data to a frame.

Definition: frame.c:765

AVHDRPlusPercentile::percentile

AVRational percentile

The linearized maxRGB value at a specific percentile in the processing window in the scene.

Definition: hdr_dynamic_metadata.h:52

get_bits_long

static unsigned int get_bits_long(GetBitContext *s, int n)

Read 0-32 bits.

Definition: get_bits.h:421

int64_t

long long int64_t

Definition: coverity.c:34

init_put_bits

static void init_put_bits(PutBitContext *s, uint8_t *buffer, int buffer_size)

Initialize the PutBitContext s.

Definition: put_bits.h:62

AVHDRPlusColorTransformParams::semimajor_axis_external_ellipse

uint16_t semimajor_axis_external_ellipse

The semi-major axis value of the external ellipse of the elliptical pixel selector in amount of pixel...

Definition: hdr_dynamic_metadata.h:134

AVHDRPlusColorTransformParams

Color transform parameters at a processing window in a dynamic metadata for SMPTE 2094-40.

Definition: hdr_dynamic_metadata.h:59

AVFrame

This structure describes decoded (raw) audio or video data.

Definition: frame.h:344

put_bits

static void put_bits(Jpeg2000EncoderContext *s, int val, int n)

put n times val bit

Definition: j2kenc.c:222

uint8_t w

Definition: llviddspenc.c:38

av_dynamic_hdr_plus_to_t35

int av_dynamic_hdr_plus_to_t35(const AVDynamicHDRPlus *s, uint8_t **data, size_t *size)

Serialize dynamic HDR10+ metadata to a user data registered ITU-T T.35 buffer, excluding the first 48...

Definition: hdr_dynamic_metadata.c:239

data

const char data[16]

Definition: mxf.c:148

AVHDRPlusColorTransformParams::tone_mapping_flag

uint8_t tone_mapping_flag

This flag indicates that the metadata for the tone mapping function in the processing window is prese...

Definition: hdr_dynamic_metadata.h:189

luminance_den

static const int64_t luminance_den

Definition: hdr_dynamic_metadata.c:28

AVHDRPlusColorTransformParams::distribution_maxrgb

AVHDRPlusPercentile distribution_maxrgb[15]

The linearized maxRGB values at given percentiles in the processing window in the scene.

Definition: hdr_dynamic_metadata.h:176

AVHDRPlusColorTransformParams::knee_point_x

AVRational knee_point_x

The x coordinate of the separation point between the linear part and the curved part of the tone mapp...

Definition: hdr_dynamic_metadata.h:196

av_malloc

#define av_malloc(s)

Definition: tableprint_vlc.h:30

get_bits

static unsigned int get_bits(GetBitContext *s, int n)

Read 1-25 bits.

Definition: get_bits.h:335

AVHDRPlusColorTransformParams::color_saturation_mapping_flag

uint8_t color_saturation_mapping_flag

This flag shall be equal to 0 in bitstreams conforming to this version of this Specification.

Definition: hdr_dynamic_metadata.h:222

AVHDRPlusColorTransformParams::center_of_ellipse_x

uint16_t center_of_ellipse_x

The x coordinate of the center position of the concentric internal and external ellipses of the ellip...

Definition: hdr_dynamic_metadata.h:102

GetBitContext

Definition: get_bits.h:108

AVERROR_BUFFER_TOO_SMALL

#define AVERROR_BUFFER_TOO_SMALL

Buffer too small.

Definition: error.h:53

AVHDRPlusColorTransformParams::knee_point_y

AVRational knee_point_y

The y coordinate of the separation point between the linear part and the curved part of the tone mapp...

Definition: hdr_dynamic_metadata.h:203

AVHDRPlusColorTransformParams::num_bezier_curve_anchors

uint8_t num_bezier_curve_anchors

The number of the intermediate anchor parameters of the tone mapping function in the processing windo...

Definition: hdr_dynamic_metadata.h:209

avassert.h

init_get_bits8

static int init_get_bits8(GetBitContext *s, const uint8_t *buffer, int byte_size)

Initialize GetBitContext.

Definition: get_bits.h:545

#define s(width, name)

Definition: cbs_vp9.c:198

AVHDRPlusColorTransformParams::semiminor_axis_external_ellipse

uint16_t semiminor_axis_external_ellipse

The semi-minor axis value of the external ellipse of the elliptical pixel selector in amount of pixel...

Definition: hdr_dynamic_metadata.h:141

AVHDRPlusColorTransformParams::window_upper_left_corner_y

AVRational window_upper_left_corner_y

The relative y coordinate of the top left pixel of the processing window.

Definition: hdr_dynamic_metadata.h:76

AVHDRPlusColorTransformParams::window_lower_right_corner_x

AVRational window_lower_right_corner_x

The relative x coordinate of the bottom right pixel of the processing window.

Definition: hdr_dynamic_metadata.h:85

av_assert0

#define av_assert0(cond)

assert() equivalent, that is always enabled.

Definition: avassert.h:40

get_bits.h

PutBitContext

Definition: put_bits.h:50

frame

static AVFrame * frame

Definition: demux_decode.c:54

AVHDRPlusPercentile::percentage

uint8_t percentage

The percentage value corresponding to a specific percentile linearized RGB value in the processing wi...

Definition: hdr_dynamic_metadata.h:45

if(ret)

Definition: filter_design.txt:179

NULL

#define NULL

Definition: coverity.c:32

AVRational

Rational number (pair of numerator and denominator).

Definition: rational.h:58

get_bits1

static unsigned int get_bits1(GetBitContext *s)

Definition: get_bits.h:388

AVHDRPlusColorTransformParams::fraction_bright_pixels

AVRational fraction_bright_pixels

The fraction of selected pixels in the image that contains the brightest pixel in the scene.

Definition: hdr_dynamic_metadata.h:183

AVHDRPlusColorTransformParams::color_saturation_weight

AVRational color_saturation_weight

The color saturation gain in the processing window in the scene.

Definition: hdr_dynamic_metadata.h:229

size

int size

Definition: twinvq_data.h:10344

AVFrameSideData::data

uint8_t * data

Definition: frame.h:252

AVHDRPlusColorTransformParams::window_lower_right_corner_y

AVRational window_lower_right_corner_y

The relative y coordinate of the bottom right pixel of the processing window.

Definition: hdr_dynamic_metadata.h:94

AVHDRPlusColorTransformParams::window_upper_left_corner_x

AVRational window_upper_left_corner_x

The relative x coordinate of the top left pixel of the processing window.

Definition: hdr_dynamic_metadata.h:67

AVHDRPlusColorTransformParams::semimajor_axis_internal_ellipse

uint16_t semimajor_axis_internal_ellipse

The semi-major axis value of the internal ellipse of the elliptical pixel selector in amount of pixel...

Definition: hdr_dynamic_metadata.h:125

#define i(width, name, range_min, range_max)

Definition: cbs_h2645.c:255

fraction_pixel_den

static const int32_t fraction_pixel_den

Definition: hdr_dynamic_metadata.c:31

AVHDRPlusColorTransformParams::overlap_process_option

enum AVHDRPlusOverlapProcessOption overlap_process_option

Overlap process option indicates one of the two methods of combining rendered pixels in the processin...

Definition: hdr_dynamic_metadata.h:149

av_mallocz

void * av_mallocz(size_t size)

Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...

Definition: mem.c:254

AVDynamicHDRPlus

This struct represents dynamic metadata for color volume transform - application 4 of SMPTE 2094-40:2...

Definition: hdr_dynamic_metadata.h:243

av_dynamic_hdr_plus_create_side_data

AVDynamicHDRPlus * av_dynamic_hdr_plus_create_side_data(AVFrame *frame)

Allocate a complete AVDynamicHDRPlus and add it to the frame.

Definition: hdr_dynamic_metadata.c:48

ret

Definition: filter_design.txt:187

knee_point_den

static const int32_t knee_point_den

Definition: hdr_dynamic_metadata.c:32

AV_INPUT_BUFFER_PADDING_SIZE

#define AV_INPUT_BUFFER_PADDING_SIZE

Definition: defs.h:40

AV_FRAME_DATA_DYNAMIC_HDR_PLUS

@ AV_FRAME_DATA_DYNAMIC_HDR_PLUS

HDR dynamic metadata associated with a video frame.

Definition: frame.h:159

AV_HDR_PLUS_MAX_PAYLOAD_SIZE

#define AV_HDR_PLUS_MAX_PAYLOAD_SIZE

Definition: hdr_dynamic_metadata.h:356

defs.h

peak_luminance_den

static const int32_t peak_luminance_den

Definition: hdr_dynamic_metadata.c:29

AVHDRPlusColorTransformParams::num_distribution_maxrgb_percentiles

uint8_t num_distribution_maxrgb_percentiles

The number of linearized maxRGB values at given percentiles in the processing window in the scene.

Definition: hdr_dynamic_metadata.h:170

AVHDRPlusColorTransformParams::maxscl

AVRational maxscl[3]

The maximum of the color components of linearized RGB values in the processing window in the scene.

Definition: hdr_dynamic_metadata.h:157

hdr_dynamic_metadata.h

AVHDRPlusColorTransformParams::center_of_ellipse_y

uint16_t center_of_ellipse_y

The y coordinate of the center position of the concentric internal and external ellipses of the ellip...

Definition: hdr_dynamic_metadata.h:110

mem.h

AVFrameSideData

Structure to hold side data for an AVFrame.

Definition: frame.h:250

flush_put_bits

static void flush_put_bits(PutBitContext *s)

Pad the end of the output stream with zeros.

Definition: put_bits.h:143

rgb_den

static const int64_t rgb_den

Definition: hdr_dynamic_metadata.c:30

av_dynamic_hdr_plus_alloc

AVDynamicHDRPlus * av_dynamic_hdr_plus_alloc(size_t *size)

Allocate an AVDynamicHDRPlus structure and set its fields to default values.

Definition: hdr_dynamic_metadata.c:36

av_dynamic_hdr_plus_from_t35

int av_dynamic_hdr_plus_from_t35(AVDynamicHDRPlus *s, const uint8_t *data, size_t size)

Parse the user data registered ITU-T T.35 to AVbuffer (AVDynamicHDRPlus).

Definition: hdr_dynamic_metadata.c:61

int32_t

Definition: audioconvert.c:56

bezier_anchor_den

static const int32_t bezier_anchor_den

Definition: hdr_dynamic_metadata.c:33

saturation_weight_den

static const int32_t saturation_weight_den

Definition: hdr_dynamic_metadata.c:34

AVERROR_INVALIDDATA

#define AVERROR_INVALIDDATA

Invalid data found when processing input.

Definition: error.h:61

put_bits.h

AVHDRPlusColorTransformParams::bezier_curve_anchors

AVRational bezier_curve_anchors[15]

The intermediate anchor parameters of the tone mapping function in the processing window in the scene...

Definition: hdr_dynamic_metadata.h:216

Generated on Thu Sep 26 2024 23:15:54 for FFmpeg by doxygen 1.8.17