FFmpeg: libavcodec/fflcms2.c Source File

FFmpeg

[フレーム]

libavcodec

fflcms2.c

Go to the documentation of this file.

1 /*

3 * This file is part of FFmpeg.

4 *

5 * FFmpeg is free software; you can redistribute it and/or

6 * modify it under the terms of the GNU Lesser General Public

7 * License as published by the Free Software Foundation; either

8 * version 2.1 of the License, or (at your option) any later version.

9 *

10 * FFmpeg is distributed in the hope that it will be useful,

11 * but WITHOUT ANY WARRANTY; without even the implied warranty of

12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU

13 * Lesser General Public License for more details.

14 *

15 * You should have received a copy of the GNU Lesser General Public

16 * License along with FFmpeg; if not, write to the Free Software

17 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA

18 */

20 #include "libavutil/csp.h"

22 #include "fflcms2.h"

24 static void log_cb(cmsContext ctx, cmsUInt32Number error, const char *str)

25 {

26 FFIccContext *s = cmsGetContextUserData(ctx);

27 av_log(s->avctx, AV_LOG_ERROR, "lcms2: [%"PRIu32"] %s\n", error, str);

28 }

30 int ff_icc_context_init(FFIccContext *s, void *avctx)

31 {

32 memset(s, 0, sizeof(*s));

33 s->avctx = avctx;

34 s->ctx = cmsCreateContext(NULL, s);

35 if (!s->ctx)

36 return AVERROR(ENOMEM);

38 cmsSetLogErrorHandlerTHR(s->ctx, log_cb);

39 return 0;

40 }

42 void ff_icc_context_uninit(FFIccContext *s)

43 {

44 for (int i = 0; i < FF_ARRAY_ELEMS(s->curves); i++)

45 cmsFreeToneCurve(s->curves[i]);

46 cmsDeleteContext(s->ctx);

47 memset(s, 0, sizeof(*s));

48 }

50 static int get_curve(FFIccContext *s, enum AVColorTransferCharacteristic trc,

51 cmsToneCurve **out_curve)

52 {

53 if (trc >= AVCOL_TRC_NB)

54 return AVERROR_INVALIDDATA;

56 if (s->curves[trc])

57 goto done;

59 switch (trc) {

60 case AVCOL_TRC_LINEAR:

61 s->curves[trc] = cmsBuildGamma(s->ctx, 1.0);

62 break;

63 case AVCOL_TRC_GAMMA22:

64 s->curves[trc] = cmsBuildGamma(s->ctx, 2.2);

65 break;

66 case AVCOL_TRC_GAMMA28:

67 s->curves[trc] = cmsBuildGamma(s->ctx, 2.8);

68 break;

69 case AVCOL_TRC_BT709:

70 case AVCOL_TRC_SMPTE170M:

71 case AVCOL_TRC_BT2020_10:

72 case AVCOL_TRC_BT2020_12:

73 s->curves[trc] = cmsBuildParametricToneCurve(s->ctx, 4, (double[5]) {

74 /* γ = */ 1/0.45,

75 /* a = */ 1/1.099296826809442,

76 /* b = */ 1 - 1/1.099296826809442,

77 /* c = */ 1/4.5,

78 /* d = */ 4.5 * 0.018053968510807,

79 });

80 break;

81 case AVCOL_TRC_SMPTE240M:

82 s->curves[trc] = cmsBuildParametricToneCurve(s->ctx, 4, (double[5]) {

83 /* γ = */ 1/0.45,

84 /* a = */ 1/1.1115,

85 /* b = */ 1 - 1/1.1115,

86 /* c = */ 1/4.0,

87 /* d = */ 4.0 * 0.0228,

88 });

89 break;

90 case AVCOL_TRC_LOG:

91 s->curves[trc] = cmsBuildParametricToneCurve(s->ctx, 8, (double[5]) {

92 /* a = */ 1.0,

93 /* b = */ 10.0,

94 /* c = */ 2.0,

95 /* d = */ -1.0,

96 /* e = */ 0.0

97 });

98 break;

99 case AVCOL_TRC_LOG_SQRT:

100 s->curves[trc] = cmsBuildParametricToneCurve(s->ctx, 8, (double[5]) {

101 /* a = */ 1.0,

102 /* b = */ 10.0,

103 /* c = */ 2.5,

104 /* d = */ -1.0,

105 /* e = */ 0.0

106 });

107 break;

108 case AVCOL_TRC_IEC61966_2_1:

109 s->curves[trc] = cmsBuildParametricToneCurve(s->ctx, 4, (double[5]) {

110 /* γ = */ 2.4,

111 /* a = */ 1/1.055,

112 /* b = */ 1 - 1/1.055,

113 /* c = */ 1/12.92,

114 /* d = */ 12.92 * 0.0031308,

115 });

116 break;

117 case AVCOL_TRC_SMPTE428:

118 s->curves[trc] = cmsBuildParametricToneCurve(s->ctx, 2, (double[3]) {

119 /* γ = */ 2.6,

120 /* a = */ pow(52.37/48.0, 1/2.6),

121 /* b = */ 0.0

122 });

123 break;

124

125 /* Can't be represented using the existing parametric tone curves.

126 * FIXME: use cmsBuildTabulatedToneCurveFloat instead */

127 case AVCOL_TRC_IEC61966_2_4:

128 case AVCOL_TRC_BT1361_ECG:

129 case AVCOL_TRC_SMPTE2084:

130 case AVCOL_TRC_ARIB_STD_B67:

131 return AVERROR_PATCHWELCOME;

132

133 default:

134 return AVERROR_INVALIDDATA;

135 }

136

137 if (!s->curves[trc])

138 return AVERROR(ENOMEM);

139

140 done:

141 *out_curve = s->curves[trc];

142 return 0;

143 }

