2 * Duck/ON2 TrueMotion 2 Decoder
3 * Copyright (c) 2005 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
24 * Duck TrueMotion2 decoder.
31 #include "bytestream.h"
35 #define TM2_ESCAPE 0x80000000
38 /* Huffman-coded streams of different types of blocks */
61 typedef struct TM2Context
{
62 AVCodecContext
*avctx
;
72 int *tokens
[TM2_NUM_STREAMS
];
73 int tok_lens
[TM2_NUM_STREAMS
];
74 int tok_ptrs
[TM2_NUM_STREAMS
];
75 int deltas
[TM2_NUM_STREAMS
][TM2_DELTAS
];
76 /* for blocks decoding */
82 /* data for current and previous frame */
83 int *Y1_base
, *U1_base
, *V1_base
, *Y2_base
, *U2_base
, *V2_base
;
84 int *Y1
, *U1
, *V1
, *Y2
, *U2
, *V2
;
85 int y_stride
, uv_stride
;
90 * Huffman codes for each of streams
92 typedef struct TM2Codes
{
93 VLC vlc
; ///< table for FFmpeg bitstream reader
95 int *recode
; ///< table for converting from code indexes to values
100 * structure for gathering Huffman codes information
102 typedef struct TM2Huff
{
103 int val_bits
; ///< length of literal
104 int max_bits
; ///< maximum length of code
105 int min_bits
; ///< minimum length of code
106 int nodes
; ///< total number of nodes in tree
107 int num
; ///< current number filled
108 int max_num
; ///< total number of codes
109 int *nums
; ///< literals
110 uint32_t *bits
; ///< codes
111 int *lens
; ///< codelengths
114 static int tm2_read_tree(TM2Context
*ctx
, uint32_t prefix
, int length
, TM2Huff
*huff
)
117 if (length
> huff
->max_bits
) {
118 av_log(ctx
->avctx
, AV_LOG_ERROR
, "Tree exceeded its given depth (%i)\n",
120 return AVERROR_INVALIDDATA
;
123 if (!get_bits1(&ctx
->gb
)) { /* literal */
127 if (huff
->num
>= huff
->max_num
) {
128 av_log(ctx
->avctx
, AV_LOG_DEBUG
, "Too many literals\n");
129 return AVERROR_INVALIDDATA
;
131 huff
->nums
[huff
->num
] = get_bits_long(&ctx
->gb
, huff
->val_bits
);
132 huff
->bits
[huff
->num
] = prefix
;
133 huff
->lens
[huff
->num
] = length
;
136 } else { /* non-terminal node */
137 if ((ret
= tm2_read_tree(ctx
, prefix
<< 1, length
+ 1, huff
)) < 0)
139 if ((ret
= tm2_read_tree(ctx
, (prefix
<< 1) | 1, length
+ 1, huff
)) < 0)
145 static int tm2_build_huff_table(TM2Context
*ctx
, TM2Codes
*code
)
150 huff
.val_bits
= get_bits(&ctx
->gb
, 5);
151 huff
.max_bits
= get_bits(&ctx
->gb
, 5);
152 huff
.min_bits
= get_bits(&ctx
->gb
, 5);
153 huff
.nodes
= get_bits_long(&ctx
->gb
, 17);
156 /* check for correct codes parameters */
157 if ((huff
.val_bits
< 1) || (huff
.val_bits
> 32) ||
158 (huff
.max_bits
< 0) || (huff
.max_bits
> 25)) {
159 av_log(ctx
->avctx
, AV_LOG_ERROR
, "Incorrect tree parameters - literal "
160 "length: %i, max code length: %i\n", huff
.val_bits
, huff
.max_bits
);
161 return AVERROR_INVALIDDATA
;
163 if ((huff
.nodes
<= 0) || (huff
.nodes
> 0x10000)) {
164 av_log(ctx
->avctx
, AV_LOG_ERROR
, "Incorrect number of Huffman tree "
165 "nodes: %i\n", huff
.nodes
);
166 return AVERROR_INVALIDDATA
;
169 if (huff
.max_bits
== 0)
172 /* allocate space for codes - it is exactly ceil(nodes / 2) entries */
173 huff
.max_num
= (huff
.nodes
+ 1) >> 1;
174 huff
.nums
= av_calloc(huff
.max_num
, sizeof(int));
175 huff
.bits
= av_calloc(huff
.max_num
, sizeof(uint32_t));
176 huff
.lens
= av_calloc(huff
.max_num
, sizeof(int));
178 if (!huff
.nums
|| !huff
.bits
|| !huff
.lens
) {
179 res
= AVERROR(ENOMEM
);
183 res
= tm2_read_tree(ctx
, 0, 0, &huff
);
185 if (huff
.num
!= huff
.max_num
) {
186 av_log(ctx
->avctx
, AV_LOG_ERROR
, "Got less codes than expected: %i of %i\n",
187 huff
.num
, huff
.max_num
);
188 res
= AVERROR_INVALIDDATA
;
191 /* convert codes to vlc_table */
195 res
= init_vlc(&code
->vlc
, huff
.max_bits
, huff
.max_num
,
196 huff
.lens
, sizeof(int), sizeof(int),
197 huff
.bits
, sizeof(uint32_t), sizeof(uint32_t), 0);
199 av_log(ctx
->avctx
, AV_LOG_ERROR
, "Cannot build VLC table\n");
201 code
->bits
= huff
.max_bits
;
202 code
->length
= huff
.max_num
;
203 code
->recode
= av_malloc_array(code
->length
, sizeof(int));
205 res
= AVERROR(ENOMEM
);
208 for (i
= 0; i
< code
->length
; i
++)
209 code
->recode
[i
] = huff
.nums
[i
];
213 /* free allocated memory */
221 static void tm2_free_codes(TM2Codes
*code
)
223 av_free(code
->recode
);
225 ff_free_vlc(&code
->vlc
);
228 static inline int tm2_get_token(GetBitContext
*gb
, TM2Codes
*code
)
231 val
= get_vlc2(gb
, code
->vlc
.table
, code
->bits
, 1);
234 return code
->recode
[val
];
237 #define TM2_OLD_HEADER_MAGIC 0x00000100
238 #define TM2_NEW_HEADER_MAGIC 0x00000101
240 static inline int tm2_read_header(TM2Context
*ctx
, const uint8_t *buf
)
242 uint32_t magic
= AV_RL32(buf
);
245 case TM2_OLD_HEADER_MAGIC
:
246 avpriv_request_sample(ctx
->avctx
, "Old TM2 header");
248 case TM2_NEW_HEADER_MAGIC
:
251 av_log(ctx
->avctx
, AV_LOG_ERROR
, "Not a TM2 header: 0x%08"PRIX32
"\n",
253 return AVERROR_INVALIDDATA
;
257 static int tm2_read_deltas(TM2Context
*ctx
, int stream_id
)
262 d
= get_bits(&ctx
->gb
, 9);
263 mb
= get_bits(&ctx
->gb
, 5);
266 if ((d
< 1) || (d
> TM2_DELTAS
) || (mb
< 1)) {
267 av_log(ctx
->avctx
, AV_LOG_ERROR
, "Incorrect delta table: %i deltas x %i bits\n", d
, mb
);
268 return AVERROR_INVALIDDATA
;
271 for (i
= 0; i
< d
; i
++) {
272 v
= get_bits_long(&ctx
->gb
, mb
);
273 if (v
& (1 << (mb
- 1)))
274 ctx
->deltas
[stream_id
][i
] = v
- (1 << mb
);
276 ctx
->deltas
[stream_id
][i
] = v
;
278 for (; i
< TM2_DELTAS
; i
++)
279 ctx
->deltas
[stream_id
][i
] = 0;
284 static int tm2_read_stream(TM2Context
*ctx
, const uint8_t *buf
, int stream_id
, int buf_size
)
293 av_log(ctx
->avctx
, AV_LOG_ERROR
, "not enough space for len left\n");
294 return AVERROR_INVALIDDATA
;
297 /* get stream length in dwords */
298 bytestream2_init(&gb
, buf
, buf_size
);
299 len
= bytestream2_get_be32(&gb
);
305 if (len
>= INT_MAX
/4-1 || len
< 0 || skip
> buf_size
) {
306 av_log(ctx
->avctx
, AV_LOG_ERROR
, "invalid stream size\n");
307 return AVERROR_INVALIDDATA
;
310 toks
= bytestream2_get_be32(&gb
);
312 len
= bytestream2_get_be32(&gb
);
313 if (len
== TM2_ESCAPE
) {
314 len
= bytestream2_get_be32(&gb
);
317 pos
= bytestream2_tell(&gb
);
319 return AVERROR_INVALIDDATA
;
320 init_get_bits(&ctx
->gb
, buf
+ pos
, (skip
- pos
) * 8);
321 if ((ret
= tm2_read_deltas(ctx
, stream_id
)) < 0)
323 bytestream2_skip(&gb
, ((get_bits_count(&ctx
->gb
) + 31) >> 5) << 2);
326 /* skip unused fields */
327 len
= bytestream2_get_be32(&gb
);
328 if (len
== TM2_ESCAPE
) { /* some unknown length - could be escaped too */
329 bytestream2_skip(&gb
, 8); /* unused by decoder */
331 bytestream2_skip(&gb
, 4); /* unused by decoder */
334 pos
= bytestream2_tell(&gb
);
336 return AVERROR_INVALIDDATA
;
337 init_get_bits(&ctx
->gb
, buf
+ pos
, (skip
- pos
) * 8);
338 if ((ret
= tm2_build_huff_table(ctx
, &codes
)) < 0)
340 bytestream2_skip(&gb
, ((get_bits_count(&ctx
->gb
) + 31) >> 5) << 2);
343 /* check if we have sane number of tokens */
344 if ((toks
< 0) || (toks
> 0xFFFFFF)) {
345 av_log(ctx
->avctx
, AV_LOG_ERROR
, "Incorrect number of tokens: %i\n", toks
);
346 tm2_free_codes(&codes
);
347 return AVERROR_INVALIDDATA
;
349 ret
= av_reallocp_array(&ctx
->tokens
[stream_id
], toks
, sizeof(int));
351 ctx
->tok_lens
[stream_id
] = 0;
354 ctx
->tok_lens
[stream_id
] = toks
;
355 len
= bytestream2_get_be32(&gb
);
357 pos
= bytestream2_tell(&gb
);
359 return AVERROR_INVALIDDATA
;
360 init_get_bits(&ctx
->gb
, buf
+ pos
, (skip
- pos
) * 8);
361 for (i
= 0; i
< toks
; i
++) {
362 if (get_bits_left(&ctx
->gb
) <= 0) {
363 av_log(ctx
->avctx
, AV_LOG_ERROR
, "Incorrect number of tokens: %i\n", toks
);
364 return AVERROR_INVALIDDATA
;
366 ctx
->tokens
[stream_id
][i
] = tm2_get_token(&ctx
->gb
, &codes
);
367 if (stream_id
<= TM2_MOT
&& ctx
->tokens
[stream_id
][i
] >= TM2_DELTAS
|| ctx
->tokens
[stream_id
][i
]<0) {
368 av_log(ctx
->avctx
, AV_LOG_ERROR
, "Invalid delta token index %d for type %d, n=%d\n",
369 ctx
->tokens
[stream_id
][i
], stream_id
, i
);
370 return AVERROR_INVALIDDATA
;
374 for (i
= 0; i
< toks
; i
++) {
375 ctx
->tokens
[stream_id
][i
] = codes
.recode
[0];
376 if (stream_id
<= TM2_MOT
&& ctx
->tokens
[stream_id
][i
] >= TM2_DELTAS
) {
377 av_log(ctx
->avctx
, AV_LOG_ERROR
, "Invalid delta token index %d for type %d, n=%d\n",
378 ctx
->tokens
[stream_id
][i
], stream_id
, i
);
379 return AVERROR_INVALIDDATA
;
383 tm2_free_codes(&codes
);
388 static inline int GET_TOK(TM2Context
*ctx
,int type
)
390 if (ctx
->tok_ptrs
[type
] >= ctx
->tok_lens
[type
]) {
391 av_log(ctx
->avctx
, AV_LOG_ERROR
, "Read token from stream %i out of bounds (%i>=%i)\n", type
, ctx
->tok_ptrs
[type
], ctx
->tok_lens
[type
]);
394 if (type
<= TM2_MOT
) {
395 if (ctx
->tokens
[type
][ctx
->tok_ptrs
[type
]] >= TM2_DELTAS
) {
396 av_log(ctx
->avctx
, AV_LOG_ERROR
, "token %d is too large\n", ctx
->tokens
[type
][ctx
->tok_ptrs
[type
]]);
399 return ctx
->deltas
[type
][ctx
->tokens
[type
][ctx
->tok_ptrs
[type
]++]];
401 return ctx
->tokens
[type
][ctx
->tok_ptrs
[type
]++];
404 /* blocks decoding routines */
406 /* common Y, U, V pointers initialisation */
407 #define TM2_INIT_POINTERS() \
410 int Ystride, Ustride, Vstride;\
412 Ystride = ctx->y_stride;\
413 Vstride = ctx->uv_stride;\
414 Ustride = ctx->uv_stride;\
415 Y = (ctx->cur?ctx->Y2:ctx->Y1) + by * 4 * Ystride + bx * 4;\
416 V = (ctx->cur?ctx->V2:ctx->V1) + by * 2 * Vstride + bx * 2;\
417 U = (ctx->cur?ctx->U2:ctx->U1) + by * 2 * Ustride + bx * 2;\
418 last = ctx->last + bx * 4;\
419 clast = ctx->clast + bx * 4;
421 #define TM2_INIT_POINTERS_2() \
423 int oYstride, oUstride, oVstride;\
425 TM2_INIT_POINTERS();\
429 Yo = (ctx->cur?ctx->Y1:ctx->Y2) + by * 4 * oYstride + bx * 4;\
430 Vo = (ctx->cur?ctx->V1:ctx->V2) + by * 2 * oVstride + bx * 2;\
431 Uo = (ctx->cur?ctx->U1:ctx->U2) + by * 2 * oUstride + bx * 2;
433 /* recalculate last and delta values for next blocks */
434 #define TM2_RECALC_BLOCK(CHR, stride, last, CD) {\
435 CD[0] = CHR[1] - last[1];\
436 CD[1] = (int)CHR[stride + 1] - (int)CHR[1];\
437 last[0] = (int)CHR[stride + 0];\
438 last[1] = (int)CHR[stride + 1];}
440 /* common operations - add deltas to 4x4 block of luma or 2x2 blocks of chroma */
441 static inline void tm2_apply_deltas(TM2Context
*ctx
, int* Y
, int stride
, int *deltas
, int *last
)
446 for (j
= 0; j
< 4; j
++){
448 for (i
= 0; i
< 4; i
++){
449 d
= deltas
[i
+ j
* 4];
452 Y
[i
] = av_clip_uint8(last
[i
]);
459 static inline void tm2_high_chroma(int *data
, int stride
, int *last
, int *CD
, int *deltas
)
462 for (j
= 0; j
< 2; j
++) {
463 for (i
= 0; i
< 2; i
++) {
464 CD
[j
] += deltas
[i
+ j
* 2];
472 static inline void tm2_low_chroma(int *data
, int stride
, int *clast
, int *CD
, int *deltas
, int bx
)
482 t
= (CD
[0] + CD
[1]) >> 1;
483 l
= (prev
- CD
[0] - CD
[1] + clast
[1]) >> 1;
484 CD
[1] = CD
[0] + CD
[1] - t
;
488 tm2_high_chroma(data
, stride
, clast
, CD
, deltas
);
491 static inline void tm2_hi_res_block(TM2Context
*ctx
, AVFrame
*pic
, int bx
, int by
)
498 for (i
= 0; i
< 4; i
++) {
499 deltas
[i
] = GET_TOK(ctx
, TM2_C_HI
);
500 deltas
[i
+ 4] = GET_TOK(ctx
, TM2_C_HI
);
502 tm2_high_chroma(U
, Ustride
, clast
, ctx
->CD
, deltas
);
503 tm2_high_chroma(V
, Vstride
, clast
+ 2, ctx
->CD
+ 2, deltas
+ 4);
506 for (i
= 0; i
< 16; i
++)
507 deltas
[i
] = GET_TOK(ctx
, TM2_L_HI
);
509 tm2_apply_deltas(ctx
, Y
, Ystride
, deltas
, last
);
512 static inline void tm2_med_res_block(TM2Context
*ctx
, AVFrame
*pic
, int bx
, int by
)
519 deltas
[0] = GET_TOK(ctx
, TM2_C_LO
);
520 deltas
[1] = deltas
[2] = deltas
[3] = 0;
521 tm2_low_chroma(U
, Ustride
, clast
, ctx
->CD
, deltas
, bx
);
523 deltas
[0] = GET_TOK(ctx
, TM2_C_LO
);
524 deltas
[1] = deltas
[2] = deltas
[3] = 0;
525 tm2_low_chroma(V
, Vstride
, clast
+ 2, ctx
->CD
+ 2, deltas
, bx
);
528 for (i
= 0; i
< 16; i
++)
529 deltas
[i
] = GET_TOK(ctx
, TM2_L_HI
);
531 tm2_apply_deltas(ctx
, Y
, Ystride
, deltas
, last
);
534 static inline void tm2_low_res_block(TM2Context
*ctx
, AVFrame
*pic
, int bx
, int by
)
542 deltas
[0] = GET_TOK(ctx
, TM2_C_LO
);
543 deltas
[1] = deltas
[2] = deltas
[3] = 0;
544 tm2_low_chroma(U
, Ustride
, clast
, ctx
->CD
, deltas
, bx
);
546 deltas
[0] = GET_TOK(ctx
, TM2_C_LO
);
547 deltas
[1] = deltas
[2] = deltas
[3] = 0;
548 tm2_low_chroma(V
, Vstride
, clast
+ 2, ctx
->CD
+ 2, deltas
, bx
);
551 for (i
= 0; i
< 16; i
++)
554 deltas
[ 0] = GET_TOK(ctx
, TM2_L_LO
);
555 deltas
[ 2] = GET_TOK(ctx
, TM2_L_LO
);
556 deltas
[ 8] = GET_TOK(ctx
, TM2_L_LO
);
557 deltas
[10] = GET_TOK(ctx
, TM2_L_LO
);
560 last
[0] = (last
[-1] - ctx
->D
[0] - ctx
->D
[1] - ctx
->D
[2] - ctx
->D
[3] + last
[1]) >> 1;
562 last
[0] = (last
[1] - ctx
->D
[0] - ctx
->D
[1] - ctx
->D
[2] - ctx
->D
[3])>> 1;
563 last
[2] = (last
[1] + last
[3]) >> 1;
565 t1
= ctx
->D
[0] + ctx
->D
[1];
567 ctx
->D
[1] = t1
- (t1
>> 1);
568 t2
= ctx
->D
[2] + ctx
->D
[3];
570 ctx
->D
[3] = t2
- (t2
>> 1);
572 tm2_apply_deltas(ctx
, Y
, Ystride
, deltas
, last
);
575 static inline void tm2_null_res_block(TM2Context
*ctx
, AVFrame
*pic
, int bx
, int by
)
579 int left
, right
, diff
;
584 deltas
[0] = deltas
[1] = deltas
[2] = deltas
[3] = 0;
585 tm2_low_chroma(U
, Ustride
, clast
, ctx
->CD
, deltas
, bx
);
587 deltas
[0] = deltas
[1] = deltas
[2] = deltas
[3] = 0;
588 tm2_low_chroma(V
, Vstride
, clast
+ 2, ctx
->CD
+ 2, deltas
, bx
);
591 for (i
= 0; i
< 16; i
++)
594 ct
= ctx
->D
[0] + ctx
->D
[1] + ctx
->D
[2] + ctx
->D
[3];
597 left
= last
[-1] - ct
;
603 last
[0] = left
+ (diff
>> 2);
604 last
[1] = left
+ (diff
>> 1);
605 last
[2] = right
- (diff
>> 2);
610 ctx
->D
[0] = (tp
+ (ct
>> 2)) - left
;
612 ctx
->D
[1] = (tp
+ (ct
>> 1)) - left
;
614 ctx
->D
[2] = ((tp
+ ct
) - (ct
>> 2)) - left
;
616 ctx
->D
[3] = (tp
+ ct
) - left
;
618 tm2_apply_deltas(ctx
, Y
, Ystride
, deltas
, last
);
621 static inline void tm2_still_block(TM2Context
*ctx
, AVFrame
*pic
, int bx
, int by
)
624 TM2_INIT_POINTERS_2();
627 for (j
= 0; j
< 2; j
++) {
628 for (i
= 0; i
< 2; i
++){
632 U
+= Ustride
; V
+= Vstride
;
633 Uo
+= oUstride
; Vo
+= oVstride
;
637 TM2_RECALC_BLOCK(U
, Ustride
, clast
, ctx
->CD
);
638 TM2_RECALC_BLOCK(V
, Vstride
, (clast
+ 2), (ctx
->CD
+ 2));
641 ctx
->D
[0] = Yo
[3] - last
[3];
642 ctx
->D
[1] = Yo
[3 + oYstride
] - Yo
[3];
643 ctx
->D
[2] = Yo
[3 + oYstride
* 2] - Yo
[3 + oYstride
];
644 ctx
->D
[3] = Yo
[3 + oYstride
* 3] - Yo
[3 + oYstride
* 2];
646 for (j
= 0; j
< 4; j
++) {
647 for (i
= 0; i
< 4; i
++) {
656 static inline void tm2_update_block(TM2Context
*ctx
, AVFrame
*pic
, int bx
, int by
)
660 TM2_INIT_POINTERS_2();
663 for (j
= 0; j
< 2; j
++) {
664 for (i
= 0; i
< 2; i
++) {
665 U
[i
] = Uo
[i
] + GET_TOK(ctx
, TM2_UPD
);
666 V
[i
] = Vo
[i
] + GET_TOK(ctx
, TM2_UPD
);
675 TM2_RECALC_BLOCK(U
, Ustride
, clast
, ctx
->CD
);
676 TM2_RECALC_BLOCK(V
, Vstride
, (clast
+ 2), (ctx
->CD
+ 2));
679 ctx
->D
[0] = Yo
[3] - last
[3];
680 ctx
->D
[1] = Yo
[3 + oYstride
] - Yo
[3];
681 ctx
->D
[2] = Yo
[3 + oYstride
* 2] - Yo
[3 + oYstride
];
682 ctx
->D
[3] = Yo
[3 + oYstride
* 3] - Yo
[3 + oYstride
* 2];
684 for (j
= 0; j
< 4; j
++) {
686 for (i
= 0; i
< 4; i
++) {
687 Y
[i
] = Yo
[i
] + GET_TOK(ctx
, TM2_UPD
);
690 ctx
->D
[j
] = last
[3] - d
;
696 static inline void tm2_motion_block(TM2Context
*ctx
, AVFrame
*pic
, int bx
, int by
)
700 TM2_INIT_POINTERS_2();
702 mx
= GET_TOK(ctx
, TM2_MOT
);
703 my
= GET_TOK(ctx
, TM2_MOT
);
704 mx
= av_clip(mx
, -(bx
* 4 + 4), ctx
->avctx
->width
- bx
* 4);
705 my
= av_clip(my
, -(by
* 4 + 4), ctx
->avctx
->height
- by
* 4);
707 if (4*bx
+mx
<0 || 4*by
+my
<0 || 4*bx
+mx
+4 > ctx
->avctx
->width
|| 4*by
+my
+4 > ctx
->avctx
->height
) {
708 av_log(ctx
->avctx
, AV_LOG_ERROR
, "MV out of picture\n");
712 Yo
+= my
* oYstride
+ mx
;
713 Uo
+= (my
>> 1) * oUstride
+ (mx
>> 1);
714 Vo
+= (my
>> 1) * oVstride
+ (mx
>> 1);
717 for (j
= 0; j
< 2; j
++) {
718 for (i
= 0; i
< 2; i
++) {
729 TM2_RECALC_BLOCK(U
, Ustride
, clast
, ctx
->CD
);
730 TM2_RECALC_BLOCK(V
, Vstride
, (clast
+ 2), (ctx
->CD
+ 2));
733 for (j
= 0; j
< 4; j
++) {
734 for (i
= 0; i
< 4; i
++) {
740 /* calculate deltas */
742 ctx
->D
[0] = Y
[3] - last
[3];
743 ctx
->D
[1] = Y
[3 + Ystride
] - Y
[3];
744 ctx
->D
[2] = Y
[3 + Ystride
* 2] - Y
[3 + Ystride
];
745 ctx
->D
[3] = Y
[3 + Ystride
* 3] - Y
[3 + Ystride
* 2];
746 for (i
= 0; i
< 4; i
++)
747 last
[i
] = Y
[i
+ Ystride
* 3];
750 static int tm2_decode_blocks(TM2Context
*ctx
, AVFrame
*p
)
753 int w
= ctx
->avctx
->width
, h
= ctx
->avctx
->height
, bw
= w
>> 2, bh
= h
>> 2, cw
= w
>> 1;
759 for (i
= 0; i
< TM2_NUM_STREAMS
; i
++)
760 ctx
->tok_ptrs
[i
] = 0;
762 if (ctx
->tok_lens
[TM2_TYPE
]<bw
*bh
) {
763 av_log(ctx
->avctx
,AV_LOG_ERROR
,"Got %i tokens for %i blocks\n",ctx
->tok_lens
[TM2_TYPE
],bw
*bh
);
764 return AVERROR_INVALIDDATA
;
767 memset(ctx
->last
, 0, 4 * bw
* sizeof(int));
768 memset(ctx
->clast
, 0, 4 * bw
* sizeof(int));
770 for (j
= 0; j
< bh
; j
++) {
771 memset(ctx
->D
, 0, 4 * sizeof(int));
772 memset(ctx
->CD
, 0, 4 * sizeof(int));
773 for (i
= 0; i
< bw
; i
++) {
774 type
= GET_TOK(ctx
, TM2_TYPE
);
777 tm2_hi_res_block(ctx
, p
, i
, j
);
780 tm2_med_res_block(ctx
, p
, i
, j
);
783 tm2_low_res_block(ctx
, p
, i
, j
);
786 tm2_null_res_block(ctx
, p
, i
, j
);
789 tm2_update_block(ctx
, p
, i
, j
);
793 tm2_still_block(ctx
, p
, i
, j
);
797 tm2_motion_block(ctx
, p
, i
, j
);
801 av_log(ctx
->avctx
, AV_LOG_ERROR
, "Skipping unknown block type %i\n", type
);
806 /* copy data from our buffer to AVFrame */
807 Y
= (ctx
->cur
?ctx
->Y2
:ctx
->Y1
);
808 U
= (ctx
->cur
?ctx
->U2
:ctx
->U1
);
809 V
= (ctx
->cur
?ctx
->V2
:ctx
->V1
);
811 for (j
= 0; j
< h
; j
++) {
812 for (i
= 0; i
< w
; i
++) {
813 int y
= Y
[i
], u
= U
[i
>> 1], v
= V
[i
>> 1];
814 dst
[3*i
+0] = av_clip_uint8(y
+ v
);
815 dst
[3*i
+1] = av_clip_uint8(y
);
816 dst
[3*i
+2] = av_clip_uint8(y
+ u
);
819 /* horizontal edge extension */
820 Y
[-4] = Y
[-3] = Y
[-2] = Y
[-1] = Y
[0];
821 Y
[w
+ 3] = Y
[w
+ 2] = Y
[w
+ 1] = Y
[w
] = Y
[w
- 1];
823 /* vertical edge extension */
825 memcpy(Y
- 4 - 1 * ctx
->y_stride
, Y
- 4, ctx
->y_stride
);
826 memcpy(Y
- 4 - 2 * ctx
->y_stride
, Y
- 4, ctx
->y_stride
);
827 memcpy(Y
- 4 - 3 * ctx
->y_stride
, Y
- 4, ctx
->y_stride
);
828 memcpy(Y
- 4 - 4 * ctx
->y_stride
, Y
- 4, ctx
->y_stride
);
829 } else if (j
== h
- 1) {
830 memcpy(Y
- 4 + 1 * ctx
->y_stride
, Y
- 4, ctx
->y_stride
);
831 memcpy(Y
- 4 + 2 * ctx
->y_stride
, Y
- 4, ctx
->y_stride
);
832 memcpy(Y
- 4 + 3 * ctx
->y_stride
, Y
- 4, ctx
->y_stride
);
833 memcpy(Y
- 4 + 4 * ctx
->y_stride
, Y
- 4, ctx
->y_stride
);
838 /* horizontal edge extension */
839 U
[-2] = U
[-1] = U
[0];
840 V
[-2] = V
[-1] = V
[0];
841 U
[cw
+ 1] = U
[cw
] = U
[cw
- 1];
842 V
[cw
+ 1] = V
[cw
] = V
[cw
- 1];
844 /* vertical edge extension */
846 memcpy(U
- 2 - 1 * ctx
->uv_stride
, U
- 2, ctx
->uv_stride
);
847 memcpy(V
- 2 - 1 * ctx
->uv_stride
, V
- 2, ctx
->uv_stride
);
848 memcpy(U
- 2 - 2 * ctx
->uv_stride
, U
- 2, ctx
->uv_stride
);
849 memcpy(V
- 2 - 2 * ctx
->uv_stride
, V
- 2, ctx
->uv_stride
);
850 } else if (j
== h
- 1) {
851 memcpy(U
- 2 + 1 * ctx
->uv_stride
, U
- 2, ctx
->uv_stride
);
852 memcpy(V
- 2 + 1 * ctx
->uv_stride
, V
- 2, ctx
->uv_stride
);
853 memcpy(U
- 2 + 2 * ctx
->uv_stride
, U
- 2, ctx
->uv_stride
);
854 memcpy(V
- 2 + 2 * ctx
->uv_stride
, V
- 2, ctx
->uv_stride
);
860 dst
+= p
->linesize
[0];
866 static const int tm2_stream_order
[TM2_NUM_STREAMS
] = {
867 TM2_C_HI
, TM2_C_LO
, TM2_L_HI
, TM2_L_LO
, TM2_UPD
, TM2_MOT
, TM2_TYPE
870 #define TM2_HEADER_SIZE 40
872 static int decode_frame(AVCodecContext
*avctx
,
873 void *data
, int *got_frame
,
876 TM2Context
* const l
= avctx
->priv_data
;
877 const uint8_t *buf
= avpkt
->data
;
878 int buf_size
= avpkt
->size
& ~3;
879 AVFrame
* const p
= l
->pic
;
880 int offset
= TM2_HEADER_SIZE
;
883 av_fast_padded_malloc(&l
->buffer
, &l
->buffer_size
, buf_size
);
885 av_log(avctx
, AV_LOG_ERROR
, "Cannot allocate temporary buffer\n");
886 return AVERROR(ENOMEM
);
889 if ((ret
= ff_reget_buffer(avctx
, p
)) < 0)
892 l
->bdsp
.bswap_buf((uint32_t *) l
->buffer
, (const uint32_t *) buf
,
895 if ((ret
= tm2_read_header(l
, l
->buffer
)) < 0) {
899 for (i
= 0; i
< TM2_NUM_STREAMS
; i
++) {
900 if (offset
>= buf_size
) {
901 av_log(avctx
, AV_LOG_ERROR
, "no space for tm2_read_stream\n");
902 return AVERROR_INVALIDDATA
;
905 t
= tm2_read_stream(l
, l
->buffer
+ offset
, tm2_stream_order
[i
],
908 int j
= tm2_stream_order
[i
];
909 memset(l
->tokens
[j
], 0, sizeof(**l
->tokens
) * l
->tok_lens
[j
]);
914 p
->key_frame
= tm2_decode_blocks(l
, p
);
916 p
->pict_type
= AV_PICTURE_TYPE_I
;
918 p
->pict_type
= AV_PICTURE_TYPE_P
;
922 ret
= av_frame_ref(data
, l
->pic
);
924 return (ret
< 0) ? ret
: buf_size
;
927 static av_cold
int decode_init(AVCodecContext
*avctx
)
929 TM2Context
* const l
= avctx
->priv_data
;
930 int i
, w
= avctx
->width
, h
= avctx
->height
;
932 if ((avctx
->width
& 3) || (avctx
->height
& 3)) {
933 av_log(avctx
, AV_LOG_ERROR
, "Width and height must be multiple of 4\n");
934 return AVERROR(EINVAL
);
938 avctx
->pix_fmt
= AV_PIX_FMT_BGR24
;
940 l
->pic
= av_frame_alloc();
942 return AVERROR(ENOMEM
);
944 ff_bswapdsp_init(&l
->bdsp
);
946 l
->last
= av_malloc_array(w
>> 2, 4 * sizeof(*l
->last
) );
947 l
->clast
= av_malloc_array(w
>> 2, 4 * sizeof(*l
->clast
));
949 for (i
= 0; i
< TM2_NUM_STREAMS
; i
++) {
956 l
->Y1_base
= av_calloc(w
* h
, sizeof(*l
->Y1_base
));
957 l
->Y2_base
= av_calloc(w
* h
, sizeof(*l
->Y2_base
));
961 l
->U1_base
= av_calloc(w
* h
, sizeof(*l
->U1_base
));
962 l
->V1_base
= av_calloc(w
* h
, sizeof(*l
->V1_base
));
963 l
->U2_base
= av_calloc(w
* h
, sizeof(*l
->U2_base
));
964 l
->V2_base
= av_calloc(w
* h
, sizeof(*l
->V1_base
));
967 if (!l
->Y1_base
|| !l
->Y2_base
|| !l
->U1_base
||
968 !l
->V1_base
|| !l
->U2_base
|| !l
->V2_base
||
969 !l
->last
|| !l
->clast
) {
970 av_freep(&l
->Y1_base
);
971 av_freep(&l
->Y2_base
);
972 av_freep(&l
->U1_base
);
973 av_freep(&l
->U2_base
);
974 av_freep(&l
->V1_base
);
975 av_freep(&l
->V2_base
);
978 av_frame_free(&l
->pic
);
979 return AVERROR(ENOMEM
);
981 l
->Y1
= l
->Y1_base
+ l
->y_stride
* 4 + 4;
982 l
->Y2
= l
->Y2_base
+ l
->y_stride
* 4 + 4;
983 l
->U1
= l
->U1_base
+ l
->uv_stride
* 2 + 2;
984 l
->U2
= l
->U2_base
+ l
->uv_stride
* 2 + 2;
985 l
->V1
= l
->V1_base
+ l
->uv_stride
* 2 + 2;
986 l
->V2
= l
->V2_base
+ l
->uv_stride
* 2 + 2;
991 static av_cold
int decode_end(AVCodecContext
*avctx
)
993 TM2Context
* const l
= avctx
->priv_data
;
998 for (i
= 0; i
< TM2_NUM_STREAMS
; i
++)
999 av_freep(&l
->tokens
[i
]);
1001 av_freep(&l
->Y1_base
);
1002 av_freep(&l
->U1_base
);
1003 av_freep(&l
->V1_base
);
1004 av_freep(&l
->Y2_base
);
1005 av_freep(&l
->U2_base
);
1006 av_freep(&l
->V2_base
);
1008 av_freep(&l
->buffer
);
1011 av_frame_free(&l
->pic
);
1016 AVCodec ff_truemotion2_decoder
= {
1017 .name
= "truemotion2",
1018 .long_name
= NULL_IF_CONFIG_SMALL("Duck TrueMotion 2.0"),
1019 .type
= AVMEDIA_TYPE_VIDEO
,
1020 .id
= AV_CODEC_ID_TRUEMOTION2
,
1021 .priv_data_size
= sizeof(TM2Context
),
1022 .init
= decode_init
,
1023 .close
= decode_end
,
1024 .decode
= decode_frame
,
1025 .capabilities
= CODEC_CAP_DR1
,