25e32a60551fba8d4a59ceeb5e43f4d5bb3a598e
[ffmpeg.git] / libavcodec / utvideodec.c
1 /*
2  * Ut Video decoder
3  * Copyright (c) 2011 Konstantin Shishkov
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  * Ut Video decoder
25  */
26
27 #include <inttypes.h>
28 #include <stdlib.h>
29
30 #include "libavutil/intreadwrite.h"
31 #include "avcodec.h"
32 #include "bswapdsp.h"
33 #include "bytestream.h"
34 #include "get_bits.h"
35 #include "internal.h"
36 #include "thread.h"
37 #include "utvideo.h"
38
39 static int build_huff10(const uint8_t *src, VLC *vlc, int *fsym)
40 {
41     int i;
42     HuffEntry he[1024];
43     int last;
44     uint32_t codes[1024];
45     uint8_t bits[1024];
46     uint16_t syms[1024];
47     uint32_t code;
48
49     *fsym = -1;
50     for (i = 0; i < 1024; i++) {
51         he[i].sym = i;
52         he[i].len = *src++;
53     }
54     qsort(he, 1024, sizeof(*he), ff_ut10_huff_cmp_len);
55
56     if (!he[0].len) {
57         *fsym = he[0].sym;
58         return 0;
59     }
60
61     last = 1023;
62     while (he[last].len == 255 && last)
63         last--;
64
65     if (he[last].len > 32) {
66         return -1;
67     }
68
69     code = 1;
70     for (i = last; i >= 0; i--) {
71         codes[i] = code >> (32 - he[i].len);
72         bits[i]  = he[i].len;
73         syms[i]  = he[i].sym;
74         code += 0x80000000u >> (he[i].len - 1);
75     }
76
77     return ff_init_vlc_sparse(vlc, FFMIN(he[last].len, 11), last + 1,
78                               bits,  sizeof(*bits),  sizeof(*bits),
79                               codes, sizeof(*codes), sizeof(*codes),
80                               syms,  sizeof(*syms),  sizeof(*syms), 0);
81 }
82
83 static int build_huff(const uint8_t *src, VLC *vlc, int *fsym)
84 {
85     int i;
86     HuffEntry he[256];
87     int last;
88     uint32_t codes[256];
89     uint8_t bits[256];
90     uint8_t syms[256];
91     uint32_t code;
92
93     *fsym = -1;
94     for (i = 0; i < 256; i++) {
95         he[i].sym = i;
96         he[i].len = *src++;
97     }
98     qsort(he, 256, sizeof(*he), ff_ut_huff_cmp_len);
99
100     if (!he[0].len) {
101         *fsym = he[0].sym;
102         return 0;
103     }
104
105     last = 255;
106     while (he[last].len == 255 && last)
107         last--;
108
109     if (he[last].len > 32)
110         return -1;
111
112     code = 1;
113     for (i = last; i >= 0; i--) {
114         codes[i] = code >> (32 - he[i].len);
115         bits[i]  = he[i].len;
116         syms[i]  = he[i].sym;
117         code += 0x80000000u >> (he[i].len - 1);
118     }
119
120     return ff_init_vlc_sparse(vlc, FFMIN(he[last].len, 11), last + 1,
121                               bits,  sizeof(*bits),  sizeof(*bits),
122                               codes, sizeof(*codes), sizeof(*codes),
123                               syms,  sizeof(*syms),  sizeof(*syms), 0);
124 }
125
126 static int decode_plane10(UtvideoContext *c, int plane_no,
127                           uint16_t *dst, int step, ptrdiff_t stride,
128                           int width, int height,
129                           const uint8_t *src, const uint8_t *huff,
130                           int use_pred)
131 {
132     int i, j, slice, pix, ret;
133     int sstart, send;
134     VLC vlc;
135     GetBitContext gb;
136     int prev, fsym;
137
138     if ((ret = build_huff10(huff, &vlc, &fsym)) < 0) {
139         av_log(c->avctx, AV_LOG_ERROR, "Cannot build Huffman codes\n");
140         return ret;
141     }
142     if (fsym >= 0) { // build_huff reported a symbol to fill slices with
143         send = 0;
144         for (slice = 0; slice < c->slices; slice++) {
145             uint16_t *dest;
146
147             sstart = send;
148             send   = (height * (slice + 1) / c->slices);
149             dest   = dst + sstart * stride;
150
151             prev = 0x200;
152             for (j = sstart; j < send; j++) {
153                 for (i = 0; i < width * step; i += step) {
154                     pix = fsym;
155                     if (use_pred) {
156                         prev += pix;
157                         prev &= 0x3FF;
158                         pix   = prev;
159                     }
160                     dest[i] = pix;
161                 }
162                 dest += stride;
163             }
164         }
165         return 0;
166     }
167
168     send = 0;
169     for (slice = 0; slice < c->slices; slice++) {
170         uint16_t *dest;
171         int slice_data_start, slice_data_end, slice_size;
172
173         sstart = send;
174         send   = (height * (slice + 1) / c->slices);
175         dest   = dst + sstart * stride;
176
177         // slice offset and size validation was done earlier
178         slice_data_start = slice ? AV_RL32(src + slice * 4 - 4) : 0;
179         slice_data_end   = AV_RL32(src + slice * 4);
180         slice_size       = slice_data_end - slice_data_start;
181
182         if (!slice_size) {
183             av_log(c->avctx, AV_LOG_ERROR, "Plane has more than one symbol "
184                    "yet a slice has a length of zero.\n");
185             goto fail;
186         }
187
188         memcpy(c->slice_bits, src + slice_data_start + c->slices * 4,
189                slice_size);
190         memset(c->slice_bits + slice_size, 0, AV_INPUT_BUFFER_PADDING_SIZE);
191         c->bdsp.bswap_buf((uint32_t *) c->slice_bits,
192                           (uint32_t *) c->slice_bits,
193                           (slice_data_end - slice_data_start + 3) >> 2);
194         init_get_bits(&gb, c->slice_bits, slice_size * 8);
195
196         prev = 0x200;
197         for (j = sstart; j < send; j++) {
198             for (i = 0; i < width * step; i += step) {
199                 if (get_bits_left(&gb) <= 0) {
200                     av_log(c->avctx, AV_LOG_ERROR,
201                            "Slice decoding ran out of bits\n");
202                     goto fail;
203                 }
204                 pix = get_vlc2(&gb, vlc.table, vlc.bits, 3);
205                 if (pix < 0) {
206                     av_log(c->avctx, AV_LOG_ERROR, "Decoding error\n");
207                     goto fail;
208                 }
209                 if (use_pred) {
210                     prev += pix;
211                     prev &= 0x3FF;
212                     pix   = prev;
213                 }
214                 dest[i] = pix;
215             }
216             dest += stride;
217         }
218         if (get_bits_left(&gb) > 32)
219             av_log(c->avctx, AV_LOG_WARNING,
220                    "%d bits left after decoding slice\n", get_bits_left(&gb));
221     }
222
223     ff_free_vlc(&vlc);
224
225     return 0;
226 fail:
227     ff_free_vlc(&vlc);
228     return AVERROR_INVALIDDATA;
229 }
230
231 static int decode_plane(UtvideoContext *c, int plane_no,
232                         uint8_t *dst, int step, ptrdiff_t stride,
233                         int width, int height,
234                         const uint8_t *src, int use_pred)
235 {
236     int i, j, slice, pix;
237     int sstart, send;
238     VLC vlc;
239     GetBitContext gb;
240     int prev, fsym;
241     const int cmask = c->interlaced ? ~(1 + 2 * (!plane_no && c->avctx->pix_fmt == AV_PIX_FMT_YUV420P)) : ~(!plane_no && c->avctx->pix_fmt == AV_PIX_FMT_YUV420P);
242
243     if (build_huff(src, &vlc, &fsym)) {
244         av_log(c->avctx, AV_LOG_ERROR, "Cannot build Huffman codes\n");
245         return AVERROR_INVALIDDATA;
246     }
247     if (fsym >= 0) { // build_huff reported a symbol to fill slices with
248         send = 0;
249         for (slice = 0; slice < c->slices; slice++) {
250             uint8_t *dest;
251
252             sstart = send;
253             send   = (height * (slice + 1) / c->slices) & cmask;
254             dest   = dst + sstart * stride;
255
256             prev = 0x80;
257             for (j = sstart; j < send; j++) {
258                 for (i = 0; i < width * step; i += step) {
259                     pix = fsym;
260                     if (use_pred) {
261                         prev += pix;
262                         pix   = prev;
263                     }
264                     dest[i] = pix;
265                 }
266                 dest += stride;
267             }
268         }
269         return 0;
270     }
271
272     src      += 256;
273
274     send = 0;
275     for (slice = 0; slice < c->slices; slice++) {
276         uint8_t *dest;
277         int slice_data_start, slice_data_end, slice_size;
278
279         sstart = send;
280         send   = (height * (slice + 1) / c->slices) & cmask;
281         dest   = dst + sstart * stride;
282
283         // slice offset and size validation was done earlier
284         slice_data_start = slice ? AV_RL32(src + slice * 4 - 4) : 0;
285         slice_data_end   = AV_RL32(src + slice * 4);
286         slice_size       = slice_data_end - slice_data_start;
287
288         if (!slice_size) {
289             av_log(c->avctx, AV_LOG_ERROR, "Plane has more than one symbol "
290                    "yet a slice has a length of zero.\n");
291             goto fail;
292         }
293
294         memcpy(c->slice_bits, src + slice_data_start + c->slices * 4,
295                slice_size);
296         memset(c->slice_bits + slice_size, 0, AV_INPUT_BUFFER_PADDING_SIZE);
297         c->bdsp.bswap_buf((uint32_t *) c->slice_bits,
298                           (uint32_t *) c->slice_bits,
299                           (slice_data_end - slice_data_start + 3) >> 2);
300         init_get_bits(&gb, c->slice_bits, slice_size * 8);
301
302         prev = 0x80;
303         for (j = sstart; j < send; j++) {
304             for (i = 0; i < width * step; i += step) {
305                 if (get_bits_left(&gb) <= 0) {
306                     av_log(c->avctx, AV_LOG_ERROR,
307                            "Slice decoding ran out of bits\n");
308                     goto fail;
309                 }
310                 pix = get_vlc2(&gb, vlc.table, vlc.bits, 3);
311                 if (pix < 0) {
312                     av_log(c->avctx, AV_LOG_ERROR, "Decoding error\n");
313                     goto fail;
314                 }
315                 if (use_pred) {
316                     prev += pix;
317                     pix   = prev;
318                 }
319                 dest[i] = pix;
320             }
321             dest += stride;
322         }
323         if (get_bits_left(&gb) > 32)
324             av_log(c->avctx, AV_LOG_WARNING,
325                    "%d bits left after decoding slice\n", get_bits_left(&gb));
326     }
327
328     ff_free_vlc(&vlc);
329
330     return 0;
331 fail:
332     ff_free_vlc(&vlc);
333     return AVERROR_INVALIDDATA;
334 }
335
336 static void restore_rgb_planes(uint8_t *src, int step, ptrdiff_t stride,
337                                int width, int height)
338 {
339     int i, j;
340     uint8_t r, g, b;
341
342     for (j = 0; j < height; j++) {
343         for (i = 0; i < width * step; i += step) {
344             r = src[i];
345             g = src[i + 1];
346             b = src[i + 2];
347             src[i]     = r + g - 0x80;
348             src[i + 2] = b + g - 0x80;
349         }
350         src += stride;
351     }
352 }
353
354 static void restore_rgb_planes10(AVFrame *frame, int width, int height)
355 {
356     uint16_t *src_r = (uint16_t *)frame->data[2];
357     uint16_t *src_g = (uint16_t *)frame->data[0];
358     uint16_t *src_b = (uint16_t *)frame->data[1];
359     int r, g, b;
360     int i, j;
361
362     for (j = 0; j < height; j++) {
363         for (i = 0; i < width; i++) {
364             r = src_r[i];
365             g = src_g[i];
366             b = src_b[i];
367             src_r[i] = (r + g - 0x200) & 0x3FF;
368             src_b[i] = (b + g - 0x200) & 0x3FF;
369         }
370         src_r += frame->linesize[2] / 2;
371         src_g += frame->linesize[0] / 2;
372         src_b += frame->linesize[1] / 2;
373     }
374 }
375
376 #undef A
377 #undef B
378 #undef C
379
380 static void restore_median_planar(UtvideoContext *c, uint8_t *src, ptrdiff_t stride,
381                                   int width, int height, int slices, int rmode)
382 {
383     int i, j, slice;
384     int A, B, C;
385     uint8_t *bsrc;
386     int slice_start, slice_height;
387     const int cmask = ~rmode;
388
389     for (slice = 0; slice < slices; slice++) {
390         slice_start  = ((slice * height) / slices) & cmask;
391         slice_height = ((((slice + 1) * height) / slices) & cmask) -
392                        slice_start;
393
394         if (!slice_height)
395             continue;
396         bsrc = src + slice_start * stride;
397
398         // first line - left neighbour prediction
399         bsrc[0] += 0x80;
400         c->llviddsp.add_left_pred(bsrc, bsrc, width, 0);
401         bsrc += stride;
402         if (slice_height <= 1)
403             continue;
404         // second line - first element has top prediction, the rest uses median
405         C        = bsrc[-stride];
406         bsrc[0] += C;
407         A        = bsrc[0];
408         for (i = 1; i < width; i++) {
409             B        = bsrc[i - stride];
410             bsrc[i] += mid_pred(A, B, (uint8_t)(A + B - C));
411             C        = B;
412             A        = bsrc[i];
413         }
414         bsrc += stride;
415         // the rest of lines use continuous median prediction
416         for (j = 2; j < slice_height; j++) {
417             c->llviddsp.add_median_pred(bsrc, bsrc - stride,
418                                             bsrc, width, &A, &B);
419             bsrc += stride;
420         }
421     }
422 }
423
424 /* UtVideo interlaced mode treats every two lines as a single one,
425  * so restoring function should take care of possible padding between
426  * two parts of the same "line".
427  */
428 static void restore_median_planar_il(UtvideoContext *c, uint8_t *src, ptrdiff_t stride,
429                                      int width, int height, int slices, int rmode)
430 {
431     int i, j, slice;
432     int A, B, C;
433     uint8_t *bsrc;
434     int slice_start, slice_height;
435     const int cmask   = ~(rmode ? 3 : 1);
436     const ptrdiff_t stride2 = stride << 1;
437
438     for (slice = 0; slice < slices; slice++) {
439         slice_start    = ((slice * height) / slices) & cmask;
440         slice_height   = ((((slice + 1) * height) / slices) & cmask) -
441                          slice_start;
442         slice_height >>= 1;
443         if (!slice_height)
444             continue;
445
446         bsrc = src + slice_start * stride;
447
448         // first line - left neighbour prediction
449         bsrc[0] += 0x80;
450         A = c->llviddsp.add_left_pred(bsrc, bsrc, width, 0);
451         c->llviddsp.add_left_pred(bsrc + stride, bsrc + stride, width, A);
452         bsrc += stride2;
453         if (slice_height <= 1)
454             continue;
455         // second line - first element has top prediction, the rest uses median
456         C        = bsrc[-stride2];
457         bsrc[0] += C;
458         A        = bsrc[0];
459         for (i = 1; i < width; i++) {
460             B        = bsrc[i - stride2];
461             bsrc[i] += mid_pred(A, B, (uint8_t)(A + B - C));
462             C        = B;
463             A        = bsrc[i];
464         }
465         c->llviddsp.add_median_pred(bsrc + stride, bsrc - stride,
466                                         bsrc + stride, width, &A, &B);
467         bsrc += stride2;
468         // the rest of lines use continuous median prediction
469         for (j = 2; j < slice_height; j++) {
470             c->llviddsp.add_median_pred(bsrc, bsrc - stride2,
471                                             bsrc, width, &A, &B);
472             c->llviddsp.add_median_pred(bsrc + stride, bsrc - stride,
473                                             bsrc + stride, width, &A, &B);
474             bsrc += stride2;
475         }
476     }
477 }
478
479 static void restore_median_packed(uint8_t *src, int step, ptrdiff_t stride,
480                                   int width, int height, int slices, int rmode)
481 {
482     int i, j, slice;
483     int A, B, C;
484     uint8_t *bsrc;
485     int slice_start, slice_height;
486     const int cmask = ~rmode;
487
488     for (slice = 0; slice < slices; slice++) {
489         slice_start  = ((slice * height) / slices) & cmask;
490         slice_height = ((((slice + 1) * height) / slices) & cmask) -
491                        slice_start;
492
493         if (!slice_height)
494             continue;
495         bsrc = src + slice_start * stride;
496
497         // first line - left neighbour prediction
498         bsrc[0] += 0x80;
499         A = bsrc[0];
500         for (i = step; i < width * step; i += step) {
501             bsrc[i] += A;
502             A        = bsrc[i];
503         }
504         bsrc += stride;
505         if (slice_height <= 1)
506             continue;
507         // second line - first element has top prediction, the rest uses median
508         C        = bsrc[-stride];
509         bsrc[0] += C;
510         A        = bsrc[0];
511         for (i = step; i < width * step; i += step) {
512             B        = bsrc[i - stride];
513             bsrc[i] += mid_pred(A, B, (uint8_t)(A + B - C));
514             C        = B;
515             A        = bsrc[i];
516         }
517         bsrc += stride;
518         // the rest of lines use continuous median prediction
519         for (j = 2; j < slice_height; j++) {
520             for (i = 0; i < width * step; i += step) {
521                 B        = bsrc[i - stride];
522                 bsrc[i] += mid_pred(A, B, (uint8_t)(A + B - C));
523                 C        = B;
524                 A        = bsrc[i];
525             }
526             bsrc += stride;
527         }
528     }
529 }
530
531 /* UtVideo interlaced mode treats every two lines as a single one,
532  * so restoring function should take care of possible padding between
533  * two parts of the same "line".
534  */
535 static void restore_median_packed_il(uint8_t *src, int step, ptrdiff_t stride,
536                                      int width, int height, int slices, int rmode)
537 {
538     int i, j, slice;
539     int A, B, C;
540     uint8_t *bsrc;
541     int slice_start, slice_height;
542     const int cmask   = ~(rmode ? 3 : 1);
543     const ptrdiff_t stride2 = stride << 1;
544
545     for (slice = 0; slice < slices; slice++) {
546         slice_start    = ((slice * height) / slices) & cmask;
547         slice_height   = ((((slice + 1) * height) / slices) & cmask) -
548                          slice_start;
549         slice_height >>= 1;
550         if (!slice_height)
551             continue;
552
553         bsrc = src + slice_start * stride;
554
555         // first line - left neighbour prediction
556         bsrc[0] += 0x80;
557         A        = bsrc[0];
558         for (i = step; i < width * step; i += step) {
559             bsrc[i] += A;
560             A        = bsrc[i];
561         }
562         for (i = 0; i < width * step; i += step) {
563             bsrc[stride + i] += A;
564             A                 = bsrc[stride + i];
565         }
566         bsrc += stride2;
567         if (slice_height <= 1)
568             continue;
569         // second line - first element has top prediction, the rest uses median
570         C        = bsrc[-stride2];
571         bsrc[0] += C;
572         A        = bsrc[0];
573         for (i = step; i < width * step; i += step) {
574             B        = bsrc[i - stride2];
575             bsrc[i] += mid_pred(A, B, (uint8_t)(A + B - C));
576             C        = B;
577             A        = bsrc[i];
578         }
579         for (i = 0; i < width * step; i += step) {
580             B                 = bsrc[i - stride];
581             bsrc[stride + i] += mid_pred(A, B, (uint8_t)(A + B - C));
582             C                 = B;
583             A                 = bsrc[stride + i];
584         }
585         bsrc += stride2;
586         // the rest of lines use continuous median prediction
587         for (j = 2; j < slice_height; j++) {
588             for (i = 0; i < width * step; i += step) {
589                 B        = bsrc[i - stride2];
590                 bsrc[i] += mid_pred(A, B, (uint8_t)(A + B - C));
591                 C        = B;
592                 A        = bsrc[i];
593             }
594             for (i = 0; i < width * step; i += step) {
595                 B                 = bsrc[i - stride];
596                 bsrc[i + stride] += mid_pred(A, B, (uint8_t)(A + B - C));
597                 C                 = B;
598                 A                 = bsrc[i + stride];
599             }
600             bsrc += stride2;
601         }
602     }
603 }
604
605 static void restore_gradient_planar(UtvideoContext *c, uint8_t *src, ptrdiff_t stride,
606                                     int width, int height, int slices, int rmode)
607 {
608     int i, j, slice;
609     int A, B, C;
610     uint8_t *bsrc;
611     int slice_start, slice_height;
612     const int cmask = ~rmode;
613
614     for (slice = 0; slice < slices; slice++) {
615         slice_start  = ((slice * height) / slices) & cmask;
616         slice_height = ((((slice + 1) * height) / slices) & cmask) -
617                        slice_start;
618
619         if (!slice_height)
620             continue;
621         bsrc = src + slice_start * stride;
622
623         // first line - left neighbour prediction
624         bsrc[0] += 0x80;
625         c->llviddsp.add_left_pred(bsrc, bsrc, width, 0);
626         bsrc += stride;
627         if (slice_height <= 1)
628             continue;
629         for (j = 1; j < slice_height; j++) {
630             // second line - first element has top prediction, the rest uses gradient
631             bsrc[0] = (bsrc[0] + bsrc[-stride]) & 0xFF;
632             for (i = 1; i < width; i++) {
633                 A = bsrc[i - stride];
634                 B = bsrc[i - (stride + 1)];
635                 C = bsrc[i - 1];
636                 bsrc[i] = (A - B + C + bsrc[i]) & 0xFF;
637             }
638             bsrc += stride;
639         }
640     }
641 }
642
643 static void restore_gradient_planar_il(UtvideoContext *c, uint8_t *src, ptrdiff_t stride,
644                                       int width, int height, int slices, int rmode)
645 {
646     int i, j, slice;
647     int A, B, C;
648     uint8_t *bsrc;
649     int slice_start, slice_height;
650     const int cmask   = ~(rmode ? 3 : 1);
651     const ptrdiff_t stride2 = stride << 1;
652
653     for (slice = 0; slice < slices; slice++) {
654         slice_start    = ((slice * height) / slices) & cmask;
655         slice_height   = ((((slice + 1) * height) / slices) & cmask) -
656                          slice_start;
657         slice_height >>= 1;
658         if (!slice_height)
659             continue;
660
661         bsrc = src + slice_start * stride;
662
663         // first line - left neighbour prediction
664         bsrc[0] += 0x80;
665         A = c->llviddsp.add_left_pred(bsrc, bsrc, width, 0);
666         c->llviddsp.add_left_pred(bsrc + stride, bsrc + stride, width, A);
667         bsrc += stride2;
668         if (slice_height <= 1)
669             continue;
670         for (j = 1; j < slice_height; j++) {
671             // second line - first element has top prediction, the rest uses gradient
672             bsrc[0] = (bsrc[0] + bsrc[-stride2]) & 0xFF;
673             for (i = 1; i < width; i++) {
674                 A = bsrc[i - stride2];
675                 B = bsrc[i - (stride2 + 1)];
676                 C = bsrc[i - 1];
677                 bsrc[i] = (A - B + C + bsrc[i]) & 0xFF;
678             }
679             for (i = 0; i < width; i++) {
680                 A = bsrc[i - stride];
681                 B = bsrc[i - (1 + stride)];
682                 C = bsrc[i - 1 + stride];
683                 bsrc[i + stride] = (A - B + C + bsrc[i + stride]) & 0xFF;
684             }
685             bsrc += stride2;
686         }
687     }
688 }
689
690 static void restore_gradient_packed(uint8_t *src, int step, ptrdiff_t stride,
691                                     int width, int height, int slices, int rmode)
692 {
693     int i, j, slice;
694     int A, B, C;
695     uint8_t *bsrc;
696     int slice_start, slice_height;
697     const int cmask = ~rmode;
698
699     for (slice = 0; slice < slices; slice++) {
700         slice_start  = ((slice * height) / slices) & cmask;
701         slice_height = ((((slice + 1) * height) / slices) & cmask) -
702                        slice_start;
703
704         if (!slice_height)
705             continue;
706         bsrc = src + slice_start * stride;
707
708         // first line - left neighbour prediction
709         bsrc[0] += 0x80;
710         A = bsrc[0];
711         for (i = step; i < width * step; i += step) {
712             bsrc[i] += A;
713             A        = bsrc[i];
714         }
715         bsrc += stride;
716         if (slice_height <= 1)
717             continue;
718         for (j = 1; j < slice_height; j++) {
719             // second line - first element has top prediction, the rest uses gradient
720             C        = bsrc[-stride];
721             bsrc[0] += C;
722             for (i = step; i < width * step; i += step) {
723                 A = bsrc[i - stride];
724                 B = bsrc[i - (stride + step)];
725                 C = bsrc[i - step];
726                 bsrc[i] = (A - B + C + bsrc[i]) & 0xFF;
727             }
728             bsrc += stride;
729         }
730     }
731 }
732
733 static void restore_gradient_packed_il(uint8_t *src, int step, ptrdiff_t stride,
734                                        int width, int height, int slices, int rmode)
735 {
736     int i, j, slice;
737     int A, B, C;
738     uint8_t *bsrc;
739     int slice_start, slice_height;
740     const int cmask   = ~(rmode ? 3 : 1);
741     const ptrdiff_t stride2 = stride << 1;
742
743     for (slice = 0; slice < slices; slice++) {
744         slice_start    = ((slice * height) / slices) & cmask;
745         slice_height   = ((((slice + 1) * height) / slices) & cmask) -
746                          slice_start;
747         slice_height >>= 1;
748         if (!slice_height)
749             continue;
750
751         bsrc = src + slice_start * stride;
752
753         // first line - left neighbour prediction
754         bsrc[0] += 0x80;
755         A        = bsrc[0];
756         for (i = step; i < width * step; i += step) {
757             bsrc[i] += A;
758             A        = bsrc[i];
759         }
760         for (i = 0; i < width * step; i += step) {
761             bsrc[stride + i] += A;
762             A                 = bsrc[stride + i];
763         }
764         bsrc += stride2;
765         if (slice_height <= 1)
766             continue;
767         for (j = 1; j < slice_height; j++) {
768             // second line - first element has top prediction, the rest uses gradient
769             C        = bsrc[-stride2];
770             bsrc[0] += C;
771             for (i = step; i < width * step; i += step) {
772                 A = bsrc[i - stride2];
773                 B = bsrc[i - (stride2 + step)];
774                 C = bsrc[i - step];
775                 bsrc[i] = (A - B + C + bsrc[i]) & 0xFF;
776             }
777             for (i = 0; i < width * step; i += step) {
778                 A = bsrc[i - stride];
779                 B = bsrc[i - (step + stride)];
780                 C = bsrc[i - step + stride];
781                 bsrc[i + stride] = (A - B + C + bsrc[i + stride]) & 0xFF;
782             }
783             bsrc += stride2;
784         }
785     }
786 }
787
788 static int decode_frame(AVCodecContext *avctx, void *data, int *got_frame,
789                         AVPacket *avpkt)
790 {
791     const uint8_t *buf = avpkt->data;
792     int buf_size = avpkt->size;
793     UtvideoContext *c = avctx->priv_data;
794     int i, j;
795     const uint8_t *plane_start[5];
796     int plane_size, max_slice_size = 0, slice_start, slice_end, slice_size;
797     int ret;
798     GetByteContext gb;
799     ThreadFrame frame = { .f = data };
800
801     if ((ret = ff_thread_get_buffer(avctx, &frame, 0)) < 0)
802         return ret;
803
804     /* parse plane structure to get frame flags and validate slice offsets */
805     bytestream2_init(&gb, buf, buf_size);
806     if (c->pro) {
807         if (bytestream2_get_bytes_left(&gb) < c->frame_info_size) {
808             av_log(avctx, AV_LOG_ERROR, "Not enough data for frame information\n");
809             return AVERROR_INVALIDDATA;
810         }
811         c->frame_info = bytestream2_get_le32u(&gb);
812         c->slices = ((c->frame_info >> 16) & 0xff) + 1;
813         for (i = 0; i < c->planes; i++) {
814             plane_start[i] = gb.buffer;
815             if (bytestream2_get_bytes_left(&gb) < 1024 + 4 * c->slices) {
816                 av_log(avctx, AV_LOG_ERROR, "Insufficient data for a plane\n");
817                 return AVERROR_INVALIDDATA;
818             }
819             slice_start = 0;
820             slice_end   = 0;
821             for (j = 0; j < c->slices; j++) {
822                 slice_end   = bytestream2_get_le32u(&gb);
823                 if (slice_end < 0 || slice_end < slice_start ||
824                     bytestream2_get_bytes_left(&gb) < slice_end) {
825                     av_log(avctx, AV_LOG_ERROR, "Incorrect slice size\n");
826                     return AVERROR_INVALIDDATA;
827                 }
828                 slice_size  = slice_end - slice_start;
829                 slice_start = slice_end;
830                 max_slice_size = FFMAX(max_slice_size, slice_size);
831             }
832             plane_size = slice_end;
833             bytestream2_skipu(&gb, plane_size);
834             bytestream2_skipu(&gb, 1024);
835         }
836         plane_start[c->planes] = gb.buffer;
837     } else {
838         for (i = 0; i < c->planes; i++) {
839             plane_start[i] = gb.buffer;
840             if (bytestream2_get_bytes_left(&gb) < 256 + 4 * c->slices) {
841                 av_log(avctx, AV_LOG_ERROR, "Insufficient data for a plane\n");
842                 return AVERROR_INVALIDDATA;
843             }
844             bytestream2_skipu(&gb, 256);
845             slice_start = 0;
846             slice_end   = 0;
847             for (j = 0; j < c->slices; j++) {
848                 slice_end   = bytestream2_get_le32u(&gb);
849                 if (slice_end < 0 || slice_end < slice_start ||
850                     bytestream2_get_bytes_left(&gb) < slice_end) {
851                     av_log(avctx, AV_LOG_ERROR, "Incorrect slice size\n");
852                     return AVERROR_INVALIDDATA;
853                 }
854                 slice_size  = slice_end - slice_start;
855                 slice_start = slice_end;
856                 max_slice_size = FFMAX(max_slice_size, slice_size);
857             }
858             plane_size = slice_end;
859             bytestream2_skipu(&gb, plane_size);
860         }
861         plane_start[c->planes] = gb.buffer;
862         if (bytestream2_get_bytes_left(&gb) < c->frame_info_size) {
863             av_log(avctx, AV_LOG_ERROR, "Not enough data for frame information\n");
864             return AVERROR_INVALIDDATA;
865         }
866         c->frame_info = bytestream2_get_le32u(&gb);
867     }
868     av_log(avctx, AV_LOG_DEBUG, "frame information flags %"PRIX32"\n",
869            c->frame_info);
870
871     c->frame_pred = (c->frame_info >> 8) & 3;
872
873     av_fast_malloc(&c->slice_bits, &c->slice_bits_size,
874                    max_slice_size + AV_INPUT_BUFFER_PADDING_SIZE);
875
876     if (!c->slice_bits) {
877         av_log(avctx, AV_LOG_ERROR, "Cannot allocate temporary buffer\n");
878         return AVERROR(ENOMEM);
879     }
880
881     switch (c->avctx->pix_fmt) {
882     case AV_PIX_FMT_RGB24:
883     case AV_PIX_FMT_RGBA:
884         for (i = 0; i < c->planes; i++) {
885             ret = decode_plane(c, i, frame.f->data[0] + ff_ut_rgb_order[i],
886                                c->planes, frame.f->linesize[0], avctx->width,
887                                avctx->height, plane_start[i],
888                                c->frame_pred == PRED_LEFT);
889             if (ret)
890                 return ret;
891             if (c->frame_pred == PRED_MEDIAN) {
892                 if (!c->interlaced) {
893                     restore_median_packed(frame.f->data[0] + ff_ut_rgb_order[i],
894                                           c->planes, frame.f->linesize[0], avctx->width,
895                                           avctx->height, c->slices, 0);
896                 } else {
897                     restore_median_packed_il(frame.f->data[0] + ff_ut_rgb_order[i],
898                                              c->planes, frame.f->linesize[0],
899                                              avctx->width, avctx->height, c->slices,
900                                              0);
901                 }
902             } else if (c->frame_pred == PRED_GRADIENT) {
903                 if (!c->interlaced) {
904                     restore_gradient_packed(frame.f->data[0] + ff_ut_rgb_order[i],
905                                             c->planes, frame.f->linesize[0], avctx->width,
906                                             avctx->height, c->slices, 0);
907                 } else {
908                     restore_gradient_packed_il(frame.f->data[0] + ff_ut_rgb_order[i],
909                                                c->planes, frame.f->linesize[0],
910                                                avctx->width, avctx->height, c->slices,
911                                                0);
912                 }
913             }
914         }
915         restore_rgb_planes(frame.f->data[0], c->planes, frame.f->linesize[0],
916                            avctx->width, avctx->height);
917         break;
918     case AV_PIX_FMT_GBRAP10:
919     case AV_PIX_FMT_GBRP10:
920         for (i = 0; i < c->planes; i++) {
921             ret = decode_plane10(c, i, (uint16_t *)frame.f->data[i], 1,
922                                  frame.f->linesize[i] / 2, avctx->width,
923                                  avctx->height, plane_start[i],
924                                  plane_start[i + 1] - 1024,
925                                  c->frame_pred == PRED_LEFT);
926             if (ret)
927                 return ret;
928         }
929         restore_rgb_planes10(frame.f, avctx->width, avctx->height);
930         break;
931     case AV_PIX_FMT_YUV420P:
932         for (i = 0; i < 3; i++) {
933             ret = decode_plane(c, i, frame.f->data[i], 1, frame.f->linesize[i],
934                                avctx->width >> !!i, avctx->height >> !!i,
935                                plane_start[i], c->frame_pred == PRED_LEFT);
936             if (ret)
937                 return ret;
938             if (c->frame_pred == PRED_MEDIAN) {
939                 if (!c->interlaced) {
940                     restore_median_planar(c, frame.f->data[i], frame.f->linesize[i],
941                                           avctx->width >> !!i, avctx->height >> !!i,
942                                           c->slices, !i);
943                 } else {
944                     restore_median_planar_il(c, frame.f->data[i], frame.f->linesize[i],
945                                              avctx->width  >> !!i,
946                                              avctx->height >> !!i,
947                                              c->slices, !i);
948                 }
949             } else if (c->frame_pred == PRED_GRADIENT) {
950                 if (!c->interlaced) {
951                     restore_gradient_planar(c, frame.f->data[i], frame.f->linesize[i],
952                                             avctx->width >> !!i, avctx->height >> !!i,
953                                             c->slices, !i);
954                 } else {
955                     restore_gradient_planar_il(c, frame.f->data[i], frame.f->linesize[i],
956                                                avctx->width  >> !!i,
957                                                avctx->height >> !!i,
958                                                c->slices, !i);
959                 }
960             }
961         }
962         break;
963     case AV_PIX_FMT_YUV422P:
964         for (i = 0; i < 3; i++) {
965             ret = decode_plane(c, i, frame.f->data[i], 1, frame.f->linesize[i],
966                                avctx->width >> !!i, avctx->height,
967                                plane_start[i], c->frame_pred == PRED_LEFT);
968             if (ret)
969                 return ret;
970             if (c->frame_pred == PRED_MEDIAN) {
971                 if (!c->interlaced) {
972                     restore_median_planar(c, frame.f->data[i], frame.f->linesize[i],
973                                           avctx->width >> !!i, avctx->height,
974                                           c->slices, 0);
975                 } else {
976                     restore_median_planar_il(c, frame.f->data[i], frame.f->linesize[i],
977                                              avctx->width >> !!i, avctx->height,
978                                              c->slices, 0);
979                 }
980             } else if (c->frame_pred == PRED_GRADIENT) {
981                 if (!c->interlaced) {
982                     restore_gradient_planar(c, frame.f->data[i], frame.f->linesize[i],
983                                             avctx->width >> !!i, avctx->height,
984                                             c->slices, 0);
985                 } else {
986                     restore_gradient_planar_il(c, frame.f->data[i], frame.f->linesize[i],
987                                                avctx->width  >> !!i, avctx->height,
988                                                c->slices, 0);
989                 }
990             }
991         }
992         break;
993     case AV_PIX_FMT_YUV444P:
994         for (i = 0; i < 3; i++) {
995             ret = decode_plane(c, i, frame.f->data[i], 1, frame.f->linesize[i],
996                                avctx->width, avctx->height,
997                                plane_start[i], c->frame_pred == PRED_LEFT);
998             if (ret)
999                 return ret;
1000             if (c->frame_pred == PRED_MEDIAN) {
1001                 if (!c->interlaced) {
1002                     restore_median_planar(c, frame.f->data[i], frame.f->linesize[i],
1003                                           avctx->width, avctx->height,
1004                                           c->slices, 0);
1005                 } else {
1006                     restore_median_planar_il(c, frame.f->data[i], frame.f->linesize[i],
1007                                              avctx->width, avctx->height,
1008                                              c->slices, 0);
1009                 }
1010             } else if (c->frame_pred == PRED_GRADIENT) {
1011                 if (!c->interlaced) {
1012                     restore_gradient_planar(c, frame.f->data[i], frame.f->linesize[i],
1013                                             avctx->width, avctx->height,
1014                                             c->slices, 0);
1015                 } else {
1016                     restore_gradient_planar_il(c, frame.f->data[i], frame.f->linesize[i],
1017                                                avctx->width, avctx->height,
1018                                                c->slices, 0);
1019                 }
1020             }
1021         }
1022         break;
1023     case AV_PIX_FMT_YUV422P10:
1024         for (i = 0; i < 3; i++) {
1025             ret = decode_plane10(c, i, (uint16_t *)frame.f->data[i], 1, frame.f->linesize[i] / 2,
1026                                  avctx->width >> !!i, avctx->height,
1027                                  plane_start[i], plane_start[i + 1] - 1024, c->frame_pred == PRED_LEFT);
1028             if (ret)
1029                 return ret;
1030         }
1031         break;
1032     }
1033
1034     frame.f->key_frame = 1;
1035     frame.f->pict_type = AV_PICTURE_TYPE_I;
1036     frame.f->interlaced_frame = !!c->interlaced;
1037
1038     *got_frame = 1;
1039
1040     /* always report that the buffer was completely consumed */
1041     return buf_size;
1042 }
1043
1044 static av_cold int decode_init(AVCodecContext *avctx)
1045 {
1046     UtvideoContext * const c = avctx->priv_data;
1047
1048     c->avctx = avctx;
1049
1050     ff_bswapdsp_init(&c->bdsp);
1051     ff_llviddsp_init(&c->llviddsp);
1052
1053     if (avctx->extradata_size >= 16) {
1054         av_log(avctx, AV_LOG_DEBUG, "Encoder version %d.%d.%d.%d\n",
1055                avctx->extradata[3], avctx->extradata[2],
1056                avctx->extradata[1], avctx->extradata[0]);
1057         av_log(avctx, AV_LOG_DEBUG, "Original format %"PRIX32"\n",
1058                AV_RB32(avctx->extradata + 4));
1059         c->frame_info_size = AV_RL32(avctx->extradata + 8);
1060         c->flags           = AV_RL32(avctx->extradata + 12);
1061
1062         if (c->frame_info_size != 4)
1063             avpriv_request_sample(avctx, "Frame info not 4 bytes");
1064         av_log(avctx, AV_LOG_DEBUG, "Encoding parameters %08"PRIX32"\n", c->flags);
1065         c->slices      = (c->flags >> 24) + 1;
1066         c->compression = c->flags & 1;
1067         c->interlaced  = c->flags & 0x800;
1068     } else if (avctx->extradata_size == 8) {
1069         av_log(avctx, AV_LOG_DEBUG, "Encoder version %d.%d.%d.%d\n",
1070                avctx->extradata[3], avctx->extradata[2],
1071                avctx->extradata[1], avctx->extradata[0]);
1072         av_log(avctx, AV_LOG_DEBUG, "Original format %"PRIX32"\n",
1073                AV_RB32(avctx->extradata + 4));
1074         c->interlaced  = 0;
1075         c->pro         = 1;
1076         c->frame_info_size = 4;
1077     } else {
1078         av_log(avctx, AV_LOG_ERROR,
1079                "Insufficient extradata size %d, should be at least 16\n",
1080                avctx->extradata_size);
1081         return AVERROR_INVALIDDATA;
1082     }
1083
1084     c->slice_bits_size = 0;
1085
1086     switch (avctx->codec_tag) {
1087     case MKTAG('U', 'L', 'R', 'G'):
1088         c->planes      = 3;
1089         avctx->pix_fmt = AV_PIX_FMT_RGB24;
1090         break;
1091     case MKTAG('U', 'L', 'R', 'A'):
1092         c->planes      = 4;
1093         avctx->pix_fmt = AV_PIX_FMT_RGBA;
1094         break;
1095     case MKTAG('U', 'L', 'Y', '0'):
1096         c->planes      = 3;
1097         avctx->pix_fmt = AV_PIX_FMT_YUV420P;
1098         avctx->colorspace = AVCOL_SPC_BT470BG;
1099         break;
1100     case MKTAG('U', 'L', 'Y', '2'):
1101         c->planes      = 3;
1102         avctx->pix_fmt = AV_PIX_FMT_YUV422P;
1103         avctx->colorspace = AVCOL_SPC_BT470BG;
1104         break;
1105     case MKTAG('U', 'L', 'Y', '4'):
1106         c->planes      = 3;
1107         avctx->pix_fmt = AV_PIX_FMT_YUV444P;
1108         avctx->colorspace = AVCOL_SPC_BT470BG;
1109         break;
1110     case MKTAG('U', 'Q', 'Y', '2'):
1111         c->planes      = 3;
1112         avctx->pix_fmt = AV_PIX_FMT_YUV422P10;
1113         break;
1114     case MKTAG('U', 'Q', 'R', 'G'):
1115         c->planes      = 3;
1116         avctx->pix_fmt = AV_PIX_FMT_GBRP10;
1117         break;
1118     case MKTAG('U', 'Q', 'R', 'A'):
1119         c->planes      = 4;
1120         avctx->pix_fmt = AV_PIX_FMT_GBRAP10;
1121         break;
1122     case MKTAG('U', 'L', 'H', '0'):
1123         c->planes      = 3;
1124         avctx->pix_fmt = AV_PIX_FMT_YUV420P;
1125         avctx->colorspace = AVCOL_SPC_BT709;
1126         break;
1127     case MKTAG('U', 'L', 'H', '2'):
1128         c->planes      = 3;
1129         avctx->pix_fmt = AV_PIX_FMT_YUV422P;
1130         avctx->colorspace = AVCOL_SPC_BT709;
1131         break;
1132     case MKTAG('U', 'L', 'H', '4'):
1133         c->planes      = 3;
1134         avctx->pix_fmt = AV_PIX_FMT_YUV444P;
1135         avctx->colorspace = AVCOL_SPC_BT709;
1136         break;
1137     default:
1138         av_log(avctx, AV_LOG_ERROR, "Unknown Ut Video FOURCC provided (%08X)\n",
1139                avctx->codec_tag);
1140         return AVERROR_INVALIDDATA;
1141     }
1142
1143     return 0;
1144 }
1145
1146 static av_cold int decode_end(AVCodecContext *avctx)
1147 {
1148     UtvideoContext * const c = avctx->priv_data;
1149
1150     av_freep(&c->slice_bits);
1151
1152     return 0;
1153 }
1154
1155 AVCodec ff_utvideo_decoder = {
1156     .name           = "utvideo",
1157     .long_name      = NULL_IF_CONFIG_SMALL("Ut Video"),
1158     .type           = AVMEDIA_TYPE_VIDEO,
1159     .id             = AV_CODEC_ID_UTVIDEO,
1160     .priv_data_size = sizeof(UtvideoContext),
1161     .init           = decode_init,
1162     .close          = decode_end,
1163     .decode         = decode_frame,
1164     .capabilities   = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_FRAME_THREADS,
1165     .caps_internal  = FF_CODEC_CAP_INIT_THREADSAFE,
1166 };