144

145 int ff_icc_profile_generate(FFIccContext *s,

146 enum AVColorPrimaries color_prim,

147 enum AVColorTransferCharacteristic color_trc,

148 cmsHPROFILE *out_profile)

149 {

150 cmsToneCurve *tonecurve;

151 const AVColorPrimariesDesc *prim;

152 int ret;

153

154 if (!(prim = av_csp_primaries_desc_from_id(color_prim)))

155 return AVERROR_INVALIDDATA;

156 if ((ret = get_curve(s, color_trc, &tonecurve)) < 0)

157 return ret;

158

159 *out_profile = cmsCreateRGBProfileTHR(s->ctx,

160 &(cmsCIExyY) { av_q2d(prim->wp.x), av_q2d(prim->wp.y), 1.0 },

161 &(cmsCIExyYTRIPLE) {

162 .Red = { av_q2d(prim->prim.r.x), av_q2d(prim->prim.r.y), 1.0 },

163 .Green = { av_q2d(prim->prim.g.x), av_q2d(prim->prim.g.y), 1.0 },

164 .Blue = { av_q2d(prim->prim.b.x), av_q2d(prim->prim.b.y), 1.0 },

165 },

166 (cmsToneCurve *[3]) { tonecurve, tonecurve, tonecurve }

167 );

168

169 return *out_profile == NULL ? AVERROR(ENOMEM) : 0;

170 }

171

172 int ff_icc_profile_attach(FFIccContext *s, cmsHPROFILE profile, AVFrame *frame)

173 {

174 cmsUInt32Number size;

175 AVBufferRef *buf;

176

177 if (!cmsSaveProfileToMem(profile, NULL, &size))

178 return AVERROR_EXTERNAL;

179

180 buf = av_buffer_alloc(size);

181 if (!buf)

182 return AVERROR(ENOMEM);

183

184 if (!cmsSaveProfileToMem(profile, buf->data, &size) || size != buf->size) {

185 av_buffer_unref(&buf);

186 return AVERROR_EXTERNAL;

187 }

188

189 if (!av_frame_new_side_data_from_buf(frame, AV_FRAME_DATA_ICC_PROFILE, buf)) {

190 av_buffer_unref(&buf);

191 return AVERROR(ENOMEM);

192 }

193

194 return 0;

195 }

196

197 static av_always_inline void XYZ_xy(cmsCIEXYZ XYZ, AVCIExy *xy)

198 {

199 double k = 1.0 / (XYZ.X + XYZ.Y + XYZ.Z);

200 xy->x = av_d2q(k * XYZ.X, 100000);

201 xy->y = av_d2q(k * XYZ.Y, 100000);

202 }

203

204 static av_always_inline AVRational abs_sub_q(AVRational r1, AVRational r2)

205 {

206 AVRational diff = av_sub_q(r1, r2);

207 /* denominator assumed to be positive */

208 return av_make_q(abs(diff.num), diff.den);

209 }

210

211 static const AVCIExy wp_d50 = { {3457, 10000}, {3585, 10000} }; /* CIE D50 */

