Mercurial > libavcodec.hg
annotate msmpeg4.c @ 11816:7c2369ec6faa libavcodec
ARM: check struct offsets only when they are used
The offsets differ depending on configuration, so only check them when
they will actually be used. Presently, this is when NEON is enabled.
author | mru |
---|---|
date | Wed, 02 Jun 2010 22:05:25 +0000 |
parents | 7dd2a45249a9 |
children | c35d7bc64882 |
rev | line source |
---|---|
0 | 1 /* |
2 * MSMPEG4 backend for ffmpeg encoder and decoder | |
8629
04423b2f6e0b
cosmetics: Remove pointless period after copyright statement non-sentences.
diego
parents:
8596
diff
changeset
|
3 * Copyright (c) 2001 Fabrice Bellard |
1739
07a484280a82
copyright year update of the files i touched and remembered, things look annoyingly unmaintained otherwise
michael
parents:
1651
diff
changeset
|
4 * Copyright (c) 2002-2004 Michael Niedermayer <michaelni@gmx.at> |
0 | 5 * |
5214 | 6 * msmpeg4v1 & v2 stuff by Michael Niedermayer <michaelni@gmx.at> |
7 * | |
3947
c8c591fe26f8
Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents:
3781
diff
changeset
|
8 * This file is part of FFmpeg. |
c8c591fe26f8
Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents:
3781
diff
changeset
|
9 * |
c8c591fe26f8
Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents:
3781
diff
changeset
|
10 * FFmpeg is free software; you can redistribute it and/or |
429 | 11 * modify it under the terms of the GNU Lesser General Public |
12 * License as published by the Free Software Foundation; either | |
3947
c8c591fe26f8
Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents:
3781
diff
changeset
|
13 * version 2.1 of the License, or (at your option) any later version. |
0 | 14 * |
3947
c8c591fe26f8
Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents:
3781
diff
changeset
|
15 * FFmpeg is distributed in the hope that it will be useful, |
0 | 16 * but WITHOUT ANY WARRANTY; without even the implied warranty of |
429 | 17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
18 * Lesser General Public License for more details. | |
0 | 19 * |
429 | 20 * You should have received a copy of the GNU Lesser General Public |
3947
c8c591fe26f8
Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents:
3781
diff
changeset
|
21 * License along with FFmpeg; if not, write to the Free Software |
3036
0b546eab515d
Update licensing information: The FSF changed postal address.
diego
parents:
2979
diff
changeset
|
22 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA |
0 | 23 */ |
1106 | 24 |
25 /** | |
11644
7dd2a45249a9
Remove explicit filename from Doxygen @file commands.
diego
parents:
11560
diff
changeset
|
26 * @file |
1106 | 27 * MSMPEG4 backend for ffmpeg encoder and decoder. |
28 */ | |
29 | |
396
fce0a2520551
removed useless header includes - use av memory functions
glantau
parents:
347
diff
changeset
|
30 #include "avcodec.h" |
0 | 31 #include "dsputil.h" |
32 #include "mpegvideo.h" | |
5884 | 33 #include "msmpeg4.h" |
10071
6ac0d4957d35
Replace #ifdef PIC checks with the more appropriate HAVE_EBX_AVAILABLE/HAVE_7REGS.
reimar
parents:
9998
diff
changeset
|
34 #include "libavutil/x86_cpu.h" |
10803 | 35 #include "h263.h" |
36 #include "mpeg4video.h" | |
411
5c8b3a717929
workaround dc_scale bug in old ffmpeg msmpeg4v3 encoder (set workaround_bugs=1 for this)
michaelni
parents:
396
diff
changeset
|
37 |
0 | 38 /* |
2967 | 39 * You can also call this codec : MPEG4 with a twist ! |
0 | 40 * |
2967 | 41 * TODO: |
0 | 42 * - (encoding) select best mv table (two choices) |
2967 | 43 * - (encoding) select best vlc/dc table |
0 | 44 */ |
45 //#define DEBUG | |
46 | |
531 | 47 #define DC_VLC_BITS 9 |
48 #define V2_INTRA_CBPC_VLC_BITS 3 | |
49 #define V2_MB_TYPE_VLC_BITS 7 | |
50 #define MV_VLC_BITS 9 | |
51 #define V2_MV_VLC_BITS 9 | |
52 #define TEX_VLC_BITS 9 | |
53 | |
578 | 54 #define II_BITRATE 128*1024 |
55 #define MBAC_BITRATE 50*1024 | |
56 | |
936 | 57 #define DEFAULT_INTER_INDEX 3 |
58 | |
1064 | 59 static uint32_t v2_dc_lum_table[512][2]; |
60 static uint32_t v2_dc_chroma_table[512][2]; | |
307 | 61 |
3359 | 62 /* vc1 externs */ |
6146 | 63 extern const uint8_t wmv3_dc_scale_table[32]; |
601 | 64 |
0 | 65 #ifdef DEBUG |
66 int frame_count = 0; | |
67 #endif | |
68 | |
69 #include "msmpeg4data.h" | |
70 | |
8590 | 71 #if CONFIG_ENCODERS //strangely gcc includes this even if it is not referenced |
1064 | 72 static uint8_t rl_length[NB_RL_TABLES][MAX_LEVEL+1][MAX_RUN+1][2]; |
1325 | 73 #endif //CONFIG_ENCODERS |
601 | 74 |
4668 | 75 static uint8_t static_rl_table_store[NB_RL_TABLES][2][2*MAX_RUN + MAX_LEVEL + 3]; |
76 | |
10751
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
77 /* This table is practically identical to the one from h263 |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
78 * except that it is inverted. */ |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
79 static av_cold void init_h263_dc_for_msmpeg4(void) |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
80 { |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
81 int level, uni_code, uni_len; |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
82 |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
83 for(level=-256; level<256; level++){ |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
84 int size, v, l; |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
85 /* find number of bits */ |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
86 size = 0; |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
87 v = abs(level); |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
88 while (v) { |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
89 v >>= 1; |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
90 size++; |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
91 } |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
92 |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
93 if (level < 0) |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
94 l= (-level) ^ ((1 << size) - 1); |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
95 else |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
96 l= level; |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
97 |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
98 /* luminance h263 */ |
10816
9abebeca7d1b
Rename DCtab_*, its a global variable and it helps understanding if mpeg4
michael
parents:
10803
diff
changeset
|
99 uni_code= ff_mpeg4_DCtab_lum[size][0]; |
9abebeca7d1b
Rename DCtab_*, its a global variable and it helps understanding if mpeg4
michael
parents:
10803
diff
changeset
|
100 uni_len = ff_mpeg4_DCtab_lum[size][1]; |
10751
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
101 uni_code ^= (1<<uni_len)-1; //M$ does not like compatibility |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
102 |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
103 if (size > 0) { |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
104 uni_code<<=size; uni_code|=l; |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
105 uni_len+=size; |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
106 if (size > 8){ |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
107 uni_code<<=1; uni_code|=1; |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
108 uni_len++; |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
109 } |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
110 } |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
111 v2_dc_lum_table[level+256][0]= uni_code; |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
112 v2_dc_lum_table[level+256][1]= uni_len; |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
113 |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
114 /* chrominance h263 */ |
10816
9abebeca7d1b
Rename DCtab_*, its a global variable and it helps understanding if mpeg4
michael
parents:
10803
diff
changeset
|
115 uni_code= ff_mpeg4_DCtab_chrom[size][0]; |
9abebeca7d1b
Rename DCtab_*, its a global variable and it helps understanding if mpeg4
michael
parents:
10803
diff
changeset
|
116 uni_len = ff_mpeg4_DCtab_chrom[size][1]; |
10751
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
117 uni_code ^= (1<<uni_len)-1; //M$ does not like compatibility |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
118 |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
119 if (size > 0) { |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
120 uni_code<<=size; uni_code|=l; |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
121 uni_len+=size; |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
122 if (size > 8){ |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
123 uni_code<<=1; uni_code|=1; |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
124 uni_len++; |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
125 } |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
126 } |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
127 v2_dc_chroma_table[level+256][0]= uni_code; |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
128 v2_dc_chroma_table[level+256][1]= uni_len; |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
129 |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
130 } |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
131 } |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
132 |
9007
043574c5c153
Add missing av_cold in static init/close functions.
stefano
parents:
8780
diff
changeset
|
133 static av_cold void common_init(MpegEncContext * s) |
499 | 134 { |
6350 | 135 static int initialized=0; |
2967 | 136 |
499 | 137 switch(s->msmpeg4_version){ |
138 case 1: | |
139 case 2: | |
140 s->y_dc_scale_table= | |
141 s->c_dc_scale_table= ff_mpeg1_dc_scale_table; | |
142 break; | |
143 case 3: | |
144 if(s->workaround_bugs){ | |
145 s->y_dc_scale_table= old_ff_y_dc_scale_table; | |
7136 | 146 s->c_dc_scale_table= wmv1_c_dc_scale_table; |
499 | 147 } else{ |
148 s->y_dc_scale_table= ff_mpeg4_y_dc_scale_table; | |
149 s->c_dc_scale_table= ff_mpeg4_c_dc_scale_table; | |
150 } | |
151 break; | |
152 case 4: | |
936 | 153 case 5: |
499 | 154 s->y_dc_scale_table= wmv1_y_dc_scale_table; |
155 s->c_dc_scale_table= wmv1_c_dc_scale_table; | |
156 break; | |
9995
3141f69e3905
Do not check for both CONFIG_VC1_DECODER and CONFIG_WMV3_DECODER,
diego
parents:
9455
diff
changeset
|
157 #if CONFIG_VC1_DECODER |
2474 | 158 case 6: |
159 s->y_dc_scale_table= wmv3_dc_scale_table; | |
160 s->c_dc_scale_table= wmv3_dc_scale_table; | |
161 break; | |
2639 | 162 #endif |
2474 | 163 |
499 | 164 } |
165 | |
2967 | 166 |
936 | 167 if(s->msmpeg4_version>=4){ |
1273 | 168 ff_init_scantable(s->dsp.idct_permutation, &s->intra_scantable , wmv1_scantable[1]); |
169 ff_init_scantable(s->dsp.idct_permutation, &s->intra_h_scantable, wmv1_scantable[2]); | |
170 ff_init_scantable(s->dsp.idct_permutation, &s->intra_v_scantable, wmv1_scantable[3]); | |
171 ff_init_scantable(s->dsp.idct_permutation, &s->inter_scantable , wmv1_scantable[0]); | |
499 | 172 } |
706
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
601
diff
changeset
|
173 //Note the default tables are set in common_init in mpegvideo.c |
2967 | 174 |
6350 | 175 if(!initialized){ |
176 initialized=1; | |
499 | 177 |
178 init_h263_dc_for_msmpeg4(); | |
179 } | |
180 } | |
181 | |
8590 | 182 #if CONFIG_ENCODERS |
1070
6da5ae9ee199
more #ifdef CONFIG_ENCODERS patch by (Wolfgang Hesseler <qv at multimediaware dot com>) with modifications by me (s/WOLFGANG/CONFIG_ENCODERS/ and some other fixes)
michaelni
parents:
1064
diff
changeset
|
183 |
0 | 184 /* build the table which associate a (x,y) motion vector to a vlc */ |
185 static void init_mv_table(MVTable *tab) | |
186 { | |
187 int i, x, y; | |
188 | |
1064 | 189 tab->table_mv_index = av_malloc(sizeof(uint16_t) * 4096); |
0 | 190 /* mark all entries as not used */ |
191 for(i=0;i<4096;i++) | |
192 tab->table_mv_index[i] = tab->n; | |
2967 | 193 |
0 | 194 for(i=0;i<tab->n;i++) { |
195 x = tab->table_mvx[i]; | |
196 y = tab->table_mvy[i]; | |
197 tab->table_mv_index[(x << 6) | y] = i; | |
198 } | |
199 } | |
200 | |
5882
51fc10d9fdff
rename some msmpeg4 symbols and make them non-static
aurel
parents:
5543
diff
changeset
|
201 void ff_msmpeg4_code012(PutBitContext *pb, int n) |
0 | 202 { |
203 if (n == 0) { | |
204 put_bits(pb, 1, 0); | |
205 } else { | |
206 put_bits(pb, 1, 1); | |
207 put_bits(pb, 1, (n >= 2)); | |
208 } | |
209 } | |
210 | |
499 | 211 static int get_size_of_code(MpegEncContext * s, RLTable *rl, int last, int run, int level, int intra){ |
212 int size=0; | |
213 int code; | |
214 int run_diff= intra ? 0 : 1; | |
2967 | 215 |
499 | 216 code = get_rl_index(rl, last, run, level); |
217 size+= rl->table_vlc[code][1]; | |
218 if (code == rl->n) { | |
219 int level1, run1; | |
220 | |
221 level1 = level - rl->max_level[last][run]; | |
2967 | 222 if (level1 < 1) |
499 | 223 goto esc2; |
224 code = get_rl_index(rl, last, run, level1); | |
225 if (code == rl->n) { | |
226 esc2: | |
227 size++; | |
228 if (level > MAX_LEVEL) | |
229 goto esc3; | |
230 run1 = run - rl->max_run[last][level] - run_diff; | |
231 if (run1 < 0) | |
232 goto esc3; | |
233 code = get_rl_index(rl, last, run1, level); | |
234 if (code == rl->n) { | |
235 esc3: | |
236 /* third escape */ | |
237 size+=1+1+6+8; | |
238 } else { | |
239 /* second escape */ | |
240 size+= 1+1+ rl->table_vlc[code][1]; | |
241 } | |
242 } else { | |
243 /* first escape */ | |
244 size+= 1+1+ rl->table_vlc[code][1]; | |
245 } | |
246 } else { | |
247 size++; | |
248 } | |
249 return size; | |
250 } | |
251 | |
10751
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
252 av_cold void ff_msmpeg4_encode_init(MpegEncContext *s) |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
253 { |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
254 static int init_done=0; |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
255 int i; |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
256 |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
257 common_init(s); |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
258 if(s->msmpeg4_version>=4){ |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
259 s->min_qcoeff= -255; |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
260 s->max_qcoeff= 255; |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
261 } |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
262 |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
263 if (!init_done) { |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
264 /* init various encoding tables */ |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
265 init_done = 1; |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
266 init_mv_table(&mv_tables[0]); |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
267 init_mv_table(&mv_tables[1]); |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
268 for(i=0;i<NB_RL_TABLES;i++) |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
269 init_rl(&rl_table[i], static_rl_table_store[i]); |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
270 |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
271 for(i=0; i<NB_RL_TABLES; i++){ |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
272 int level; |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
273 for(level=0; level<=MAX_LEVEL; level++){ |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
274 int run; |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
275 for(run=0; run<=MAX_RUN; run++){ |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
276 int last; |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
277 for(last=0; last<2; last++){ |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
278 rl_length[i][level][run][last]= get_size_of_code(s, &rl_table[ i], last, run, level, 0); |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
279 } |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
280 } |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
281 } |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
282 } |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
283 } |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
284 } |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
285 |
7994
ecade9a77827
Mark the ff_find_best_tables symbol static to msmpeg4. Patch by Diego Petten«Ò
lu_zero
parents:
7831
diff
changeset
|
286 static void find_best_tables(MpegEncContext * s) |
499 | 287 { |
288 int i; | |
289 int best =-1, best_size =9999999; | |
290 int chroma_best=-1, best_chroma_size=9999999; | |
601 | 291 |
499 | 292 for(i=0; i<3; i++){ |
293 int level; | |
294 int chroma_size=0; | |
295 int size=0; | |
296 | |
297 if(i>0){// ;) | |
2967 | 298 size++; |
499 | 299 chroma_size++; |
300 } | |
301 for(level=0; level<=MAX_LEVEL; level++){ | |
302 int run; | |
303 for(run=0; run<=MAX_RUN; run++){ | |
304 int last; | |
601 | 305 const int last_size= size + chroma_size; |
499 | 306 for(last=0; last<2; last++){ |
307 int inter_count = s->ac_stats[0][0][level][run][last] + s->ac_stats[0][1][level][run][last]; | |
308 int intra_luma_count = s->ac_stats[1][0][level][run][last]; | |
309 int intra_chroma_count= s->ac_stats[1][1][level][run][last]; | |
2967 | 310 |
6481 | 311 if(s->pict_type==FF_I_TYPE){ |
774
baa66649df35
mergeing inter & intra rl_length tables (50% smaller & no meassureable difference in filesize/quality)
michaelni
parents:
773
diff
changeset
|
312 size += intra_luma_count *rl_length[i ][level][run][last]; |
baa66649df35
mergeing inter & intra rl_length tables (50% smaller & no meassureable difference in filesize/quality)
michaelni
parents:
773
diff
changeset
|
313 chroma_size+= intra_chroma_count*rl_length[i+3][level][run][last]; |
499 | 314 }else{ |
774
baa66649df35
mergeing inter & intra rl_length tables (50% smaller & no meassureable difference in filesize/quality)
michaelni
parents:
773
diff
changeset
|
315 size+= intra_luma_count *rl_length[i ][level][run][last] |
baa66649df35
mergeing inter & intra rl_length tables (50% smaller & no meassureable difference in filesize/quality)
michaelni
parents:
773
diff
changeset
|
316 +intra_chroma_count*rl_length[i+3][level][run][last] |
baa66649df35
mergeing inter & intra rl_length tables (50% smaller & no meassureable difference in filesize/quality)
michaelni
parents:
773
diff
changeset
|
317 +inter_count *rl_length[i+3][level][run][last]; |
2967 | 318 } |
499 | 319 } |
601 | 320 if(last_size == size+chroma_size) break; |
499 | 321 } |
322 } | |
323 if(size<best_size){ | |
324 best_size= size; | |
325 best= i; | |
326 } | |
327 if(chroma_size<best_chroma_size){ | |
328 best_chroma_size= chroma_size; | |
329 chroma_best= i; | |
330 } | |
331 } | |
601 | 332 |
2967 | 333 // printf("type:%d, best:%d, qp:%d, var:%d, mcvar:%d, size:%d //\n", |
499 | 334 // s->pict_type, best, s->qscale, s->mb_var_sum, s->mc_mb_var_sum, best_size); |
2967 | 335 |
6481 | 336 if(s->pict_type==FF_P_TYPE) chroma_best= best; |
499 | 337 |
338 memset(s->ac_stats, 0, sizeof(int)*(MAX_LEVEL+1)*(MAX_RUN+1)*2*2*2); | |
339 | |
340 s->rl_table_index = best; | |
341 s->rl_chroma_table_index= chroma_best; | |
2967 | 342 |
499 | 343 if(s->pict_type != s->last_non_b_pict_type){ |
344 s->rl_table_index= 2; | |
6481 | 345 if(s->pict_type==FF_I_TYPE) |
499 | 346 s->rl_chroma_table_index= 1; |
347 else | |
348 s->rl_chroma_table_index= 2; | |
349 } | |
350 | |
351 } | |
352 | |
457 | 353 /* write MSMPEG4 compatible frame header */ |
0 | 354 void msmpeg4_encode_picture_header(MpegEncContext * s, int picture_number) |
355 { | |
7994
ecade9a77827
Mark the ff_find_best_tables symbol static to msmpeg4. Patch by Diego Petten«Ò
lu_zero
parents:
7831
diff
changeset
|
356 find_best_tables(s); |
0 | 357 |
358 align_put_bits(&s->pb); | |
359 put_bits(&s->pb, 2, s->pict_type - 1); | |
360 | |
361 put_bits(&s->pb, 5, s->qscale); | |
499 | 362 if(s->msmpeg4_version<=2){ |
363 s->rl_table_index = 2; | |
364 s->rl_chroma_table_index = 2; | |
365 } | |
310 | 366 |
0 | 367 s->dc_table_index = 1; |
368 s->mv_table_index = 1; /* only if P frame */ | |
369 s->use_skip_mb_code = 1; /* only if P frame */ | |
499 | 370 s->per_mb_rl_table = 0; |
759 | 371 if(s->msmpeg4_version==4) |
6481 | 372 s->inter_intra_pred= (s->width*s->height < 320*240 && s->bit_rate<=II_BITRATE && s->pict_type==FF_P_TYPE); |
936 | 373 //printf("%d %d %d %d %d\n", s->pict_type, s->bit_rate, s->inter_intra_pred, s->width, s->height); |
499 | 374 |
6481 | 375 if (s->pict_type == FF_I_TYPE) { |
519 | 376 s->slice_height= s->mb_height/1; |
377 put_bits(&s->pb, 5, 0x16 + s->mb_height/s->slice_height); | |
2967 | 378 |
499 | 379 if(s->msmpeg4_version==4){ |
380 msmpeg4_encode_ext_header(s); | |
578 | 381 if(s->bit_rate>MBAC_BITRATE) |
519 | 382 put_bits(&s->pb, 1, s->per_mb_rl_table); |
499 | 383 } |
0 | 384 |
457 | 385 if(s->msmpeg4_version>2){ |
499 | 386 if(!s->per_mb_rl_table){ |
5882
51fc10d9fdff
rename some msmpeg4 symbols and make them non-static
aurel
parents:
5543
diff
changeset
|
387 ff_msmpeg4_code012(&s->pb, s->rl_chroma_table_index); |
51fc10d9fdff
rename some msmpeg4 symbols and make them non-static
aurel
parents:
5543
diff
changeset
|
388 ff_msmpeg4_code012(&s->pb, s->rl_table_index); |
499 | 389 } |
0 | 390 |
310 | 391 put_bits(&s->pb, 1, s->dc_table_index); |
392 } | |
0 | 393 } else { |
394 put_bits(&s->pb, 1, s->use_skip_mb_code); | |
2967 | 395 |
578 | 396 if(s->msmpeg4_version==4 && s->bit_rate>MBAC_BITRATE) |
499 | 397 put_bits(&s->pb, 1, s->per_mb_rl_table); |
398 | |
457 | 399 if(s->msmpeg4_version>2){ |
499 | 400 if(!s->per_mb_rl_table) |
5882
51fc10d9fdff
rename some msmpeg4 symbols and make them non-static
aurel
parents:
5543
diff
changeset
|
401 ff_msmpeg4_code012(&s->pb, s->rl_table_index); |
0 | 402 |
310 | 403 put_bits(&s->pb, 1, s->dc_table_index); |
0 | 404 |
310 | 405 put_bits(&s->pb, 1, s->mv_table_index); |
406 } | |
0 | 407 } |
408 | |
499 | 409 s->esc3_level_length= 0; |
410 s->esc3_run_length= 0; | |
0 | 411 } |
412 | |
208 | 413 void msmpeg4_encode_ext_header(MpegEncContext * s) |
414 { | |
2637 | 415 put_bits(&s->pb, 5, s->avctx->time_base.den / s->avctx->time_base.num); //yes 29.97 -> 29 |
208 | 416 |
847 | 417 put_bits(&s->pb, 11, FFMIN(s->bit_rate/1024, 2047)); |
208 | 418 |
1163 | 419 if(s->msmpeg4_version>=3) |
457 | 420 put_bits(&s->pb, 1, s->flipflop_rounding); |
1163 | 421 else |
422 assert(s->flipflop_rounding==0); | |
208 | 423 } |
424 | |
1070
6da5ae9ee199
more #ifdef CONFIG_ENCODERS patch by (Wolfgang Hesseler <qv at multimediaware dot com>) with modifications by me (s/WOLFGANG/CONFIG_ENCODERS/ and some other fixes)
michaelni
parents:
1064
diff
changeset
|
425 #endif //CONFIG_ENCODERS |
6da5ae9ee199
more #ifdef CONFIG_ENCODERS patch by (Wolfgang Hesseler <qv at multimediaware dot com>) with modifications by me (s/WOLFGANG/CONFIG_ENCODERS/ and some other fixes)
michaelni
parents:
1064
diff
changeset
|
426 |
0 | 427 /* predict coded block */ |
5882
51fc10d9fdff
rename some msmpeg4 symbols and make them non-static
aurel
parents:
5543
diff
changeset
|
428 int ff_msmpeg4_coded_block_pred(MpegEncContext * s, int n, uint8_t **coded_block_ptr) |
0 | 429 { |
299 | 430 int xy, wrap, pred, a, b, c; |
0 | 431 |
299 | 432 xy = s->block_index[n]; |
1938
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1739
diff
changeset
|
433 wrap = s->b8_stride; |
0 | 434 |
435 /* B C | |
2967 | 436 * A X |
0 | 437 */ |
299 | 438 a = s->coded_block[xy - 1 ]; |
439 b = s->coded_block[xy - 1 - wrap]; | |
440 c = s->coded_block[xy - wrap]; | |
2967 | 441 |
0 | 442 if (b == c) { |
443 pred = a; | |
444 } else { | |
445 pred = c; | |
446 } | |
2967 | 447 |
0 | 448 /* store value */ |
299 | 449 *coded_block_ptr = &s->coded_block[xy]; |
0 | 450 |
451 return pred; | |
452 } | |
453 | |
8590 | 454 #if CONFIG_ENCODERS |
1070
6da5ae9ee199
more #ifdef CONFIG_ENCODERS patch by (Wolfgang Hesseler <qv at multimediaware dot com>) with modifications by me (s/WOLFGANG/CONFIG_ENCODERS/ and some other fixes)
michaelni
parents:
1064
diff
changeset
|
455 |
5882
51fc10d9fdff
rename some msmpeg4 symbols and make them non-static
aurel
parents:
5543
diff
changeset
|
456 void ff_msmpeg4_encode_motion(MpegEncContext * s, |
0 | 457 int mx, int my) |
458 { | |
459 int code; | |
460 MVTable *mv; | |
461 | |
462 /* modulo encoding */ | |
463 /* WARNING : you cannot reach all the MVs even with the modulo | |
464 encoding. This is a somewhat strange compromise they took !!! */ | |
465 if (mx <= -64) | |
466 mx += 64; | |
467 else if (mx >= 64) | |
468 mx -= 64; | |
469 if (my <= -64) | |
470 my += 64; | |
471 else if (my >= 64) | |
472 my -= 64; | |
2967 | 473 |
0 | 474 mx += 32; |
475 my += 32; | |
476 #if 0 | |
477 if ((unsigned)mx >= 64 || | |
2967 | 478 (unsigned)my >= 64) |
3177 | 479 av_log(s->avctx, AV_LOG_ERROR, "error mx=%d my=%d\n", mx, my); |
0 | 480 #endif |
481 mv = &mv_tables[s->mv_table_index]; | |
482 | |
483 code = mv->table_mv_index[(mx << 6) | my]; | |
2967 | 484 put_bits(&s->pb, |
485 mv->table_mv_bits[code], | |
0 | 486 mv->table_mv_code[code]); |
487 if (code == mv->n) { | |
5129 | 488 /* escape : code literally */ |
0 | 489 put_bits(&s->pb, 6, mx); |
490 put_bits(&s->pb, 6, my); | |
491 } | |
492 } | |
493 | |
5882
51fc10d9fdff
rename some msmpeg4 symbols and make them non-static
aurel
parents:
5543
diff
changeset
|
494 void ff_msmpeg4_handle_slices(MpegEncContext *s){ |
519 | 495 if (s->mb_x == 0) { |
496 if (s->slice_height && (s->mb_y % s->slice_height) == 0) { | |
983 | 497 if(s->msmpeg4_version < 4){ |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
743
diff
changeset
|
498 ff_mpeg4_clean_buffers(s); |
519 | 499 } |
500 s->first_slice_line = 1; | |
501 } else { | |
2967 | 502 s->first_slice_line = 0; |
519 | 503 } |
504 } | |
505 } | |
506 | |
10751
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
507 static void msmpeg4v2_encode_motion(MpegEncContext * s, int val) |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
508 { |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
509 int range, bit_size, sign, code, bits; |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
510 |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
511 if (val == 0) { |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
512 /* zero vector */ |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
513 code = 0; |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
514 put_bits(&s->pb, mvtab[code][1], mvtab[code][0]); |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
515 } else { |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
516 bit_size = s->f_code - 1; |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
517 range = 1 << bit_size; |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
518 if (val <= -64) |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
519 val += 64; |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
520 else if (val >= 64) |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
521 val -= 64; |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
522 |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
523 if (val >= 0) { |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
524 sign = 0; |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
525 } else { |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
526 val = -val; |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
527 sign = 1; |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
528 } |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
529 val--; |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
530 code = (val >> bit_size) + 1; |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
531 bits = val & (range - 1); |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
532 |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
533 put_bits(&s->pb, mvtab[code][1] + 1, (mvtab[code][0] << 1) | sign); |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
534 if (bit_size > 0) { |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
535 put_bits(&s->pb, bit_size, bits); |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
536 } |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
537 } |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
538 } |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
539 |
2967 | 540 void msmpeg4_encode_mb(MpegEncContext * s, |
0 | 541 DCTELEM block[6][64], |
542 int motion_x, int motion_y) | |
543 { | |
544 int cbp, coded_cbp, i; | |
545 int pred_x, pred_y; | |
1064 | 546 uint8_t *coded_block; |
0 | 547 |
5882
51fc10d9fdff
rename some msmpeg4 symbols and make them non-static
aurel
parents:
5543
diff
changeset
|
548 ff_msmpeg4_handle_slices(s); |
2967 | 549 |
0 | 550 if (!s->mb_intra) { |
2979 | 551 /* compute cbp */ |
552 cbp = 0; | |
553 for (i = 0; i < 6; i++) { | |
554 if (s->block_last_index[i] >= 0) | |
555 cbp |= 1 << (5 - i); | |
556 } | |
557 if (s->use_skip_mb_code && (cbp | motion_x | motion_y) == 0) { | |
558 /* skip macroblock */ | |
559 put_bits(&s->pb, 1, 1); | |
1164 | 560 s->last_bits++; |
2979 | 561 s->misc_bits++; |
1216 | 562 s->skip_count++; |
1164 | 563 |
2979 | 564 return; |
565 } | |
0 | 566 if (s->use_skip_mb_code) |
2979 | 567 put_bits(&s->pb, 1, 0); /* mb coded */ |
2967 | 568 |
457 | 569 if(s->msmpeg4_version<=2){ |
2967 | 570 put_bits(&s->pb, |
571 v2_mb_type[cbp&3][1], | |
310 | 572 v2_mb_type[cbp&3][0]); |
573 if((cbp&3) != 3) coded_cbp= cbp ^ 0x3C; | |
574 else coded_cbp= cbp; | |
0 | 575 |
2967 | 576 put_bits(&s->pb, |
10818
514dc1c87b2e
Rename most non static h263 tables so their name contains h263.
michael
parents:
10816
diff
changeset
|
577 ff_h263_cbpy_tab[coded_cbp>>2][1], |
514dc1c87b2e
Rename most non static h263 tables so their name contains h263.
michael
parents:
10816
diff
changeset
|
578 ff_h263_cbpy_tab[coded_cbp>>2][0]); |
1164 | 579 |
580 s->misc_bits += get_bits_diff(s); | |
581 | |
1938
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1739
diff
changeset
|
582 h263_pred_motion(s, 0, 0, &pred_x, &pred_y); |
310 | 583 msmpeg4v2_encode_motion(s, motion_x - pred_x); |
584 msmpeg4v2_encode_motion(s, motion_y - pred_y); | |
585 }else{ | |
2967 | 586 put_bits(&s->pb, |
587 table_mb_non_intra[cbp + 64][1], | |
310 | 588 table_mb_non_intra[cbp + 64][0]); |
589 | |
1164 | 590 s->misc_bits += get_bits_diff(s); |
591 | |
310 | 592 /* motion vector */ |
1938
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1739
diff
changeset
|
593 h263_pred_motion(s, 0, 0, &pred_x, &pred_y); |
5882
51fc10d9fdff
rename some msmpeg4 symbols and make them non-static
aurel
parents:
5543
diff
changeset
|
594 ff_msmpeg4_encode_motion(s, motion_x - pred_x, |
310 | 595 motion_y - pred_y); |
596 } | |
1164 | 597 |
598 s->mv_bits += get_bits_diff(s); | |
599 | |
600 for (i = 0; i < 6; i++) { | |
5178 | 601 ff_msmpeg4_encode_block(s, block[i], i); |
1164 | 602 } |
603 s->p_tex_bits += get_bits_diff(s); | |
0 | 604 } else { |
2979 | 605 /* compute cbp */ |
606 cbp = 0; | |
0 | 607 coded_cbp = 0; |
2979 | 608 for (i = 0; i < 6; i++) { |
0 | 609 int val, pred; |
610 val = (s->block_last_index[i] >= 1); | |
611 cbp |= val << (5 - i); | |
612 if (i < 4) { | |
613 /* predict value for close blocks only for luma */ | |
5882
51fc10d9fdff
rename some msmpeg4 symbols and make them non-static
aurel
parents:
5543
diff
changeset
|
614 pred = ff_msmpeg4_coded_block_pred(s, i, &coded_block); |
0 | 615 *coded_block = val; |
616 val = val ^ pred; | |
617 } | |
618 coded_cbp |= val << (5 - i); | |
2979 | 619 } |
0 | 620 #if 0 |
621 if (coded_cbp) | |
622 printf("cbp=%x %x\n", cbp, coded_cbp); | |
623 #endif | |
624 | |
457 | 625 if(s->msmpeg4_version<=2){ |
6481 | 626 if (s->pict_type == FF_I_TYPE) { |
2967 | 627 put_bits(&s->pb, |
310 | 628 v2_intra_cbpc[cbp&3][1], v2_intra_cbpc[cbp&3][0]); |
629 } else { | |
630 if (s->use_skip_mb_code) | |
2979 | 631 put_bits(&s->pb, 1, 0); /* mb coded */ |
2967 | 632 put_bits(&s->pb, |
633 v2_mb_type[(cbp&3) + 4][1], | |
310 | 634 v2_mb_type[(cbp&3) + 4][0]); |
635 } | |
2979 | 636 put_bits(&s->pb, 1, 0); /* no AC prediction yet */ |
2967 | 637 put_bits(&s->pb, |
10818
514dc1c87b2e
Rename most non static h263 tables so their name contains h263.
michael
parents:
10816
diff
changeset
|
638 ff_h263_cbpy_tab[cbp>>2][1], |
514dc1c87b2e
Rename most non static h263 tables so their name contains h263.
michael
parents:
10816
diff
changeset
|
639 ff_h263_cbpy_tab[cbp>>2][0]); |
310 | 640 }else{ |
6481 | 641 if (s->pict_type == FF_I_TYPE) { |
2967 | 642 put_bits(&s->pb, |
2474 | 643 ff_msmp4_mb_i_table[coded_cbp][1], ff_msmp4_mb_i_table[coded_cbp][0]); |
310 | 644 } else { |
645 if (s->use_skip_mb_code) | |
2979 | 646 put_bits(&s->pb, 1, 0); /* mb coded */ |
2967 | 647 put_bits(&s->pb, |
648 table_mb_non_intra[cbp][1], | |
310 | 649 table_mb_non_intra[cbp][0]); |
650 } | |
2979 | 651 put_bits(&s->pb, 1, 0); /* no AC prediction yet */ |
578 | 652 if(s->inter_intra_pred){ |
653 s->h263_aic_dir=0; | |
654 put_bits(&s->pb, table_inter_intra[s->h263_aic_dir][1], table_inter_intra[s->h263_aic_dir][0]); | |
655 } | |
0 | 656 } |
1164 | 657 s->misc_bits += get_bits_diff(s); |
0 | 658 |
1164 | 659 for (i = 0; i < 6; i++) { |
5178 | 660 ff_msmpeg4_encode_block(s, block[i], i); |
1164 | 661 } |
662 s->i_tex_bits += get_bits_diff(s); | |
1216 | 663 s->i_count++; |
0 | 664 } |
665 } | |
666 | |
1070
6da5ae9ee199
more #ifdef CONFIG_ENCODERS patch by (Wolfgang Hesseler <qv at multimediaware dot com>) with modifications by me (s/WOLFGANG/CONFIG_ENCODERS/ and some other fixes)
michaelni
parents:
1064
diff
changeset
|
667 #endif //CONFIG_ENCODERS |
6da5ae9ee199
more #ifdef CONFIG_ENCODERS patch by (Wolfgang Hesseler <qv at multimediaware dot com>) with modifications by me (s/WOLFGANG/CONFIG_ENCODERS/ and some other fixes)
michaelni
parents:
1064
diff
changeset
|
668 |
2967 | 669 static inline int msmpeg4v1_pred_dc(MpegEncContext * s, int n, |
1064 | 670 int32_t **dc_val_ptr) |
457 | 671 { |
672 int i; | |
673 | |
674 if (n < 4) { | |
675 i= 0; | |
676 } else { | |
677 i= n-3; | |
678 } | |
2967 | 679 |
457 | 680 *dc_val_ptr= &s->last_dc[i]; |
2967 | 681 return s->last_dc[i]; |
457 | 682 } |
683 | |
519 | 684 static int get_dc(uint8_t *src, int stride, int scale) |
685 { | |
686 int y; | |
687 int sum=0; | |
688 for(y=0; y<8; y++){ | |
689 int x; | |
690 for(x=0; x<8; x++){ | |
691 sum+=src[x + y*stride]; | |
692 } | |
693 } | |
1261
362947395f5c
fastdiv patch by (BERO <bero at geocities dot co dot jp>) with fixes & cleanup by me
michaelni
parents:
1255
diff
changeset
|
694 return FASTDIV((sum + (scale>>1)), scale); |
519 | 695 } |
696 | |
0 | 697 /* dir = 0: left, dir = 1: top prediction */ |
2967 | 698 static inline int msmpeg4_pred_dc(MpegEncContext * s, int n, |
3781 | 699 int16_t **dc_val_ptr, int *dir_ptr) |
0 | 700 { |
299 | 701 int a, b, c, wrap, pred, scale; |
3781 | 702 int16_t *dc_val; |
0 | 703 |
704 /* find prediction */ | |
705 if (n < 4) { | |
2979 | 706 scale = s->y_dc_scale; |
0 | 707 } else { |
2979 | 708 scale = s->c_dc_scale; |
0 | 709 } |
2967 | 710 |
299 | 711 wrap = s->block_wrap[n]; |
712 dc_val= s->dc_val[0] + s->block_index[n]; | |
0 | 713 |
714 /* B C | |
2967 | 715 * A X |
0 | 716 */ |
299 | 717 a = dc_val[ - 1]; |
718 b = dc_val[ - 1 - wrap]; | |
719 c = dc_val[ - wrap]; | |
2967 | 720 |
983 | 721 if(s->first_slice_line && (n&2)==0 && s->msmpeg4_version<4){ |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
743
diff
changeset
|
722 b=c=1024; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
743
diff
changeset
|
723 } |
0 | 724 |
725 /* XXX: the following solution consumes divisions, but it does not | |
726 necessitate to modify mpegvideo.c. The problem comes from the | |
727 fact they decided to store the quantized DC (which would lead | |
728 to problems if Q could vary !) */ | |
10071
6ac0d4957d35
Replace #ifdef PIC checks with the more appropriate HAVE_EBX_AVAILABLE/HAVE_7REGS.
reimar
parents:
9998
diff
changeset
|
729 #if ARCH_X86 && HAVE_7REGS && HAVE_EBX_AVAILABLE |
8031 | 730 __asm__ volatile( |
2979 | 731 "movl %3, %%eax \n\t" |
732 "shrl $1, %%eax \n\t" | |
733 "addl %%eax, %2 \n\t" | |
734 "addl %%eax, %1 \n\t" | |
735 "addl %0, %%eax \n\t" | |
736 "mull %4 \n\t" | |
737 "movl %%edx, %0 \n\t" | |
738 "movl %1, %%eax \n\t" | |
739 "mull %4 \n\t" | |
740 "movl %%edx, %1 \n\t" | |
741 "movl %2, %%eax \n\t" | |
742 "mull %4 \n\t" | |
743 "movl %%edx, %2 \n\t" | |
744 : "+b" (a), "+c" (b), "+D" (c) | |
4174 | 745 : "g" (scale), "S" (ff_inverse[scale]) |
2979 | 746 : "%eax", "%edx" |
204 | 747 ); |
221 | 748 #else |
8590 | 749 /* #elif ARCH_ALPHA */ |
214
73df666cacc7
Alpha optimizations by Falk Hueffner <falk.hueffner@student.uni-tuebingen.de>
nickols_k
parents:
208
diff
changeset
|
750 /* Divisions are extremely costly on Alpha; optimize the most |
221 | 751 common case. But they are costly everywhere... |
752 */ | |
214
73df666cacc7
Alpha optimizations by Falk Hueffner <falk.hueffner@student.uni-tuebingen.de>
nickols_k
parents:
208
diff
changeset
|
753 if (scale == 8) { |
2979 | 754 a = (a + (8 >> 1)) / 8; |
755 b = (b + (8 >> 1)) / 8; | |
756 c = (c + (8 >> 1)) / 8; | |
214
73df666cacc7
Alpha optimizations by Falk Hueffner <falk.hueffner@student.uni-tuebingen.de>
nickols_k
parents:
208
diff
changeset
|
757 } else { |
2979 | 758 a = FASTDIV((a + (scale >> 1)), scale); |
759 b = FASTDIV((b + (scale >> 1)), scale); | |
760 c = FASTDIV((c + (scale >> 1)), scale); | |
214
73df666cacc7
Alpha optimizations by Falk Hueffner <falk.hueffner@student.uni-tuebingen.de>
nickols_k
parents:
208
diff
changeset
|
761 } |
204 | 762 #endif |
0 | 763 /* XXX: WARNING: they did not choose the same test as MPEG4. This |
764 is very important ! */ | |
501
2241bce35bb9
fixing wmv1 bugs, it was foolish to belive that m$ would use the same dc prediction as mpeg4 just cuz they changed it a bit from msmpeg4v3
michaelni
parents:
499
diff
changeset
|
765 if(s->msmpeg4_version>3){ |
519 | 766 if(s->inter_intra_pred){ |
767 uint8_t *dest; | |
768 int wrap; | |
2967 | 769 |
519 | 770 if(n==1){ |
771 pred=a; | |
772 *dir_ptr = 0; | |
773 }else if(n==2){ | |
774 pred=c; | |
775 *dir_ptr = 1; | |
776 }else if(n==3){ | |
777 if (abs(a - b) < abs(b - c)) { | |
778 pred = c; | |
779 *dir_ptr = 1; | |
780 } else { | |
781 pred = a; | |
782 *dir_ptr = 0; | |
783 } | |
784 }else{ | |
785 if(n<4){ | |
786 wrap= s->linesize; | |
903 | 787 dest= s->current_picture.data[0] + (((n>>1) + 2*s->mb_y) * 8* wrap ) + ((n&1) + 2*s->mb_x) * 8; |
519 | 788 }else{ |
556 | 789 wrap= s->uvlinesize; |
903 | 790 dest= s->current_picture.data[n-3] + (s->mb_y * 8 * wrap) + s->mb_x * 8; |
519 | 791 } |
792 if(s->mb_x==0) a= (1024 + (scale>>1))/scale; | |
793 else a= get_dc(dest-8, wrap, scale*8); | |
794 if(s->mb_y==0) c= (1024 + (scale>>1))/scale; | |
795 else c= get_dc(dest-8*wrap, wrap, scale*8); | |
2967 | 796 |
519 | 797 if (s->h263_aic_dir==0) { |
798 pred= a; | |
799 *dir_ptr = 0; | |
800 }else if (s->h263_aic_dir==1) { | |
801 if(n==0){ | |
802 pred= c; | |
803 *dir_ptr = 1; | |
804 }else{ | |
805 pred= a; | |
806 *dir_ptr = 0; | |
807 } | |
808 }else if (s->h263_aic_dir==2) { | |
809 if(n==0){ | |
810 pred= a; | |
811 *dir_ptr = 0; | |
812 }else{ | |
813 pred= c; | |
814 *dir_ptr = 1; | |
815 } | |
816 } else { | |
817 pred= c; | |
818 *dir_ptr = 1; | |
819 } | |
820 } | |
821 }else{ | |
822 if (abs(a - b) < abs(b - c)) { | |
823 pred = c; | |
824 *dir_ptr = 1; | |
825 } else { | |
826 pred = a; | |
827 *dir_ptr = 0; | |
828 } | |
501
2241bce35bb9
fixing wmv1 bugs, it was foolish to belive that m$ would use the same dc prediction as mpeg4 just cuz they changed it a bit from msmpeg4v3
michaelni
parents:
499
diff
changeset
|
829 } |
2241bce35bb9
fixing wmv1 bugs, it was foolish to belive that m$ would use the same dc prediction as mpeg4 just cuz they changed it a bit from msmpeg4v3
michaelni
parents:
499
diff
changeset
|
830 }else{ |
2241bce35bb9
fixing wmv1 bugs, it was foolish to belive that m$ would use the same dc prediction as mpeg4 just cuz they changed it a bit from msmpeg4v3
michaelni
parents:
499
diff
changeset
|
831 if (abs(a - b) <= abs(b - c)) { |
2241bce35bb9
fixing wmv1 bugs, it was foolish to belive that m$ would use the same dc prediction as mpeg4 just cuz they changed it a bit from msmpeg4v3
michaelni
parents:
499
diff
changeset
|
832 pred = c; |
2241bce35bb9
fixing wmv1 bugs, it was foolish to belive that m$ would use the same dc prediction as mpeg4 just cuz they changed it a bit from msmpeg4v3
michaelni
parents:
499
diff
changeset
|
833 *dir_ptr = 1; |
2241bce35bb9
fixing wmv1 bugs, it was foolish to belive that m$ would use the same dc prediction as mpeg4 just cuz they changed it a bit from msmpeg4v3
michaelni
parents:
499
diff
changeset
|
834 } else { |
2241bce35bb9
fixing wmv1 bugs, it was foolish to belive that m$ would use the same dc prediction as mpeg4 just cuz they changed it a bit from msmpeg4v3
michaelni
parents:
499
diff
changeset
|
835 pred = a; |
2241bce35bb9
fixing wmv1 bugs, it was foolish to belive that m$ would use the same dc prediction as mpeg4 just cuz they changed it a bit from msmpeg4v3
michaelni
parents:
499
diff
changeset
|
836 *dir_ptr = 0; |
2241bce35bb9
fixing wmv1 bugs, it was foolish to belive that m$ would use the same dc prediction as mpeg4 just cuz they changed it a bit from msmpeg4v3
michaelni
parents:
499
diff
changeset
|
837 } |
0 | 838 } |
839 | |
840 /* update predictor */ | |
299 | 841 *dc_val_ptr = &dc_val[0]; |
0 | 842 return pred; |
843 } | |
844 | |
845 #define DC_MAX 119 | |
846 | |
847 static void msmpeg4_encode_dc(MpegEncContext * s, int level, int n, int *dir_ptr) | |
848 { | |
849 int sign, code; | |
5179
04bbac6e28df
modify msmpeg4 functions to generate VC1 compatible block layer bitstream
benoit
parents:
5178
diff
changeset
|
850 int pred, extquant; |
04bbac6e28df
modify msmpeg4 functions to generate VC1 compatible block layer bitstream
benoit
parents:
5178
diff
changeset
|
851 int extrabits = 0; |
0 | 852 |
457 | 853 if(s->msmpeg4_version==1){ |
1064 | 854 int32_t *dc_val; |
457 | 855 pred = msmpeg4v1_pred_dc(s, n, &dc_val); |
2967 | 856 |
457 | 857 /* update predictor */ |
858 *dc_val= level; | |
859 }else{ | |
3781 | 860 int16_t *dc_val; |
501
2241bce35bb9
fixing wmv1 bugs, it was foolish to belive that m$ would use the same dc prediction as mpeg4 just cuz they changed it a bit from msmpeg4v3
michaelni
parents:
499
diff
changeset
|
861 pred = msmpeg4_pred_dc(s, n, &dc_val, dir_ptr); |
457 | 862 |
863 /* update predictor */ | |
864 if (n < 4) { | |
865 *dc_val = level * s->y_dc_scale; | |
866 } else { | |
867 *dc_val = level * s->c_dc_scale; | |
868 } | |
0 | 869 } |
870 | |
871 /* do the prediction */ | |
872 level -= pred; | |
873 | |
457 | 874 if(s->msmpeg4_version<=2){ |
310 | 875 if (n < 4) { |
2967 | 876 put_bits(&s->pb, |
310 | 877 v2_dc_lum_table[level+256][1], |
878 v2_dc_lum_table[level+256][0]); | |
879 }else{ | |
2967 | 880 put_bits(&s->pb, |
310 | 881 v2_dc_chroma_table[level+256][1], |
882 v2_dc_chroma_table[level+256][0]); | |
883 } | |
884 }else{ | |
885 sign = 0; | |
886 if (level < 0) { | |
887 level = -level; | |
888 sign = 1; | |
889 } | |
890 code = level; | |
2967 | 891 if (code > DC_MAX) |
310 | 892 code = DC_MAX; |
5179
04bbac6e28df
modify msmpeg4 functions to generate VC1 compatible block layer bitstream
benoit
parents:
5178
diff
changeset
|
893 else if( s->msmpeg4_version>=6 ) { |
04bbac6e28df
modify msmpeg4 functions to generate VC1 compatible block layer bitstream
benoit
parents:
5178
diff
changeset
|
894 if( s->qscale == 1 ) { |
04bbac6e28df
modify msmpeg4 functions to generate VC1 compatible block layer bitstream
benoit
parents:
5178
diff
changeset
|
895 extquant = (level + 3) & 0x3; |
04bbac6e28df
modify msmpeg4 functions to generate VC1 compatible block layer bitstream
benoit
parents:
5178
diff
changeset
|
896 code = ((level+3)>>2); |
04bbac6e28df
modify msmpeg4 functions to generate VC1 compatible block layer bitstream
benoit
parents:
5178
diff
changeset
|
897 } else if( s->qscale == 2 ) { |
04bbac6e28df
modify msmpeg4 functions to generate VC1 compatible block layer bitstream
benoit
parents:
5178
diff
changeset
|
898 extquant = (level + 1) & 0x1; |
04bbac6e28df
modify msmpeg4 functions to generate VC1 compatible block layer bitstream
benoit
parents:
5178
diff
changeset
|
899 code = ((level+1)>>1); |
04bbac6e28df
modify msmpeg4 functions to generate VC1 compatible block layer bitstream
benoit
parents:
5178
diff
changeset
|
900 } |
04bbac6e28df
modify msmpeg4 functions to generate VC1 compatible block layer bitstream
benoit
parents:
5178
diff
changeset
|
901 } |
0 | 902 |
310 | 903 if (s->dc_table_index == 0) { |
904 if (n < 4) { | |
2465
5565203c95ee
use dc tables from msmpeg4 instead of duplicating them patch by anonymous
michael
parents:
2464
diff
changeset
|
905 put_bits(&s->pb, ff_table0_dc_lum[code][1], ff_table0_dc_lum[code][0]); |
310 | 906 } else { |
2465
5565203c95ee
use dc tables from msmpeg4 instead of duplicating them patch by anonymous
michael
parents:
2464
diff
changeset
|
907 put_bits(&s->pb, ff_table0_dc_chroma[code][1], ff_table0_dc_chroma[code][0]); |
310 | 908 } |
0 | 909 } else { |
310 | 910 if (n < 4) { |
2465
5565203c95ee
use dc tables from msmpeg4 instead of duplicating them patch by anonymous
michael
parents:
2464
diff
changeset
|
911 put_bits(&s->pb, ff_table1_dc_lum[code][1], ff_table1_dc_lum[code][0]); |
310 | 912 } else { |
2465
5565203c95ee
use dc tables from msmpeg4 instead of duplicating them patch by anonymous
michael
parents:
2464
diff
changeset
|
913 put_bits(&s->pb, ff_table1_dc_chroma[code][1], ff_table1_dc_chroma[code][0]); |
310 | 914 } |
0 | 915 } |
2967 | 916 |
5179
04bbac6e28df
modify msmpeg4 functions to generate VC1 compatible block layer bitstream
benoit
parents:
5178
diff
changeset
|
917 if(s->msmpeg4_version>=6 && s->qscale<=2) |
04bbac6e28df
modify msmpeg4 functions to generate VC1 compatible block layer bitstream
benoit
parents:
5178
diff
changeset
|
918 extrabits = 3 - s->qscale; |
04bbac6e28df
modify msmpeg4 functions to generate VC1 compatible block layer bitstream
benoit
parents:
5178
diff
changeset
|
919 |
310 | 920 if (code == DC_MAX) |
5179
04bbac6e28df
modify msmpeg4 functions to generate VC1 compatible block layer bitstream
benoit
parents:
5178
diff
changeset
|
921 put_bits(&s->pb, 8 + extrabits, level); |
04bbac6e28df
modify msmpeg4 functions to generate VC1 compatible block layer bitstream
benoit
parents:
5178
diff
changeset
|
922 else if(extrabits > 0)//== VC1 && s->qscale<=2 |
04bbac6e28df
modify msmpeg4 functions to generate VC1 compatible block layer bitstream
benoit
parents:
5178
diff
changeset
|
923 put_bits(&s->pb, extrabits, extquant); |
2967 | 924 |
310 | 925 if (level != 0) { |
926 put_bits(&s->pb, 1, sign); | |
927 } | |
0 | 928 } |
929 } | |
930 | |
931 /* Encoding of a block. Very similar to MPEG4 except for a different | |
932 escape coding (same as H263) and more vlc tables. | |
933 */ | |
5178 | 934 void ff_msmpeg4_encode_block(MpegEncContext * s, DCTELEM * block, int n) |
0 | 935 { |
936 int level, run, last, i, j, last_index; | |
937 int last_non_zero, sign, slevel; | |
938 int code, run_diff, dc_pred_dir; | |
939 const RLTable *rl; | |
1064 | 940 const uint8_t *scantable; |
0 | 941 |
942 if (s->mb_intra) { | |
943 msmpeg4_encode_dc(s, block[0], n, &dc_pred_dir); | |
944 i = 1; | |
945 if (n < 4) { | |
946 rl = &rl_table[s->rl_table_index]; | |
947 } else { | |
948 rl = &rl_table[3 + s->rl_chroma_table_index]; | |
949 } | |
5496 | 950 run_diff = s->msmpeg4_version>=4; |
706
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
601
diff
changeset
|
951 scantable= s->intra_scantable.permutated; |
0 | 952 } else { |
953 i = 0; | |
954 rl = &rl_table[3 + s->rl_table_index]; | |
457 | 955 if(s->msmpeg4_version<=2) |
310 | 956 run_diff = 0; |
957 else | |
958 run_diff = 1; | |
706
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
601
diff
changeset
|
959 scantable= s->inter_scantable.permutated; |
0 | 960 } |
961 | |
499 | 962 /* recalculate block_last_index for M$ wmv1 */ |
5179
04bbac6e28df
modify msmpeg4 functions to generate VC1 compatible block layer bitstream
benoit
parents:
5178
diff
changeset
|
963 if(s->msmpeg4_version>=4 && s->msmpeg4_version<6 && s->block_last_index[n]>0){ |
499 | 964 for(last_index=63; last_index>=0; last_index--){ |
965 if(block[scantable[last_index]]) break; | |
966 } | |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
743
diff
changeset
|
967 s->block_last_index[n]= last_index; |
499 | 968 }else |
969 last_index = s->block_last_index[n]; | |
0 | 970 /* AC coefs */ |
971 last_non_zero = i - 1; | |
972 for (; i <= last_index; i++) { | |
2979 | 973 j = scantable[i]; |
974 level = block[j]; | |
975 if (level) { | |
976 run = i - last_non_zero - 1; | |
977 last = (i == last_index); | |
978 sign = 0; | |
979 slevel = level; | |
980 if (level < 0) { | |
981 sign = 1; | |
982 level = -level; | |
983 } | |
601 | 984 |
499 | 985 if(level<=MAX_LEVEL && run<=MAX_RUN){ |
986 s->ac_stats[s->mb_intra][n>3][level][run][last]++; | |
987 } | |
988 #if 0 | |
989 else | |
990 s->ac_stats[s->mb_intra][n>3][40][63][0]++; //esc3 like | |
991 #endif | |
0 | 992 code = get_rl_index(rl, last, run, level); |
993 put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]); | |
994 if (code == rl->n) { | |
995 int level1, run1; | |
996 | |
997 level1 = level - rl->max_level[last][run]; | |
2967 | 998 if (level1 < 1) |
0 | 999 goto esc2; |
1000 code = get_rl_index(rl, last, run, level1); | |
1001 if (code == rl->n) { | |
1002 esc2: | |
1003 put_bits(&s->pb, 1, 0); | |
1004 if (level > MAX_LEVEL) | |
1005 goto esc3; | |
1006 run1 = run - rl->max_run[last][level] - run_diff; | |
1007 if (run1 < 0) | |
1008 goto esc3; | |
5496 | 1009 code = get_rl_index(rl, last, run1+1, level); |
1010 if (s->msmpeg4_version == 4 && code == rl->n) | |
1011 goto esc3; | |
0 | 1012 code = get_rl_index(rl, last, run1, level); |
1013 if (code == rl->n) { | |
1014 esc3: | |
1015 /* third escape */ | |
1016 put_bits(&s->pb, 1, 0); | |
1017 put_bits(&s->pb, 1, last); | |
936 | 1018 if(s->msmpeg4_version>=4){ |
499 | 1019 if(s->esc3_level_length==0){ |
1020 s->esc3_level_length=8; | |
1021 s->esc3_run_length= 6; | |
5179
04bbac6e28df
modify msmpeg4 functions to generate VC1 compatible block layer bitstream
benoit
parents:
5178
diff
changeset
|
1022 //ESCLVLSZ + ESCRUNSZ |
499 | 1023 if(s->qscale<8) |
5179
04bbac6e28df
modify msmpeg4 functions to generate VC1 compatible block layer bitstream
benoit
parents:
5178
diff
changeset
|
1024 put_bits(&s->pb, 6 + (s->msmpeg4_version>=6), 3); |
499 | 1025 else |
1026 put_bits(&s->pb, 8, 3); | |
1027 } | |
1028 put_bits(&s->pb, s->esc3_run_length, run); | |
1029 put_bits(&s->pb, 1, sign); | |
1030 put_bits(&s->pb, s->esc3_level_length, level); | |
1031 }else{ | |
1032 put_bits(&s->pb, 6, run); | |
7260
3ec34b551aae
bitstream: move put_sbits() from flacenc.c to bitstream.h and use it
ramiro
parents:
7136
diff
changeset
|
1033 put_sbits(&s->pb, 8, slevel); |
499 | 1034 } |
0 | 1035 } else { |
1036 /* second escape */ | |
1037 put_bits(&s->pb, 1, 1); | |
1038 put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]); | |
1039 put_bits(&s->pb, 1, sign); | |
1040 } | |
1041 } else { | |
1042 /* first escape */ | |
1043 put_bits(&s->pb, 1, 1); | |
1044 put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]); | |
1045 put_bits(&s->pb, 1, sign); | |
1046 } | |
1047 } else { | |
1048 put_bits(&s->pb, 1, sign); | |
1049 } | |
2979 | 1050 last_non_zero = i; |
1051 } | |
0 | 1052 } |
1053 } | |
1054 | |
1055 /****************************************/ | |
1056 /* decoding stuff */ | |
1057 | |
5882
51fc10d9fdff
rename some msmpeg4 symbols and make them non-static
aurel
parents:
5543
diff
changeset
|
1058 VLC ff_mb_non_intra_vlc[4]; |
307 | 1059 static VLC v2_dc_lum_vlc; |
1060 static VLC v2_dc_chroma_vlc; | |
1061 static VLC v2_intra_cbpc_vlc; | |
1062 static VLC v2_mb_type_vlc; | |
1063 static VLC v2_mv_vlc; | |
5882
51fc10d9fdff
rename some msmpeg4 symbols and make them non-static
aurel
parents:
5543
diff
changeset
|
1064 VLC ff_inter_intra_vlc; |
307 | 1065 |
10751
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
1066 /* This is identical to h263 except that its range is multiplied by 2. */ |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
1067 static int msmpeg4v2_decode_motion(MpegEncContext * s, int pred, int f_code) |
307 | 1068 { |
10751
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
1069 int code, val, sign, shift; |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
1070 |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
1071 code = get_vlc2(&s->gb, v2_mv_vlc.table, V2_MV_VLC_BITS, 2); |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
1072 // printf("MV code %d at %d %d pred: %d\n", code, s->mb_x,s->mb_y, pred); |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
1073 if (code < 0) |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
1074 return 0xffff; |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
1075 |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
1076 if (code == 0) |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
1077 return pred; |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
1078 sign = get_bits1(&s->gb); |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
1079 shift = f_code - 1; |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
1080 val = code; |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
1081 if (shift) { |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
1082 val = (val - 1) << shift; |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
1083 val |= get_bits(&s->gb, shift); |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
1084 val++; |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
1085 } |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
1086 if (sign) |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
1087 val = -val; |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
1088 |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
1089 val += pred; |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
1090 if (val <= -64) |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
1091 val += 64; |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
1092 else if (val >= 64) |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
1093 val -= 64; |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
1094 |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
1095 return val; |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
1096 } |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
1097 |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
1098 static int msmpeg4v12_decode_mb(MpegEncContext *s, DCTELEM block[6][64]) |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
1099 { |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
1100 int cbp, code, i; |
307 | 1101 |
10751
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
1102 if (s->pict_type == FF_P_TYPE) { |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
1103 if (s->use_skip_mb_code) { |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
1104 if (get_bits1(&s->gb)) { |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
1105 /* skip mb */ |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
1106 s->mb_intra = 0; |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
1107 for(i=0;i<6;i++) |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
1108 s->block_last_index[i] = -1; |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
1109 s->mv_dir = MV_DIR_FORWARD; |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
1110 s->mv_type = MV_TYPE_16X16; |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
1111 s->mv[0][0][0] = 0; |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
1112 s->mv[0][0][1] = 0; |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
1113 s->mb_skipped = 1; |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
1114 return 0; |
307 | 1115 } |
10751
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
1116 } |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
1117 |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
1118 if(s->msmpeg4_version==2) |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
1119 code = get_vlc2(&s->gb, v2_mb_type_vlc.table, V2_MB_TYPE_VLC_BITS, 1); |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
1120 else |
10821
030e30b050e4
Use h263 tables in msmpeg4v1 dont duplicate them halfway.
michael
parents:
10818
diff
changeset
|
1121 code = get_vlc2(&s->gb, ff_h263_inter_MCBPC_vlc.table, INTER_MCBPC_VLC_BITS, 2); |
10751
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
1122 if(code<0 || code>7){ |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
1123 av_log(s->avctx, AV_LOG_ERROR, "cbpc %d invalid at %d %d\n", code, s->mb_x, s->mb_y); |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
1124 return -1; |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
1125 } |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
1126 |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
1127 s->mb_intra = code >>2; |
307 | 1128 |
10751
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
1129 cbp = code & 0x3; |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
1130 } else { |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
1131 s->mb_intra = 1; |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
1132 if(s->msmpeg4_version==2) |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
1133 cbp= get_vlc2(&s->gb, v2_intra_cbpc_vlc.table, V2_INTRA_CBPC_VLC_BITS, 1); |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
1134 else |
10821
030e30b050e4
Use h263 tables in msmpeg4v1 dont duplicate them halfway.
michael
parents:
10818
diff
changeset
|
1135 cbp= get_vlc2(&s->gb, ff_h263_intra_MCBPC_vlc.table, INTRA_MCBPC_VLC_BITS, 1); |
10751
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
1136 if(cbp<0 || cbp>3){ |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
1137 av_log(s->avctx, AV_LOG_ERROR, "cbpc %d invalid at %d %d\n", cbp, s->mb_x, s->mb_y); |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
1138 return -1; |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
1139 } |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
1140 } |
307 | 1141 |
10751
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
1142 if (!s->mb_intra) { |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
1143 int mx, my, cbpy; |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
1144 |
10818
514dc1c87b2e
Rename most non static h263 tables so their name contains h263.
michael
parents:
10816
diff
changeset
|
1145 cbpy= get_vlc2(&s->gb, ff_h263_cbpy_vlc.table, CBPY_VLC_BITS, 1); |
10751
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
1146 if(cbpy<0){ |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
1147 av_log(s->avctx, AV_LOG_ERROR, "cbpy %d invalid at %d %d\n", cbp, s->mb_x, s->mb_y); |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
1148 return -1; |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
1149 } |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
1150 |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
1151 cbp|= cbpy<<2; |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
1152 if(s->msmpeg4_version==1 || (cbp&3) != 3) cbp^= 0x3C; |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
1153 |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
1154 h263_pred_motion(s, 0, 0, &mx, &my); |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
1155 mx= msmpeg4v2_decode_motion(s, mx, 1); |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
1156 my= msmpeg4v2_decode_motion(s, my, 1); |
307 | 1157 |
10751
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
1158 s->mv_dir = MV_DIR_FORWARD; |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
1159 s->mv_type = MV_TYPE_16X16; |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
1160 s->mv[0][0][0] = mx; |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
1161 s->mv[0][0][1] = my; |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
1162 } else { |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
1163 if(s->msmpeg4_version==2){ |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
1164 s->ac_pred = get_bits1(&s->gb); |
10818
514dc1c87b2e
Rename most non static h263 tables so their name contains h263.
michael
parents:
10816
diff
changeset
|
1165 cbp|= get_vlc2(&s->gb, ff_h263_cbpy_vlc.table, CBPY_VLC_BITS, 1)<<2; //FIXME check errors |
10751
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
1166 } else{ |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
1167 s->ac_pred = 0; |
10818
514dc1c87b2e
Rename most non static h263 tables so their name contains h263.
michael
parents:
10816
diff
changeset
|
1168 cbp|= get_vlc2(&s->gb, ff_h263_cbpy_vlc.table, CBPY_VLC_BITS, 1)<<2; //FIXME check errors |
10751
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
1169 if(s->pict_type==FF_P_TYPE) cbp^=0x3C; |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
1170 } |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
1171 } |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
1172 |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
1173 s->dsp.clear_blocks(s->block[0]); |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
1174 for (i = 0; i < 6; i++) { |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
1175 if (ff_msmpeg4_decode_block(s, block[i], i, (cbp >> (5 - i)) & 1, NULL) < 0) |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
1176 { |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
1177 av_log(s->avctx, AV_LOG_ERROR, "\nerror while decoding block: %d x %d (%d)\n", s->mb_x, s->mb_y, i); |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
1178 return -1; |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
1179 } |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
1180 } |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
1181 return 0; |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
1182 } |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
1183 |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
1184 static int msmpeg4v34_decode_mb(MpegEncContext *s, DCTELEM block[6][64]) |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
1185 { |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
1186 int cbp, code, i; |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
1187 uint8_t *coded_val; |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
1188 uint32_t * const mb_type_ptr= &s->current_picture.mb_type[ s->mb_x + s->mb_y*s->mb_stride ]; |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
1189 |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
1190 if (s->pict_type == FF_P_TYPE) { |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
1191 if (s->use_skip_mb_code) { |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
1192 if (get_bits1(&s->gb)) { |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
1193 /* skip mb */ |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
1194 s->mb_intra = 0; |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
1195 for(i=0;i<6;i++) |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
1196 s->block_last_index[i] = -1; |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
1197 s->mv_dir = MV_DIR_FORWARD; |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
1198 s->mv_type = MV_TYPE_16X16; |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
1199 s->mv[0][0][0] = 0; |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
1200 s->mv[0][0][1] = 0; |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
1201 s->mb_skipped = 1; |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
1202 *mb_type_ptr = MB_TYPE_SKIP | MB_TYPE_L0 | MB_TYPE_16x16; |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
1203 |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
1204 return 0; |
307 | 1205 } |
10751
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
1206 } |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
1207 |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
1208 code = get_vlc2(&s->gb, ff_mb_non_intra_vlc[DEFAULT_INTER_INDEX].table, MB_NON_INTRA_VLC_BITS, 3); |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
1209 if (code < 0) |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
1210 return -1; |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
1211 //s->mb_intra = (code & 0x40) ? 0 : 1; |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
1212 s->mb_intra = (~code & 0x40) >> 6; |
307 | 1213 |
10751
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
1214 cbp = code & 0x3f; |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
1215 } else { |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
1216 s->mb_intra = 1; |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
1217 code = get_vlc2(&s->gb, ff_msmp4_mb_i_vlc.table, MB_INTRA_VLC_BITS, 2); |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
1218 if (code < 0) |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
1219 return -1; |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
1220 /* predict coded block pattern */ |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
1221 cbp = 0; |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
1222 for(i=0;i<6;i++) { |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
1223 int val = ((code >> (5 - i)) & 1); |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
1224 if (i < 4) { |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
1225 int pred = ff_msmpeg4_coded_block_pred(s, i, &coded_val); |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
1226 val = val ^ pred; |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
1227 *coded_val = val; |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
1228 } |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
1229 cbp |= val << (5 - i); |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
1230 } |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
1231 } |
2967 | 1232 |
10751
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
1233 if (!s->mb_intra) { |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
1234 int mx, my; |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
1235 //printf("P at %d %d\n", s->mb_x, s->mb_y); |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
1236 if(s->per_mb_rl_table && cbp){ |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
1237 s->rl_table_index = decode012(&s->gb); |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
1238 s->rl_chroma_table_index = s->rl_table_index; |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
1239 } |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
1240 h263_pred_motion(s, 0, 0, &mx, &my); |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
1241 if (ff_msmpeg4_decode_motion(s, &mx, &my) < 0) |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
1242 return -1; |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
1243 s->mv_dir = MV_DIR_FORWARD; |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
1244 s->mv_type = MV_TYPE_16X16; |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
1245 s->mv[0][0][0] = mx; |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
1246 s->mv[0][0][1] = my; |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
1247 *mb_type_ptr = MB_TYPE_L0 | MB_TYPE_16x16; |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
1248 } else { |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
1249 //printf("I at %d %d %d %06X\n", s->mb_x, s->mb_y, ((cbp&3)? 1 : 0) +((cbp&0x3C)? 2 : 0), show_bits(&s->gb, 24)); |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
1250 s->ac_pred = get_bits1(&s->gb); |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
1251 *mb_type_ptr = MB_TYPE_INTRA; |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
1252 if(s->inter_intra_pred){ |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
1253 s->h263_aic_dir= get_vlc2(&s->gb, ff_inter_intra_vlc.table, INTER_INTRA_VLC_BITS, 1); |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
1254 // printf("%d%d %d %d/", s->ac_pred, s->h263_aic_dir, s->mb_x, s->mb_y); |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
1255 } |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
1256 if(s->per_mb_rl_table && cbp){ |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
1257 s->rl_table_index = decode012(&s->gb); |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
1258 s->rl_chroma_table_index = s->rl_table_index; |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
1259 } |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
1260 } |
307 | 1261 |
10751
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
1262 s->dsp.clear_blocks(s->block[0]); |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
1263 for (i = 0; i < 6; i++) { |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
1264 if (ff_msmpeg4_decode_block(s, block[i], i, (cbp >> (5 - i)) & 1, NULL) < 0) |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
1265 { |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
1266 av_log(s->avctx, AV_LOG_ERROR, "\nerror while decoding block: %d x %d (%d)\n", s->mb_x, s->mb_y, i); |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
1267 return -1; |
307 | 1268 } |
10751
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
1269 } |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
1270 |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
1271 return 0; |
307 | 1272 } |
0 | 1273 |
1274 /* init all vlc decoding tables */ | |
10822
9ccc13d1144d
Move AVCodecs from h263dec.c to msmpeg4.c and disentangle init decode init.
michael
parents:
10821
diff
changeset
|
1275 av_cold int ff_msmpeg4_decode_init(AVCodecContext *avctx) |
0 | 1276 { |
10822
9ccc13d1144d
Move AVCodecs from h263dec.c to msmpeg4.c and disentangle init decode init.
michael
parents:
10821
diff
changeset
|
1277 MpegEncContext *s = avctx->priv_data; |
483 | 1278 static int done = 0; |
0 | 1279 int i; |
1280 MVTable *mv; | |
1281 | |
10822
9ccc13d1144d
Move AVCodecs from h263dec.c to msmpeg4.c and disentangle init decode init.
michael
parents:
10821
diff
changeset
|
1282 ff_h263_decode_init(avctx); |
9ccc13d1144d
Move AVCodecs from h263dec.c to msmpeg4.c and disentangle init decode init.
michael
parents:
10821
diff
changeset
|
1283 |
499 | 1284 common_init(s); |
483 | 1285 |
1286 if (!done) { | |
1287 done = 1; | |
0 | 1288 |
483 | 1289 for(i=0;i<NB_RL_TABLES;i++) { |
4668 | 1290 init_rl(&rl_table[i], static_rl_table_store[i]); |
483 | 1291 } |
6940
778ecab25dd8
Change init_vlc_rl() so it does not use *alloc_static() anymore.
michael
parents:
6481
diff
changeset
|
1292 INIT_VLC_RL(rl_table[0], 642); |
778ecab25dd8
Change init_vlc_rl() so it does not use *alloc_static() anymore.
michael
parents:
6481
diff
changeset
|
1293 INIT_VLC_RL(rl_table[1], 1104); |
778ecab25dd8
Change init_vlc_rl() so it does not use *alloc_static() anymore.
michael
parents:
6481
diff
changeset
|
1294 INIT_VLC_RL(rl_table[2], 554); |
778ecab25dd8
Change init_vlc_rl() so it does not use *alloc_static() anymore.
michael
parents:
6481
diff
changeset
|
1295 INIT_VLC_RL(rl_table[3], 940); |
778ecab25dd8
Change init_vlc_rl() so it does not use *alloc_static() anymore.
michael
parents:
6481
diff
changeset
|
1296 INIT_VLC_RL(rl_table[4], 962); |
778ecab25dd8
Change init_vlc_rl() so it does not use *alloc_static() anymore.
michael
parents:
6481
diff
changeset
|
1297 INIT_VLC_RL(rl_table[5], 554); |
483 | 1298 |
9396 | 1299 mv = &mv_tables[0]; |
1300 INIT_VLC_STATIC(&mv->vlc, MV_VLC_BITS, mv->n + 1, | |
1301 mv->table_mv_bits, 1, 1, | |
1302 mv->table_mv_code, 2, 2, 3714); | |
1303 mv = &mv_tables[1]; | |
1304 INIT_VLC_STATIC(&mv->vlc, MV_VLC_BITS, mv->n + 1, | |
1305 mv->table_mv_bits, 1, 1, | |
1306 mv->table_mv_code, 2, 2, 2694); | |
1307 | |
1308 INIT_VLC_STATIC(&ff_msmp4_dc_luma_vlc[0], DC_VLC_BITS, 120, | |
2465
5565203c95ee
use dc tables from msmpeg4 instead of duplicating them patch by anonymous
michael
parents:
2464
diff
changeset
|
1309 &ff_table0_dc_lum[0][1], 8, 4, |
9396 | 1310 &ff_table0_dc_lum[0][0], 8, 4, 1158); |
1311 INIT_VLC_STATIC(&ff_msmp4_dc_chroma_vlc[0], DC_VLC_BITS, 120, | |
2465
5565203c95ee
use dc tables from msmpeg4 instead of duplicating them patch by anonymous
michael
parents:
2464
diff
changeset
|
1312 &ff_table0_dc_chroma[0][1], 8, 4, |
9396 | 1313 &ff_table0_dc_chroma[0][0], 8, 4, 1118); |
1314 INIT_VLC_STATIC(&ff_msmp4_dc_luma_vlc[1], DC_VLC_BITS, 120, | |
2465
5565203c95ee
use dc tables from msmpeg4 instead of duplicating them patch by anonymous
michael
parents:
2464
diff
changeset
|
1315 &ff_table1_dc_lum[0][1], 8, 4, |
9396 | 1316 &ff_table1_dc_lum[0][0], 8, 4, 1476); |
1317 INIT_VLC_STATIC(&ff_msmp4_dc_chroma_vlc[1], DC_VLC_BITS, 120, | |
2465
5565203c95ee
use dc tables from msmpeg4 instead of duplicating them patch by anonymous
michael
parents:
2464
diff
changeset
|
1318 &ff_table1_dc_chroma[0][1], 8, 4, |
9396 | 1319 &ff_table1_dc_chroma[0][0], 8, 4, 1216); |
2967 | 1320 |
9396 | 1321 INIT_VLC_STATIC(&v2_dc_lum_vlc, DC_VLC_BITS, 512, |
483 | 1322 &v2_dc_lum_table[0][1], 8, 4, |
9396 | 1323 &v2_dc_lum_table[0][0], 8, 4, 1472); |
1324 INIT_VLC_STATIC(&v2_dc_chroma_vlc, DC_VLC_BITS, 512, | |
483 | 1325 &v2_dc_chroma_table[0][1], 8, 4, |
9396 | 1326 &v2_dc_chroma_table[0][0], 8, 4, 1506); |
2967 | 1327 |
9396 | 1328 INIT_VLC_STATIC(&v2_intra_cbpc_vlc, V2_INTRA_CBPC_VLC_BITS, 4, |
483 | 1329 &v2_intra_cbpc[0][1], 2, 1, |
9396 | 1330 &v2_intra_cbpc[0][0], 2, 1, 8); |
1331 INIT_VLC_STATIC(&v2_mb_type_vlc, V2_MB_TYPE_VLC_BITS, 8, | |
483 | 1332 &v2_mb_type[0][1], 2, 1, |
9396 | 1333 &v2_mb_type[0][0], 2, 1, 128); |
1334 INIT_VLC_STATIC(&v2_mv_vlc, V2_MV_VLC_BITS, 33, | |
483 | 1335 &mvtab[0][1], 2, 1, |
9396 | 1336 &mvtab[0][0], 2, 1, 538); |
0 | 1337 |
9396 | 1338 INIT_VLC_STATIC(&ff_mb_non_intra_vlc[0], MB_NON_INTRA_VLC_BITS, 128, |
1339 &wmv2_inter_table[0][0][1], 8, 4, | |
1340 &wmv2_inter_table[0][0][0], 8, 4, 1636); | |
1341 INIT_VLC_STATIC(&ff_mb_non_intra_vlc[1], MB_NON_INTRA_VLC_BITS, 128, | |
1342 &wmv2_inter_table[1][0][1], 8, 4, | |
1343 &wmv2_inter_table[1][0][0], 8, 4, 2648); | |
1344 INIT_VLC_STATIC(&ff_mb_non_intra_vlc[2], MB_NON_INTRA_VLC_BITS, 128, | |
1345 &wmv2_inter_table[2][0][1], 8, 4, | |
1346 &wmv2_inter_table[2][0][0], 8, 4, 1532); | |
1347 INIT_VLC_STATIC(&ff_mb_non_intra_vlc[3], MB_NON_INTRA_VLC_BITS, 128, | |
1348 &wmv2_inter_table[3][0][1], 8, 4, | |
1349 &wmv2_inter_table[3][0][0], 8, 4, 2488); | |
2967 | 1350 |
9396 | 1351 INIT_VLC_STATIC(&ff_msmp4_mb_i_vlc, MB_INTRA_VLC_BITS, 64, |
1352 &ff_msmp4_mb_i_table[0][1], 4, 2, | |
1353 &ff_msmp4_mb_i_table[0][0], 4, 2, 536); | |
1354 | |
1355 INIT_VLC_STATIC(&ff_inter_intra_vlc, INTER_INTRA_VLC_BITS, 4, | |
519 | 1356 &table_inter_intra[0][1], 2, 1, |
9396 | 1357 &table_inter_intra[0][0], 2, 1, 8); |
483 | 1358 } |
2967 | 1359 |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
743
diff
changeset
|
1360 switch(s->msmpeg4_version){ |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
743
diff
changeset
|
1361 case 1: |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
743
diff
changeset
|
1362 case 2: |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
743
diff
changeset
|
1363 s->decode_mb= msmpeg4v12_decode_mb; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
743
diff
changeset
|
1364 break; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
743
diff
changeset
|
1365 case 3: |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
743
diff
changeset
|
1366 case 4: |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
743
diff
changeset
|
1367 s->decode_mb= msmpeg4v34_decode_mb; |
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
743
diff
changeset
|
1368 break; |
936 | 1369 case 5: |
8596
68e959302527
replace all occurrence of ENABLE_ by the corresponding CONFIG_, HAVE_ or ARCH_
aurel
parents:
8590
diff
changeset
|
1370 if (CONFIG_WMV2_DECODER) |
5885 | 1371 s->decode_mb= ff_wmv2_decode_mb; |
2474 | 1372 case 6: |
3359 | 1373 //FIXME + TODO VC1 decode mb |
936 | 1374 break; |
745
25d7fb7c89be
better/cleaner error resilience (done in a 2nd pass after decoding)
michaelni
parents:
743
diff
changeset
|
1375 } |
2967 | 1376 |
5127 | 1377 s->slice_height= s->mb_height; //to avoid 1/0 if the first frame is not a keyframe |
2967 | 1378 |
0 | 1379 return 0; |
1380 } | |
1381 | |
307 | 1382 int msmpeg4_decode_picture_header(MpegEncContext * s) |
300
d874359e58f1
msmpeg4v2 header parser & some dump bits code behind #if 0
michaelni
parents:
299
diff
changeset
|
1383 { |
499 | 1384 int code; |
300
d874359e58f1
msmpeg4v2 header parser & some dump bits code behind #if 0
michaelni
parents:
299
diff
changeset
|
1385 |
311 | 1386 #if 0 |
1387 { | |
1388 int i; | |
1025
1f9afd8b9131
GetBitContext.size is allways multiplied by 8 -> use size_in_bits to avoid useless *8 in a few inner loops
michaelni
parents:
983
diff
changeset
|
1389 for(i=0; i<s->gb.size_in_bits; i++) |
3177 | 1390 av_log(s->avctx, AV_LOG_DEBUG, "%d", get_bits1(&s->gb)); |
311 | 1391 // get_bits1(&s->gb); |
3177 | 1392 av_log(s->avctx, AV_LOG_DEBUG, "END\n"); |
311 | 1393 return -1; |
1394 } | |
1395 #endif | |
457 | 1396 |
1397 if(s->msmpeg4_version==1){ | |
9455
6cb61c6220c3
Get rid of an unused variable, found by the clang static analyzer.
michael
parents:
9396
diff
changeset
|
1398 int start_code; |
457 | 1399 start_code = (get_bits(&s->gb, 16)<<16) | get_bits(&s->gb, 16); |
1400 if(start_code!=0x00000100){ | |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1399
diff
changeset
|
1401 av_log(s->avctx, AV_LOG_ERROR, "invalid startcode\n"); |
457 | 1402 return -1; |
1403 } | |
1404 | |
9455
6cb61c6220c3
Get rid of an unused variable, found by the clang static analyzer.
michael
parents:
9396
diff
changeset
|
1405 skip_bits(&s->gb, 5); // frame number */ |
457 | 1406 } |
1407 | |
300
d874359e58f1
msmpeg4v2 header parser & some dump bits code behind #if 0
michaelni
parents:
299
diff
changeset
|
1408 s->pict_type = get_bits(&s->gb, 2) + 1; |
6481 | 1409 if (s->pict_type != FF_I_TYPE && |
1410 s->pict_type != FF_P_TYPE){ | |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1399
diff
changeset
|
1411 av_log(s->avctx, AV_LOG_ERROR, "invalid picture type\n"); |
300
d874359e58f1
msmpeg4v2 header parser & some dump bits code behind #if 0
michaelni
parents:
299
diff
changeset
|
1412 return -1; |
457 | 1413 } |
519 | 1414 #if 0 |
1415 { | |
1416 static int had_i=0; | |
6481 | 1417 if(s->pict_type == FF_I_TYPE) had_i=1; |
519 | 1418 if(!had_i) return -1; |
1419 } | |
1420 #endif | |
1651 | 1421 s->chroma_qscale= s->qscale = get_bits(&s->gb, 5); |
1063
fdeac9642346
check for qscale==0 (fixes 1/0 on one corrupted stream)
michaelni
parents:
1057
diff
changeset
|
1422 if(s->qscale==0){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1399
diff
changeset
|
1423 av_log(s->avctx, AV_LOG_ERROR, "invalid qscale\n"); |
1063
fdeac9642346
check for qscale==0 (fixes 1/0 on one corrupted stream)
michaelni
parents:
1057
diff
changeset
|
1424 return -1; |
fdeac9642346
check for qscale==0 (fixes 1/0 on one corrupted stream)
michaelni
parents:
1057
diff
changeset
|
1425 } |
300
d874359e58f1
msmpeg4v2 header parser & some dump bits code behind #if 0
michaelni
parents:
299
diff
changeset
|
1426 |
6481 | 1427 if (s->pict_type == FF_I_TYPE) { |
2967 | 1428 code = get_bits(&s->gb, 5); |
457 | 1429 if(s->msmpeg4_version==1){ |
1430 if(code==0 || code>s->mb_height){ | |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1399
diff
changeset
|
1431 av_log(s->avctx, AV_LOG_ERROR, "invalid slice height %d\n", code); |
457 | 1432 return -1; |
1433 } | |
1434 | |
1435 s->slice_height = code; | |
1436 }else{ | |
1437 /* 0x17: one slice, 0x18: two slices, ... */ | |
519 | 1438 if (code < 0x17){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1399
diff
changeset
|
1439 av_log(s->avctx, AV_LOG_ERROR, "error, slice code was %X\n", code); |
457 | 1440 return -1; |
519 | 1441 } |
457 | 1442 |
1443 s->slice_height = s->mb_height / (code - 0x16); | |
1444 } | |
311 | 1445 |
1446 switch(s->msmpeg4_version){ | |
457 | 1447 case 1: |
311 | 1448 case 2: |
307 | 1449 s->rl_chroma_table_index = 2; |
1450 s->rl_table_index = 2; | |
300
d874359e58f1
msmpeg4v2 header parser & some dump bits code behind #if 0
michaelni
parents:
299
diff
changeset
|
1451 |
307 | 1452 s->dc_table_index = 0; //not used |
311 | 1453 break; |
1454 case 3: | |
307 | 1455 s->rl_chroma_table_index = decode012(&s->gb); |
1456 s->rl_table_index = decode012(&s->gb); | |
0 | 1457 |
307 | 1458 s->dc_table_index = get_bits1(&s->gb); |
311 | 1459 break; |
1460 case 4: | |
499 | 1461 msmpeg4_decode_ext_header(s, (2+5+5+17+7)/8); |
1462 | |
578 | 1463 if(s->bit_rate > MBAC_BITRATE) s->per_mb_rl_table= get_bits1(&s->gb); |
1464 else s->per_mb_rl_table= 0; | |
2967 | 1465 |
499 | 1466 if(!s->per_mb_rl_table){ |
1467 s->rl_chroma_table_index = decode012(&s->gb); | |
1468 s->rl_table_index = decode012(&s->gb); | |
311 | 1469 } |
1470 | |
499 | 1471 s->dc_table_index = get_bits1(&s->gb); |
519 | 1472 s->inter_intra_pred= 0; |
311 | 1473 break; |
307 | 1474 } |
0 | 1475 s->no_rounding = 1; |
1388 | 1476 if(s->avctx->debug&FF_DEBUG_PICT_INFO) |
2979 | 1477 av_log(s->avctx, AV_LOG_DEBUG, "qscale:%d rlc:%d rl:%d dc:%d mbrl:%d slice:%d \n", |
1478 s->qscale, | |
1479 s->rl_chroma_table_index, | |
1480 s->rl_table_index, | |
1481 s->dc_table_index, | |
519 | 1482 s->per_mb_rl_table, |
1388 | 1483 s->slice_height); |
0 | 1484 } else { |
457 | 1485 switch(s->msmpeg4_version){ |
1486 case 1: | |
1487 case 2: | |
1488 if(s->msmpeg4_version==1) | |
1489 s->use_skip_mb_code = 1; | |
1490 else | |
1491 s->use_skip_mb_code = get_bits1(&s->gb); | |
307 | 1492 s->rl_table_index = 2; |
1493 s->rl_chroma_table_index = s->rl_table_index; | |
1494 s->dc_table_index = 0; //not used | |
1495 s->mv_table_index = 0; | |
457 | 1496 break; |
1497 case 3: | |
1498 s->use_skip_mb_code = get_bits1(&s->gb); | |
307 | 1499 s->rl_table_index = decode012(&s->gb); |
1500 s->rl_chroma_table_index = s->rl_table_index; | |
0 | 1501 |
307 | 1502 s->dc_table_index = get_bits1(&s->gb); |
1503 | |
1504 s->mv_table_index = get_bits1(&s->gb); | |
457 | 1505 break; |
499 | 1506 case 4: |
1507 s->use_skip_mb_code = get_bits1(&s->gb); | |
519 | 1508 |
578 | 1509 if(s->bit_rate > MBAC_BITRATE) s->per_mb_rl_table= get_bits1(&s->gb); |
1510 else s->per_mb_rl_table= 0; | |
519 | 1511 |
499 | 1512 if(!s->per_mb_rl_table){ |
1513 s->rl_table_index = decode012(&s->gb); | |
1514 s->rl_chroma_table_index = s->rl_table_index; | |
1515 } | |
1516 | |
1517 s->dc_table_index = get_bits1(&s->gb); | |
1518 | |
1519 s->mv_table_index = get_bits1(&s->gb); | |
578 | 1520 s->inter_intra_pred= (s->width*s->height < 320*240 && s->bit_rate<=II_BITRATE); |
499 | 1521 break; |
307 | 1522 } |
2967 | 1523 |
1388 | 1524 if(s->avctx->debug&FF_DEBUG_PICT_INFO) |
2979 | 1525 av_log(s->avctx, AV_LOG_DEBUG, "skip:%d rl:%d rlc:%d dc:%d mv:%d mbrl:%d qp:%d \n", |
1526 s->use_skip_mb_code, | |
1527 s->rl_table_index, | |
1528 s->rl_chroma_table_index, | |
1529 s->dc_table_index, | |
1530 s->mv_table_index, | |
519 | 1531 s->per_mb_rl_table, |
1388 | 1532 s->qscale); |
1533 | |
2979 | 1534 if(s->flipflop_rounding){ |
1535 s->no_rounding ^= 1; | |
1536 }else{ | |
1537 s->no_rounding = 0; | |
1538 } | |
0 | 1539 } |
936 | 1540 //printf("%d %d %d %d %d\n", s->pict_type, s->bit_rate, s->inter_intra_pred, s->width, s->height); |
499 | 1541 |
1542 s->esc3_level_length= 0; | |
1543 s->esc3_run_length= 0; | |
307 | 1544 |
0 | 1545 return 0; |
1546 } | |
1547 | |
208 | 1548 int msmpeg4_decode_ext_header(MpegEncContext * s, int buf_size) |
1549 { | |
457 | 1550 int left= buf_size*8 - get_bits_count(&s->gb); |
1551 int length= s->msmpeg4_version>=3 ? 17 : 16; | |
208 | 1552 /* the alt_bitstream reader could read over the end so we need to check it */ |
457 | 1553 if(left>=length && left<length+8) |
208 | 1554 { |
251
75091bfc577b
fixing msmpeg4 decoding if fps < 16 (i thought it was a indicator for the ext header, its the fps indeed)
michaelni
parents:
246
diff
changeset
|
1555 int fps; |
75091bfc577b
fixing msmpeg4 decoding if fps < 16 (i thought it was a indicator for the ext header, its the fps indeed)
michaelni
parents:
246
diff
changeset
|
1556 |
75091bfc577b
fixing msmpeg4 decoding if fps < 16 (i thought it was a indicator for the ext header, its the fps indeed)
michaelni
parents:
246
diff
changeset
|
1557 fps= get_bits(&s->gb, 5); |
578 | 1558 s->bit_rate= get_bits(&s->gb, 11)*1024; |
457 | 1559 if(s->msmpeg4_version>=3) |
1560 s->flipflop_rounding= get_bits1(&s->gb); | |
1561 else | |
1562 s->flipflop_rounding= 0; | |
251
75091bfc577b
fixing msmpeg4 decoding if fps < 16 (i thought it was a indicator for the ext header, its the fps indeed)
michaelni
parents:
246
diff
changeset
|
1563 |
578 | 1564 // printf("fps:%2d bps:%2d roundingType:%1d\n", fps, s->bit_rate/1024, s->flipflop_rounding); |
457 | 1565 } |
1566 else if(left<length+8) | |
1567 { | |
1568 s->flipflop_rounding= 0; | |
1399 | 1569 if(s->msmpeg4_version != 2) |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1399
diff
changeset
|
1570 av_log(s->avctx, AV_LOG_ERROR, "ext header missing, %d left\n", left); |
208 | 1571 } |
1572 else | |
1573 { | |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1399
diff
changeset
|
1574 av_log(s->avctx, AV_LOG_ERROR, "I frame too long, ignoring ext header\n"); |
208 | 1575 } |
251
75091bfc577b
fixing msmpeg4 decoding if fps < 16 (i thought it was a indicator for the ext header, its the fps indeed)
michaelni
parents:
246
diff
changeset
|
1576 |
208 | 1577 return 0; |
1578 } | |
1579 | |
10751
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
1580 static int msmpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr) |
310 | 1581 { |
10751
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
1582 int level, pred; |
457 | 1583 |
10751
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
1584 if(s->msmpeg4_version<=2){ |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
1585 if (n < 4) { |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
1586 level = get_vlc2(&s->gb, v2_dc_lum_vlc.table, DC_VLC_BITS, 3); |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
1587 } else { |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
1588 level = get_vlc2(&s->gb, v2_dc_chroma_vlc.table, DC_VLC_BITS, 3); |
307 | 1589 } |
10751
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
1590 if (level < 0) |
457 | 1591 return -1; |
10751
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
1592 level-=256; |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
1593 }else{ //FIXME optimize use unified tables & index |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
1594 if (n < 4) { |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
1595 level = get_vlc2(&s->gb, ff_msmp4_dc_luma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3); |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
1596 } else { |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
1597 level = get_vlc2(&s->gb, ff_msmp4_dc_chroma_vlc[s->dc_table_index].table, DC_VLC_BITS, 3); |
457 | 1598 } |
10751
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
1599 if (level < 0){ |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
1600 av_log(s->avctx, AV_LOG_ERROR, "illegal dc vlc\n"); |
457 | 1601 return -1; |
1602 } | |
307 | 1603 |
10751
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
1604 if (level == DC_MAX) { |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
1605 level = get_bits(&s->gb, 8); |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
1606 if (get_bits1(&s->gb)) |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
1607 level = -level; |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
1608 } else if (level != 0) { |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
1609 if (get_bits1(&s->gb)) |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
1610 level = -level; |
457 | 1611 } |
307 | 1612 } |
1613 | |
10751
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
1614 if(s->msmpeg4_version==1){ |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
1615 int32_t *dc_val; |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
1616 pred = msmpeg4v1_pred_dc(s, n, &dc_val); |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
1617 level += pred; |
0 | 1618 |
10751
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
1619 /* update predictor */ |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
1620 *dc_val= level; |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
1621 }else{ |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
1622 int16_t *dc_val; |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
1623 pred = msmpeg4_pred_dc(s, n, &dc_val, dir_ptr); |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
1624 level += pred; |
2967 | 1625 |
10751
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
1626 /* update predictor */ |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
1627 if (n < 4) { |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
1628 *dc_val = level * s->y_dc_scale; |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
1629 } else { |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
1630 *dc_val = level * s->c_dc_scale; |
0 | 1631 } |
1632 } | |
1633 | |
10751
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
1634 return level; |
74e8feb81c6d
cosmetics: Reorder functions to avoid forward declarations.
diego
parents:
10750
diff
changeset
|
1635 } |
0 | 1636 |
563 | 1637 //#define ERROR_DETAILS |
5882
51fc10d9fdff
rename some msmpeg4 symbols and make them non-static
aurel
parents:
5543
diff
changeset
|
1638 int ff_msmpeg4_decode_block(MpegEncContext * s, DCTELEM * block, |
936 | 1639 int n, int coded, const uint8_t *scan_table) |
0 | 1640 { |
542 | 1641 int level, i, last, run, run_diff; |
8780
56c41adae7d8
Fix: libavcodec/msmpeg4.c:1612: warning: ¡Ædc_pred_dir¡Ç may be used uninitialized in this function
michael
parents:
8718
diff
changeset
|
1642 int av_uninit(dc_pred_dir); |
0 | 1643 RLTable *rl; |
542 | 1644 RL_VLC_ELEM *rl_vlc; |
200 | 1645 int qmul, qadd; |
0 | 1646 |
1647 if (s->mb_intra) { | |
200 | 1648 qmul=1; |
1649 qadd=0; | |
1650 | |
2979 | 1651 /* DC coef */ |
0 | 1652 level = msmpeg4_decode_dc(s, n, &dc_pred_dir); |
2967 | 1653 |
457 | 1654 if (level < 0){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1399
diff
changeset
|
1655 av_log(s->avctx, AV_LOG_ERROR, "dc overflow- block: %d qscale: %d//\n", n, s->qscale); |
519 | 1656 if(s->inter_intra_pred) level=0; |
1657 else return -1; | |
457 | 1658 } |
0 | 1659 if (n < 4) { |
1660 rl = &rl_table[s->rl_table_index]; | |
457 | 1661 if(level > 256*s->y_dc_scale){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1399
diff
changeset
|
1662 av_log(s->avctx, AV_LOG_ERROR, "dc overflow+ L qscale: %d//\n", s->qscale); |
519 | 1663 if(!s->inter_intra_pred) return -1; |
457 | 1664 } |
0 | 1665 } else { |
1666 rl = &rl_table[3 + s->rl_chroma_table_index]; | |
457 | 1667 if(level > 256*s->c_dc_scale){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1399
diff
changeset
|
1668 av_log(s->avctx, AV_LOG_ERROR, "dc overflow+ C qscale: %d//\n", s->qscale); |
519 | 1669 if(!s->inter_intra_pred) return -1; |
457 | 1670 } |
0 | 1671 } |
457 | 1672 block[0] = level; |
200 | 1673 |
5496 | 1674 run_diff = s->msmpeg4_version >= 4; |
542 | 1675 i = 0; |
0 | 1676 if (!coded) { |
1677 goto not_coded; | |
1678 } | |
1679 if (s->ac_pred) { | |
2967 | 1680 if (dc_pred_dir == 0) |
706
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
601
diff
changeset
|
1681 scan_table = s->intra_v_scantable.permutated; /* left */ |
0 | 1682 else |
706
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
601
diff
changeset
|
1683 scan_table = s->intra_h_scantable.permutated; /* top */ |
0 | 1684 } else { |
706
e65798d228ea
idct permutation cleanup, idct can be selected per context now
michaelni
parents:
601
diff
changeset
|
1685 scan_table = s->intra_scantable.permutated; |
0 | 1686 } |
542 | 1687 rl_vlc= rl->rl_vlc[0]; |
0 | 1688 } else { |
200 | 1689 qmul = s->qscale << 1; |
1690 qadd = (s->qscale - 1) | 1; | |
542 | 1691 i = -1; |
0 | 1692 rl = &rl_table[3 + s->rl_table_index]; |
307 | 1693 |
1694 if(s->msmpeg4_version==2) | |
1695 run_diff = 0; | |
1696 else | |
1697 run_diff = 1; | |
1698 | |
0 | 1699 if (!coded) { |
542 | 1700 s->block_last_index[n] = i; |
0 | 1701 return 0; |
1702 } | |
936 | 1703 if(!scan_table) |
1704 scan_table = s->inter_scantable.permutated; | |
542 | 1705 rl_vlc= rl->rl_vlc[s->qscale]; |
0 | 1706 } |
542 | 1707 { |
1708 OPEN_READER(re, &s->gb); | |
0 | 1709 for(;;) { |
542 | 1710 UPDATE_CACHE(re, &s->gb); |
2615
0d88e3f89379
avoid UPDATE_CACHE() in GET_RL_VLC() if not needed
michael
parents:
2474
diff
changeset
|
1711 GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2, 0); |
542 | 1712 if (level==0) { |
1713 int cache; | |
1714 cache= GET_CACHE(re, &s->gb); | |
0 | 1715 /* escape */ |
542 | 1716 if (s->msmpeg4_version==1 || (cache&0x80000000)==0) { |
1717 if (s->msmpeg4_version==1 || (cache&0x40000000)==0) { | |
0 | 1718 /* third escape */ |
542 | 1719 if(s->msmpeg4_version!=1) LAST_SKIP_BITS(re, &s->gb, 2); |
1720 UPDATE_CACHE(re, &s->gb); | |
499 | 1721 if(s->msmpeg4_version<=3){ |
542 | 1722 last= SHOW_UBITS(re, &s->gb, 1); SKIP_CACHE(re, &s->gb, 1); |
1723 run= SHOW_UBITS(re, &s->gb, 6); SKIP_CACHE(re, &s->gb, 6); | |
1724 level= SHOW_SBITS(re, &s->gb, 8); LAST_SKIP_CACHE(re, &s->gb, 8); | |
1725 SKIP_COUNTER(re, &s->gb, 1+6+8); | |
2967 | 1726 }else{ |
499 | 1727 int sign; |
542 | 1728 last= SHOW_UBITS(re, &s->gb, 1); SKIP_BITS(re, &s->gb, 1); |
499 | 1729 if(!s->esc3_level_length){ |
1730 int ll; | |
1731 //printf("ESC-3 %X at %d %d\n", show_bits(&s->gb, 24), s->mb_x, s->mb_y); | |
1732 if(s->qscale<8){ | |
542 | 1733 ll= SHOW_UBITS(re, &s->gb, 3); SKIP_BITS(re, &s->gb, 3); |
499 | 1734 if(ll==0){ |
11075 | 1735 ll= 8+SHOW_UBITS(re, &s->gb, 1); SKIP_BITS(re, &s->gb, 1); |
499 | 1736 } |
1737 }else{ | |
1738 ll=2; | |
542 | 1739 while(ll<8 && SHOW_UBITS(re, &s->gb, 1)==0){ |
1740 ll++; | |
1741 SKIP_BITS(re, &s->gb, 1); | |
1742 } | |
578 | 1743 if(ll<8) SKIP_BITS(re, &s->gb, 1); |
499 | 1744 } |
1745 | |
1746 s->esc3_level_length= ll; | |
542 | 1747 s->esc3_run_length= SHOW_UBITS(re, &s->gb, 2) + 3; SKIP_BITS(re, &s->gb, 2); |
499 | 1748 //printf("level length:%d, run length: %d\n", ll, s->esc3_run_length); |
578 | 1749 UPDATE_CACHE(re, &s->gb); |
499 | 1750 } |
2967 | 1751 run= SHOW_UBITS(re, &s->gb, s->esc3_run_length); |
542 | 1752 SKIP_BITS(re, &s->gb, s->esc3_run_length); |
2967 | 1753 |
1754 sign= SHOW_UBITS(re, &s->gb, 1); | |
542 | 1755 SKIP_BITS(re, &s->gb, 1); |
2967 | 1756 |
1757 level= SHOW_UBITS(re, &s->gb, s->esc3_level_length); | |
542 | 1758 SKIP_BITS(re, &s->gb, s->esc3_level_length); |
499 | 1759 if(sign) level= -level; |
1760 } | |
1761 //printf("level: %d, run: %d at %d %d\n", level, run, s->mb_x, s->mb_y); | |
457 | 1762 #if 0 // waste of time / this will detect very few errors |
1763 { | |
4001 | 1764 const int abs_level= FFABS(level); |
457 | 1765 const int run1= run - rl->max_run[last][abs_level] - run_diff; |
1766 if(abs_level<=MAX_LEVEL && run<=MAX_RUN){ | |
1767 if(abs_level <= rl->max_level[last][run]){ | |
3177 | 1768 av_log(s->avctx, AV_LOG_ERROR, "illegal 3. esc, vlc encoding possible\n"); |
457 | 1769 return DECODING_AC_LOST; |
1770 } | |
1771 if(abs_level <= rl->max_level[last][run]*2){ | |
3177 | 1772 av_log(s->avctx, AV_LOG_ERROR, "illegal 3. esc, esc 1 encoding possible\n"); |
457 | 1773 return DECODING_AC_LOST; |
1774 } | |
499 | 1775 if(run1>=0 && abs_level <= rl->max_level[last][run1]){ |
3177 | 1776 av_log(s->avctx, AV_LOG_ERROR, "illegal 3. esc, esc 2 encoding possible\n"); |
457 | 1777 return DECODING_AC_LOST; |
1778 } | |
1779 } | |
1780 } | |
1781 #endif | |
2979 | 1782 //level = level * qmul + (level>0) * qadd - (level<=0) * qadd ; |
1783 if (level>0) level= level * qmul + qadd; | |
457 | 1784 else level= level * qmul - qadd; |
1785 #if 0 // waste of time too :( | |
1786 if(level>2048 || level<-2048){ | |
3177 | 1787 av_log(s->avctx, AV_LOG_ERROR, "|level| overflow in 3. esc\n"); |
457 | 1788 return DECODING_AC_LOST; |
1789 } | |
1790 #endif | |
542 | 1791 i+= run + 1; |
1792 if(last) i+=192; | |
563 | 1793 #ifdef ERROR_DETAILS |
1794 if(run==66) | |
2846
40765c51a7a9
Compilation fixes part 1 patch by (Arvind R. and Burkhard Plaum, plaum, ipf uni-stuttgart de)
michael
parents:
2639
diff
changeset
|
1795 av_log(s->avctx, AV_LOG_ERROR, "illegal vlc code in ESC3 level=%d\n", level); |
563 | 1796 else if((i>62 && i<192) || i>192+63) |
2846
40765c51a7a9
Compilation fixes part 1 patch by (Arvind R. and Burkhard Plaum, plaum, ipf uni-stuttgart de)
michael
parents:
2639
diff
changeset
|
1797 av_log(s->avctx, AV_LOG_ERROR, "run overflow in ESC3 i=%d run=%d level=%d\n", i, run, level); |
563 | 1798 #endif |
0 | 1799 } else { |
1800 /* second escape */ | |
542 | 1801 #if MIN_CACHE_BITS < 23 |
1802 LAST_SKIP_BITS(re, &s->gb, 2); | |
1803 UPDATE_CACHE(re, &s->gb); | |
1804 #else | |
1805 SKIP_BITS(re, &s->gb, 2); | |
1806 #endif | |
2615
0d88e3f89379
avoid UPDATE_CACHE() in GET_RL_VLC() if not needed
michael
parents:
2474
diff
changeset
|
1807 GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2, 1); |
542 | 1808 i+= run + rl->max_run[run>>7][level/qmul] + run_diff; //FIXME opt indexing |
1809 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1); | |
1810 LAST_SKIP_BITS(re, &s->gb, 1); | |
563 | 1811 #ifdef ERROR_DETAILS |
1812 if(run==66) | |
2846
40765c51a7a9
Compilation fixes part 1 patch by (Arvind R. and Burkhard Plaum, plaum, ipf uni-stuttgart de)
michael
parents:
2639
diff
changeset
|
1813 av_log(s->avctx, AV_LOG_ERROR, "illegal vlc code in ESC2 level=%d\n", level); |
563 | 1814 else if((i>62 && i<192) || i>192+63) |
2846
40765c51a7a9
Compilation fixes part 1 patch by (Arvind R. and Burkhard Plaum, plaum, ipf uni-stuttgart de)
michael
parents:
2639
diff
changeset
|
1815 av_log(s->avctx, AV_LOG_ERROR, "run overflow in ESC2 i=%d run=%d level=%d\n", i, run, level); |
563 | 1816 #endif |
0 | 1817 } |
1818 } else { | |
1819 /* first escape */ | |
542 | 1820 #if MIN_CACHE_BITS < 22 |
1821 LAST_SKIP_BITS(re, &s->gb, 1); | |
1822 UPDATE_CACHE(re, &s->gb); | |
1823 #else | |
1824 SKIP_BITS(re, &s->gb, 1); | |
1825 #endif | |
2615
0d88e3f89379
avoid UPDATE_CACHE() in GET_RL_VLC() if not needed
michael
parents:
2474
diff
changeset
|
1826 GET_RL_VLC(level, run, re, &s->gb, rl_vlc, TEX_VLC_BITS, 2, 1); |
542 | 1827 i+= run; |
1828 level = level + rl->max_level[run>>7][(run-1)&63] * qmul;//FIXME opt indexing | |
1829 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1); | |
1830 LAST_SKIP_BITS(re, &s->gb, 1); | |
563 | 1831 #ifdef ERROR_DETAILS |
1832 if(run==66) | |
2846
40765c51a7a9
Compilation fixes part 1 patch by (Arvind R. and Burkhard Plaum, plaum, ipf uni-stuttgart de)
michael
parents:
2639
diff
changeset
|
1833 av_log(s->avctx, AV_LOG_ERROR, "illegal vlc code in ESC1 level=%d\n", level); |
563 | 1834 else if((i>62 && i<192) || i>192+63) |
2846
40765c51a7a9
Compilation fixes part 1 patch by (Arvind R. and Burkhard Plaum, plaum, ipf uni-stuttgart de)
michael
parents:
2639
diff
changeset
|
1835 av_log(s->avctx, AV_LOG_ERROR, "run overflow in ESC1 i=%d run=%d level=%d\n", i, run, level); |
563 | 1836 #endif |
0 | 1837 } |
1838 } else { | |
542 | 1839 i+= run; |
1840 level = (level ^ SHOW_SBITS(re, &s->gb, 1)) - SHOW_SBITS(re, &s->gb, 1); | |
1841 LAST_SKIP_BITS(re, &s->gb, 1); | |
563 | 1842 #ifdef ERROR_DETAILS |
1843 if(run==66) | |
2846
40765c51a7a9
Compilation fixes part 1 patch by (Arvind R. and Burkhard Plaum, plaum, ipf uni-stuttgart de)
michael
parents:
2639
diff
changeset
|
1844 av_log(s->avctx, AV_LOG_ERROR, "illegal vlc code level=%d\n", level); |
563 | 1845 else if((i>62 && i<192) || i>192+63) |
2846
40765c51a7a9
Compilation fixes part 1 patch by (Arvind R. and Burkhard Plaum, plaum, ipf uni-stuttgart de)
michael
parents:
2639
diff
changeset
|
1846 av_log(s->avctx, AV_LOG_ERROR, "run overflow i=%d run=%d level=%d\n", i, run, level); |
563 | 1847 #endif |
0 | 1848 } |
542 | 1849 if (i > 62){ |
1850 i-= 192; | |
1851 if(i&(~63)){ | |
10535
95f3daa991a2
Use get_bits_left() instead of size_in_bits - get_bits_count().
rbultje
parents:
10071
diff
changeset
|
1852 const int left= get_bits_left(&s->gb); |
7831 | 1853 if(((i+192 == 64 && level/qmul==-1) || s->error_recognition<=1) && left>=0){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1399
diff
changeset
|
1854 av_log(s->avctx, AV_LOG_ERROR, "ignoring overflow at %d %d\n", s->mb_x, s->mb_y); |
563 | 1855 break; |
1856 }else{ | |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1399
diff
changeset
|
1857 av_log(s->avctx, AV_LOG_ERROR, "ac-tex damaged at %d %d\n", s->mb_x, s->mb_y); |
563 | 1858 return -1; |
1859 } | |
542 | 1860 } |
1861 | |
1862 block[scan_table[i]] = level; | |
1863 break; | |
499 | 1864 } |
457 | 1865 |
542 | 1866 block[scan_table[i]] = level; |
0 | 1867 } |
542 | 1868 CLOSE_READER(re, &s->gb); |
1869 } | |
0 | 1870 not_coded: |
1871 if (s->mb_intra) { | |
1872 mpeg4_pred_ac(s, block, n, dc_pred_dir); | |
1873 if (s->ac_pred) { | |
542 | 1874 i = 63; /* XXX: not optimal */ |
0 | 1875 } |
1876 } | |
936 | 1877 if(s->msmpeg4_version>=4 && i>0) i=63; //FIXME/XXX optimize |
542 | 1878 s->block_last_index[n] = i; |
2967 | 1879 |
0 | 1880 return 0; |
1881 } | |
1882 | |
5882
51fc10d9fdff
rename some msmpeg4 symbols and make them non-static
aurel
parents:
5543
diff
changeset
|
1883 int ff_msmpeg4_decode_motion(MpegEncContext * s, |
0 | 1884 int *mx_ptr, int *my_ptr) |
1885 { | |
1886 MVTable *mv; | |
1887 int code, mx, my; | |
1888 | |
1889 mv = &mv_tables[s->mv_table_index]; | |
1890 | |
531 | 1891 code = get_vlc2(&s->gb, mv->vlc.table, MV_VLC_BITS, 2); |
499 | 1892 if (code < 0){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1399
diff
changeset
|
1893 av_log(s->avctx, AV_LOG_ERROR, "illegal MV code at %d %d\n", s->mb_x, s->mb_y); |
0 | 1894 return -1; |
499 | 1895 } |
0 | 1896 if (code == mv->n) { |
499 | 1897 //printf("MV ESC %X at %d %d\n", show_bits(&s->gb, 24), s->mb_x, s->mb_y); |
0 | 1898 mx = get_bits(&s->gb, 6); |
1899 my = get_bits(&s->gb, 6); | |
1900 } else { | |
1901 mx = mv->table_mvx[code]; | |
1902 my = mv->table_mvy[code]; | |
1903 } | |
1904 | |
1905 mx += *mx_ptr - 32; | |
1906 my += *my_ptr - 32; | |
1907 /* WARNING : they do not do exactly modulo encoding */ | |
1908 if (mx <= -64) | |
1909 mx += 64; | |
1910 else if (mx >= 64) | |
1911 mx -= 64; | |
1912 | |
1913 if (my <= -64) | |
1914 my += 64; | |
1915 else if (my >= 64) | |
1916 my -= 64; | |
1917 *mx_ptr = mx; | |
1918 *my_ptr = my; | |
1919 return 0; | |
1920 } | |
10822
9ccc13d1144d
Move AVCodecs from h263dec.c to msmpeg4.c and disentangle init decode init.
michael
parents:
10821
diff
changeset
|
1921 |
9ccc13d1144d
Move AVCodecs from h263dec.c to msmpeg4.c and disentangle init decode init.
michael
parents:
10821
diff
changeset
|
1922 AVCodec msmpeg4v1_decoder = { |
9ccc13d1144d
Move AVCodecs from h263dec.c to msmpeg4.c and disentangle init decode init.
michael
parents:
10821
diff
changeset
|
1923 "msmpeg4v1", |
11560
8a4984c5cacc
Define AVMediaType enum, and use it instead of enum CodecType, which
stefano
parents:
11075
diff
changeset
|
1924 AVMEDIA_TYPE_VIDEO, |
10822
9ccc13d1144d
Move AVCodecs from h263dec.c to msmpeg4.c and disentangle init decode init.
michael
parents:
10821
diff
changeset
|
1925 CODEC_ID_MSMPEG4V1, |
9ccc13d1144d
Move AVCodecs from h263dec.c to msmpeg4.c and disentangle init decode init.
michael
parents:
10821
diff
changeset
|
1926 sizeof(MpegEncContext), |
9ccc13d1144d
Move AVCodecs from h263dec.c to msmpeg4.c and disentangle init decode init.
michael
parents:
10821
diff
changeset
|
1927 ff_msmpeg4_decode_init, |
9ccc13d1144d
Move AVCodecs from h263dec.c to msmpeg4.c and disentangle init decode init.
michael
parents:
10821
diff
changeset
|
1928 NULL, |
9ccc13d1144d
Move AVCodecs from h263dec.c to msmpeg4.c and disentangle init decode init.
michael
parents:
10821
diff
changeset
|
1929 ff_h263_decode_end, |
9ccc13d1144d
Move AVCodecs from h263dec.c to msmpeg4.c and disentangle init decode init.
michael
parents:
10821
diff
changeset
|
1930 ff_h263_decode_frame, |
9ccc13d1144d
Move AVCodecs from h263dec.c to msmpeg4.c and disentangle init decode init.
michael
parents:
10821
diff
changeset
|
1931 CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1, |
9ccc13d1144d
Move AVCodecs from h263dec.c to msmpeg4.c and disentangle init decode init.
michael
parents:
10821
diff
changeset
|
1932 .long_name= NULL_IF_CONFIG_SMALL("MPEG-4 part 2 Microsoft variant version 1"), |
9ccc13d1144d
Move AVCodecs from h263dec.c to msmpeg4.c and disentangle init decode init.
michael
parents:
10821
diff
changeset
|
1933 .pix_fmts= ff_pixfmt_list_420, |
9ccc13d1144d
Move AVCodecs from h263dec.c to msmpeg4.c and disentangle init decode init.
michael
parents:
10821
diff
changeset
|
1934 }; |
9ccc13d1144d
Move AVCodecs from h263dec.c to msmpeg4.c and disentangle init decode init.
michael
parents:
10821
diff
changeset
|
1935 |
9ccc13d1144d
Move AVCodecs from h263dec.c to msmpeg4.c and disentangle init decode init.
michael
parents:
10821
diff
changeset
|
1936 AVCodec msmpeg4v2_decoder = { |
9ccc13d1144d
Move AVCodecs from h263dec.c to msmpeg4.c and disentangle init decode init.
michael
parents:
10821
diff
changeset
|
1937 "msmpeg4v2", |
11560
8a4984c5cacc
Define AVMediaType enum, and use it instead of enum CodecType, which
stefano
parents:
11075
diff
changeset
|
1938 AVMEDIA_TYPE_VIDEO, |
10822
9ccc13d1144d
Move AVCodecs from h263dec.c to msmpeg4.c and disentangle init decode init.
michael
parents:
10821
diff
changeset
|
1939 CODEC_ID_MSMPEG4V2, |
9ccc13d1144d
Move AVCodecs from h263dec.c to msmpeg4.c and disentangle init decode init.
michael
parents:
10821
diff
changeset
|
1940 sizeof(MpegEncContext), |
9ccc13d1144d
Move AVCodecs from h263dec.c to msmpeg4.c and disentangle init decode init.
michael
parents:
10821
diff
changeset
|
1941 ff_msmpeg4_decode_init, |
9ccc13d1144d
Move AVCodecs from h263dec.c to msmpeg4.c and disentangle init decode init.
michael
parents:
10821
diff
changeset
|
1942 NULL, |
9ccc13d1144d
Move AVCodecs from h263dec.c to msmpeg4.c and disentangle init decode init.
michael
parents:
10821
diff
changeset
|
1943 ff_h263_decode_end, |
9ccc13d1144d
Move AVCodecs from h263dec.c to msmpeg4.c and disentangle init decode init.
michael
parents:
10821
diff
changeset
|
1944 ff_h263_decode_frame, |
9ccc13d1144d
Move AVCodecs from h263dec.c to msmpeg4.c and disentangle init decode init.
michael
parents:
10821
diff
changeset
|
1945 CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1, |
9ccc13d1144d
Move AVCodecs from h263dec.c to msmpeg4.c and disentangle init decode init.
michael
parents:
10821
diff
changeset
|
1946 .long_name= NULL_IF_CONFIG_SMALL("MPEG-4 part 2 Microsoft variant version 2"), |
9ccc13d1144d
Move AVCodecs from h263dec.c to msmpeg4.c and disentangle init decode init.
michael
parents:
10821
diff
changeset
|
1947 .pix_fmts= ff_pixfmt_list_420, |
9ccc13d1144d
Move AVCodecs from h263dec.c to msmpeg4.c and disentangle init decode init.
michael
parents:
10821
diff
changeset
|
1948 }; |
9ccc13d1144d
Move AVCodecs from h263dec.c to msmpeg4.c and disentangle init decode init.
michael
parents:
10821
diff
changeset
|
1949 |
9ccc13d1144d
Move AVCodecs from h263dec.c to msmpeg4.c and disentangle init decode init.
michael
parents:
10821
diff
changeset
|
1950 AVCodec msmpeg4v3_decoder = { |
9ccc13d1144d
Move AVCodecs from h263dec.c to msmpeg4.c and disentangle init decode init.
michael
parents:
10821
diff
changeset
|
1951 "msmpeg4", |
11560
8a4984c5cacc
Define AVMediaType enum, and use it instead of enum CodecType, which
stefano
parents:
11075
diff
changeset
|
1952 AVMEDIA_TYPE_VIDEO, |
10822
9ccc13d1144d
Move AVCodecs from h263dec.c to msmpeg4.c and disentangle init decode init.
michael
parents:
10821
diff
changeset
|
1953 CODEC_ID_MSMPEG4V3, |
9ccc13d1144d
Move AVCodecs from h263dec.c to msmpeg4.c and disentangle init decode init.
michael
parents:
10821
diff
changeset
|
1954 sizeof(MpegEncContext), |
9ccc13d1144d
Move AVCodecs from h263dec.c to msmpeg4.c and disentangle init decode init.
michael
parents:
10821
diff
changeset
|
1955 ff_msmpeg4_decode_init, |
9ccc13d1144d
Move AVCodecs from h263dec.c to msmpeg4.c and disentangle init decode init.
michael
parents:
10821
diff
changeset
|
1956 NULL, |
9ccc13d1144d
Move AVCodecs from h263dec.c to msmpeg4.c and disentangle init decode init.
michael
parents:
10821
diff
changeset
|
1957 ff_h263_decode_end, |
9ccc13d1144d
Move AVCodecs from h263dec.c to msmpeg4.c and disentangle init decode init.
michael
parents:
10821
diff
changeset
|
1958 ff_h263_decode_frame, |
9ccc13d1144d
Move AVCodecs from h263dec.c to msmpeg4.c and disentangle init decode init.
michael
parents:
10821
diff
changeset
|
1959 CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1, |
9ccc13d1144d
Move AVCodecs from h263dec.c to msmpeg4.c and disentangle init decode init.
michael
parents:
10821
diff
changeset
|
1960 .long_name= NULL_IF_CONFIG_SMALL("MPEG-4 part 2 Microsoft variant version 3"), |
9ccc13d1144d
Move AVCodecs from h263dec.c to msmpeg4.c and disentangle init decode init.
michael
parents:
10821
diff
changeset
|
1961 .pix_fmts= ff_pixfmt_list_420, |
9ccc13d1144d
Move AVCodecs from h263dec.c to msmpeg4.c and disentangle init decode init.
michael
parents:
10821
diff
changeset
|
1962 }; |
9ccc13d1144d
Move AVCodecs from h263dec.c to msmpeg4.c and disentangle init decode init.
michael
parents:
10821
diff
changeset
|
1963 |
9ccc13d1144d
Move AVCodecs from h263dec.c to msmpeg4.c and disentangle init decode init.
michael
parents:
10821
diff
changeset
|
1964 AVCodec wmv1_decoder = { |
9ccc13d1144d
Move AVCodecs from h263dec.c to msmpeg4.c and disentangle init decode init.
michael
parents:
10821
diff
changeset
|
1965 "wmv1", |
11560
8a4984c5cacc
Define AVMediaType enum, and use it instead of enum CodecType, which
stefano
parents:
11075
diff
changeset
|
1966 AVMEDIA_TYPE_VIDEO, |
10822
9ccc13d1144d
Move AVCodecs from h263dec.c to msmpeg4.c and disentangle init decode init.
michael
parents:
10821
diff
changeset
|
1967 CODEC_ID_WMV1, |
9ccc13d1144d
Move AVCodecs from h263dec.c to msmpeg4.c and disentangle init decode init.
michael
parents:
10821
diff
changeset
|
1968 sizeof(MpegEncContext), |
9ccc13d1144d
Move AVCodecs from h263dec.c to msmpeg4.c and disentangle init decode init.
michael
parents:
10821
diff
changeset
|
1969 ff_msmpeg4_decode_init, |
9ccc13d1144d
Move AVCodecs from h263dec.c to msmpeg4.c and disentangle init decode init.
michael
parents:
10821
diff
changeset
|
1970 NULL, |
9ccc13d1144d
Move AVCodecs from h263dec.c to msmpeg4.c and disentangle init decode init.
michael
parents:
10821
diff
changeset
|
1971 ff_h263_decode_end, |
9ccc13d1144d
Move AVCodecs from h263dec.c to msmpeg4.c and disentangle init decode init.
michael
parents:
10821
diff
changeset
|
1972 ff_h263_decode_frame, |
9ccc13d1144d
Move AVCodecs from h263dec.c to msmpeg4.c and disentangle init decode init.
michael
parents:
10821
diff
changeset
|
1973 CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1, |
9ccc13d1144d
Move AVCodecs from h263dec.c to msmpeg4.c and disentangle init decode init.
michael
parents:
10821
diff
changeset
|
1974 .long_name= NULL_IF_CONFIG_SMALL("Windows Media Video 7"), |
9ccc13d1144d
Move AVCodecs from h263dec.c to msmpeg4.c and disentangle init decode init.
michael
parents:
10821
diff
changeset
|
1975 .pix_fmts= ff_pixfmt_list_420, |
9ccc13d1144d
Move AVCodecs from h263dec.c to msmpeg4.c and disentangle init decode init.
michael
parents:
10821
diff
changeset
|
1976 }; |