lagarith.c
Go to the documentation of this file.
1 /*
2  * Lagarith lossless decoder
3  * Copyright (c) 2009 Nathan Caldwell <saintdev (at) gmail.com>
4  *
5  * This file is part of Libav.
6  *
7  * Libav is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU Lesser General Public
9  * License as published by the Free Software Foundation; either
10  * version 2.1 of the License, or (at your option) any later version.
11  *
12  * Libav is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15  * Lesser General Public License for more details.
16  *
17  * You should have received a copy of the GNU Lesser General Public
18  * License along with Libav; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20  */
21 
28 #include "avcodec.h"
29 #include "get_bits.h"
30 #include "mathops.h"
31 #include "dsputil.h"
32 #include "lagarithrac.h"
33 #include "thread.h"
34 
36  FRAME_RAW = 1,
47 };
48 
49 typedef struct LagarithContext {
53  int zeros;
54  int zeros_rem;
58 
67 static uint64_t softfloat_reciprocal(uint32_t denom)
68 {
69  int shift = av_log2(denom - 1) + 1;
70  uint64_t ret = (1ULL << 52) / denom;
71  uint64_t err = (1ULL << 52) - ret * denom;
72  ret <<= shift;
73  err <<= shift;
74  err += denom / 2;
75  return ret + err / denom;
76 }
77 
86 static uint32_t softfloat_mul(uint32_t x, uint64_t mantissa)
87 {
88  uint64_t l = x * (mantissa & 0xffffffff);
89  uint64_t h = x * (mantissa >> 32);
90  h += l >> 32;
91  l &= 0xffffffff;
92  l += 1 << av_log2(h >> 21);
93  h += l >> 32;
94  return h >> 20;
95 }
96 
97 static uint8_t lag_calc_zero_run(int8_t x)
98 {
99  return (x << 1) ^ (x >> 7);
100 }
101 
102 static int lag_decode_prob(GetBitContext *gb, uint32_t *value)
103 {
104  static const uint8_t series[] = { 1, 2, 3, 5, 8, 13, 21 };
105  int i;
106  int bit = 0;
107  int bits = 0;
108  int prevbit = 0;
109  unsigned val;
110 
111  for (i = 0; i < 7; i++) {
112  if (prevbit && bit)
113  break;
114  prevbit = bit;
115  bit = get_bits1(gb);
116  if (bit && !prevbit)
117  bits += series[i];
118  }
119  bits--;
120  if (bits < 0 || bits > 31) {
121  *value = 0;
122  return -1;
123  } else if (bits == 0) {
124  *value = 0;
125  return 0;
126  }
127 
128  val = get_bits_long(gb, bits);
129  val |= 1 << bits;
130 
131  *value = val - 1;
132 
133  return 0;
134 }
135 
137 {
138  int i, j, scale_factor;
139  unsigned prob, cumulative_target;
140  unsigned cumul_prob = 0;
141  unsigned scaled_cumul_prob = 0;
142 
143  rac->prob[0] = 0;
144  rac->prob[257] = UINT_MAX;
145  /* Read probabilities from bitstream */
146  for (i = 1; i < 257; i++) {
147  if (lag_decode_prob(gb, &rac->prob[i]) < 0) {
148  av_log(rac->avctx, AV_LOG_ERROR, "Invalid probability encountered.\n");
149  return -1;
150  }
151  if ((uint64_t)cumul_prob + rac->prob[i] > UINT_MAX) {
152  av_log(rac->avctx, AV_LOG_ERROR, "Integer overflow encountered in cumulative probability calculation.\n");
153  return -1;
154  }
155  cumul_prob += rac->prob[i];
156  if (!rac->prob[i]) {
157  if (lag_decode_prob(gb, &prob)) {
158  av_log(rac->avctx, AV_LOG_ERROR, "Invalid probability run encountered.\n");
159  return -1;
160  }
161  if (prob > 257 - i)
162  prob = 257 - i;
163  for (j = 0; j < prob; j++)
164  rac->prob[++i] = 0;
165  }
166  }
167 
168  if (!cumul_prob) {
169  av_log(rac->avctx, AV_LOG_ERROR, "All probabilities are 0!\n");
170  return -1;
171  }
172 
173  /* Scale probabilities so cumulative probability is an even power of 2. */
174  scale_factor = av_log2(cumul_prob);
175 
176  if (cumul_prob & (cumul_prob - 1)) {
177  uint64_t mul = softfloat_reciprocal(cumul_prob);
178  for (i = 1; i < 257; i++) {
179  rac->prob[i] = softfloat_mul(rac->prob[i], mul);
180  scaled_cumul_prob += rac->prob[i];
181  }
182 
183  scale_factor++;
184  cumulative_target = 1 << scale_factor;
185 
186  if (scaled_cumul_prob > cumulative_target) {
187  av_log(rac->avctx, AV_LOG_ERROR,
188  "Scaled probabilities are larger than target!\n");
189  return -1;
190  }
191 
192  scaled_cumul_prob = cumulative_target - scaled_cumul_prob;
193 
194  for (i = 1; scaled_cumul_prob; i = (i & 0x7f) + 1) {
195  if (rac->prob[i]) {
196  rac->prob[i]++;
197  scaled_cumul_prob--;
198  }
199  /* Comment from reference source:
200  * if (b & 0x80 == 0) { // order of operations is 'wrong'; it has been left this way
201  * // since the compression change is negligible and fixing it
202  * // breaks backwards compatibility
203  * b =- (signed int)b;
204  * b &= 0xFF;
205  * } else {
206  * b++;
207  * b &= 0x7f;
208  * }
209  */
210  }
211  }
212 
213  rac->scale = scale_factor;
214 
215  /* Fill probability array with cumulative probability for each symbol. */
216  for (i = 1; i < 257; i++)
217  rac->prob[i] += rac->prob[i - 1];
218 
219  return 0;
220 }
221 
222 static void add_lag_median_prediction(uint8_t *dst, uint8_t *src1,
223  uint8_t *diff, int w, int *left,
224  int *left_top)
225 {
226  /* This is almost identical to add_hfyu_median_prediction in dsputil.h.
227  * However the &0xFF on the gradient predictor yealds incorrect output
228  * for lagarith.
229  */
230  int i;
231  uint8_t l, lt;
232 
233  l = *left;
234  lt = *left_top;
235 
236  for (i = 0; i < w; i++) {
237  l = mid_pred(l, src1[i], l + src1[i] - lt) + diff[i];
238  lt = src1[i];
239  dst[i] = l;
240  }
241 
242  *left = l;
243  *left_top = lt;
244 }
245 
246 static void lag_pred_line(LagarithContext *l, uint8_t *buf,
247  int width, int stride, int line)
248 {
249  int L, TL;
250 
251  if (!line) {
252  /* Left prediction only for first line */
253  L = l->dsp.add_hfyu_left_prediction(buf + 1, buf + 1,
254  width - 1, buf[0]);
255  } else {
256  /* Left pixel is actually prev_row[width] */
257  L = buf[width - stride - 1];
258 
259  if (line == 1) {
260  /* Second line, left predict first pixel, the rest of the line is median predicted
261  * NOTE: In the case of RGB this pixel is top predicted */
262  TL = l->avctx->pix_fmt == AV_PIX_FMT_YUV420P ? buf[-stride] : L;
263  } else {
264  /* Top left is 2 rows back, last pixel */
265  TL = buf[width - (2 * stride) - 1];
266  }
267 
268  add_lag_median_prediction(buf, buf - stride, buf,
269  width, &L, &TL);
270  }
271 }
272 
274  int width, int stride, int line,
275  int is_luma)
276 {
277  int L, TL;
278 
279  if (!line) {
280  if (is_luma) {
281  buf++;
282  width--;
283  }
284  l->dsp.add_hfyu_left_prediction(buf + 1, buf + 1, width - 1, buf[0]);
285  return;
286  }
287  if (line == 1) {
288  const int HEAD = is_luma ? 4 : 2;
289  int i;
290 
291  L = buf[width - stride - 1];
292  TL = buf[HEAD - stride - 1];
293  for (i = 0; i < HEAD; i++) {
294  L += buf[i];
295  buf[i] = L;
296  }
297  buf += HEAD;
298  width -= HEAD;
299  } else {
300  TL = buf[width - (2 * stride) - 1];
301  L = buf[width - stride - 1];
302  }
303  l->dsp.add_hfyu_median_prediction(buf, buf - stride, buf, width,
304  &L, &TL);
305 }
306 
308  uint8_t *dst, int width, int stride,
309  int esc_count)
310 {
311  int i = 0;
312  int ret = 0;
313 
314  if (!esc_count)
315  esc_count = -1;
316 
317  /* Output any zeros remaining from the previous run */
318 handle_zeros:
319  if (l->zeros_rem) {
320  int count = FFMIN(l->zeros_rem, width - i);
321  memset(dst + i, 0, count);
322  i += count;
323  l->zeros_rem -= count;
324  }
325 
326  while (i < width) {
327  dst[i] = lag_get_rac(rac);
328  ret++;
329 
330  if (dst[i])
331  l->zeros = 0;
332  else
333  l->zeros++;
334 
335  i++;
336  if (l->zeros == esc_count) {
337  int index = lag_get_rac(rac);
338  ret++;
339 
340  l->zeros = 0;
341 
342  l->zeros_rem = lag_calc_zero_run(index);
343  goto handle_zeros;
344  }
345  }
346  return ret;
347 }
348 
350  const uint8_t *src, const uint8_t *src_end,
351  int width, int esc_count)
352 {
353  int i = 0;
354  int count;
355  uint8_t zero_run = 0;
356  const uint8_t *src_start = src;
357  uint8_t mask1 = -(esc_count < 2);
358  uint8_t mask2 = -(esc_count < 3);
359  uint8_t *end = dst + (width - 2);
360 
361 output_zeros:
362  if (l->zeros_rem) {
363  count = FFMIN(l->zeros_rem, width - i);
364  if (end - dst < count) {
365  av_log(l->avctx, AV_LOG_ERROR, "Too many zeros remaining.\n");
366  return AVERROR_INVALIDDATA;
367  }
368 
369  memset(dst, 0, count);
370  l->zeros_rem -= count;
371  dst += count;
372  }
373 
374  while (dst < end) {
375  i = 0;
376  while (!zero_run && dst + i < end) {
377  i++;
378  if (src + i >= src_end)
379  return AVERROR_INVALIDDATA;
380  zero_run =
381  !(src[i] | (src[i + 1] & mask1) | (src[i + 2] & mask2));
382  }
383  if (zero_run) {
384  zero_run = 0;
385  i += esc_count;
386  memcpy(dst, src, i);
387  dst += i;
388  l->zeros_rem = lag_calc_zero_run(src[i]);
389 
390  src += i + 1;
391  goto output_zeros;
392  } else {
393  memcpy(dst, src, i);
394  src += i;
395  dst += i;
396  }
397  }
398  return src_start - src;
399 }
400 
401 
402 
404  int width, int height, int stride,
405  const uint8_t *src, int src_size)
406 {
407  int i = 0;
408  int read = 0;
409  uint32_t length;
410  uint32_t offset = 1;
411  int esc_count = src[0];
412  GetBitContext gb;
413  lag_rac rac;
414  const uint8_t *src_end = src + src_size;
415 
416  rac.avctx = l->avctx;
417  l->zeros = 0;
418 
419  if (esc_count < 4) {
420  length = width * height;
421  if (esc_count && AV_RL32(src + 1) < length) {
422  length = AV_RL32(src + 1);
423  offset += 4;
424  }
425 
426  init_get_bits(&gb, src + offset, src_size * 8);
427 
428  if (lag_read_prob_header(&rac, &gb) < 0)
429  return -1;
430 
431  ff_lag_rac_init(&rac, &gb, length - stride);
432 
433  for (i = 0; i < height; i++)
434  read += lag_decode_line(l, &rac, dst + (i * stride), width,
435  stride, esc_count);
436 
437  if (read > length)
439  "Output more bytes than length (%d of %d)\n", read,
440  length);
441  } else if (esc_count < 8) {
442  esc_count -= 4;
443  if (esc_count > 0) {
444  /* Zero run coding only, no range coding. */
445  for (i = 0; i < height; i++) {
446  int res = lag_decode_zero_run_line(l, dst + (i * stride), src,
447  src_end, width, esc_count);
448  if (res < 0)
449  return res;
450  src += res;
451  }
452  } else {
453  if (src_size < width * height)
454  return AVERROR_INVALIDDATA; // buffer not big enough
455  /* Plane is stored uncompressed */
456  for (i = 0; i < height; i++) {
457  memcpy(dst + (i * stride), src, width);
458  src += width;
459  }
460  }
461  } else if (esc_count == 0xff) {
462  /* Plane is a solid run of given value */
463  for (i = 0; i < height; i++)
464  memset(dst + i * stride, src[1], width);
465  /* Do not apply prediction.
466  Note: memset to 0 above, setting first value to src[1]
467  and applying prediction gives the same result. */
468  return 0;
469  } else {
471  "Invalid zero run escape code! (%#x)\n", esc_count);
472  return -1;
473  }
474 
475  if (l->avctx->pix_fmt != AV_PIX_FMT_YUV422P) {
476  for (i = 0; i < height; i++) {
477  lag_pred_line(l, dst, width, stride, i);
478  dst += stride;
479  }
480  } else {
481  for (i = 0; i < height; i++) {
482  lag_pred_line_yuy2(l, dst, width, stride, i,
483  width == l->avctx->width);
484  dst += stride;
485  }
486  }
487 
488  return 0;
489 }
490 
500  void *data, int *got_frame, AVPacket *avpkt)
501 {
502  const uint8_t *buf = avpkt->data;
503  int buf_size = avpkt->size;
504  LagarithContext *l = avctx->priv_data;
505  AVFrame *const p = &l->picture;
506  uint8_t frametype = 0;
507  uint32_t offset_gu = 0, offset_bv = 0, offset_ry = 9;
508  uint32_t offs[4];
509  uint8_t *srcs[4], *dst;
510  int i, j, planes = 3;
511 
512  AVFrame *picture = data;
513 
514  if (p->data[0])
515  ff_thread_release_buffer(avctx, p);
516 
517  p->reference = 0;
518  p->key_frame = 1;
519 
520  frametype = buf[0];
521 
522  offset_gu = AV_RL32(buf + 1);
523  offset_bv = AV_RL32(buf + 5);
524 
525  switch (frametype) {
526  case FRAME_SOLID_RGBA:
527  avctx->pix_fmt = AV_PIX_FMT_RGB32;
528 
529  if (ff_thread_get_buffer(avctx, p) < 0) {
530  av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
531  return -1;
532  }
533 
534  dst = p->data[0];
535  for (j = 0; j < avctx->height; j++) {
536  for (i = 0; i < avctx->width; i++)
537  AV_WN32(dst + i * 4, offset_gu);
538  dst += p->linesize[0];
539  }
540  break;
541  case FRAME_ARITH_RGBA:
542  avctx->pix_fmt = AV_PIX_FMT_RGB32;
543  planes = 4;
544  offset_ry += 4;
545  offs[3] = AV_RL32(buf + 9);
546  case FRAME_ARITH_RGB24:
547  case FRAME_U_RGB24:
548  if (frametype == FRAME_ARITH_RGB24 || frametype == FRAME_U_RGB24)
549  avctx->pix_fmt = AV_PIX_FMT_RGB24;
550 
551  if (ff_thread_get_buffer(avctx, p) < 0) {
552  av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
553  return -1;
554  }
555 
556  offs[0] = offset_bv;
557  offs[1] = offset_gu;
558  offs[2] = offset_ry;
559 
560  if (!l->rgb_planes) {
561  l->rgb_stride = FFALIGN(avctx->width, 16);
562  l->rgb_planes = av_malloc(l->rgb_stride * avctx->height * planes + 1);
563  if (!l->rgb_planes) {
564  av_log(avctx, AV_LOG_ERROR, "cannot allocate temporary buffer\n");
565  return AVERROR(ENOMEM);
566  }
567  }
568  for (i = 0; i < planes; i++)
569  srcs[i] = l->rgb_planes + (i + 1) * l->rgb_stride * avctx->height - l->rgb_stride;
570  if (offset_ry >= buf_size ||
571  offset_gu >= buf_size ||
572  offset_bv >= buf_size ||
573  (planes == 4 && offs[3] >= buf_size)) {
574  av_log(avctx, AV_LOG_ERROR,
575  "Invalid frame offsets\n");
576  return AVERROR_INVALIDDATA;
577  }
578  for (i = 0; i < planes; i++)
579  lag_decode_arith_plane(l, srcs[i],
580  avctx->width, avctx->height,
581  -l->rgb_stride, buf + offs[i],
582  buf_size - offs[i]);
583  dst = p->data[0];
584  for (i = 0; i < planes; i++)
585  srcs[i] = l->rgb_planes + i * l->rgb_stride * avctx->height;
586  for (j = 0; j < avctx->height; j++) {
587  for (i = 0; i < avctx->width; i++) {
588  uint8_t r, g, b, a;
589  r = srcs[0][i];
590  g = srcs[1][i];
591  b = srcs[2][i];
592  r += g;
593  b += g;
594  if (frametype == FRAME_ARITH_RGBA) {
595  a = srcs[3][i];
596  AV_WN32(dst + i * 4, MKBETAG(a, r, g, b));
597  } else {
598  dst[i * 3 + 0] = r;
599  dst[i * 3 + 1] = g;
600  dst[i * 3 + 2] = b;
601  }
602  }
603  dst += p->linesize[0];
604  for (i = 0; i < planes; i++)
605  srcs[i] += l->rgb_stride;
606  }
607  break;
608  case FRAME_ARITH_YUY2:
609  avctx->pix_fmt = AV_PIX_FMT_YUV422P;
610 
611  if (ff_thread_get_buffer(avctx, p) < 0) {
612  av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
613  return -1;
614  }
615 
616  if (offset_ry >= buf_size ||
617  offset_gu >= buf_size ||
618  offset_bv >= buf_size) {
619  av_log(avctx, AV_LOG_ERROR,
620  "Invalid frame offsets\n");
621  return AVERROR_INVALIDDATA;
622  }
623 
624  lag_decode_arith_plane(l, p->data[0], avctx->width, avctx->height,
625  p->linesize[0], buf + offset_ry,
626  buf_size - offset_ry);
627  lag_decode_arith_plane(l, p->data[1], avctx->width / 2,
628  avctx->height, p->linesize[1],
629  buf + offset_gu, buf_size - offset_gu);
630  lag_decode_arith_plane(l, p->data[2], avctx->width / 2,
631  avctx->height, p->linesize[2],
632  buf + offset_bv, buf_size - offset_bv);
633  break;
634  case FRAME_ARITH_YV12:
635  avctx->pix_fmt = AV_PIX_FMT_YUV420P;
636 
637  if (ff_thread_get_buffer(avctx, p) < 0) {
638  av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
639  return -1;
640  }
641 
642  if (offset_ry >= buf_size ||
643  offset_gu >= buf_size ||
644  offset_bv >= buf_size) {
645  av_log(avctx, AV_LOG_ERROR,
646  "Invalid frame offsets\n");
647  return AVERROR_INVALIDDATA;
648  }
649 
650  lag_decode_arith_plane(l, p->data[0], avctx->width, avctx->height,
651  p->linesize[0], buf + offset_ry,
652  buf_size - offset_ry);
653  lag_decode_arith_plane(l, p->data[2], avctx->width / 2,
654  avctx->height / 2, p->linesize[2],
655  buf + offset_gu, buf_size - offset_gu);
656  lag_decode_arith_plane(l, p->data[1], avctx->width / 2,
657  avctx->height / 2, p->linesize[1],
658  buf + offset_bv, buf_size - offset_bv);
659  break;
660  default:
661  av_log(avctx, AV_LOG_ERROR,
662  "Unsupported Lagarith frame type: %#x\n", frametype);
663  return -1;
664  }
665 
666  *picture = *p;
667  *got_frame = 1;
668 
669  return buf_size;
670 }
671 
673 {
674  LagarithContext *l = avctx->priv_data;
675  l->avctx = avctx;
676 
677  ff_dsputil_init(&l->dsp, avctx);
678 
679  return 0;
680 }
681 
683 {
684  LagarithContext *l = avctx->priv_data;
685 
686  if (l->picture.data[0])
687  ff_thread_release_buffer(avctx, &l->picture);
688  av_freep(&l->rgb_planes);
689 
690  return 0;
691 }
692 
694  .name = "lagarith",
695  .type = AVMEDIA_TYPE_VIDEO,
696  .id = AV_CODEC_ID_LAGARITH,
697  .priv_data_size = sizeof(LagarithContext),
701  .capabilities = CODEC_CAP_DR1 | CODEC_CAP_FRAME_THREADS,
702  .long_name = NULL_IF_CONFIG_SMALL("Lagarith lossless"),
703 };
AVCodecContext * avctx
Definition: lagarithrac.h:40
static uint8_t lag_get_rac(lag_rac *l)
Decode a single byte from the compressed plane described by *l.
Definition: lagarithrac.h:73
void * av_malloc(size_t size)
Allocate a block of size bytes with alignment suitable for all memory accesses (including vectors if ...
Definition: mem.c:61
av_cold void ff_dsputil_init(DSPContext *c, AVCodecContext *avctx)
Definition: dsputil.c:2656
This structure describes decoded (raw) audio or video data.
Definition: avcodec.h:989
void ff_lag_rac_init(lag_rac *l, GetBitContext *gb, int length)
Definition: lagarithrac.c:33
packed RGB 8:8:8, 24bpp, RGBRGB...
Definition: pixfmt.h:67
int size
Definition: avcodec.h:916
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:1533
int stride
Definition: mace.c:144
AVCodec.
Definition: avcodec.h:2960
static int lag_decode_arith_plane(LagarithContext *l, uint8_t *dst, int width, int height, int stride, const uint8_t *src, int src_size)
Definition: lagarith.c:403
DSPContext dsp
Definition: lagarith.c:52
int zeros
number of consecutive zero bytes encountered
Definition: lagarith.c:53
void av_freep(void *arg)
Free a memory block which has been allocated with av_malloc(z)() or av_realloc() and set the pointer ...
Definition: mem.c:151
AVCodec ff_lagarith_decoder
Definition: lagarith.c:693
static int decode(MimicContext *ctx, int quality, int num_coeffs, int is_iframe)
Definition: mimic.c:228
static int lag_decode_zero_run_line(LagarithContext *l, uint8_t *dst, const uint8_t *src, const uint8_t *src_end, int width, int esc_count)
Definition: lagarith.c:349
Lagarith range decoder.
uint8_t bits
Definition: crc.c:31
uint8_t
solid grayscale color frame
Definition: lagarith.c:40
static void lag_pred_line(LagarithContext *l, uint8_t *buf, int width, int stride, int line)
Definition: lagarith.c:246
#define b
Definition: input.c:52
int zeros_rem
number of zero bytes remaining to output
Definition: lagarith.c:54
const char data[16]
Definition: mxf.c:66
unsigned scale
Number of bits of precision in range.
Definition: lagarithrac.h:43
uint8_t * data
Definition: avcodec.h:915
bitstream reader API header.
static int init(AVCodecParserContext *s)
Definition: h264_parser.c:335
#define r
Definition: input.c:51
struct LagarithContext LagarithContext
uncompressed
Definition: lagarith.c:36
LagarithFrameType
Definition: lagarith.c:35
arithmetic coded RGB24
Definition: lagarith.c:39
Multithreading support functions.
int reference
is this picture used as reference The values for this are the same as the MpegEncContext.picture_structure variable, that is 1->top field, 2->bottom field, 3->frame/both fields.
Definition: avcodec.h:1132
static void add_lag_median_prediction(uint8_t *dst, uint8_t *src1, uint8_t *diff, int w, int *left, int *left_top)
Definition: lagarith.c:222
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:88
g
Definition: yuv2rgb.c:540
AVCodecContext * avctx
Definition: lagarith.c:50
Definition: graph2dot.c:48
void av_log(void *avcl, int level, const char *fmt,...)
Definition: log.c:146
int(* add_hfyu_left_prediction)(uint8_t *dst, const uint8_t *src, int w, int left)
Definition: dsputil.h:341
const char * name
Name of the codec implementation.
Definition: avcodec.h:2967
static av_cold int lag_decode_init(AVCodecContext *avctx)
Definition: lagarith.c:672
planar YUV 4:2:2, 16bpp, (1 Cr & Cb sample per 2x1 Y samples)
Definition: pixfmt.h:69
arithmetic coded YV12
Definition: lagarith.c:45
void(* add_hfyu_median_prediction)(uint8_t *dst, const uint8_t *top, const uint8_t *diff, int w, int *left, int *left_top)
Definition: dsputil.h:340
static uint64_t softfloat_reciprocal(uint32_t denom)
Compute the 52bit mantissa of 1/(double)denom.
Definition: lagarith.c:67
static AVFrame * picture
obsolete arithmetic coded RGB (no longer encoded by upstream since version 1.1.0) ...
Definition: lagarith.c:42
int width
picture width / height.
Definition: avcodec.h:1508
arithmetic coded YUY2
Definition: lagarith.c:38
static int lag_decode_frame(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *avpkt)
Decode a frame.
Definition: lagarith.c:499
#define AV_RL32
Definition: intreadwrite.h:146
static int lag_decode_prob(GetBitContext *gb, uint32_t *value)
Definition: lagarith.c:102
#define L(x)
Definition: vp56_arith.h:36
static int width
Definition: utils.c:156
static int lag_decode_line(LagarithContext *l, lag_rac *rac, uint8_t *dst, int width, int stride, int esc_count)
Definition: lagarith.c:307
external API header
uint32_t prob[258]
Table of cumulative probability for each symbol.
Definition: lagarithrac.h:50
int linesize[AV_NUM_DATA_POINTERS]
Size, in bytes, of the data for each picture/channel plane.
Definition: avcodec.h:1008
static uint32_t softfloat_mul(uint32_t x, uint64_t mantissa)
(uint32_t)(x*f), where f has the given mantissa, and exponent 0 Used in combination with softfloat_re...
Definition: lagarith.c:86
main external API structure.
Definition: avcodec.h:1339
static void close(AVCodecParserContext *s)
Definition: h264_parser.c:326
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:268
int index
Definition: gxfenc.c:72
static int init_get_bits(GetBitContext *s, const uint8_t *buffer, int bit_size)
Initialize GetBitContext.
Definition: get_bits.h:372
#define mid_pred
Definition: mathops.h:94
AVFrame picture
Definition: lagarith.c:51
static int lag_read_prob_header(lag_rac *rac, GetBitContext *gb)
Definition: lagarith.c:136
static unsigned int get_bits_long(GetBitContext *s, int n)
Read 0-32 bits.
Definition: get_bits.h:301
uint8_t * rgb_planes
Definition: lagarith.c:55
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: avcodec.h:997
int height
Definition: gxfenc.c:72
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
Definition: pixfmt.h:65
static av_cold int lag_decode_end(AVCodecContext *avctx)
Definition: lagarith.c:682
#define AV_WN32(p, v)
Definition: intreadwrite.h:338
solid non-grayscale color frame
Definition: lagarith.c:41
DSP utils.
void * priv_data
Definition: avcodec.h:1382
static uint8_t lag_calc_zero_run(int8_t x)
Definition: lagarith.c:97
static void lag_pred_line_yuy2(LagarithContext *l, uint8_t *buf, int width, int stride, int line, int is_luma)
Definition: lagarith.c:273
#define av_log2
Definition: intmath.h:85
int key_frame
1 -> keyframe, 0-> not
Definition: avcodec.h:1058
solid RGBA color frame
Definition: lagarith.c:44
arithmetic coded RGBA
Definition: lagarith.c:43
reduced resolution YV12 frame
Definition: lagarith.c:46
unaligned RGB24
Definition: lagarith.c:37
int ff_thread_get_buffer(AVCodecContext *avctx, AVFrame *f)
Wrapper around get_buffer() for frame-multithreaded codecs.
Definition: pthread.c:921
This structure stores compressed data.
Definition: avcodec.h:898
void ff_thread_release_buffer(AVCodecContext *avctx, AVFrame *f)
Wrapper around release_buffer() frame-for multithreaded codecs.
Definition: pthread.c:979
for(j=16;j >0;--j)
DSPContext.
Definition: dsputil.h:194