212

213 int ff_icc_profile_sanitize(FFIccContext *s, cmsHPROFILE profile)

214 {

215 cmsCIEXYZ *white, fixed;

216 AVCIExy wpxy;

217 AVRational diff, z;

218 if (!profile)

219 return 0;

220

221 if (cmsGetEncodedICCversion(profile) >= 0x4000000) { // ICC v4

222 switch (cmsGetHeaderRenderingIntent(profile)) {

223 case INTENT_RELATIVE_COLORIMETRIC:

224 case INTENT_ABSOLUTE_COLORIMETRIC: ;

225 /* ICC v4 colorimetric profiles are specified to always use D50

226 * media white point, anything else is a violation of the spec.

227 * Sadly, such profiles are incredibly common (Apple...), so make

228 * an effort to fix them. */

229 if (!(white = cmsReadTag(profile, cmsSigMediaWhitePointTag)))

230 return AVERROR_INVALIDDATA;

231 XYZ_xy(*white, &wpxy);

232 diff = av_add_q(abs_sub_q(wpxy.x, wp_d50.x), abs_sub_q(wpxy.y, wp_d50.y));

233 if (av_cmp_q(diff, av_make_q(1, 1000)) > 0) {

234 av_log(s->avctx, AV_LOG_WARNING, "Invalid colorimetric ICCv4 "

235 "profile media white point tag (expected %.4f %.4f, "

236 "got %.4f %.4f)\n",

237 av_q2d(wp_d50.x), av_q2d(wp_d50.y),

238 av_q2d(wpxy.x), av_q2d(wpxy.y));

239 /* x+y+z = 1 */

240 z = av_sub_q(av_sub_q(av_make_q(1, 1), wp_d50.x), wp_d50.y);

241 fixed.X = av_q2d(av_div_q(wp_d50.x, wp_d50.y)) * white->Y;

242 fixed.Y = white->Y;

243 fixed.Z = av_q2d(av_div_q(z, wp_d50.y)) * white->Y;

244 if (!cmsWriteTag(profile, cmsSigMediaWhitePointTag, &fixed))

245 return AVERROR_EXTERNAL;

246 }

247 break;

248 default: break;

249 }

250 }

251

252 return 0;

253 }

254

255 int ff_icc_profile_read_primaries(FFIccContext *s, cmsHPROFILE profile,

256 AVColorPrimariesDesc *out_primaries)

257 {

258 static const uint8_t testprimaries[4][3] = {

259 { 0xFF, 0, 0 }, /* red */

260 { 0, 0xFF, 0 }, /* green */

261 { 0, 0, 0xFF }, /* blue */

262 { 0xFF, 0xFF, 0xFF }, /* white */

263 };

264

265 AVWhitepointCoefficients *wp = &out_primaries->wp;

266 AVPrimaryCoefficients *prim = &out_primaries->prim;

267 cmsFloat64Number prev_adapt;

268 cmsHPROFILE xyz;

269 cmsHTRANSFORM tf;

270 cmsCIEXYZ dst[4];

271

272 xyz = cmsCreateXYZProfileTHR(s->ctx);

273 if (!xyz)

274 return AVERROR(ENOMEM);

275

276 /* We need to use an unadapted observer to get the raw values */

277 prev_adapt = cmsSetAdaptationStateTHR(s->ctx, 0.0);

278 tf = cmsCreateTransformTHR(s->ctx, profile, TYPE_RGB_8, xyz, TYPE_XYZ_DBL,

279 INTENT_ABSOLUTE_COLORIMETRIC,

280 /* Note: These flags mostly don't do anything

281 * anyway, but specify them regardless */

282 cmsFLAGS_NOCACHE |

283 cmsFLAGS_NOOPTIMIZE |

284 cmsFLAGS_LOWRESPRECALC |

285 cmsFLAGS_GRIDPOINTS(2));

286 cmsSetAdaptationStateTHR(s->ctx, prev_adapt);

287 cmsCloseProfile(xyz);

288 if (!tf) {

289 av_log(s->avctx, AV_LOG_ERROR, "Invalid ICC profile (e.g. CMYK)\n");

290 return AVERROR_INVALIDDATA;

291 }

292

293 cmsDoTransform(tf, testprimaries, dst, 4);

294 cmsDeleteTransform(tf);

295 XYZ_xy(dst[0], &prim->r);

296 XYZ_xy(dst[1], &prim->g);

297 XYZ_xy(dst[2], &prim->b);

298 XYZ_xy(dst[3], wp);

299 return 0;

300 }

