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