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 "codec_internal.h"
32 #include "get_bits.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  if (i > end - dst ||
413  i >= src_end - src)
414  return AVERROR_INVALIDDATA;
415  memcpy(dst, src, i);
416  dst += i;
418 
419  src += i + 1;
420  goto output_zeros;
421  } else {
422  memcpy(dst, src, i);
423  src += i;
424  dst += i;
425  }
426  }
427  return src - src_start;
428 }
429 
430 
431 
432 static int lag_decode_arith_plane(LagarithContext *l, uint8_t *dst,
433  int width, int height, int stride,
434  const uint8_t *src, int src_size)
435 {
436  int i = 0;
437  int read = 0;
438  uint32_t length;
439  uint32_t offset = 1;
440  int esc_count;
441  GetBitContext gb;
442  lag_rac rac;
443  const uint8_t *src_end = src + src_size;
444  int ret;
445 
446  rac.avctx = l->avctx;
447  l->zeros = 0;
448 
449  if(src_size < 2)
450  return AVERROR_INVALIDDATA;
451 
452  esc_count = src[0];
453  if (esc_count < 4) {
454  length = width * height;
455  if(src_size < 5)
456  return AVERROR_INVALIDDATA;
457  if (esc_count && AV_RL32(src + 1) < length) {
458  length = AV_RL32(src + 1);
459  offset += 4;
460  }
461 
462  if ((ret = init_get_bits8(&gb, src + offset, src_size - offset)) < 0)
463  return ret;
464 
465  if ((ret = lag_read_prob_header(&rac, &gb)) < 0)
466  return ret;
467 
468  ff_lag_rac_init(&rac, &gb, length - stride);
469  for (i = 0; i < height; i++) {
470  if (rac.overread > MAX_OVERREAD)
471  return AVERROR_INVALIDDATA;
472  read += lag_decode_line(l, &rac, dst + (i * stride), width,
473  stride, esc_count);
474  }
475 
476  if (read > length)
478  "Output more bytes than length (%d of %"PRIu32")\n", read,
479  length);
480  } else if (esc_count < 8) {
481  esc_count -= 4;
482  src ++;
483  src_size --;
484  if (esc_count > 0) {
485  /* Zero run coding only, no range coding. */
486  for (i = 0; i < height; i++) {
487  int res = lag_decode_zero_run_line(l, dst + (i * stride), src,
488  src_end, width, esc_count);
489  if (res < 0)
490  return res;
491  src += res;
492  }
493  } else {
494  if (src_size < width * height)
495  return AVERROR_INVALIDDATA; // buffer not big enough
496  /* Plane is stored uncompressed */
497  for (i = 0; i < height; i++) {
498  memcpy(dst + (i * stride), src, width);
499  src += width;
500  }
501  }
502  } else if (esc_count == 0xff) {
503  /* Plane is a solid run of given value */
504  for (i = 0; i < height; i++)
505  memset(dst + i * stride, src[1], width);
506  /* Do not apply prediction.
507  Note: memset to 0 above, setting first value to src[1]
508  and applying prediction gives the same result. */
509  return 0;
510  } else {
512  "Invalid zero run escape code! (%#x)\n", esc_count);
513  return AVERROR_INVALIDDATA;
514  }
515 
516  if (l->avctx->pix_fmt != AV_PIX_FMT_YUV422P) {
517  for (i = 0; i < height; i++) {
518  lag_pred_line(l, dst, width, stride, i);
519  dst += stride;
520  }
521  } else {
522  for (i = 0; i < height; i++) {
523  lag_pred_line_yuy2(l, dst, width, stride, i,
524  width == l->avctx->width);
525  dst += stride;
526  }
527  }
528 
529  return 0;
530 }
531 
532 /**
533  * Decode a frame.
534  * @param avctx codec context
535  * @param data output AVFrame
536  * @param data_size size of output data or 0 if no picture is returned
537  * @param avpkt input packet
538  * @return number of consumed bytes on success or negative if decode fails
539  */
541  int *got_frame, AVPacket *avpkt)
542 {
543  const uint8_t *buf = avpkt->data;
544  unsigned int buf_size = avpkt->size;
545  LagarithContext *l = avctx->priv_data;
546  uint8_t frametype;
547  uint32_t offset_gu = 0, offset_bv = 0, offset_ry = 9;
548  uint32_t offs[4];
549  uint8_t *srcs[4];
550  int i, j, planes = 3;
551  int ret = 0;
552 
553  p->key_frame = 1;
555 
556  frametype = buf[0];
557 
558  offset_gu = AV_RL32(buf + 1);
559  offset_bv = AV_RL32(buf + 5);
560 
561  switch (frametype) {
562  case FRAME_SOLID_RGBA:
563  avctx->pix_fmt = AV_PIX_FMT_GBRAP;
564  case FRAME_SOLID_GRAY:
565  if (frametype == FRAME_SOLID_GRAY)
566  if (avctx->bits_per_coded_sample == 24) {
567  avctx->pix_fmt = AV_PIX_FMT_GBRP;
568  } else {
569  avctx->pix_fmt = AV_PIX_FMT_GBRAP;
570  planes = 4;
571  }
572 
573  if ((ret = ff_thread_get_buffer(avctx, p, 0)) < 0)
574  return ret;
575 
576  if (frametype == FRAME_SOLID_RGBA) {
577  for (i = 0; i < avctx->height; i++) {
578  memset(p->data[0] + i * p->linesize[0], buf[2], avctx->width);
579  memset(p->data[1] + i * p->linesize[1], buf[1], avctx->width);
580  memset(p->data[2] + i * p->linesize[2], buf[3], avctx->width);
581  memset(p->data[3] + i * p->linesize[3], buf[4], avctx->width);
582  }
583  } else {
584  for (i = 0; i < avctx->height; i++) {
585  for (j = 0; j < planes; j++)
586  memset(p->data[j] + i * p->linesize[j], buf[1], avctx->width);
587  }
588  }
589  break;
590  case FRAME_SOLID_COLOR:
591  if (avctx->bits_per_coded_sample == 24) {
592  avctx->pix_fmt = AV_PIX_FMT_GBRP;
593  } else {
594  avctx->pix_fmt = AV_PIX_FMT_GBRAP;
595  }
596 
597  if ((ret = ff_thread_get_buffer(avctx, p,0)) < 0)
598  return ret;
599 
600  for (i = 0; i < avctx->height; i++) {
601  memset(p->data[0] + i * p->linesize[0], buf[2], avctx->width);
602  memset(p->data[1] + i * p->linesize[1], buf[1], avctx->width);
603  memset(p->data[2] + i * p->linesize[2], buf[3], avctx->width);
604  if (avctx->pix_fmt == AV_PIX_FMT_GBRAP)
605  memset(p->data[3] + i * p->linesize[3], 0xFFu, avctx->width);
606  }
607  break;
608  case FRAME_ARITH_RGBA:
609  avctx->pix_fmt = AV_PIX_FMT_GBRAP;
610  planes = 4;
611  offset_ry += 4;
612  offs[3] = AV_RL32(buf + 9);
613  case FRAME_ARITH_RGB24:
614  case FRAME_U_RGB24:
615  if (frametype == FRAME_ARITH_RGB24 || frametype == FRAME_U_RGB24)
616  avctx->pix_fmt = AV_PIX_FMT_GBRP;
617 
618  if ((ret = ff_thread_get_buffer(avctx, p, 0)) < 0)
619  return ret;
620 
621  offs[0] = offset_bv;
622  offs[1] = offset_gu;
623  offs[2] = offset_ry;
624 
625  for (i = 0; i < planes; i++)
626  srcs[i] = p->data[i] + (avctx->height - 1) * p->linesize[i];
627  for (i = 0; i < planes; i++)
628  if (buf_size <= offs[i]) {
629  av_log(avctx, AV_LOG_ERROR,
630  "Invalid frame offsets\n");
631  return AVERROR_INVALIDDATA;
632  }
633 
634  for (i = 0; i < planes; i++) {
635  ret = lag_decode_arith_plane(l, srcs[i],
636  avctx->width, avctx->height,
637  -p->linesize[i], buf + offs[i],
638  buf_size - offs[i]);
639  if (ret < 0)
640  return ret;
641  }
642  for (i = 0; i < avctx->height; i++) {
643  l->llviddsp.add_bytes(p->data[0] + i * p->linesize[0], p->data[1] + i * p->linesize[1], avctx->width);
644  l->llviddsp.add_bytes(p->data[2] + i * p->linesize[2], p->data[1] + i * p->linesize[1], avctx->width);
645  }
646  FFSWAP(uint8_t*, p->data[0], p->data[1]);
647  FFSWAP(int, p->linesize[0], p->linesize[1]);
648  FFSWAP(uint8_t*, p->data[2], p->data[1]);
649  FFSWAP(int, p->linesize[2], p->linesize[1]);
650  break;
651  case FRAME_ARITH_YUY2:
652  avctx->pix_fmt = AV_PIX_FMT_YUV422P;
653 
654  if ((ret = ff_thread_get_buffer(avctx, p, 0)) < 0)
655  return ret;
656 
657  if (offset_ry >= buf_size ||
658  offset_gu >= buf_size ||
659  offset_bv >= buf_size) {
660  av_log(avctx, AV_LOG_ERROR,
661  "Invalid frame offsets\n");
662  return AVERROR_INVALIDDATA;
663  }
664 
665  ret = lag_decode_arith_plane(l, p->data[0], avctx->width, avctx->height,
666  p->linesize[0], buf + offset_ry,
667  buf_size - offset_ry);
668  if (ret < 0)
669  return ret;
670  ret = lag_decode_arith_plane(l, p->data[1], (avctx->width + 1) / 2,
671  avctx->height, p->linesize[1],
672  buf + offset_gu, buf_size - offset_gu);
673  if (ret < 0)
674  return ret;
675  ret = lag_decode_arith_plane(l, p->data[2], (avctx->width + 1) / 2,
676  avctx->height, p->linesize[2],
677  buf + offset_bv, buf_size - offset_bv);
678  break;
679  case FRAME_ARITH_YV12:
680  avctx->pix_fmt = AV_PIX_FMT_YUV420P;
681 
682  if ((ret = ff_thread_get_buffer(avctx, p, 0)) < 0)
683  return ret;
684 
685  if (offset_ry >= buf_size ||
686  offset_gu >= buf_size ||
687  offset_bv >= buf_size) {
688  av_log(avctx, AV_LOG_ERROR,
689  "Invalid frame offsets\n");
690  return AVERROR_INVALIDDATA;
691  }
692 
693  ret = lag_decode_arith_plane(l, p->data[0], avctx->width, avctx->height,
694  p->linesize[0], buf + offset_ry,
695  buf_size - offset_ry);
696  if (ret < 0)
697  return ret;
698  ret = lag_decode_arith_plane(l, p->data[2], (avctx->width + 1) / 2,
699  (avctx->height + 1) / 2, p->linesize[2],
700  buf + offset_gu, buf_size - offset_gu);
701  if (ret < 0)
702  return ret;
703  ret = lag_decode_arith_plane(l, p->data[1], (avctx->width + 1) / 2,
704  (avctx->height + 1) / 2, p->linesize[1],
705  buf + offset_bv, buf_size - offset_bv);
706  break;
707  default:
708  av_log(avctx, AV_LOG_ERROR,
709  "Unsupported Lagarith frame type: %#"PRIx8"\n", frametype);
710  return AVERROR_PATCHWELCOME;
711  }
712 
713  if (ret < 0)
714  return ret;
715 
716  *got_frame = 1;
717 
718  return buf_size;
719 }
720 
722 {
723  LagarithContext *l = avctx->priv_data;
724  l->avctx = avctx;
725 
727 
728  return 0;
729 }
730 
732  .p.name = "lagarith",
733  CODEC_LONG_NAME("Lagarith lossless"),
734  .p.type = AVMEDIA_TYPE_VIDEO,
735  .p.id = AV_CODEC_ID_LAGARITH,
736  .priv_data_size = sizeof(LagarithContext),
739  .p.capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_FRAME_THREADS,
740 };
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:186
AV_CODEC_ID_LAGARITH
@ AV_CODEC_ID_LAGARITH
Definition: codec_id.h:199
FRAME_ARITH_YUY2
@ FRAME_ARITH_YUY2
arithmetic coded YUY2
Definition: lagarith.c:41
show_bits_long
static unsigned int show_bits_long(GetBitContext *s, int n)
Show 0-32 bits.
Definition: get_bits.h:602
LagarithContext::avctx
AVCodecContext * avctx
Definition: lagarith.c:53
MAX_OVERREAD
#define MAX_OVERREAD
Definition: lagarithrac.h:50
src1
const pixel * src1
Definition: h264pred_template.c:421
lagarithrac.h
get_bits_long
static unsigned int get_bits_long(GetBitContext *s, int n)
Read 0-32 bits.
Definition: get_bits.h:546
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:325
w
uint8_t w
Definition: llviddspenc.c:38
lag_rac::scale
unsigned scale
Number of bits of precision in range.
Definition: lagarithrac.h:42
AVPacket::data
uint8_t * data
Definition: packet.h:374
lag_rac::overread
int overread
Definition: lagarithrac.h:49
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:77
FFCodec
Definition: codec_internal.h:119
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:52
lag_decode_init
static av_cold int lag_decode_init(AVCodecContext *avctx)
Definition: lagarith.c:721
thread.h
AVFrame::data
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:346
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
FFCodec::p
AVCodec p
The public AVCodec.
Definition: codec_internal.h:123
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
LagarithContext::llviddsp
LLVidDSPContext llviddsp
Definition: lagarith.c:54
GetBitContext
Definition: get_bits.h:61
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
lag_decode_frame
static int lag_decode_frame(AVCodecContext *avctx, AVFrame *p, int *got_frame, AVPacket *avpkt)
Decode a frame.
Definition: lagarith.c:540
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:417
val
static double val(void *priv, double ch)
Definition: aeval.c:77
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:667
width
#define width
FF_CODEC_DECODE_CB
#define FF_CODEC_DECODE_CB(func)
Definition: codec_internal.h:298
init
int(* init)(AVBSFContext *ctx)
Definition: dts2pts_bsf.c:363
bits
uint8_t bits
Definition: vp3data.h:128
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
planes
static const struct @345 planes[]
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
CODEC_LONG_NAME
#define CODEC_LONG_NAME(str)
Definition: codec_internal.h:264
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:38
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:498
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
ff_lagarith_decoder
const FFCodec ff_lagarith_decoder
Definition: lagarith.c:731
index
int index
Definition: gxfenc.c:89
lag_rac::avctx
AVCodecContext * avctx
Definition: lagarithrac.h:39
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:422
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:375
codec_internal.h
FRAME_REDUCED_RES
@ FRAME_REDUCED_RES
reduced resolution YV12 frame
Definition: lagarith.c:49
shift
static int shift(int a, int b)
Definition: bonk.c:253
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
AVCodecContext::bits_per_coded_sample
int bits_per_coded_sample
bits per sample/pixel from the demuxer (needed for huffyuv).
Definition: avcodec.h:1444
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:269
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:211
AVCodecContext::height
int height
Definition: avcodec.h:571
AVCodecContext::pix_fmt
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:608
avcodec.h
stride
#define stride
Definition: h264pred_template.c:537
mid_pred
#define mid_pred
Definition: mathops.h:98
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
prob
#define prob(name, subs,...)
Definition: cbs_vp9.c:372
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
U
#define U(x)
Definition: vpx_arith.h:37
ff_llviddsp_init
void ff_llviddsp_init(LLVidDSPContext *c)
Definition: lossless_videodsp.c:113
AVCodecContext
main external API structure.
Definition: avcodec.h:398
LagarithContext
Definition: lagarith.c:52
LagarithContext::zeros
int zeros
number of consecutive zero bytes encountered
Definition: lagarith.c:55
L
#define L(x)
Definition: vpx_arith.h:36
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:36
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:425
AVPacket
This structure stores compressed data.
Definition: packet.h:351
src
INIT_CLIP pixel * src
Definition: h264pred_template.c:418
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:571
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:370
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:27
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:432
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