301

302 int ff_icc_profile_detect_transfer(FFIccContext *s, cmsHPROFILE profile,

303 enum AVColorTransferCharacteristic *out_trc)

304 {

305 /* 8-bit linear grayscale ramp */

306 static const uint8_t testramp[16][3] = {

307 { 1, 1, 1}, /* avoid exact zero due to log100 etc. */

308 { 17, 17, 17},

309 { 34, 34, 34},

310 { 51, 51, 51},

311 { 68, 68, 68},

312 { 85, 85, 85},

313 { 02, 02, 02},

314 {119, 119, 119},

315 {136, 136, 136},

316 {153, 153, 153},

317 {170, 170, 170},

318 {187, 187, 187},

319 {204, 204, 204},

320 {221, 221, 221},

321 {238, 238, 238},

322 {255, 255, 255},

323 };

324

325 double dst[FF_ARRAY_ELEMS(testramp)];

326

327 for (enum AVColorTransferCharacteristic trc = 0; trc < AVCOL_TRC_NB; trc++) {

328 cmsToneCurve *tonecurve;

329 cmsHPROFILE ref;

330 cmsHTRANSFORM tf;

331 double delta = 0.0;

332 if (get_curve(s, trc, &tonecurve) < 0)

333 continue;

334

335 ref = cmsCreateGrayProfileTHR(s->ctx, cmsD50_xyY(), tonecurve);

336 if (!ref)

337 return AVERROR(ENOMEM);

338

339 tf = cmsCreateTransformTHR(s->ctx, profile, TYPE_RGB_8, ref, TYPE_GRAY_DBL,

340 INTENT_RELATIVE_COLORIMETRIC,

341 cmsFLAGS_NOCACHE | cmsFLAGS_NOOPTIMIZE);

342 cmsCloseProfile(ref);

343 if (!tf) {

344 av_log(s->avctx, AV_LOG_ERROR, "Invalid ICC profile (e.g. CMYK)\n");

345 return AVERROR_INVALIDDATA;

346 }

347

348 cmsDoTransform(tf, testramp, dst, FF_ARRAY_ELEMS(dst));

349 cmsDeleteTransform(tf);

350

351 for (int i = 0; i < FF_ARRAY_ELEMS(dst); i++)

352 delta += fabs(testramp[i][0] / 255.0 - dst[i]);

353 if (delta < 0.01) {

354 *out_trc = trc;

355 return 0;

356 }

357 }

358

359 *out_trc = AVCOL_TRC_UNSPECIFIED;

360 return 0;

361 }

error

static void error(const char *err)

Definition: target_bsf_fuzzer.c:32

AV_LOG_WARNING

#define AV_LOG_WARNING

Something somehow does not look correct.

Definition: log.h:216

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

ff_icc_profile_read_primaries

int ff_icc_profile_read_primaries(FFIccContext *s, cmsHPROFILE profile, AVColorPrimariesDesc *out_primaries)

Read the color primaries and white point coefficients encoded by an ICC profile, and return the raw v...

Definition: fflcms2.c:255

AVColorTransferCharacteristic

Color Transfer Characteristic.

Definition: pixfmt.h:661

AVColorPrimariesDesc::wp

AVWhitepointCoefficients wp

Definition: csp.h:79

AVColorPrimariesDesc

Struct that contains both white point location and primaries location, providing the complete descrip...

Definition: csp.h:78

XYZ

#define XYZ(X, Y, Z)

AVBufferRef::data

uint8_t * data

The data buffer.

Definition: buffer.h:90

AVCOL_TRC_LINEAR

@ AVCOL_TRC_LINEAR

"Linear transfer characteristics"

Definition: pixfmt.h:670

av_div_q

AVRational av_div_q(AVRational b, AVRational c)

Divide one rational by another.

Definition: rational.c:88

AVFrame

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

Definition: frame.h:427

AVCOL_TRC_NB

@ AVCOL_TRC_NB

Not part of ABI.

Definition: pixfmt.h:683

AVCOL_TRC_UNSPECIFIED

@ AVCOL_TRC_UNSPECIFIED

Definition: pixfmt.h:664

AVCOL_TRC_BT2020_12

@ AVCOL_TRC_BT2020_12

ITU-R BT2020 for 12-bit system.

