FFmpeg
jpeglsdec.c
Go to the documentation of this file.
1 /*
2  * JPEG-LS decoder
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 decoder.
26  */
27 
28 #include "avcodec.h"
29 #include "get_bits.h"
30 #include "golomb.h"
31 #include "internal.h"
32 #include "mathops.h"
33 #include "mjpeg.h"
34 #include "mjpegdec.h"
35 #include "jpegls.h"
36 #include "jpeglsdec.h"
37 
38 /*
39  * Uncomment this to significantly speed up decoding of broken JPEG-LS
40  * (or test broken JPEG-LS decoder) and slow down ordinary decoding a bit.
41  *
42  * There is no Golomb code with length >= 32 bits possible, so check and
43  * avoid situation of 32 zeros, FFmpeg Golomb decoder is painfully slow
44  * on this errors.
45  */
46 //#define JLS_BROKEN
47 
48 /**
49  * Decode LSE block with initialization parameters
50  */
52 {
53  int id;
54  int tid, wt, maxtab, i, j;
55 
56  int len = get_bits(&s->gb, 16);
57  id = get_bits(&s->gb, 8);
58 
59  switch (id) {
60  case 1:
61  if (len < 13)
62  return AVERROR_INVALIDDATA;
63 
64  s->maxval = get_bits(&s->gb, 16);
65  s->t1 = get_bits(&s->gb, 16);
66  s->t2 = get_bits(&s->gb, 16);
67  s->t3 = get_bits(&s->gb, 16);
68  s->reset = get_bits(&s->gb, 16);
69 
70  if(s->avctx->debug & FF_DEBUG_PICT_INFO) {
71  av_log(s->avctx, AV_LOG_DEBUG, "Coding parameters maxval:%d T1:%d T2:%d T3:%d reset:%d\n",
72  s->maxval, s->t1, s->t2, s->t3, s->reset);
73  }
74 
75 // ff_jpegls_reset_coding_parameters(s, 0);
76  //FIXME quant table?
77  break;
78  case 2:
79  s->palette_index = 0;
80  case 3:
81  tid= get_bits(&s->gb, 8);
82  wt = get_bits(&s->gb, 8);
83 
84  if (len < 5)
85  return AVERROR_INVALIDDATA;
86 
87  if (wt < 1 || wt > MAX_COMPONENTS) {
88  avpriv_request_sample(s->avctx, "wt %d", wt);
89  return AVERROR_PATCHWELCOME;
90  }
91 
92  if (!s->maxval)
93  maxtab = 255;
94  else if ((5 + wt*(s->maxval+1)) < 65535)
95  maxtab = s->maxval;
96  else
97  maxtab = 65530/wt - 1;
98 
99  if(s->avctx->debug & FF_DEBUG_PICT_INFO) {
100  av_log(s->avctx, AV_LOG_DEBUG, "LSE palette %d tid:%d wt:%d maxtab:%d\n", id, tid, wt, maxtab);
101  }
102  if (maxtab >= 256) {
103  avpriv_request_sample(s->avctx, ">8bit palette");
104  return AVERROR_PATCHWELCOME;
105  }
106  maxtab = FFMIN(maxtab, (len - 5) / wt + s->palette_index);
107 
108  if (s->palette_index > maxtab)
109  return AVERROR_INVALIDDATA;
110 
111  if ((s->avctx->pix_fmt == AV_PIX_FMT_GRAY8 || s->avctx->pix_fmt == AV_PIX_FMT_PAL8) &&
113  uint32_t *pal = (uint32_t *)s->picture_ptr->data[1];
114  int shift = 0;
115 
116  if (s->avctx->bits_per_raw_sample > 0 && s->avctx->bits_per_raw_sample < 8) {
117  maxtab = FFMIN(maxtab, (1<<s->avctx->bits_per_raw_sample)-1);
118  shift = 8 - s->avctx->bits_per_raw_sample;
119  }
120 
121  s->picture_ptr->format =
123  for (i=s->palette_index; i<=maxtab; i++) {
124  uint8_t k = i << shift;
125  pal[k] = 0;
126  for (j=0; j<wt; j++) {
127  pal[k] |= get_bits(&s->gb, 8) << (8*(wt-j-1));
128  }
129  }
130  s->palette_index = i;
131  }
132  break;
133  case 4:
134  avpriv_request_sample(s->avctx, "oversize image");
135  return AVERROR(ENOSYS);
136  default:
137  av_log(s->avctx, AV_LOG_ERROR, "invalid id %d\n", id);
138  return AVERROR_INVALIDDATA;
139  }
140  ff_dlog(s->avctx, "ID=%i, T=%i,%i,%i\n", id, s->t1, s->t2, s->t3);
141 
142  return 0;
143 }
144 
145 /**
146  * Get context-dependent Golomb code, decode it and update context
147  */
148 static inline int ls_get_code_regular(GetBitContext *gb, JLSState *state, int Q)
149 {
150  int k, ret;
151 
152  for (k = 0; (state->N[Q] << k) < state->A[Q]; k++)
153  ;
154 
155 #ifdef JLS_BROKEN
156  if (!show_bits_long(gb, 32))
157  return -1;
158 #endif
159  ret = get_ur_golomb_jpegls(gb, k, state->limit, state->qbpp);
160 
161  /* decode mapped error */
162  if (ret & 1)
163  ret = -(ret + 1 >> 1);
164  else
165  ret >>= 1;
166 
167  /* for NEAR=0, k=0 and 2*B[Q] <= - N[Q] mapping is reversed */
168  if (!state->near && !k && (2 * state->B[Q] <= -state->N[Q]))
169  ret = -(ret + 1);
170 
171  ret = ff_jpegls_update_state_regular(state, Q, ret);
172 
173  return ret;
174 }
175 
176 /**
177  * Get Golomb code, decode it and update state for run termination
178  */
180  int RItype, int limit_add)
181 {
182  int k, ret, temp, map;
183  int Q = 365 + RItype;
184 
185  temp = state->A[Q];
186  if (RItype)
187  temp += state->N[Q] >> 1;
188 
189  for (k = 0; (state->N[Q] << k) < temp; k++)
190  ;
191 
192 #ifdef JLS_BROKEN
193  if (!show_bits_long(gb, 32))
194  return -1;
195 #endif
196  ret = get_ur_golomb_jpegls(gb, k, state->limit - limit_add - 1,
197  state->qbpp);
198 
199  /* decode mapped error */
200  map = 0;
201  if (!k && (RItype || ret) && (2 * state->B[Q] < state->N[Q]))
202  map = 1;
203  ret += RItype + map;
204 
205  if (ret & 1) {
206  ret = map - (ret + 1 >> 1);
207  state->B[Q]++;
208  } else {
209  ret = ret >> 1;
210  }
211 
212  if(FFABS(ret) > 0xFFFF)
213  return -0x10000;
214  /* update state */
215  state->A[Q] += FFABS(ret) - RItype;
216  ret *= state->twonear;
217  ff_jpegls_downscale_state(state, Q);
218 
219  return ret;
220 }
221 
222 /**
223  * Decode one line of image
224  */
226  void *last, void *dst, int last2, int w,
227  int stride, int comp, int bits)
228 {
229  int i, x = 0;
230  int Ra, Rb, Rc, Rd;
231  int D0, D1, D2;
232 
233  while (x < w) {
234  int err, pred;
235 
236  if (get_bits_left(&s->gb) <= 0)
237  return;
238 
239  /* compute gradients */
240  Ra = x ? R(dst, x - stride) : R(last, x);
241  Rb = R(last, x);
242  Rc = x ? R(last, x - stride) : last2;
243  Rd = (x >= w - stride) ? R(last, x) : R(last, x + stride);
244  D0 = Rd - Rb;
245  D1 = Rb - Rc;
246  D2 = Rc - Ra;
247  /* run mode */
248  if ((FFABS(D0) <= state->near) &&
249  (FFABS(D1) <= state->near) &&
250  (FFABS(D2) <= state->near)) {
251  int r;
252  int RItype;
253 
254  /* decode full runs while available */
255  while (get_bits1(&s->gb)) {
256  int r;
257  r = 1 << ff_log2_run[state->run_index[comp]];
258  if (x + r * stride > w)
259  r = (w - x) / stride;
260  for (i = 0; i < r; i++) {
261  W(dst, x, Ra);
262  x += stride;
263  }
264  /* if EOL reached, we stop decoding */
265  if (r != 1 << ff_log2_run[state->run_index[comp]])
266  return;
267  if (state->run_index[comp] < 31)
268  state->run_index[comp]++;
269  if (x + stride > w)
270  return;
271  }
272  /* decode aborted run */
273  r = ff_log2_run[state->run_index[comp]];
274  if (r)
275  r = get_bits_long(&s->gb, r);
276  if (x + r * stride > w) {
277  r = (w - x) / stride;
278  }
279  for (i = 0; i < r; i++) {
280  W(dst, x, Ra);
281  x += stride;
282  }
283 
284  if (x >= w) {
285  av_log(NULL, AV_LOG_ERROR, "run overflow\n");
286  av_assert0(x <= w);
287  return;
288  }
289 
290  /* decode run termination value */
291  Rb = R(last, x);
292  RItype = (FFABS(Ra - Rb) <= state->near) ? 1 : 0;
293  err = ls_get_code_runterm(&s->gb, state, RItype,
294  ff_log2_run[state->run_index[comp]]);
295  if (state->run_index[comp])
296  state->run_index[comp]--;
297 
298  if (state->near && RItype) {
299  pred = Ra + err;
300  } else {
301  if (Rb < Ra)
302  pred = Rb - err;
303  else
304  pred = Rb + err;
305  }
306  } else { /* regular mode */
307  int context, sign;
308 
309  context = ff_jpegls_quantize(state, D0) * 81 +
310  ff_jpegls_quantize(state, D1) * 9 +
311  ff_jpegls_quantize(state, D2);
312  pred = mid_pred(Ra, Ra + Rb - Rc, Rb);
313 
314  if (context < 0) {
315  context = -context;
316  sign = 1;
317  } else {
318  sign = 0;
319  }
320 
321  if (sign) {
322  pred = av_clip(pred - state->C[context], 0, state->maxval);
323  err = -ls_get_code_regular(&s->gb, state, context);
324  } else {
325  pred = av_clip(pred + state->C[context], 0, state->maxval);
326  err = ls_get_code_regular(&s->gb, state, context);
327  }
328 
329  /* we have to do something more for near-lossless coding */
330  pred += err;
331  }
332  if (state->near) {
333  if (pred < -state->near)
334  pred += state->range * state->twonear;
335  else if (pred > state->maxval + state->near)
336  pred -= state->range * state->twonear;
337  pred = av_clip(pred, 0, state->maxval);
338  }
339 
340  pred &= state->maxval;
341  W(dst, x, pred);
342  x += stride;
343  }
344 }
345 
347  int point_transform, int ilv)
348 {
349  int i, t = 0;
350  uint8_t *zero, *last, *cur;
351  JLSState *state;
352  int off = 0, stride = 1, width, shift, ret = 0;
353 
354  zero = av_mallocz(s->picture_ptr->linesize[0]);
355  if (!zero)
356  return AVERROR(ENOMEM);
357  last = zero;
358  cur = s->picture_ptr->data[0];
359 
360  state = av_mallocz(sizeof(JLSState));
361  if (!state) {
362  av_free(zero);
363  return AVERROR(ENOMEM);
364  }
365  /* initialize JPEG-LS state from JPEG parameters */
366  state->near = near;
367  state->bpp = (s->bits < 2) ? 2 : s->bits;
368  state->maxval = s->maxval;
369  state->T1 = s->t1;
370  state->T2 = s->t2;
371  state->T3 = s->t3;
372  state->reset = s->reset;
374  ff_jpegls_init_state(state);
375 
376  if (s->bits <= 8)
377  shift = point_transform + (8 - s->bits);
378  else
379  shift = point_transform + (16 - s->bits);
380 
381  if (shift >= 16) {
382  ret = AVERROR_INVALIDDATA;
383  goto end;
384  }
385 
386  if (s->avctx->debug & FF_DEBUG_PICT_INFO) {
388  "JPEG-LS params: %ix%i NEAR=%i MV=%i T(%i,%i,%i) "
389  "RESET=%i, LIMIT=%i, qbpp=%i, RANGE=%i\n",
390  s->width, s->height, state->near, state->maxval,
391  state->T1, state->T2, state->T3,
392  state->reset, state->limit, state->qbpp, state->range);
393  av_log(s->avctx, AV_LOG_DEBUG, "JPEG params: ILV=%i Pt=%i BPP=%i, scan = %i\n",
394  ilv, point_transform, s->bits, s->cur_scan);
395  }
396  if (get_bits_left(&s->gb) < s->height) {
397  ret = AVERROR_INVALIDDATA;
398  goto end;
399  }
400  if (ilv == 0) { /* separate planes */
401  if (s->cur_scan > s->nb_components) {
402  ret = AVERROR_INVALIDDATA;
403  goto end;
404  }
405  stride = (s->nb_components > 1) ? 3 : 1;
406  off = av_clip(s->cur_scan - 1, 0, stride - 1);
407  width = s->width * stride;
408  cur += off;
409  for (i = 0; i < s->height; i++) {
410  if (s->bits <= 8) {
411  ls_decode_line(state, s, last, cur, t, width, stride, off, 8);
412  t = last[0];
413  } else {
414  ls_decode_line(state, s, last, cur, t, width, stride, off, 16);
415  t = *((uint16_t *)last);
416  }
417  last = cur;
418  cur += s->picture_ptr->linesize[0];
419 
420  if (s->restart_interval && !--s->restart_count) {
421  align_get_bits(&s->gb);
422  skip_bits(&s->gb, 16); /* skip RSTn */
423  }
424  }
425  } else if (ilv == 1) { /* line interleaving */
426  int j;
427  int Rc[3] = { 0, 0, 0 };
428  stride = (s->nb_components > 1) ? 3 : 1;
429  memset(cur, 0, s->picture_ptr->linesize[0]);
430  width = s->width * stride;
431  for (i = 0; i < s->height; i++) {
432  for (j = 0; j < stride; j++) {
433  ls_decode_line(state, s, last + j, cur + j,
434  Rc[j], width, stride, j, 8);
435  Rc[j] = last[j];
436 
437  if (s->restart_interval && !--s->restart_count) {
438  align_get_bits(&s->gb);
439  skip_bits(&s->gb, 16); /* skip RSTn */
440  }
441  }
442  last = cur;
443  cur += s->picture_ptr->linesize[0];
444  }
445  } else if (ilv == 2) { /* sample interleaving */
446  avpriv_report_missing_feature(s->avctx, "Sample interleaved images");
447  ret = AVERROR_PATCHWELCOME;
448  goto end;
449  } else { /* unknown interleaving */
450  avpriv_report_missing_feature(s->avctx, "Unknown interleaved images");
451  ret = AVERROR_PATCHWELCOME;
452  goto end;
453  }
454 
455  if (s->xfrm && s->nb_components == 3) {
456  int x, w;
457 
458  w = s->width * s->nb_components;
459 
460  if (s->bits <= 8) {
461  uint8_t *src = s->picture_ptr->data[0];
462 
463  for (i = 0; i < s->height; i++) {
464  switch(s->xfrm) {
465  case 1:
466  for (x = off; x < w; x += 3) {
467  src[x ] += src[x+1] + 128;
468  src[x+2] += src[x+1] + 128;
469  }
470  break;
471  case 2:
472  for (x = off; x < w; x += 3) {
473  src[x ] += src[x+1] + 128;
474  src[x+2] += ((src[x ] + src[x+1])>>1) + 128;
475  }
476  break;
477  case 3:
478  for (x = off; x < w; x += 3) {
479  int g = src[x+0] - ((src[x+2]+src[x+1])>>2) + 64;
480  src[x+0] = src[x+2] + g + 128;
481  src[x+2] = src[x+1] + g + 128;
482  src[x+1] = g;
483  }
484  break;
485  case 4:
486  for (x = off; x < w; x += 3) {
487  int r = src[x+0] - (( 359 * (src[x+2]-128) + 490) >> 8);
488  int g = src[x+0] - (( 88 * (src[x+1]-128) - 183 * (src[x+2]-128) + 30) >> 8);
489  int b = src[x+0] + ((454 * (src[x+1]-128) + 574) >> 8);
490  src[x+0] = av_clip_uint8(r);
491  src[x+1] = av_clip_uint8(g);
492  src[x+2] = av_clip_uint8(b);
493  }
494  break;
495  }
496  src += s->picture_ptr->linesize[0];
497  }
498  }else
499  avpriv_report_missing_feature(s->avctx, "16bit xfrm");
500  }
501 
502  if (shift) { /* we need to do point transform or normalize samples */
503  int x, w;
504 
505  w = s->width * s->nb_components;
506 
507  if (s->bits <= 8) {
508  uint8_t *src = s->picture_ptr->data[0];
509 
510  for (i = 0; i < s->height; i++) {
511  for (x = off; x < w; x += stride)
512  src[x] <<= shift;
513  src += s->picture_ptr->linesize[0];
514  }
515  } else {
516  uint16_t *src = (uint16_t *)s->picture_ptr->data[0];
517 
518  for (i = 0; i < s->height; i++) {
519  for (x = 0; x < w; x++)
520  src[x] <<= shift;
521  src += s->picture_ptr->linesize[0] / 2;
522  }
523  }
524  }
525 
526 end:
527  av_free(state);
528  av_free(zero);
529 
530  return ret;
531 }
532 
534  .name = "jpegls",
535  .long_name = NULL_IF_CONFIG_SMALL("JPEG-LS"),
536  .type = AVMEDIA_TYPE_VIDEO,
537  .id = AV_CODEC_ID_JPEGLS,
538  .priv_data_size = sizeof(MJpegDecodeContext),
540  .close = ff_mjpeg_decode_end,
542  .capabilities = AV_CODEC_CAP_DR1,
543  .caps_internal = FF_CODEC_CAP_INIT_THREADSAFE,
544 };
static unsigned int show_bits_long(GetBitContext *s, int n)
Show 0-32 bits.
Definition: get_bits.h:602
int reset
Definition: jpegls.h:44
#define NULL
Definition: coverity.c:32
const uint8_t ff_log2_run[41]
Definition: bitstream.c:39
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
int T2
Definition: jpegls.h:42
static int shift(int a, int b)
Definition: sonic.c:82
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:379
else temp
Definition: vf_mcdeint.c:256
const char * g
Definition: vf_curves.c:115
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:35
#define avpriv_request_sample(...)
int C[365]
Definition: jpegls.h:43
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:1775
int twonear
Definition: jpegls.h:45
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
Definition: mem.c:236
static int get_ur_golomb_jpegls(GetBitContext *gb, int k, int limit, int esc_len)
read unsigned golomb rice code (jpegls).
Definition: golomb.h:426
int bits_per_raw_sample
Bits per sample/pixel of internal libavcodec pixel/sample format.
Definition: avcodec.h:2792
int limit
Definition: jpegls.h:44
#define src
Definition: vp8dsp.c:254
AVCodec.
Definition: avcodec.h:3477
JPEG-LS decoder.
MJPEG encoder and decoder.
static void decode(AVCodecContext *dec_ctx, AVPacket *pkt, AVFrame *frame, FILE *outfile)
Definition: decode_audio.c:42
int bpp
Definition: jpegls.h:44
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
int maxval
Definition: jpegls.h:44
#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:40
uint8_t
8 bits with AV_PIX_FMT_RGB32 palette
Definition: pixfmt.h:77
#define FF_DEBUG_PICT_INFO
Definition: avcodec.h:2647
static av_cold int end(AVCodecContext *avctx)
Definition: avrndec.c:90
AVFrame * picture_ptr
Definition: mjpegdec.h:100
#define MAX_COMPONENTS
Definition: mjpegdec.h:44
#define ff_dlog(a,...)
bitstream reader API header.
#define av_log(a,...)
static int get_bits_left(GetBitContext *gb)
Definition: get_bits.h:849
int ff_mjpeg_decode_frame(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *avpkt)
Definition: mjpegdec.c:2266
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:260
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
#define R
Definition: huffyuvdsp.h:34
av_cold int ff_mjpeg_decode_end(AVCodecContext *avctx)
Definition: mjpegdec.c:2745
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:186
const char * r
Definition: vf_curves.c:114
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:197
#define zero
Definition: regdef.h:64
void ff_jpegls_reset_coding_parameters(JLSState *s, int reset_all)
Calculate JPEG-LS codec values.
Definition: jpegls.c:62
const char * name
Name of the codec implementation.
Definition: avcodec.h:3484
static int ff_jpegls_update_state_regular(JLSState *state, int Q, int err)
Definition: jpegls.h:99
uint8_t bits
Definition: vp3data.h:202
int B[367]
Definition: jpegls.h:43
int ff_jpegls_decode_lse(MJpegDecodeContext *s)
Decode LSE block with initialization parameters.
Definition: jpeglsdec.c:51
int near
Definition: jpegls.h:45
#define b
Definition: input.c:41
#define FFMIN(a, b)
Definition: common.h:96
#define width
uint8_t w
Definition: llviddspenc.c:38
#define FFABS(a)
Absolute value, Note, INT_MIN / INT64_MIN result in undefined behavior as they are not representable ...
Definition: common.h:72
#define s(width, name)
Definition: cbs_vp9.c:257
GetBitContext gb
Definition: mjpegdec.h:49
if(ret)
static const float pred[4]
Definition: siprdata.h:259
int qbpp
Definition: jpegls.h:44
static void comp(unsigned char *dst, ptrdiff_t dst_stride, unsigned char *src, ptrdiff_t src_stride, int add)
Definition: eamad.c:83
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Definition: error.h:62
int format
format of the frame, -1 if unknown or unset Values correspond to enum AVPixelFormat for video frames...
Definition: frame.h:341
Libavcodec external API header.
static void ls_decode_line(JLSState *state, MJpegDecodeContext *s, void *last, void *dst, int last2, int w, int stride, int comp, int bits)
Decode one line of image.
Definition: jpeglsdec.c:225
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
Definition: frame.h:299
int debug
debug
Definition: avcodec.h:2646
int A[367]
Definition: jpegls.h:43
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:498
int ff_jpegls_decode_picture(MJpegDecodeContext *s, int near, int point_transform, int ilv)
Definition: jpeglsdec.c:346
static void skip_bits(GetBitContext *s, int n)
Definition: get_bits.h:467
static int ls_get_code_regular(GetBitContext *gb, JLSState *state, int Q)
Get context-dependent Golomb code, decode it and update context.
Definition: jpeglsdec.c:148
#define W(a, i, v)
Definition: jpegls.h:124
JPEG-LS common code.
int T1
Definition: jpegls.h:42
int range
Definition: jpegls.h:44
int N[367]
Definition: jpegls.h:43
#define mid_pred
Definition: mathops.h:97
int reset
context halfing interval ?rename
Definition: mjpegdec.h:80
const VDPAUPixFmtMap * map
AVCodec ff_jpegls_decoder
Definition: jpeglsdec.c:533
static unsigned int get_bits_long(GetBitContext *s, int n)
Read 0-32 bits.
Definition: get_bits.h:546
void avpriv_report_missing_feature(void *avc, const char *msg,...) av_printf_format(2
Log a generic warning message about a missing feature.
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:282
av_cold int ff_mjpeg_decode_init(AVCodecContext *avctx)
Definition: mjpegdec.c:139
GLint GLenum GLboolean GLsizei stride
Definition: opengl_enc.c:104
Y , 8bpp.
Definition: pixfmt.h:74
common internal api header.
static int ls_get_code_runterm(GetBitContext *gb, JLSState *state, int RItype, int limit_add)
Get Golomb code, decode it and update state for run termination.
Definition: jpeglsdec.c:179
AVCodecContext * avctx
Definition: mjpegdec.h:48
#define av_free(p)
static int ff_jpegls_quantize(JLSState *s, int v)
Calculate quantized gradient value, used for context determination.
Definition: jpegls.h:57
int len
static const uint8_t * align_get_bits(GetBitContext *s)
Definition: get_bits.h:693
int T3
Definition: jpegls.h:42
void ff_jpegls_init_state(JLSState *state)
Calculate initial JPEG-LS parameters.
Definition: jpegls.c:31
#define stride
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
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 local context
MJPEG decoder.
exp golomb vlc stuff
enum AVCodecID id
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() for allocating buffers and supports custom allocators.
Definition: avcodec.h:981
for(j=16;j >0;--j)
int run_index[4]
Definition: jpegls.h:46
static void ff_jpegls_downscale_state(JLSState *state, int Q)
Definition: jpegls.h:89
static struct @308 state