FFmpeg
Loading...
Searching...
No Matches
libjxlenc.c
Go to the documentation of this file.
1/*
2 * JPEG XL encoding support via libjxl
3 * Copyright (c) 2021 Leo Izen <leo.izen@gmail.com>
4 *
5 * This file is part of FFmpeg.
6 *
7 * FFmpeg is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
11 *
12 * FFmpeg is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
16 *
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with FFmpeg; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20 */
21
22/**
23 * @file
24 * JPEG XL encoder using libjxl
25 */
26
27#include <math.h>
28#include <string.h>
29
30#include "libavutil/avutil.h"
31#include "libavutil/csp.h"
32#include "libavutil/display.h"
33#include "libavutil/error.h"
34#include "libavutil/frame.h"
35#include "libavutil/mem.h"
36#include "libavutil/opt.h"
37#include "libavutil/pixdesc.h"
38#include "libavutil/pixfmt.h"
39#include "libavutil/version.h"
40
41#include "avcodec.h"
42#include "encode.h"
43#include "codec_internal.h"
44#include "exif_internal.h"
45
46#include <jxl/encode.h>
47#include <jxl/thread_parallel_runner.h>
48#include "libjxl.h"
49
50typedef struct LibJxlEncodeContext {
51 AVClass *class;
52 void *runner;
53 JxlEncoder *encoder;
54 JxlEncoderFrameSettings *options;
55 int effort;
56 float distance;
58 int xyb;
59 uint8_t *buffer;
61 JxlPixelFormat jxl_fmt;
63
64 /* animation stuff */
69
70/**
71 * Map a quality setting for -qscale roughly from libjpeg
72 * quality numbers to libjxl's butteraugli distance for
73 * photographic content.
74 *
75 * Setting distance explicitly is preferred, but this will
76 * allow qscale to be used as a fallback.
77 *
78 * This function is continuous and injective on [0, 100] which
79 * makes it monotonic.
80 *
81 * @param quality 0.0 to 100.0 quality setting, libjpeg quality
82 * @return Butteraugli distance between 0.0 and 15.0
83 */
84static float quality_to_distance(float quality)
85{
86 if (quality >= 100.0)
87 return 0.0;
88 else if (quality >= 90.0)
89 return (100.0 - quality) * 0.10;
90 else if (quality >= 30.0)
91 return 0.1 + (100.0 - quality) * 0.09;
92 else if (quality > 0.0)
93 return 15.0 + (59.0 * quality - 4350.0) * quality / 9000.0;
94 else
95 return 15.0;
96}
97
98/**
99 * Initialize the encoder on a per-file basis. All of these need to be set
100 * once each time the encoder is reset, which is each frame for still
101 * images, to make the image2 muxer work. For animation this is run once.
102 *
103 * @return 0 upon success, negative on failure.
104 */
106{
108
109 /* reset the encoder every frame for image2 muxer */
110 JxlEncoderReset(ctx->encoder);
111
112 /* This needs to be set each time the encoder is reset */
113 if (JxlEncoderSetParallelRunner(ctx->encoder, JxlThreadParallelRunner, ctx->runner)
114 != JXL_ENC_SUCCESS) {
115 av_log(avctx, AV_LOG_ERROR, "Failed to set JxlThreadParallelRunner\n");
116 return AVERROR_EXTERNAL;
117 }
118
119 ctx->options = JxlEncoderFrameSettingsCreate(ctx->encoder, NULL);
120 if (!ctx->options) {
121 av_log(avctx, AV_LOG_ERROR, "Failed to create JxlEncoderOptions\n");
122 return AVERROR_EXTERNAL;
123 }
124
125 return 0;
126}
127
128/**
129 * Global encoder initialization. This only needs to be run once,
130 * not every frame.
131 */
133{
135 JxlMemoryManager manager;
136
138 ctx->encoder = JxlEncoderCreate(&manager);
139 if (!ctx->encoder) {
140 av_log(avctx, AV_LOG_ERROR, "Failed to create JxlEncoder\n");
141 return AVERROR_EXTERNAL;
142 }
143
144 ctx->runner = JxlThreadParallelRunnerCreate(&manager, ff_libjxl_get_threadcount(avctx->thread_count));
145 if (!ctx->runner) {
146 av_log(avctx, AV_LOG_ERROR, "Failed to create JxlThreadParallelRunner\n");
147 return AVERROR_EXTERNAL;
148 }
149
150 ctx->buffer_size = 4096;
151 ctx->buffer = av_realloc(NULL, ctx->buffer_size);
152
153 if (!ctx->buffer) {
154 av_log(avctx, AV_LOG_ERROR, "Could not allocate encoding buffer\n");
155 return AVERROR(ENOMEM);
156 }
157
158 /* check for negative, our default */
159 if (ctx->distance < 0.0) {
160 /* use ffmpeg.c -q option if passed */
161 if (avctx->flags & AV_CODEC_FLAG_QSCALE)
162 ctx->distance = quality_to_distance((float)avctx->global_quality / FF_QP2LAMBDA);
163 else
164 /* default 1.0 matches cjxl */
165 ctx->distance = 1.0;
166 }
167 /*
168 * 0.01 is the minimum distance accepted for lossy
169 * interpreting any positive value less than this as minimum
170 */
171 if (ctx->distance > 0.0 && ctx->distance < 0.01)
172 ctx->distance = 0.01;
173
174 return 0;
175}
176
177/**
178 * Initializer for the animation encoder. This calls the other initializers
179 * to prevent code duplication and also allocates the prev-frame used in the
180 * encoder.
181 */
183{
184 int ret;
186
187 ret = libjxl_encode_init(avctx);
188 if (ret < 0)
189 return ret;
190
192 if (ret < 0)
193 return ret;
194
195 ctx->frame = av_frame_alloc();
196 if (!ctx->frame)
197 return AVERROR(ENOMEM);
198
199 return 0;
200}
201
202/**
203 * Populate a JxlColorEncoding with the given enum AVColorPrimaries.
204 * @return < 0 upon failure, >= 0 upon success
205 */
206static int libjxl_populate_primaries(void *avctx, JxlColorEncoding *jxl_color, enum AVColorPrimaries prm)
207{
209
210 switch (prm) {
211 case AVCOL_PRI_BT709:
212 jxl_color->primaries = JXL_PRIMARIES_SRGB;
213 jxl_color->white_point = JXL_WHITE_POINT_D65;
214 return 0;
215 case AVCOL_PRI_BT2020:
216 jxl_color->primaries = JXL_PRIMARIES_2100;
217 jxl_color->white_point = JXL_WHITE_POINT_D65;
218 return 0;
220 jxl_color->primaries = JXL_PRIMARIES_P3;
221 jxl_color->white_point = JXL_WHITE_POINT_DCI;
222 return 0;
224 jxl_color->primaries = JXL_PRIMARIES_P3;
225 jxl_color->white_point = JXL_WHITE_POINT_D65;
226 return 0;
228 av_log(avctx, AV_LOG_WARNING, "Unknown primaries, assuming BT.709/sRGB. Colors may be wrong.\n");
229 jxl_color->primaries = JXL_PRIMARIES_SRGB;
230 jxl_color->white_point = JXL_WHITE_POINT_D65;
231 return 0;
233 av_log(avctx, AV_LOG_ERROR, "SMPTE ST 428-1 XYZ cannot be described by "
234 "a JXL color encoding, use an ICC profile instead.\n");
235 return AVERROR(EINVAL);
236 }
237
239 if (!desc)
240 return AVERROR(EINVAL);
241
242 jxl_color->primaries = JXL_PRIMARIES_CUSTOM;
243 jxl_color->white_point = JXL_WHITE_POINT_CUSTOM;
244
245 jxl_color->primaries_red_xy[0] = av_q2d(desc->prim.r.x);
246 jxl_color->primaries_red_xy[1] = av_q2d(desc->prim.r.y);
247 jxl_color->primaries_green_xy[0] = av_q2d(desc->prim.g.x);
248 jxl_color->primaries_green_xy[1] = av_q2d(desc->prim.g.y);
249 jxl_color->primaries_blue_xy[0] = av_q2d(desc->prim.b.x);
250 jxl_color->primaries_blue_xy[1] = av_q2d(desc->prim.b.y);
251 jxl_color->white_point_xy[0] = av_q2d(desc->wp.x);
252 jxl_color->white_point_xy[1] = av_q2d(desc->wp.y);
253
254 return 0;
255}
256
258 const AVPixFmtDescriptor *pix_desc, const JxlBasicInfo *info)
259{
260 JxlColorEncoding jxl_color;
262 int ret;
263
264 switch (frame->color_trc && frame->color_trc != AVCOL_TRC_UNSPECIFIED
265 ? frame->color_trc : avctx->color_trc) {
266 case AVCOL_TRC_BT709:
267 jxl_color.transfer_function = JXL_TRANSFER_FUNCTION_709;
268 break;
269 case AVCOL_TRC_LINEAR:
270 jxl_color.transfer_function = JXL_TRANSFER_FUNCTION_LINEAR;
271 break;
273 jxl_color.transfer_function = JXL_TRANSFER_FUNCTION_SRGB;
274 break;
276 jxl_color.transfer_function = JXL_TRANSFER_FUNCTION_DCI;
277 break;
279 jxl_color.transfer_function = JXL_TRANSFER_FUNCTION_PQ;
280 break;
282 jxl_color.transfer_function = JXL_TRANSFER_FUNCTION_HLG;
283 break;
285 jxl_color.transfer_function = JXL_TRANSFER_FUNCTION_GAMMA;
286 jxl_color.gamma = 1/2.2f;
287 break;
289 jxl_color.transfer_function = JXL_TRANSFER_FUNCTION_GAMMA;
290 jxl_color.gamma = 1/2.8f;
291 break;
292 default:
293 if (pix_desc->flags & AV_PIX_FMT_FLAG_FLOAT) {
294 av_log(avctx, AV_LOG_WARNING,
295 "Unknown transfer function, assuming Linear Light. Colors may be wrong.\n");
296 jxl_color.transfer_function = JXL_TRANSFER_FUNCTION_LINEAR;
297 } else {
298 av_log(avctx, AV_LOG_WARNING,
299 "Unknown transfer function, assuming IEC61966-2-1/sRGB. Colors may be wrong.\n");
300 jxl_color.transfer_function = JXL_TRANSFER_FUNCTION_SRGB;
301 }
302 }
303
304 jxl_color.rendering_intent = JXL_RENDERING_INTENT_RELATIVE;
305 if (info->num_color_channels == 1)
306 jxl_color.color_space = JXL_COLOR_SPACE_GRAY;
307 else
308 jxl_color.color_space = JXL_COLOR_SPACE_RGB;
309
310 ret = libjxl_populate_primaries(avctx, &jxl_color,
311 frame->color_primaries && frame->color_primaries != AVCOL_PRI_UNSPECIFIED
312 ? frame->color_primaries : avctx->color_primaries);
313 if (ret < 0)
314 return ret;
315
316 if (JxlEncoderSetColorEncoding(ctx->encoder, &jxl_color) != JXL_ENC_SUCCESS) {
317 av_log(avctx, AV_LOG_WARNING, "Failed to set JxlColorEncoding\n");
318 return AVERROR_EXTERNAL;
319 }
320
321 return 0;
322}
323
325{
327 JxlEncoderStatus jret = JXL_ENC_SUCCESS;
328 int ret = 0, opened = 0;
329
330 /* no boxes need to be added */
331 if (!ctx->exif_buffer)
332 goto end;
333
334 jret = JxlEncoderUseBoxes(ctx->encoder);
335 if (jret != JXL_ENC_SUCCESS) {
336 av_log(avctx, AV_LOG_WARNING, "Could not enable UseBoxes\n");
338 goto end;
339 }
340 opened = 1;
341
342 jret = JxlEncoderAddBox(ctx->encoder, "Exif", ctx->exif_buffer->data, ctx->exif_buffer->size, JXL_TRUE);
343 if (jret != JXL_ENC_SUCCESS)
344 jret = JxlEncoderAddBox(ctx->encoder, "Exif", ctx->exif_buffer->data, ctx->exif_buffer->size, JXL_FALSE);
345 if (jret != JXL_ENC_SUCCESS) {
346 av_log(avctx, AV_LOG_WARNING, "Failed to add Exif box\n");
348 goto end;
349 }
350
351end:
352 if (opened)
353 JxlEncoderCloseBoxes(ctx->encoder);
354
355 return ret;
356}
357
358/**
359 * Sends metadata to libjxl based on the first frame of the stream, such as pixel format,
360 * orientation, bit depth, and that sort of thing.
361 */
362static int libjxl_preprocess_stream(AVCodecContext *avctx, const AVFrame *frame, int animated)
363{
365 AVFrameSideData *sd;
366 int32_t *matrix = (int32_t[9]){ 0 };
367 int ret = 0, have_matrix = 0;
368 JxlEncoderStatus jret = JXL_ENC_SUCCESS;
369 const AVPixFmtDescriptor *pix_desc = av_pix_fmt_desc_get(frame->format);
370 JxlBasicInfo info;
371 JxlPixelFormat *jxl_fmt = &ctx->jxl_fmt;
372 int bits_per_sample;
373 int orientation;
374#if JPEGXL_NUMERIC_VERSION >= JPEGXL_COMPUTE_NUMERIC_VERSION(0, 8, 0)
375 JxlBitDepth jxl_bit_depth;
376#endif
377
378 /* populate the basic info settings */
379 JxlEncoderInitBasicInfo(&info);
380 jxl_fmt->num_channels = pix_desc->nb_components;
381 info.xsize = frame->width;
382 info.ysize = frame->height;
383 info.num_extra_channels = (jxl_fmt->num_channels + 1) & 0x1;
384 info.num_color_channels = jxl_fmt->num_channels - info.num_extra_channels;
385 bits_per_sample = av_get_bits_per_pixel(pix_desc) / jxl_fmt->num_channels;
386 info.bits_per_sample = avctx->bits_per_raw_sample > 0 && !(pix_desc->flags & AV_PIX_FMT_FLAG_FLOAT)
387 ? avctx->bits_per_raw_sample : bits_per_sample;
388 info.alpha_bits = (info.num_extra_channels > 0) * info.bits_per_sample;
389 if (pix_desc->flags & AV_PIX_FMT_FLAG_FLOAT) {
390 info.exponent_bits_per_sample = info.bits_per_sample > 16 ? 8 : 5;
391 info.alpha_exponent_bits = info.alpha_bits ? info.exponent_bits_per_sample : 0;
392 jxl_fmt->data_type = info.bits_per_sample > 16 ? JXL_TYPE_FLOAT : JXL_TYPE_FLOAT16;
393 } else {
394 info.exponent_bits_per_sample = 0;
395 info.alpha_exponent_bits = 0;
396 jxl_fmt->data_type = info.bits_per_sample <= 8 ? JXL_TYPE_UINT8 : JXL_TYPE_UINT16;
397 }
398
399 if (info.alpha_bits) {
402 info.alpha_premultiplied = 1;
403 } else if (avctx->alpha_mode != AVALPHA_MODE_STRAIGHT && frame->alpha_mode != AVALPHA_MODE_STRAIGHT) {
404 av_log(avctx, AV_LOG_WARNING, "Unknown alpha mode, assuming straight (independent)\n");
405 }
406 }
407
408#if JPEGXL_NUMERIC_VERSION >= JPEGXL_COMPUTE_NUMERIC_VERSION(0, 8, 0)
409 jxl_bit_depth.bits_per_sample = bits_per_sample;
410 jxl_bit_depth.type = JXL_BIT_DEPTH_FROM_PIXEL_FORMAT;
411 jxl_bit_depth.exponent_bits_per_sample = pix_desc->flags & AV_PIX_FMT_FLAG_FLOAT ?
412 info.exponent_bits_per_sample : 0;
413#endif
414
415 /* JPEG XL format itself does not support limited range */
416 if (avctx->color_range == AVCOL_RANGE_MPEG ||
417 avctx->color_range == AVCOL_RANGE_UNSPECIFIED && frame->color_range == AVCOL_RANGE_MPEG)
418 av_log(avctx, AV_LOG_WARNING, "This encoder does not support limited (tv) range, colors will be wrong!\n");
419 else if (avctx->color_range != AVCOL_RANGE_JPEG && frame->color_range != AVCOL_RANGE_JPEG)
420 av_log(avctx, AV_LOG_WARNING, "Unknown color range, assuming full (pc)\n");
421
422 /* bitexact lossless requires there to be no XYB transform */
423 info.uses_original_profile = ctx->distance == 0.0 || !ctx->xyb;
424
426 if (sd) {
427 matrix = (int32_t *) sd->data;
428 have_matrix = 1;
429 }
431 if (sd) {
432 AVExifMetadata ifd = { 0 };
433 AVExifEntry *orient = NULL;
434 uint16_t tag = av_exif_get_tag_id("Orientation");
435 ret = av_exif_parse_buffer(avctx, sd->data, sd->size, &ifd, AV_EXIF_TIFF_HEADER);
436 if (ret >= 0)
437 ret = ff_exif_sanitize_ifd(avctx, frame, &ifd);
438 if (ret >= 0)
439 ret = av_exif_get_entry(avctx, &ifd, tag, 0, &orient);
440 if (ret >= 0 && orient) {
441 if (!have_matrix && orient->type == AV_TIFF_SHORT && orient->count
442 && orient->value.uint[0] >= 1 && orient->value.uint[0] <= 8) {
444 have_matrix = 1;
445 }
446 /* pop the orientation tag anyway, because it only creates */
447 /* ambiguity with the codestream orientation taking precdence */
448 ret = av_exif_remove_entry(avctx, &ifd, tag, 0);
449 }
450 if (ret >= 0)
451 ret = av_exif_write(avctx, &ifd, &ctx->exif_buffer, AV_EXIF_T_OFF);
452 if (ret < 0)
453 av_log(avctx, AV_LOG_WARNING, "unable to process EXIF frame data\n");
454 av_exif_free(&ifd);
455 }
456
457 /* use identity matrix as default */
458 if (!have_matrix)
460
461 /* av_display_matrix_flip is a right-multipilcation */
462 /* i.e. flip is applied before the previous matrix */
463 if (frame->linesize[0] < 0)
465
467 /* JPEG XL orientation flag agrees with EXIF for values 1-8 */
468 if (orientation) {
469 info.orientation = orientation;
470 } else {
471 av_log(avctx, AV_LOG_WARNING, "singular displaymatrix data\n");
472 info.orientation = frame->linesize[0] >= 0 ? JXL_ORIENT_IDENTITY : JXL_ORIENT_FLIP_VERTICAL;
473 }
474
475 /* restore the previous value */
476 if (frame->linesize[0] < 0)
478
479 if (animated) {
480 info.have_animation = 1;
481 info.animation.have_timecodes = 0;
482 info.animation.num_loops = 0;
483 /* avctx->timebase is in seconds per tick, so we take the reciprocol */
484 info.animation.tps_numerator = avctx->time_base.den;
485 info.animation.tps_denominator = avctx->time_base.num;
486 }
487
488 jret = JxlEncoderSetBasicInfo(ctx->encoder, &info);
489 if (jret != JXL_ENC_SUCCESS) {
490 av_log(avctx, AV_LOG_ERROR, "Failed to set JxlBasicInfo\n");
492 goto end;
493 }
494
495 if (info.alpha_bits) {
496 JxlExtraChannelInfo extra_info;
497 JxlEncoderInitExtraChannelInfo(JXL_CHANNEL_ALPHA, &extra_info);
498 extra_info.bits_per_sample = info.alpha_bits;
499 extra_info.exponent_bits_per_sample = info.alpha_exponent_bits;
500 extra_info.alpha_premultiplied = info.alpha_premultiplied;
501 jret = JxlEncoderSetExtraChannelInfo(ctx->encoder, 0, &extra_info);
502 if (jret != JXL_ENC_SUCCESS) {
503 av_log(avctx, AV_LOG_ERROR, "Failed to set JxlExtraChannelInfo for alpha!\n");
505 goto end;
506 }
507 }
508
510 if (sd && sd->size) {
511 jret = JxlEncoderSetICCProfile(ctx->encoder, sd->data, sd->size);
512 if (jret != JXL_ENC_SUCCESS)
513 av_log(avctx, AV_LOG_WARNING, "Could not set ICC Profile\n");
514 }
515
516 /* jret != JXL_ENC_SUCCESS means fallthrough from above */
517 if (!sd || !sd->size || jret != JXL_ENC_SUCCESS) {
518 ret = libjxl_populate_colorspace(avctx, frame, pix_desc, &info);
519 if (ret < 0)
520 goto end;
521 }
522
523#if JPEGXL_NUMERIC_VERSION >= JPEGXL_COMPUTE_NUMERIC_VERSION(0, 8, 0)
524 jret = JxlEncoderSetFrameBitDepth(ctx->options, &jxl_bit_depth);
525 if (jret != JXL_ENC_SUCCESS)
526 av_log(avctx, AV_LOG_WARNING, "Failed to set JxlBitDepth\n");
527#endif
528
529 /* depending on basic info, level 10 might
530 * be required instead of level 5 */
531 if (JxlEncoderGetRequiredCodestreamLevel(ctx->encoder) > 5) {
532 jret = JxlEncoderSetCodestreamLevel(ctx->encoder, 10);
533 if (jret != JXL_ENC_SUCCESS)
534 av_log(avctx, AV_LOG_WARNING, "Could not increase codestream level\n");
535 }
536
537 libjxl_add_boxes(avctx);
538
539end:
540 av_buffer_unref(&ctx->exif_buffer);
541 return ret;
542}
543
544/**
545 * Sends frame information to libjxl on a per-frame basis. If this is a still image,
546 * this is evaluated once per output file. If this is an animated JPEG XL encode, it
547 * is called once per frame.
548 *
549 * This returns a buffer to the data that should be passed to libjxl (via the
550 * argument **data). If the linesize is nonnegative, this will be frame->data[0],
551 * although if the linesize is negative, it will be the start of the buffer
552 * instead. *data is just a pointer to a location in frame->data so it should not be
553 * freed directly.
554 */
555static int libjxl_preprocess_frame(AVCodecContext *avctx, const AVFrame *frame, const uint8_t **data)
556{
558 JxlPixelFormat *jxl_fmt = &ctx->jxl_fmt;
559
560 /* these shouldn't fail, libjxl bug notwithstanding */
561 if (JxlEncoderFrameSettingsSetOption(ctx->options, JXL_ENC_FRAME_SETTING_EFFORT, ctx->effort)
562 != JXL_ENC_SUCCESS) {
563 av_log(avctx, AV_LOG_ERROR, "Failed to set effort to: %d\n", ctx->effort);
564 return AVERROR_EXTERNAL;
565 }
566
567 if (JxlEncoderSetFrameDistance(ctx->options, ctx->distance) != JXL_ENC_SUCCESS) {
568 av_log(avctx, AV_LOG_ERROR, "Failed to set distance: %f\n", ctx->distance);
569 return AVERROR_EXTERNAL;
570 }
571
572 /*
573 * In theory the library should automatically enable modular if necessary,
574 * but it appears it won't at the moment due to a bug. This will still
575 * work even if that is patched.
576 */
577 if (JxlEncoderFrameSettingsSetOption(ctx->options, JXL_ENC_FRAME_SETTING_MODULAR,
578 ctx->modular || ctx->distance <= 0.0 ? 1 : -1) != JXL_ENC_SUCCESS) {
579 av_log(avctx, AV_LOG_ERROR, "Failed to set modular\n");
580 return AVERROR_EXTERNAL;
581 }
582
583 jxl_fmt->endianness = JXL_NATIVE_ENDIAN;
584 if (frame->linesize[0] >= 0) {
585 jxl_fmt->align = frame->linesize[0];
586 *data = frame->data[0];
587 } else {
588 jxl_fmt->align = -frame->linesize[0];
589 *data = frame->data[0] + frame->linesize[0] * (frame->height - 1);
590 }
591
592 return 0;
593}
594
595/**
596 * Run libjxl's output processing loop, reallocating the packet as necessary
597 * if libjxl needs more space to work with.
598 */
599static int libjxl_process_output(AVCodecContext *avctx, size_t *bytes_written)
600{
602 JxlEncoderStatus jret;
603 size_t available = ctx->buffer_size;
604 uint8_t *next_out = ctx->buffer;
605
606 while (1) {
607 jret = JxlEncoderProcessOutput(ctx->encoder, &next_out, &available);
608 if (jret == JXL_ENC_ERROR) {
609 av_log(avctx, AV_LOG_ERROR, "Unspecified libjxl error occurred\n");
610 return AVERROR_EXTERNAL;
611 }
612 *bytes_written = ctx->buffer_size - available;
613 /* all data passed has been encoded */
614 if (jret == JXL_ENC_SUCCESS)
615 break;
616 if (jret == JXL_ENC_NEED_MORE_OUTPUT) {
617 /*
618 * at the moment, libjxl has no way to
619 * tell us how much space it actually needs
620 * so we need to malloc loop
621 */
622 uint8_t *temp;
623 size_t new_size = ctx->buffer_size * 2;
624 temp = av_realloc(ctx->buffer, new_size);
625 if (!temp)
626 return AVERROR(ENOMEM);
627 ctx->buffer = temp;
628 ctx->buffer_size = new_size;
629 next_out = ctx->buffer + *bytes_written;
630 available = new_size - *bytes_written;
631 continue;
632 }
633 av_log(avctx, AV_LOG_ERROR, "Bad libjxl event: %d\n", jret);
634 return AVERROR_EXTERNAL;
635 }
636
637 return 0;
638}
639
640/**
641 * Encode an entire frame. This will always reinitialize a new still image
642 * and encode a one-frame image (for image2 and image2pipe).
643 */
644static int libjxl_encode_frame(AVCodecContext *avctx, AVPacket *pkt, const AVFrame *frame, int *got_packet)
645{
646
648 int ret;
649 size_t bytes_written = 0;
650 const uint8_t *data;
651
653 if (ret < 0) {
654 av_log(avctx, AV_LOG_ERROR, "Error frame-initializing JxlEncoder\n");
655 return ret;
656 }
657
659 if (ret < 0)
660 return ret;
661
663 if (ret < 0)
664 return ret;
665
666 if (JxlEncoderAddImageFrame(ctx->options, &ctx->jxl_fmt, data, ctx->jxl_fmt.align * frame->height)
667 != JXL_ENC_SUCCESS) {
668 av_log(avctx, AV_LOG_ERROR, "Failed to add Image Frame\n");
669 return AVERROR_EXTERNAL;
670 }
671
672 /*
673 * Run this after the last frame in the image has been passed.
674 */
675 JxlEncoderCloseInput(ctx->encoder);
676
677 ret = libjxl_process_output(avctx, &bytes_written);
678 if (ret < 0)
679 return ret;
680
681 ret = ff_get_encode_buffer(avctx, pkt, bytes_written, 0);
682 if (ret < 0)
683 return ret;
684
685 memcpy(pkt->data, ctx->buffer, bytes_written);
686 *got_packet = 1;
687
688 return 0;
689}
690
691/**
692 * Encode one frame of the animation. libjxl requires us to set duration of the frame
693 * but we're only promised the PTS, not the duration. As a result we have to buffer
694 * a frame and subtract the PTS from the last PTS. The last frame uses the previous
695 * frame's calculated duration as a fallback if its duration field is unset.
696 *
697 * We also need to tell libjxl if our frame is the last one, which we won't know upon
698 * receiving a single frame, so we have to buffer a frame as well and send the "last frame"
699 * upon receiving the special EOF frame.
700 */
702{
704 int ret = 0;
705 JxlFrameHeader frame_header;
706 size_t bytes_written = 0;
707 const uint8_t *data;
708
709 if (!ctx->prev) {
710 ctx->prev = av_frame_alloc();
711 if (!ctx->prev)
712 return AVERROR(ENOMEM);
713 ret = ff_encode_get_frame(avctx, ctx->prev);
714 if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF)
715 return ret;
716 ret = libjxl_preprocess_stream(avctx, ctx->prev, 1);
717 if (ret < 0)
718 return ret;
719 }
720
721 ret = ff_encode_get_frame(avctx, ctx->frame);
722 if (ret == AVERROR_EOF) {
723 av_frame_free(&ctx->frame);
724 ret = 0;
725 }
726 if (ret == AVERROR(EAGAIN))
727 return ret;
728
729 JxlEncoderInitFrameHeader(&frame_header);
730
731 ctx->duration = ctx->prev->duration ? ctx->prev->duration :
732 ctx->frame ? ctx->frame->pts - ctx->prev->pts :
733 ctx->duration ? ctx->duration :
734 1;
735
736 frame_header.duration = ctx->duration;
737 pkt->duration = ctx->duration;
738 pkt->pts = ctx->prev->pts;
739 pkt->dts = pkt->pts;
740
741 if (JxlEncoderSetFrameHeader(ctx->options, &frame_header) != JXL_ENC_SUCCESS) {
742 av_log(avctx, AV_LOG_ERROR, "Failed to set JxlFrameHeader\n");
743 return AVERROR_EXTERNAL;
744 }
745
746 ret = libjxl_preprocess_frame(avctx, ctx->prev, &data);
747 if (ret < 0)
748 return ret;
749
750 if (JxlEncoderAddImageFrame(ctx->options, &ctx->jxl_fmt, data, ctx->jxl_fmt.align * ctx->prev->height)
751 != JXL_ENC_SUCCESS) {
752 av_log(avctx, AV_LOG_ERROR, "Failed to add Image Frame\n");
753 return AVERROR_EXTERNAL;
754 }
755
756 if (!ctx->frame)
757 JxlEncoderCloseInput(ctx->encoder);
758
759 ret = libjxl_process_output(avctx, &bytes_written);
760 if (ret < 0)
761 return ret;
762
763 ret = ff_get_encode_buffer(avctx, pkt, bytes_written, 0);
764 if (ret < 0)
765 return ret;
766
767 memcpy(pkt->data, ctx->buffer, bytes_written);
768
769 if (ctx->frame) {
770 av_frame_unref(ctx->prev);
771 av_frame_move_ref(ctx->prev, ctx->frame);
772 } else {
773 av_frame_free(&ctx->prev);
774 }
775
776 return ret;
777}
778
780{
782
783 if (ctx->runner)
784 JxlThreadParallelRunnerDestroy(ctx->runner);
785 ctx->runner = NULL;
786
787 /*
788 * destroying the encoder also frees
789 * ctx->options so we don't need to
790 */
791 if (ctx->encoder)
792 JxlEncoderDestroy(ctx->encoder);
793 ctx->encoder = NULL;
794
795 av_freep(&ctx->buffer);
796 av_frame_free(&ctx->prev);
797 av_frame_free(&ctx->frame);
798
799 return 0;
800}
801
802#define OFFSET(x) offsetof(LibJxlEncodeContext, x)
803#define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
804
806 { "effort", "Encoding effort", OFFSET(effort), AV_OPT_TYPE_INT, { .i64 = 7 }, 1, 9, VE },
807 { "distance", "Maximum Butteraugli distance (quality setting, "
808 "lower = better, zero = lossless, default 1.0)", OFFSET(distance), AV_OPT_TYPE_FLOAT, { .dbl = -1.0 }, -1.0, 15.0, VE },
809 { "modular", "Force modular mode", OFFSET(modular), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 1, VE },
810 { "xyb", "Use XYB-encoding for lossy images", OFFSET(xyb),
811 AV_OPT_TYPE_INT, { .i64 = 1 }, 0, 1, VE },
812 { NULL },
813};
814
816 .class_name = "libjxl",
817 .item_name = av_default_item_name,
818 .option = libjxl_encode_options,
819 .version = LIBAVUTIL_VERSION_INT,
820};
821
831
833 .p.name = "libjxl",
834 CODEC_LONG_NAME("libjxl JPEG XL"),
835 .p.type = AVMEDIA_TYPE_VIDEO,
836 .p.id = AV_CODEC_ID_JPEGXL,
837 .priv_data_size = sizeof(LibJxlEncodeContext),
840 .close = libjxl_encode_close,
841 .p.capabilities = AV_CODEC_CAP_OTHER_THREADS |
844 .caps_internal = FF_CODEC_CAP_NOT_INIT_THREADSAFE |
849 .p.priv_class = &libjxl_encode_class,
850 .p.wrapper_name = "libjxl",
851};
852
854 .p.name = "libjxl_anim",
855 CODEC_LONG_NAME("libjxl JPEG XL animated"),
856 .p.type = AVMEDIA_TYPE_VIDEO,
858 .priv_data_size = sizeof(LibJxlEncodeContext),
861 .close = libjxl_encode_close,
862 .p.capabilities = AV_CODEC_CAP_OTHER_THREADS |
865 .caps_internal = FF_CODEC_CAP_NOT_INIT_THREADSAFE |
870 .p.priv_class = &libjxl_encode_class,
871 .p.wrapper_name = "libjxl",
872};
const FFCodec ff_libjxl_encoder
Definition libjxlenc.c:832
const FFCodec ff_libjxl_anim_encoder
Definition libjxlenc.c:853
#define VE
Definition amfenc_av1.c:30
static AVFormatContext * ctx
int32_t
Libavcodec external API header.
Convenience header that includes libavutil's core.
#define CODEC_PIXFMTS_ARRAY(array)
#define FF_CODEC_CAP_NOT_INIT_THREADSAFE
The codec is not known to be init-threadsafe (i.e.
#define FF_CODEC_RECEIVE_PACKET_CB(func)
#define FF_CODEC_CAP_ICC_PROFILES
Codec supports embedded ICC profiles (AV_FRAME_DATA_ICC_PROFILE).
#define FF_CODEC_ENCODE_CB(func)
#define CODEC_LONG_NAME(str)
#define FF_CODEC_CAP_INIT_CLEANUP
The codec allows calling the close function for deallocation even if the init function returned a fai...
#define FF_CODEC_CAP_AUTO_THREADS
Codec handles avctx->thread_count == 0 (auto) internally.
#define NULL
Definition coverity.c:32
long long int64_t
Definition coverity.c:34
Colorspace value utility functions for libavutil.
static AVPacket * pkt
static AVFrame * frame
Display matrix.
int(* init)(AVBSFContext *ctx)
Definition dts2pts.c:613
int ff_get_encode_buffer(AVCodecContext *avctx, AVPacket *avpkt, int64_t size, int flags)
Get a buffer for a packet.
Definition encode.c:107
int ff_encode_get_frame(AVCodecContext *avctx, AVFrame *frame)
Called by encoders to get the next frame for encoding.
Definition encode.c:220
error code definitions
int av_exif_get_entry(void *logctx, AVExifMetadata *ifd, uint16_t id, int flags, AVExifEntry **value)
Get an entry with the tagged ID from the EXIF metadata struct.
Definition exif.c:1204
int av_exif_parse_buffer(void *logctx, const uint8_t *buf, size_t size, AVExifMetadata *ifd, enum AVExifHeaderMode header_mode)
Decodes the EXIF data provided in the buffer and writes it into the struct *ifd.
Definition exif.c:902
void av_exif_free(AVExifMetadata *ifd)
Frees all resources associated with the given EXIF metadata struct.
Definition exif.c:679
int av_exif_matrix_to_orientation(const int32_t *matrix)
Convert a display matrix used by AV_FRAME_DATA_DISPLAYMATRIX into an orientation constant used by EXI...
Definition exif.c:1344
int av_exif_orientation_to_matrix(int32_t *matrix, int orientation)
Convert an orientation constant used by EXIF's orientation tag into a display matrix used by AV_FRAME...
Definition exif.c:1357
int ff_exif_sanitize_ifd(void *logctx, const AVFrame *frame, AVExifMetadata *ifd)
Compares values in the IFD with data in the provided AVFrame and sets the values in that IFD to match...
Definition exif.c:1395
int av_exif_write(void *logctx, const AVExifMetadata *ifd, AVBufferRef **buffer, enum AVExifHeaderMode header_mode)
Allocates a buffer using av_malloc of an appropriate size and writes the EXIF data represented by ifd...
Definition exif.c:773
int32_t av_exif_get_tag_id(const char *name)
Retrieves the tag ID associated with the provided tag string name.
Definition exif.c:245
int av_exif_remove_entry(void *logctx, AVExifMetadata *ifd, uint16_t id, int flags)
Remove an entry from the provided EXIF metadata struct.
Definition exif.c:1303
@ AV_TIFF_SHORT
Definition exif.h:44
@ AV_EXIF_TIFF_HEADER
The TIFF header starts with 0x49492a00, or 0x4d4d002a.
Definition exif.h:62
@ AV_EXIF_T_OFF
The first four bytes point to the actual start, then it's AV_EXIF_TIFF_HEADER.
Definition exif.h:68
EXIF metadata parser - internal functions.
int ret
Definition ffplay.c:391
reference-counted frame API
@ AV_OPT_TYPE_INT
Underlying C type is int.
Definition opt.h:258
@ AV_OPT_TYPE_FLOAT
Underlying C type is float.
Definition opt.h:270
#define AV_CODEC_CAP_ENCODER_REORDERED_OPAQUE
This encoder can reorder user opaque values from input AVFrames and return them with corresponding ou...
Definition codec.h:147
#define AV_CODEC_CAP_OTHER_THREADS
Codec supports multithreading through a method other than slice- or frame-level multithreading.
Definition codec.h:112
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() or get_encode_buffer() for allocating buffers and supports custom allocators.
Definition codec.h:49
#define AV_CODEC_FLAG_QSCALE
Use fixed qscale.
Definition avcodec.h:213
@ AV_CODEC_ID_JPEGXL_ANIM
Definition codec_id.h:322
@ AV_CODEC_ID_JPEGXL
Definition codec_id.h:308
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:140
#define FF_QP2LAMBDA
factor to convert from H.263 QP to lambda
Definition avutil.h:226
#define AVERROR_EXTERNAL
Generic error in an external library.
Definition error.h:59
#define AVERROR_EOF
End of file.
Definition error.h:57
#define AVERROR(e)
Definition error.h:45
void av_frame_unref(AVFrame *frame)
Unreference all the buffers referenced by frame and reset the frame fields.
Definition frame.c:499
AVFrameSideData * av_frame_get_side_data(const AVFrame *frame, enum AVFrameSideDataType type)
Definition frame.c:662
void av_frame_move_ref(AVFrame *dst, AVFrame *src)
Move everything contained in src to dst and reset src.
Definition frame.c:526
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition frame.c:65
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
Definition frame.c:53
@ AV_FRAME_DATA_EXIF
Exchangeable image file format metadata.
Definition frame.h:263
@ AV_FRAME_DATA_DISPLAYMATRIX
This side data contains a 3x3 transformation matrix describing an affine transformation that needs to...
Definition frame.h:85
@ 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
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition log.h:216
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition log.h:210
const char * av_default_item_name(void *ptr)
Return the context name.
Definition log.c:247
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:95
static double av_q2d(AVRational a)
Convert an AVRational to a double.
Definition rational.h:104
@ AVMEDIA_TYPE_VIDEO
Definition avutil.h:200
#define LIBAVUTIL_VERSION_INT
Definition version.h:85
void av_display_matrix_flip(int32_t matrix[9], int hflip, int vflip)
Flip the input matrix horizontally and/or vertically.
Definition display.c:65
#define av_cold
Definition attributes.h:117
Libavutil version macros.
size_t ff_libjxl_get_threadcount(int threads)
Transform threadcount in ffmpeg to one used by libjxl.
Definition libjxl.c:33
void ff_libjxl_init_memory_manager(JxlMemoryManager *manager)
Initialize and populate a JxlMemoryManager with av_malloc() and av_free() so libjxl will use these fu...
Definition libjxl.c:65
JPEG XL via libjxl common support header.
static const AVClass libjxl_encode_class
Definition libjxlenc.c:815
static int libjxl_preprocess_stream(AVCodecContext *avctx, const AVFrame *frame, int animated)
Sends metadata to libjxl based on the first frame of the stream, such as pixel format,...
Definition libjxlenc.c:362
static int libjxl_populate_colorspace(AVCodecContext *avctx, const AVFrame *frame, const AVPixFmtDescriptor *pix_desc, const JxlBasicInfo *info)
Definition libjxlenc.c:257
static int libjxl_anim_encode_frame(AVCodecContext *avctx, AVPacket *pkt)
Encode one frame of the animation.
Definition libjxlenc.c:701
static int libjxl_encode_frame(AVCodecContext *avctx, AVPacket *pkt, const AVFrame *frame, int *got_packet)
Encode an entire frame.
Definition libjxlenc.c:644
static enum AVPixelFormat libjxl_supported_pixfmts[]
Definition libjxlenc.c:822
static int libjxl_populate_primaries(void *avctx, JxlColorEncoding *jxl_color, enum AVColorPrimaries prm)
Populate a JxlColorEncoding with the given enum AVColorPrimaries.
Definition libjxlenc.c:206
static const AVOption libjxl_encode_options[]
Definition libjxlenc.c:805
static int libjxl_preprocess_frame(AVCodecContext *avctx, const AVFrame *frame, const uint8_t **data)
Sends frame information to libjxl on a per-frame basis.
Definition libjxlenc.c:555
static int libjxl_process_output(AVCodecContext *avctx, size_t *bytes_written)
Run libjxl's output processing loop, reallocating the packet as necessary if libjxl needs more space ...
Definition libjxlenc.c:599
static av_cold int libjxl_anim_encode_init(AVCodecContext *avctx)
Initializer for the animation encoder.
Definition libjxlenc.c:182
static av_cold int libjxl_encode_close(AVCodecContext *avctx)
Definition libjxlenc.c:779
#define OFFSET(x)
Definition libjxlenc.c:802
static int libjxl_add_boxes(AVCodecContext *avctx)
Definition libjxlenc.c:324
static float quality_to_distance(float quality)
Map a quality setting for -qscale roughly from libjpeg quality numbers to libjxl's butteraugli distan...
Definition libjxlenc.c:84
static int libjxl_init_jxl_encoder(AVCodecContext *avctx)
Initialize the encoder on a per-file basis.
Definition libjxlenc.c:105
static av_cold int libjxl_encode_init(AVCodecContext *avctx)
Global encoder initialization.
Definition libjxlenc.c:132
const char * desc
Definition libsvtav1.c:83
Memory handling functions.
uint32_t tag
Definition movenc.c:2144
const char data[16]
Definition mxf.c:149
static float distance(float x, float y, int band)
#define av_realloc(p, s)
Definition ops_static.c:54
AVOptions.
int av_get_bits_per_pixel(const AVPixFmtDescriptor *pixdesc)
Return the number of bits per pixel used by the pixel format described by pixdesc.
Definition pixdesc.c:3436
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
Definition pixdesc.c:3484
#define AV_PIX_FMT_FLAG_FLOAT
The pixel format contains IEEE-754 floating point values.
Definition pixdesc.h:158
pixel format definitions
#define AV_PIX_FMT_RGBF32
Definition pixfmt.h:637
#define AV_PIX_FMT_RGBAF32
Definition pixfmt.h:638
@ AVCOL_RANGE_MPEG
Narrow or limited range content.
Definition pixfmt.h:775
@ AVCOL_RANGE_UNSPECIFIED
Definition pixfmt.h:758
@ AVCOL_RANGE_JPEG
Full range content.
Definition pixfmt.h:792
#define AV_PIX_FMT_YA16
Definition pixfmt.h:533
@ AVALPHA_MODE_STRAIGHT
Alpha channel is independent of color values.
Definition pixfmt.h:828
@ AVALPHA_MODE_UNSPECIFIED
Unknown alpha handling, or no alpha channel.
Definition pixfmt.h:826
@ AVALPHA_MODE_PREMULTIPLIED
Alpha channel is multiplied into color values.
Definition pixfmt.h:827
#define AV_PIX_FMT_RGBA64
Definition pixfmt.h:538
#define AV_PIX_FMT_RGB48
Definition pixfmt.h:534
#define AV_PIX_FMT_GRAYF32
Definition pixfmt.h:591
AVPixelFormat
Pixel format.
Definition pixfmt.h:71
@ AV_PIX_FMT_NONE
Definition pixfmt.h:72
@ AV_PIX_FMT_RGB24
packed RGB 8:8:8, 24bpp, RGBRGB...
Definition pixfmt.h:75
@ AV_PIX_FMT_GRAY8
Y , 8bpp.
Definition pixfmt.h:81
@ AV_PIX_FMT_RGBA
packed RGBA 8:8:8:8, 32bpp, RGBARGBA...
Definition pixfmt.h:100
@ AV_PIX_FMT_YA8
8 bits gray, 8 bits alpha
Definition pixfmt.h:140
#define AV_PIX_FMT_GRAY16
Definition pixfmt.h:531
AVColorPrimaries
Chromaticity coordinates of the source primaries.
Definition pixfmt.h:647
@ AVCOL_PRI_SMPTE432
SMPTE ST 432-1 (2010) / P3 D65 / Display P3.
Definition pixfmt.h:662
@ AVCOL_PRI_BT709
also ITU-R BT1361 / IEC 61966-2-4 / SMPTE RP 177 Annex B
Definition pixfmt.h:649
@ AVCOL_PRI_UNSPECIFIED
Definition pixfmt.h:650
@ AVCOL_PRI_SMPTE431
SMPTE ST 431-2 (2011) / DCI P3.
Definition pixfmt.h:661
@ AVCOL_PRI_SMPTE428
SMPTE ST 428-1 (CIE 1931 XYZ)
Definition pixfmt.h:659
@ AVCOL_PRI_BT2020
ITU-R BT2020.
Definition pixfmt.h:658
@ AVCOL_TRC_SMPTE2084
SMPTE ST 2084 for 10-, 12-, 14- and 16-bit systems.
Definition pixfmt.h:694
@ AVCOL_TRC_GAMMA22
also ITU-R BT470M / ITU-R BT1700 625 PAL & SECAM
Definition pixfmt.h:682
@ AVCOL_TRC_LINEAR
"Linear transfer characteristics"
Definition pixfmt.h:686
@ AVCOL_TRC_GAMMA28
also ITU-R BT470BG
Definition pixfmt.h:683
@ AVCOL_TRC_ARIB_STD_B67
ARIB STD-B67, known as "Hybrid log-gamma".
Definition pixfmt.h:698
@ AVCOL_TRC_SMPTE428
SMPTE ST 428-1.
Definition pixfmt.h:696
@ AVCOL_TRC_IEC61966_2_1
IEC 61966-2-1 (sRGB or sYCC)
Definition pixfmt.h:691
@ AVCOL_TRC_UNSPECIFIED
Definition pixfmt.h:680
@ AVCOL_TRC_BT709
also ITU-R BT1361
Definition pixfmt.h:679
A reference to a data buffer.
Definition buffer.h:82
Describe the class of an AVClass context structure.
Definition log.h:76
main external API structure.
Definition avcodec.h:443
int global_quality
Global quality for codecs which cannot change it per frame.
Definition avcodec.h:1240
enum AVColorRange color_range
MPEG vs JPEG YUV range.
Definition avcodec.h:685
enum AVColorPrimaries color_primaries
Chromaticity coordinates of the source primaries.
Definition avcodec.h:658
int bits_per_raw_sample
Bits per sample/pixel of internal libavcodec pixel/sample format.
Definition avcodec.h:1581
int thread_count
thread count is used to decide how many independent tasks should be passed to execute()
Definition avcodec.h:1589
enum AVColorTransferCharacteristic color_trc
Color Transfer Characteristic.
Definition avcodec.h:665
AVRational time_base
This is the fundamental unit of time (in seconds) in terms of which frame timestamps are represented.
Definition avcodec.h:547
int flags
AV_CODEC_FLAG_*.
Definition avcodec.h:500
enum AVAlphaMode alpha_mode
Indicates how the alpha channel of the video is represented.
Definition avcodec.h:1947
void * priv_data
Definition avcodec.h:470
Struct that contains both white point location and primaries location, providing the complete descrip...
Definition csp.h:78
enum AVTiffDataType type
Definition exif.h:86
uint32_t count
Definition exif.h:87
union AVExifEntry::@325220332140161067313112036135003363017341144014 value
uint64_t * uint
Definition exif.h:108
Structure to hold side data for an AVFrame.
Definition frame.h:334
size_t size
Definition frame.h:337
uint8_t * data
Definition frame.h:336
This structure describes decoded (raw) audio or video data.
Definition frame.h:479
AVOption.
Definition opt.h:428
This structure stores compressed data.
Definition packet.h:587
Descriptor that unambiguously describes how the bits of a pixel are stored in the up to 4 data planes...
Definition pixdesc.h:69
uint64_t flags
Combination of AV_PIX_FMT_FLAG_... flags.
Definition pixdesc.h:94
uint8_t nb_components
The number of components each pixel has, (1-4)
Definition pixdesc.h:71
int num
Numerator.
Definition rational.h:59
int den
Denominator.
Definition rational.h:60
AVBufferRef * exif_buffer
Definition libjxlenc.c:62
JxlEncoder * encoder
Definition libjxlenc.c:53
JxlEncoderFrameSettings * options
Definition libjxlenc.c:54
JxlPixelFormat jxl_fmt
Definition libjxlenc.c:61
#define av_freep(p)
#define av_log(a,...)
else temp
Definition vf_mcdeint.c:275
static const uint8_t quality[]
Definition vmixdec.c:58