FFmpeg
jpeglsenc.c
Go to the documentation of this file.
1 /*
2  * JPEG-LS encoder
3  * Copyright (c) 2003 Michael Niedermayer
4  * Copyright (c) 2006 Konstantin Shishkov
5  *
6  * This file is part of FFmpeg.
7  *
8  * FFmpeg is free software; you can redistribute it and/or
9  * modify it under the terms of the GNU Lesser General Public
10  * License as published by the Free Software Foundation; either
11  * version 2.1 of the License, or (at your option) any later version.
12  *
13  * FFmpeg is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16  * Lesser General Public License for more details.
17  *
18  * You should have received a copy of the GNU Lesser General Public
19  * License along with FFmpeg; if not, write to the Free Software
20  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
21  */
22 
23 /**
24  * @file
25  * JPEG-LS encoder.
26  */
27 
28 #define UNCHECKED_BITSTREAM_READER 1
29 #include "libavutil/opt.h"
30 #include "avcodec.h"
31 #include "bytestream.h"
32 #include "encode.h"
33 #include "get_bits.h"
34 #include "put_bits.h"
35 #include "golomb.h"
36 #include "internal.h"
37 #include "mathops.h"
38 #include "mjpeg.h"
39 #include "jpegls.h"
40 
41 typedef struct JPEGLSContext {
42  AVClass *class;
43 
44  int pred;
45  int comps;
46 
47  size_t size;
48  uint8_t *buf;
50 
51 static inline void put_marker_byteu(PutByteContext *pb, enum JpegMarker code)
52 {
53  bytestream2_put_byteu(pb, 0xff);
54  bytestream2_put_byteu(pb, code);
55 }
56 
57 /**
58  * Encode error from regular symbol
59  */
60 static inline void ls_encode_regular(JLSState *state, PutBitContext *pb, int Q,
61  int err)
62 {
63  int k;
64  int val;
65  int map;
66 
67  for (k = 0; (state->N[Q] << k) < state->A[Q]; k++)
68  ;
69 
70  map = !state->near && !k && (2 * state->B[Q] <= -state->N[Q]);
71 
72  if (err < 0)
73  err += state->range;
74  if (err >= (state->range + 1 >> 1)) {
75  err -= state->range;
76  val = 2 * FFABS(err) - 1 - map;
77  } else
78  val = 2 * err + map;
79 
80  set_ur_golomb_jpegls(pb, val, k, state->limit, state->qbpp);
81 
83 }
84 
85 /**
86  * Encode error from run termination
87  */
88 static inline void ls_encode_runterm(JLSState *state, PutBitContext *pb,
89  int RItype, int err, int limit_add)
90 {
91  int k;
92  int val, map;
93  int Q = 365 + RItype;
94  int temp;
95 
96  temp = state->A[Q];
97  if (RItype)
98  temp += state->N[Q] >> 1;
99  for (k = 0; (state->N[Q] << k) < temp; k++)
100  ;
101  map = 0;
102  if (!k && err && (2 * state->B[Q] < state->N[Q]))
103  map = 1;
104 
105  if (err < 0)
106  val = -(2 * err) - 1 - RItype + map;
107  else
108  val = 2 * err - RItype - map;
109  set_ur_golomb_jpegls(pb, val, k, state->limit - limit_add - 1, state->qbpp);
110 
111  if (err < 0)
112  state->B[Q]++;
113  state->A[Q] += (val + 1 - RItype) >> 1;
114 
116 }
117 
118 /**
119  * Encode run value as specified by JPEG-LS standard
120  */
121 static inline void ls_encode_run(JLSState *state, PutBitContext *pb, int run,
122  int comp, int trail)
123 {
124  while (run >= (1 << ff_log2_run[state->run_index[comp]])) {
125  put_bits(pb, 1, 1);
126  run -= 1 << ff_log2_run[state->run_index[comp]];
127  if (state->run_index[comp] < 31)
128  state->run_index[comp]++;
129  }
130  /* if hit EOL, encode another full run, else encode aborted run */
131  if (!trail && run) {
132  put_bits(pb, 1, 1);
133  } else if (trail) {
134  put_bits(pb, 1, 0);
135  if (ff_log2_run[state->run_index[comp]])
136  put_bits(pb, ff_log2_run[state->run_index[comp]], run);
137  }
138 }
139 
140 /**
141  * Encode one line of image
142  */
143 static inline void ls_encode_line(JLSState *state, PutBitContext *pb,
144  void *tmp, const void *in, int last2, int w,
145  int stride, int comp, int bits)
146 {
147  int x = 0;
148  int Ra = R(tmp, 0), Rb, Rc = last2, Rd;
149  int D0, D1, D2;
150 
151  while (x < w) {
152  int err, pred, sign;
153 
154  /* compute gradients */
155  Rb = R(tmp, x);
156  Rd = (x >= w - stride) ? R(tmp, x) : R(tmp, x + stride);
157  D0 = Rd - Rb;
158  D1 = Rb - Rc;
159  D2 = Rc - Ra;
160 
161  /* run mode */
162  if ((FFABS(D0) <= state->near) &&
163  (FFABS(D1) <= state->near) &&
164  (FFABS(D2) <= state->near)) {
165  int RUNval, RItype, run;
166 
167  run = 0;
168  RUNval = Ra;
169  while (x < w && (FFABS(R(in, x) - RUNval) <= state->near)) {
170  run++;
171  W(tmp, x, Ra);
172  x += stride;
173  }
174  ls_encode_run(state, pb, run, comp, x < w);
175  if (x >= w)
176  return;
177  Rb = R(tmp, x);
178  RItype = FFABS(Ra - Rb) <= state->near;
179  pred = RItype ? Ra : Rb;
180  err = R(in, x) - pred;
181 
182  if (!RItype && Ra > Rb)
183  err = -err;
184 
185  if (state->near) {
186  if (err > 0)
187  err = (state->near + err) / state->twonear;
188  else
189  err = -(state->near - err) / state->twonear;
190 
191  if (RItype || (Rb >= Ra))
192  Ra = av_clip(pred + err * state->twonear, 0, state->maxval);
193  else
194  Ra = av_clip(pred - err * state->twonear, 0, state->maxval);
195  } else
196  Ra = R(in, x);
197  W(tmp, x, Ra);
198 
199  if (err < 0)
200  err += state->range;
201  if (err >= state->range + 1 >> 1)
202  err -= state->range;
203 
204  ls_encode_runterm(state, pb, RItype, err,
205  ff_log2_run[state->run_index[comp]]);
206 
207  if (state->run_index[comp] > 0)
208  state->run_index[comp]--;
209  } else { /* regular mode */
210  int context;
211 
212  context = ff_jpegls_quantize(state, D0) * 81 +
213  ff_jpegls_quantize(state, D1) * 9 +
215  pred = mid_pred(Ra, Ra + Rb - Rc, Rb);
216 
217  if (context < 0) {
218  context = -context;
219  sign = 1;
220  pred = av_clip(pred - state->C[context], 0, state->maxval);
221  err = pred - R(in, x);
222  } else {
223  sign = 0;
224  pred = av_clip(pred + state->C[context], 0, state->maxval);
225  err = R(in, x) - pred;
226  }
227 
228  if (state->near) {
229  if (err > 0)
230  err = (state->near + err) / state->twonear;
231  else
232  err = -(state->near - err) / state->twonear;
233  if (!sign)
234  Ra = av_clip(pred + err * state->twonear, 0, state->maxval);
235  else
236  Ra = av_clip(pred - err * state->twonear, 0, state->maxval);
237  } else
238  Ra = R(in, x);
239  W(tmp, x, Ra);
240 
241  ls_encode_regular(state, pb, context, err);
242  }
243  Rc = Rb;
244  x += stride;
245  }
246 }
247 
249 {
250  /* Test if we have default params and don't need to store LSE */
251  JLSState state2 = { 0 };
252  state2.bpp = state->bpp;
253  state2.near = state->near;
255  if (state->T1 == state2.T1 &&
256  state->T2 == state2.T2 &&
257  state->T3 == state2.T3 &&
258  state->reset == state2.reset)
259  return;
260  /* store LSE type 1 */
261  put_marker_byteu(pb, LSE);
262  bytestream2_put_be16u(pb, 13);
263  bytestream2_put_byteu(pb, 1);
264  bytestream2_put_be16u(pb, state->maxval);
265  bytestream2_put_be16u(pb, state->T1);
266  bytestream2_put_be16u(pb, state->T2);
267  bytestream2_put_be16u(pb, state->T3);
268  bytestream2_put_be16u(pb, state->reset);
269 }
270 
272  const AVFrame *pict, int *got_packet)
273 {
274  JPEGLSContext *ctx = avctx->priv_data;
275  const AVFrame *const p = pict;
276  PutByteContext pb;
277  PutBitContext pb2;
278  GetBitContext gb;
279  const uint8_t *in;
280  uint8_t *last = NULL;
281  JLSState state = { 0 };
282  size_t size;
283  int i, ret, size_in_bits;
284  int comps;
285 
286  last = av_mallocz(FFABS(p->linesize[0]));
287  if (!last)
288  return AVERROR(ENOMEM);
289 
290  init_put_bits(&pb2, ctx->buf, ctx->size);
291 
292  comps = ctx->comps;
293  /* initialize JPEG-LS state from JPEG parameters */
294  state.near = ctx->pred;
295  state.bpp = (avctx->pix_fmt == AV_PIX_FMT_GRAY16) ? 16 : 8;
298 
299  in = p->data[0];
300  if (avctx->pix_fmt == AV_PIX_FMT_GRAY8) {
301  int t = 0;
302 
303  for (i = 0; i < avctx->height; i++) {
304  int last0 = last[0];
305  ls_encode_line(&state, &pb2, last, in, t, avctx->width, 1, 0, 8);
306  t = last0;
307  in += p->linesize[0];
308  }
309  } else if (avctx->pix_fmt == AV_PIX_FMT_GRAY16) {
310  int t = 0;
311 
312  for (i = 0; i < avctx->height; i++) {
313  int last0 = *((uint16_t *)last);
314  ls_encode_line(&state, &pb2, last, in, t, avctx->width, 1, 0, 16);
315  t = last0;
316  in += p->linesize[0];
317  }
318  } else if (avctx->pix_fmt == AV_PIX_FMT_RGB24) {
319  int j, width;
320  int Rc[3] = { 0, 0, 0 };
321 
322  width = avctx->width * 3;
323  for (i = 0; i < avctx->height; i++) {
324  for (j = 0; j < 3; j++) {
325  int last0 = last[j];
326  ls_encode_line(&state, &pb2, last + j, in + j, Rc[j],
327  width, 3, j, 8);
328  Rc[j] = last0;
329  }
330  in += p->linesize[0];
331  }
332  } else if (avctx->pix_fmt == AV_PIX_FMT_BGR24) {
333  int j, width;
334  int Rc[3] = { 0, 0, 0 };
335 
336  width = avctx->width * 3;
337  for (i = 0; i < avctx->height; i++) {
338  for (j = 2; j >= 0; j--) {
339  int last0 = last[j];
340  ls_encode_line(&state, &pb2, last + j, in + j, Rc[j],
341  width, 3, j, 8);
342  Rc[j] = last0;
343  }
344  in += p->linesize[0];
345  }
346  }
347  av_free(last);
348  /* Now the actual image data has been written, which enables us to estimate
349  * the needed packet size: For every 15 input bits, an escape bit might be
350  * added below; and if put_bits_count % 15 is >= 8, then another bit might
351  * be added.
352  * Furthermore the specification says that after doing 0xff escaping unused
353  * bits in the last byte must be set to 0, so just append 7 "optional" zero
354  * bits to avoid special-casing. This also simplifies the size calculation:
355  * Properly rounding up is now automatically baked-in. */
356  put_bits(&pb2, 7, 0);
357  /* Make sure that the bit count + padding is representable in an int;
358  necessary for put_bits_count() as well as for using a GetBitContext. */
359  if (put_bytes_count(&pb2, 0) > INT_MAX / 8 - AV_INPUT_BUFFER_PADDING_SIZE)
360  return AVERROR(ERANGE);
361  size_in_bits = put_bits_count(&pb2);
362  flush_put_bits(&pb2);
363  size = size_in_bits * 2U / 15;
364  size += 2 + 2 + 2 + 1 + 2 + 2 + 1 + comps * (1 + 1 + 1) + 2 + 2 + 1
365  + comps * (1 + 1) + 1 + 1 + 1; /* Header */
366  size += 2 + 2 + 1 + 2 + 2 + 2 + 2 + 2; /* LSE */
367  size += 2; /* EOI */
368  if ((ret = ff_get_encode_buffer(avctx, pkt, size, 0)) < 0)
369  return ret;
370 
372 
373  /* write our own JPEG header, can't use mjpeg_picture_header */
374  put_marker_byteu(&pb, SOI);
375  put_marker_byteu(&pb, SOF48);
376  bytestream2_put_be16u(&pb, 8 + comps * 3); // header size depends on components
377  bytestream2_put_byteu(&pb, (avctx->pix_fmt == AV_PIX_FMT_GRAY16) ? 16 : 8); // bpp
378  bytestream2_put_be16u(&pb, avctx->height);
379  bytestream2_put_be16u(&pb, avctx->width);
380  bytestream2_put_byteu(&pb, comps); // components
381  for (i = 1; i <= comps; i++) {
382  bytestream2_put_byteu(&pb, i); // component ID
383  bytestream2_put_byteu(&pb, 0x11); // subsampling: none
384  bytestream2_put_byteu(&pb, 0); // Tiq, used by JPEG-LS ext
385  }
386 
387  put_marker_byteu(&pb, SOS);
388  bytestream2_put_be16u(&pb, 6 + comps * 2);
389  bytestream2_put_byteu(&pb, comps);
390  for (i = 1; i <= comps; i++) {
391  bytestream2_put_byteu(&pb, i); // component ID
392  bytestream2_put_byteu(&pb, 0); // mapping index: none
393  }
394  bytestream2_put_byteu(&pb, ctx->pred);
395  bytestream2_put_byteu(&pb, (comps > 1) ? 1 : 0); // interleaving: 0 - plane, 1 - line
396  bytestream2_put_byteu(&pb, 0); // point transform: none
397 
398  ls_store_lse(&state, &pb);
399 
400  /* do escape coding */
401  init_get_bits(&gb, pb2.buf, size_in_bits);
402  size_in_bits -= 7;
403  while (get_bits_count(&gb) < size_in_bits) {
404  int v;
405  v = get_bits(&gb, 8);
406  bytestream2_put_byteu(&pb, v);
407  if (v == 0xFF) {
408  v = get_bits(&gb, 7);
409  bytestream2_put_byteu(&pb, v);
410  }
411  }
412 
413  /* End of image */
414  put_marker_byteu(&pb, EOI);
415 
416  emms_c();
417 
419  *got_packet = 1;
420  return 0;
421 }
422 
424 {
425  JPEGLSContext *ctx = avctx->priv_data;
426  size_t size;
427 
428  if ((avctx->width | avctx->height) > UINT16_MAX) {
429  av_log(avctx, AV_LOG_ERROR, "Dimensions exceeding 65535x65535\n");
430  return AVERROR(EINVAL);
431  }
432  if (avctx->pix_fmt == AV_PIX_FMT_GRAY8 ||
433  avctx->pix_fmt == AV_PIX_FMT_GRAY16)
434  ctx->comps = 1;
435  else
436  ctx->comps = 3;
438  /* INT_MAX due to PutBit-API. */
439  if (avctx->width * (unsigned)avctx->height > (INT_MAX - size) / 4 / ctx->comps)
440  return AVERROR(ERANGE);
441  size += 4 * ctx->comps * avctx->width * avctx->height;
442  ctx->size = size;
444  if (!ctx->buf)
445  return AVERROR(ENOMEM);
446 
447  return 0;
448 }
449 
451 {
452  JPEGLSContext *ctx = avctx->priv_data;
453 
454  av_freep(&ctx->buf);
455  return 0;
456 }
457 
458 #define OFFSET(x) offsetof(JPEGLSContext, x)
459 #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
460 static const AVOption options[] = {
461 { "pred", "Prediction method", OFFSET(pred), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 2, VE, "pred" },
462  { "left", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = 0 }, INT_MIN, INT_MAX, VE, "pred" },
463  { "plane", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = 1 }, INT_MIN, INT_MAX, VE, "pred" },
464  { "median", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = 2 }, INT_MIN, INT_MAX, VE, "pred" },
465 
466  { NULL},
467 };
468 
469 static const AVClass jpegls_class = {
470  .class_name = "jpegls",
471  .item_name = av_default_item_name,
472  .option = options,
473  .version = LIBAVUTIL_VERSION_INT,
474 };
475 
477  .name = "jpegls",
478  .long_name = NULL_IF_CONFIG_SMALL("JPEG-LS"),
479  .type = AVMEDIA_TYPE_VIDEO,
480  .id = AV_CODEC_ID_JPEGLS,
482  .priv_data_size = sizeof(JPEGLSContext),
483  .priv_class = &jpegls_class,
485  .encode2 = encode_picture_ls,
486  .close = encode_jpegls_close,
487  .pix_fmts = (const enum AVPixelFormat[]) {
491  },
492  .caps_internal = FF_CODEC_CAP_INIT_THREADSAFE |
494 };
JLSState::bpp
int bpp
Definition: jpegls.h:39
AVCodec
AVCodec.
Definition: codec.h:202
stride
int stride
Definition: mace.c:144
FF_CODEC_CAP_INIT_THREADSAFE
#define FF_CODEC_CAP_INIT_THREADSAFE
The codec does not modify any global variables in the init function, allowing to call the init functi...
Definition: internal.h:42
AVPixelFormat
AVPixelFormat
Pixel format.
Definition: pixfmt.h:64
mjpeg.h
av_clip
#define av_clip
Definition: common.h:96
init
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:31
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
encode_jpegls_close
static av_cold int encode_jpegls_close(AVCodecContext *avctx)
Definition: jpeglsenc.c:450
opt.h
SOS
@ SOS
Definition: mjpeg.h:72
SOF48
@ SOF48
JPEG-LS.
Definition: mjpeg.h:103
comp
static void comp(unsigned char *dst, ptrdiff_t dst_stride, unsigned char *src, ptrdiff_t src_stride, int add)
Definition: eamad.c:85
init_put_bits
static void init_put_bits(PutBitContext *s, uint8_t *buffer, int buffer_size)
Initialize the PutBitContext s.
Definition: put_bits.h:61
get_bits_count
static int get_bits_count(const GetBitContext *s)
Definition: get_bits.h:220
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:303
tmp
static uint8_t tmp[11]
Definition: aes_ctr.c:26
put_bits
static void put_bits(Jpeg2000EncoderContext *s, int val, int n)
put n times val bit
Definition: j2kenc.c:220
w
uint8_t w
Definition: llviddspenc.c:38
JLSState::T1
int T1
Definition: jpegls.h:37
R
#define R
Definition: huffyuvdsp.h:34
internal.h
AVPacket::data
uint8_t * data
Definition: packet.h:373
AVOption
AVOption.
Definition: opt.h:247
W
@ W
Definition: vf_addroi.c:26
encode.h
put_bytes_count
static int put_bytes_count(const PutBitContext *s, int round_up)
Definition: put_bits.h:99
ls_encode_run
static void ls_encode_run(JLSState *state, PutBitContext *pb, int run, int comp, int trail)
Encode run value as specified by JPEG-LS standard.
Definition: jpeglsenc.c:121
bytestream2_tell_p
static av_always_inline int bytestream2_tell_p(PutByteContext *p)
Definition: bytestream.h:197
JPEGLSContext
Definition: jpeglsenc.c:41
AV_PIX_FMT_BGR24
@ AV_PIX_FMT_BGR24
packed RGB 8:8:8, 24bpp, BGRBGR...
Definition: pixfmt.h:69
encode_jpegls_init
static av_cold int encode_jpegls_init(AVCodecContext *avctx)
Definition: jpeglsenc.c:423
JLSState::T2
int T2
Definition: jpegls.h:37
JpegMarker
JpegMarker
Definition: mjpeg.h:37
init_get_bits
static int init_get_bits(GetBitContext *s, const uint8_t *buffer, int bit_size)
Initialize GetBitContext.
Definition: get_bits.h:660
AVFrame::data
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:317
av_malloc
#define av_malloc(s)
Definition: tableprint_vlc.h:31
state
static struct @319 state
golomb.h
exp golomb vlc stuff
get_bits
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:380
U
#define U(x)
Definition: vp56_arith.h:37
av_shrink_packet
void av_shrink_packet(AVPacket *pkt, int size)
Reduce packet size, correctly zeroing padding.
Definition: avpacket.c:114
GetBitContext
Definition: get_bits.h:62
val
static double val(void *priv, double ch)
Definition: aeval.c:76
AV_PIX_FMT_GRAY16
#define AV_PIX_FMT_GRAY16
Definition: pixfmt.h:375
JLSState
Definition: jpegls.h:36
jpegls.h
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
av_cold
#define av_cold
Definition: attributes.h:90
JPEGLSContext::buf
uint8_t * buf
Definition: jpeglsenc.c:48
bytestream2_init_writer
static av_always_inline void bytestream2_init_writer(PutByteContext *p, uint8_t *buf, int buf_size)
Definition: bytestream.h:147
width
#define width
VE
#define VE
Definition: jpeglsenc.c:459
bits
uint8_t bits
Definition: vp3data.h:141
pix_fmts
static enum AVPixelFormat pix_fmts[]
Definition: libkvazaar.c:290
ctx
AVFormatContext * ctx
Definition: movenc.c:48
get_bits.h
AV_INPUT_BUFFER_MIN_SIZE
#define AV_INPUT_BUFFER_MIN_SIZE
Definition: avcodec.h:185
set_ur_golomb_jpegls
static void set_ur_golomb_jpegls(PutBitContext *pb, int i, int k, int limit, int esc_len)
write unsigned golomb rice code (jpegls).
Definition: golomb.h:695
PutBitContext
Definition: put_bits.h:49
FFABS
#define FFABS(a)
Absolute value, Note, INT_MIN / INT64_MIN result in undefined behavior as they are not representable ...
Definition: common.h:65
JLSState::near
int near
Definition: jpegls.h:40
ls_encode_line
static void ls_encode_line(JLSState *state, PutBitContext *pb, void *tmp, const void *in, int last2, int w, int stride, int comp, int bits)
Encode one line of image.
Definition: jpeglsenc.c:143
context
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf default minimum maximum flags name is the option keep it simple and lowercase description are in without and describe what they for example set the foo of the bar offset is the offset of the field in your context
Definition: writing_filters.txt:91
AV_CODEC_CAP_FRAME_THREADS
#define AV_CODEC_CAP_FRAME_THREADS
Codec supports frame-level multithreading.
Definition: codec.h:113
ff_jpegls_downscale_state
static void ff_jpegls_downscale_state(JLSState *state, int Q)
Definition: jpegls.h:84
LIBAVUTIL_VERSION_INT
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:66
PutBitContext::buf
uint8_t * buf
Definition: put_bits.h:52
NULL
#define NULL
Definition: coverity.c:32
ff_log2_run
const uint8_t ff_log2_run[41]
Definition: bitstream.c:50
run
uint8_t run
Definition: svq3.c:203
put_marker_byteu
static void put_marker_byteu(PutByteContext *pb, enum JpegMarker code)
Definition: jpeglsenc.c:51
av_default_item_name
const char * av_default_item_name(void *ptr)
Return the context name.
Definition: log.c:235
mathops.h
OFFSET
#define OFFSET(x)
Definition: jpeglsenc.c:458
AV_PIX_FMT_GRAY8
@ AV_PIX_FMT_GRAY8
Y , 8bpp.
Definition: pixfmt.h:74
JPEGLSContext::comps
int comps
Definition: jpeglsenc.c:45
JPEGLSContext::pred
int pred
Definition: jpeglsenc.c:44
JLSState::T3
int T3
Definition: jpegls.h:37
PutByteContext
Definition: bytestream.h:37
AV_PIX_FMT_RGB24
@ AV_PIX_FMT_RGB24
packed RGB 8:8:8, 24bpp, RGBRGB...
Definition: pixfmt.h:68
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
AVPacket::size
int size
Definition: packet.h:374
NULL_IF_CONFIG_SMALL
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
Definition: internal.h:117
size
int size
Definition: twinvq_data.h:10344
JLSState::reset
int reset
Definition: jpegls.h:39
ff_jpegls_quantize
static int ff_jpegls_quantize(JLSState *s, int v)
Calculate quantized gradient value, used for context determination.
Definition: jpegls.h:52
ff_jpegls_encoder
const AVCodec ff_jpegls_encoder
Definition: jpeglsenc.c:476
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:271
code
and forward the test the status of outputs and forward it to the corresponding return FFERROR_NOT_READY If the filters stores internally one or a few frame for some it can consider them to be part of the FIFO and delay acknowledging a status change accordingly Example code
Definition: filter_design.txt:178
ff_jpegls_init_state
void ff_jpegls_init_state(JLSState *state)
Calculate initial JPEG-LS parameters.
Definition: jpegls.c:33
put_bits_count
static int put_bits_count(PutBitContext *s)
Definition: put_bits.h:79
EOI
@ EOI
Definition: mjpeg.h:71
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: internal.h:50
ff_jpegls_update_state_regular
static int ff_jpegls_update_state_regular(JLSState *state, int Q, int err)
Definition: jpegls.h:94
av_mallocz
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
Definition: mem.c:263
AVCodec::name
const char * name
Name of the codec implementation.
Definition: codec.h:209
AVCodecContext::height
int height
Definition: avcodec.h:556
AVCodecContext::pix_fmt
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:593
ls_encode_regular
static void ls_encode_regular(JLSState *state, PutBitContext *pb, int Q, int err)
Encode error from regular symbol.
Definition: jpeglsenc.c:60
avcodec.h
options
static const AVOption options[]
Definition: jpeglsenc.c:460
mid_pred
#define mid_pred
Definition: mathops.h:97
ret
ret
Definition: filter_design.txt:187
pred
static const float pred[4]
Definition: siprdata.h:259
ls_encode_runterm
static void ls_encode_runterm(JLSState *state, PutBitContext *pb, int RItype, int err, int limit_add)
Encode error from run termination.
Definition: jpeglsenc.c:88
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
LSE
@ LSE
JPEG-LS extension parameters.
Definition: mjpeg.h:104
ff_jpegls_reset_coding_parameters
void ff_jpegls_reset_coding_parameters(JLSState *s, int reset_all)
Calculate JPEG-LS codec values.
Definition: jpegls.c:64
AV_INPUT_BUFFER_PADDING_SIZE
#define AV_INPUT_BUFFER_PADDING_SIZE
Definition: defs.h:40
AVCodecContext
main external API structure.
Definition: avcodec.h:383
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:78
AV_PIX_FMT_NONE
@ AV_PIX_FMT_NONE
Definition: pixfmt.h:65
AV_CODEC_ID_JPEGLS
@ AV_CODEC_ID_JPEGLS
Definition: codec_id.h:61
AV_OPT_TYPE_INT
@ AV_OPT_TYPE_INT
Definition: opt.h:224
temp
else temp
Definition: vf_mcdeint.c:248
ls_store_lse
static void ls_store_lse(JLSState *state, PutByteContext *pb)
Definition: jpeglsenc.c:248
encode_picture_ls
static int encode_picture_ls(AVCodecContext *avctx, AVPacket *pkt, const AVFrame *pict, int *got_packet)
Definition: jpeglsenc.c:271
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
jpegls_class
static const AVClass jpegls_class
Definition: jpeglsenc.c:469
SOI
@ SOI
Definition: mjpeg.h:70
flush_put_bits
static void flush_put_bits(PutBitContext *s)
Pad the end of the output stream with zeros.
Definition: put_bits.h:142
map
const VDPAUPixFmtMap * map
Definition: hwcontext_vdpau.c:71
av_free
#define av_free(p)
Definition: tableprint_vlc.h:34
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:410
AVPacket
This structure stores compressed data.
Definition: packet.h:350
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:35
AVCodecContext::width
int width
picture width / height.
Definition: avcodec.h:556
bytestream.h
AVFrame::linesize
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
Definition: frame.h:334
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:28
put_bits.h
AV_OPT_TYPE_CONST
@ AV_OPT_TYPE_CONST
Definition: opt.h:233
JPEGLSContext::size
size_t size
Definition: jpeglsenc.c:47