avcodec/gsmdec_template: Fix runtime error: signed integer overflow: -22527 * 99113...
[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, int 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, int 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 = ~(!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, int stride, int width,
337                                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, int 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, int 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 int 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, int 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, int 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 int 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 int decode_frame(AVCodecContext *avctx, void *data, int *got_frame,
606                         AVPacket *avpkt)
607 {
608     const uint8_t *buf = avpkt->data;
609     int buf_size = avpkt->size;
610     UtvideoContext *c = avctx->priv_data;
611     int i, j;
612     const uint8_t *plane_start[5];
613     int plane_size, max_slice_size = 0, slice_start, slice_end, slice_size;
614     int ret;
615     GetByteContext gb;
616     ThreadFrame frame = { .f = data };
617
618     if ((ret = ff_thread_get_buffer(avctx, &frame, 0)) < 0)
619         return ret;
620
621     /* parse plane structure to get frame flags and validate slice offsets */
622     bytestream2_init(&gb, buf, buf_size);
623     if (c->pro) {
624         if (bytestream2_get_bytes_left(&gb) < c->frame_info_size) {
625             av_log(avctx, AV_LOG_ERROR, "Not enough data for frame information\n");
626             return AVERROR_INVALIDDATA;
627         }
628         c->frame_info = bytestream2_get_le32u(&gb);
629         c->slices = ((c->frame_info >> 16) & 0xff) + 1;
630         for (i = 0; i < c->planes; i++) {
631             plane_start[i] = gb.buffer;
632             if (bytestream2_get_bytes_left(&gb) < 1024 + 4 * c->slices) {
633                 av_log(avctx, AV_LOG_ERROR, "Insufficient data for a plane\n");
634                 return AVERROR_INVALIDDATA;
635             }
636             slice_start = 0;
637             slice_end   = 0;
638             for (j = 0; j < c->slices; j++) {
639                 slice_end   = bytestream2_get_le32u(&gb);
640                 if (slice_end < 0 || slice_end < slice_start ||
641                     bytestream2_get_bytes_left(&gb) < slice_end) {
642                     av_log(avctx, AV_LOG_ERROR, "Incorrect slice size\n");
643                     return AVERROR_INVALIDDATA;
644                 }
645                 slice_size  = slice_end - slice_start;
646                 slice_start = slice_end;
647                 max_slice_size = FFMAX(max_slice_size, slice_size);
648             }
649             plane_size = slice_end;
650             bytestream2_skipu(&gb, plane_size);
651             bytestream2_skipu(&gb, 1024);
652         }
653         plane_start[c->planes] = gb.buffer;
654     } else {
655         for (i = 0; i < c->planes; i++) {
656             plane_start[i] = gb.buffer;
657             if (bytestream2_get_bytes_left(&gb) < 256 + 4 * c->slices) {
658                 av_log(avctx, AV_LOG_ERROR, "Insufficient data for a plane\n");
659                 return AVERROR_INVALIDDATA;
660             }
661             bytestream2_skipu(&gb, 256);
662             slice_start = 0;
663             slice_end   = 0;
664             for (j = 0; j < c->slices; j++) {
665                 slice_end   = bytestream2_get_le32u(&gb);
666                 if (slice_end < 0 || slice_end < slice_start ||
667                     bytestream2_get_bytes_left(&gb) < slice_end) {
668                     av_log(avctx, AV_LOG_ERROR, "Incorrect slice size\n");
669                     return AVERROR_INVALIDDATA;
670                 }
671                 slice_size  = slice_end - slice_start;
672                 slice_start = slice_end;
673                 max_slice_size = FFMAX(max_slice_size, slice_size);
674             }
675             plane_size = slice_end;
676             bytestream2_skipu(&gb, plane_size);
677         }
678         plane_start[c->planes] = gb.buffer;
679         if (bytestream2_get_bytes_left(&gb) < c->frame_info_size) {
680             av_log(avctx, AV_LOG_ERROR, "Not enough data for frame information\n");
681             return AVERROR_INVALIDDATA;
682         }
683         c->frame_info = bytestream2_get_le32u(&gb);
684     }
685     av_log(avctx, AV_LOG_DEBUG, "frame information flags %"PRIX32"\n",
686            c->frame_info);
687
688     c->frame_pred = (c->frame_info >> 8) & 3;
689
690     if (c->frame_pred == PRED_GRADIENT) {
691         avpriv_request_sample(avctx, "Frame with gradient prediction");
692         return AVERROR_PATCHWELCOME;
693     }
694
695     av_fast_malloc(&c->slice_bits, &c->slice_bits_size,
696                    max_slice_size + AV_INPUT_BUFFER_PADDING_SIZE);
697
698     if (!c->slice_bits) {
699         av_log(avctx, AV_LOG_ERROR, "Cannot allocate temporary buffer\n");
700         return AVERROR(ENOMEM);
701     }
702
703     switch (c->avctx->pix_fmt) {
704     case AV_PIX_FMT_RGB24:
705     case AV_PIX_FMT_RGBA:
706         for (i = 0; i < c->planes; i++) {
707             ret = decode_plane(c, i, frame.f->data[0] + ff_ut_rgb_order[i],
708                                c->planes, frame.f->linesize[0], avctx->width,
709                                avctx->height, plane_start[i],
710                                c->frame_pred == PRED_LEFT);
711             if (ret)
712                 return ret;
713             if (c->frame_pred == PRED_MEDIAN) {
714                 if (!c->interlaced) {
715                     restore_median_packed(frame.f->data[0] + ff_ut_rgb_order[i],
716                                           c->planes, frame.f->linesize[0], avctx->width,
717                                           avctx->height, c->slices, 0);
718                 } else {
719                     restore_median_packed_il(frame.f->data[0] + ff_ut_rgb_order[i],
720                                              c->planes, frame.f->linesize[0],
721                                              avctx->width, avctx->height, c->slices,
722                                              0);
723                 }
724             }
725         }
726         restore_rgb_planes(frame.f->data[0], c->planes, frame.f->linesize[0],
727                            avctx->width, avctx->height);
728         break;
729     case AV_PIX_FMT_GBRAP10:
730     case AV_PIX_FMT_GBRP10:
731         for (i = 0; i < c->planes; i++) {
732             ret = decode_plane10(c, i, (uint16_t *)frame.f->data[i], 1,
733                                  frame.f->linesize[i] / 2, avctx->width,
734                                  avctx->height, plane_start[i],
735                                  plane_start[i + 1] - 1024,
736                                  c->frame_pred == PRED_LEFT);
737             if (ret)
738                 return ret;
739         }
740         restore_rgb_planes10(frame.f, avctx->width, avctx->height);
741         break;
742     case AV_PIX_FMT_YUV420P:
743         for (i = 0; i < 3; i++) {
744             ret = decode_plane(c, i, frame.f->data[i], 1, frame.f->linesize[i],
745                                avctx->width >> !!i, avctx->height >> !!i,
746                                plane_start[i], c->frame_pred == PRED_LEFT);
747             if (ret)
748                 return ret;
749             if (c->frame_pred == PRED_MEDIAN) {
750                 if (!c->interlaced) {
751                     restore_median_planar(c, frame.f->data[i], frame.f->linesize[i],
752                                           avctx->width >> !!i, avctx->height >> !!i,
753                                           c->slices, !i);
754                 } else {
755                     restore_median_planar_il(c, frame.f->data[i], frame.f->linesize[i],
756                                              avctx->width  >> !!i,
757                                              avctx->height >> !!i,
758                                              c->slices, !i);
759                 }
760             }
761         }
762         break;
763     case AV_PIX_FMT_YUV422P:
764         for (i = 0; i < 3; i++) {
765             ret = decode_plane(c, i, frame.f->data[i], 1, frame.f->linesize[i],
766                                avctx->width >> !!i, avctx->height,
767                                plane_start[i], c->frame_pred == PRED_LEFT);
768             if (ret)
769                 return ret;
770             if (c->frame_pred == PRED_MEDIAN) {
771                 if (!c->interlaced) {
772                     restore_median_planar(c, frame.f->data[i], frame.f->linesize[i],
773                                           avctx->width >> !!i, avctx->height,
774                                           c->slices, 0);
775                 } else {
776                     restore_median_planar_il(c, frame.f->data[i], frame.f->linesize[i],
777                                              avctx->width >> !!i, avctx->height,
778                                              c->slices, 0);
779                 }
780             }
781         }
782         break;
783     case AV_PIX_FMT_YUV444P:
784         for (i = 0; i < 3; i++) {
785             ret = decode_plane(c, i, frame.f->data[i], 1, frame.f->linesize[i],
786                                avctx->width, avctx->height,
787                                plane_start[i], c->frame_pred == PRED_LEFT);
788             if (ret)
789                 return ret;
790             if (c->frame_pred == PRED_MEDIAN) {
791                 if (!c->interlaced) {
792                     restore_median_planar(c, frame.f->data[i], frame.f->linesize[i],
793                                           avctx->width, avctx->height,
794                                           c->slices, 0);
795                 } else {
796                     restore_median_planar_il(c, frame.f->data[i], frame.f->linesize[i],
797                                              avctx->width, avctx->height,
798                                              c->slices, 0);
799                 }
800             }
801         }
802         break;
803     case AV_PIX_FMT_YUV422P10:
804         for (i = 0; i < 3; i++) {
805             ret = decode_plane10(c, i, (uint16_t *)frame.f->data[i], 1, frame.f->linesize[i] / 2,
806                                  avctx->width >> !!i, avctx->height,
807                                  plane_start[i], plane_start[i + 1] - 1024, c->frame_pred == PRED_LEFT);
808             if (ret)
809                 return ret;
810         }
811         break;
812     }
813
814     frame.f->key_frame = 1;
815     frame.f->pict_type = AV_PICTURE_TYPE_I;
816     frame.f->interlaced_frame = !!c->interlaced;
817
818     *got_frame = 1;
819
820     /* always report that the buffer was completely consumed */
821     return buf_size;
822 }
823
824 static av_cold int decode_init(AVCodecContext *avctx)
825 {
826     UtvideoContext * const c = avctx->priv_data;
827
828     c->avctx = avctx;
829
830     ff_bswapdsp_init(&c->bdsp);
831     ff_llviddsp_init(&c->llviddsp);
832
833     if (avctx->extradata_size >= 16) {
834         av_log(avctx, AV_LOG_DEBUG, "Encoder version %d.%d.%d.%d\n",
835                avctx->extradata[3], avctx->extradata[2],
836                avctx->extradata[1], avctx->extradata[0]);
837         av_log(avctx, AV_LOG_DEBUG, "Original format %"PRIX32"\n",
838                AV_RB32(avctx->extradata + 4));
839         c->frame_info_size = AV_RL32(avctx->extradata + 8);
840         c->flags           = AV_RL32(avctx->extradata + 12);
841
842         if (c->frame_info_size != 4)
843             avpriv_request_sample(avctx, "Frame info not 4 bytes");
844         av_log(avctx, AV_LOG_DEBUG, "Encoding parameters %08"PRIX32"\n", c->flags);
845         c->slices      = (c->flags >> 24) + 1;
846         c->compression = c->flags & 1;
847         c->interlaced  = c->flags & 0x800;
848     } else if (avctx->extradata_size == 8) {
849         av_log(avctx, AV_LOG_DEBUG, "Encoder version %d.%d.%d.%d\n",
850                avctx->extradata[3], avctx->extradata[2],
851                avctx->extradata[1], avctx->extradata[0]);
852         av_log(avctx, AV_LOG_DEBUG, "Original format %"PRIX32"\n",
853                AV_RB32(avctx->extradata + 4));
854         c->interlaced  = 0;
855         c->pro         = 1;
856         c->frame_info_size = 4;
857     } else {
858         av_log(avctx, AV_LOG_ERROR,
859                "Insufficient extradata size %d, should be at least 16\n",
860                avctx->extradata_size);
861         return AVERROR_INVALIDDATA;
862     }
863
864     c->slice_bits_size = 0;
865
866     switch (avctx->codec_tag) {
867     case MKTAG('U', 'L', 'R', 'G'):
868         c->planes      = 3;
869         avctx->pix_fmt = AV_PIX_FMT_RGB24;
870         break;
871     case MKTAG('U', 'L', 'R', 'A'):
872         c->planes      = 4;
873         avctx->pix_fmt = AV_PIX_FMT_RGBA;
874         break;
875     case MKTAG('U', 'L', 'Y', '0'):
876         c->planes      = 3;
877         avctx->pix_fmt = AV_PIX_FMT_YUV420P;
878         avctx->colorspace = AVCOL_SPC_BT470BG;
879         break;
880     case MKTAG('U', 'L', 'Y', '2'):
881         c->planes      = 3;
882         avctx->pix_fmt = AV_PIX_FMT_YUV422P;
883         avctx->colorspace = AVCOL_SPC_BT470BG;
884         break;
885     case MKTAG('U', 'L', 'Y', '4'):
886         c->planes      = 3;
887         avctx->pix_fmt = AV_PIX_FMT_YUV444P;
888         avctx->colorspace = AVCOL_SPC_BT470BG;
889         break;
890     case MKTAG('U', 'Q', 'Y', '2'):
891         c->planes      = 3;
892         avctx->pix_fmt = AV_PIX_FMT_YUV422P10;
893         break;
894     case MKTAG('U', 'Q', 'R', 'G'):
895         c->planes      = 3;
896         avctx->pix_fmt = AV_PIX_FMT_GBRP10;
897         break;
898     case MKTAG('U', 'Q', 'R', 'A'):
899         c->planes      = 4;
900         avctx->pix_fmt = AV_PIX_FMT_GBRAP10;
901         break;
902     case MKTAG('U', 'L', 'H', '0'):
903         c->planes      = 3;
904         avctx->pix_fmt = AV_PIX_FMT_YUV420P;
905         avctx->colorspace = AVCOL_SPC_BT709;
906         break;
907     case MKTAG('U', 'L', 'H', '2'):
908         c->planes      = 3;
909         avctx->pix_fmt = AV_PIX_FMT_YUV422P;
910         avctx->colorspace = AVCOL_SPC_BT709;
911         break;
912     case MKTAG('U', 'L', 'H', '4'):
913         c->planes      = 3;
914         avctx->pix_fmt = AV_PIX_FMT_YUV444P;
915         avctx->colorspace = AVCOL_SPC_BT709;
916         break;
917     default:
918         av_log(avctx, AV_LOG_ERROR, "Unknown Ut Video FOURCC provided (%08X)\n",
919                avctx->codec_tag);
920         return AVERROR_INVALIDDATA;
921     }
922
923     return 0;
924 }
925
926 static av_cold int decode_end(AVCodecContext *avctx)
927 {
928     UtvideoContext * const c = avctx->priv_data;
929
930     av_freep(&c->slice_bits);
931
932     return 0;
933 }
934
935 AVCodec ff_utvideo_decoder = {
936     .name           = "utvideo",
937     .long_name      = NULL_IF_CONFIG_SMALL("Ut Video"),
938     .type           = AVMEDIA_TYPE_VIDEO,
939     .id             = AV_CODEC_ID_UTVIDEO,
940     .priv_data_size = sizeof(UtvideoContext),
941     .init           = decode_init,
942     .close          = decode_end,
943     .decode         = decode_frame,
944     .capabilities   = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_FRAME_THREADS,
945     .caps_internal  = FF_CODEC_CAP_INIT_THREADSAFE,
946 };