510a6ff2d6acb0f69278e4b2d4de37d97d9b2d17
[ffmpeg.git] / libavcodec / lagarith.c
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
37 enum LagarithFrameType {
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 {
52     AVCodecContext *avctx;
53     LLVidDSPContext llviddsp;
54     int zeros;                  /**< number of consecutive zero bytes encountered */
55     int zeros_rem;              /**< number of zero bytes remaining to output */
56     uint8_t *rgb_planes;
57     int      rgb_planes_allocated;
58     int rgb_stride;
59 } LagarithContext;
60
61 /**
62  * Compute the 52-bit mantissa of 1/(double)denom.
63  * This crazy format uses floats in an entropy coder and we have to match x86
64  * rounding exactly, thus ordinary floats aren't portable enough.
65  * @param denom denominator
66  * @return 52-bit mantissa
67  * @see softfloat_mul
68  */
69 static uint64_t softfloat_reciprocal(uint32_t denom)
70 {
71     int shift = av_log2(denom - 1) + 1;
72     uint64_t ret = (1ULL << 52) / denom;
73     uint64_t err = (1ULL << 52) - ret * denom;
74     ret <<= shift;
75     err <<= shift;
76     err +=  denom / 2;
77     return ret + err / denom;
78 }
79
80 /**
81  * (uint32_t)(x*f), where f has the given mantissa, and exponent 0
82  * Used in combination with softfloat_reciprocal computes x/(double)denom.
83  * @param x 32-bit integer factor
84  * @param mantissa mantissa of f with exponent 0
85  * @return 32-bit integer value (x*f)
86  * @see softfloat_reciprocal
87  */
88 static uint32_t softfloat_mul(uint32_t x, uint64_t mantissa)
89 {
90     uint64_t l = x * (mantissa & 0xffffffff);
91     uint64_t h = x * (mantissa >> 32);
92     h += l >> 32;
93     l &= 0xffffffff;
94     l += 1LL << av_log2(h >> 21);
95     h += l >> 32;
96     return h >> 20;
97 }
98
99 static uint8_t lag_calc_zero_run(int8_t x)
100 {
101     return (x * 2) ^ (x >> 7);
102 }
103
104 static int lag_decode_prob(GetBitContext *gb, uint32_t *value)
105 {
106     static const uint8_t series[] = { 1, 2, 3, 5, 8, 13, 21 };
107     int i;
108     int bit     = 0;
109     int bits    = 0;
110     int prevbit = 0;
111     unsigned val;
112
113     for (i = 0; i < 7; i++) {
114         if (prevbit && bit)
115             break;
116         prevbit = bit;
117         bit = get_bits1(gb);
118         if (bit && !prevbit)
119             bits += series[i];
120     }
121     bits--;
122     if (bits < 0 || bits > 31) {
123         *value = 0;
124         return -1;
125     } else if (bits == 0) {
126         *value = 0;
127         return 0;
128     }
129
130     val  = get_bits_long(gb, bits);
131     val |= 1U << bits;
132
133     *value = val - 1;
134
135     return 0;
136 }
137
138 static int lag_read_prob_header(lag_rac *rac, GetBitContext *gb)
139 {
140     int i, j, scale_factor;
141     unsigned prob, cumulative_target;
142     unsigned cumul_prob = 0;
143     unsigned scaled_cumul_prob = 0;
144     int nnz = 0;
145
146     rac->prob[0] = 0;
147     rac->prob[257] = UINT_MAX;
148     /* Read probabilities from bitstream */
149     for (i = 1; i < 257; i++) {
150         if (lag_decode_prob(gb, &rac->prob[i]) < 0) {
151             av_log(rac->avctx, AV_LOG_ERROR, "Invalid probability encountered.\n");
152             return -1;
153         }
154         if ((uint64_t)cumul_prob + rac->prob[i] > UINT_MAX) {
155             av_log(rac->avctx, AV_LOG_ERROR, "Integer overflow encountered in cumulative probability calculation.\n");
156             return -1;
157         }
158         cumul_prob += rac->prob[i];
159         if (!rac->prob[i]) {
160             if (lag_decode_prob(gb, &prob)) {
161                 av_log(rac->avctx, AV_LOG_ERROR, "Invalid probability run encountered.\n");
162                 return -1;
163             }
164             if (prob > 256 - i)
165                 prob = 256 - i;
166             for (j = 0; j < prob; j++)
167                 rac->prob[++i] = 0;
168         }else {
169             nnz++;
170         }
171     }
172
173     if (!cumul_prob) {
174         av_log(rac->avctx, AV_LOG_ERROR, "All probabilities are 0!\n");
175         return -1;
176     }
177
178     if (nnz == 1 && (show_bits_long(gb, 32) & 0xFFFFFF)) {
179         return AVERROR_INVALIDDATA;
180     }
181
182     /* Scale probabilities so cumulative probability is an even power of 2. */
183     scale_factor = av_log2(cumul_prob);
184
185     if (cumul_prob & (cumul_prob - 1)) {
186         uint64_t mul = softfloat_reciprocal(cumul_prob);
187         for (i = 1; i <= 128; i++) {
188             rac->prob[i] = softfloat_mul(rac->prob[i], mul);
189             scaled_cumul_prob += rac->prob[i];
190         }
191         if (scaled_cumul_prob <= 0) {
192             av_log(rac->avctx, AV_LOG_ERROR, "Scaled probabilities invalid\n");
193             return AVERROR_INVALIDDATA;
194         }
195         for (; i < 257; i++) {
196             rac->prob[i] = softfloat_mul(rac->prob[i], mul);
197             scaled_cumul_prob += rac->prob[i];
198         }
199
200         scale_factor++;
201         if (scale_factor >= 32U)
202             return AVERROR_INVALIDDATA;
203         cumulative_target = 1U << scale_factor;
204
205         if (scaled_cumul_prob > cumulative_target) {
206             av_log(rac->avctx, AV_LOG_ERROR,
207                    "Scaled probabilities are larger than target!\n");
208             return -1;
209         }
210
211         scaled_cumul_prob = cumulative_target - scaled_cumul_prob;
212
213         for (i = 1; scaled_cumul_prob; i = (i & 0x7f) + 1) {
214             if (rac->prob[i]) {
215                 rac->prob[i]++;
216                 scaled_cumul_prob--;
217             }
218             /* Comment from reference source:
219              * if (b & 0x80 == 0) {     // order of operations is 'wrong'; it has been left this way
220              *                          // since the compression change is negligible and fixing it
221              *                          // breaks backwards compatibility
222              *      b =- (signed int)b;
223              *      b &= 0xFF;
224              * } else {
225              *      b++;
226              *      b &= 0x7f;
227              * }
228              */
229         }
230     }
231
232     rac->scale = scale_factor;
233
234     /* Fill probability array with cumulative probability for each symbol. */
235     for (i = 1; i < 257; i++)
236         rac->prob[i] += rac->prob[i - 1];
237
238     return 0;
239 }
240
241 static void add_lag_median_prediction(uint8_t *dst, uint8_t *src1,
242                                       uint8_t *diff, int w, int *left,
243                                       int *left_top)
244 {
245     /* This is almost identical to add_hfyu_median_pred in huffyuvdsp.h.
246      * However the &0xFF on the gradient predictor yields incorrect output
247      * for lagarith.
248      */
249     int i;
250     uint8_t l, lt;
251
252     l  = *left;
253     lt = *left_top;
254
255     for (i = 0; i < w; i++) {
256         l = mid_pred(l, src1[i], l + src1[i] - lt) + diff[i];
257         lt = src1[i];
258         dst[i] = l;
259     }
260
261     *left     = l;
262     *left_top = lt;
263 }
264
265 static void lag_pred_line(LagarithContext *l, uint8_t *buf,
266                           int width, int stride, int line)
267 {
268     int L, TL;
269
270     if (!line) {
271         /* Left prediction only for first line */
272         L = l->llviddsp.add_left_pred(buf, buf, width, 0);
273     } else {
274         /* Left pixel is actually prev_row[width] */
275         L = buf[width - stride - 1];
276
277         if (line == 1) {
278             /* Second line, left predict first pixel, the rest of the line is median predicted
279              * NOTE: In the case of RGB this pixel is top predicted */
280             TL = l->avctx->pix_fmt == AV_PIX_FMT_YUV420P ? buf[-stride] : L;
281         } else {
282             /* Top left is 2 rows back, last pixel */
283             TL = buf[width - (2 * stride) - 1];
284         }
285
286         add_lag_median_prediction(buf, buf - stride, buf,
287                                   width, &L, &TL);
288     }
289 }
290
291 static void lag_pred_line_yuy2(LagarithContext *l, uint8_t *buf,
292                                int width, int stride, int line,
293                                int is_luma)
294 {
295     int L, TL;
296
297     if (!line) {
298         L= buf[0];
299         if (is_luma)
300             buf[0] = 0;
301         l->llviddsp.add_left_pred(buf, buf, width, 0);
302         if (is_luma)
303             buf[0] = L;
304         return;
305     }
306     if (line == 1) {
307         const int HEAD = is_luma ? 4 : 2;
308         int i;
309
310         L  = buf[width - stride - 1];
311         TL = buf[HEAD  - stride - 1];
312         for (i = 0; i < HEAD; i++) {
313             L += buf[i];
314             buf[i] = L;
315         }
316         for (; i < width; i++) {
317             L      = mid_pred(L & 0xFF, buf[i - stride], (L + buf[i - stride] - TL) & 0xFF) + buf[i];
318             TL     = buf[i - stride];
319             buf[i] = L;
320         }
321     } else {
322         TL = buf[width - (2 * stride) - 1];
323         L  = buf[width - stride - 1];
324         l->llviddsp.add_median_pred(buf, buf - stride, buf, width, &L, &TL);
325     }
326 }
327
328 static int lag_decode_line(LagarithContext *l, lag_rac *rac,
329                            uint8_t *dst, int width, int stride,
330                            int esc_count)
331 {
332     int i = 0;
333     int ret = 0;
334
335     if (!esc_count)
336         esc_count = -1;
337
338     /* Output any zeros remaining from the previous run */
339 handle_zeros:
340     if (l->zeros_rem) {
341         int count = FFMIN(l->zeros_rem, width - i);
342         memset(dst + i, 0, count);
343         i += count;
344         l->zeros_rem -= count;
345     }
346
347     while (i < width) {
348         dst[i] = lag_get_rac(rac);
349         ret++;
350
351         if (dst[i])
352             l->zeros = 0;
353         else
354             l->zeros++;
355
356         i++;
357         if (l->zeros == esc_count) {
358             int index = lag_get_rac(rac);
359             ret++;
360
361             l->zeros = 0;
362
363             l->zeros_rem = lag_calc_zero_run(index);
364             goto handle_zeros;
365         }
366     }
367     return ret;
368 }
369
370 static int lag_decode_zero_run_line(LagarithContext *l, uint8_t *dst,
371                                     const uint8_t *src, const uint8_t *src_end,
372                                     int width, int esc_count)
373 {
374     int i = 0;
375     int count;
376     uint8_t zero_run = 0;
377     const uint8_t *src_start = src;
378     uint8_t mask1 = -(esc_count < 2);
379     uint8_t mask2 = -(esc_count < 3);
380     uint8_t *end = dst + (width - 2);
381
382     avpriv_request_sample(l->avctx, "zero_run_line");
383
384     memset(dst, 0, width);
385
386 output_zeros:
387     if (l->zeros_rem) {
388         count = FFMIN(l->zeros_rem, width - i);
389         if (end - dst < count) {
390             av_log(l->avctx, AV_LOG_ERROR, "Too many zeros remaining.\n");
391             return AVERROR_INVALIDDATA;
392         }
393
394         memset(dst, 0, count);
395         l->zeros_rem -= count;
396         dst += count;
397     }
398
399     while (dst < end) {
400         i = 0;
401         while (!zero_run && dst + i < end) {
402             i++;
403             if (i+2 >= src_end - src)
404                 return AVERROR_INVALIDDATA;
405             zero_run =
406                 !(src[i] | (src[i + 1] & mask1) | (src[i + 2] & mask2));
407         }
408         if (zero_run) {
409             zero_run = 0;
410             i += esc_count;
411             memcpy(dst, src, i);
412             dst += i;
413             l->zeros_rem = lag_calc_zero_run(src[i]);
414
415             src += i + 1;
416             goto output_zeros;
417         } else {
418             memcpy(dst, src, i);
419             src += i;
420             dst += i;
421         }
422     }
423     return  src - src_start;
424 }
425
426
427
428 static int lag_decode_arith_plane(LagarithContext *l, uint8_t *dst,
429                                   int width, int height, int stride,
430                                   const uint8_t *src, int src_size)
431 {
432     int i = 0;
433     int read = 0;
434     uint32_t length;
435     uint32_t offset = 1;
436     int esc_count;
437     GetBitContext gb;
438     lag_rac rac;
439     const uint8_t *src_end = src + src_size;
440     int ret;
441
442     rac.avctx = l->avctx;
443     l->zeros = 0;
444
445     if(src_size < 2)
446         return AVERROR_INVALIDDATA;
447
448     esc_count = src[0];
449     if (esc_count < 4) {
450         length = width * height;
451         if(src_size < 5)
452             return AVERROR_INVALIDDATA;
453         if (esc_count && AV_RL32(src + 1) < length) {
454             length = AV_RL32(src + 1);
455             offset += 4;
456         }
457
458         if ((ret = init_get_bits8(&gb, src + offset, src_size - offset)) < 0)
459             return ret;
460
461         if (lag_read_prob_header(&rac, &gb) < 0)
462             return -1;
463
464         ff_lag_rac_init(&rac, &gb, length - stride);
465         for (i = 0; i < height; i++) {
466             if (rac.overread > MAX_OVERREAD)
467                 return AVERROR_INVALIDDATA;
468             read += lag_decode_line(l, &rac, dst + (i * stride), width,
469                                     stride, esc_count);
470         }
471
472         if (read > length)
473             av_log(l->avctx, AV_LOG_WARNING,
474                    "Output more bytes than length (%d of %"PRIu32")\n", read,
475                    length);
476     } else if (esc_count < 8) {
477         esc_count -= 4;
478         src ++;
479         src_size --;
480         if (esc_count > 0) {
481             /* Zero run coding only, no range coding. */
482             for (i = 0; i < height; i++) {
483                 int res = lag_decode_zero_run_line(l, dst + (i * stride), src,
484                                                    src_end, width, esc_count);
485                 if (res < 0)
486                     return res;
487                 src += res;
488             }
489         } else {
490             if (src_size < width * height)
491                 return AVERROR_INVALIDDATA; // buffer not big enough
492             /* Plane is stored uncompressed */
493             for (i = 0; i < height; i++) {
494                 memcpy(dst + (i * stride), src, width);
495                 src += width;
496             }
497         }
498     } else if (esc_count == 0xff) {
499         /* Plane is a solid run of given value */
500         for (i = 0; i < height; i++)
501             memset(dst + i * stride, src[1], width);
502         /* Do not apply prediction.
503            Note: memset to 0 above, setting first value to src[1]
504            and applying prediction gives the same result. */
505         return 0;
506     } else {
507         av_log(l->avctx, AV_LOG_ERROR,
508                "Invalid zero run escape code! (%#x)\n", esc_count);
509         return -1;
510     }
511
512     if (l->avctx->pix_fmt != AV_PIX_FMT_YUV422P) {
513         for (i = 0; i < height; i++) {
514             lag_pred_line(l, dst, width, stride, i);
515             dst += stride;
516         }
517     } else {
518         for (i = 0; i < height; i++) {
519             lag_pred_line_yuy2(l, dst, width, stride, i,
520                                width == l->avctx->width);
521             dst += stride;
522         }
523     }
524
525     return 0;
526 }
527
528 /**
529  * Decode a frame.
530  * @param avctx codec context
531  * @param data output AVFrame
532  * @param data_size size of output data or 0 if no picture is returned
533  * @param avpkt input packet
534  * @return number of consumed bytes on success or negative if decode fails
535  */
536 static int lag_decode_frame(AVCodecContext *avctx,
537                             void *data, int *got_frame, AVPacket *avpkt)
538 {
539     const uint8_t *buf = avpkt->data;
540     unsigned int buf_size = avpkt->size;
541     LagarithContext *l = avctx->priv_data;
542     ThreadFrame frame = { .f = data };
543     AVFrame *const p  = data;
544     uint8_t frametype;
545     uint32_t offset_gu = 0, offset_bv = 0, offset_ry = 9;
546     uint32_t offs[4];
547     uint8_t *srcs[4], *dst;
548     int i, j, planes = 3;
549     int ret;
550
551     p->key_frame = 1;
552
553     frametype = buf[0];
554
555     offset_gu = AV_RL32(buf + 1);
556     offset_bv = AV_RL32(buf + 5);
557
558     switch (frametype) {
559     case FRAME_SOLID_RGBA:
560         avctx->pix_fmt = AV_PIX_FMT_RGB32;
561     case FRAME_SOLID_GRAY:
562         if (frametype == FRAME_SOLID_GRAY)
563             if (avctx->bits_per_coded_sample == 24) {
564                 avctx->pix_fmt = AV_PIX_FMT_RGB24;
565             } else {
566                 avctx->pix_fmt = AV_PIX_FMT_0RGB32;
567                 planes = 4;
568             }
569
570         if ((ret = ff_thread_get_buffer(avctx, &frame, 0)) < 0)
571             return ret;
572
573         dst = p->data[0];
574         if (frametype == FRAME_SOLID_RGBA) {
575         for (j = 0; j < avctx->height; j++) {
576             for (i = 0; i < avctx->width; i++)
577                 AV_WN32(dst + i * 4, offset_gu);
578             dst += p->linesize[0];
579         }
580         } else {
581             for (j = 0; j < avctx->height; j++) {
582                 memset(dst, buf[1], avctx->width * planes);
583                 dst += p->linesize[0];
584             }
585         }
586         break;
587     case FRAME_SOLID_COLOR:
588         if (avctx->bits_per_coded_sample == 24) {
589             avctx->pix_fmt = AV_PIX_FMT_RGB24;
590         } else {
591             avctx->pix_fmt = AV_PIX_FMT_RGB32;
592             offset_gu |= 0xFFU << 24;
593         }
594
595         if ((ret = ff_thread_get_buffer(avctx, &frame,0)) < 0)
596             return ret;
597
598         dst = p->data[0];
599         for (j = 0; j < avctx->height; j++) {
600             for (i = 0; i < avctx->width; i++)
601                 if (avctx->bits_per_coded_sample == 24) {
602                     AV_WB24(dst + i * 3, offset_gu);
603                 } else {
604                     AV_WN32(dst + i * 4, offset_gu);
605                 }
606             dst += p->linesize[0];
607         }
608         break;
609     case FRAME_ARITH_RGBA:
610         avctx->pix_fmt = AV_PIX_FMT_RGB32;
611         planes = 4;
612         offset_ry += 4;
613         offs[3] = AV_RL32(buf + 9);
614     case FRAME_ARITH_RGB24:
615     case FRAME_U_RGB24:
616         if (frametype == FRAME_ARITH_RGB24 || frametype == FRAME_U_RGB24)
617             avctx->pix_fmt = AV_PIX_FMT_RGB24;
618
619         if ((ret = ff_thread_get_buffer(avctx, &frame, 0)) < 0)
620             return ret;
621
622         offs[0] = offset_bv;
623         offs[1] = offset_gu;
624         offs[2] = offset_ry;
625
626         l->rgb_stride = FFALIGN(avctx->width, 16);
627         av_fast_malloc(&l->rgb_planes, &l->rgb_planes_allocated,
628                        l->rgb_stride * avctx->height * planes + 1);
629         if (!l->rgb_planes) {
630             av_log(avctx, AV_LOG_ERROR, "cannot allocate temporary buffer\n");
631             return AVERROR(ENOMEM);
632         }
633         for (i = 0; i < planes; i++)
634             srcs[i] = l->rgb_planes + (i + 1) * l->rgb_stride * avctx->height - l->rgb_stride;
635         for (i = 0; i < planes; i++)
636             if (buf_size <= offs[i]) {
637                 av_log(avctx, AV_LOG_ERROR,
638                         "Invalid frame offsets\n");
639                 return AVERROR_INVALIDDATA;
640             }
641
642         for (i = 0; i < planes; i++)
643             lag_decode_arith_plane(l, srcs[i],
644                                    avctx->width, avctx->height,
645                                    -l->rgb_stride, buf + offs[i],
646                                    buf_size - offs[i]);
647         dst = p->data[0];
648         for (i = 0; i < planes; i++)
649             srcs[i] = l->rgb_planes + i * l->rgb_stride * avctx->height;
650         for (j = 0; j < avctx->height; j++) {
651             for (i = 0; i < avctx->width; i++) {
652                 uint8_t r, g, b, a;
653                 r = srcs[0][i];
654                 g = srcs[1][i];
655                 b = srcs[2][i];
656                 r += g;
657                 b += g;
658                 if (frametype == FRAME_ARITH_RGBA) {
659                     a = srcs[3][i];
660                     AV_WN32(dst + i * 4, MKBETAG(a, r, g, b));
661                 } else {
662                     dst[i * 3 + 0] = r;
663                     dst[i * 3 + 1] = g;
664                     dst[i * 3 + 2] = b;
665                 }
666             }
667             dst += p->linesize[0];
668             for (i = 0; i < planes; i++)
669                 srcs[i] += l->rgb_stride;
670         }
671         break;
672     case FRAME_ARITH_YUY2:
673         avctx->pix_fmt = AV_PIX_FMT_YUV422P;
674
675         if ((ret = ff_thread_get_buffer(avctx, &frame, 0)) < 0)
676             return ret;
677
678         if (offset_ry >= buf_size ||
679             offset_gu >= buf_size ||
680             offset_bv >= buf_size) {
681             av_log(avctx, AV_LOG_ERROR,
682                    "Invalid frame offsets\n");
683             return AVERROR_INVALIDDATA;
684         }
685
686         lag_decode_arith_plane(l, p->data[0], avctx->width, avctx->height,
687                                p->linesize[0], buf + offset_ry,
688                                buf_size - offset_ry);
689         lag_decode_arith_plane(l, p->data[1], (avctx->width + 1) / 2,
690                                avctx->height, p->linesize[1],
691                                buf + offset_gu, buf_size - offset_gu);
692         lag_decode_arith_plane(l, p->data[2], (avctx->width + 1) / 2,
693                                avctx->height, p->linesize[2],
694                                buf + offset_bv, buf_size - offset_bv);
695         break;
696     case FRAME_ARITH_YV12:
697         avctx->pix_fmt = AV_PIX_FMT_YUV420P;
698
699         if ((ret = ff_thread_get_buffer(avctx, &frame, 0)) < 0)
700             return ret;
701         if (buf_size <= offset_ry || buf_size <= offset_gu || buf_size <= offset_bv) {
702             return AVERROR_INVALIDDATA;
703         }
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         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         lag_decode_arith_plane(l, p->data[2], (avctx->width + 1) / 2,
717                                (avctx->height + 1) / 2, p->linesize[2],
718                                buf + offset_gu, buf_size - offset_gu);
719         lag_decode_arith_plane(l, p->data[1], (avctx->width + 1) / 2,
720                                (avctx->height + 1) / 2, p->linesize[1],
721                                buf + offset_bv, buf_size - offset_bv);
722         break;
723     default:
724         av_log(avctx, AV_LOG_ERROR,
725                "Unsupported Lagarith frame type: %#"PRIx8"\n", frametype);
726         return AVERROR_PATCHWELCOME;
727     }
728
729     *got_frame = 1;
730
731     return buf_size;
732 }
733
734 static av_cold int lag_decode_init(AVCodecContext *avctx)
735 {
736     LagarithContext *l = avctx->priv_data;
737     l->avctx = avctx;
738
739     ff_llviddsp_init(&l->llviddsp);
740
741     return 0;
742 }
743
744 #if HAVE_THREADS
745 static av_cold int lag_decode_init_thread_copy(AVCodecContext *avctx)
746 {
747     LagarithContext *l = avctx->priv_data;
748     l->avctx = avctx;
749
750     return 0;
751 }
752 #endif
753
754 static av_cold int lag_decode_end(AVCodecContext *avctx)
755 {
756     LagarithContext *l = avctx->priv_data;
757
758     av_freep(&l->rgb_planes);
759
760     return 0;
761 }
762
763 AVCodec ff_lagarith_decoder = {
764     .name           = "lagarith",
765     .long_name      = NULL_IF_CONFIG_SMALL("Lagarith lossless"),
766     .type           = AVMEDIA_TYPE_VIDEO,
767     .id             = AV_CODEC_ID_LAGARITH,
768     .priv_data_size = sizeof(LagarithContext),
769     .init           = lag_decode_init,
770     .init_thread_copy = ONLY_IF_THREADS_ENABLED(lag_decode_init_thread_copy),
771     .close          = lag_decode_end,
772     .decode         = lag_decode_frame,
773     .capabilities   = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_FRAME_THREADS,
774 };