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 #include "avcodec.h"
29 #include "bytestream.h"
30 #include "get_bits.h"
31 #include "put_bits.h"
32 #include "golomb.h"
33 #include "internal.h"
34 #include "mathops.h"
35 #include "mjpeg.h"
36 #include "mjpegenc.h"
37 #include "jpegls.h"
38 
39 typedef struct JPEGLSContext {
40  AVClass *class;
41 
42  int pred;
44 
45 static inline void put_marker_byteu(PutByteContext *pb, enum JpegMarker code)
46 {
47  bytestream2_put_byteu(pb, 0xff);
48  bytestream2_put_byteu(pb, code);
49 }
50 
51 static inline void put_marker_byte(PutByteContext *pb, enum JpegMarker code)
52 {
53  bytestream2_put_byte(pb, 0xff);
54  bytestream2_put_byte(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  int i, size, ret;
283  int comps;
284 
285  if (avctx->pix_fmt == AV_PIX_FMT_GRAY8 ||
286  avctx->pix_fmt == AV_PIX_FMT_GRAY16)
287  comps = 1;
288  else
289  comps = 3;
290 
291  if ((ret = ff_alloc_packet2(avctx, pkt, avctx->width *avctx->height * comps * 4 +
292  AV_INPUT_BUFFER_MIN_SIZE, 0)) < 0)
293  return ret;
294 
295  last = av_malloc((unsigned)pkt->size + FFABS(p->linesize[0]));
296  if (!last)
297  return AVERROR(ENOMEM);
298  memset(last, 0, FFABS(p->linesize[0]));
299 
301  init_put_bits(&pb2, last + FFABS(p->linesize[0]), pkt->size);
302 
303  /* write our own JPEG header, can't use mjpeg_picture_header */
304  put_marker_byteu(&pb, SOI);
305  put_marker_byteu(&pb, SOF48);
306  bytestream2_put_be16u(&pb, 8 + comps * 3); // header size depends on components
307  bytestream2_put_byteu(&pb, (avctx->pix_fmt == AV_PIX_FMT_GRAY16) ? 16 : 8); // bpp
308  bytestream2_put_be16u(&pb, avctx->height);
309  bytestream2_put_be16u(&pb, avctx->width);
310  bytestream2_put_byteu(&pb, comps); // components
311  for (i = 1; i <= comps; i++) {
312  bytestream2_put_byteu(&pb, i); // component ID
313  bytestream2_put_byteu(&pb, 0x11); // subsampling: none
314  bytestream2_put_byteu(&pb, 0); // Tiq, used by JPEG-LS ext
315  }
316 
317  put_marker_byteu(&pb, SOS);
318  bytestream2_put_be16u(&pb, 6 + comps * 2);
319  bytestream2_put_byteu(&pb, comps);
320  for (i = 1; i <= comps; i++) {
321  bytestream2_put_byteu(&pb, i); // component ID
322  bytestream2_put_byteu(&pb, 0); // mapping index: none
323  }
324  bytestream2_put_byteu(&pb, ctx->pred);
325  bytestream2_put_byteu(&pb, (comps > 1) ? 1 : 0); // interleaving: 0 - plane, 1 - line
326  bytestream2_put_byteu(&pb, 0); // point transform: none
327 
328  /* initialize JPEG-LS state from JPEG parameters */
329  state.near = ctx->pred;
330  state.bpp = (avctx->pix_fmt == AV_PIX_FMT_GRAY16) ? 16 : 8;
333 
334  ls_store_lse(&state, &pb);
335 
336  in = p->data[0];
337  if (avctx->pix_fmt == AV_PIX_FMT_GRAY8) {
338  int t = 0;
339 
340  for (i = 0; i < avctx->height; i++) {
341  int last0 = last[0];
342  ls_encode_line(&state, &pb2, last, in, t, avctx->width, 1, 0, 8);
343  t = last0;
344  in += p->linesize[0];
345  }
346  } else if (avctx->pix_fmt == AV_PIX_FMT_GRAY16) {
347  int t = 0;
348 
349  for (i = 0; i < avctx->height; i++) {
350  int last0 = *((uint16_t *)last);
351  ls_encode_line(&state, &pb2, last, in, t, avctx->width, 1, 0, 16);
352  t = last0;
353  in += p->linesize[0];
354  }
355  } else if (avctx->pix_fmt == AV_PIX_FMT_RGB24) {
356  int j, width;
357  int Rc[3] = { 0, 0, 0 };
358 
359  width = avctx->width * 3;
360  for (i = 0; i < avctx->height; i++) {
361  for (j = 0; j < 3; j++) {
362  int last0 = last[j];
363  ls_encode_line(&state, &pb2, last + j, in + j, Rc[j],
364  width, 3, j, 8);
365  Rc[j] = last0;
366  }
367  in += p->linesize[0];
368  }
369  } else if (avctx->pix_fmt == AV_PIX_FMT_BGR24) {
370  int j, width;
371  int Rc[3] = { 0, 0, 0 };
372 
373  width = avctx->width * 3;
374  for (i = 0; i < avctx->height; i++) {
375  for (j = 2; j >= 0; j--) {
376  int last0 = last[j];
377  ls_encode_line(&state, &pb2, last + j, in + j, Rc[j],
378  width, 3, j, 8);
379  Rc[j] = last0;
380  }
381  in += p->linesize[0];
382  }
383  }
384 
385  /* the specification says that after doing 0xff escaping unused bits in
386  * the last byte must be set to 0, so just append 7 "optional" zero bits
387  * to avoid special-casing. */
388  put_bits(&pb2, 7, 0);
389  size = put_bits_count(&pb2);
390  flush_put_bits(&pb2);
391  /* do escape coding */
392  init_get_bits(&gb, pb2.buf, size);
393  size -= 7;
394  while (get_bits_count(&gb) < size) {
395  int v;
396  v = get_bits(&gb, 8);
397  bytestream2_put_byte(&pb, v);
398  if (v == 0xFF) {
399  v = get_bits(&gb, 7);
400  bytestream2_put_byte(&pb, v);
401  }
402  }
403  av_freep(&last);
404 
405  /* End of image */
406  put_marker_byte(&pb, EOI);
407 
408  emms_c();
409 
410  pkt->size = bytestream2_tell_p(&pb);
412  *got_packet = 1;
413  return 0;
414 }
415 
416 #define OFFSET(x) offsetof(JPEGLSContext, x)
417 #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
418 static const AVOption options[] = {
419 { "pred", "Prediction method", OFFSET(pred), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 2, VE, "pred" },
420  { "left", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = 0 }, INT_MIN, INT_MAX, VE, "pred" },
421  { "plane", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = 1 }, INT_MIN, INT_MAX, VE, "pred" },
422  { "median", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = 2 }, INT_MIN, INT_MAX, VE, "pred" },
423 
424  { NULL},
425 };
426 
427 static const AVClass jpegls_class = {
428  .class_name = "jpegls",
429  .item_name = av_default_item_name,
430  .option = options,
431  .version = LIBAVUTIL_VERSION_INT,
432 };
433 
435  .name = "jpegls",
436  .long_name = NULL_IF_CONFIG_SMALL("JPEG-LS"),
437  .type = AVMEDIA_TYPE_VIDEO,
438  .id = AV_CODEC_ID_JPEGLS,
439  .priv_data_size = sizeof(JPEGLSContext),
440  .priv_class = &jpegls_class,
441  .capabilities = AV_CODEC_CAP_FRAME_THREADS,
442  .encode2 = encode_picture_ls,
443  .pix_fmts = (const enum AVPixelFormat[]) {
447  },
448  .caps_internal = FF_CODEC_CAP_INIT_THREADSAFE |
450 };
JLSState::bpp
int bpp
Definition: jpegls.h:40
AVCodec
AVCodec.
Definition: codec.h:197
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:41
AVPixelFormat
AVPixelFormat
Pixel format.
Definition: pixfmt.h:64
mjpeg.h
W
@ W
Definition: vf_addroi.c:26
av_clip
#define av_clip
Definition: common.h:122
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
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:219
state
static struct @321 state
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:303
tmp
static uint8_t tmp[11]
Definition: aes_ctr.c:27
put_bits
static void put_bits(Jpeg2000EncoderContext *s, int val, int n)
put n times val bit
Definition: j2kenc.c:218
w
uint8_t w
Definition: llviddspenc.c:39
JLSState::T1
int T1
Definition: jpegls.h:38
R
#define R
Definition: huffyuvdsp.h:34
internal.h
AVPacket::data
uint8_t * data
Definition: packet.h:365
AVOption
AVOption.
Definition: opt.h:248
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:39
AV_PIX_FMT_BGR24
@ AV_PIX_FMT_BGR24
packed RGB 8:8:8, 24bpp, BGRBGR...
Definition: pixfmt.h:69
JLSState::T2
int T2
Definition: jpegls.h:38
JpegMarker
JpegMarker
Definition: mjpeg.h:37
AV_PKT_FLAG_KEY
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
Definition: packet.h:396
init_get_bits
static int init_get_bits(GetBitContext *s, const uint8_t *buffer, int bit_size)
Initialize GetBitContext.
Definition: get_bits.h:659
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
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:379
GetBitContext
Definition: get_bits.h:61
val
static double val(void *priv, double ch)
Definition: aeval.c:76
AV_PIX_FMT_GRAY16
#define AV_PIX_FMT_GRAY16
Definition: pixfmt.h:373
JLSState
Definition: jpegls.h:37
jpegls.h
pkt
AVPacket * pkt
Definition: movenc.c:59
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:417
bits
uint8_t bits
Definition: vp3data.h:141
pix_fmts
static enum AVPixelFormat pix_fmts[]
Definition: libkvazaar.c:289
ctx
AVFormatContext * ctx
Definition: movenc.c:48
get_bits.h
AV_INPUT_BUFFER_MIN_SIZE
#define AV_INPUT_BUFFER_MIN_SIZE
Definition: avcodec.h:199
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:72
JLSState::near
int near
Definition: jpegls.h:41
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:108
ff_jpegls_downscale_state
static void ff_jpegls_downscale_state(JLSState *state, int Q)
Definition: jpegls.h:85
LIBAVUTIL_VERSION_INT
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:67
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:39
run
uint8_t run
Definition: svq3.c:203
put_marker_byteu
static void put_marker_byteu(PutByteContext *pb, enum JpegMarker code)
Definition: jpeglsenc.c:45
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:416
AV_PIX_FMT_GRAY8
@ AV_PIX_FMT_GRAY8
Y , 8bpp.
Definition: pixfmt.h:74
JPEGLSContext::pred
int pred
Definition: jpeglsenc.c:42
JLSState::T3
int T3
Definition: jpegls.h:38
PutByteContext
Definition: bytestream.h:37
AV_PIX_FMT_RGB24
@ AV_PIX_FMT_RGB24
packed RGB 8:8:8, 24bpp, RGBRGB...
Definition: pixfmt.h:68
AVPacket::size
int size
Definition: packet.h:366
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:40
ff_jpegls_quantize
static int ff_jpegls_quantize(JLSState *s, int v)
Calculate quantized gradient value, used for context determination.
Definition: jpegls.h:53
AVPacket::flags
int flags
A combination of AV_PKT_FLAG values.
Definition: packet.h:371
ff_jpegls_encoder
const AVCodec ff_jpegls_encoder
Definition: jpeglsenc.c:434
i
int i
Definition: input.c:407
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:31
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:49
ff_jpegls_update_state_regular
static int ff_jpegls_update_state_regular(JLSState *state, int Q, int err)
Definition: jpegls.h:95
AVCodec::name
const char * name
Name of the codec implementation.
Definition: codec.h:204
AVCodecContext::height
int height
Definition: avcodec.h:674
AVCodecContext::pix_fmt
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:711
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:418
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:72
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:62
AVCodecContext
main external API structure.
Definition: avcodec.h:501
AV_PIX_FMT_NONE
@ AV_PIX_FMT_NONE
Definition: pixfmt.h:65
AV_CODEC_ID_JPEGLS
@ AV_CODEC_ID_JPEGLS
Definition: codec_id.h:60
AV_OPT_TYPE_INT
@ AV_OPT_TYPE_INT
Definition: opt.h:225
temp
else temp
Definition: vf_mcdeint.c:259
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:427
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
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:528
AVPacket
This structure stores compressed data.
Definition: packet.h:342
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:35
AVCodecContext::width
int width
picture width / height.
Definition: avcodec.h:674
bytestream.h
AVFrame::linesize
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
Definition: frame.h:334
ff_alloc_packet2
int ff_alloc_packet2(AVCodecContext *avctx, AVPacket *avpkt, int64_t size, int64_t min_size)
Check AVPacket size and/or allocate data.
Definition: encode.c:33
put_bits.h
mjpegenc.h
AV_OPT_TYPE_CONST
@ AV_OPT_TYPE_CONST
Definition: opt.h:234
put_marker_byte
static void put_marker_byte(PutByteContext *pb, enum JpegMarker code)
Definition: jpeglsenc.c:51