FFmpeg: libavcodec/libjxlenc.c Source File

FFmpeg
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 <string.h>
28 
29 #include "libavutil/avutil.h"
30 #include "libavutil/csp.h"
31 #include "libavutil/error.h"
32 #include "libavutil/frame.h"
33 #include "libavutil/libm.h"
34 #include "libavutil/opt.h"
35 #include "libavutil/pixdesc.h"
36 #include "libavutil/pixfmt.h"
37 #include "libavutil/version.h"
38 
39 #include "avcodec.h"
40 #include "encode.h"
41 #include "codec_internal.h"
42 
43 #include <jxl/encode.h>
44 #include <jxl/thread_parallel_runner.h>
45 #include "libjxl.h"
46 
47  typedef struct LibJxlEncodeContext {
48   AVClass *class;
49   void *runner;
50   JxlEncoder *encoder;
51   JxlEncoderFrameSettings *options;
52   int effort;
53   float distance;
54   int modular;
55   int xyb;
56   uint8_t *buffer;
57   size_t buffer_size;
58 } LibJxlEncodeContext;
59 
60 /**
61  * Map a quality setting for -qscale roughly from libjpeg
62  * quality numbers to libjxl's butteraugli distance for
63  * photographic content.
64  *
65  * Setting distance explicitly is preferred, but this will
66  * allow qscale to be used as a fallback.
67  *
68  * This function is continuous and injective on [0, 100] which
69  * makes it monotonic.
70  *
71  * @param quality 0.0 to 100.0 quality setting, libjpeg quality
72  * @return Butteraugli distance between 0.0 and 15.0
73  */
74  static float quality_to_distance(float quality)
75 {
76  if (quality >= 100.0)
77  return 0.0;
78  else if (quality >= 90.0)
79  return (100.0 - quality) * 0.10;
80  else if (quality >= 30.0)
81  return 0.1 + (100.0 - quality) * 0.09;
82  else if (quality > 0.0)
83  return 15.0 + (59.0 * quality - 4350.0) * quality / 9000.0;
84  else
85  return 15.0;
86 }
87 
88 /**
89  * Initalize the encoder on a per-frame basis. All of these need to be set
90  * once each time the encoder is reset, which it must be each frame to make
91  * the image2 muxer work.
92  *
93  * @return 0 upon success, negative on failure.
94  */
95  static int libjxl_init_jxl_encoder(AVCodecContext *avctx)
96 {
97  LibJxlEncodeContext *ctx = avctx->priv_data;
98 
99  /* reset the encoder every frame for image2 muxer */
100  JxlEncoderReset(ctx->encoder);
101 
102  ctx->options = JxlEncoderFrameSettingsCreate(ctx->encoder, NULL);
103  if (!ctx->options) {
104  av_log(avctx, AV_LOG_ERROR, "Failed to create JxlEncoderOptions\n");
105  return AVERROR_EXTERNAL;
106  }
107 
108  /* This needs to be set each time the encoder is reset */
109  if (JxlEncoderSetParallelRunner(ctx->encoder, JxlThreadParallelRunner, ctx->runner)
110  != JXL_ENC_SUCCESS) {
111  av_log(avctx, AV_LOG_ERROR, "Failed to set JxlThreadParallelRunner\n");
112  return AVERROR_EXTERNAL;
113  }
114 
115  /* these shouldn't fail, libjxl bug notwithstanding */
116  if (JxlEncoderFrameSettingsSetOption(ctx->options, JXL_ENC_FRAME_SETTING_EFFORT, ctx->effort)
117  != JXL_ENC_SUCCESS) {
118  av_log(avctx, AV_LOG_ERROR, "Failed to set effort to: %d\n", ctx->effort);
119  return AVERROR_EXTERNAL;
120  }
121 
122  /* check for negative, our default */
123  if (ctx->distance < 0.0) {
124  /* use ffmpeg.c -q option if passed */
125  if (avctx->flags & AV_CODEC_FLAG_QSCALE)
126  ctx->distance = quality_to_distance((float)avctx->global_quality / FF_QP2LAMBDA);
127  else
128  /* default 1.0 matches cjxl */
129  ctx->distance = 1.0;
130  }
131 
132  /*
133  * 0.01 is the minimum distance accepted for lossy
134  * interpreting any positive value less than this as minimum
135  */
136  if (ctx->distance > 0.0 && ctx->distance < 0.01)
137  ctx->distance = 0.01;
138  if (JxlEncoderSetFrameDistance(ctx->options, ctx->distance) != JXL_ENC_SUCCESS) {
139  av_log(avctx, AV_LOG_ERROR, "Failed to set distance: %f\n", ctx->distance);
140  return AVERROR_EXTERNAL;
141  }
142 
143  /*
144  * In theory the library should automatically enable modular if necessary,
145  * but it appears it won't at the moment due to a bug. This will still
146  * work even if that is patched.
147  */
148  if (JxlEncoderFrameSettingsSetOption(ctx->options, JXL_ENC_FRAME_SETTING_MODULAR,
149  ctx->modular || ctx->distance <= 0.0 ? 1 : -1) != JXL_ENC_SUCCESS) {
150  av_log(avctx, AV_LOG_ERROR, "Failed to set modular\n");
151  return AVERROR_EXTERNAL;
152  }
153 
154  return 0;
155 }
156 
157 /**
158  * Global encoder initialization. This only needs to be run once,
159  * not every frame.
160  */
161  static av_cold int libjxl_encode_init(AVCodecContext *avctx)
162 {
163  LibJxlEncodeContext *ctx = avctx->priv_data;
164  JxlMemoryManager manager;
165 
166  ff_libjxl_init_memory_manager(&manager);
167  ctx->encoder = JxlEncoderCreate(&manager);
168  if (!ctx->encoder) {
169  av_log(avctx, AV_LOG_ERROR, "Failed to create JxlEncoder\n");
170  return AVERROR_EXTERNAL;
171  }
172 
173  ctx->runner = JxlThreadParallelRunnerCreate(&manager, ff_libjxl_get_threadcount(avctx->thread_count));
174  if (!ctx->runner) {
175  av_log(avctx, AV_LOG_ERROR, "Failed to create JxlThreadParallelRunner\n");
176  return AVERROR_EXTERNAL;
177  }
178 
179  ctx->buffer_size = 4096;
180  ctx->buffer = av_realloc(NULL, ctx->buffer_size);
181 
182  if (!ctx->buffer) {
183  av_log(avctx, AV_LOG_ERROR, "Could not allocate encoding buffer\n");
184  return AVERROR(ENOMEM);
185  }
186 
187  return 0;
188 }
189 
190 /**
191  * Populate a JxlColorEncoding with the given enum AVColorPrimaries.
192  * @return < 0 upon failure, >= 0 upon success
193  */
194  static int libjxl_populate_primaries(void *avctx, JxlColorEncoding *jxl_color, enum AVColorPrimaries prm)
195 {
196  const AVColorPrimariesDesc *desc;
197 
198  switch (prm) {
199  case AVCOL_PRI_BT709:
200  jxl_color->primaries = JXL_PRIMARIES_SRGB;
201  jxl_color->white_point = JXL_WHITE_POINT_D65;
202  return 0;
203  case AVCOL_PRI_BT2020:
204  jxl_color->primaries = JXL_PRIMARIES_2100;
205  jxl_color->white_point = JXL_WHITE_POINT_D65;
206  return 0;
207  case AVCOL_PRI_SMPTE431:
208  jxl_color->primaries = JXL_PRIMARIES_P3;
209  jxl_color->white_point = JXL_WHITE_POINT_DCI;
210  return 0;
211  case AVCOL_PRI_SMPTE432:
212  jxl_color->primaries = JXL_PRIMARIES_P3;
213  jxl_color->white_point = JXL_WHITE_POINT_D65;
214  return 0;
215  case AVCOL_PRI_UNSPECIFIED:
216  av_log(avctx, AV_LOG_WARNING, "Unknown primaries, assuming BT.709/sRGB. Colors may be wrong.\n");
217  jxl_color->primaries = JXL_PRIMARIES_SRGB;
218  jxl_color->white_point = JXL_WHITE_POINT_D65;
219  return 0;
220  }
221 
222  desc = av_csp_primaries_desc_from_id(prm);
223  if (!desc)
224  return AVERROR(EINVAL);
225 
226  jxl_color->primaries = JXL_PRIMARIES_CUSTOM;
227  jxl_color->white_point = JXL_WHITE_POINT_CUSTOM;
228 
229  jxl_color->primaries_red_xy[0] = av_q2d(desc->prim.r.x);
230  jxl_color->primaries_red_xy[1] = av_q2d(desc->prim.r.y);
231  jxl_color->primaries_green_xy[0] = av_q2d(desc->prim.g.x);
232  jxl_color->primaries_green_xy[1] = av_q2d(desc->prim.g.y);
233  jxl_color->primaries_blue_xy[0] = av_q2d(desc->prim.b.x);
234  jxl_color->primaries_blue_xy[1] = av_q2d(desc->prim.b.y);
235  jxl_color->white_point_xy[0] = av_q2d(desc->wp.x);
236  jxl_color->white_point_xy[1] = av_q2d(desc->wp.y);
237 
238  return 0;
239 }
240 
241 /**
242  * Encode an entire frame. Currently animation, is not supported by
243  * this encoder, so this will always reinitialize a new still image
244  * and encode a one-frame image (for image2 and image2pipe).
245  */
246  static int libjxl_encode_frame(AVCodecContext *avctx, AVPacket *pkt, const AVFrame *frame, int *got_packet)
247 {
248  LibJxlEncodeContext *ctx = avctx->priv_data;
249  AVFrameSideData *sd;
250  const AVPixFmtDescriptor *pix_desc = av_pix_fmt_desc_get(frame->format);
251  JxlBasicInfo info;
252  JxlColorEncoding jxl_color;
253  JxlPixelFormat jxl_fmt;
254  int bits_per_sample;
255 #if JPEGXL_NUMERIC_VERSION >= JPEGXL_COMPUTE_NUMERIC_VERSION(0, 8, 0)
256  JxlBitDepth jxl_bit_depth;
257 #endif
258  JxlEncoderStatus jret;
259  int ret;
260  size_t available = ctx->buffer_size;
261  size_t bytes_written = 0;
262  uint8_t *next_out = ctx->buffer;
263  const uint8_t *data;
264 
265  ret = libjxl_init_jxl_encoder(avctx);
266  if (ret) {
267  av_log(avctx, AV_LOG_ERROR, "Error frame-initializing JxlEncoder\n");
268  return ret;
269  }
270 
271  /* populate the basic info settings */
272  JxlEncoderInitBasicInfo(&info);
273  jxl_fmt.num_channels = pix_desc->nb_components;
274  info.xsize = frame->width;
275  info.ysize = frame->height;
276  info.num_extra_channels = (jxl_fmt.num_channels + 1) % 2;
277  info.num_color_channels = jxl_fmt.num_channels - info.num_extra_channels;
278  bits_per_sample = av_get_bits_per_pixel(pix_desc) / jxl_fmt.num_channels;
279  info.bits_per_sample = avctx->bits_per_raw_sample > 0 && !(pix_desc->flags & AV_PIX_FMT_FLAG_FLOAT)
280  ? avctx->bits_per_raw_sample : bits_per_sample;
281  info.alpha_bits = (info.num_extra_channels > 0) * info.bits_per_sample;
282  if (pix_desc->flags & AV_PIX_FMT_FLAG_FLOAT) {
283  info.exponent_bits_per_sample = info.bits_per_sample > 16 ? 8 : 5;
284  info.alpha_exponent_bits = info.alpha_bits ? info.exponent_bits_per_sample : 0;
285  jxl_fmt.data_type = info.bits_per_sample > 16 ? JXL_TYPE_FLOAT : JXL_TYPE_FLOAT16;
286  } else {
287  info.exponent_bits_per_sample = 0;
288  info.alpha_exponent_bits = 0;
289  jxl_fmt.data_type = info.bits_per_sample <= 8 ? JXL_TYPE_UINT8 : JXL_TYPE_UINT16;
290  }
291 
292 #if JPEGXL_NUMERIC_VERSION >= JPEGXL_COMPUTE_NUMERIC_VERSION(0, 8, 0)
293  jxl_bit_depth.bits_per_sample = bits_per_sample;
294  jxl_bit_depth.type = JXL_BIT_DEPTH_FROM_PIXEL_FORMAT;
295  jxl_bit_depth.exponent_bits_per_sample = pix_desc->flags & AV_PIX_FMT_FLAG_FLOAT ?
296  info.exponent_bits_per_sample : 0;
297 #endif
298 
299  /* JPEG XL format itself does not support limited range */
300  if (avctx->color_range == AVCOL_RANGE_MPEG ||
301  avctx->color_range == AVCOL_RANGE_UNSPECIFIED && frame->color_range == AVCOL_RANGE_MPEG)
302  av_log(avctx, AV_LOG_WARNING, "This encoder does not support limited (tv) range, colors will be wrong!\n");
303  else if (avctx->color_range != AVCOL_RANGE_JPEG && frame->color_range != AVCOL_RANGE_JPEG)
304  av_log(avctx, AV_LOG_WARNING, "Unknown color range, assuming full (pc)\n");
305 
306  /* bitexact lossless requires there to be no XYB transform */
307  info.uses_original_profile = ctx->distance == 0.0 || !ctx->xyb;
308  info.orientation = frame->linesize[0] >= 0 ? JXL_ORIENT_IDENTITY : JXL_ORIENT_FLIP_VERTICAL;
309 
310  if (JxlEncoderSetBasicInfo(ctx->encoder, &info) != JXL_ENC_SUCCESS) {
311  av_log(avctx, AV_LOG_ERROR, "Failed to set JxlBasicInfo\n");
312  return AVERROR_EXTERNAL;
313  }
314 
315  /* rendering intent doesn't matter here
316  * but libjxl will whine if we don't set it */
317  jxl_color.rendering_intent = JXL_RENDERING_INTENT_RELATIVE;
318 
319  switch (frame->color_trc && frame->color_trc != AVCOL_TRC_UNSPECIFIED
320  ? frame->color_trc : avctx->color_trc) {
321  case AVCOL_TRC_BT709:
322  jxl_color.transfer_function = JXL_TRANSFER_FUNCTION_709;
323  break;
324  case AVCOL_TRC_LINEAR:
325  jxl_color.transfer_function = JXL_TRANSFER_FUNCTION_LINEAR;
326  break;
327  case AVCOL_TRC_IEC61966_2_1:
328  jxl_color.transfer_function = JXL_TRANSFER_FUNCTION_SRGB;
329  break;
330  case AVCOL_TRC_SMPTE428:
331  jxl_color.transfer_function = JXL_TRANSFER_FUNCTION_DCI;
332  break;
333  case AVCOL_TRC_SMPTE2084:
334  jxl_color.transfer_function = JXL_TRANSFER_FUNCTION_PQ;
335  break;
336  case AVCOL_TRC_ARIB_STD_B67:
337  jxl_color.transfer_function = JXL_TRANSFER_FUNCTION_HLG;
338  break;
339  case AVCOL_TRC_GAMMA22:
340  jxl_color.transfer_function = JXL_TRANSFER_FUNCTION_GAMMA;
341  jxl_color.gamma = 1/2.2f;
342  break;
343  case AVCOL_TRC_GAMMA28:
344  jxl_color.transfer_function = JXL_TRANSFER_FUNCTION_GAMMA;
345  jxl_color.gamma = 1/2.8f;
346  break;
347  default:
348  if (pix_desc->flags & AV_PIX_FMT_FLAG_FLOAT) {
349  av_log(avctx, AV_LOG_WARNING, "Unknown transfer function, assuming Linear Light. Colors may be wrong.\n");
350  jxl_color.transfer_function = JXL_TRANSFER_FUNCTION_LINEAR;
351  } else {
352  av_log(avctx, AV_LOG_WARNING, "Unknown transfer function, assuming IEC61966-2-1/sRGB. Colors may be wrong.\n");
353  jxl_color.transfer_function = JXL_TRANSFER_FUNCTION_SRGB;
354  }
355  }
356 
357  /* This should be implied to be honest
358  * but a libjxl bug makes it fail otherwise */
359  if (info.num_color_channels == 1)
360  jxl_color.color_space = JXL_COLOR_SPACE_GRAY;
361  else
362  jxl_color.color_space = JXL_COLOR_SPACE_RGB;
363 
364  ret = libjxl_populate_primaries(avctx, &jxl_color,
365  frame->color_primaries && frame->color_primaries != AVCOL_PRI_UNSPECIFIED
366  ? frame->color_primaries : avctx->color_primaries);
367  if (ret < 0)
368  return ret;
369 
370  sd = av_frame_get_side_data(frame, AV_FRAME_DATA_ICC_PROFILE);
371  if (sd && sd->size && JxlEncoderSetICCProfile(ctx->encoder, sd->data, sd->size) != JXL_ENC_SUCCESS)
372  av_log(avctx, AV_LOG_WARNING, "Could not set ICC Profile\n");
373  if (JxlEncoderSetColorEncoding(ctx->encoder, &jxl_color) != JXL_ENC_SUCCESS)
374  av_log(avctx, AV_LOG_WARNING, "Failed to set JxlColorEncoding\n");
375 
376 #if JPEGXL_NUMERIC_VERSION >= JPEGXL_COMPUTE_NUMERIC_VERSION(0, 8, 0)
377  if (JxlEncoderSetFrameBitDepth(ctx->options, &jxl_bit_depth) != JXL_ENC_SUCCESS)
378  av_log(avctx, AV_LOG_WARNING, "Failed to set JxlBitDepth\n");
379 #endif
380 
381  /* depending on basic info, level 10 might
382  * be required instead of level 5 */
383  if (JxlEncoderGetRequiredCodestreamLevel(ctx->encoder) > 5) {
384  if (JxlEncoderSetCodestreamLevel(ctx->encoder, 10) != JXL_ENC_SUCCESS)
385  av_log(avctx, AV_LOG_WARNING, "Could not increase codestream level\n");
386  }
387 
388  jxl_fmt.endianness = JXL_NATIVE_ENDIAN;
389  if (frame->linesize[0] >= 0) {
390  jxl_fmt.align = frame->linesize[0];
391  data = frame->data[0];
392  } else {
393  jxl_fmt.align = -frame->linesize[0];
394  data = frame->data[0] + frame->linesize[0] * (info.ysize - 1);
395  }
396 
397  if (JxlEncoderAddImageFrame(ctx->options, &jxl_fmt, data, jxl_fmt.align * info.ysize) != JXL_ENC_SUCCESS) {
398  av_log(avctx, AV_LOG_ERROR, "Failed to add Image Frame\n");
399  return AVERROR_EXTERNAL;
400  }
401 
402  /*
403  * Run this after the last frame in the image has been passed.
404  * TODO support animation
405  */
406  JxlEncoderCloseInput(ctx->encoder);
407 
408  while (1) {
409  jret = JxlEncoderProcessOutput(ctx->encoder, &next_out, &available);
410  if (jret == JXL_ENC_ERROR) {
411  av_log(avctx, AV_LOG_ERROR, "Unspecified libjxl error occurred\n");
412  return AVERROR_EXTERNAL;
413  }
414  bytes_written = ctx->buffer_size - available;
415  /* all data passed has been encoded */
416  if (jret == JXL_ENC_SUCCESS)
417  break;
418  if (jret == JXL_ENC_NEED_MORE_OUTPUT) {
419  /*
420  * at the moment, libjxl has no way to
421  * tell us how much space it actually needs
422  * so we need to malloc loop
423  */
424  uint8_t *temp;
425  size_t new_size = ctx->buffer_size * 2;
426  temp = av_realloc(ctx->buffer, new_size);
427  if (!temp)
428  return AVERROR(ENOMEM);
429  ctx->buffer = temp;
430  ctx->buffer_size = new_size;
431  next_out = ctx->buffer + bytes_written;
432  available = new_size - bytes_written;
433  continue;
434  }
435  av_log(avctx, AV_LOG_ERROR, "Bad libjxl event: %d\n", jret);
436  return AVERROR_EXTERNAL;
437  }
438 
439  ret = ff_get_encode_buffer(avctx, pkt, bytes_written, 0);
440  if (ret < 0)
441  return ret;
442 
443  memcpy(pkt->data, ctx->buffer, bytes_written);
444  *got_packet = 1;
445 
446  return 0;
447 }
448 
449  static av_cold int libjxl_encode_close(AVCodecContext *avctx)
450 {
451  LibJxlEncodeContext *ctx = avctx->priv_data;
452 
453  if (ctx->runner)
454  JxlThreadParallelRunnerDestroy(ctx->runner);
455  ctx->runner = NULL;
456 
457  /*
458  * destroying the encoder also frees
459  * ctx->options so we don't need to
460  */
461  if (ctx->encoder)
462  JxlEncoderDestroy(ctx->encoder);
463  ctx->encoder = NULL;
464 
465  av_freep(&ctx->buffer);
466 
467  return 0;
468 }
469 
470  #define OFFSET(x) offsetof(LibJxlEncodeContext, x)
471  #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
472 
473  static const AVOption libjxl_encode_options[] = {
474  { "effort", "Encoding effort", OFFSET(effort), AV_OPT_TYPE_INT, { .i64 = 7 }, 1, 9, VE },
475  { "distance", "Maximum Butteraugli distance (quality setting, "
476  "lower = better, zero = lossless, default 1.0)", OFFSET(distance), AV_OPT_TYPE_FLOAT, { .dbl = -1.0 }, -1.0, 15.0, VE },
477  { "modular", "Force modular mode", OFFSET(modular), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 1, VE },
478  { "xyb", "Use XYB-encoding for lossy images", OFFSET(xyb),
479  AV_OPT_TYPE_INT, { .i64 = 1 }, 0, 1, VE },
480  { NULL },
481 };
482 
483  static const AVClass libjxl_encode_class = {
484  .class_name = "libjxl",
485  .item_name = av_default_item_name,
486  .option = libjxl_encode_options,
487  .version = LIBAVUTIL_VERSION_INT,
488 };
489 
490  const FFCodec ff_libjxl_encoder = {
491  .p.name = "libjxl",
492  CODEC_LONG_NAME("libjxl JPEG XL"),
493  .p.type = AVMEDIA_TYPE_VIDEO,
494  .p.id = AV_CODEC_ID_JPEGXL,
495  .priv_data_size = sizeof(LibJxlEncodeContext),
496  .init = libjxl_encode_init,
497  FF_CODEC_ENCODE_CB(libjxl_encode_frame),
498  .close = libjxl_encode_close,
499  .p.capabilities = AV_CODEC_CAP_OTHER_THREADS |
500  AV_CODEC_CAP_DR1 |
501  AV_CODEC_CAP_ENCODER_REORDERED_OPAQUE,
502  .caps_internal = FF_CODEC_CAP_NOT_INIT_THREADSAFE |
503  FF_CODEC_CAP_AUTO_THREADS | FF_CODEC_CAP_INIT_CLEANUP |
504  FF_CODEC_CAP_ICC_PROFILES,
505  .p.pix_fmts = (const enum AVPixelFormat[]) {
506  AV_PIX_FMT_RGB24, AV_PIX_FMT_RGBA,
507  AV_PIX_FMT_RGB48, AV_PIX_FMT_RGBA64,
508  AV_PIX_FMT_RGBF32, AV_PIX_FMT_RGBAF32,
509  AV_PIX_FMT_GRAY8, AV_PIX_FMT_YA8,
510  AV_PIX_FMT_GRAY16, AV_PIX_FMT_YA16,
511  AV_PIX_FMT_GRAYF32,
512  AV_PIX_FMT_NONE
513  },
514  .p.priv_class = &libjxl_encode_class,
515  .p.wrapper_name = "libjxl",
516 };
AVFrame::color_trc
enum AVColorTransferCharacteristic color_trc
Definition: frame.h:627
LibJxlEncodeContext::effort
int effort
Definition: libjxlenc.c:52
LibJxlEncodeContext::options
JxlEncoderFrameSettings * options
Definition: libjxlenc.c:51
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:186
AVFrame::color_range
enum AVColorRange color_range
MPEG vs JPEG YUV range.
Definition: frame.h:623
AVPixelFormat
AVPixelFormat
Pixel format.
Definition: pixfmt.h:71
LibJxlEncodeContext::buffer_size
size_t buffer_size
Definition: libjxlenc.c:57
ff_libjxl_get_threadcount
size_t ff_libjxl_get_threadcount(int threads)
Transform threadcount in ffmpeg to one used by libjxl.
Definition: libjxl.c:33
FF_CODEC_CAP_INIT_CLEANUP
#define FF_CODEC_CAP_INIT_CLEANUP
The codec allows calling the close function for deallocation even if the init function returned a fai...
Definition: codec_internal.h:42
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
opt.h
AV_PIX_FMT_YA8
@ AV_PIX_FMT_YA8
8 bits gray, 8 bits alpha
Definition: pixfmt.h:140
libm.h
av_frame_get_side_data
AVFrameSideData * av_frame_get_side_data(const AVFrame *frame, enum AVFrameSideDataType type)
Definition: frame.c:838
VE
#define VE
Definition: libjxlenc.c:471
AVColorPrimariesDesc
Struct that contains both white point location and primaries location, providing the complete descrip...
Definition: csp.h:78
av_pix_fmt_desc_get
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:2962
LibJxlEncodeContext::runner
void * runner
Definition: libjxlenc.c:49
AVCOL_TRC_LINEAR
@ AVCOL_TRC_LINEAR
"Linear transfer characteristics"
Definition: pixfmt.h:589
AV_CODEC_FLAG_QSCALE
#define AV_CODEC_FLAG_QSCALE
Use fixed qscale.
Definition: avcodec.h:224
AV_PIX_FMT_FLAG_FLOAT
#define AV_PIX_FMT_FLAG_FLOAT
The pixel format contains IEEE-754 floating point values.
Definition: pixdesc.h:158
AVFrame::color_primaries
enum AVColorPrimaries color_primaries
Definition: frame.h:625
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:344
pixdesc.h
AVCodecContext::color_trc
enum AVColorTransferCharacteristic color_trc
Color Transfer Characteristic.
Definition: avcodec.h:678
AVFrame::width
int width
Definition: frame.h:416
AVCOL_RANGE_JPEG
@ AVCOL_RANGE_JPEG
Full range content.
Definition: pixfmt.h:683
AVPacket::data
uint8_t * data
Definition: packet.h:522
AVOption
AVOption.
Definition: opt.h:346
encode.h
AVCOL_TRC_UNSPECIFIED
@ AVCOL_TRC_UNSPECIFIED
Definition: pixfmt.h:583
data
const char data[16]
Definition: mxf.c:148
FF_CODEC_CAP_NOT_INIT_THREADSAFE
#define FF_CODEC_CAP_NOT_INIT_THREADSAFE
The codec is not known to be init-threadsafe (i.e.
Definition: codec_internal.h:34
FFCodec
Definition: codec_internal.h:127
libjxl.h
av_get_bits_per_pixel
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:2914
AVColorPrimaries
AVColorPrimaries
Chromaticity coordinates of the source primaries.
Definition: pixfmt.h:555
quality
trying all byte sequences megabyte in length and selecting the best looking sequence will yield cases to try But a word about quality
Definition: rate_distortion.txt:12
AVFrame::data
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:365
FFCodec::p
AVCodec p
The public AVCodec.
Definition: codec_internal.h:131
AVCOL_TRC_IEC61966_2_1
@ AVCOL_TRC_IEC61966_2_1
IEC 61966-2-1 (sRGB or sYCC)
Definition: pixfmt.h:594
OFFSET
#define OFFSET(x)
Definition: libjxlenc.c:470
AVCodecContext::thread_count
int thread_count
thread count is used to decide how many independent tasks should be passed to execute()
Definition: avcodec.h:1582
AVCOL_TRC_GAMMA28
@ AVCOL_TRC_GAMMA28
also ITU-R BT470BG
Definition: pixfmt.h:586
AVCodecContext::flags
int flags
AV_CODEC_FLAG_*.
Definition: avcodec.h:502
LibJxlEncodeContext::xyb
int xyb
Definition: libjxlenc.c:55
AV_PIX_FMT_GRAY16
#define AV_PIX_FMT_GRAY16
Definition: pixfmt.h:462
FF_CODEC_ENCODE_CB
#define FF_CODEC_ENCODE_CB(func)
Definition: codec_internal.h:296
LibJxlEncodeContext::modular
int modular
Definition: libjxlenc.c:54
AVCOL_TRC_GAMMA22
@ AVCOL_TRC_GAMMA22
also ITU-R BT470M / ITU-R BT1700 625 PAL & SECAM
Definition: pixfmt.h:585
AVCodecContext::color_primaries
enum AVColorPrimaries color_primaries
Chromaticity coordinates of the source primaries.
Definition: avcodec.h:671
pkt
AVPacket * pkt
Definition: movenc.c:59
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:180
AVFrameSideData::size
size_t size
Definition: frame.h:253
av_cold
#define av_cold
Definition: attributes.h:90
AVCodecContext::global_quality
int global_quality
Global quality for codecs which cannot change it per frame.
Definition: avcodec.h:1239
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
av_q2d
static double av_q2d(AVRational a)
Convert an AVRational to a double.
Definition: rational.h:104
AV_CODEC_CAP_OTHER_THREADS
#define AV_CODEC_CAP_OTHER_THREADS
Codec supports multithreading through a method other than slice- or frame-level multithreading.
Definition: codec.h:124
info
MIPS optimizations info
Definition: mips.txt:2
AV_CODEC_CAP_ENCODER_REORDERED_OPAQUE
#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:159
AVCodecContext::bits_per_raw_sample
int bits_per_raw_sample
Bits per sample/pixel of internal libavcodec pixel/sample format.
Definition: avcodec.h:1574
ctx
AVFormatContext * ctx
Definition: movenc.c:48
AV_PIX_FMT_RGBF32
#define AV_PIX_FMT_RGBF32
Definition: pixfmt.h:548
AV_PIX_FMT_GRAYF32
#define AV_PIX_FMT_GRAYF32
Definition: pixfmt.h:511
AVCOL_PRI_UNSPECIFIED
@ AVCOL_PRI_UNSPECIFIED
Definition: pixfmt.h:558
CODEC_LONG_NAME
#define CODEC_LONG_NAME(str)
Definition: codec_internal.h:272
AV_PIX_FMT_RGBA
@ AV_PIX_FMT_RGBA
packed RGBA 8:8:8:8, 32bpp, RGBARGBA...
Definition: pixfmt.h:100
frame
static AVFrame * frame
Definition: demux_decode.c:54
AV_PIX_FMT_RGBA64
#define AV_PIX_FMT_RGBA64
Definition: pixfmt.h:468
LIBAVUTIL_VERSION_INT
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:66
NULL
#define NULL
Definition: coverity.c:32
AVCodecContext::color_range
enum AVColorRange color_range
MPEG vs JPEG YUV range.
Definition: avcodec.h:695
AVPixFmtDescriptor::nb_components
uint8_t nb_components
The number of components each pixel has, (1-4)
Definition: pixdesc.h:71
LibJxlEncodeContext::buffer
uint8_t * buffer
Definition: libjxlenc.c:56
AVCOL_PRI_BT709
@ AVCOL_PRI_BT709
also ITU-R BT1361 / IEC 61966-2-4 / SMPTE RP 177 Annex B
Definition: pixfmt.h:557
av_default_item_name
const char * av_default_item_name(void *ptr)
Return the context name.
Definition: log.c:237
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
libjxl_init_jxl_encoder
static int libjxl_init_jxl_encoder(AVCodecContext *avctx)
Initalize the encoder on a per-frame basis.
Definition: libjxlenc.c:95
AV_PIX_FMT_GRAY8
@ AV_PIX_FMT_GRAY8
Y , 8bpp.
Definition: pixfmt.h:81
AVPixFmtDescriptor::flags
uint64_t flags
Combination of AV_PIX_FMT_FLAG_...
Definition: pixdesc.h:94
AVCOL_RANGE_UNSPECIFIED
@ AVCOL_RANGE_UNSPECIFIED
Definition: pixfmt.h:649
LibJxlEncodeContext
Definition: libjxlenc.c:47
error.h
AVCOL_PRI_BT2020
@ AVCOL_PRI_BT2020
ITU-R BT2020.
Definition: pixfmt.h:566
AVCOL_TRC_SMPTE2084
@ AVCOL_TRC_SMPTE2084
SMPTE ST 2084 for 10-, 12-, 14- and 16-bit systems.
Definition: pixfmt.h:597
AVCOL_PRI_SMPTE431
@ AVCOL_PRI_SMPTE431
SMPTE ST 431-2 (2011) / DCI P3.
Definition: pixfmt.h:569
init
int(* init)(AVBSFContext *ctx)
Definition: dts2pts.c:365
AV_PIX_FMT_RGB24
@ AV_PIX_FMT_RGB24
packed RGB 8:8:8, 24bpp, RGBRGB...
Definition: pixfmt.h:75
AV_CODEC_CAP_DR1
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() or get_encode_buffer() for allocating buffers and supports custom allocators.
Definition: codec.h:52
codec_internal.h
libjxl_encode_frame
static int libjxl_encode_frame(AVCodecContext *avctx, AVPacket *pkt, const AVFrame *frame, int *got_packet)
Encode an entire frame.
Definition: libjxlenc.c:246
AV_PIX_FMT_RGB48
#define AV_PIX_FMT_RGB48
Definition: pixfmt.h:464
AVFrameSideData::data
uint8_t * data
Definition: frame.h:252
ff_libjxl_encoder
const FFCodec ff_libjxl_encoder
Definition: libjxlenc.c:490
AVFrame::format
int format
format of the frame, -1 if unknown or unset Values correspond to enum AVPixelFormat for video frames,...
Definition: frame.h:431
frame.h
csp.h
AVERROR_EXTERNAL
#define AVERROR_EXTERNAL
Generic error in an external library.
Definition: error.h:59
quality_to_distance
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:74
AVCOL_TRC_BT709
@ AVCOL_TRC_BT709
also ITU-R BT1361
Definition: pixfmt.h:582
AV_OPT_TYPE_FLOAT
@ AV_OPT_TYPE_FLOAT
Definition: opt.h:238
LibJxlEncodeContext::distance
float distance
Definition: libjxlenc.c:53
libjxl_populate_primaries
static int libjxl_populate_primaries(void *avctx, JxlColorEncoding *jxl_color, enum AVColorPrimaries prm)
Populate a JxlColorEncoding with the given enum AVColorPrimaries.
Definition: libjxlenc.c:194
AV_PIX_FMT_YA16
#define AV_PIX_FMT_YA16
Definition: pixfmt.h:463
libjxl_encode_init
static av_cold int libjxl_encode_init(AVCodecContext *avctx)
Global encoder initialization.
Definition: libjxlenc.c:161
available
if no frame is available
Definition: filter_design.txt:166
AV_CODEC_ID_JPEGXL
@ AV_CODEC_ID_JPEGXL
Definition: codec_id.h:313
libjxl_encode_close
static av_cold int libjxl_encode_close(AVCodecContext *avctx)
Definition: libjxlenc.c:449
AVCodec::name
const char * name
Name of the codec implementation.
Definition: codec.h:194
AVCOL_RANGE_MPEG
@ AVCOL_RANGE_MPEG
Narrow or limited range content.
Definition: pixfmt.h:666
FF_CODEC_CAP_ICC_PROFILES
#define FF_CODEC_CAP_ICC_PROFILES
Codec supports embedded ICC profiles (AV_FRAME_DATA_ICC_PROFILE).
Definition: codec_internal.h:82
libjxl_encode_class
static const AVClass libjxl_encode_class
Definition: libjxlenc.c:483
avcodec.h
version.h
ret
ret
Definition: filter_design.txt:187
pixfmt.h
AVClass::class_name
const char * class_name
The name of the class; usually it is the same name as the context structure type to which the AVClass...
Definition: log.h:71
AVCodecContext
main external API structure.
Definition: avcodec.h:445
AVFrame::height
int height
Definition: frame.h:416
AVCOL_TRC_ARIB_STD_B67
@ AVCOL_TRC_ARIB_STD_B67
ARIB STD-B67, known as "Hybrid log-gamma".
Definition: pixfmt.h:601
ff_get_encode_buffer
int ff_get_encode_buffer(AVCodecContext *avctx, AVPacket *avpkt, int64_t size, int flags)
Get a buffer for a packet.
Definition: encode.c:105
libjxl_encode_options
static const AVOption libjxl_encode_options[]
Definition: libjxlenc.c:473
AV_PIX_FMT_NONE
@ AV_PIX_FMT_NONE
Definition: pixfmt.h:72
AV_OPT_TYPE_INT
@ AV_OPT_TYPE_INT
Definition: opt.h:235
temp
else temp
Definition: vf_mcdeint.c:263
AV_PIX_FMT_RGBAF32
#define AV_PIX_FMT_RGBAF32
Definition: pixfmt.h:549
desc
const char * desc
Definition: libsvtav1.c:75
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
avutil.h
FF_CODEC_CAP_AUTO_THREADS
#define FF_CODEC_CAP_AUTO_THREADS
Codec handles avctx->thread_count == 0 (auto) internally.
Definition: codec_internal.h:73
AVFrameSideData
Structure to hold side data for an AVFrame.
Definition: frame.h:250
AVPixFmtDescriptor
Descriptor that unambiguously describes how the bits of a pixel are stored in the up to 4 data planes...
Definition: pixdesc.h:69
AVCOL_PRI_SMPTE432
@ AVCOL_PRI_SMPTE432
SMPTE ST 432-1 (2010) / P3 D65 / Display P3.
Definition: pixfmt.h:570
AVPacket
This structure stores compressed data.
Definition: packet.h:499
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:472
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:34
ff_libjxl_init_memory_manager
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
distance
static float distance(float x, float y, int band)
Definition: nellymoserenc.c:230
AVFrame::linesize
int linesize[AV_NUM_DATA_POINTERS]
For video, a positive or negative value, which is typically indicating the size in bytes of each pict...
Definition: frame.h:389
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
AVCOL_TRC_SMPTE428
@ AVCOL_TRC_SMPTE428
SMPTE ST 428-1.
Definition: pixfmt.h:599
LibJxlEncodeContext::encoder
JxlEncoder * encoder
Definition: libjxlenc.c:50
FF_QP2LAMBDA
#define FF_QP2LAMBDA
factor to convert from H.263 QP to lambda
Definition: avutil.h:227
av_realloc
void * av_realloc(void *ptr, size_t size)
Allocate, reallocate, or free a block of memory.
Definition: mem.c:153
Generated on Thu Sep 26 2024 23:15:02 for FFmpeg by   doxygen 1.8.17

AltStyle によって変換されたページ (->オリジナル) /