FFmpeg
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 FFmpeg.
6  *
7  * FFmpeg 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  * FFmpeg 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 FFmpeg; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20  */
21 
22 /**
23  * @file
24  * Lagarith lossless decoder
25  * @author Nathan Caldwell
26  */
27 
28 #include <inttypes.h>
29 
30 #include "avcodec.h"
31 #include "get_bits.h"
32 #include "mathops.h"
33 #include "lagarithrac.h"
34 #include "lossless_videodsp.h"
35 #include "thread.h"
36 
38  FRAME_RAW = 1, /**< uncompressed */
39  FRAME_U_RGB24 = 2, /**< unaligned RGB24 */
40  FRAME_ARITH_YUY2 = 3, /**< arithmetic coded YUY2 */
41  FRAME_ARITH_RGB24 = 4, /**< arithmetic coded RGB24 */
42  FRAME_SOLID_GRAY = 5, /**< solid grayscale color frame */
43  FRAME_SOLID_COLOR = 6, /**< solid non-grayscale color frame */
44  FRAME_OLD_ARITH_RGB = 7, /**< obsolete arithmetic coded RGB (no longer encoded by upstream since version 1.1.0) */
45  FRAME_ARITH_RGBA = 8, /**< arithmetic coded RGBA */
46  FRAME_SOLID_RGBA = 9, /**< solid RGBA color frame */
47  FRAME_ARITH_YV12 = 10, /**< arithmetic coded YV12 */
48  FRAME_REDUCED_RES = 11, /**< reduced resolution YV12 frame */
49 };
50 
51 typedef struct LagarithContext {
54  int zeros; /**< number of consecutive zero bytes encountered */
55  int zeros_rem; /**< number of zero bytes remaining to output */
57 
58 /**
59  * Compute the 52-bit mantissa of 1/(double)denom.
60  * This crazy format uses floats in an entropy coder and we have to match x86
61  * rounding exactly, thus ordinary floats aren't portable enough.
62  * @param denom denominator
63  * @return 52-bit mantissa
64  * @see softfloat_mul
65  */
66 static uint64_t softfloat_reciprocal(uint32_t denom)
67 {
68  int shift = av_log2(denom - 1) + 1;
69  uint64_t ret = (1ULL << 52) / denom;
70  uint64_t err = (1ULL << 52) - ret * denom;
71  ret <<= shift;
72  err <<= shift;
73  err += denom / 2;
74  return ret + err / denom;
75 }
76 
77 /**
78  * (uint32_t)(x*f), where f has the given mantissa, and exponent 0
79  * Used in combination with softfloat_reciprocal computes x/(double)denom.
80  * @param x 32-bit integer factor
81  * @param mantissa mantissa of f with exponent 0
82  * @return 32-bit integer value (x*f)
83  * @see softfloat_reciprocal
84  */
85 static uint32_t softfloat_mul(uint32_t x, uint64_t mantissa)
86 {
87  uint64_t l = x * (mantissa & 0xffffffff);
88  uint64_t h = x * (mantissa >> 32);
89  h += l >> 32;
90  l &= 0xffffffff;
91  l += 1LL << av_log2(h >> 21);
92  h += l >> 32;
93  return h >> 20;
94 }
95 
96 static uint8_t lag_calc_zero_run(int8_t x)
97 {
98  return (x * 2) ^ (x >> 7);
99 }
100 
101 static int lag_decode_prob(GetBitContext *gb, uint32_t *value)
102 {
103  static const uint8_t series[] = { 1, 2, 3, 5, 8, 13, 21 };
104  int i;
105  int bit = 0;
106  int bits = 0;
107  int prevbit = 0;
108  unsigned val;
109 
110  for (i = 0; i < 7; i++) {
111  if (prevbit && bit)
112  break;
113  prevbit = bit;
114  bit = get_bits1(gb);
115  if (bit && !prevbit)
116  bits += series[i];
117  }
118  bits--;
119  if (bits < 0 || bits > 31) {
120  *value = 0;
121  return -1;
122  } else if (bits == 0) {
123  *value = 0;
124  return 0;
125  }
126 
127  val = get_bits_long(gb, bits);
128  val |= 1U << bits;
129 
130  *value = val - 1;
131 
132  return 0;
133 }
134 
136 {
137  int i, j, scale_factor;
138  unsigned prob, cumulative_target;
139  unsigned cumul_prob = 0;
140  unsigned scaled_cumul_prob = 0;
141  int nnz = 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 > 256 - i)
162  prob = 256 - i;
163  for (j = 0; j < prob; j++)
164  rac->prob[++i] = 0;
165  }else {
166  nnz++;
167  }
168  }
169 
170  if (!cumul_prob) {
171  av_log(rac->avctx, AV_LOG_ERROR, "All probabilities are 0!\n");
172  return -1;
173  }
174 
175  if (nnz == 1 && (show_bits_long(gb, 32) & 0xFFFFFF)) {
176  return AVERROR_INVALIDDATA;
177  }
178 
179  /* Scale probabilities so cumulative probability is an even power of 2. */
180  scale_factor = av_log2(cumul_prob);
181 
182  if (cumul_prob & (cumul_prob - 1)) {
183  uint64_t mul = softfloat_reciprocal(cumul_prob);
184  for (i = 1; i <= 128; i++) {
185  rac->prob[i] = softfloat_mul(rac->prob[i], mul);
186  scaled_cumul_prob += rac->prob[i];
187  }
188  if (scaled_cumul_prob <= 0) {
189  av_log(rac->avctx, AV_LOG_ERROR, "Scaled probabilities invalid\n");
190  return AVERROR_INVALIDDATA;
191  }
192  for (; i < 257; i++) {
193  rac->prob[i] = softfloat_mul(rac->prob[i], mul);
194  scaled_cumul_prob += rac->prob[i];
195  }
196 
197  scale_factor++;
198  if (scale_factor >= 32U)
199  return AVERROR_INVALIDDATA;
200  cumulative_target = 1U << scale_factor;
201 
202  if (scaled_cumul_prob > cumulative_target) {
203  av_log(rac->avctx, AV_LOG_ERROR,
204  "Scaled probabilities are larger than target!\n");
205  return -1;
206  }
207 
208  scaled_cumul_prob = cumulative_target - scaled_cumul_prob;
209 
210  for (i = 1; scaled_cumul_prob; i = (i & 0x7f) + 1) {
211  if (rac->prob[i]) {
212  rac->prob[i]++;
213  scaled_cumul_prob--;
214  }
215  /* Comment from reference source:
216  * if (b & 0x80 == 0) { // order of operations is 'wrong'; it has been left this way
217  * // since the compression change is negligible and fixing it
218  * // breaks backwards compatibility
219  * b =- (signed int)b;
220  * b &= 0xFF;
221  * } else {
222  * b++;
223  * b &= 0x7f;
224  * }
225  */
226  }
227  }
228 
229  if (scale_factor > 23)
230  return AVERROR_INVALIDDATA;
231 
232  rac->scale = scale_factor;
233 
234  /* Fill probability array with cumulative probability for each symbol. */
235  for (i = 1; i < 257; i++)
236  rac->prob[i] += rac->prob[i - 1];
237 
238  return 0;
239 }
240 
242  uint8_t *diff, int w, int *left,
243  int *left_top)
244 {
245  /* This is almost identical to add_hfyu_median_pred in huffyuvdsp.h.
246  * However the &0xFF on the gradient predictor yields incorrect output
247  * for lagarith.
248  */
249  int i;
250  uint8_t l, lt;
251 
252  l = *left;
253  lt = *left_top;
254 
255  for (i = 0; i < w; i++) {
256  l = mid_pred(l, src1[i], l + src1[i] - lt) + diff[i];
257  lt = src1[i];
258  dst[i] = l;
259  }
260 
261  *left = l;
262  *left_top = lt;
263 }
264 
265 static void lag_pred_line(LagarithContext *l, uint8_t *buf,
266  int width, int stride, int line)
267 {
268  int L, TL;
269 
270  if (!line) {
271  /* Left prediction only for first line */
272  L = l->llviddsp.add_left_pred(buf, buf, width, 0);
273  } else {
274  /* Left pixel is actually prev_row[width] */
275  L = buf[width - stride - 1];
276 
277  if (line == 1) {
278  /* Second line, left predict first pixel, the rest of the line is median predicted
279  * NOTE: In the case of RGB this pixel is top predicted */
280  TL = l->avctx->pix_fmt == AV_PIX_FMT_YUV420P ? buf[-stride] : L;
281  } else {
282  /* Top left is 2 rows back, last pixel */
283  TL = buf[width - (2 * stride) - 1];
284  }
285 
286  add_lag_median_prediction(buf, buf - stride, buf,
287  width, &L, &TL);
288  }
289 }
290 
292  int width, int stride, int line,
293  int is_luma)
294 {
295  int L, TL;
296 
297  if (!line) {
298  L= buf[0];
299  if (is_luma)
300  buf[0] = 0;
301  l->llviddsp.add_left_pred(buf, buf, width, 0);
302  if (is_luma)
303  buf[0] = L;
304  return;
305  }
306  if (line == 1) {
307  const int HEAD = is_luma ? 4 : 2;
308  int i;
309 
310  L = buf[width - stride - 1];
311  TL = buf[HEAD - stride - 1];
312  for (i = 0; i < HEAD; i++) {
313  L += buf[i];
314  buf[i] = L;
315  }
316  for (; i < width; i++) {
317  L = mid_pred(L & 0xFF, buf[i - stride], (L + buf[i - stride] - TL) & 0xFF) + buf[i];
318  TL = buf[i - stride];
319  buf[i] = L;
320  }
321  } else {
322  TL = buf[width - (2 * stride) - 1];
323  L = buf[width - stride - 1];
324  l->llviddsp.add_median_pred(buf, buf - stride, buf, width, &L, &TL);
325  }
326 }
327 
329  uint8_t *dst, int width, int stride,
330  int esc_count)
331 {
332  int i = 0;
333  int ret = 0;
334 
335  if (!esc_count)
336  esc_count = -1;
337 
338  /* Output any zeros remaining from the previous run */
339 handle_zeros:
340  if (l->zeros_rem) {
341  int count = FFMIN(l->zeros_rem, width - i);
342  memset(dst + i, 0, count);
343  i += count;
344  l->zeros_rem -= count;
345  }
346 
347  while (i < width) {
348  dst[i] = lag_get_rac(rac);
349  ret++;
350 
351  if (dst[i])
352  l->zeros = 0;
353  else
354  l->zeros++;
355 
356  i++;
357  if (l->zeros == esc_count) {
358  int index = lag_get_rac(rac);
359  ret++;
360 
361  l->zeros = 0;
362 
363  l->zeros_rem = lag_calc_zero_run(index);
364  goto handle_zeros;
365  }
366  }
367  return ret;
368 }
369 
371  const uint8_t *src, const uint8_t *src_end,
372  int width, int esc_count)
373 {
374  int i = 0;
375  int count;
376  uint8_t zero_run = 0;
377  const uint8_t *src_start = src;
378  uint8_t mask1 = -(esc_count < 2);
379  uint8_t mask2 = -(esc_count < 3);
380  uint8_t *end = dst + (width - 2);
381 
382  avpriv_request_sample(l->avctx, "zero_run_line");
383 
384  memset(dst, 0, width);
385 
386 output_zeros:
387  if (l->zeros_rem) {
388  count = FFMIN(l->zeros_rem, width - i);
389  if (end - dst < count) {
390  av_log(l->avctx, AV_LOG_ERROR, "Too many zeros remaining.\n");
391  return AVERROR_INVALIDDATA;
392  }
393 
394  memset(dst, 0, count);
395  l->zeros_rem -= count;
396  dst += count;
397  }
398 
399  while (dst < end) {
400  i = 0;
401  while (!zero_run && dst + i < end) {
402  i++;
403  if (i+2 >= src_end - src)
404  return AVERROR_INVALIDDATA;
405  zero_run =
406  !(src[i] | (src[i + 1] & mask1) | (src[i + 2] & mask2));
407  }
408  if (zero_run) {
409  zero_run = 0;
410  i += esc_count;
411  memcpy(dst, src, i);
412  dst += i;
413  l->zeros_rem = lag_calc_zero_run(src[i]);
414 
415  src += i + 1;
416  goto output_zeros;
417  } else {
418  memcpy(dst, src, i);
419  src += i;
420  dst += i;
421  }
422  }
423  return src - src_start;
424 }
425 
426 
427 
429  int width, int height, int stride,
430  const uint8_t *src, int src_size)
431 {
432  int i = 0;
433  int read = 0;
434  uint32_t length;
435  uint32_t offset = 1;
436  int esc_count;
437  GetBitContext gb;
438  lag_rac rac;
439  const uint8_t *src_end = src + src_size;
440  int ret;
441 
442  rac.avctx = l->avctx;
443  l->zeros = 0;
444 
445  if(src_size < 2)
446  return AVERROR_INVALIDDATA;
447 
448  esc_count = src[0];
449  if (esc_count < 4) {
450  length = width * height;
451  if(src_size < 5)
452  return AVERROR_INVALIDDATA;
453  if (esc_count && AV_RL32(src + 1) < length) {
454  length = AV_RL32(src + 1);
455  offset += 4;
456  }
457 
458  if ((ret = init_get_bits8(&gb, src + offset, src_size - offset)) < 0)
459  return ret;
460 
461  if (lag_read_prob_header(&rac, &gb) < 0)
462  return -1;
463 
464  ff_lag_rac_init(&rac, &gb, length - stride);
465  for (i = 0; i < height; i++) {
466  if (rac.overread > MAX_OVERREAD)
467  return AVERROR_INVALIDDATA;
468  read += lag_decode_line(l, &rac, dst + (i * stride), width,
469  stride, esc_count);
470  }
471 
472  if (read > length)
474  "Output more bytes than length (%d of %"PRIu32")\n", read,
475  length);
476  } else if (esc_count < 8) {
477  esc_count -= 4;
478  src ++;
479  src_size --;
480  if (esc_count > 0) {
481  /* Zero run coding only, no range coding. */
482  for (i = 0; i < height; i++) {
483  int res = lag_decode_zero_run_line(l, dst + (i * stride), src,
484  src_end, width, esc_count);
485  if (res < 0)
486  return res;
487  src += res;
488  }
489  } else {
490  if (src_size < width * height)
491  return AVERROR_INVALIDDATA; // buffer not big enough
492  /* Plane is stored uncompressed */
493  for (i = 0; i < height; i++) {
494  memcpy(dst + (i * stride), src, width);
495  src += width;
496  }
497  }
498  } else if (esc_count == 0xff) {
499  /* Plane is a solid run of given value */
500  for (i = 0; i < height; i++)
501  memset(dst + i * stride, src[1], width);
502  /* Do not apply prediction.
503  Note: memset to 0 above, setting first value to src[1]
504  and applying prediction gives the same result. */
505  return 0;
506  } else {
508  "Invalid zero run escape code! (%#x)\n", esc_count);
509  return -1;
510  }
511 
512  if (l->avctx->pix_fmt != AV_PIX_FMT_YUV422P) {
513  for (i = 0; i < height; i++) {
514  lag_pred_line(l, dst, width, stride, i);
515  dst += stride;
516  }
517  } else {
518  for (i = 0; i < height; i++) {
519  lag_pred_line_yuy2(l, dst, width, stride, i,
520  width == l->avctx->width);
521  dst += stride;
522  }
523  }
524 
525  return 0;
526 }
527 
528 /**
529  * Decode a frame.
530  * @param avctx codec context
531  * @param data output AVFrame
532  * @param data_size size of output data or 0 if no picture is returned
533  * @param avpkt input packet
534  * @return number of consumed bytes on success or negative if decode fails
535  */
537  void *data, int *got_frame, AVPacket *avpkt)
538 {
539  const uint8_t *buf = avpkt->data;
540  unsigned int buf_size = avpkt->size;
541  LagarithContext *l = avctx->priv_data;
542  ThreadFrame frame = { .f = data };
543  AVFrame *const p = data;
544  uint8_t frametype;
545  uint32_t offset_gu = 0, offset_bv = 0, offset_ry = 9;
546  uint32_t offs[4];
547  uint8_t *srcs[4];
548  int i, j, planes = 3;
549  int ret;
550 
551  p->key_frame = 1;
553 
554  frametype = buf[0];
555 
556  offset_gu = AV_RL32(buf + 1);
557  offset_bv = AV_RL32(buf + 5);
558 
559  switch (frametype) {
560  case FRAME_SOLID_RGBA:
561  avctx->pix_fmt = AV_PIX_FMT_GBRAP;
562  case FRAME_SOLID_GRAY:
563  if (frametype == FRAME_SOLID_GRAY)
564  if (avctx->bits_per_coded_sample == 24) {
565  avctx->pix_fmt = AV_PIX_FMT_GBRP;
566  } else {
567  avctx->pix_fmt = AV_PIX_FMT_GBRAP;
568  planes = 4;
569  }
570 
571  if ((ret = ff_thread_get_buffer(avctx, &frame, 0)) < 0)
572  return ret;
573 
574  if (frametype == FRAME_SOLID_RGBA) {
575  for (i = 0; i < avctx->height; i++) {
576  memset(p->data[0] + i * p->linesize[0], buf[2], avctx->width);
577  memset(p->data[1] + i * p->linesize[1], buf[1], avctx->width);
578  memset(p->data[2] + i * p->linesize[2], buf[3], avctx->width);
579  memset(p->data[3] + i * p->linesize[3], buf[4], avctx->width);
580  }
581  } else {
582  for (i = 0; i < avctx->height; i++) {
583  for (j = 0; j < planes; j++)
584  memset(p->data[j] + i * p->linesize[j], buf[1], avctx->width);
585  }
586  }
587  break;
588  case FRAME_SOLID_COLOR:
589  if (avctx->bits_per_coded_sample == 24) {
590  avctx->pix_fmt = AV_PIX_FMT_GBRP;
591  } else {
592  avctx->pix_fmt = AV_PIX_FMT_GBRAP;
593  }
594 
595  if ((ret = ff_thread_get_buffer(avctx, &frame,0)) < 0)
596  return ret;
597 
598  for (i = 0; i < avctx->height; i++) {
599  memset(p->data[0] + i * p->linesize[0], buf[2], avctx->width);
600  memset(p->data[1] + i * p->linesize[1], buf[1], avctx->width);
601  memset(p->data[2] + i * p->linesize[2], buf[3], avctx->width);
602  if (avctx->pix_fmt == AV_PIX_FMT_GBRAP)
603  memset(p->data[3] + i * p->linesize[3], 0xFFu, avctx->width);
604  }
605  break;
606  case FRAME_ARITH_RGBA:
607  avctx->pix_fmt = AV_PIX_FMT_GBRAP;
608  planes = 4;
609  offset_ry += 4;
610  offs[3] = AV_RL32(buf + 9);
611  case FRAME_ARITH_RGB24:
612  case FRAME_U_RGB24:
613  if (frametype == FRAME_ARITH_RGB24 || frametype == FRAME_U_RGB24)
614  avctx->pix_fmt = AV_PIX_FMT_GBRP;
615 
616  if ((ret = ff_thread_get_buffer(avctx, &frame, 0)) < 0)
617  return ret;
618 
619  offs[0] = offset_bv;
620  offs[1] = offset_gu;
621  offs[2] = offset_ry;
622 
623  for (i = 0; i < planes; i++)
624  srcs[i] = p->data[i] + (avctx->height - 1) * p->linesize[i];
625  for (i = 0; i < planes; i++)
626  if (buf_size <= offs[i]) {
627  av_log(avctx, AV_LOG_ERROR,
628  "Invalid frame offsets\n");
629  return AVERROR_INVALIDDATA;
630  }
631 
632  for (i = 0; i < planes; i++)
633  lag_decode_arith_plane(l, srcs[i],
634  avctx->width, avctx->height,
635  -p->linesize[i], buf + offs[i],
636  buf_size - offs[i]);
637  for (i = 0; i < avctx->height; i++) {
638  l->llviddsp.add_bytes(p->data[0] + i * p->linesize[0], p->data[1] + i * p->linesize[1], avctx->width);
639  l->llviddsp.add_bytes(p->data[2] + i * p->linesize[2], p->data[1] + i * p->linesize[1], avctx->width);
640  }
641  FFSWAP(uint8_t*, p->data[0], p->data[1]);
642  FFSWAP(int, p->linesize[0], p->linesize[1]);
643  FFSWAP(uint8_t*, p->data[2], p->data[1]);
644  FFSWAP(int, p->linesize[2], p->linesize[1]);
645  break;
646  case FRAME_ARITH_YUY2:
647  avctx->pix_fmt = AV_PIX_FMT_YUV422P;
648 
649  if ((ret = ff_thread_get_buffer(avctx, &frame, 0)) < 0)
650  return ret;
651 
652  if (offset_ry >= buf_size ||
653  offset_gu >= buf_size ||
654  offset_bv >= buf_size) {
655  av_log(avctx, AV_LOG_ERROR,
656  "Invalid frame offsets\n");
657  return AVERROR_INVALIDDATA;
658  }
659 
660  lag_decode_arith_plane(l, p->data[0], avctx->width, avctx->height,
661  p->linesize[0], buf + offset_ry,
662  buf_size - offset_ry);
663  lag_decode_arith_plane(l, p->data[1], (avctx->width + 1) / 2,
664  avctx->height, p->linesize[1],
665  buf + offset_gu, buf_size - offset_gu);
666  lag_decode_arith_plane(l, p->data[2], (avctx->width + 1) / 2,
667  avctx->height, p->linesize[2],
668  buf + offset_bv, buf_size - offset_bv);
669  break;
670  case FRAME_ARITH_YV12:
671  avctx->pix_fmt = AV_PIX_FMT_YUV420P;
672 
673  if ((ret = ff_thread_get_buffer(avctx, &frame, 0)) < 0)
674  return ret;
675 
676  if (offset_ry >= buf_size ||
677  offset_gu >= buf_size ||
678  offset_bv >= buf_size) {
679  av_log(avctx, AV_LOG_ERROR,
680  "Invalid frame offsets\n");
681  return AVERROR_INVALIDDATA;
682  }
683 
684  lag_decode_arith_plane(l, p->data[0], avctx->width, avctx->height,
685  p->linesize[0], buf + offset_ry,
686  buf_size - offset_ry);
687  lag_decode_arith_plane(l, p->data[2], (avctx->width + 1) / 2,
688  (avctx->height + 1) / 2, p->linesize[2],
689  buf + offset_gu, buf_size - offset_gu);
690  lag_decode_arith_plane(l, p->data[1], (avctx->width + 1) / 2,
691  (avctx->height + 1) / 2, p->linesize[1],
692  buf + offset_bv, buf_size - offset_bv);
693  break;
694  default:
695  av_log(avctx, AV_LOG_ERROR,
696  "Unsupported Lagarith frame type: %#"PRIx8"\n", frametype);
697  return AVERROR_PATCHWELCOME;
698  }
699 
700  *got_frame = 1;
701 
702  return buf_size;
703 }
704 
706 {
707  LagarithContext *l = avctx->priv_data;
708  l->avctx = avctx;
709 
711 
712  return 0;
713 }
714 
716  .name = "lagarith",
717  .long_name = NULL_IF_CONFIG_SMALL("Lagarith lossless"),
718  .type = AVMEDIA_TYPE_VIDEO,
719  .id = AV_CODEC_ID_LAGARITH,
720  .priv_data_size = sizeof(LagarithContext),
724 };
static unsigned int show_bits_long(GetBitContext *s, int n)
Show 0-32 bits.
Definition: get_bits.h:602
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:78
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
int(* add_left_pred)(uint8_t *dst, const uint8_t *src, ptrdiff_t w, int left)
static int shift(int a, int b)
Definition: sonic.c:82
This structure describes decoded (raw) audio or video data.
Definition: frame.h:308
ptrdiff_t const GLvoid * data
Definition: opengl_enc.c:100
void ff_lag_rac_init(lag_rac *l, GetBitContext *gb, int length)
Definition: lagarithrac.c:33
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:200
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:35
#define avpriv_request_sample(...)
planar GBR 4:4:4 24bpp
Definition: pixfmt.h:168
static const struct @319 planes[]
int size
Definition: packet.h:364
int av_log2(unsigned v)
Definition: intmath.c:26
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:736
AVCodec.
Definition: codec.h:190
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:428
static void decode(AVCodecContext *dec_ctx, AVPacket *pkt, AVFrame *frame, FILE *outfile)
Definition: decode_audio.c:71
int zeros
number of consecutive zero bytes encountered
Definition: lagarith.c:54
AVCodec ff_lagarith_decoder
Definition: lagarith.c:715
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:370
Lagarith range decoder.
uint8_t
#define av_cold
Definition: attributes.h:88
solid grayscale color frame
Definition: lagarith.c:42
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 offset
static av_cold int end(AVCodecContext *avctx)
Definition: avrndec.c:90
static void lag_pred_line(LagarithContext *l, uint8_t *buf, int width, int stride, int line)
Definition: lagarith.c:265
Multithreading support functions.
int zeros_rem
number of zero bytes remaining to output
Definition: lagarith.c:55
GLsizei GLboolean const GLfloat * value
Definition: opengl_enc.c:108
#define height
unsigned scale
Number of bits of precision in range.
Definition: lagarithrac.h:43
uint8_t * data
Definition: packet.h:363
void(* add_median_pred)(uint8_t *dst, const uint8_t *top, const uint8_t *diff, ptrdiff_t w, int *left, int *left_top)
bitstream reader API header.
int bits_per_coded_sample
bits per sample/pixel from the demuxer (needed for huffyuv).
Definition: avcodec.h:1750
#define av_log(a,...)
#define prob(name, subs,...)
Definition: cbs_vp9.c:373
#define U(x)
Definition: vp56_arith.h:37
#define src
Definition: vp8dsp.c:254
uncompressed
Definition: lagarith.c:38
LagarithFrameType
Definition: lagarith.c:37
arithmetic coded RGB24
Definition: lagarith.c:41
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:194
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:241
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:153
AVCodecContext * avctx
Definition: lagarith.c:52
Definition: graph2dot.c:48
GLsizei GLsizei * length
Definition: opengl_enc.c:114
const char * name
Name of the codec implementation.
Definition: codec.h:197
uint8_t bits
Definition: vp3data.h:202
GLsizei count
Definition: opengl_enc.c:108
#define AV_CODEC_CAP_FRAME_THREADS
Codec supports frame-level multithreading.
Definition: codec.h:106
static av_cold int lag_decode_init(AVCodecContext *avctx)
Definition: lagarith.c:705
planar YUV 4:2:2, 16bpp, (1 Cr & Cb sample per 2x1 Y samples)
Definition: pixfmt.h:70
arithmetic coded YV12
Definition: lagarith.c:47
the pkt_dts and pkt_pts fields in AVFrame will work as usual Restrictions on codec whose streams don t reset across will not work because their bitstreams cannot be decoded in parallel *The contents of buffers must not be read before as well as code calling up to before the decode process starts Call have so the codec calls ff_thread_report set FF_CODEC_CAP_ALLOCATE_PROGRESS in AVCodec caps_internal and use ff_thread_get_buffer() to allocate frames.The frames must then be freed with ff_thread_release_buffer().Otherwise decode directly into the user-supplied frames.Call ff_thread_report_progress() after some part of the current picture has decoded.A good place to put this is where draw_horiz_band() is called-add this if it isn't called anywhere
static uint64_t softfloat_reciprocal(uint32_t denom)
Compute the 52-bit mantissa of 1/(double)denom.
Definition: lagarith.c:66
enum AVPictureType pict_type
Picture type of the frame.
Definition: frame.h:391
obsolete arithmetic coded RGB (no longer encoded by upstream since version 1.1.0) ...
Definition: lagarith.c:44
#define FFMIN(a, b)
Definition: common.h:96
#define width
int width
picture width / height.
Definition: avcodec.h:699
uint8_t w
Definition: llviddspenc.c:38
arithmetic coded YUY2
Definition: lagarith.c:40
static int lag_decode_frame(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *avpkt)
Decode a frame.
Definition: lagarith.c:536
these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several the filter must be ready for frames arriving randomly on any input any filter with several inputs will most likely require some kind of queuing mechanism It is perfectly acceptable to have a limited queue and to drop frames when the inputs are too unbalanced request_frame For filters that do not use the this method is called when a frame is wanted on an output For a it should directly call filter_frame on the corresponding output For a if there are queued frames already one of these frames should be pushed If the filter should request a frame on one of its repeatedly until at least one frame has been pushed Return or at least make progress towards producing a frame
static int lag_decode_prob(GetBitContext *gb, uint32_t *value)
Definition: lagarith.c:101
#define L(x)
Definition: vp56_arith.h:36
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Definition: error.h:62
#define src1
Definition: h264pred.c:139
static int lag_decode_line(LagarithContext *l, lag_rac *rac, uint8_t *dst, int width, int stride, int esc_count)
Definition: lagarith.c:328
Libavcodec external API header.
uint32_t prob[258]
Table of cumulative probability for each symbol.
Definition: lagarithrac.h:53
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
Definition: frame.h:339
static int init_get_bits8(GetBitContext *s, const uint8_t *buffer, int byte_size)
Initialize GetBitContext.
Definition: get_bits.h:677
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:85
main external API structure.
Definition: avcodec.h:526
Tag MUST be and< 10hcoeff half pel interpolation filter coefficients, hcoeff[0] are the 2 middle coefficients[1] are the next outer ones and so on, resulting in a filter like:...eff[2], hcoeff[1], hcoeff[0], hcoeff[0], hcoeff[1], hcoeff[2]...the sign of the coefficients is not explicitly stored but alternates after each coeff and coeff[0] is positive, so...,+,-,+,-,+,+,-,+,-,+,...hcoeff[0] is not explicitly stored but found by subtracting the sum of all stored coefficients with signs from 32 hcoeff[0]=32-hcoeff[1]-hcoeff[2]-...a good choice for hcoeff and htaps is htaps=6 hcoeff={40,-10, 2}an alternative which requires more computations at both encoder and decoder side and may or may not be better is htaps=8 hcoeff={42,-14, 6,-2}ref_frames minimum of the number of available reference frames and max_ref_frames for example the first frame after a key frame always has ref_frames=1spatial_decomposition_type wavelet type 0 is a 9/7 symmetric compact integer wavelet 1 is a 5/3 symmetric compact integer wavelet others are reserved stored as delta from last, last is reset to 0 if always_reset||keyframeqlog quality(logarithmic quantizer scale) stored as delta from last, last is reset to 0 if always_reset||keyframemv_scale stored as delta from last, last is reset to 0 if always_reset||keyframe FIXME check that everything works fine if this changes between framesqbias dequantization bias stored as delta from last, last is reset to 0 if always_reset||keyframeblock_max_depth maximum depth of the block tree stored as delta from last, last is reset to 0 if always_reset||keyframequant_table quantization tableHighlevel bitstream structure:==============================--------------------------------------------|Header|--------------------------------------------|------------------------------------|||Block0||||split?||||yes no||||.........intra?||||:Block01:yes no||||:Block02:.................||||:Block03::y DC::ref index:||||:Block04::cb DC::motion x:||||.........:cr DC::motion y:||||.................|||------------------------------------||------------------------------------|||Block1|||...|--------------------------------------------|------------------------------------|||Y subbands||Cb subbands||Cr subbands||||------||------||------|||||LL0||HL0||||LL0||HL0||||LL0||HL0|||||------||------||------||||------||------||------|||||LH0||HH0||||LH0||HH0||||LH0||HH0|||||------||------||------||||------||------||------|||||HL1||LH1||||HL1||LH1||||HL1||LH1|||||------||------||------||||------||------||------|||||HH1||HL2||||HH1||HL2||||HH1||HL2|||||...||...||...|||------------------------------------|--------------------------------------------Decoding process:=================------------|||Subbands|------------||||------------|Intra DC||||LL0 subband prediction------------|\Dequantization-------------------\||Reference frames|\IDWT|--------------|Motion\|||Frame 0||Frame 1||Compensation.OBMC v-------|--------------|--------------.\------> Frame n output Frame Frame<----------------------------------/|...|-------------------Range Coder:============Binary Range Coder:-------------------The implemented range coder is an adapted version based upon"Range encoding: an algorithm for removing redundancy from a digitised message."by G.N.N.Martin.The symbols encoded by the Snow range coder are bits(0|1).The associated probabilities are not fix but change depending on the symbol mix seen so far.bit seen|new state---------+-----------------------------------------------0|256-state_transition_table[256-old_state];1|state_transition_table[old_state];state_transition_table={0, 0, 0, 0, 0, 0, 0, 0, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 190, 191, 192, 194, 194, 195, 196, 197, 198, 199, 200, 201, 202, 202, 204, 205, 206, 207, 208, 209, 209, 210, 211, 212, 213, 215, 215, 216, 217, 218, 219, 220, 220, 222, 223, 224, 225, 226, 227, 227, 229, 229, 230, 231, 232, 234, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 248, 0, 0, 0, 0, 0, 0, 0};FIXME Range Coding of integers:-------------------------FIXME Neighboring Blocks:===================left and top are set to the respective blocks unless they are outside of the image in which case they are set to the Null block top-left is set to the top left block unless it is outside of the image in which case it is set to the left block if this block has no larger parent block or it is at the left side of its parent block and the top right block is not outside of the image then the top right block is used for top-right else the top-left block is used Null block y, cb, cr are 128 level, ref, mx and my are 0 Motion Vector Prediction:=========================1.the motion vectors of all the neighboring blocks are scaled to compensate for the difference of reference frames scaled_mv=(mv *(256 *(current_reference+1)/(mv.reference+1))+128)> the median of the scaled left
Definition: snow.txt:206
int overread
Definition: lagarithrac.h:50
void ff_llviddsp_init(LLVidDSPContext *c)
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:498
int index
Definition: gxfenc.c:89
#define MAX_OVERREAD
Definition: lagarithrac.h:51
#define mid_pred
Definition: mathops.h:97
static int lag_read_prob_header(lag_rac *rac, GetBitContext *gb)
Definition: lagarith.c:135
static unsigned int get_bits_long(GetBitContext *s, int n)
Read 0-32 bits.
Definition: get_bits.h:546
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:322
GLint GLenum GLboolean GLsizei stride
Definition: opengl_enc.c:104
LLVidDSPContext llviddsp
Definition: lagarith.c:53
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
Definition: pixfmt.h:66
planar GBRA 4:4:4:4 32bpp
Definition: pixfmt.h:215
#define bit(string, value)
Definition: cbs_mpeg2.c:58
solid non-grayscale color frame
Definition: lagarith.c:43
void * priv_data
Definition: avcodec.h:553
static uint8_t lag_calc_zero_run(int8_t x)
Definition: lagarith.c:96
static av_always_inline int diff(const uint32_t a, const uint32_t b)
static void lag_pred_line_yuy2(LagarithContext *l, uint8_t *buf, int width, int stride, int line, int is_luma)
Definition: lagarith.c:291
int key_frame
1 -> keyframe, 0-> not
Definition: frame.h:386
solid RGBA color frame
Definition: lagarith.c:46
arithmetic coded RGBA
Definition: lagarith.c:45
reduced resolution YV12 frame
Definition: lagarith.c:48
unaligned RGB24
Definition: lagarith.c:39
#define FFSWAP(type, a, b)
Definition: common.h:99
#define stride
void(* add_bytes)(uint8_t *dst, uint8_t *src, ptrdiff_t w)
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_RL32
Definition: bytestream.h:87
static double val(void *priv, double ch)
Definition: aeval.c:76
This structure stores compressed data.
Definition: packet.h:340
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() for allocating buffers and supports custom allocators.
Definition: codec.h:50
int i
Definition: input.c:407