3 * Copyright (c) 2011 Konstantin Shishkov
5 * This file is part of FFmpeg.
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.
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.
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
30 #include "libavutil/intreadwrite.h"
33 #include "bytestream.h"
38 static int build_huff(const uint8_t *src
, VLC
*vlc
, int *fsym
)
49 for (i
= 0; i
< 256; i
++) {
53 qsort(he
, 256, sizeof(*he
), ff_ut_huff_cmp_len
);
63 while (he
[last
].len
== 255 && last
)
67 for (i
= last
; i
>= 0; i
--) {
68 codes
[i
] = code
>> (32 - he
[i
].len
);
71 code
+= 0x80000000u
>> (he
[i
].len
- 1);
74 return ff_init_vlc_sparse(vlc
, FFMIN(he
[last
].len
, 11), last
+ 1,
75 bits
, sizeof(*bits
), sizeof(*bits
),
76 codes
, sizeof(*codes
), sizeof(*codes
),
77 syms
, sizeof(*syms
), sizeof(*syms
), 0);
80 static int decode_plane(UtvideoContext
*c
, int plane_no
,
81 uint8_t *dst
, int step
, int stride
,
82 int width
, int height
,
83 const uint8_t *src
, int use_pred
)
90 const int cmask
= ~(!plane_no
&& c
->avctx
->pix_fmt
== AV_PIX_FMT_YUV420P
);
92 if (build_huff(src
, &vlc
, &fsym
)) {
93 av_log(c
->avctx
, AV_LOG_ERROR
, "Cannot build Huffman codes\n");
94 return AVERROR_INVALIDDATA
;
96 if (fsym
>= 0) { // build_huff reported a symbol to fill slices with
98 for (slice
= 0; slice
< c
->slices
; slice
++) {
102 send
= (height
* (slice
+ 1) / c
->slices
) & cmask
;
103 dest
= dst
+ sstart
* stride
;
106 for (j
= sstart
; j
< send
; j
++) {
107 for (i
= 0; i
< width
* step
; i
+= step
) {
124 for (slice
= 0; slice
< c
->slices
; slice
++) {
126 int slice_data_start
, slice_data_end
, slice_size
;
129 send
= (height
* (slice
+ 1) / c
->slices
) & cmask
;
130 dest
= dst
+ sstart
* stride
;
132 // slice offset and size validation was done earlier
133 slice_data_start
= slice
? AV_RL32(src
+ slice
* 4 - 4) : 0;
134 slice_data_end
= AV_RL32(src
+ slice
* 4);
135 slice_size
= slice_data_end
- slice_data_start
;
138 av_log(c
->avctx
, AV_LOG_ERROR
, "Plane has more than one symbol "
139 "yet a slice has a length of zero.\n");
143 memcpy(c
->slice_bits
, src
+ slice_data_start
+ c
->slices
* 4,
145 memset(c
->slice_bits
+ slice_size
, 0, FF_INPUT_BUFFER_PADDING_SIZE
);
146 c
->bdsp
.bswap_buf((uint32_t *) c
->slice_bits
,
147 (uint32_t *) c
->slice_bits
,
148 (slice_data_end
- slice_data_start
+ 3) >> 2);
149 init_get_bits(&gb
, c
->slice_bits
, slice_size
* 8);
152 for (j
= sstart
; j
< send
; j
++) {
153 for (i
= 0; i
< width
* step
; i
+= step
) {
154 if (get_bits_left(&gb
) <= 0) {
155 av_log(c
->avctx
, AV_LOG_ERROR
,
156 "Slice decoding ran out of bits\n");
159 pix
= get_vlc2(&gb
, vlc
.table
, vlc
.bits
, 3);
161 av_log(c
->avctx
, AV_LOG_ERROR
, "Decoding error\n");
172 if (get_bits_left(&gb
) > 32)
173 av_log(c
->avctx
, AV_LOG_WARNING
,
174 "%d bits left after decoding slice\n", get_bits_left(&gb
));
182 return AVERROR_INVALIDDATA
;
185 static void restore_rgb_planes(uint8_t *src
, int step
, int stride
, int width
,
191 for (j
= 0; j
< height
; j
++) {
192 for (i
= 0; i
< width
* step
; i
+= step
) {
196 src
[i
] = r
+ g
- 0x80;
197 src
[i
+ 2] = b
+ g
- 0x80;
203 static void restore_median(uint8_t *src
, int step
, int stride
,
204 int width
, int height
, int slices
, int rmode
)
209 int slice_start
, slice_height
;
210 const int cmask
= ~rmode
;
212 for (slice
= 0; slice
< slices
; slice
++) {
213 slice_start
= ((slice
* height
) / slices
) & cmask
;
214 slice_height
= ((((slice
+ 1) * height
) / slices
) & cmask
) -
217 bsrc
= src
+ slice_start
* stride
;
219 // first line - left neighbour prediction
222 for (i
= step
; i
< width
* step
; i
+= step
) {
227 if (slice_height
== 1)
229 // second line - first element has top prediction, the rest uses median
233 for (i
= step
; i
< width
* step
; i
+= step
) {
234 B
= bsrc
[i
- stride
];
235 bsrc
[i
] += mid_pred(A
, B
, (uint8_t)(A
+ B
- C
));
240 // the rest of lines use continuous median prediction
241 for (j
= 2; j
< slice_height
; j
++) {
242 for (i
= 0; i
< width
* step
; i
+= step
) {
243 B
= bsrc
[i
- stride
];
244 bsrc
[i
] += mid_pred(A
, B
, (uint8_t)(A
+ B
- C
));
253 /* UtVideo interlaced mode treats every two lines as a single one,
254 * so restoring function should take care of possible padding between
255 * two parts of the same "line".
257 static void restore_median_il(uint8_t *src
, int step
, int stride
,
258 int width
, int height
, int slices
, int rmode
)
263 int slice_start
, slice_height
;
264 const int cmask
= ~(rmode
? 3 : 1);
265 const int stride2
= stride
<< 1;
267 for (slice
= 0; slice
< slices
; slice
++) {
268 slice_start
= ((slice
* height
) / slices
) & cmask
;
269 slice_height
= ((((slice
+ 1) * height
) / slices
) & cmask
) -
273 bsrc
= src
+ slice_start
* stride
;
275 // first line - left neighbour prediction
278 for (i
= step
; i
< width
* step
; i
+= step
) {
282 for (i
= 0; i
< width
* step
; i
+= step
) {
283 bsrc
[stride
+ i
] += A
;
284 A
= bsrc
[stride
+ i
];
287 if (slice_height
== 1)
289 // second line - first element has top prediction, the rest uses median
293 for (i
= step
; i
< width
* step
; i
+= step
) {
294 B
= bsrc
[i
- stride2
];
295 bsrc
[i
] += mid_pred(A
, B
, (uint8_t)(A
+ B
- C
));
299 for (i
= 0; i
< width
* step
; i
+= step
) {
300 B
= bsrc
[i
- stride
];
301 bsrc
[stride
+ i
] += mid_pred(A
, B
, (uint8_t)(A
+ B
- C
));
303 A
= bsrc
[stride
+ i
];
306 // the rest of lines use continuous median prediction
307 for (j
= 2; j
< slice_height
; j
++) {
308 for (i
= 0; i
< width
* step
; i
+= step
) {
309 B
= bsrc
[i
- stride2
];
310 bsrc
[i
] += mid_pred(A
, B
, (uint8_t)(A
+ B
- C
));
314 for (i
= 0; i
< width
* step
; i
+= step
) {
315 B
= bsrc
[i
- stride
];
316 bsrc
[i
+ stride
] += mid_pred(A
, B
, (uint8_t)(A
+ B
- C
));
318 A
= bsrc
[i
+ stride
];
325 static int decode_frame(AVCodecContext
*avctx
, void *data
, int *got_frame
,
328 const uint8_t *buf
= avpkt
->data
;
329 int buf_size
= avpkt
->size
;
330 UtvideoContext
*c
= avctx
->priv_data
;
332 const uint8_t *plane_start
[5];
333 int plane_size
, max_slice_size
= 0, slice_start
, slice_end
, slice_size
;
336 ThreadFrame frame
= { .f
= data
};
338 if ((ret
= ff_thread_get_buffer(avctx
, &frame
, 0)) < 0)
341 /* parse plane structure to get frame flags and validate slice offsets */
342 bytestream2_init(&gb
, buf
, buf_size
);
343 for (i
= 0; i
< c
->planes
; i
++) {
344 plane_start
[i
] = gb
.buffer
;
345 if (bytestream2_get_bytes_left(&gb
) < 256 + 4 * c
->slices
) {
346 av_log(avctx
, AV_LOG_ERROR
, "Insufficient data for a plane\n");
347 return AVERROR_INVALIDDATA
;
349 bytestream2_skipu(&gb
, 256);
352 for (j
= 0; j
< c
->slices
; j
++) {
353 slice_end
= bytestream2_get_le32u(&gb
);
354 slice_size
= slice_end
- slice_start
;
355 if (slice_end
< 0 || slice_size
< 0 ||
356 bytestream2_get_bytes_left(&gb
) < slice_end
) {
357 av_log(avctx
, AV_LOG_ERROR
, "Incorrect slice size\n");
358 return AVERROR_INVALIDDATA
;
360 slice_start
= slice_end
;
361 max_slice_size
= FFMAX(max_slice_size
, slice_size
);
363 plane_size
= slice_end
;
364 bytestream2_skipu(&gb
, plane_size
);
366 plane_start
[c
->planes
] = gb
.buffer
;
367 if (bytestream2_get_bytes_left(&gb
) < c
->frame_info_size
) {
368 av_log(avctx
, AV_LOG_ERROR
, "Not enough data for frame information\n");
369 return AVERROR_INVALIDDATA
;
371 c
->frame_info
= bytestream2_get_le32u(&gb
);
372 av_log(avctx
, AV_LOG_DEBUG
, "frame information flags %"PRIX32
"\n",
375 c
->frame_pred
= (c
->frame_info
>> 8) & 3;
377 if (c
->frame_pred
== PRED_GRADIENT
) {
378 avpriv_request_sample(avctx
, "Frame with gradient prediction");
379 return AVERROR_PATCHWELCOME
;
382 av_fast_malloc(&c
->slice_bits
, &c
->slice_bits_size
,
383 max_slice_size
+ FF_INPUT_BUFFER_PADDING_SIZE
);
385 if (!c
->slice_bits
) {
386 av_log(avctx
, AV_LOG_ERROR
, "Cannot allocate temporary buffer\n");
387 return AVERROR(ENOMEM
);
390 switch (c
->avctx
->pix_fmt
) {
391 case AV_PIX_FMT_RGB24
:
392 case AV_PIX_FMT_RGBA
:
393 for (i
= 0; i
< c
->planes
; i
++) {
394 ret
= decode_plane(c
, i
, frame
.f
->data
[0] + ff_ut_rgb_order
[i
],
395 c
->planes
, frame
.f
->linesize
[0], avctx
->width
,
396 avctx
->height
, plane_start
[i
],
397 c
->frame_pred
== PRED_LEFT
);
400 if (c
->frame_pred
== PRED_MEDIAN
) {
401 if (!c
->interlaced
) {
402 restore_median(frame
.f
->data
[0] + ff_ut_rgb_order
[i
],
403 c
->planes
, frame
.f
->linesize
[0], avctx
->width
,
404 avctx
->height
, c
->slices
, 0);
406 restore_median_il(frame
.f
->data
[0] + ff_ut_rgb_order
[i
],
407 c
->planes
, frame
.f
->linesize
[0],
408 avctx
->width
, avctx
->height
, c
->slices
,
413 restore_rgb_planes(frame
.f
->data
[0], c
->planes
, frame
.f
->linesize
[0],
414 avctx
->width
, avctx
->height
);
416 case AV_PIX_FMT_YUV420P
:
417 for (i
= 0; i
< 3; i
++) {
418 ret
= decode_plane(c
, i
, frame
.f
->data
[i
], 1, frame
.f
->linesize
[i
],
419 avctx
->width
>> !!i
, avctx
->height
>> !!i
,
420 plane_start
[i
], c
->frame_pred
== PRED_LEFT
);
423 if (c
->frame_pred
== PRED_MEDIAN
) {
424 if (!c
->interlaced
) {
425 restore_median(frame
.f
->data
[i
], 1, frame
.f
->linesize
[i
],
426 avctx
->width
>> !!i
, avctx
->height
>> !!i
,
429 restore_median_il(frame
.f
->data
[i
], 1, frame
.f
->linesize
[i
],
431 avctx
->height
>> !!i
,
437 case AV_PIX_FMT_YUV422P
:
438 for (i
= 0; i
< 3; i
++) {
439 ret
= decode_plane(c
, i
, frame
.f
->data
[i
], 1, frame
.f
->linesize
[i
],
440 avctx
->width
>> !!i
, avctx
->height
,
441 plane_start
[i
], c
->frame_pred
== PRED_LEFT
);
444 if (c
->frame_pred
== PRED_MEDIAN
) {
445 if (!c
->interlaced
) {
446 restore_median(frame
.f
->data
[i
], 1, frame
.f
->linesize
[i
],
447 avctx
->width
>> !!i
, avctx
->height
,
450 restore_median_il(frame
.f
->data
[i
], 1, frame
.f
->linesize
[i
],
451 avctx
->width
>> !!i
, avctx
->height
,
459 frame
.f
->key_frame
= 1;
460 frame
.f
->pict_type
= AV_PICTURE_TYPE_I
;
461 frame
.f
->interlaced_frame
= !!c
->interlaced
;
465 /* always report that the buffer was completely consumed */
469 static av_cold
int decode_init(AVCodecContext
*avctx
)
471 UtvideoContext
* const c
= avctx
->priv_data
;
475 ff_bswapdsp_init(&c
->bdsp
);
477 if (avctx
->extradata_size
< 16) {
478 av_log(avctx
, AV_LOG_ERROR
,
479 "Insufficient extradata size %d, should be at least 16\n",
480 avctx
->extradata_size
);
481 return AVERROR_INVALIDDATA
;
484 av_log(avctx
, AV_LOG_DEBUG
, "Encoder version %d.%d.%d.%d\n",
485 avctx
->extradata
[3], avctx
->extradata
[2],
486 avctx
->extradata
[1], avctx
->extradata
[0]);
487 av_log(avctx
, AV_LOG_DEBUG
, "Original format %"PRIX32
"\n",
488 AV_RB32(avctx
->extradata
+ 4));
489 c
->frame_info_size
= AV_RL32(avctx
->extradata
+ 8);
490 c
->flags
= AV_RL32(avctx
->extradata
+ 12);
492 if (c
->frame_info_size
!= 4)
493 avpriv_request_sample(avctx
, "Frame info not 4 bytes");
494 av_log(avctx
, AV_LOG_DEBUG
, "Encoding parameters %08"PRIX32
"\n", c
->flags
);
495 c
->slices
= (c
->flags
>> 24) + 1;
496 c
->compression
= c
->flags
& 1;
497 c
->interlaced
= c
->flags
& 0x800;
499 c
->slice_bits_size
= 0;
501 switch (avctx
->codec_tag
) {
502 case MKTAG('U', 'L', 'R', 'G'):
504 avctx
->pix_fmt
= AV_PIX_FMT_RGB24
;
506 case MKTAG('U', 'L', 'R', 'A'):
508 avctx
->pix_fmt
= AV_PIX_FMT_RGBA
;
510 case MKTAG('U', 'L', 'Y', '0'):
512 avctx
->pix_fmt
= AV_PIX_FMT_YUV420P
;
513 avctx
->colorspace
= AVCOL_SPC_BT470BG
;
515 case MKTAG('U', 'L', 'Y', '2'):
517 avctx
->pix_fmt
= AV_PIX_FMT_YUV422P
;
518 avctx
->colorspace
= AVCOL_SPC_BT470BG
;
520 case MKTAG('U', 'L', 'H', '0'):
522 avctx
->pix_fmt
= AV_PIX_FMT_YUV420P
;
523 avctx
->colorspace
= AVCOL_SPC_BT709
;
525 case MKTAG('U', 'L', 'H', '2'):
527 avctx
->pix_fmt
= AV_PIX_FMT_YUV422P
;
528 avctx
->colorspace
= AVCOL_SPC_BT709
;
531 av_log(avctx
, AV_LOG_ERROR
, "Unknown Ut Video FOURCC provided (%08X)\n",
533 return AVERROR_INVALIDDATA
;
539 static av_cold
int decode_end(AVCodecContext
*avctx
)
541 UtvideoContext
* const c
= avctx
->priv_data
;
543 av_freep(&c
->slice_bits
);
548 AVCodec ff_utvideo_decoder
= {
550 .long_name
= NULL_IF_CONFIG_SMALL("Ut Video"),
551 .type
= AVMEDIA_TYPE_VIDEO
,
552 .id
= AV_CODEC_ID_UTVIDEO
,
553 .priv_data_size
= sizeof(UtvideoContext
),
556 .decode
= decode_frame
,
557 .capabilities
= CODEC_CAP_DR1
| CODEC_CAP_FRAME_THREADS
,