f5fae8ba44e6edc7329d77f32db15627f5249634
[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(uint8_t *src, int step, ptrdiff_t stride,
377                            int width, int height, int slices, int rmode)
378 {
379     int i, j, slice;
380     int A, B, C;
381     uint8_t *bsrc;
382     int slice_start, slice_height;
383     const int cmask = ~rmode;
384
385     for (slice = 0; slice < slices; slice++) {
386         slice_start  = ((slice * height) / slices) & cmask;
387         slice_height = ((((slice + 1) * height) / slices) & cmask) -
388                        slice_start;
389         if (!slice_height)
390             continue;
391
392         bsrc = src + slice_start * stride;
393
394         // first line - left neighbour prediction
395         bsrc[0] += 0x80;
396         A = bsrc[0];
397         for (i = step; i < width * step; i += step) {
398             bsrc[i] += A;
399             A        = bsrc[i];
400         }
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 = step; i < width * step; i += step) {
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             for (i = 0; i < width * step; i += step) {
418                 B        = bsrc[i - stride];
419                 bsrc[i] += mid_pred(A, B, (uint8_t)(A + B - C));
420                 C        = B;
421                 A        = bsrc[i];
422             }
423             bsrc += stride;
424         }
425     }
426 }
427
428 /* UtVideo interlaced mode treats every two lines as a single one,
429  * so restoring function should take care of possible padding between
430  * two parts of the same "line".
431  */
432 static void restore_median_il(uint8_t *src, int step, ptrdiff_t stride,
433                               int width, int height, int slices, int rmode)
434 {
435     int i, j, slice;
436     int A, B, C;
437     uint8_t *bsrc;
438     int slice_start, slice_height;
439     const int cmask   = ~(rmode ? 3 : 1);
440     const ptrdiff_t stride2 = stride << 1;
441
442     for (slice = 0; slice < slices; slice++) {
443         slice_start    = ((slice * height) / slices) & cmask;
444         slice_height   = ((((slice + 1) * height) / slices) & cmask) -
445                          slice_start;
446         slice_height >>= 1;
447         if (!slice_height)
448             continue;
449
450         bsrc = src + slice_start * stride;
451
452         // first line - left neighbour prediction
453         bsrc[0] += 0x80;
454         A        = bsrc[0];
455         for (i = step; i < width * step; i += step) {
456             bsrc[i] += A;
457             A        = bsrc[i];
458         }
459         for (i = 0; i < width * step; i += step) {
460             bsrc[stride + i] += A;
461             A                 = bsrc[stride + i];
462         }
463         bsrc += stride2;
464         if (slice_height == 1)
465             continue;
466         // second line - first element has top prediction, the rest uses median
467         C        = bsrc[-stride2];
468         bsrc[0] += C;
469         A        = bsrc[0];
470         for (i = step; i < width * step; i += step) {
471             B        = bsrc[i - stride2];
472             bsrc[i] += mid_pred(A, B, (uint8_t)(A + B - C));
473             C        = B;
474             A        = bsrc[i];
475         }
476         for (i = 0; i < width * step; i += step) {
477             B                 = bsrc[i - stride];
478             bsrc[stride + i] += mid_pred(A, B, (uint8_t)(A + B - C));
479             C                 = B;
480             A                 = bsrc[stride + i];
481         }
482         bsrc += stride2;
483         // the rest of lines use continuous median prediction
484         for (j = 2; j < slice_height; j++) {
485             for (i = 0; i < width * step; i += step) {
486                 B        = bsrc[i - stride2];
487                 bsrc[i] += mid_pred(A, B, (uint8_t)(A + B - C));
488                 C        = B;
489                 A        = bsrc[i];
490             }
491             for (i = 0; i < width * step; i += step) {
492                 B                 = bsrc[i - stride];
493                 bsrc[i + stride] += mid_pred(A, B, (uint8_t)(A + B - C));
494                 C                 = B;
495                 A                 = bsrc[i + stride];
496             }
497             bsrc += stride2;
498         }
499     }
500 }
501
502 static int decode_frame(AVCodecContext *avctx, void *data, int *got_frame,
503                         AVPacket *avpkt)
504 {
505     const uint8_t *buf = avpkt->data;
506     int buf_size = avpkt->size;
507     UtvideoContext *c = avctx->priv_data;
508     int i, j;
509     const uint8_t *plane_start[5];
510     int plane_size, max_slice_size = 0, slice_start, slice_end, slice_size;
511     int ret;
512     GetByteContext gb;
513     ThreadFrame frame = { .f = data };
514
515     if ((ret = ff_thread_get_buffer(avctx, &frame, 0)) < 0) {
516         av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
517         return ret;
518     }
519
520     ff_thread_finish_setup(avctx);
521
522     /* parse plane structure to get frame flags and validate slice offsets */
523     bytestream2_init(&gb, buf, buf_size);
524     if (c->pro) {
525         if (bytestream2_get_bytes_left(&gb) < c->frame_info_size) {
526             av_log(avctx, AV_LOG_ERROR, "Not enough data for frame information\n");
527             return AVERROR_INVALIDDATA;
528         }
529         c->frame_info = bytestream2_get_le32u(&gb);
530         c->slices = ((c->frame_info >> 16) & 0xff) + 1;
531         for (i = 0; i < c->planes; i++) {
532             plane_start[i] = gb.buffer;
533             if (bytestream2_get_bytes_left(&gb) < 1024 + 4 * c->slices) {
534                 av_log(avctx, AV_LOG_ERROR, "Insufficient data for a plane\n");
535                 return AVERROR_INVALIDDATA;
536             }
537             slice_start = 0;
538             slice_end   = 0;
539             for (j = 0; j < c->slices; j++) {
540                 slice_end   = bytestream2_get_le32u(&gb);
541                 if (slice_end < 0 || slice_end < slice_start ||
542                     bytestream2_get_bytes_left(&gb) < slice_end) {
543                     av_log(avctx, AV_LOG_ERROR, "Incorrect slice size\n");
544                     return AVERROR_INVALIDDATA;
545                 }
546                 slice_size  = slice_end - slice_start;
547                 slice_start = slice_end;
548                 max_slice_size = FFMAX(max_slice_size, slice_size);
549             }
550             plane_size = slice_end;
551             bytestream2_skipu(&gb, plane_size);
552             bytestream2_skipu(&gb, 1024);
553         }
554         plane_start[c->planes] = gb.buffer;
555     } else {
556         for (i = 0; i < c->planes; i++) {
557             plane_start[i] = gb.buffer;
558             if (bytestream2_get_bytes_left(&gb) < 256 + 4 * c->slices) {
559                 av_log(avctx, AV_LOG_ERROR, "Insufficient data for a plane\n");
560                 return AVERROR_INVALIDDATA;
561             }
562             bytestream2_skipu(&gb, 256);
563             slice_start = 0;
564             slice_end   = 0;
565             for (j = 0; j < c->slices; j++) {
566                 slice_end   = bytestream2_get_le32u(&gb);
567                 if (slice_end < 0 || slice_end < slice_start ||
568                     bytestream2_get_bytes_left(&gb) < slice_end) {
569                     av_log(avctx, AV_LOG_ERROR, "Incorrect slice size\n");
570                     return AVERROR_INVALIDDATA;
571                 }
572                 slice_size  = slice_end - slice_start;
573                 slice_start = slice_end;
574                 max_slice_size = FFMAX(max_slice_size, slice_size);
575             }
576             plane_size = slice_end;
577             bytestream2_skipu(&gb, plane_size);
578         }
579         plane_start[c->planes] = gb.buffer;
580         if (bytestream2_get_bytes_left(&gb) < c->frame_info_size) {
581             av_log(avctx, AV_LOG_ERROR, "Not enough data for frame information\n");
582             return AVERROR_INVALIDDATA;
583         }
584         c->frame_info = bytestream2_get_le32u(&gb);
585     }
586     av_log(avctx, AV_LOG_DEBUG, "frame information flags %"PRIX32"\n",
587            c->frame_info);
588
589     c->frame_pred = (c->frame_info >> 8) & 3;
590
591     if (c->frame_pred == PRED_GRADIENT) {
592         avpriv_request_sample(avctx, "Frame with gradient prediction");
593         return AVERROR_PATCHWELCOME;
594     }
595
596     av_fast_malloc(&c->slice_bits, &c->slice_bits_size,
597                    max_slice_size + AV_INPUT_BUFFER_PADDING_SIZE);
598
599     if (!c->slice_bits) {
600         av_log(avctx, AV_LOG_ERROR, "Cannot allocate temporary buffer\n");
601         return AVERROR(ENOMEM);
602     }
603
604     switch (c->avctx->pix_fmt) {
605     case AV_PIX_FMT_RGB24:
606     case AV_PIX_FMT_RGBA:
607         for (i = 0; i < c->planes; i++) {
608             ret = decode_plane(c, i, frame.f->data[0] + ff_ut_rgb_order[i],
609                                c->planes, frame.f->linesize[0], avctx->width,
610                                avctx->height, plane_start[i],
611                                c->frame_pred == PRED_LEFT);
612             if (ret)
613                 return ret;
614             if (c->frame_pred == PRED_MEDIAN) {
615                 if (!c->interlaced) {
616                     restore_median(frame.f->data[0] + ff_ut_rgb_order[i],
617                                    c->planes, frame.f->linesize[0], avctx->width,
618                                    avctx->height, c->slices, 0);
619                 } else {
620                     restore_median_il(frame.f->data[0] + ff_ut_rgb_order[i],
621                                       c->planes, frame.f->linesize[0],
622                                       avctx->width, avctx->height, c->slices,
623                                       0);
624                 }
625             }
626         }
627         restore_rgb_planes(frame.f->data[0], c->planes, frame.f->linesize[0],
628                            avctx->width, avctx->height);
629         break;
630     case AV_PIX_FMT_GBRAP10:
631     case AV_PIX_FMT_GBRP10:
632         for (i = 0; i < c->planes; i++) {
633             ret = decode_plane10(c, i, (uint16_t *)frame.f->data[i], 1,
634                                  frame.f->linesize[i] / 2, avctx->width,
635                                  avctx->height, plane_start[i],
636                                  plane_start[i + 1] - 1024,
637                                  c->frame_pred == PRED_LEFT);
638             if (ret)
639                 return ret;
640         }
641         restore_rgb_planes10(frame.f, avctx->width, avctx->height);
642         break;
643     case AV_PIX_FMT_YUV420P:
644         for (i = 0; i < 3; i++) {
645             ret = decode_plane(c, i, frame.f->data[i], 1, frame.f->linesize[i],
646                                avctx->width >> !!i, avctx->height >> !!i,
647                                plane_start[i], c->frame_pred == PRED_LEFT);
648             if (ret)
649                 return ret;
650             if (c->frame_pred == PRED_MEDIAN) {
651                 if (!c->interlaced) {
652                     restore_median(frame.f->data[i], 1, frame.f->linesize[i],
653                                    avctx->width >> !!i, avctx->height >> !!i,
654                                    c->slices, !i);
655                 } else {
656                     restore_median_il(frame.f->data[i], 1, frame.f->linesize[i],
657                                       avctx->width  >> !!i,
658                                       avctx->height >> !!i,
659                                       c->slices, !i);
660                 }
661             }
662         }
663         break;
664     case AV_PIX_FMT_YUV422P:
665         for (i = 0; i < 3; i++) {
666             ret = decode_plane(c, i, frame.f->data[i], 1, frame.f->linesize[i],
667                                avctx->width >> !!i, avctx->height,
668                                plane_start[i], c->frame_pred == PRED_LEFT);
669             if (ret)
670                 return ret;
671             if (c->frame_pred == PRED_MEDIAN) {
672                 if (!c->interlaced) {
673                     restore_median(frame.f->data[i], 1, frame.f->linesize[i],
674                                    avctx->width >> !!i, avctx->height,
675                                    c->slices, 0);
676                 } else {
677                     restore_median_il(frame.f->data[i], 1, frame.f->linesize[i],
678                                       avctx->width >> !!i, avctx->height,
679                                       c->slices, 0);
680                 }
681             }
682         }
683         break;
684     case AV_PIX_FMT_YUV444P:
685         for (i = 0; i < 3; i++) {
686             ret = decode_plane(c, i, frame.f->data[i], 1, frame.f->linesize[i],
687                                avctx->width, avctx->height,
688                                plane_start[i], c->frame_pred == PRED_LEFT);
689             if (ret)
690                 return ret;
691             if (c->frame_pred == PRED_MEDIAN) {
692                 if (!c->interlaced) {
693                     restore_median(frame.f->data[i], 1, frame.f->linesize[i],
694                                    avctx->width, avctx->height,
695                                    c->slices, 0);
696                 } else {
697                     restore_median_il(frame.f->data[i], 1, frame.f->linesize[i],
698                                       avctx->width, avctx->height,
699                                       c->slices, 0);
700                 }
701             }
702         }
703         break;
704     case AV_PIX_FMT_YUV422P10:
705         for (i = 0; i < 3; i++) {
706             ret = decode_plane10(c, i, (uint16_t *)frame.f->data[i], 1, frame.f->linesize[i] / 2,
707                                  avctx->width >> !!i, avctx->height,
708                                  plane_start[i], plane_start[i + 1] - 1024, c->frame_pred == PRED_LEFT);
709             if (ret)
710                 return ret;
711         }
712         break;
713     }
714
715     frame.f->key_frame = 1;
716     frame.f->pict_type = AV_PICTURE_TYPE_I;
717     frame.f->interlaced_frame = !!c->interlaced;
718
719     *got_frame = 1;
720
721     /* always report that the buffer was completely consumed */
722     return buf_size;
723 }
724
725 static av_cold int decode_init(AVCodecContext *avctx)
726 {
727     UtvideoContext * const c = avctx->priv_data;
728
729     c->avctx = avctx;
730
731     ff_bswapdsp_init(&c->bdsp);
732
733     if (avctx->extradata_size >= 16) {
734         av_log(avctx, AV_LOG_DEBUG, "Encoder version %d.%d.%d.%d\n",
735                avctx->extradata[3], avctx->extradata[2],
736                avctx->extradata[1], avctx->extradata[0]);
737         av_log(avctx, AV_LOG_DEBUG, "Original format %"PRIX32"\n",
738                AV_RB32(avctx->extradata + 4));
739         c->frame_info_size = AV_RL32(avctx->extradata + 8);
740         c->flags           = AV_RL32(avctx->extradata + 12);
741
742         if (c->frame_info_size != 4)
743             avpriv_request_sample(avctx, "Frame info not 4 bytes");
744         av_log(avctx, AV_LOG_DEBUG, "Encoding parameters %08"PRIX32"\n", c->flags);
745         c->slices      = (c->flags >> 24) + 1;
746         c->compression = c->flags & 1;
747         c->interlaced  = c->flags & 0x800;
748     } else if (avctx->extradata_size == 8) {
749         av_log(avctx, AV_LOG_DEBUG, "Encoder version %d.%d.%d.%d\n",
750                avctx->extradata[3], avctx->extradata[2],
751                avctx->extradata[1], avctx->extradata[0]);
752         av_log(avctx, AV_LOG_DEBUG, "Original format %"PRIX32"\n",
753                AV_RB32(avctx->extradata + 4));
754         c->interlaced  = 0;
755         c->pro         = 1;
756         c->frame_info_size = 4;
757     } else {
758         av_log(avctx, AV_LOG_ERROR,
759                "Insufficient extradata size %d, should be at least 16\n",
760                avctx->extradata_size);
761         return AVERROR_INVALIDDATA;
762     }
763
764     c->slice_bits_size = 0;
765
766     switch (avctx->codec_tag) {
767     case MKTAG('U', 'L', 'R', 'G'):
768         c->planes      = 3;
769         avctx->pix_fmt = AV_PIX_FMT_RGB24;
770         break;
771     case MKTAG('U', 'L', 'R', 'A'):
772         c->planes      = 4;
773         avctx->pix_fmt = AV_PIX_FMT_RGBA;
774         break;
775     case MKTAG('U', 'L', 'Y', '0'):
776         c->planes      = 3;
777         avctx->pix_fmt = AV_PIX_FMT_YUV420P;
778         avctx->colorspace = AVCOL_SPC_BT470BG;
779         break;
780     case MKTAG('U', 'L', 'Y', '2'):
781         c->planes      = 3;
782         avctx->pix_fmt = AV_PIX_FMT_YUV422P;
783         avctx->colorspace = AVCOL_SPC_BT470BG;
784         break;
785     case MKTAG('U', 'L', 'Y', '4'):
786         c->planes      = 3;
787         avctx->pix_fmt = AV_PIX_FMT_YUV444P;
788         avctx->colorspace = AVCOL_SPC_BT470BG;
789         break;
790     case MKTAG('U', 'Q', 'Y', '2'):
791         c->planes      = 3;
792         avctx->pix_fmt = AV_PIX_FMT_YUV422P10;
793         break;
794     case MKTAG('U', 'Q', 'R', 'G'):
795         c->planes      = 3;
796         avctx->pix_fmt = AV_PIX_FMT_GBRP10;
797         break;
798     case MKTAG('U', 'Q', 'R', 'A'):
799         c->planes      = 4;
800         avctx->pix_fmt = AV_PIX_FMT_GBRAP10;
801         break;
802     case MKTAG('U', 'L', 'H', '0'):
803         c->planes      = 3;
804         avctx->pix_fmt = AV_PIX_FMT_YUV420P;
805         avctx->colorspace = AVCOL_SPC_BT709;
806         break;
807     case MKTAG('U', 'L', 'H', '2'):
808         c->planes      = 3;
809         avctx->pix_fmt = AV_PIX_FMT_YUV422P;
810         avctx->colorspace = AVCOL_SPC_BT709;
811         break;
812     case MKTAG('U', 'L', 'H', '4'):
813         c->planes      = 3;
814         avctx->pix_fmt = AV_PIX_FMT_YUV444P;
815         avctx->colorspace = AVCOL_SPC_BT709;
816         break;
817     default:
818         av_log(avctx, AV_LOG_ERROR, "Unknown Ut Video FOURCC provided (%08X)\n",
819                avctx->codec_tag);
820         return AVERROR_INVALIDDATA;
821     }
822
823     return 0;
824 }
825
826 static av_cold int decode_end(AVCodecContext *avctx)
827 {
828     UtvideoContext * const c = avctx->priv_data;
829
830     av_freep(&c->slice_bits);
831
832     return 0;
833 }
834
835 AVCodec ff_utvideo_decoder = {
836     .name           = "utvideo",
837     .long_name      = NULL_IF_CONFIG_SMALL("Ut Video"),
838     .type           = AVMEDIA_TYPE_VIDEO,
839     .id             = AV_CODEC_ID_UTVIDEO,
840     .priv_data_size = sizeof(UtvideoContext),
841     .init           = decode_init,
842     .close          = decode_end,
843     .decode         = decode_frame,
844     .capabilities   = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_FRAME_THREADS,
845     .caps_internal  = FF_CODEC_CAP_INIT_THREADSAFE,
846 };