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