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 
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 
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;
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 
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;
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 
715 #if HAVE_THREADS
716 static av_cold int lag_decode_init_thread_copy(AVCodecContext *avctx)
717 {
718  LagarithContext *l = avctx->priv_data;
719  l->avctx = avctx;
720 
721  return 0;
722 }
723 #endif
724 
726  .name = "lagarith",
727  .long_name = NULL_IF_CONFIG_SMALL("Lagarith lossless"),
728  .type = AVMEDIA_TYPE_VIDEO,
729  .id = AV_CODEC_ID_LAGARITH,
730  .priv_data_size = sizeof(LagarithContext),
732  .init_thread_copy = ONLY_IF_THREADS_ENABLED(lag_decode_init_thread_copy),
733  .decode = lag_decode_frame,
735 };
AVCodec
AVCodec.
Definition: avcodec.h:3481
stride
int stride
Definition: mace.c:144
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:182
AV_CODEC_ID_LAGARITH
@ AV_CODEC_ID_LAGARITH
Definition: avcodec.h:365
FRAME_ARITH_YUY2
@ FRAME_ARITH_YUY2
arithmetic coded YUY2
Definition: lagarith.c:40
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
FFSWAP
#define FFSWAP(type, a, b)
Definition: common.h:99
LagarithContext::avctx
AVCodecContext * avctx
Definition: lagarith.c:52
lag_decode_frame
static int lag_decode_frame(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *avpkt)
Decode a frame.
Definition: lagarith.c:536
MAX_OVERREAD
#define MAX_OVERREAD
Definition: lagarithrac.h:51
lagarithrac.h
get_bits_long
static unsigned int get_bits_long(GetBitContext *s, int n)
Read 0-32 bits.
Definition: get_bits.h:546
count
void INT64 INT64 count
Definition: avisynth_c.h:767
end
static av_cold int end(AVCodecContext *avctx)
Definition: avrndec.c:90
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:295
w
uint8_t w
Definition: llviddspenc.c:38
lag_rac::scale
unsigned scale
Number of bits of precision in range.
Definition: lagarithrac.h:43
AVPacket::data
uint8_t * data
Definition: avcodec.h:1477
lag_rac::overread
int overread
Definition: lagarithrac.h:50
data
const char data[16]
Definition: mxf.c:91
lag_get_rac
static uint8_t lag_get_rac(lag_rac *l)
Decode a single byte from the compressed plane described by *l.
Definition: lagarithrac.h:78
lag_decode_zero_run_line
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
lag_rac::prob
uint32_t prob[258]
Table of cumulative probability for each symbol.
Definition: lagarithrac.h:53
lag_decode_init
static av_cold int lag_decode_init(AVCodecContext *avctx)
Definition: lagarith.c:705
thread.h
AVFrame::data
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:309
bit
#define bit(string, value)
Definition: cbs_mpeg2.c:58
add_lag_median_prediction
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
AV_PIX_FMT_GBRAP
@ AV_PIX_FMT_GBRAP
planar GBRA 4:4:4:4 32bpp
Definition: pixfmt.h:215
lag_pred_line_yuy2
static void lag_pred_line_yuy2(LagarithContext *l, uint8_t *buf, int width, int stride, int line, int is_luma)
Definition: lagarith.c:291
U
#define U(x)
Definition: vp56_arith.h:37
LagarithContext::llviddsp
LLVidDSPContext llviddsp
Definition: lagarith.c:53
GetBitContext
Definition: get_bits.h:61
FRAME_ARITH_RGBA
@ FRAME_ARITH_RGBA
arithmetic coded RGBA
Definition: lagarith.c:45
AVFrame::key_frame
int key_frame
1 -> keyframe, 0-> not
Definition: frame.h:373
src
#define src
Definition: vp8dsp.c:254
LLVidDSPContext
Definition: lossless_videodsp.h:31
LLVidDSPContext::add_bytes
void(* add_bytes)(uint8_t *dst, uint8_t *src, ptrdiff_t w)
Definition: lossless_videodsp.h:32
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
buf
void * buf
Definition: avisynth_c.h:766
av_cold
#define av_cold
Definition: attributes.h:84
init_get_bits8
static int init_get_bits8(GetBitContext *s, const uint8_t *buffer, int byte_size)
Initialize GetBitContext.
Definition: get_bits.h:677
width
#define width
bits
uint8_t bits
Definition: vp3data.h:202
get_bits.h
AV_PIX_FMT_YUV420P
@ AV_PIX_FMT_YUV420P
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
Definition: pixfmt.h:66
FRAME_OLD_ARITH_RGB
@ FRAME_OLD_ARITH_RGB
obsolete arithmetic coded RGB (no longer encoded by upstream since version 1.1.0)
Definition: lagarith.c:44
lag_decode_prob
static int lag_decode_prob(GetBitContext *gb, uint32_t *value)
Definition: lagarith.c:101
lag_rac
Definition: lagarithrac.h:39
AV_CODEC_CAP_FRAME_THREADS
#define AV_CODEC_CAP_FRAME_THREADS
Codec supports frame-level multithreading.
Definition: avcodec.h:1037
AVERROR_PATCHWELCOME
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Definition: error.h:62
FRAME_RAW
@ FRAME_RAW
uncompressed
Definition: lagarith.c:38
AV_PICTURE_TYPE_I
@ AV_PICTURE_TYPE_I
Intra.
Definition: avutil.h:274
get_bits1
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:498
mathops.h
lag_calc_zero_run
static uint8_t lag_calc_zero_run(int8_t x)
Definition: lagarith.c:96
ONLY_IF_THREADS_ENABLED
#define ONLY_IF_THREADS_ENABLED(x)
Define a function with only the non-default version specified.
Definition: internal.h:227
ff_thread_get_buffer
int ff_thread_get_buffer(AVCodecContext *avctx, ThreadFrame *f, int flags)
Wrapper around get_buffer() for frame-multithreaded codecs.
Definition: pthread_frame.c:964
lag_decode_line
static int lag_decode_line(LagarithContext *l, lag_rac *rac, uint8_t *dst, int width, int stride, int esc_count)
Definition: lagarith.c:328
index
int index
Definition: gxfenc.c:89
lag_rac::avctx
AVCodecContext * avctx
Definition: lagarithrac.h:40
FRAME_ARITH_RGB24
@ FRAME_ARITH_RGB24
arithmetic coded RGB24
Definition: lagarith.c:41
AVFrame::pict_type
enum AVPictureType pict_type
Picture type of the frame.
Definition: frame.h:378
planes
static const struct @314 planes[]
AV_CODEC_CAP_DR1
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() for allocating buffers and supports custom allocators.
Definition: avcodec.h:981
AVPacket::size
int size
Definition: avcodec.h:1478
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:188
FRAME_REDUCED_RES
@ FRAME_REDUCED_RES
reduced resolution YV12 frame
Definition: lagarith.c:48
ff_lag_rac_init
void ff_lag_rac_init(lag_rac *l, GetBitContext *gb, int length)
Definition: lagarithrac.c:33
init_thread_copy
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 add an init_thread_copy() which re-allocates them for other threads. Add AV_CODEC_CAP_FRAME_THREADS to the codec capabilities. There will be very little speed gain at this point but it should work. If there are inter-frame dependencies
val
const char const char void * val
Definition: avisynth_c.h:863
height
#define height
FFMIN
#define FFMIN(a, b)
Definition: common.h:96
offset
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
Definition: writing_filters.txt:86
line
Definition: graph2dot.c:48
FRAME_ARITH_YV12
@ FRAME_ARITH_YV12
arithmetic coded YV12
Definition: lagarith.c:47
FRAME_U_RGB24
@ FRAME_U_RGB24
unaligned RGB24
Definition: lagarith.c:39
LLVidDSPContext::add_median_pred
void(* add_median_pred)(uint8_t *dst, const uint8_t *top, const uint8_t *diff, ptrdiff_t w, int *left, int *left_top)
Definition: lossless_videodsp.h:34
LLVidDSPContext::add_left_pred
int(* add_left_pred)(uint8_t *dst, const uint8_t *src, ptrdiff_t w, int left)
Definition: lossless_videodsp.h:37
src1
#define src1
Definition: h264pred.c:139
AVCodecContext::bits_per_coded_sample
int bits_per_coded_sample
bits per sample/pixel from the demuxer (needed for huffyuv).
Definition: avcodec.h:2789
FRAME_SOLID_GRAY
@ FRAME_SOLID_GRAY
solid grayscale color frame
Definition: lagarith.c:42
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:259
value
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 value
Definition: writing_filters.txt:86
uint8_t
uint8_t
Definition: audio_convert.c:194
AVCodec::name
const char * name
Name of the codec implementation.
Definition: avcodec.h:3488
AVCodecContext::height
int height
Definition: avcodec.h:1738
AVCodecContext::pix_fmt
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:1775
avcodec.h
mid_pred
#define mid_pred
Definition: mathops.h:97
softfloat_reciprocal
static uint64_t softfloat_reciprocal(uint32_t denom)
Compute the 52-bit mantissa of 1/(double)denom.
Definition: lagarith.c:66
ret
ret
Definition: filter_design.txt:187
frame
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
Definition: filter_design.txt:264
prob
#define prob(name, subs,...)
Definition: cbs_vp9.c:374
FRAME_SOLID_COLOR
@ FRAME_SOLID_COLOR
solid non-grayscale color frame
Definition: lagarith.c:43
left
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:386
AV_RL32
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_RL32
Definition: bytestream.h:88
L
#define L(x)
Definition: vp56_arith.h:36
ff_llviddsp_init
void ff_llviddsp_init(LLVidDSPContext *c)
Definition: lossless_videodsp.c:112
AVCodecContext
main external API structure.
Definition: avcodec.h:1565
LagarithContext
Definition: lagarith.c:51
ThreadFrame
Definition: thread.h:34
LagarithContext::zeros
int zeros
number of consecutive zero bytes encountered
Definition: lagarith.c:54
ff_lagarith_decoder
AVCodec ff_lagarith_decoder
Definition: lagarith.c:725
shift
static int shift(int a, int b)
Definition: sonic.c:82
AV_PIX_FMT_GBRP
@ AV_PIX_FMT_GBRP
planar GBR 4:4:4 24bpp
Definition: pixfmt.h:168
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
AV_PIX_FMT_YUV422P
@ AV_PIX_FMT_YUV422P
planar YUV 4:2:2, 16bpp, (1 Cr & Cb sample per 2x1 Y samples)
Definition: pixfmt.h:70
lossless_videodsp.h
avpriv_request_sample
#define avpriv_request_sample(...)
Definition: tableprint_vlc.h:39
diff
static av_always_inline int diff(const uint32_t a, const uint32_t b)
Definition: vf_palettegen.c:136
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:1592
AVPacket
This structure stores compressed data.
Definition: avcodec.h:1454
LagarithContext::zeros_rem
int zeros_rem
number of zero bytes remaining to output
Definition: lagarith.c:55
AVCodecContext::width
int width
picture width / height.
Definition: avcodec.h:1738
AVFrame::linesize
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
Definition: frame.h:326
softfloat_mul
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
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
length
const char int length
Definition: avisynth_c.h:860
h
h
Definition: vp9dsp_template.c:2038
lag_pred_line
static void lag_pred_line(LagarithContext *l, uint8_t *buf, int width, int stride, int line)
Definition: lagarith.c:265
LagarithFrameType
LagarithFrameType
Definition: lagarith.c:37
lag_decode_arith_plane
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
av_log2
int av_log2(unsigned v)
Definition: intmath.c:26
FRAME_SOLID_RGBA
@ FRAME_SOLID_RGBA
solid RGBA color frame
Definition: lagarith.c:46
lag_read_prob_header
static int lag_read_prob_header(lag_rac *rac, GetBitContext *gb)
Definition: lagarith.c:135