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