Definition: pixfmt.h:677

AVColorPrimaries

Chromaticity coordinates of the source primaries.

Definition: pixfmt.h:636

av_sub_q

AVRational av_sub_q(AVRational b, AVRational c)

Subtract one rational from another.

Definition: rational.c:101

ff_icc_profile_attach

int ff_icc_profile_attach(FFIccContext *s, cmsHPROFILE profile, AVFrame *frame)

Attach an ICC profile to a frame.

Definition: fflcms2.c:172

XYZ_xy

static av_always_inline void XYZ_xy(cmsCIEXYZ XYZ, AVCIExy *xy)

Definition: fflcms2.c:197

AVCOL_TRC_IEC61966_2_1

@ AVCOL_TRC_IEC61966_2_1

IEC 61966-2-1 (sRGB or sYCC)

Definition: pixfmt.h:675

ff_icc_context_init

int ff_icc_context_init(FFIccContext *s, void *avctx)

Initializes an FFIccContext.

Definition: fflcms2.c:30

AVPrimaryCoefficients

Struct defining the red, green, and blue primary locations in terms of CIE 1931 chromaticity x and y.

Definition: csp.h:64

AVCOL_TRC_GAMMA28

@ AVCOL_TRC_GAMMA28

also ITU-R BT470BG

Definition: pixfmt.h:667

AVCOL_TRC_LOG_SQRT

@ AVCOL_TRC_LOG_SQRT

"Logarithmic transfer characteristic (100 * Sqrt(10) : 1 range)"

Definition: pixfmt.h:672

AVCOL_TRC_GAMMA22

@ AVCOL_TRC_GAMMA22

also ITU-R BT470M / ITU-R BT1700 625 PAL & SECAM

Definition: pixfmt.h:666

wp_d50

static const AVCIExy wp_d50

Definition: fflcms2.c:211

AV_LOG_ERROR

#define AV_LOG_ERROR

Something went wrong and cannot losslessly be recovered.

Definition: log.h:210

FF_ARRAY_ELEMS

#define FF_ARRAY_ELEMS(a)

Definition: sinewin_tablegen.c:29

get_curve

static int get_curve(FFIccContext *s, enum AVColorTransferCharacteristic trc, cmsToneCurve **out_curve)

Definition: fflcms2.c:50

#define s(width, name)

Definition: cbs_vp9.c:198

av_csp_primaries_desc_from_id

const AVColorPrimariesDesc * av_csp_primaries_desc_from_id(enum AVColorPrimaries prm)

Retrieves a complete gamut description from an enum constant describing the color primaries.

Definition: csp.c:90

AVCOL_TRC_BT1361_ECG

@ AVCOL_TRC_BT1361_ECG

ITU-R BT1361 Extended Colour Gamut.

Definition: pixfmt.h:674

av_q2d

static double av_q2d(AVRational a)

Convert an AVRational to a double.

Definition: rational.h:104

ctx

AVFormatContext * ctx

Definition: movenc.c:49

ff_icc_context_uninit

void ff_icc_context_uninit(FFIccContext *s)

Definition: fflcms2.c:42

fabs

static __device__ float fabs(float a)

Definition: cuda_runtime.h:182

NULL

#define NULL

Definition: coverity.c:32

AVERROR_PATCHWELCOME

#define AVERROR_PATCHWELCOME

Not yet implemented in FFmpeg, patches welcome.

Definition: error.h:64

av_buffer_unref

void av_buffer_unref(AVBufferRef **buf)

Free a given reference and automatically free the buffer if there are no more references to it.

Definition: buffer.c:139

AVRational

Rational number (pair of numerator and denominator).

Definition: rational.h:58

AVCOL_TRC_IEC61966_2_4

@ AVCOL_TRC_IEC61966_2_4

IEC 61966-2-4.

Definition: pixfmt.h:673

AV_FRAME_DATA_ICC_PROFILE

@ AV_FRAME_DATA_ICC_PROFILE

The data contains an ICC profile as an opaque octet buffer following the format described by ISO 1507...

Definition: frame.h:144

av_frame_new_side_data_from_buf

AVFrameSideData * av_frame_new_side_data_from_buf(AVFrame *frame, enum AVFrameSideDataType type, AVBufferRef *buf)

Add a new side data to a frame from an existing AVBufferRef.

Definition: frame.c:638

AVCOL_TRC_BT2020_10

