FFmpeg  4.3
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) &&
112  (s->picture_ptr->format == AV_PIX_FMT_GRAY8 || s->picture_ptr->format == 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 =
122  s->avctx->pix_fmt = AV_PIX_FMT_PAL8;
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 
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;
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 AVERROR_INVALIDDATA;
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 0;
267  if (state->run_index[comp] < 31)
268  state->run_index[comp]++;
269  if (x + stride > w)
270  return 0;
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 AVERROR_INVALIDDATA;
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 +
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  return 0;
346 }
347 
349  int point_transform, int ilv)
350 {
351  int i, t = 0;
352  uint8_t *zero, *last, *cur;
353  JLSState *state;
354  int off = 0, stride = 1, width, shift, ret = 0;
355  int decoded_height = 0;
356 
357  zero = av_mallocz(s->picture_ptr->linesize[0]);
358  if (!zero)
359  return AVERROR(ENOMEM);
360  last = zero;
361  cur = s->picture_ptr->data[0];
362 
363  state = av_mallocz(sizeof(JLSState));
364  if (!state) {
365  av_free(zero);
366  return AVERROR(ENOMEM);
367  }
368  /* initialize JPEG-LS state from JPEG parameters */
369  state->near = near;
370  state->bpp = (s->bits < 2) ? 2 : s->bits;
371  state->maxval = s->maxval;
372  state->T1 = s->t1;
373  state->T2 = s->t2;
374  state->T3 = s->t3;
375  state->reset = s->reset;
378 
379  if (s->bits <= 8)
380  shift = point_transform + (8 - s->bits);
381  else
382  shift = point_transform + (16 - s->bits);
383 
384  if (shift >= 16) {
386  goto end;
387  }
388 
389  if (s->avctx->debug & FF_DEBUG_PICT_INFO) {
390  av_log(s->avctx, AV_LOG_DEBUG,
391  "JPEG-LS params: %ix%i NEAR=%i MV=%i T(%i,%i,%i) "
392  "RESET=%i, LIMIT=%i, qbpp=%i, RANGE=%i\n",
393  s->width, s->height, state->near, state->maxval,
394  state->T1, state->T2, state->T3,
395  state->reset, state->limit, state->qbpp, state->range);
396  av_log(s->avctx, AV_LOG_DEBUG, "JPEG params: ILV=%i Pt=%i BPP=%i, scan = %i\n",
397  ilv, point_transform, s->bits, s->cur_scan);
398  }
399  if (get_bits_left(&s->gb) < s->height) {
401  goto end;
402  }
403  if (ilv == 0) { /* separate planes */
404  if (s->cur_scan > s->nb_components) {
406  goto end;
407  }
408  stride = (s->nb_components > 1) ? 3 : 1;
409  off = av_clip(s->cur_scan - 1, 0, stride - 1);
410  width = s->width * stride;
411  cur += off;
412  for (i = 0; i < s->height; i++) {
413  int ret;
414  if (s->bits <= 8) {
415  ret = ls_decode_line(state, s, last, cur, t, width, stride, off, 8);
416  t = last[0];
417  } else {
418  ret = ls_decode_line(state, s, last, cur, t, width, stride, off, 16);
419  t = *((uint16_t *)last);
420  }
421  if (ret < 0)
422  break;
423  last = cur;
424  cur += s->picture_ptr->linesize[0];
425 
426  if (s->restart_interval && !--s->restart_count) {
427  align_get_bits(&s->gb);
428  skip_bits(&s->gb, 16); /* skip RSTn */
429  }
430  }
431  decoded_height = i;
432  } else if (ilv == 1) { /* line interleaving */
433  int j;
434  int Rc[3] = { 0, 0, 0 };
435  stride = (s->nb_components > 1) ? 3 : 1;
436  memset(cur, 0, s->picture_ptr->linesize[0]);
437  width = s->width * stride;
438  for (i = 0; i < s->height; i++) {
439  int ret;
440  for (j = 0; j < stride; j++) {
441  ret = ls_decode_line(state, s, last + j, cur + j,
442  Rc[j], width, stride, j, 8);
443  if (ret < 0)
444  break;
445  Rc[j] = last[j];
446 
447  if (s->restart_interval && !--s->restart_count) {
448  align_get_bits(&s->gb);
449  skip_bits(&s->gb, 16); /* skip RSTn */
450  }
451  }
452  if (ret < 0)
453  break;
454  last = cur;
455  cur += s->picture_ptr->linesize[0];
456  }
457  decoded_height = i;
458  } else if (ilv == 2) { /* sample interleaving */
459  avpriv_report_missing_feature(s->avctx, "Sample interleaved images");
461  goto end;
462  } else { /* unknown interleaving */
463  avpriv_report_missing_feature(s->avctx, "Unknown interleaved images");
465  goto end;
466  }
467 
468  if (s->xfrm && s->nb_components == 3) {
469  int x, w;
470 
471  w = s->width * s->nb_components;
472 
473  if (s->bits <= 8) {
474  uint8_t *src = s->picture_ptr->data[0];
475 
476  for (i = 0; i < s->height; i++) {
477  switch(s->xfrm) {
478  case 1:
479  for (x = off; x < w; x += 3) {
480  src[x ] += src[x+1] + 128;
481  src[x+2] += src[x+1] + 128;
482  }
483  break;
484  case 2:
485  for (x = off; x < w; x += 3) {
486  src[x ] += src[x+1] + 128;
487  src[x+2] += ((src[x ] + src[x+1])>>1) + 128;
488  }
489  break;
490  case 3:
491  for (x = off; x < w; x += 3) {
492  int g = src[x+0] - ((src[x+2]+src[x+1])>>2) + 64;
493  src[x+0] = src[x+2] + g + 128;
494  src[x+2] = src[x+1] + g + 128;
495  src[x+1] = g;
496  }
497  break;
498  case 4:
499  for (x = off; x < w; x += 3) {
500  int r = src[x+0] - (( 359 * (src[x+2]-128) + 490) >> 8);
501  int g = src[x+0] - (( 88 * (src[x+1]-128) - 183 * (src[x+2]-128) + 30) >> 8);
502  int b = src[x+0] + ((454 * (src[x+1]-128) + 574) >> 8);
503  src[x+0] = av_clip_uint8(r);
504  src[x+1] = av_clip_uint8(g);
505  src[x+2] = av_clip_uint8(b);
506  }
507  break;
508  }
509  src += s->picture_ptr->linesize[0];
510  }
511  }else
512  avpriv_report_missing_feature(s->avctx, "16bit xfrm");
513  }
514 
515  if (shift) { /* we need to do point transform or normalize samples */
516  int x, w;
517 
518  w = s->width * s->nb_components;
519 
520  if (s->bits <= 8) {
521  uint8_t *src = s->picture_ptr->data[0];
522 
523  for (i = 0; i < decoded_height; i++) {
524  for (x = off; x < w; x += stride)
525  src[x] <<= shift;
526  src += s->picture_ptr->linesize[0];
527  }
528  } else {
529  uint16_t *src = (uint16_t *)s->picture_ptr->data[0];
530 
531  for (i = 0; i < decoded_height; i++) {
532  for (x = 0; x < w; x++)
533  src[x] <<= shift;
534  src += s->picture_ptr->linesize[0] / 2;
535  }
536  }
537  }
538 
539 end:
540  av_free(state);
541  av_free(zero);
542 
543  return ret;
544 }
545 
547  .name = "jpegls",
548  .long_name = NULL_IF_CONFIG_SMALL("JPEG-LS"),
549  .type = AVMEDIA_TYPE_VIDEO,
550  .id = AV_CODEC_ID_JPEGLS,
551  .priv_data_size = sizeof(MJpegDecodeContext),
553  .close = ff_mjpeg_decode_end,
555  .capabilities = AV_CODEC_CAP_DR1,
556  .caps_internal = FF_CODEC_CAP_INIT_THREADSAFE,
557 };
AVCodec
AVCodec.
Definition: codec.h:190
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:40
mjpeg.h
init
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:35
show_bits_long
static unsigned int show_bits_long(GetBitContext *s, int n)
Show 0-32 bits.
Definition: get_bits.h:602
get_bits_left
static int get_bits_left(GetBitContext *gb)
Definition: get_bits.h:849
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
W
@ W
Definition: vf_addroi.c:26
comp
static void comp(unsigned char *dst, ptrdiff_t dst_stride, unsigned char *src, ptrdiff_t src_stride, int add)
Definition: eamad.c:83
get_bits_long
static unsigned int get_bits_long(GetBitContext *s, int n)
Read 0-32 bits.
Definition: get_bits.h:546
end
static av_cold int end(AVCodecContext *avctx)
Definition: avrndec.c:90
mjpegdec.h
R
#define R
Definition: huffyuvdsp.h:34
internal.h
b
#define b
Definition: input.c:41
jpeglsdec.h
ls_get_code_regular
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
FF_DEBUG_PICT_INFO
#define FF_DEBUG_PICT_INFO
Definition: avcodec.h:1612
skip_bits
static void skip_bits(GetBitContext *s, int n)
Definition: get_bits.h:467
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
ff_mjpeg_decode_init
av_cold int ff_mjpeg_decode_init(AVCodecContext *avctx)
Definition: mjpegdec.c:139
GetBitContext
Definition: get_bits.h:61
x
FFmpeg Automated Testing Environment ************************************Introduction Using FATE from your FFmpeg source directory Submitting the results to the FFmpeg result aggregation server Uploading new samples to the fate suite FATE makefile targets and variables Makefile targets Makefile variables Examples Introduction **************FATE is an extended regression suite on the client side and a means for results aggregation and presentation on the server side The first part of this document explains how you can use FATE from your FFmpeg source directory to test your ffmpeg binary The second part describes how you can run FATE to submit the results to FFmpeg’s FATE server In any way you can have a look at the publicly viewable FATE results by visiting this as it can be seen if some test on some platform broke with their recent contribution This usually happens on the platforms the developers could not test on The second part of this document describes how you can run FATE to submit your results to FFmpeg’s FATE server If you want to submit your results be sure to check that your combination of OS and compiler is not already listed on the above mentioned website In the third part you can find a comprehensive listing of FATE makefile targets and variables Using FATE from your FFmpeg source directory **********************************************If you want to run FATE on your machine you need to have the samples in place You can get the samples via the build target fate rsync Use this command from the top level source this will cause FATE to fail NOTE To use a custom wrapper to run the pass ‘ target exec’ to ‘configure’ or set the TARGET_EXEC Make variable Submitting the results to the FFmpeg result aggregation server ****************************************************************To submit your results to the server you should run fate through the shell script ‘tests fate sh’ from the FFmpeg sources This script needs to be invoked with a configuration file as its first argument tests fate sh path to fate_config A configuration file template with comments describing the individual configuration variables can be found at ‘doc fate_config sh template’ Create a configuration that suits your based on the configuration template The ‘slot’ configuration variable can be any string that is not yet but it is suggested that you name it adhering to the following pattern ‘ARCH OS COMPILER COMPILER VERSION’ The configuration file itself will be sourced in a shell therefore all shell features may be used This enables you to setup the environment as you need it for your build For your first test runs the ‘fate_recv’ variable should be empty or commented out This will run everything as normal except that it will omit the submission of the results to the server The following files should be present in $workdir as specified in the configuration it may help to try out the ‘ssh’ command with one or more ‘ v’ options You should get detailed output concerning your SSH configuration and the authentication process The only thing left is to automate the execution of the fate sh script and the synchronisation of the samples directory Uploading new samples to the fate suite *****************************************If you need a sample uploaded send a mail to samples request This is for developers who have an account on the fate suite server If you upload new please make sure they are as small as space on each network bandwidth and so on benefit from smaller test cases Also keep in mind older checkouts use existing sample that means in practice generally do not remove or overwrite files as it likely would break older checkouts or releases Also all needed samples for a commit should be ideally before the push If you need an account for frequently uploading samples or you wish to help others by doing that send a mail to ffmpeg devel rsync vauL Duo x
Definition: fate.txt:150
JLSState
Definition: jpegls.h:41
jpegls.h
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
get_ur_golomb_jpegls
static int get_ur_golomb_jpegls(GetBitContext *gb, int k, int limit, int esc_len)
read unsigned golomb rice code (jpegls).
Definition: golomb.h:428
decode
static void decode(AVCodecContext *dec_ctx, AVPacket *pkt, AVFrame *frame, FILE *outfile)
Definition: decode_audio.c:71
width
#define width
s
#define s(width, name)
Definition: cbs_vp9.c:257
g
const char * g
Definition: vf_curves.c:115
ff_jpegls_decode_picture
int ff_jpegls_decode_picture(MJpegDecodeContext *s, int near, int point_transform, int ilv)
Definition: jpeglsdec.c:348
bits
uint8_t bits
Definition: vp3data.h:202
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
AV_LOG_DEBUG
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:197
ls_decode_line
static int 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
get_bits.h
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:239
ff_mjpeg_decode_end
av_cold int ff_mjpeg_decode_end(AVCodecContext *avctx)
Definition: mjpegdec.c:2801
FFABS
#define FFABS(a)
Absolute value, Note, INT_MIN / INT64_MIN result in undefined behavior as they are not representable ...
Definition: common.h:72
if
if(ret)
Definition: filter_design.txt:179
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
ff_jpegls_downscale_state
static void ff_jpegls_downscale_state(JLSState *state, int Q)
Definition: jpegls.h:89
NULL
#define NULL
Definition: coverity.c:32
AVERROR_PATCHWELCOME
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Definition: error.h:62
ff_log2_run
const uint8_t ff_log2_run[41]
Definition: bitstream.c:39
get_bits1
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:498
src
#define src
Definition: vp8dsp.c:254
mathops.h
MJpegDecodeContext
Definition: mjpegdec.h:46
AV_PIX_FMT_GRAY8
@ AV_PIX_FMT_GRAY8
Y , 8bpp.
Definition: pixfmt.h:74
for
for(j=16;j >0;--j)
Definition: h264pred_template.c:469
ff_dlog
#define ff_dlog(a,...)
Definition: tableprint_vlc.h:29
AV_CODEC_CAP_DR1
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() for allocating buffers and supports custom allocators.
Definition: codec.h:50
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:186
id
enum AVCodecID id
Definition: extract_extradata_bsf.c:332
ff_jpegls_decode_lse
int ff_jpegls_decode_lse(MJpegDecodeContext *s)
Decode LSE block with initialization parameters.
Definition: jpeglsdec.c:51
state
static struct @314 state
avpriv_report_missing_feature
void avpriv_report_missing_feature(void *avc, const char *msg,...) av_printf_format(2
Log a generic warning message about a missing feature.
ff_jpegls_quantize
static int ff_jpegls_quantize(JLSState *s, int v)
Calculate quantized gradient value, used for context determination.
Definition: jpegls.h:57
FFMIN
#define FFMIN(a, b)
Definition: common.h:96
r
#define r
Definition: input.c:40
ff_mjpeg_decode_frame
int ff_mjpeg_decode_frame(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *avpkt)
Definition: mjpegdec.c:2322
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:269
ff_jpegls_init_state
void ff_jpegls_init_state(JLSState *state)
Calculate initial JPEG-LS parameters.
Definition: jpegls.c:31
ff_jpegls_update_state_regular
static int ff_jpegls_update_state_regular(JLSState *state, int Q, int err)
Definition: jpegls.h:99
uint8_t
uint8_t
Definition: audio_convert.c:194
AVCodec::name
const char * name
Name of the codec implementation.
Definition: codec.h:197
len
int len
Definition: vorbis_enc_data.h:452
avcodec.h
AV_PIX_FMT_PAL8
@ AV_PIX_FMT_PAL8
8 bits with AV_PIX_FMT_RGB32 palette
Definition: pixfmt.h:77
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_get_code_runterm
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
w
FFmpeg Automated Testing Environment ************************************Introduction Using FATE from your FFmpeg source directory Submitting the results to the FFmpeg result aggregation server Uploading new samples to the fate suite FATE makefile targets and variables Makefile targets Makefile variables Examples Introduction **************FATE is an extended regression suite on the client side and a means for results aggregation and presentation on the server side The first part of this document explains how you can use FATE from your FFmpeg source directory to test your ffmpeg binary The second part describes how you can run FATE to submit the results to FFmpeg’s FATE server In any way you can have a look at the publicly viewable FATE results by visiting this as it can be seen if some test on some platform broke with their recent contribution This usually happens on the platforms the developers could not test on The second part of this document describes how you can run FATE to submit your results to FFmpeg’s FATE server If you want to submit your results be sure to check that your combination of OS and compiler is not already listed on the above mentioned website In the third part you can find a comprehensive listing of FATE makefile targets and variables Using FATE from your FFmpeg source directory **********************************************If you want to run FATE on your machine you need to have the samples in place You can get the samples via the build target fate rsync Use this command from the top level source this will cause FATE to fail NOTE To use a custom wrapper to run the pass ‘ target exec’ to ‘configure’ or set the TARGET_EXEC Make variable Submitting the results to the FFmpeg result aggregation server ****************************************************************To submit your results to the server you should run fate through the shell script ‘tests fate sh’ from the FFmpeg sources This script needs to be invoked with a configuration file as its first argument tests fate sh path to fate_config A configuration file template with comments describing the individual configuration variables can be found at ‘doc fate_config sh template’ Create a configuration that suits your based on the configuration template The ‘slot’ configuration variable can be any string that is not yet but it is suggested that you name it adhering to the following pattern ‘ARCH OS COMPILER COMPILER VERSION’ The configuration file itself will be sourced in a shell therefore all shell features may be used This enables you to setup the environment as you need it for your build For your first test runs the ‘fate_recv’ variable should be empty or commented out This will run everything as normal except that it will omit the submission of the results to the server The following files should be present in $workdir as specified in the configuration it may help to try out the ‘ssh’ command with one or more ‘ v’ options You should get detailed output concerning your SSH configuration and the authentication process The only thing left is to automate the execution of the fate sh script and the synchronisation of the samples directory Uploading new samples to the fate suite *****************************************If you need a sample uploaded send a mail to samples request This is for developers who have an account on the fate suite server If you upload new please make sure they are as small as space on each network bandwidth and so on benefit from smaller test cases Also keep in mind older checkouts use existing sample that means in practice generally do not remove or overwrite files as it likely would break older checkouts or releases Also all needed samples for a commit should be ideally before the push If you need an account for frequently uploading samples or you wish to help others by doing that send a mail to ffmpeg devel rsync vauL Duo ug o o w
Definition: fate.txt:150
align_get_bits
static const uint8_t * align_get_bits(GetBitContext *s)
Definition: get_bits.h:693
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
AV_CODEC_ID_JPEGLS
@ AV_CODEC_ID_JPEGLS
Definition: codec_id.h:60
temp
else temp
Definition: vf_mcdeint.c:256
shift
static int shift(int a, int b)
Definition: sonic.c:82
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
zero
#define zero
Definition: regdef.h:64
avpriv_request_sample
#define avpriv_request_sample(...)
Definition: tableprint_vlc.h:39
map
const VDPAUPixFmtMap * map
Definition: hwcontext_vdpau.c:85
av_free
#define av_free(p)
Definition: tableprint_vlc.h:34
MAX_COMPONENTS
#define MAX_COMPONENTS
Definition: mjpegdec.h:44
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:28
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
ff_jpegls_decoder
AVCodec ff_jpegls_decoder
Definition: jpeglsdec.c:546