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;
59 
68 static uint64_t softfloat_reciprocal(uint32_t denom)
69 {
70  int shift = av_log2(denom - 1) + 1;
71  uint64_t ret = (1ULL << 52) / denom;
72  uint64_t err = (1ULL << 52) - ret * denom;
73  ret <<= shift;
74  err <<= shift;
75  err += denom / 2;
76  return ret + err / denom;
77 }
78 
87 static uint32_t softfloat_mul(uint32_t x, uint64_t mantissa)
88 {
89  uint64_t l = x * (mantissa & 0xffffffff);
90  uint64_t h = x * (mantissa >> 32);
91  h += l >> 32;
92  l &= 0xffffffff;
93  l += 1 << av_log2(h >> 21);
94  h += l >> 32;
95  return h >> 20;
96 }
97 
98 static uint8_t lag_calc_zero_run(int8_t x)
99 {
100  return (x << 1) ^ (x >> 7);
101 }
102 
103 static int lag_decode_prob(GetBitContext *gb, uint32_t *value)
104 {
105  static const uint8_t series[] = { 1, 2, 3, 5, 8, 13, 21 };
106  int i;
107  int bit = 0;
108  int bits = 0;
109  int prevbit = 0;
110  unsigned val;
111 
112  for (i = 0; i < 7; i++) {
113  if (prevbit && bit)
114  break;
115  prevbit = bit;
116  bit = get_bits1(gb);
117  if (bit && !prevbit)
118  bits += series[i];
119  }
120  bits--;
121  if (bits < 0 || bits > 31) {
122  *value = 0;
123  return -1;
124  } else if (bits == 0) {
125  *value = 0;
126  return 0;
127  }
128 
129  val = get_bits_long(gb, bits);
130  val |= 1 << bits;
131 
132  *value = val - 1;
133 
134  return 0;
135 }
136 
138 {
139  int i, j, scale_factor;
140  unsigned prob, cumulative_target;
141  unsigned cumul_prob = 0;
142  unsigned scaled_cumul_prob = 0;
143 
144  rac->prob[0] = 0;
145  rac->prob[257] = UINT_MAX;
146  /* Read probabilities from bitstream */
147  for (i = 1; i < 257; i++) {
148  if (lag_decode_prob(gb, &rac->prob[i]) < 0) {
149  av_log(rac->avctx, AV_LOG_ERROR, "Invalid probability encountered.\n");
150  return -1;
151  }
152  if ((uint64_t)cumul_prob + rac->prob[i] > UINT_MAX) {
153  av_log(rac->avctx, AV_LOG_ERROR, "Integer overflow encountered in cumulative probability calculation.\n");
154  return -1;
155  }
156  cumul_prob += rac->prob[i];
157  if (!rac->prob[i]) {
158  if (lag_decode_prob(gb, &prob)) {
159  av_log(rac->avctx, AV_LOG_ERROR, "Invalid probability run encountered.\n");
160  return -1;
161  }
162  if (prob > 257 - i)
163  prob = 257 - i;
164  for (j = 0; j < prob; j++)
165  rac->prob[++i] = 0;
166  }
167  }
168 
169  if (!cumul_prob) {
170  av_log(rac->avctx, AV_LOG_ERROR, "All probabilities are 0!\n");
171  return -1;
172  }
173 
174  /* Scale probabilities so cumulative probability is an even power of 2. */
175  scale_factor = av_log2(cumul_prob);
176 
177  if (cumul_prob & (cumul_prob - 1)) {
178  uint64_t mul = softfloat_reciprocal(cumul_prob);
179  for (i = 1; i < 257; i++) {
180  rac->prob[i] = softfloat_mul(rac->prob[i], mul);
181  scaled_cumul_prob += rac->prob[i];
182  }
183 
184  scale_factor++;
185  cumulative_target = 1 << scale_factor;
186 
187  if (scaled_cumul_prob > cumulative_target) {
188  av_log(rac->avctx, AV_LOG_ERROR,
189  "Scaled probabilities are larger than target!\n");
190  return -1;
191  }
192 
193  scaled_cumul_prob = cumulative_target - scaled_cumul_prob;
194 
195  for (i = 1; scaled_cumul_prob; i = (i & 0x7f) + 1) {
196  if (rac->prob[i]) {
197  rac->prob[i]++;
198  scaled_cumul_prob--;
199  }
200  /* Comment from reference source:
201  * if (b & 0x80 == 0) { // order of operations is 'wrong'; it has been left this way
202  * // since the compression change is negligible and fixing it
203  * // breaks backwards compatibility
204  * b =- (signed int)b;
205  * b &= 0xFF;
206  * } else {
207  * b++;
208  * b &= 0x7f;
209  * }
210  */
211  }
212  }
213 
214  rac->scale = scale_factor;
215 
216  /* Fill probability array with cumulative probability for each symbol. */
217  for (i = 1; i < 257; i++)
218  rac->prob[i] += rac->prob[i - 1];
219 
220  return 0;
221 }
222 
223 static void add_lag_median_prediction(uint8_t *dst, uint8_t *src1,
224  uint8_t *diff, int w, int *left,
225  int *left_top)
226 {
227  /* This is almost identical to add_hfyu_median_prediction in dsputil.h.
228  * However the &0xFF on the gradient predictor yealds incorrect output
229  * for lagarith.
230  */
231  int i;
232  uint8_t l, lt;
233 
234  l = *left;
235  lt = *left_top;
236 
237  for (i = 0; i < w; i++) {
238  l = mid_pred(l, src1[i], l + src1[i] - lt) + diff[i];
239  lt = src1[i];
240  dst[i] = l;
241  }
242 
243  *left = l;
244  *left_top = lt;
245 }
246 
247 static void lag_pred_line(LagarithContext *l, uint8_t *buf,
248  int width, int stride, int line)
249 {
250  int L, TL;
251 
252  if (!line) {
253  /* Left prediction only for first line */
254  L = l->dsp.add_hfyu_left_prediction(buf + 1, buf + 1,
255  width - 1, buf[0]);
256  } else {
257  /* Left pixel is actually prev_row[width] */
258  L = buf[width - stride - 1];
259 
260  if (line == 1) {
261  /* Second line, left predict first pixel, the rest of the line is median predicted
262  * NOTE: In the case of RGB this pixel is top predicted */
263  TL = l->avctx->pix_fmt == AV_PIX_FMT_YUV420P ? buf[-stride] : L;
264  } else {
265  /* Top left is 2 rows back, last pixel */
266  TL = buf[width - (2 * stride) - 1];
267  }
268 
269  add_lag_median_prediction(buf, buf - stride, buf,
270  width, &L, &TL);
271  }
272 }
273 
275  int width, int stride, int line,
276  int is_luma)
277 {
278  int L, TL;
279 
280  if (!line) {
281  if (is_luma) {
282  buf++;
283  width--;
284  }
285  l->dsp.add_hfyu_left_prediction(buf + 1, buf + 1, width - 1, buf[0]);
286  return;
287  }
288  if (line == 1) {
289  const int HEAD = is_luma ? 4 : 2;
290  int i;
291 
292  L = buf[width - stride - 1];
293  TL = buf[HEAD - stride - 1];
294  for (i = 0; i < HEAD; i++) {
295  L += buf[i];
296  buf[i] = L;
297  }
298  buf += HEAD;
299  width -= HEAD;
300  } else {
301  TL = buf[width - (2 * stride) - 1];
302  L = buf[width - stride - 1];
303  }
304  l->dsp.add_hfyu_median_prediction(buf, buf - stride, buf, width,
305  &L, &TL);
306 }
307 
309  uint8_t *dst, int width, int stride,
310  int esc_count)
311 {
312  int i = 0;
313  int ret = 0;
314 
315  if (!esc_count)
316  esc_count = -1;
317 
318  /* Output any zeros remaining from the previous run */
319 handle_zeros:
320  if (l->zeros_rem) {
321  int count = FFMIN(l->zeros_rem, width - i);
322  memset(dst + i, 0, count);
323  i += count;
324  l->zeros_rem -= count;
325  }
326 
327  while (i < width) {
328  dst[i] = lag_get_rac(rac);
329  ret++;
330 
331  if (dst[i])
332  l->zeros = 0;
333  else
334  l->zeros++;
335 
336  i++;
337  if (l->zeros == esc_count) {
338  int index = lag_get_rac(rac);
339  ret++;
340 
341  l->zeros = 0;
342 
343  l->zeros_rem = lag_calc_zero_run(index);
344  goto handle_zeros;
345  }
346  }
347  return ret;
348 }
349 
351  const uint8_t *src, const uint8_t *src_end,
352  int width, int esc_count)
353 {
354  int i = 0;
355  int count;
356  uint8_t zero_run = 0;
357  const uint8_t *src_start = src;
358  uint8_t mask1 = -(esc_count < 2);
359  uint8_t mask2 = -(esc_count < 3);
360  uint8_t *end = dst + (width - 2);
361 
362 output_zeros:
363  if (l->zeros_rem) {
364  count = FFMIN(l->zeros_rem, width - i);
365  if (end - dst < count) {
366  av_log(l->avctx, AV_LOG_ERROR, "Too many zeros remaining.\n");
367  return AVERROR_INVALIDDATA;
368  }
369 
370  memset(dst, 0, count);
371  l->zeros_rem -= count;
372  dst += count;
373  }
374 
375  while (dst < end) {
376  i = 0;
377  while (!zero_run && dst + i < end) {
378  i++;
379  if (src + i >= src_end)
380  return AVERROR_INVALIDDATA;
381  zero_run =
382  !(src[i] | (src[i + 1] & mask1) | (src[i + 2] & mask2));
383  }
384  if (zero_run) {
385  zero_run = 0;
386  i += esc_count;
387  memcpy(dst, src, i);
388  dst += i;
389  l->zeros_rem = lag_calc_zero_run(src[i]);
390 
391  src += i + 1;
392  goto output_zeros;
393  } else {
394  memcpy(dst, src, i);
395  src += i;
396  dst += i;
397  }
398  }
399  return src_start - src;
400 }
401 
402 
403 
405  int width, int height, int stride,
406  const uint8_t *src, int src_size)
407 {
408  int i = 0;
409  int read = 0;
410  uint32_t length;
411  uint32_t offset = 1;
412  int esc_count = src[0];
413  GetBitContext gb;
414  lag_rac rac;
415  const uint8_t *src_end = src + src_size;
416 
417  rac.avctx = l->avctx;
418  l->zeros = 0;
419 
420  if (esc_count < 4) {
421  length = width * height;
422  if (esc_count && AV_RL32(src + 1) < length) {
423  length = AV_RL32(src + 1);
424  offset += 4;
425  }
426 
427  init_get_bits(&gb, src + offset, src_size * 8);
428 
429  if (lag_read_prob_header(&rac, &gb) < 0)
430  return -1;
431 
432  ff_lag_rac_init(&rac, &gb, length - stride);
433 
434  for (i = 0; i < height; i++)
435  read += lag_decode_line(l, &rac, dst + (i * stride), width,
436  stride, esc_count);
437 
438  if (read > length)
440  "Output more bytes than length (%d of %d)\n", read,
441  length);
442  } else if (esc_count < 8) {
443  esc_count -= 4;
444  if (esc_count > 0) {
445  /* Zero run coding only, no range coding. */
446  for (i = 0; i < height; i++) {
447  int res = lag_decode_zero_run_line(l, dst + (i * stride), src,
448  src_end, width, esc_count);
449  if (res < 0)
450  return res;
451  src += res;
452  }
453  } else {
454  if (src_size < width * height)
455  return AVERROR_INVALIDDATA; // buffer not big enough
456  /* Plane is stored uncompressed */
457  for (i = 0; i < height; i++) {
458  memcpy(dst + (i * stride), src, width);
459  src += width;
460  }
461  }
462  } else if (esc_count == 0xff) {
463  /* Plane is a solid run of given value */
464  for (i = 0; i < height; i++)
465  memset(dst + i * stride, src[1], width);
466  /* Do not apply prediction.
467  Note: memset to 0 above, setting first value to src[1]
468  and applying prediction gives the same result. */
469  return 0;
470  } else {
472  "Invalid zero run escape code! (%#x)\n", esc_count);
473  return -1;
474  }
475 
476  if (l->avctx->pix_fmt != AV_PIX_FMT_YUV422P) {
477  for (i = 0; i < height; i++) {
478  lag_pred_line(l, dst, width, stride, i);
479  dst += stride;
480  }
481  } else {
482  for (i = 0; i < height; i++) {
483  lag_pred_line_yuy2(l, dst, width, stride, i,
484  width == l->avctx->width);
485  dst += stride;
486  }
487  }
488 
489  return 0;
490 }
491 
501  void *data, int *got_frame, AVPacket *avpkt)
502 {
503  const uint8_t *buf = avpkt->data;
504  int buf_size = avpkt->size;
505  LagarithContext *l = avctx->priv_data;
506  AVFrame *const p = &l->picture;
507  uint8_t frametype = 0;
508  uint32_t offset_gu = 0, offset_bv = 0, offset_ry = 9;
509  uint32_t offs[4];
510  uint8_t *srcs[4], *dst;
511  int i, j, planes = 3;
512 
513  AVFrame *picture = data;
514 
515  if (p->data[0])
516  ff_thread_release_buffer(avctx, p);
517 
518  p->reference = 0;
519  p->key_frame = 1;
520 
521  frametype = buf[0];
522 
523  offset_gu = AV_RL32(buf + 1);
524  offset_bv = AV_RL32(buf + 5);
525 
526  switch (frametype) {
527  case FRAME_SOLID_RGBA:
528  avctx->pix_fmt = AV_PIX_FMT_RGB32;
529 
530  if (ff_thread_get_buffer(avctx, p) < 0) {
531  av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
532  return -1;
533  }
534 
535  dst = p->data[0];
536  for (j = 0; j < avctx->height; j++) {
537  for (i = 0; i < avctx->width; i++)
538  AV_WN32(dst + i * 4, offset_gu);
539  dst += p->linesize[0];
540  }
541  break;
542  case FRAME_ARITH_RGBA:
543  avctx->pix_fmt = AV_PIX_FMT_RGB32;
544  planes = 4;
545  offset_ry += 4;
546  offs[3] = AV_RL32(buf + 9);
547  case FRAME_ARITH_RGB24:
548  case FRAME_U_RGB24:
549  if (frametype == FRAME_ARITH_RGB24 || frametype == FRAME_U_RGB24)
550  avctx->pix_fmt = AV_PIX_FMT_RGB24;
551 
552  if (ff_thread_get_buffer(avctx, p) < 0) {
553  av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
554  return -1;
555  }
556 
557  offs[0] = offset_bv;
558  offs[1] = offset_gu;
559  offs[2] = offset_ry;
560 
561  l->rgb_stride = FFALIGN(avctx->width, 16);
563  l->rgb_stride * avctx->height * planes + 1);
564  if (!l->rgb_planes) {
565  av_log(avctx, AV_LOG_ERROR, "cannot allocate temporary buffer\n");
566  return AVERROR(ENOMEM);
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
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:404
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
void av_fast_malloc(void *ptr, unsigned int *size, size_t min_size)
Allocate a buffer, reusing the given one if large enough.
Definition: utils.c:72
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:350
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:247
#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:223
#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
int rgb_planes_allocated
Definition: lagarith.c:56
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:68
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:500
#define AV_RL32
Definition: intreadwrite.h:146
static int lag_decode_prob(GetBitContext *gb, uint32_t *value)
Definition: lagarith.c:103
#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:308
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:87
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:137
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:98
static void lag_pred_line_yuy2(LagarithContext *l, uint8_t *buf, int width, int stride, int line, int is_luma)
Definition: lagarith.c:274
#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