utvideodec: Reuse the huffyuv add_left
[ffmpeg.git] / libavcodec / utvideodec.c
1 /*
2  * Ut Video decoder
3  * Copyright (c) 2011 Konstantin Shishkov
4  *
5  * This file is part of Libav.
6  *
7  * Libav 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  * Libav 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 Libav; 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
32 #include "avcodec.h"
33 #include "bitstream.h"
34 #include "bswapdsp.h"
35 #include "bytestream.h"
36 #include "internal.h"
37 #include "thread.h"
38 #include "utvideo.h"
39
40 static int build_huff10(const uint8_t *src, VLC *vlc, int *fsym)
41 {
42     int i;
43     HuffEntry he[1024];
44     int last;
45     uint32_t codes[1024];
46     uint8_t bits[1024];
47     uint16_t syms[1024];
48     uint32_t code;
49
50     *fsym = -1;
51     for (i = 0; i < 1024; i++) {
52         he[i].sym = i;
53         he[i].len = *src++;
54     }
55     qsort(he, 1024, sizeof(*he), ff_ut10_huff_cmp_len);
56
57     if (!he[0].len) {
58         *fsym = he[0].sym;
59         return 0;
60     }
61
62     last = 1023;
63     while (he[last].len == 255 && last)
64         last--;
65
66     if (he[last].len > 32) {
67         return -1;
68     }
69
70     code = 1;
71     for (i = last; i >= 0; i--) {
72         codes[i] = code >> (32 - he[i].len);
73         bits[i]  = he[i].len;
74         syms[i]  = he[i].sym;
75         code += 0x80000000u >> (he[i].len - 1);
76     }
77
78     return ff_init_vlc_sparse(vlc, FFMIN(he[last].len, 11), last + 1,
79                               bits,  sizeof(*bits),  sizeof(*bits),
80                               codes, sizeof(*codes), sizeof(*codes),
81                               syms,  sizeof(*syms),  sizeof(*syms), 0);
82 }
83
84 static int build_huff(const uint8_t *src, VLC *vlc, int *fsym)
85 {
86     int i;
87     HuffEntry he[256];
88     int last;
89     uint32_t codes[256];
90     uint8_t bits[256];
91     uint8_t syms[256];
92     uint32_t code;
93
94     *fsym = -1;
95     for (i = 0; i < 256; i++) {
96         he[i].sym = i;
97         he[i].len = *src++;
98     }
99     qsort(he, 256, sizeof(*he), ff_ut_huff_cmp_len);
100
101     if (!he[0].len) {
102         *fsym = he[0].sym;
103         return 0;
104     }
105     if (he[0].len > 32)
106         return -1;
107
108     last = 255;
109     while (he[last].len == 255 && last)
110         last--;
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, 9), 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     BitstreamContext bc;
133     int i, j, slice, pix, ret;
134     int sstart, send;
135     VLC vlc;
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         bitstream_init8(&bc, c->slice_bits, slice_size);
195
196         prev = 0x200;
197         for (j = sstart; j < send; j++) {
198             for (i = 0; i < width * step; i += step) {
199                 if (bitstream_bits_left(&bc) <= 0) {
200                     av_log(c->avctx, AV_LOG_ERROR,
201                            "Slice decoding ran out of bits\n");
202                     goto fail;
203                 }
204                 pix = bitstream_read_vlc(&bc, 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 (bitstream_bits_left(&bc) > 32)
219             av_log(c->avctx, AV_LOG_WARNING,
220                    "%d bits left after decoding slice\n", bitstream_bits_left(&bc));
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     BitstreamContext bc;
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         bitstream_init8(&bc, c->slice_bits, slice_size);
301
302         prev = 0x80;
303         for (j = sstart; j < send; j++) {
304             for (i = 0; i < width * step; i += step) {
305                 if (bitstream_bits_left(&bc) <= 0) {
306                     av_log(c->avctx, AV_LOG_ERROR,
307                            "Slice decoding ran out of bits\n");
308                     goto fail;
309                 }
310                 pix = bitstream_read_vlc(&bc, vlc.table, vlc.bits, 4);
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 (bitstream_bits_left(&bc) > 32)
324             av_log(c->avctx, AV_LOG_WARNING,
325                    "%d bits left after decoding slice\n", bitstream_bits_left(&bc));
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 static void restore_median_planar(UtvideoContext *c, uint8_t *src,
377                                   ptrdiff_t stride, int width, int height,
378                                   int slices, int rmode)
379 {
380     int i, j, slice;
381     int A, B, C;
382     uint8_t *bsrc;
383     int slice_start, slice_height;
384     const int cmask = ~rmode;
385
386     for (slice = 0; slice < slices; slice++) {
387         slice_start  = ((slice * height) / slices) & cmask;
388         slice_height = ((((slice + 1) * height) / slices) & cmask) -
389                        slice_start;
390
391         if (!slice_height)
392             continue;
393         bsrc = src + slice_start * stride;
394
395         // first line - left neighbour prediction
396         bsrc[0] += 0x80;
397         c->hdspdec.add_hfyu_left_pred(bsrc, bsrc, width, 0);
398         bsrc += stride;
399         if (slice_height <= 1)
400             continue;
401         // second line - first element has top prediction, the rest uses median
402         C        = bsrc[-stride];
403         bsrc[0] += C;
404         A        = bsrc[0];
405         for (i = 1; i < width; i++) {
406             B        = bsrc[i - stride];
407             bsrc[i] += mid_pred(A, B, (uint8_t)(A + B - C));
408             C        = B;
409             A        = bsrc[i];
410         }
411         bsrc += stride;
412         // the rest of lines use continuous median prediction
413         for (j = 2; j < slice_height; j++) {
414             c->hdspdec.add_hfyu_median_pred(bsrc, bsrc - stride,
415                                             bsrc, width, &A, &B);
416             bsrc += stride;
417         }
418     }
419 }
420
421 /* UtVideo interlaced mode treats every two lines as a single one,
422  * so restoring function should take care of possible padding between
423  * two parts of the same "line".
424  */
425 static void restore_median_planar_il(UtvideoContext *c, uint8_t *src,
426                                      ptrdiff_t stride, int width, int height,
427                                      int slices, int rmode)
428 {
429     int i, j, slice;
430     int A, B, C;
431     uint8_t *bsrc;
432     int slice_start, slice_height;
433     const int cmask   = ~(rmode ? 3 : 1);
434     const int stride2 = stride << 1;
435
436     for (slice = 0; slice < slices; slice++) {
437         slice_start    = ((slice * height) / slices) & cmask;
438         slice_height   = ((((slice + 1) * height) / slices) & cmask) -
439                          slice_start;
440         slice_height >>= 1;
441         if (!slice_height)
442             continue;
443
444         bsrc = src + slice_start * stride;
445
446         // first line - left neighbour prediction
447         bsrc[0] += 0x80;
448         A = c->hdspdec.add_hfyu_left_pred(bsrc, bsrc, width, 0);
449         c->hdspdec.add_hfyu_left_pred(bsrc + stride, bsrc + stride, width, A);
450         bsrc += stride2;
451         if (slice_height <= 1)
452             continue;
453         // second line - first element has top prediction, the rest uses median
454         C        = bsrc[-stride2];
455         bsrc[0] += C;
456         A        = bsrc[0];
457         for (i = 1; i < width; i++) {
458             B        = bsrc[i - stride2];
459             bsrc[i] += mid_pred(A, B, (uint8_t)(A + B - C));
460             C        = B;
461             A        = bsrc[i];
462         }
463         c->hdspdec.add_hfyu_median_pred(bsrc + stride, bsrc - stride,
464                                         bsrc + stride, width, &A, &B);
465         bsrc += stride2;
466         // the rest of lines use continuous median prediction
467         for (j = 2; j < slice_height; j++) {
468             c->hdspdec.add_hfyu_median_pred(bsrc, bsrc - stride2,
469                                             bsrc, width, &A, &B);
470             c->hdspdec.add_hfyu_median_pred(bsrc + stride, bsrc - stride,
471                                             bsrc + stride, width, &A, &B);
472             bsrc += stride2;
473         }
474     }
475 }
476
477 static void restore_median_packed(uint8_t *src, int step, ptrdiff_t stride,
478                                   int width, int height,
479                                   int slices, int rmode)
480 {
481     int i, j, slice;
482     int A, B, C;
483     uint8_t *bsrc;
484     int slice_start, slice_height;
485     const int cmask = ~rmode;
486
487     for (slice = 0; slice < slices; slice++) {
488         slice_start  = ((slice * height) / slices) & cmask;
489         slice_height = ((((slice + 1) * height) / slices) & cmask) -
490                        slice_start;
491         if (!slice_height)
492             continue;
493
494         bsrc = src + slice_start * stride;
495
496         // first line - left neighbour prediction
497         bsrc[0] += 0x80;
498         A = bsrc[0];
499         for (i = step; i < width * step; i += step) {
500             bsrc[i] += A;
501             A        = bsrc[i];
502         }
503         bsrc += stride;
504         if (slice_height == 1)
505             continue;
506         // second line - first element has top prediction, the rest uses median
507         C        = bsrc[-stride];
508         bsrc[0] += C;
509         A        = bsrc[0];
510         for (i = step; i < width * step; i += step) {
511             B        = bsrc[i - stride];
512             bsrc[i] += mid_pred(A, B, (uint8_t)(A + B - C));
513             C        = B;
514             A        = bsrc[i];
515         }
516         bsrc += stride;
517         // the rest of lines use continuous median prediction
518         for (j = 2; j < slice_height; j++) {
519             for (i = 0; i < width * step; i += step) {
520                 B        = bsrc[i - stride];
521                 bsrc[i] += mid_pred(A, B, (uint8_t)(A + B - C));
522                 C        = B;
523                 A        = bsrc[i];
524             }
525             bsrc += stride;
526         }
527     }
528 }
529
530 /* UtVideo interlaced mode treats every two lines as a single one,
531  * so restoring function should take care of possible padding between
532  * two parts of the same "line".
533  */
534 static void restore_median_packed_il(uint8_t *src, int step, ptrdiff_t stride,
535                                      int width, int height,
536                                      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 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         av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
620         return ret;
621     }
622
623     ff_thread_finish_setup(avctx);
624
625     /* parse plane structure to get frame flags and validate slice offsets */
626     bytestream2_init(&gb, buf, buf_size);
627     if (c->pro) {
628         if (bytestream2_get_bytes_left(&gb) < c->frame_info_size) {
629             av_log(avctx, AV_LOG_ERROR, "Not enough data for frame information\n");
630             return AVERROR_INVALIDDATA;
631         }
632         c->frame_info = bytestream2_get_le32u(&gb);
633         c->slices = ((c->frame_info >> 16) & 0xff) + 1;
634         for (i = 0; i < c->planes; i++) {
635             plane_start[i] = gb.buffer;
636             if (bytestream2_get_bytes_left(&gb) < 1024 + 4 * c->slices) {
637                 av_log(avctx, AV_LOG_ERROR, "Insufficient data for a plane\n");
638                 return AVERROR_INVALIDDATA;
639             }
640             slice_start = 0;
641             slice_end   = 0;
642             for (j = 0; j < c->slices; j++) {
643                 slice_end   = bytestream2_get_le32u(&gb);
644                 if (slice_end < 0 || slice_end < slice_start ||
645                     bytestream2_get_bytes_left(&gb) < slice_end) {
646                     av_log(avctx, AV_LOG_ERROR, "Incorrect slice size\n");
647                     return AVERROR_INVALIDDATA;
648                 }
649                 slice_size  = slice_end - slice_start;
650                 slice_start = slice_end;
651                 max_slice_size = FFMAX(max_slice_size, slice_size);
652             }
653             plane_size = slice_end;
654             bytestream2_skipu(&gb, plane_size);
655             bytestream2_skipu(&gb, 1024);
656         }
657         plane_start[c->planes] = gb.buffer;
658     } else {
659         for (i = 0; i < c->planes; i++) {
660             plane_start[i] = gb.buffer;
661             if (bytestream2_get_bytes_left(&gb) < 256 + 4 * c->slices) {
662                 av_log(avctx, AV_LOG_ERROR, "Insufficient data for a plane\n");
663                 return AVERROR_INVALIDDATA;
664             }
665             bytestream2_skipu(&gb, 256);
666             slice_start = 0;
667             slice_end   = 0;
668             for (j = 0; j < c->slices; j++) {
669                 slice_end   = bytestream2_get_le32u(&gb);
670                 if (slice_end < 0 || slice_end < slice_start ||
671                     bytestream2_get_bytes_left(&gb) < slice_end) {
672                     av_log(avctx, AV_LOG_ERROR, "Incorrect slice size\n");
673                     return AVERROR_INVALIDDATA;
674                 }
675                 slice_size  = slice_end - slice_start;
676                 slice_start = slice_end;
677                 max_slice_size = FFMAX(max_slice_size, slice_size);
678             }
679             plane_size = slice_end;
680             bytestream2_skipu(&gb, plane_size);
681         }
682         plane_start[c->planes] = gb.buffer;
683         if (bytestream2_get_bytes_left(&gb) < c->frame_info_size) {
684             av_log(avctx, AV_LOG_ERROR, "Not enough data for frame information\n");
685             return AVERROR_INVALIDDATA;
686         }
687         c->frame_info = bytestream2_get_le32u(&gb);
688     }
689     av_log(avctx, AV_LOG_DEBUG, "frame information flags %"PRIX32"\n",
690            c->frame_info);
691
692     c->frame_pred = (c->frame_info >> 8) & 3;
693
694     if (c->frame_pred == PRED_GRADIENT) {
695         avpriv_request_sample(avctx, "Frame with gradient prediction");
696         return AVERROR_PATCHWELCOME;
697     }
698
699     av_fast_malloc(&c->slice_bits, &c->slice_bits_size,
700                    max_slice_size + AV_INPUT_BUFFER_PADDING_SIZE);
701
702     if (!c->slice_bits) {
703         av_log(avctx, AV_LOG_ERROR, "Cannot allocate temporary buffer\n");
704         return AVERROR(ENOMEM);
705     }
706
707     switch (c->avctx->pix_fmt) {
708     case AV_PIX_FMT_RGB24:
709     case AV_PIX_FMT_RGBA:
710         for (i = 0; i < c->planes; i++) {
711             ret = decode_plane(c, i, frame.f->data[0] + ff_ut_rgb_order[i],
712                                c->planes, frame.f->linesize[0], avctx->width,
713                                avctx->height, plane_start[i],
714                                c->frame_pred == PRED_LEFT);
715             if (ret)
716                 return ret;
717             if (c->frame_pred == PRED_MEDIAN) {
718                 if (!c->interlaced) {
719                     restore_median_packed(frame.f->data[0] + ff_ut_rgb_order[i],
720                                           c->planes, frame.f->linesize[0], avctx->width,
721                                           avctx->height, c->slices, 0);
722                 } else {
723                     restore_median_packed_il(frame.f->data[0] + ff_ut_rgb_order[i],
724                                              c->planes, frame.f->linesize[0],
725                                              avctx->width, avctx->height, c->slices,
726                                              0);
727                 }
728             }
729         }
730         restore_rgb_planes(frame.f->data[0], c->planes, frame.f->linesize[0],
731                            avctx->width, avctx->height);
732         break;
733     case AV_PIX_FMT_GBRAP10:
734     case AV_PIX_FMT_GBRP10:
735         for (i = 0; i < c->planes; i++) {
736             ret = decode_plane10(c, i, (uint16_t *)frame.f->data[i], 1,
737                                  frame.f->linesize[i] / 2, avctx->width,
738                                  avctx->height, plane_start[i],
739                                  plane_start[i + 1] - 1024,
740                                  c->frame_pred == PRED_LEFT);
741             if (ret)
742                 return ret;
743         }
744         restore_rgb_planes10(frame.f, avctx->width, avctx->height);
745         break;
746     case AV_PIX_FMT_YUV420P:
747         for (i = 0; i < 3; i++) {
748             ret = decode_plane(c, i, frame.f->data[i], 1, frame.f->linesize[i],
749                                avctx->width >> !!i, avctx->height >> !!i,
750                                plane_start[i], c->frame_pred == PRED_LEFT);
751             if (ret)
752                 return ret;
753             if (c->frame_pred == PRED_MEDIAN) {
754                 if (!c->interlaced) {
755                     restore_median_planar(c, frame.f->data[i], frame.f->linesize[i],
756                                           avctx->width >> !!i, avctx->height >> !!i,
757                                           c->slices, !i);
758                 } else {
759                     restore_median_planar_il(c, frame.f->data[i], frame.f->linesize[i],
760                                              avctx->width  >> !!i,
761                                              avctx->height >> !!i,
762                                              c->slices, !i);
763                 }
764             }
765         }
766         break;
767     case AV_PIX_FMT_YUV422P:
768         for (i = 0; i < 3; i++) {
769             ret = decode_plane(c, i, frame.f->data[i], 1, frame.f->linesize[i],
770                                avctx->width >> !!i, avctx->height,
771                                plane_start[i], c->frame_pred == PRED_LEFT);
772             if (ret)
773                 return ret;
774             if (c->frame_pred == PRED_MEDIAN) {
775                 if (!c->interlaced) {
776                     restore_median_planar(c, frame.f->data[i], frame.f->linesize[i],
777                                           avctx->width >> !!i, avctx->height,
778                                           c->slices, 0);
779                 } else {
780                     restore_median_planar_il(c, frame.f->data[i], frame.f->linesize[i],
781                                              avctx->width >> !!i, avctx->height,
782                                              c->slices, 0);
783                 }
784             }
785         }
786         break;
787     case AV_PIX_FMT_YUV444P:
788         for (i = 0; i < 3; i++) {
789             ret = decode_plane(c, i, frame.f->data[i], 1, frame.f->linesize[i],
790                                avctx->width, avctx->height,
791                                plane_start[i], c->frame_pred == PRED_LEFT);
792             if (ret)
793                 return ret;
794             if (c->frame_pred == PRED_MEDIAN) {
795                 if (!c->interlaced) {
796                     restore_median_planar(c, frame.f->data[i], frame.f->linesize[i],
797                                           avctx->width, avctx->height,
798                                           c->slices, 0);
799                 } else {
800                     restore_median_planar_il(c, frame.f->data[i], frame.f->linesize[i],
801                                              avctx->width, avctx->height,
802                                              c->slices, 0);
803                 }
804             }
805         }
806         break;
807     case AV_PIX_FMT_YUV422P10:
808         for (i = 0; i < 3; i++) {
809             ret = decode_plane10(c, i, (uint16_t *)frame.f->data[i], 1, frame.f->linesize[i] / 2,
810                                  avctx->width >> !!i, avctx->height,
811                                  plane_start[i], plane_start[i + 1] - 1024, c->frame_pred == PRED_LEFT);
812             if (ret)
813                 return ret;
814         }
815         break;
816     }
817
818     frame.f->key_frame = 1;
819     frame.f->pict_type = AV_PICTURE_TYPE_I;
820     frame.f->interlaced_frame = !!c->interlaced;
821
822     *got_frame = 1;
823
824     /* always report that the buffer was completely consumed */
825     return buf_size;
826 }
827
828 static av_cold int decode_init(AVCodecContext *avctx)
829 {
830     UtvideoContext * const c = avctx->priv_data;
831
832     c->avctx = avctx;
833
834     ff_bswapdsp_init(&c->bdsp);
835     ff_huffyuvdsp_init(&c->hdspdec);
836
837     if (avctx->extradata_size >= 16) {
838         av_log(avctx, AV_LOG_DEBUG, "Encoder version %d.%d.%d.%d\n",
839                avctx->extradata[3], avctx->extradata[2],
840                avctx->extradata[1], avctx->extradata[0]);
841         av_log(avctx, AV_LOG_DEBUG, "Original format %"PRIX32"\n",
842                AV_RB32(avctx->extradata + 4));
843         c->frame_info_size = AV_RL32(avctx->extradata + 8);
844         c->flags           = AV_RL32(avctx->extradata + 12);
845
846         if (c->frame_info_size != 4)
847             avpriv_request_sample(avctx, "Frame info not 4 bytes");
848         av_log(avctx, AV_LOG_DEBUG, "Encoding parameters %08"PRIX32"\n", c->flags);
849         c->slices      = (c->flags >> 24) + 1;
850         c->compression = c->flags & 1;
851         c->interlaced  = c->flags & 0x800;
852     } else if (avctx->extradata_size == 8) {
853         av_log(avctx, AV_LOG_DEBUG, "Encoder version %d.%d.%d.%d\n",
854                avctx->extradata[3], avctx->extradata[2],
855                avctx->extradata[1], avctx->extradata[0]);
856         av_log(avctx, AV_LOG_DEBUG, "Original format %"PRIX32"\n",
857                AV_RB32(avctx->extradata + 4));
858         c->interlaced  = 0;
859         c->pro         = 1;
860         c->frame_info_size = 4;
861     } else {
862         av_log(avctx, AV_LOG_ERROR,
863                "Insufficient extradata size %d, should be at least 16\n",
864                avctx->extradata_size);
865         return AVERROR_INVALIDDATA;
866     }
867
868     c->slice_bits_size = 0;
869
870     switch (avctx->codec_tag) {
871     case MKTAG('U', 'L', 'R', 'G'):
872         c->planes      = 3;
873         avctx->pix_fmt = AV_PIX_FMT_RGB24;
874         break;
875     case MKTAG('U', 'L', 'R', 'A'):
876         c->planes      = 4;
877         avctx->pix_fmt = AV_PIX_FMT_RGBA;
878         break;
879     case MKTAG('U', 'L', 'Y', '0'):
880         c->planes      = 3;
881         avctx->pix_fmt = AV_PIX_FMT_YUV420P;
882         avctx->colorspace = AVCOL_SPC_BT470BG;
883         break;
884     case MKTAG('U', 'L', 'Y', '2'):
885         c->planes      = 3;
886         avctx->pix_fmt = AV_PIX_FMT_YUV422P;
887         avctx->colorspace = AVCOL_SPC_BT470BG;
888         break;
889     case MKTAG('U', 'L', 'Y', '4'):
890         c->planes      = 3;
891         avctx->pix_fmt = AV_PIX_FMT_YUV444P;
892         avctx->colorspace = AVCOL_SPC_BT470BG;
893         break;
894     case MKTAG('U', 'Q', 'Y', '2'):
895         c->planes      = 3;
896         avctx->pix_fmt = AV_PIX_FMT_YUV422P10;
897         break;
898     case MKTAG('U', 'Q', 'R', 'G'):
899         c->planes      = 3;
900         avctx->pix_fmt = AV_PIX_FMT_GBRP10;
901         break;
902     case MKTAG('U', 'Q', 'R', 'A'):
903         c->planes      = 4;
904         avctx->pix_fmt = AV_PIX_FMT_GBRAP10;
905         break;
906     case MKTAG('U', 'L', 'H', '0'):
907         c->planes      = 3;
908         avctx->pix_fmt = AV_PIX_FMT_YUV420P;
909         avctx->colorspace = AVCOL_SPC_BT709;
910         break;
911     case MKTAG('U', 'L', 'H', '2'):
912         c->planes      = 3;
913         avctx->pix_fmt = AV_PIX_FMT_YUV422P;
914         avctx->colorspace = AVCOL_SPC_BT709;
915         break;
916     case MKTAG('U', 'L', 'H', '4'):
917         c->planes      = 3;
918         avctx->pix_fmt = AV_PIX_FMT_YUV444P;
919         avctx->colorspace = AVCOL_SPC_BT709;
920         break;
921     default:
922         av_log(avctx, AV_LOG_ERROR, "Unknown Ut Video FOURCC provided (%08X)\n",
923                avctx->codec_tag);
924         return AVERROR_INVALIDDATA;
925     }
926
927     return 0;
928 }
929
930 static av_cold int decode_end(AVCodecContext *avctx)
931 {
932     UtvideoContext * const c = avctx->priv_data;
933
934     av_freep(&c->slice_bits);
935
936     return 0;
937 }
938
939 AVCodec ff_utvideo_decoder = {
940     .name           = "utvideo",
941     .long_name      = NULL_IF_CONFIG_SMALL("Ut Video"),
942     .type           = AVMEDIA_TYPE_VIDEO,
943     .id             = AV_CODEC_ID_UTVIDEO,
944     .priv_data_size = sizeof(UtvideoContext),
945     .init           = decode_init,
946     .close          = decode_end,
947     .decode         = decode_frame,
948     .capabilities   = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_FRAME_THREADS,
949     .caps_internal  = FF_CODEC_CAP_INIT_THREADSAFE,
950 };