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