@ AVCOL_TRC_BT2020_10

ITU-R BT2020 for 10-bit system.

Definition: pixfmt.h:676

abs

#define abs(x)

Definition: cuda_runtime.h:35

ff_icc_profile_detect_transfer

int ff_icc_profile_detect_transfer(FFIccContext *s, cmsHPROFILE profile, enum AVColorTransferCharacteristic *out_trc)

Attempt detecting the transfer characteristic that best approximates the transfer function encoded by...

Definition: fflcms2.c:302

AVCIExy

Struct containing chromaticity x and y values for the standard CIE 1931 chromaticity definition.

Definition: csp.h:56

fflcms2.h

ff_icc_profile_generate

int ff_icc_profile_generate(FFIccContext *s, enum AVColorPrimaries color_prim, enum AVColorTransferCharacteristic color_trc, cmsHPROFILE *out_profile)

Generate an ICC profile for a given combination of color primaries and transfer function.

Definition: fflcms2.c:145

AVCIExy::x

AVRational x

Definition: csp.h:57

AVCOL_TRC_SMPTE2084

@ AVCOL_TRC_SMPTE2084

SMPTE ST 2084 for 10-, 12-, 14- and 16-bit systems.

Definition: pixfmt.h:678

AVPrimaryCoefficients::b

AVCIExy b

Definition: csp.h:65

AVPrimaryCoefficients::r

AVCIExy r

Definition: csp.h:65

AVCOL_TRC_SMPTE240M

@ AVCOL_TRC_SMPTE240M

Definition: pixfmt.h:669

dst

uint8_t ptrdiff_t const uint8_t ptrdiff_t int intptr_t intptr_t int int16_t * dst

Definition: dsp.h:87

AVCOL_TRC_LOG

@ AVCOL_TRC_LOG

"Logarithmic transfer characteristic (100:1 range)"

Definition: pixfmt.h:671

size

int size

Definition: twinvq_data.h:10344

av_make_q

static AVRational av_make_q(int num, int den)

Create an AVRational.

Definition: rational.h:71

AVPrimaryCoefficients::g

AVCIExy g

Definition: csp.h:65

diff

static av_always_inline int diff(const struct color_info *a, const struct color_info *b, const int trans_thresh)

Definition: vf_paletteuse.c:166

csp.h

AVERROR_EXTERNAL

#define AVERROR_EXTERNAL

Generic error in an external library.

Definition: error.h:59

av_buffer_alloc

AVBufferRef * av_buffer_alloc(size_t size)

Allocate an AVBuffer of the given size using av_malloc().

Definition: buffer.c:77

fixed

#define fixed(width, name, value)

Definition: cbs_apv.c:77

AVBufferRef::size

size_t size

Size of data in bytes.

Definition: buffer.h:94

AVCOL_TRC_BT709

@ AVCOL_TRC_BT709

also ITU-R BT1361

Definition: pixfmt.h:663

FFIccContext

Definition: fflcms2.h:34

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

Definition: cbs_h2645.c:256

delta

float delta

Definition: vorbis_enc_data.h:430

av_always_inline

#define av_always_inline

Definition: attributes.h:63

av_d2q

AVRational av_d2q(double d, int max)

Convert a double precision floating point number to a rational.

Definition: rational.c:106

profile

int profile

Definition: mxfenc.c:2278

av_cmp_q

static int av_cmp_q(AVRational a, AVRational b)

Compare two rationals.

Definition: rational.h:89

ret

Definition: filter_design.txt:187

frame

these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several the filter must be ready for frames arriving randomly on any input any filter with several inputs will most likely require some kind of queuing mechanism It is perfectly acceptable to have a limited queue and to drop frames when the inputs are too unbalanced request_frame For filters that do not use the this method is called when a frame is wanted on an output For a it should directly call filter_frame on the corresponding output For a if there are queued frames already one of these frames should be pushed If the filter should request a frame on one of its repeatedly until at least one frame has been pushed Return or at least make progress towards producing a frame

Definition: filter_design.txt:265

AVCIExy::y

AVRational y

Definition: csp.h:57

AVCOL_TRC_ARIB_STD_B67

@ AVCOL_TRC_ARIB_STD_B67

ARIB STD-B67, known as "Hybrid log-gamma".

Definition: pixfmt.h:682

ref

static int ref[MAX_W *MAX_W]

Definition: jpeg2000dwt.c:117

AVCOL_TRC_SMPTE170M