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