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 "internal.h"
33 #include "mathops.h"
34 #include "lagarithrac.h"
35 #include "lossless_videodsp.h"
36 #include "thread.h"
37 
39  FRAME_RAW = 1, /**< uncompressed */
40  FRAME_U_RGB24 = 2, /**< unaligned RGB24 */
41  FRAME_ARITH_YUY2 = 3, /**< arithmetic coded YUY2 */
42  FRAME_ARITH_RGB24 = 4, /**< arithmetic coded RGB24 */
43  FRAME_SOLID_GRAY = 5, /**< solid grayscale color frame */
44  FRAME_SOLID_COLOR = 6, /**< solid non-grayscale color frame */
45  FRAME_OLD_ARITH_RGB = 7, /**< obsolete arithmetic coded RGB (no longer encoded by upstream since version 1.1.0) */
46  FRAME_ARITH_RGBA = 8, /**< arithmetic coded RGBA */
47  FRAME_SOLID_RGBA = 9, /**< solid RGBA color frame */
48  FRAME_ARITH_YV12 = 10, /**< arithmetic coded YV12 */
49  FRAME_REDUCED_RES = 11, /**< reduced resolution YV12 frame */
50 };
51 
52 typedef struct LagarithContext {
55  int zeros; /**< number of consecutive zero bytes encountered */
56  int zeros_rem; /**< number of zero bytes remaining to output */
58 
59 /**
60  * Compute the 52-bit mantissa of 1/(double)denom.
61  * This crazy format uses floats in an entropy coder and we have to match x86
62  * rounding exactly, thus ordinary floats aren't portable enough.
63  * @param denom denominator
64  * @return 52-bit mantissa
65  * @see softfloat_mul
66  */
67 static uint64_t softfloat_reciprocal(uint32_t denom)
68 {
69  int shift = av_log2(denom - 1) + 1;
70  uint64_t ret = (1ULL << 52) / denom;
71  uint64_t err = (1ULL << 52) - ret * denom;
72  ret <<= shift;
73  err <<= shift;
74  err += denom / 2;
75  return ret + err / denom;
76 }
77 
78 /**
79  * (uint32_t)(x*f), where f has the given mantissa, and exponent 0
80  * Used in combination with softfloat_reciprocal computes x/(double)denom.
81  * @param x 32-bit integer factor
82  * @param mantissa mantissa of f with exponent 0
83  * @return 32-bit integer value (x*f)
84  * @see softfloat_reciprocal
85  */
86 static uint32_t softfloat_mul(uint32_t x, uint64_t mantissa)
87 {
88  uint64_t l = x * (mantissa & 0xffffffff);
89  uint64_t h = x * (mantissa >> 32);
90  h += l >> 32;
91  l &= 0xffffffff;
92  l += 1LL << av_log2(h >> 21);
93  h += l >> 32;
94  return h >> 20;
95 }
96 
97 static uint8_t lag_calc_zero_run(int8_t x)
98 {
99  return (x * 2) ^ (x >> 7);
100 }
101 
102 static int lag_decode_prob(GetBitContext *gb, uint32_t *value)
103 {
104  static const uint8_t series[] = { 1, 2, 3, 5, 8, 13, 21 };
105  int i;
106  int bit = 0;
107  int bits = 0;
108  int prevbit = 0;
109  unsigned val;
110 
111  for (i = 0; i < 7; i++) {
112  if (prevbit && bit)
113  break;
114  prevbit = bit;
115  bit = get_bits1(gb);
116  if (bit && !prevbit)
117  bits += series[i];
118  }
119  bits--;
120  if (bits < 0 || bits > 31) {
121  *value = 0;
122  return AVERROR_INVALIDDATA;
123  } else if (bits == 0) {
124  *value = 0;
125  return 0;
126  }
127 
128  val = get_bits_long(gb, bits);
129  val |= 1U << bits;
130 
131  *value = val - 1;
132 
133  return 0;
134 }
135 
137 {
138  int i, j, scale_factor;
139  unsigned prob, cumulative_target;
140  unsigned cumul_prob = 0;
141  unsigned scaled_cumul_prob = 0;
142  int nnz = 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 AVERROR_INVALIDDATA;
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 AVERROR_INVALIDDATA;
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 AVERROR_INVALIDDATA;
161  }
162  if (prob > 256 - i)
163  prob = 256 - i;
164  for (j = 0; j < prob; j++)
165  rac->prob[++i] = 0;
166  }else {
167  nnz++;
168  }
169  }
170 
171  if (!cumul_prob) {
172  av_log(rac->avctx, AV_LOG_ERROR, "All probabilities are 0!\n");
173  return AVERROR_INVALIDDATA;
174  }
175 
176  if (nnz == 1 && (show_bits_long(gb, 32) & 0xFFFFFF)) {
177  return AVERROR_INVALIDDATA;
178  }
179 
180  /* Scale probabilities so cumulative probability is an even power of 2. */
181  scale_factor = av_log2(cumul_prob);
182 
183  if (cumul_prob & (cumul_prob - 1)) {
184  uint64_t mul = softfloat_reciprocal(cumul_prob);
185  for (i = 1; i <= 128; i++) {
186  rac->prob[i] = softfloat_mul(rac->prob[i], mul);
187  scaled_cumul_prob += rac->prob[i];
188  }
189  if (scaled_cumul_prob <= 0) {
190  av_log(rac->avctx, AV_LOG_ERROR, "Scaled probabilities invalid\n");
191  return AVERROR_INVALIDDATA;
192  }
193  for (; i < 257; i++) {
194  rac->prob[i] = softfloat_mul(rac->prob[i], mul);
195  scaled_cumul_prob += rac->prob[i];
196  }
197 
198  scale_factor++;
199  if (scale_factor >= 32U)
200  return AVERROR_INVALIDDATA;
201  cumulative_target = 1U << scale_factor;
202 
203  if (scaled_cumul_prob > cumulative_target) {
204  av_log(rac->avctx, AV_LOG_ERROR,
205  "Scaled probabilities are larger than target!\n");
206  return AVERROR_INVALIDDATA;
207  }
208 
209  scaled_cumul_prob = cumulative_target - scaled_cumul_prob;
210 
211  for (i = 1; scaled_cumul_prob; i = (i & 0x7f) + 1) {
212  if (rac->prob[i]) {
213  rac->prob[i]++;
214  scaled_cumul_prob--;
215  }
216  /* Comment from reference source:
217  * if (b & 0x80 == 0) { // order of operations is 'wrong'; it has been left this way
218  * // since the compression change is negligible and fixing it
219  * // breaks backwards compatibility
220  * b =- (signed int)b;
221  * b &= 0xFF;
222  * } else {
223  * b++;
224  * b &= 0x7f;
225  * }
226  */
227  }
228  }
229 
230  if (scale_factor > 23)
231  return AVERROR_INVALIDDATA;
232 
233  rac->scale = scale_factor;
234 
235  /* Fill probability array with cumulative probability for each symbol. */
236  for (i = 1; i < 257; i++)
237  rac->prob[i] += rac->prob[i - 1];
238 
239  return 0;
240 }
241 
242 static void add_lag_median_prediction(uint8_t *dst, uint8_t *src1,
243  uint8_t *diff, int w, int *left,
244  int *left_top)
245 {
246  /* This is almost identical to add_hfyu_median_pred in huffyuvdsp.h.
247  * However the &0xFF on the gradient predictor yields incorrect output
248  * for lagarith.
249  */
250  int i;
251  uint8_t l, lt;
252 
253  l = *left;
254  lt = *left_top;
255 
256  for (i = 0; i < w; i++) {
257  l = mid_pred(l, src1[i], l + src1[i] - lt) + diff[i];
258  lt = src1[i];
259  dst[i] = l;
260  }
261 
262  *left = l;
263  *left_top = lt;
264 }
265 
266 static void lag_pred_line(LagarithContext *l, uint8_t *buf,
267  int width, int stride, int line)
268 {
269  int L, TL;
270 
271  if (!line) {
272  /* Left prediction only for first line */
273  L = l->llviddsp.add_left_pred(buf, buf, width, 0);
274  } else {
275  /* Left pixel is actually prev_row[width] */
276  L = buf[width - stride - 1];
277 
278  if (line == 1) {
279  /* Second line, left predict first pixel, the rest of the line is median predicted
280  * NOTE: In the case of RGB this pixel is top predicted */
281  TL = l->avctx->pix_fmt == AV_PIX_FMT_YUV420P ? buf[-stride] : L;
282  } else {
283  /* Top left is 2 rows back, last pixel */
284  TL = buf[width - (2 * stride) - 1];
285  }
286 
287  add_lag_median_prediction(buf, buf - stride, buf,
288  width, &L, &TL);
289  }
290 }
291 
292 static void lag_pred_line_yuy2(LagarithContext *l, uint8_t *buf,
293  int width, int stride, int line,
294  int is_luma)
295 {
296  int L, TL;
297 
298  if (!line) {
299  L= buf[0];
300  if (is_luma)
301  buf[0] = 0;
302  l->llviddsp.add_left_pred(buf, buf, width, 0);
303  if (is_luma)
304  buf[0] = L;
305  return;
306  }
307  if (line == 1) {
308  const int HEAD = is_luma ? 4 : 2;
309  int i;
310 
311  L = buf[width - stride - 1];
312  TL = buf[HEAD - stride - 1];
313  for (i = 0; i < HEAD; i++) {
314  L += buf[i];
315  buf[i] = L;
316  }
317  for (; i < width; i++) {
318  L = mid_pred(L & 0xFF, buf[i - stride], (L + buf[i - stride] - TL) & 0xFF) + buf[i];
319  TL = buf[i - stride];
320  buf[i] = L;
321  }
322  } else {
323  TL = buf[width - (2 * stride) - 1];
324  L = buf[width - stride - 1];
325  l->llviddsp.add_median_pred(buf, buf - stride, buf, width, &L, &TL);
326  }
327 }
328 
330  uint8_t *dst, int width, int stride,
331  int esc_count)
332 {
333  int i = 0;
334  int ret = 0;
335 
336  if (!esc_count)
337  esc_count = -1;
338 
339  /* Output any zeros remaining from the previous run */
340 handle_zeros:
341  if (l->zeros_rem) {
342  int count = FFMIN(l->zeros_rem, width - i);
343  memset(dst + i, 0, count);
344  i += count;
345  l->zeros_rem -= count;
346  }
347 
348  while (i < width) {
349  dst[i] = lag_get_rac(rac);
350  ret++;
351 
352  if (dst[i])
353  l->zeros = 0;
354  else
355  l->zeros++;
356 
357  i++;
358  if (l->zeros == esc_count) {
359  int index = lag_get_rac(rac);
360  ret++;
361 
362  l->zeros = 0;
363 
365  goto handle_zeros;
366  }
367  }
368  return ret;
369 }
370 
371 static int lag_decode_zero_run_line(LagarithContext *l, uint8_t *dst,
372  const uint8_t *src, const uint8_t *src_end,
373  int width, int esc_count)
374 {
375  int i = 0;
376  int count;
377  uint8_t zero_run = 0;
378  const uint8_t *src_start = src;
379  uint8_t mask1 = -(esc_count < 2);
380  uint8_t mask2 = -(esc_count < 3);
381  uint8_t *end = dst + (width - 2);
382 
383  avpriv_request_sample(l->avctx, "zero_run_line");
384 
385  memset(dst, 0, width);
386 
387 output_zeros:
388  if (l->zeros_rem) {
389  count = FFMIN(l->zeros_rem, width - i);
390  if (end - dst < count) {
391  av_log(l->avctx, AV_LOG_ERROR, "Too many zeros remaining.\n");
392  return AVERROR_INVALIDDATA;
393  }
394 
395  memset(dst, 0, count);
396  l->zeros_rem -= count;
397  dst += count;
398  }
399 
400  while (dst < end) {
401  i = 0;
402  while (!zero_run && dst + i < end) {
403  i++;
404  if (i+2 >= src_end - src)
405  return AVERROR_INVALIDDATA;
406  zero_run =
407  !(src[i] | (src[i + 1] & mask1) | (src[i + 2] & mask2));
408  }
409  if (zero_run) {
410  zero_run = 0;
411  i += esc_count;
412  memcpy(dst, src, i);
413  dst += i;
415 
416  src += i + 1;
417  goto output_zeros;
418  } else {
419  memcpy(dst, src, i);
420  src += i;
421  dst += i;
422  }
423  }
424  return src - src_start;
425 }
426 
427 
428 
429 static int lag_decode_arith_plane(LagarithContext *l, uint8_t *dst,
430  int width, int height, int stride,
431  const uint8_t *src, int src_size)
432 {
433  int i = 0;
434  int read = 0;
435  uint32_t length;
436  uint32_t offset = 1;
437  int esc_count;
438  GetBitContext gb;
439  lag_rac rac;
440  const uint8_t *src_end = src + src_size;
441  int ret;
442 
443  rac.avctx = l->avctx;
444  l->zeros = 0;
445 
446  if(src_size < 2)
447  return AVERROR_INVALIDDATA;
448 
449  esc_count = src[0];
450  if (esc_count < 4) {
451  length = width * height;
452  if(src_size < 5)
453  return AVERROR_INVALIDDATA;
454  if (esc_count && AV_RL32(src + 1) < length) {
455  length = AV_RL32(src + 1);
456  offset += 4;
457  }
458 
459  if ((ret = init_get_bits8(&gb, src + offset, src_size - offset)) < 0)
460  return ret;
461 
462  if ((ret = lag_read_prob_header(&rac, &gb)) < 0)
463  return ret;
464 
465  ff_lag_rac_init(&rac, &gb, length - stride);
466  for (i = 0; i < height; i++) {
467  if (rac.overread > MAX_OVERREAD)
468  return AVERROR_INVALIDDATA;
469  read += lag_decode_line(l, &rac, dst + (i * stride), width,
470  stride, esc_count);
471  }
472 
473  if (read > length)
475  "Output more bytes than length (%d of %"PRIu32")\n", read,
476  length);
477  } else if (esc_count < 8) {
478  esc_count -= 4;
479  src ++;
480  src_size --;
481  if (esc_count > 0) {
482  /* Zero run coding only, no range coding. */
483  for (i = 0; i < height; i++) {
484  int res = lag_decode_zero_run_line(l, dst + (i * stride), src,
485  src_end, width, esc_count);
486  if (res < 0)
487  return res;
488  src += res;
489  }
490  } else {
491  if (src_size < width * height)
492  return AVERROR_INVALIDDATA; // buffer not big enough
493  /* Plane is stored uncompressed */
494  for (i = 0; i < height; i++) {
495  memcpy(dst + (i * stride), src, width);
496  src += width;
497  }
498  }
499  } else if (esc_count == 0xff) {
500  /* Plane is a solid run of given value */
501  for (i = 0; i < height; i++)
502  memset(dst + i * stride, src[1], width);
503  /* Do not apply prediction.
504  Note: memset to 0 above, setting first value to src[1]
505  and applying prediction gives the same result. */
506  return 0;
507  } else {
509  "Invalid zero run escape code! (%#x)\n", esc_count);
510  return AVERROR_INVALIDDATA;
511  }
512 
513  if (l->avctx->pix_fmt != AV_PIX_FMT_YUV422P) {
514  for (i = 0; i < height; i++) {
515  lag_pred_line(l, dst, width, stride, i);
516  dst += stride;
517  }
518  } else {
519  for (i = 0; i < height; i++) {
520  lag_pred_line_yuy2(l, dst, width, stride, i,
521  width == l->avctx->width);
522  dst += stride;
523  }
524  }
525 
526  return 0;
527 }
528 
529 /**
530  * Decode a frame.
531  * @param avctx codec context
532  * @param data output AVFrame
533  * @param data_size size of output data or 0 if no picture is returned
534  * @param avpkt input packet
535  * @return number of consumed bytes on success or negative if decode fails
536  */
538  void *data, int *got_frame, AVPacket *avpkt)
539 {
540  const uint8_t *buf = avpkt->data;
541  unsigned int buf_size = avpkt->size;
542  LagarithContext *l = avctx->priv_data;
543  ThreadFrame frame = { .f = data };
544  AVFrame *const p = data;
545  uint8_t frametype;
546  uint32_t offset_gu = 0, offset_bv = 0, offset_ry = 9;
547  uint32_t offs[4];
548  uint8_t *srcs[4];
549  int i, j, planes = 3;
550  int ret = 0;
551 
552  p->key_frame = 1;
554 
555  frametype = buf[0];
556 
557  offset_gu = AV_RL32(buf + 1);
558  offset_bv = AV_RL32(buf + 5);
559 
560  switch (frametype) {
561  case FRAME_SOLID_RGBA:
562  avctx->pix_fmt = AV_PIX_FMT_GBRAP;
563  case FRAME_SOLID_GRAY:
564  if (frametype == FRAME_SOLID_GRAY)
565  if (avctx->bits_per_coded_sample == 24) {
566  avctx->pix_fmt = AV_PIX_FMT_GBRP;
567  } else {
568  avctx->pix_fmt = AV_PIX_FMT_GBRAP;
569  planes = 4;
570  }
571 
572  if ((ret = ff_thread_get_buffer(avctx, &frame, 0)) < 0)
573  return ret;
574 
575  if (frametype == FRAME_SOLID_RGBA) {
576  for (i = 0; i < avctx->height; i++) {
577  memset(p->data[0] + i * p->linesize[0], buf[2], avctx->width);
578  memset(p->data[1] + i * p->linesize[1], buf[1], avctx->width);
579  memset(p->data[2] + i * p->linesize[2], buf[3], avctx->width);
580  memset(p->data[3] + i * p->linesize[3], buf[4], avctx->width);
581  }
582  } else {
583  for (i = 0; i < avctx->height; i++) {
584  for (j = 0; j < planes; j++)
585  memset(p->data[j] + i * p->linesize[j], buf[1], avctx->width);
586  }
587  }
588  break;
589  case FRAME_SOLID_COLOR:
590  if (avctx->bits_per_coded_sample == 24) {
591  avctx->pix_fmt = AV_PIX_FMT_GBRP;
592  } else {
593  avctx->pix_fmt = AV_PIX_FMT_GBRAP;
594  }
595 
596  if ((ret = ff_thread_get_buffer(avctx, &frame,0)) < 0)
597  return ret;
598 
599  for (i = 0; i < avctx->height; i++) {
600  memset(p->data[0] + i * p->linesize[0], buf[2], avctx->width);
601  memset(p->data[1] + i * p->linesize[1], buf[1], avctx->width);
602  memset(p->data[2] + i * p->linesize[2], buf[3], avctx->width);
603  if (avctx->pix_fmt == AV_PIX_FMT_GBRAP)
604  memset(p->data[3] + i * p->linesize[3], 0xFFu, avctx->width);
605  }
606  break;
607  case FRAME_ARITH_RGBA:
608  avctx->pix_fmt = AV_PIX_FMT_GBRAP;
609  planes = 4;
610  offset_ry += 4;
611  offs[3] = AV_RL32(buf + 9);
612  case FRAME_ARITH_RGB24:
613  case FRAME_U_RGB24:
614  if (frametype == FRAME_ARITH_RGB24 || frametype == FRAME_U_RGB24)
615  avctx->pix_fmt = AV_PIX_FMT_GBRP;
616 
617  if ((ret = ff_thread_get_buffer(avctx, &frame, 0)) < 0)
618  return ret;
619 
620  offs[0] = offset_bv;
621  offs[1] = offset_gu;
622  offs[2] = offset_ry;
623 
624  for (i = 0; i < planes; i++)
625  srcs[i] = p->data[i] + (avctx->height - 1) * p->linesize[i];
626  for (i = 0; i < planes; i++)
627  if (buf_size <= offs[i]) {
628  av_log(avctx, AV_LOG_ERROR,
629  "Invalid frame offsets\n");
630  return AVERROR_INVALIDDATA;
631  }
632 
633  for (i = 0; i < planes; i++) {
634  ret = lag_decode_arith_plane(l, srcs[i],
635  avctx->width, avctx->height,
636  -p->linesize[i], buf + offs[i],
637  buf_size - offs[i]);
638  if (ret < 0)
639  return ret;
640  }
641  for (i = 0; i < avctx->height; i++) {
642  l->llviddsp.add_bytes(p->data[0] + i * p->linesize[0], p->data[1] + i * p->linesize[1], avctx->width);
643  l->llviddsp.add_bytes(p->data[2] + i * p->linesize[2], p->data[1] + i * p->linesize[1], avctx->width);
644  }
645  FFSWAP(uint8_t*, p->data[0], p->data[1]);
646  FFSWAP(int, p->linesize[0], p->linesize[1]);
647  FFSWAP(uint8_t*, p->data[2], p->data[1]);
648  FFSWAP(int, p->linesize[2], p->linesize[1]);
649  break;
650  case FRAME_ARITH_YUY2:
651  avctx->pix_fmt = AV_PIX_FMT_YUV422P;
652 
653  if ((ret = ff_thread_get_buffer(avctx, &frame, 0)) < 0)
654  return ret;
655 
656  if (offset_ry >= buf_size ||
657  offset_gu >= buf_size ||
658  offset_bv >= buf_size) {
659  av_log(avctx, AV_LOG_ERROR,
660  "Invalid frame offsets\n");
661  return AVERROR_INVALIDDATA;
662  }
663 
664  ret = lag_decode_arith_plane(l, p->data[0], avctx->width, avctx->height,
665  p->linesize[0], buf + offset_ry,
666  buf_size - offset_ry);
667  if (ret < 0)
668  return ret;
669  ret = lag_decode_arith_plane(l, p->data[1], (avctx->width + 1) / 2,
670  avctx->height, p->linesize[1],
671  buf + offset_gu, buf_size - offset_gu);
672  if (ret < 0)
673  return ret;
674  ret = lag_decode_arith_plane(l, p->data[2], (avctx->width + 1) / 2,
675  avctx->height, p->linesize[2],
676  buf + offset_bv, buf_size - offset_bv);
677  break;
678  case FRAME_ARITH_YV12:
679  avctx->pix_fmt = AV_PIX_FMT_YUV420P;
680 
681  if ((ret = ff_thread_get_buffer(avctx, &frame, 0)) < 0)
682  return ret;
683 
684  if (offset_ry >= buf_size ||
685  offset_gu >= buf_size ||
686  offset_bv >= buf_size) {
687  av_log(avctx, AV_LOG_ERROR,
688  "Invalid frame offsets\n");
689  return AVERROR_INVALIDDATA;
690  }
691 
692  ret = lag_decode_arith_plane(l, p->data[0], avctx->width, avctx->height,
693  p->linesize[0], buf + offset_ry,
694  buf_size - offset_ry);
695  if (ret < 0)
696  return ret;
697  ret = lag_decode_arith_plane(l, p->data[2], (avctx->width + 1) / 2,
698  (avctx->height + 1) / 2, p->linesize[2],
699  buf + offset_gu, buf_size - offset_gu);
700  if (ret < 0)
701  return ret;
702  ret = lag_decode_arith_plane(l, p->data[1], (avctx->width + 1) / 2,
703  (avctx->height + 1) / 2, p->linesize[1],
704  buf + offset_bv, buf_size - offset_bv);
705  break;
706  default:
707  av_log(avctx, AV_LOG_ERROR,
708  "Unsupported Lagarith frame type: %#"PRIx8"\n", frametype);
709  return AVERROR_PATCHWELCOME;
710  }
711 
712  if (ret < 0)
713  return ret;
714 
715  *got_frame = 1;
716 
717  return buf_size;
718 }
719 
721 {
722  LagarithContext *l = avctx->priv_data;
723  l->avctx = avctx;
724 
726 
727  return 0;
728 }
729 
731  .name = "lagarith",
732  .long_name = NULL_IF_CONFIG_SMALL("Lagarith lossless"),
733  .type = AVMEDIA_TYPE_VIDEO,
734  .id = AV_CODEC_ID_LAGARITH,
735  .priv_data_size = sizeof(LagarithContext),
739  .caps_internal = FF_CODEC_CAP_INIT_THREADSAFE,
740 };
AVCodec
AVCodec.
Definition: codec.h:202
stride
int stride
Definition: mace.c:144
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:186
FF_CODEC_CAP_INIT_THREADSAFE
#define FF_CODEC_CAP_INIT_THREADSAFE
The codec does not modify any global variables in the init function, allowing to call the init functi...
Definition: internal.h:42
AV_CODEC_ID_LAGARITH
@ AV_CODEC_ID_LAGARITH
Definition: codec_id.h:197
FRAME_ARITH_YUY2
@ FRAME_ARITH_YUY2
arithmetic coded YUY2
Definition: lagarith.c:41
init
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:31
show_bits_long
static unsigned int show_bits_long(GetBitContext *s, int n)
Show 0-32 bits.
Definition: get_bits.h:603
LagarithContext::avctx
AVCodecContext * avctx
Definition: lagarith.c:53
lag_decode_frame
static int lag_decode_frame(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *avpkt)
Decode a frame.
Definition: lagarith.c:537
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:547
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:310
index
fg index
Definition: ffmpeg_filter.c:168
w
uint8_t w
Definition: llviddspenc.c:38
internal.h
lag_rac::scale
unsigned scale
Number of bits of precision in range.
Definition: lagarithrac.h:43
AVPacket::data
uint8_t * data
Definition: packet.h:373
lag_rac::overread
int overread
Definition: lagarithrac.h:50
data
const char data[16]
Definition: mxf.c:143
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:371
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:720
thread.h
AVFrame::data
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:329
planes
static const struct @320 planes[]
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:242
AV_PIX_FMT_GBRAP
@ AV_PIX_FMT_GBRAP
planar GBRA 4:4:4:4 32bpp
Definition: pixfmt.h:205
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:292
U
#define U(x)
Definition: vp56_arith.h:37
LagarithContext::llviddsp
LLVidDSPContext llviddsp
Definition: lagarith.c:54
GetBitContext
Definition: get_bits.h:62
ff_thread_get_buffer
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
FRAME_ARITH_RGBA
@ FRAME_ARITH_RGBA
arithmetic coded RGBA
Definition: lagarith.c:46
AVFrame::key_frame
int key_frame
1 -> keyframe, 0-> not
Definition: frame.h:400
val
static double val(void *priv, double ch)
Definition: aeval.c:76
LLVidDSPContext
Definition: lossless_videodsp.h:28
LLVidDSPContext::add_bytes
void(* add_bytes)(uint8_t *dst, uint8_t *src, ptrdiff_t w)
Definition: lossless_videodsp.h:29
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:180
av_cold
#define av_cold
Definition: attributes.h:90
init_get_bits8
static int init_get_bits8(GetBitContext *s, const uint8_t *buffer, int byte_size)
Initialize GetBitContext.
Definition: get_bits.h:678
decode
static void decode(AVCodecContext *dec_ctx, AVPacket *pkt, AVFrame *frame, FILE *outfile)
Definition: decode_audio.c:71
width
#define width
bits
uint8_t bits
Definition: vp3data.h:141
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:45
lag_decode_prob
static int lag_decode_prob(GetBitContext *gb, uint32_t *value)
Definition: lagarith.c:102
mul
static float mul(float src0, float src1)
Definition: dnn_backend_native_layer_mathbinary.c:39
lag_rac
Definition: lagarithrac.h:39
AV_CODEC_CAP_FRAME_THREADS
#define AV_CODEC_CAP_FRAME_THREADS
Codec supports frame-level multithreading.
Definition: codec.h:113
AVERROR_PATCHWELCOME
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Definition: error.h:64
FRAME_RAW
@ FRAME_RAW
uncompressed
Definition: lagarith.c:39
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:499
src
#define src
Definition: vp8dsp.c:255
mathops.h
lag_calc_zero_run
static uint8_t lag_calc_zero_run(int8_t x)
Definition: lagarith.c:97
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:329
lag_rac::avctx
AVCodecContext * avctx
Definition: lagarithrac.h:40
FRAME_ARITH_RGB24
@ FRAME_ARITH_RGB24
arithmetic coded RGB24
Definition: lagarith.c:42
AVFrame::pict_type
enum AVPictureType pict_type
Picture type of the frame.
Definition: frame.h:405
AV_CODEC_CAP_DR1
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() or get_encode_buffer() for allocating buffers and supports custom allocators.
Definition: codec.h:52
AVPacket::size
int size
Definition: packet.h:374
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:117
FRAME_REDUCED_RES
@ FRAME_REDUCED_RES
reduced resolution YV12 frame
Definition: lagarith.c:49
ff_lag_rac_init
void ff_lag_rac_init(lag_rac *l, GetBitContext *gb, int length)
Definition: lagarithrac.c:33
height
#define height
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:48
FRAME_U_RGB24
@ FRAME_U_RGB24
unaligned RGB24
Definition: lagarith.c:40
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:31
LLVidDSPContext::add_left_pred
int(* add_left_pred)(uint8_t *dst, const uint8_t *src, ptrdiff_t w, int left)
Definition: lossless_videodsp.h:34
src1
#define src1
Definition: h264pred.c:140
AVCodecContext::bits_per_coded_sample
int bits_per_coded_sample
bits per sample/pixel from the demuxer (needed for huffyuv).
Definition: avcodec.h:1418
FRAME_SOLID_GRAY
@ FRAME_SOLID_GRAY
solid grayscale color frame
Definition: lagarith.c:43
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:271
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
FFMIN
#define FFMIN(a, b)
Definition: macros.h:49
AVCodec::name
const char * name
Name of the codec implementation.
Definition: codec.h:209
AVCodecContext::height
int height
Definition: avcodec.h:556
AVCodecContext::pix_fmt
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:593
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:67
ret
ret
Definition: filter_design.txt:187
FFSWAP
#define FFSWAP(type, a, b)
Definition: macros.h:52
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:373
FRAME_SOLID_COLOR
@ FRAME_SOLID_COLOR
solid non-grayscale color frame
Definition: lagarith.c:44
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:92
L
#define L(x)
Definition: vp56_arith.h:36
ff_llviddsp_init
void ff_llviddsp_init(LLVidDSPContext *c)
Definition: lossless_videodsp.c:113
AVCodecContext
main external API structure.
Definition: avcodec.h:383
LagarithContext
Definition: lagarith.c:52
ThreadFrame
Definition: thread.h:34
LagarithContext::zeros
int zeros
number of consecutive zero bytes encountered
Definition: lagarith.c:55
shift
static int shift(int a, int b)
Definition: sonic.c:83
AV_PIX_FMT_GBRP
@ AV_PIX_FMT_GBRP
planar GBR 4:4:4 24bpp
Definition: pixfmt.h:158
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:37
diff
static av_always_inline int diff(const uint32_t a, const uint32_t b)
Definition: vf_palettegen.c:139
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:410
AVPacket
This structure stores compressed data.
Definition: packet.h:350
ff_lagarith_decoder
const AVCodec ff_lagarith_decoder
Definition: lagarith.c:730
LagarithContext::zeros_rem
int zeros_rem
number of zero bytes remaining to output
Definition: lagarith.c:56
AVCodecContext::width
int width
picture width / height.
Definition: avcodec.h:556
AVFrame::linesize
int linesize[AV_NUM_DATA_POINTERS]
For video, a positive or negative value, which is typically indicating the size in bytes of each pict...
Definition: frame.h:353
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:86
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:61
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:266
LagarithFrameType
LagarithFrameType
Definition: lagarith.c:38
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:429
av_log2
int av_log2(unsigned v)
Definition: intmath.c:26
FRAME_SOLID_RGBA
@ FRAME_SOLID_RGBA
solid RGBA color frame
Definition: lagarith.c:47
lag_read_prob_header
static int lag_read_prob_header(lag_rac *rac, GetBitContext *gb)
Definition: lagarith.c:136