Mercurial > libavcodec.hg
annotate truemotion1.c @ 2956:5f51b1e0bed6 libavcodec
Cook compatibe decoder, patch by Benjamin Larsson
Add cook demucing, change rm demuxer so that it reorders audio packets
before sending them to the decoder, and send minimum decodeable sized
packets; pass only real codec extradata fo the decoder
Fix 28_8 decoder for the new demuxer strategy
author | rtognimp |
---|---|
date | Fri, 09 Dec 2005 16:08:18 +0000 |
parents | 04cf75617d00 |
children | ef2149182f1c |
rev | line source |
---|---|
1650
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
1 /* |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
2 * Duck TrueMotion 1.0 Decoder |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
3 * Copyright (C) 2003 Alex Beregszaszi & Mike Melanson |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
4 * |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
5 * This library is free software; you can redistribute it and/or |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
6 * modify it under the terms of the GNU Lesser General Public |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
7 * License as published by the Free Software Foundation; either |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
8 * version 2 of the License, or (at your option) any later version. |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
9 * |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
10 * This library is distributed in the hope that it will be useful, |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
13 * Lesser General Public License for more details. |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
14 * |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
15 * You should have received a copy of the GNU Lesser General Public |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
16 * License along with this library; if not, write to the Free Software |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
17 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
18 */ |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
19 |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
20 /** |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
21 * @file truemotion1.c |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
22 * Duck TrueMotion v1 Video Decoder by |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
23 * Alex Beregszaszi (alex@fsn.hu) and |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
24 * Mike Melanson (melanson@pcisys.net) |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
25 * |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
26 * The TrueMotion v1 decoder presently only decodes 16-bit TM1 data and |
2245
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
27 * outputs RGB555 (or RGB565) data. 24-bit TM1 data is not supported yet. |
1650
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
28 */ |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
29 |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
30 #include <stdio.h> |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
31 #include <stdlib.h> |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
32 #include <string.h> |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
33 #include <unistd.h> |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
34 |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
35 #include "common.h" |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
36 #include "avcodec.h" |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
37 #include "dsputil.h" |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
38 |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
39 #include "truemotion1data.h" |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
40 |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
41 typedef struct TrueMotion1Context { |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
42 AVCodecContext *avctx; |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
43 AVFrame frame; |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
44 AVFrame prev_frame; |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
45 |
2245
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
46 uint8_t *buf; |
1650
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
47 int size; |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
48 |
2245
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
49 uint8_t *mb_change_bits; |
1650
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
50 int mb_change_bits_row_size; |
2245
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
51 uint8_t *index_stream; |
1650
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
52 int index_stream_size; |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
53 |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
54 int flags; |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
55 int x, y, w, h; |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
56 |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
57 uint32_t y_predictor_table[1024]; |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
58 uint32_t c_predictor_table[1024]; |
2245
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
59 uint32_t fat_y_predictor_table[1024]; |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
60 uint32_t fat_c_predictor_table[1024]; |
1650
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
61 |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
62 int compression; |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
63 int block_type; |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
64 int block_width; |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
65 int block_height; |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
66 |
2073
95d303a305d2
fix initialization bug in which execution overwrites essential data
melanson
parents:
2028
diff
changeset
|
67 int16_t ydt[8]; |
95d303a305d2
fix initialization bug in which execution overwrites essential data
melanson
parents:
2028
diff
changeset
|
68 int16_t cdt[8]; |
95d303a305d2
fix initialization bug in which execution overwrites essential data
melanson
parents:
2028
diff
changeset
|
69 int16_t fat_ydt[8]; |
95d303a305d2
fix initialization bug in which execution overwrites essential data
melanson
parents:
2028
diff
changeset
|
70 int16_t fat_cdt[8]; |
1650
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
71 |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
72 int last_deltaset, last_vectable; |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
73 |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
74 unsigned int *vert_pred; |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
75 |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
76 } TrueMotion1Context; |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
77 |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
78 #define FLAG_SPRITE 32 |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
79 #define FLAG_KEYFRAME 16 |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
80 #define FLAG_INTERFRAME 8 |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
81 #define FLAG_INTERPOLATED 4 |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
82 |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
83 struct frame_header { |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
84 uint8_t header_size; |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
85 uint8_t compression; |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
86 uint8_t deltaset; |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
87 uint8_t vectable; |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
88 uint16_t ysize; |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
89 uint16_t xsize; |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
90 uint16_t checksum; |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
91 uint8_t version; |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
92 uint8_t header_type; |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
93 uint8_t flags; |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
94 uint8_t control; |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
95 uint16_t xoffset; |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
96 uint16_t yoffset; |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
97 uint16_t width; |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
98 uint16_t height; |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
99 }; |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
100 |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
101 #define ALGO_NOP 0 |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
102 #define ALGO_RGB16V 1 |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
103 #define ALGO_RGB16H 2 |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
104 #define ALGO_RGB24H 3 |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
105 |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
106 /* these are the various block sizes that can occupy a 4x4 block */ |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
107 #define BLOCK_2x2 0 |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
108 #define BLOCK_2x4 1 |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
109 #define BLOCK_4x2 2 |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
110 #define BLOCK_4x4 3 |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
111 |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
112 typedef struct comp_types { |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
113 int algorithm; |
2245
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
114 int block_width; // vres |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
115 int block_height; // hres |
1650
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
116 int block_type; |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
117 } comp_types; |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
118 |
2245
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
119 /* { valid for metatype }, algorithm, num of deltas, vert res, horiz res */ |
1650
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
120 static comp_types compression_types[17] = { |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
121 { ALGO_NOP, 0, 0, 0 }, |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
122 |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
123 { ALGO_RGB16V, 4, 4, BLOCK_4x4 }, |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
124 { ALGO_RGB16H, 4, 4, BLOCK_4x4 }, |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
125 { ALGO_RGB16V, 4, 2, BLOCK_4x2 }, |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
126 { ALGO_RGB16H, 4, 2, BLOCK_4x2 }, |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
127 |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
128 { ALGO_RGB16V, 2, 4, BLOCK_2x4 }, |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
129 { ALGO_RGB16H, 2, 4, BLOCK_2x4 }, |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
130 { ALGO_RGB16V, 2, 2, BLOCK_2x2 }, |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
131 { ALGO_RGB16H, 2, 2, BLOCK_2x2 }, |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
132 |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
133 { ALGO_NOP, 4, 4, BLOCK_4x4 }, |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
134 { ALGO_RGB24H, 4, 4, BLOCK_4x4 }, |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
135 { ALGO_NOP, 4, 2, BLOCK_4x2 }, |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
136 { ALGO_RGB24H, 4, 2, BLOCK_4x2 }, |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
137 |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
138 { ALGO_NOP, 2, 4, BLOCK_2x4 }, |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
139 { ALGO_RGB24H, 2, 4, BLOCK_2x4 }, |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
140 { ALGO_NOP, 2, 2, BLOCK_2x2 }, |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
141 { ALGO_RGB24H, 2, 2, BLOCK_2x2 } |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
142 }; |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
143 |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
144 static void select_delta_tables(TrueMotion1Context *s, int delta_table_index) |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
145 { |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
146 int i; |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
147 |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
148 if (delta_table_index > 3) |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
149 return; |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
150 |
2073
95d303a305d2
fix initialization bug in which execution overwrites essential data
melanson
parents:
2028
diff
changeset
|
151 memcpy(s->ydt, ydts[delta_table_index], 8 * sizeof(int16_t)); |
95d303a305d2
fix initialization bug in which execution overwrites essential data
melanson
parents:
2028
diff
changeset
|
152 memcpy(s->cdt, cdts[delta_table_index], 8 * sizeof(int16_t)); |
95d303a305d2
fix initialization bug in which execution overwrites essential data
melanson
parents:
2028
diff
changeset
|
153 memcpy(s->fat_ydt, fat_ydts[delta_table_index], 8 * sizeof(int16_t)); |
95d303a305d2
fix initialization bug in which execution overwrites essential data
melanson
parents:
2028
diff
changeset
|
154 memcpy(s->fat_cdt, fat_cdts[delta_table_index], 8 * sizeof(int16_t)); |
1650
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
155 |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
156 /* Y skinny deltas need to be halved for some reason; maybe the |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
157 * skinny Y deltas should be modified */ |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
158 for (i = 0; i < 8; i++) |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
159 { |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
160 /* drop the lsb before dividing by 2-- net effect: round down |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
161 * when dividing a negative number (e.g., -3/2 = -2, not -1) */ |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
162 s->ydt[i] &= 0xFFFE; |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
163 s->ydt[i] /= 2; |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
164 } |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
165 } |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
166 |
1654
1c123e036890
this should make the decoder safe for big-endian platforms
melanson
parents:
1650
diff
changeset
|
167 #ifdef WORDS_BIGENDIAN |
2245
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
168 static int make_ydt15_entry(int p2, int p1, int16_t *ydt) |
1654
1c123e036890
this should make the decoder safe for big-endian platforms
melanson
parents:
1650
diff
changeset
|
169 #else |
2245
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
170 static int make_ydt15_entry(int p1, int p2, int16_t *ydt) |
1654
1c123e036890
this should make the decoder safe for big-endian platforms
melanson
parents:
1650
diff
changeset
|
171 #endif |
1650
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
172 { |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
173 int lo, hi; |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
174 |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
175 lo = ydt[p1]; |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
176 lo += (lo << 5) + (lo << 10); |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
177 hi = ydt[p2]; |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
178 hi += (hi << 5) + (hi << 10); |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
179 return ((lo + (hi << 16)) << 1); |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
180 } |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
181 |
1654
1c123e036890
this should make the decoder safe for big-endian platforms
melanson
parents:
1650
diff
changeset
|
182 #ifdef WORDS_BIGENDIAN |
2245
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
183 static int make_cdt15_entry(int p2, int p1, int16_t *cdt) |
1654
1c123e036890
this should make the decoder safe for big-endian platforms
melanson
parents:
1650
diff
changeset
|
184 #else |
2245
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
185 static int make_cdt15_entry(int p1, int p2, int16_t *cdt) |
1654
1c123e036890
this should make the decoder safe for big-endian platforms
melanson
parents:
1650
diff
changeset
|
186 #endif |
1650
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
187 { |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
188 int r, b, lo; |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
189 |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
190 b = cdt[p2]; |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
191 r = cdt[p1] << 10; |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
192 lo = b + r; |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
193 return ((lo + (lo << 16)) << 1); |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
194 } |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
195 |
2245
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
196 #ifdef WORDS_BIGENDIAN |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
197 static int make_ydt16_entry(int p2, int p1, int16_t *ydt) |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
198 #else |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
199 static int make_ydt16_entry(int p1, int p2, int16_t *ydt) |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
200 #endif |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
201 { |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
202 int lo, hi; |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
203 |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
204 lo = ydt[p1]; |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
205 lo += (lo << 6) + (lo << 11); |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
206 hi = ydt[p2]; |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
207 hi += (hi << 6) + (hi << 11); |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
208 return ((lo + (hi << 16)) << 1); |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
209 } |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
210 |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
211 #ifdef WORDS_BIGENDIAN |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
212 static int make_cdt16_entry(int p2, int p1, int16_t *cdt) |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
213 #else |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
214 static int make_cdt16_entry(int p1, int p2, int16_t *cdt) |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
215 #endif |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
216 { |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
217 int r, b, lo; |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
218 |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
219 b = cdt[p2]; |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
220 r = cdt[p1] << 11; |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
221 lo = b + r; |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
222 return ((lo + (lo << 16)) << 1); |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
223 } |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
224 |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
225 #ifdef WORDS_BIGENDIAN |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
226 static int make_ydt24_entry(int p2, int p1, int16_t *ydt) |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
227 #else |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
228 static int make_ydt24_entry(int p1, int p2, int16_t *ydt) |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
229 #endif |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
230 { |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
231 int lo, hi; |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
232 |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
233 lo = ydt[p1]; |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
234 hi = ydt[p2]; |
2938
363be7734674
improvements by Reimar D«Óffinger; 24-bit decoding is not perfect, only
melanson
parents:
2753
diff
changeset
|
235 return ((lo + (hi << 8) + (hi << 16)) << 1); |
2245
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
236 } |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
237 |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
238 #ifdef WORDS_BIGENDIAN |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
239 static int make_cdt24_entry(int p2, int p1, int16_t *cdt) |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
240 #else |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
241 static int make_cdt24_entry(int p1, int p2, int16_t *cdt) |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
242 #endif |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
243 { |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
244 int r, b; |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
245 |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
246 b = cdt[p2]; |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
247 r = cdt[p1]<<16; |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
248 return ((b+r) << 1); |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
249 } |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
250 |
2753 | 251 static void gen_vector_table15(TrueMotion1Context *s, const uint8_t *sel_vector_table) |
1650
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
252 { |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
253 int len, i, j; |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
254 unsigned char delta_pair; |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
255 |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
256 for (i = 0; i < 1024; i += 4) |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
257 { |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
258 len = *sel_vector_table++ / 2; |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
259 for (j = 0; j < len; j++) |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
260 { |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
261 delta_pair = *sel_vector_table++; |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
262 s->y_predictor_table[i+j] = 0xfffffffe & |
2245
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
263 make_ydt15_entry(delta_pair >> 4, delta_pair & 0xf, s->ydt); |
1650
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
264 s->c_predictor_table[i+j] = 0xfffffffe & |
2245
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
265 make_cdt15_entry(delta_pair >> 4, delta_pair & 0xf, s->cdt); |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
266 } |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
267 s->y_predictor_table[i+(j-1)] |= 1; |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
268 s->c_predictor_table[i+(j-1)] |= 1; |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
269 } |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
270 } |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
271 |
2753 | 272 static void gen_vector_table16(TrueMotion1Context *s, const uint8_t *sel_vector_table) |
2245
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
273 { |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
274 int len, i, j; |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
275 unsigned char delta_pair; |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
276 |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
277 for (i = 0; i < 1024; i += 4) |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
278 { |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
279 len = *sel_vector_table++ / 2; |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
280 for (j = 0; j < len; j++) |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
281 { |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
282 delta_pair = *sel_vector_table++; |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
283 s->y_predictor_table[i+j] = 0xfffffffe & |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
284 make_ydt16_entry(delta_pair >> 4, delta_pair & 0xf, s->ydt); |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
285 s->c_predictor_table[i+j] = 0xfffffffe & |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
286 make_cdt16_entry(delta_pair >> 4, delta_pair & 0xf, s->cdt); |
1650
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
287 } |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
288 s->y_predictor_table[i+(j-1)] |= 1; |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
289 s->c_predictor_table[i+(j-1)] |= 1; |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
290 } |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
291 } |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
292 |
2753 | 293 static void gen_vector_table24(TrueMotion1Context *s, const uint8_t *sel_vector_table) |
2245
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
294 { |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
295 int len, i, j; |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
296 unsigned char delta_pair; |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
297 |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
298 for (i = 0; i < 1024; i += 4) |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
299 { |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
300 len = *sel_vector_table++ / 2; |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
301 for (j = 0; j < len; j++) |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
302 { |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
303 delta_pair = *sel_vector_table++; |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
304 s->y_predictor_table[i+j] = 0xfffffffe & |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
305 make_ydt24_entry(delta_pair >> 4, delta_pair & 0xf, s->ydt); |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
306 s->c_predictor_table[i+j] = 0xfffffffe & |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
307 make_cdt24_entry(delta_pair >> 4, delta_pair & 0xf, s->cdt); |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
308 s->fat_y_predictor_table[i+j] = 0xfffffffe & |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
309 make_ydt24_entry(delta_pair >> 4, delta_pair & 0xf, s->fat_ydt); |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
310 s->fat_c_predictor_table[i+j] = 0xfffffffe & |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
311 make_cdt24_entry(delta_pair >> 4, delta_pair & 0xf, s->fat_cdt); |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
312 } |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
313 s->y_predictor_table[i+(j-1)] |= 1; |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
314 s->c_predictor_table[i+(j-1)] |= 1; |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
315 s->fat_y_predictor_table[i+(j-1)] |= 1; |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
316 s->fat_c_predictor_table[i+(j-1)] |= 1; |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
317 } |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
318 } |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
319 |
1650
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
320 /* Returns the number of bytes consumed from the bytestream. Returns -1 if |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
321 * there was an error while decoding the header */ |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
322 static int truemotion1_decode_header(TrueMotion1Context *s) |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
323 { |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
324 int i; |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
325 struct frame_header header; |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
326 uint8_t header_buffer[128]; /* logical maximum size of the header */ |
2753 | 327 const uint8_t *sel_vector_table; |
1650
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
328 |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
329 /* There is 1 change bit per 4 pixels, so each change byte represents |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
330 * 32 pixels; divide width by 4 to obtain the number of change bits and |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
331 * then round up to the nearest byte. */ |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
332 s->mb_change_bits_row_size = ((s->avctx->width >> 2) + 7) >> 3; |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
333 |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
334 header.header_size = ((s->buf[0] >> 5) | (s->buf[0] << 3)) & 0x7f; |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
335 if (s->buf[0] < 0x10) |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
336 { |
2245
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
337 av_log(s->avctx, AV_LOG_ERROR, "invalid header size (%d)\n", s->buf[0]); |
1650
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
338 return -1; |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
339 } |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
340 |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
341 /* unscramble the header bytes with a XOR operation */ |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
342 memset(header_buffer, 0, 128); |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
343 for (i = 1; i < header.header_size; i++) |
2245
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
344 header_buffer[i - 1] = s->buf[i] ^ s->buf[i + 1]; |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
345 |
1650
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
346 header.compression = header_buffer[0]; |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
347 header.deltaset = header_buffer[1]; |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
348 header.vectable = header_buffer[2]; |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
349 header.ysize = LE_16(&header_buffer[3]); |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
350 header.xsize = LE_16(&header_buffer[5]); |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
351 header.checksum = LE_16(&header_buffer[7]); |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
352 header.version = header_buffer[9]; |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
353 header.header_type = header_buffer[10]; |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
354 header.flags = header_buffer[11]; |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
355 header.control = header_buffer[12]; |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
356 |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
357 /* Version 2 */ |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
358 if (header.version >= 2) |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
359 { |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
360 if (header.header_type > 3) |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
361 { |
2245
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
362 av_log(s->avctx, AV_LOG_ERROR, "invalid header type (%d)\n", header.header_type); |
1650
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
363 return -1; |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
364 } else if ((header.header_type == 2) || (header.header_type == 3)) { |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
365 s->flags = header.flags; |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
366 if (!(s->flags & FLAG_INTERFRAME)) |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
367 s->flags |= FLAG_KEYFRAME; |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
368 } else |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
369 s->flags = FLAG_KEYFRAME; |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
370 } else /* Version 1 */ |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
371 s->flags = FLAG_KEYFRAME; |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
372 |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
373 if (s->flags & FLAG_SPRITE) { |
2245
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
374 av_log(s->avctx, AV_LOG_INFO, "SPRITE frame found, please report the sample to the developers\n"); |
1650
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
375 s->w = header.width; |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
376 s->h = header.height; |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
377 s->x = header.xoffset; |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
378 s->y = header.yoffset; |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
379 } else { |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
380 s->w = header.xsize; |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
381 s->h = header.ysize; |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
382 if (header.header_type < 2) { |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
383 if ((s->w < 213) && (s->h >= 176)) |
2245
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
384 { |
1650
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
385 s->flags |= FLAG_INTERPOLATED; |
2245
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
386 av_log(s->avctx, AV_LOG_INFO, "INTERPOLATION selected, please report the sample to the developers\n"); |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
387 } |
1650
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
388 } |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
389 } |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
390 |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
391 if (header.compression > 17) { |
1927 | 392 av_log(s->avctx, AV_LOG_ERROR, "invalid compression type (%d)\n", header.compression); |
1650
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
393 return -1; |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
394 } |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
395 |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
396 if ((header.deltaset != s->last_deltaset) || |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
397 (header.vectable != s->last_vectable)) |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
398 select_delta_tables(s, header.deltaset); |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
399 |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
400 if ((header.compression & 1) && header.header_type) |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
401 sel_vector_table = pc_tbl2; |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
402 else { |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
403 if (header.vectable < 4) |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
404 sel_vector_table = tables[header.vectable - 1]; |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
405 else { |
1927 | 406 av_log(s->avctx, AV_LOG_ERROR, "invalid vector table id (%d)\n", header.vectable); |
1650
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
407 return -1; |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
408 } |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
409 } |
2245
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
410 |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
411 // FIXME: where to place this ?!?! |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
412 if (compression_types[header.compression].algorithm == ALGO_RGB24H) |
2938
363be7734674
improvements by Reimar D«Óffinger; 24-bit decoding is not perfect, only
melanson
parents:
2753
diff
changeset
|
413 s->avctx->pix_fmt = PIX_FMT_RGBA32; |
2245
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
414 else |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
415 s->avctx->pix_fmt = PIX_FMT_RGB555; // RGB565 is supported aswell |
1650
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
416 |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
417 if ((header.deltaset != s->last_deltaset) || (header.vectable != s->last_vectable)) |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
418 { |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
419 if (compression_types[header.compression].algorithm == ALGO_RGB24H) |
2245
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
420 gen_vector_table24(s, sel_vector_table); |
1650
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
421 else |
2245
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
422 if (s->avctx->pix_fmt == PIX_FMT_RGB555) |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
423 gen_vector_table15(s, sel_vector_table); |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
424 else |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
425 gen_vector_table16(s, sel_vector_table); |
1650
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
426 } |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
427 |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
428 /* set up pointers to the other key data chunks */ |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
429 s->mb_change_bits = s->buf + header.header_size; |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
430 if (s->flags & FLAG_KEYFRAME) { |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
431 /* no change bits specified for a keyframe; only index bytes */ |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
432 s->index_stream = s->mb_change_bits; |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
433 } else { |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
434 /* one change bit per 4x4 block */ |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
435 s->index_stream = s->mb_change_bits + |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
436 (s->mb_change_bits_row_size * (s->avctx->height >> 2)); |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
437 } |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
438 s->index_stream_size = s->size - (s->index_stream - s->buf); |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
439 |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
440 s->last_deltaset = header.deltaset; |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
441 s->last_vectable = header.vectable; |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
442 s->compression = header.compression; |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
443 s->block_width = compression_types[header.compression].block_width; |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
444 s->block_height = compression_types[header.compression].block_height; |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
445 s->block_type = compression_types[header.compression].block_type; |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
446 |
2245
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
447 if (s->avctx->debug & FF_DEBUG_PICT_INFO) |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
448 av_log(s->avctx, AV_LOG_INFO, "tables: %d / %d c:%d %dx%d t:%d %s%s%s%s\n", |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
449 s->last_deltaset, s->last_vectable, s->compression, s->block_width, |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
450 s->block_height, s->block_type, |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
451 s->flags & FLAG_KEYFRAME ? " KEY" : "", |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
452 s->flags & FLAG_INTERFRAME ? " INTER" : "", |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
453 s->flags & FLAG_SPRITE ? " SPRITE" : "", |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
454 s->flags & FLAG_INTERPOLATED ? " INTERPOL" : ""); |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
455 |
1650
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
456 return header.header_size; |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
457 } |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
458 |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
459 static int truemotion1_decode_init(AVCodecContext *avctx) |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
460 { |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
461 TrueMotion1Context *s = (TrueMotion1Context *)avctx->priv_data; |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
462 |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
463 s->avctx = avctx; |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
464 |
2245
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
465 // FIXME: it may change ? |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
466 // if (avctx->bits_per_sample == 24) |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
467 // avctx->pix_fmt = PIX_FMT_RGB24; |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
468 // else |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
469 // avctx->pix_fmt = PIX_FMT_RGB555; |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
470 |
1650
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
471 avctx->has_b_frames = 0; |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
472 s->frame.data[0] = s->prev_frame.data[0] = NULL; |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
473 |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
474 /* there is a vertical predictor for each pixel in a line; each vertical |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
475 * predictor is 0 to start with */ |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
476 s->vert_pred = |
2938
363be7734674
improvements by Reimar D«Óffinger; 24-bit decoding is not perfect, only
melanson
parents:
2753
diff
changeset
|
477 (unsigned int *)av_malloc(s->avctx->width * sizeof(unsigned int)); |
1650
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
478 |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
479 return 0; |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
480 } |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
481 |
2245
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
482 /* |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
483 Block decoding order: |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
484 |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
485 dxi: Y-Y |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
486 dxic: Y-C-Y |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
487 dxic2: Y-C-Y-C |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
488 |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
489 hres,vres,i,i%vres (0 < i < 4) |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
490 2x2 0: 0 dxic2 |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
491 2x2 1: 1 dxi |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
492 2x2 2: 0 dxic2 |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
493 2x2 3: 1 dxi |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
494 2x4 0: 0 dxic2 |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
495 2x4 1: 1 dxi |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
496 2x4 2: 2 dxi |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
497 2x4 3: 3 dxi |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
498 4x2 0: 0 dxic |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
499 4x2 1: 1 dxi |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
500 4x2 2: 0 dxic |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
501 4x2 3: 1 dxi |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
502 4x4 0: 0 dxic |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
503 4x4 1: 1 dxi |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
504 4x4 2: 2 dxi |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
505 4x4 3: 3 dxi |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
506 */ |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
507 |
1650
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
508 #define GET_NEXT_INDEX() \ |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
509 {\ |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
510 if (index_stream_index >= s->index_stream_size) { \ |
1927 | 511 av_log(s->avctx, AV_LOG_INFO, " help! truemotion1 decoder went out of bounds\n"); \ |
1650
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
512 return; \ |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
513 } \ |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
514 index = s->index_stream[index_stream_index++] * 4; \ |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
515 } |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
516 |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
517 #define APPLY_C_PREDICTOR() \ |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
518 predictor_pair = s->c_predictor_table[index]; \ |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
519 horiz_pred += (predictor_pair >> 1); \ |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
520 if (predictor_pair & 1) { \ |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
521 GET_NEXT_INDEX() \ |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
522 if (!index) { \ |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
523 GET_NEXT_INDEX() \ |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
524 predictor_pair = s->c_predictor_table[index]; \ |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
525 horiz_pred += ((predictor_pair >> 1) * 5); \ |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
526 if (predictor_pair & 1) \ |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
527 GET_NEXT_INDEX() \ |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
528 else \ |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
529 index++; \ |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
530 } \ |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
531 } else \ |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
532 index++; |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
533 |
2245
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
534 #define APPLY_C_PREDICTOR_24() \ |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
535 predictor_pair = s->c_predictor_table[index]; \ |
2938
363be7734674
improvements by Reimar D«Óffinger; 24-bit decoding is not perfect, only
melanson
parents:
2753
diff
changeset
|
536 horiz_pred += (predictor_pair >> 1); \ |
2245
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
537 if (predictor_pair & 1) { \ |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
538 GET_NEXT_INDEX() \ |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
539 if (!index) { \ |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
540 GET_NEXT_INDEX() \ |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
541 predictor_pair = s->fat_c_predictor_table[index]; \ |
2938
363be7734674
improvements by Reimar D«Óffinger; 24-bit decoding is not perfect, only
melanson
parents:
2753
diff
changeset
|
542 horiz_pred += (predictor_pair >> 1); \ |
2245
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
543 if (predictor_pair & 1) \ |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
544 GET_NEXT_INDEX() \ |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
545 else \ |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
546 index++; \ |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
547 } \ |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
548 } else \ |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
549 index++; |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
550 |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
551 |
1650
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
552 #define APPLY_Y_PREDICTOR() \ |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
553 predictor_pair = s->y_predictor_table[index]; \ |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
554 horiz_pred += (predictor_pair >> 1); \ |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
555 if (predictor_pair & 1) { \ |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
556 GET_NEXT_INDEX() \ |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
557 if (!index) { \ |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
558 GET_NEXT_INDEX() \ |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
559 predictor_pair = s->y_predictor_table[index]; \ |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
560 horiz_pred += ((predictor_pair >> 1) * 5); \ |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
561 if (predictor_pair & 1) \ |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
562 GET_NEXT_INDEX() \ |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
563 else \ |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
564 index++; \ |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
565 } \ |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
566 } else \ |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
567 index++; |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
568 |
2245
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
569 #define APPLY_Y_PREDICTOR_24() \ |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
570 predictor_pair = s->y_predictor_table[index]; \ |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
571 horiz_pred += (predictor_pair >> 1); \ |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
572 if (predictor_pair & 1) { \ |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
573 GET_NEXT_INDEX() \ |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
574 if (!index) { \ |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
575 GET_NEXT_INDEX() \ |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
576 predictor_pair = s->fat_y_predictor_table[index]; \ |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
577 horiz_pred += (predictor_pair >> 1); \ |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
578 if (predictor_pair & 1) \ |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
579 GET_NEXT_INDEX() \ |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
580 else \ |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
581 index++; \ |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
582 } \ |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
583 } else \ |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
584 index++; |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
585 |
1650
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
586 #define OUTPUT_PIXEL_PAIR() \ |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
587 *current_pixel_pair = *vert_pred + horiz_pred; \ |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
588 *vert_pred++ = *current_pixel_pair++; \ |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
589 prev_pixel_pair++; |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
590 |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
591 static void truemotion1_decode_16bit(TrueMotion1Context *s) |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
592 { |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
593 int y; |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
594 int pixels_left; /* remaining pixels on this line */ |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
595 unsigned int predictor_pair; |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
596 unsigned int horiz_pred; |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
597 unsigned int *vert_pred; |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
598 unsigned int *current_pixel_pair; |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
599 unsigned int *prev_pixel_pair; |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
600 unsigned char *current_line = s->frame.data[0]; |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
601 unsigned char *prev_line = s->prev_frame.data[0]; |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
602 int keyframe = s->flags & FLAG_KEYFRAME; |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
603 |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
604 /* these variables are for managing the stream of macroblock change bits */ |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
605 unsigned char *mb_change_bits = s->mb_change_bits; |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
606 unsigned char mb_change_byte; |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
607 unsigned char mb_change_byte_mask; |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
608 int mb_change_index; |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
609 |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
610 /* these variables are for managing the main index stream */ |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
611 int index_stream_index = 0; /* yes, the index into the index stream */ |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
612 int index; |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
613 |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
614 /* clean out the line buffer */ |
2938
363be7734674
improvements by Reimar D«Óffinger; 24-bit decoding is not perfect, only
melanson
parents:
2753
diff
changeset
|
615 memset(s->vert_pred, 0, s->avctx->width * sizeof(unsigned int)); |
1650
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
616 |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
617 GET_NEXT_INDEX(); |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
618 |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
619 for (y = 0; y < s->avctx->height; y++) { |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
620 |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
621 /* re-init variables for the next line iteration */ |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
622 horiz_pred = 0; |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
623 current_pixel_pair = (unsigned int *)current_line; |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
624 prev_pixel_pair = (unsigned int *)prev_line; |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
625 vert_pred = s->vert_pred; |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
626 mb_change_index = 0; |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
627 mb_change_byte = mb_change_bits[mb_change_index++]; |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
628 mb_change_byte_mask = 0x01; |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
629 pixels_left = s->avctx->width; |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
630 |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
631 while (pixels_left > 0) { |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
632 |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
633 if (keyframe || ((mb_change_byte & mb_change_byte_mask) == 0)) { |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
634 |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
635 switch (y & 3) { |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
636 case 0: |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
637 /* if macroblock width is 2, apply C-Y-C-Y; else |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
638 * apply C-Y-Y */ |
1654
1c123e036890
this should make the decoder safe for big-endian platforms
melanson
parents:
1650
diff
changeset
|
639 if (s->block_width == 2) { |
1650
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
640 APPLY_C_PREDICTOR(); |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
641 APPLY_Y_PREDICTOR(); |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
642 OUTPUT_PIXEL_PAIR(); |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
643 APPLY_C_PREDICTOR(); |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
644 APPLY_Y_PREDICTOR(); |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
645 OUTPUT_PIXEL_PAIR(); |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
646 } else { |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
647 APPLY_C_PREDICTOR(); |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
648 APPLY_Y_PREDICTOR(); |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
649 OUTPUT_PIXEL_PAIR(); |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
650 APPLY_Y_PREDICTOR(); |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
651 OUTPUT_PIXEL_PAIR(); |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
652 } |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
653 break; |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
654 |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
655 case 1: |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
656 case 3: |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
657 /* always apply 2 Y predictors on these iterations */ |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
658 APPLY_Y_PREDICTOR(); |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
659 OUTPUT_PIXEL_PAIR(); |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
660 APPLY_Y_PREDICTOR(); |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
661 OUTPUT_PIXEL_PAIR(); |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
662 break; |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
663 |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
664 case 2: |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
665 /* this iteration might be C-Y-C-Y, Y-Y, or C-Y-Y |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
666 * depending on the macroblock type */ |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
667 if (s->block_type == BLOCK_2x2) { |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
668 APPLY_C_PREDICTOR(); |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
669 APPLY_Y_PREDICTOR(); |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
670 OUTPUT_PIXEL_PAIR(); |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
671 APPLY_C_PREDICTOR(); |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
672 APPLY_Y_PREDICTOR(); |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
673 OUTPUT_PIXEL_PAIR(); |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
674 } else if (s->block_type == BLOCK_4x2) { |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
675 APPLY_C_PREDICTOR(); |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
676 APPLY_Y_PREDICTOR(); |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
677 OUTPUT_PIXEL_PAIR(); |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
678 APPLY_Y_PREDICTOR(); |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
679 OUTPUT_PIXEL_PAIR(); |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
680 } else { |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
681 APPLY_Y_PREDICTOR(); |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
682 OUTPUT_PIXEL_PAIR(); |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
683 APPLY_Y_PREDICTOR(); |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
684 OUTPUT_PIXEL_PAIR(); |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
685 } |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
686 break; |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
687 } |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
688 |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
689 } else { |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
690 |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
691 /* skip (copy) four pixels, but reassign the horizontal |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
692 * predictor */ |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
693 *current_pixel_pair = *prev_pixel_pair++; |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
694 *vert_pred++ = *current_pixel_pair++; |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
695 *current_pixel_pair = *prev_pixel_pair++; |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
696 horiz_pred = *current_pixel_pair - *vert_pred; |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
697 *vert_pred++ = *current_pixel_pair++; |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
698 |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
699 } |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
700 |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
701 if (!keyframe) { |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
702 mb_change_byte_mask <<= 1; |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
703 |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
704 /* next byte */ |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
705 if (!mb_change_byte_mask) { |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
706 mb_change_byte = mb_change_bits[mb_change_index++]; |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
707 mb_change_byte_mask = 0x01; |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
708 } |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
709 } |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
710 |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
711 pixels_left -= 4; |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
712 } |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
713 |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
714 /* next change row */ |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
715 if (((y + 1) & 3) == 0) |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
716 mb_change_bits += s->mb_change_bits_row_size; |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
717 |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
718 current_line += s->frame.linesize[0]; |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
719 prev_line += s->prev_frame.linesize[0]; |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
720 } |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
721 } |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
722 |
2245
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
723 static void truemotion1_decode_24bit(TrueMotion1Context *s) |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
724 { |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
725 int y; |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
726 int pixels_left; /* remaining pixels on this line */ |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
727 unsigned int predictor_pair; |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
728 unsigned int horiz_pred; |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
729 unsigned int *vert_pred; |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
730 unsigned int *current_pixel_pair; |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
731 unsigned int *prev_pixel_pair; |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
732 unsigned char *current_line = s->frame.data[0]; |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
733 unsigned char *prev_line = s->prev_frame.data[0]; |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
734 int keyframe = s->flags & FLAG_KEYFRAME; |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
735 |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
736 /* these variables are for managing the stream of macroblock change bits */ |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
737 unsigned char *mb_change_bits = s->mb_change_bits; |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
738 unsigned char mb_change_byte; |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
739 unsigned char mb_change_byte_mask; |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
740 int mb_change_index; |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
741 |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
742 /* these variables are for managing the main index stream */ |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
743 int index_stream_index = 0; /* yes, the index into the index stream */ |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
744 int index; |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
745 |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
746 /* clean out the line buffer */ |
2939
04cf75617d00
clear the whole vert_pred buffer for 24 bit decoding.
reimar
parents:
2938
diff
changeset
|
747 memset(s->vert_pred, 0, s->avctx->width * sizeof(unsigned int)); |
2245
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
748 |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
749 GET_NEXT_INDEX(); |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
750 |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
751 for (y = 0; y < s->avctx->height; y++) { |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
752 |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
753 /* re-init variables for the next line iteration */ |
2938
363be7734674
improvements by Reimar D«Óffinger; 24-bit decoding is not perfect, only
melanson
parents:
2753
diff
changeset
|
754 horiz_pred = 0; |
2245
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
755 current_pixel_pair = (unsigned int *)current_line; |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
756 prev_pixel_pair = (unsigned int *)prev_line; |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
757 vert_pred = s->vert_pred; |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
758 mb_change_index = 0; |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
759 mb_change_byte = mb_change_bits[mb_change_index++]; |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
760 mb_change_byte_mask = 0x01; |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
761 pixels_left = s->avctx->width; |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
762 |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
763 while (pixels_left > 0) { |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
764 |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
765 if (keyframe || ((mb_change_byte & mb_change_byte_mask) == 0)) { |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
766 |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
767 switch (y & 3) { |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
768 case 0: |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
769 /* if macroblock width is 2, apply C-Y-C-Y; else |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
770 * apply C-Y-Y */ |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
771 if (s->block_width == 2) { |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
772 APPLY_C_PREDICTOR_24(); |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
773 APPLY_Y_PREDICTOR_24(); |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
774 OUTPUT_PIXEL_PAIR(); |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
775 APPLY_C_PREDICTOR_24(); |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
776 APPLY_Y_PREDICTOR_24(); |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
777 OUTPUT_PIXEL_PAIR(); |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
778 } else { |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
779 APPLY_C_PREDICTOR_24(); |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
780 APPLY_Y_PREDICTOR_24(); |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
781 OUTPUT_PIXEL_PAIR(); |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
782 APPLY_Y_PREDICTOR_24(); |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
783 OUTPUT_PIXEL_PAIR(); |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
784 } |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
785 break; |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
786 |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
787 case 1: |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
788 case 3: |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
789 /* always apply 2 Y predictors on these iterations */ |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
790 APPLY_Y_PREDICTOR_24(); |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
791 OUTPUT_PIXEL_PAIR(); |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
792 APPLY_Y_PREDICTOR_24(); |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
793 OUTPUT_PIXEL_PAIR(); |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
794 break; |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
795 |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
796 case 2: |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
797 /* this iteration might be C-Y-C-Y, Y-Y, or C-Y-Y |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
798 * depending on the macroblock type */ |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
799 if (s->block_type == BLOCK_2x2) { |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
800 APPLY_C_PREDICTOR_24(); |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
801 APPLY_Y_PREDICTOR_24(); |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
802 OUTPUT_PIXEL_PAIR(); |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
803 APPLY_C_PREDICTOR_24(); |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
804 APPLY_Y_PREDICTOR_24(); |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
805 OUTPUT_PIXEL_PAIR(); |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
806 } else if (s->block_type == BLOCK_4x2) { |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
807 APPLY_C_PREDICTOR_24(); |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
808 APPLY_Y_PREDICTOR_24(); |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
809 OUTPUT_PIXEL_PAIR(); |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
810 APPLY_Y_PREDICTOR_24(); |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
811 OUTPUT_PIXEL_PAIR(); |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
812 } else { |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
813 APPLY_Y_PREDICTOR_24(); |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
814 OUTPUT_PIXEL_PAIR(); |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
815 APPLY_Y_PREDICTOR_24(); |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
816 OUTPUT_PIXEL_PAIR(); |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
817 } |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
818 break; |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
819 } |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
820 |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
821 } else { |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
822 |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
823 /* skip (copy) four pixels, but reassign the horizontal |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
824 * predictor */ |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
825 *current_pixel_pair = *prev_pixel_pair++; |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
826 *vert_pred++ = *current_pixel_pair++; |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
827 *current_pixel_pair = *prev_pixel_pair++; |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
828 horiz_pred = *current_pixel_pair - *vert_pred; |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
829 *vert_pred++ = *current_pixel_pair++; |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
830 |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
831 } |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
832 |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
833 if (!keyframe) { |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
834 mb_change_byte_mask <<= 1; |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
835 |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
836 /* next byte */ |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
837 if (!mb_change_byte_mask) { |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
838 mb_change_byte = mb_change_bits[mb_change_index++]; |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
839 mb_change_byte_mask = 0x01; |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
840 } |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
841 } |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
842 |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
843 pixels_left -= 4; |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
844 } |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
845 |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
846 /* next change row */ |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
847 if (((y + 1) & 3) == 0) |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
848 mb_change_bits += s->mb_change_bits_row_size; |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
849 |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
850 current_line += s->frame.linesize[0]; |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
851 prev_line += s->prev_frame.linesize[0]; |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
852 } |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
853 } |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
854 |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
855 |
1650
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
856 static int truemotion1_decode_frame(AVCodecContext *avctx, |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
857 void *data, int *data_size, |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
858 uint8_t *buf, int buf_size) |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
859 { |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
860 TrueMotion1Context *s = (TrueMotion1Context *)avctx->priv_data; |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
861 |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
862 s->buf = buf; |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
863 s->size = buf_size; |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
864 |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
865 if (truemotion1_decode_header(s) == -1) |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
866 return -1; |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
867 |
2245
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
868 s->frame.reference = 1; |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
869 if (avctx->get_buffer(avctx, &s->frame) < 0) { |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
870 av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed\n"); |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
871 return -1; |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
872 } |
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
873 |
1650
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
874 /* check for a do-nothing frame and copy the previous frame */ |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
875 if (compression_types[s->compression].algorithm == ALGO_NOP) |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
876 { |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
877 memcpy(s->frame.data[0], s->prev_frame.data[0], |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
878 s->frame.linesize[0] * s->avctx->height); |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
879 } else if (compression_types[s->compression].algorithm == ALGO_RGB24H) { |
2245
81802fed5b8c
Decoding to bgr15/16 from 16bit input. Decoding of 24bit input added, not yet finished, but at least the picture can be recognized
alex
parents:
2073
diff
changeset
|
880 truemotion1_decode_24bit(s); |
1650
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
881 } else { |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
882 truemotion1_decode_16bit(s); |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
883 } |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
884 |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
885 if (s->prev_frame.data[0]) |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
886 avctx->release_buffer(avctx, &s->prev_frame); |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
887 |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
888 /* shuffle frames */ |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
889 s->prev_frame = s->frame; |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
890 |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
891 *data_size = sizeof(AVFrame); |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
892 *(AVFrame*)data = s->frame; |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
893 |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
894 /* report that the buffer was completely consumed */ |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
895 return buf_size; |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
896 } |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
897 |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
898 static int truemotion1_decode_end(AVCodecContext *avctx) |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
899 { |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
900 TrueMotion1Context *s = (TrueMotion1Context *)avctx->priv_data; |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
901 |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
902 /* release the last frame */ |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
903 if (s->prev_frame.data[0]) |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
904 avctx->release_buffer(avctx, &s->prev_frame); |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
905 |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
906 av_free(s->vert_pred); |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
907 |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
908 return 0; |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
909 } |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
910 |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
911 AVCodec truemotion1_decoder = { |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
912 "truemotion1", |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
913 CODEC_TYPE_VIDEO, |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
914 CODEC_ID_TRUEMOTION1, |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
915 sizeof(TrueMotion1Context), |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
916 truemotion1_decode_init, |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
917 NULL, |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
918 truemotion1_decode_end, |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
919 truemotion1_decode_frame, |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
920 CODEC_CAP_DR1, |
bdade3baabfc
initial support for Duck TrueMotion v1 (think of it as On2 VP1); only
melanson
parents:
diff
changeset
|
921 }; |