Mercurial > libavcodec.hg
annotate wmv2.c @ 2809:75400dfbe117 libavcodec
fixing colocated mv if colocated block is L1 predicted for the temporal direct case
untested (none of the conformance streams laying around on my disk seems affected by this change)
author | michael |
---|---|
date | Wed, 27 Jul 2005 00:15:55 +0000 |
parents | ab7bd4722cef |
children | b866af0c02d6 |
rev | line source |
---|---|
936 | 1 /* |
2 * Copyright (c) 2002 The FFmpeg Project. | |
3 * | |
4 * This library is free software; you can redistribute it and/or | |
5 * modify it under the terms of the GNU Lesser General Public | |
6 * License as published by the Free Software Foundation; either | |
7 * version 2 of the License, or (at your option) any later version. | |
8 * | |
9 * This library is distributed in the hope that it will be useful, | |
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of | |
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |
12 * Lesser General Public License for more details. | |
13 * | |
14 * You should have received a copy of the GNU Lesser General Public | |
15 * License along with this library; if not, write to the Free Software | |
16 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA | |
17 * | |
18 */ | |
19 | |
1106 | 20 /** |
21 * @file wmv2.c | |
22 * wmv2 codec. | |
23 */ | |
24 | |
936 | 25 #include "simple_idct.h" |
26 | |
27 #define SKIP_TYPE_NONE 0 | |
28 #define SKIP_TYPE_MPEG 1 | |
29 #define SKIP_TYPE_ROW 2 | |
30 #define SKIP_TYPE_COL 3 | |
31 | |
32 | |
33 typedef struct Wmv2Context{ | |
34 MpegEncContext s; | |
35 int j_type_bit; | |
36 int j_type; | |
37 int flag3; | |
38 int flag63; | |
39 int abt_flag; | |
40 int abt_type; | |
41 int abt_type_table[6]; | |
42 int per_mb_abt; | |
43 int per_block_abt; | |
44 int mspel_bit; | |
45 int cbp_table_index; | |
46 int top_left_mv_flag; | |
47 int per_mb_rl_bit; | |
48 int skip_type; | |
49 int hshift; | |
50 | |
51 ScanTable abt_scantable[2]; | |
52 DCTELEM abt_block2[6][64] __align8; | |
53 }Wmv2Context; | |
54 | |
55 static void wmv2_common_init(Wmv2Context * w){ | |
56 MpegEncContext * const s= &w->s; | |
57 | |
1273 | 58 ff_init_scantable(s->dsp.idct_permutation, &w->abt_scantable[0], wmv2_scantableA); |
59 ff_init_scantable(s->dsp.idct_permutation, &w->abt_scantable[1], wmv2_scantableB); | |
936 | 60 } |
61 | |
2024
f65d87bfdd5a
some of the warning fixes by (Michael Roitzsch <mroi at users dot sourceforge dot net>)
michael
parents:
1943
diff
changeset
|
62 #ifdef CONFIG_ENCODERS |
f65d87bfdd5a
some of the warning fixes by (Michael Roitzsch <mroi at users dot sourceforge dot net>)
michael
parents:
1943
diff
changeset
|
63 |
936 | 64 static int encode_ext_header(Wmv2Context *w){ |
65 MpegEncContext * const s= &w->s; | |
66 PutBitContext pb; | |
67 int code; | |
68 | |
1524 | 69 init_put_bits(&pb, s->avctx->extradata, s->avctx->extradata_size); |
936 | 70 |
2637 | 71 put_bits(&pb, 5, s->avctx->time_base.den / s->avctx->time_base.num); //yes 29.97 -> 29 |
936 | 72 put_bits(&pb, 11, FFMIN(s->bit_rate/1024, 2047)); |
73 | |
74 put_bits(&pb, 1, w->mspel_bit=1); | |
75 put_bits(&pb, 1, w->flag3=1); | |
76 put_bits(&pb, 1, w->abt_flag=1); | |
77 put_bits(&pb, 1, w->j_type_bit=1); | |
78 put_bits(&pb, 1, w->top_left_mv_flag=0); | |
79 put_bits(&pb, 1, w->per_mb_rl_bit=1); | |
80 put_bits(&pb, 3, code=1); | |
81 | |
82 flush_put_bits(&pb); | |
83 | |
84 s->slice_height = s->mb_height / code; | |
85 | |
86 return 0; | |
87 } | |
88 | |
89 static int wmv2_encode_init(AVCodecContext *avctx){ | |
90 Wmv2Context * const w= avctx->priv_data; | |
91 | |
92 if(MPV_encode_init(avctx) < 0) | |
93 return -1; | |
94 | |
95 wmv2_common_init(w); | |
96 | |
97 avctx->extradata_size= 4; | |
98 avctx->extradata= av_mallocz(avctx->extradata_size + 10); | |
99 encode_ext_header(w); | |
100 | |
101 return 0; | |
102 } | |
103 | |
2522
e25782262d7d
kill warnings patch by (Mns Rullgrd <mru inprovide com>)
michael
parents:
2474
diff
changeset
|
104 #if 0 /* unused, remove? */ |
936 | 105 static int wmv2_encode_end(AVCodecContext *avctx){ |
106 | |
107 if(MPV_encode_end(avctx) < 0) | |
108 return -1; | |
109 | |
110 avctx->extradata_size= 0; | |
111 av_freep(&avctx->extradata); | |
112 | |
113 return 0; | |
114 } | |
2522
e25782262d7d
kill warnings patch by (Mns Rullgrd <mru inprovide com>)
michael
parents:
2474
diff
changeset
|
115 #endif |
936 | 116 |
117 int ff_wmv2_encode_picture_header(MpegEncContext * s, int picture_number) | |
118 { | |
119 Wmv2Context * const w= (Wmv2Context*)s; | |
120 | |
121 put_bits(&s->pb, 1, s->pict_type - 1); | |
122 if(s->pict_type == I_TYPE){ | |
123 put_bits(&s->pb, 7, 0); | |
124 } | |
125 put_bits(&s->pb, 5, s->qscale); | |
126 | |
127 s->dc_table_index = 1; | |
128 s->mv_table_index = 1; /* only if P frame */ | |
129 // s->use_skip_mb_code = 1; /* only if P frame */ | |
130 s->per_mb_rl_table = 0; | |
131 s->mspel= 0; | |
132 w->per_mb_abt=0; | |
133 w->abt_type=0; | |
134 w->j_type=0; | |
135 | |
1163 | 136 assert(s->flipflop_rounding); |
137 | |
936 | 138 if (s->pict_type == I_TYPE) { |
1163 | 139 assert(s->no_rounding==1); |
936 | 140 if(w->j_type_bit) put_bits(&s->pb, 1, w->j_type); |
141 | |
142 if(w->per_mb_rl_bit) put_bits(&s->pb, 1, s->per_mb_rl_table); | |
143 | |
144 if(!s->per_mb_rl_table){ | |
145 code012(&s->pb, s->rl_chroma_table_index); | |
146 code012(&s->pb, s->rl_table_index); | |
147 } | |
148 | |
149 put_bits(&s->pb, 1, s->dc_table_index); | |
150 | |
151 s->inter_intra_pred= 0; | |
152 }else{ | |
153 int cbp_index; | |
154 | |
155 put_bits(&s->pb, 2, SKIP_TYPE_NONE); | |
156 | |
157 code012(&s->pb, cbp_index=0); | |
158 if(s->qscale <= 10){ | |
159 int map[3]= {0,2,1}; | |
160 w->cbp_table_index= map[cbp_index]; | |
161 }else if(s->qscale <= 20){ | |
162 int map[3]= {1,0,2}; | |
163 w->cbp_table_index= map[cbp_index]; | |
164 }else{ | |
165 int map[3]= {2,1,0}; | |
166 w->cbp_table_index= map[cbp_index]; | |
167 } | |
168 | |
169 if(w->mspel_bit) put_bits(&s->pb, 1, s->mspel); | |
170 | |
171 if(w->abt_flag){ | |
172 put_bits(&s->pb, 1, w->per_mb_abt^1); | |
173 if(!w->per_mb_abt){ | |
174 code012(&s->pb, w->abt_type); | |
175 } | |
176 } | |
177 | |
178 if(w->per_mb_rl_bit) put_bits(&s->pb, 1, s->per_mb_rl_table); | |
179 | |
180 if(!s->per_mb_rl_table){ | |
181 code012(&s->pb, s->rl_table_index); | |
182 s->rl_chroma_table_index = s->rl_table_index; | |
183 } | |
184 put_bits(&s->pb, 1, s->dc_table_index); | |
185 put_bits(&s->pb, 1, s->mv_table_index); | |
186 | |
1943 | 187 s->inter_intra_pred= 0;//(s->width*s->height < 320*240 && s->bit_rate<=II_BITRATE); |
936 | 188 } |
189 s->esc3_level_length= 0; | |
190 s->esc3_run_length= 0; | |
191 | |
192 return 0; | |
193 } | |
194 | |
195 // nearly idential to wmv1 but thats just because we dont use the useless M$ crap features | |
196 // its duplicated here in case someone wants to add support for these carp features | |
197 void ff_wmv2_encode_mb(MpegEncContext * s, | |
198 DCTELEM block[6][64], | |
199 int motion_x, int motion_y) | |
200 { | |
201 Wmv2Context * const w= (Wmv2Context*)s; | |
202 int cbp, coded_cbp, i; | |
203 int pred_x, pred_y; | |
1064 | 204 uint8_t *coded_block; |
936 | 205 |
206 handle_slices(s); | |
207 | |
208 if (!s->mb_intra) { | |
209 /* compute cbp */ | |
210 set_stat(ST_INTER_MB); | |
211 cbp = 0; | |
212 for (i = 0; i < 6; i++) { | |
213 if (s->block_last_index[i] >= 0) | |
214 cbp |= 1 << (5 - i); | |
215 } | |
216 | |
217 put_bits(&s->pb, | |
218 wmv2_inter_table[w->cbp_table_index][cbp + 64][1], | |
219 wmv2_inter_table[w->cbp_table_index][cbp + 64][0]); | |
220 | |
221 /* motion vector */ | |
1938
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1668
diff
changeset
|
222 h263_pred_motion(s, 0, 0, &pred_x, &pred_y); |
936 | 223 msmpeg4_encode_motion(s, motion_x - pred_x, |
224 motion_y - pred_y); | |
225 } else { | |
226 /* compute cbp */ | |
227 cbp = 0; | |
228 coded_cbp = 0; | |
229 for (i = 0; i < 6; i++) { | |
230 int val, pred; | |
231 val = (s->block_last_index[i] >= 1); | |
232 cbp |= val << (5 - i); | |
233 if (i < 4) { | |
234 /* predict value for close blocks only for luma */ | |
235 pred = coded_block_pred(s, i, &coded_block); | |
236 *coded_block = val; | |
237 val = val ^ pred; | |
238 } | |
239 coded_cbp |= val << (5 - i); | |
240 } | |
241 #if 0 | |
242 if (coded_cbp) | |
243 printf("cbp=%x %x\n", cbp, coded_cbp); | |
244 #endif | |
245 | |
246 if (s->pict_type == I_TYPE) { | |
247 set_stat(ST_INTRA_MB); | |
248 put_bits(&s->pb, | |
2474 | 249 ff_msmp4_mb_i_table[coded_cbp][1], ff_msmp4_mb_i_table[coded_cbp][0]); |
936 | 250 } else { |
251 put_bits(&s->pb, | |
252 wmv2_inter_table[w->cbp_table_index][cbp][1], | |
253 wmv2_inter_table[w->cbp_table_index][cbp][0]); | |
254 } | |
255 set_stat(ST_INTRA_MB); | |
256 put_bits(&s->pb, 1, 0); /* no AC prediction yet */ | |
257 if(s->inter_intra_pred){ | |
258 s->h263_aic_dir=0; | |
259 put_bits(&s->pb, table_inter_intra[s->h263_aic_dir][1], table_inter_intra[s->h263_aic_dir][0]); | |
260 } | |
261 } | |
262 | |
263 for (i = 0; i < 6; i++) { | |
264 msmpeg4_encode_block(s, block[i], i); | |
265 } | |
266 } | |
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
|
267 #endif //CONFIG_ENCODERS |
936 | 268 |
269 static void parse_mb_skip(Wmv2Context * w){ | |
270 int mb_x, mb_y; | |
271 MpegEncContext * const s= &w->s; | |
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:
1163
diff
changeset
|
272 uint32_t * const mb_type= s->current_picture_ptr->mb_type; |
936 | 273 |
274 w->skip_type= get_bits(&s->gb, 2); | |
275 switch(w->skip_type){ | |
276 case SKIP_TYPE_NONE: | |
277 for(mb_y=0; mb_y<s->mb_height; mb_y++){ | |
278 for(mb_x=0; mb_x<s->mb_width; mb_x++){ | |
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:
1163
diff
changeset
|
279 mb_type[mb_y*s->mb_stride + mb_x]= MB_TYPE_16x16 | MB_TYPE_L0; |
936 | 280 } |
281 } | |
282 break; | |
283 case SKIP_TYPE_MPEG: | |
284 for(mb_y=0; mb_y<s->mb_height; mb_y++){ | |
285 for(mb_x=0; mb_x<s->mb_width; mb_x++){ | |
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:
1163
diff
changeset
|
286 mb_type[mb_y*s->mb_stride + mb_x]= (get_bits1(&s->gb) ? MB_TYPE_SKIP : 0) | MB_TYPE_16x16 | MB_TYPE_L0; |
936 | 287 } |
288 } | |
289 break; | |
290 case SKIP_TYPE_ROW: | |
291 for(mb_y=0; mb_y<s->mb_height; mb_y++){ | |
292 if(get_bits1(&s->gb)){ | |
293 for(mb_x=0; mb_x<s->mb_width; mb_x++){ | |
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:
1163
diff
changeset
|
294 mb_type[mb_y*s->mb_stride + mb_x]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0; |
936 | 295 } |
296 }else{ | |
297 for(mb_x=0; mb_x<s->mb_width; mb_x++){ | |
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:
1163
diff
changeset
|
298 mb_type[mb_y*s->mb_stride + mb_x]= (get_bits1(&s->gb) ? MB_TYPE_SKIP : 0) | MB_TYPE_16x16 | MB_TYPE_L0; |
936 | 299 } |
300 } | |
301 } | |
302 break; | |
303 case SKIP_TYPE_COL: | |
304 for(mb_x=0; mb_x<s->mb_width; mb_x++){ | |
305 if(get_bits1(&s->gb)){ | |
306 for(mb_y=0; mb_y<s->mb_height; mb_y++){ | |
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:
1163
diff
changeset
|
307 mb_type[mb_y*s->mb_stride + mb_x]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0; |
936 | 308 } |
309 }else{ | |
310 for(mb_y=0; mb_y<s->mb_height; mb_y++){ | |
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:
1163
diff
changeset
|
311 mb_type[mb_y*s->mb_stride + mb_x]= (get_bits1(&s->gb) ? MB_TYPE_SKIP : 0) | MB_TYPE_16x16 | MB_TYPE_L0; |
936 | 312 } |
313 } | |
314 } | |
315 break; | |
316 } | |
317 } | |
318 | |
319 static int decode_ext_header(Wmv2Context *w){ | |
320 MpegEncContext * const s= &w->s; | |
321 GetBitContext gb; | |
322 int fps; | |
323 int code; | |
324 | |
325 if(s->avctx->extradata_size<4) return -1; | |
326 | |
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
|
327 init_get_bits(&gb, s->avctx->extradata, s->avctx->extradata_size*8); |
936 | 328 |
329 fps = get_bits(&gb, 5); | |
330 s->bit_rate = get_bits(&gb, 11)*1024; | |
331 w->mspel_bit = get_bits1(&gb); | |
332 w->flag3 = get_bits1(&gb); | |
333 w->abt_flag = get_bits1(&gb); | |
334 w->j_type_bit = get_bits1(&gb); | |
335 w->top_left_mv_flag= get_bits1(&gb); | |
336 w->per_mb_rl_bit = get_bits1(&gb); | |
337 code = get_bits(&gb, 3); | |
338 | |
339 if(code==0) return -1; | |
1092 | 340 |
936 | 341 s->slice_height = s->mb_height / code; |
342 | |
343 if(s->avctx->debug&FF_DEBUG_PICT_INFO){ | |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1524
diff
changeset
|
344 av_log(s->avctx, AV_LOG_DEBUG, "fps:%d, br:%d, qpbit:%d, abt_flag:%d, j_type_bit:%d, tl_mv_flag:%d, mbrl_bit:%d, code:%d, flag3:%d, slices:%d\n", |
983 | 345 fps, s->bit_rate, w->mspel_bit, w->abt_flag, w->j_type_bit, w->top_left_mv_flag, w->per_mb_rl_bit, code, w->flag3, |
346 code); | |
936 | 347 } |
348 return 0; | |
349 } | |
350 | |
351 int ff_wmv2_decode_picture_header(MpegEncContext * s) | |
352 { | |
353 Wmv2Context * const w= (Wmv2Context*)s; | |
1183 | 354 int code; |
936 | 355 |
356 #if 0 | |
357 { | |
358 int i; | |
359 for(i=0; i<s->gb.size*8; i++) | |
360 printf("%d", get_bits1(&s->gb)); | |
361 // get_bits1(&s->gb); | |
362 printf("END\n"); | |
363 return -1; | |
364 } | |
365 #endif | |
366 if(s->picture_number==0) | |
367 decode_ext_header(w); | |
368 | |
369 s->pict_type = get_bits(&s->gb, 1) + 1; | |
370 if(s->pict_type == I_TYPE){ | |
371 code = get_bits(&s->gb, 7); | |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1524
diff
changeset
|
372 av_log(s->avctx, AV_LOG_ERROR, "I7:%X/\n", code); |
936 | 373 } |
1651 | 374 s->chroma_qscale= s->qscale = get_bits(&s->gb, 5); |
1183 | 375 if(s->qscale < 0) |
376 return -1; | |
377 | |
378 return 0; | |
379 } | |
380 | |
381 int ff_wmv2_decode_secondary_picture_header(MpegEncContext * s) | |
382 { | |
383 Wmv2Context * const w= (Wmv2Context*)s; | |
936 | 384 |
385 if (s->pict_type == I_TYPE) { | |
386 if(w->j_type_bit) w->j_type= get_bits1(&s->gb); | |
387 else w->j_type= 0; //FIXME check | |
388 | |
389 if(!w->j_type){ | |
390 if(w->per_mb_rl_bit) s->per_mb_rl_table= get_bits1(&s->gb); | |
391 else s->per_mb_rl_table= 0; | |
392 | |
393 if(!s->per_mb_rl_table){ | |
394 s->rl_chroma_table_index = decode012(&s->gb); | |
395 s->rl_table_index = decode012(&s->gb); | |
396 } | |
397 | |
398 s->dc_table_index = get_bits1(&s->gb); | |
399 } | |
400 s->inter_intra_pred= 0; | |
401 s->no_rounding = 1; | |
402 if(s->avctx->debug&FF_DEBUG_PICT_INFO){ | |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1524
diff
changeset
|
403 av_log(s->avctx, AV_LOG_DEBUG, "qscale:%d rlc:%d rl:%d dc:%d mbrl:%d j_type:%d \n", |
936 | 404 s->qscale, |
405 s->rl_chroma_table_index, | |
406 s->rl_table_index, | |
407 s->dc_table_index, | |
408 s->per_mb_rl_table, | |
409 w->j_type); | |
410 } | |
411 }else{ | |
412 int cbp_index; | |
413 w->j_type=0; | |
414 | |
415 parse_mb_skip(w); | |
416 cbp_index= decode012(&s->gb); | |
417 if(s->qscale <= 10){ | |
418 int map[3]= {0,2,1}; | |
419 w->cbp_table_index= map[cbp_index]; | |
420 }else if(s->qscale <= 20){ | |
421 int map[3]= {1,0,2}; | |
422 w->cbp_table_index= map[cbp_index]; | |
423 }else{ | |
424 int map[3]= {2,1,0}; | |
425 w->cbp_table_index= map[cbp_index]; | |
426 } | |
427 | |
428 if(w->mspel_bit) s->mspel= get_bits1(&s->gb); | |
429 else s->mspel= 0; //FIXME check | |
430 | |
431 if(w->abt_flag){ | |
432 w->per_mb_abt= get_bits1(&s->gb)^1; | |
433 if(!w->per_mb_abt){ | |
434 w->abt_type= decode012(&s->gb); | |
435 } | |
436 } | |
437 | |
438 if(w->per_mb_rl_bit) s->per_mb_rl_table= get_bits1(&s->gb); | |
439 else s->per_mb_rl_table= 0; | |
440 | |
441 if(!s->per_mb_rl_table){ | |
442 s->rl_table_index = decode012(&s->gb); | |
443 s->rl_chroma_table_index = s->rl_table_index; | |
444 } | |
445 | |
446 s->dc_table_index = get_bits1(&s->gb); | |
447 s->mv_table_index = get_bits1(&s->gb); | |
448 | |
1943 | 449 s->inter_intra_pred= 0;//(s->width*s->height < 320*240 && s->bit_rate<=II_BITRATE); |
936 | 450 s->no_rounding ^= 1; |
451 | |
452 if(s->avctx->debug&FF_DEBUG_PICT_INFO){ | |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1524
diff
changeset
|
453 av_log(s->avctx, AV_LOG_DEBUG, "rl:%d rlc:%d dc:%d mv:%d mbrl:%d qp:%d mspel:%d per_mb_abt:%d abt_type:%d cbp:%d ii:%d\n", |
936 | 454 s->rl_table_index, |
455 s->rl_chroma_table_index, | |
456 s->dc_table_index, | |
457 s->mv_table_index, | |
458 s->per_mb_rl_table, | |
459 s->qscale, | |
460 s->mspel, | |
461 w->per_mb_abt, | |
462 w->abt_type, | |
463 w->cbp_table_index, | |
464 s->inter_intra_pred); | |
465 } | |
466 } | |
467 s->esc3_level_length= 0; | |
468 s->esc3_run_length= 0; | |
469 | |
470 s->picture_number++; //FIXME ? | |
471 | |
472 | |
473 // if(w->j_type) | |
474 // return wmv2_decode_j_picture(w); //FIXME | |
475 | |
476 if(w->j_type){ | |
2628
511e3afc43e1
Ministry of English Composition, reporting for duty (and the word is "skipped", not "skiped"; "skiped" would rhyme with "hyped")
melanson
parents:
2522
diff
changeset
|
477 av_log(s->avctx, AV_LOG_ERROR, "J-type picture is not supported\n"); |
936 | 478 return -1; |
479 } | |
480 | |
481 return 0; | |
482 } | |
483 | |
484 static inline int wmv2_decode_motion(Wmv2Context *w, int *mx_ptr, int *my_ptr){ | |
485 MpegEncContext * const s= &w->s; | |
486 int ret; | |
487 | |
488 ret= msmpeg4_decode_motion(s, mx_ptr, my_ptr); | |
489 | |
490 if(ret<0) return -1; | |
491 | |
492 if((((*mx_ptr)|(*my_ptr)) & 1) && s->mspel) | |
493 w->hshift= get_bits1(&s->gb); | |
494 else | |
495 w->hshift= 0; | |
496 | |
497 //printf("%d %d ", *mx_ptr, *my_ptr); | |
498 | |
499 return 0; | |
500 } | |
501 | |
502 static int16_t *wmv2_pred_motion(Wmv2Context *w, int *px, int *py){ | |
503 MpegEncContext * const s= &w->s; | |
504 int xy, wrap, diff, type; | |
1064 | 505 int16_t *A, *B, *C, *mot_val; |
936 | 506 |
1938
e2501e6e7ff7
unify table indexing (motion_val,dc_val,ac_val,coded_block changed)
michael
parents:
1668
diff
changeset
|
507 wrap = s->b8_stride; |
936 | 508 xy = s->block_index[0]; |
509 | |
1668
30746f429df6
move motion_val & mb_type to AVFrame patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1651
diff
changeset
|
510 mot_val = s->current_picture.motion_val[0][xy]; |
936 | 511 |
1668
30746f429df6
move motion_val & mb_type to AVFrame patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1651
diff
changeset
|
512 A = s->current_picture.motion_val[0][xy - 1]; |
30746f429df6
move motion_val & mb_type to AVFrame patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1651
diff
changeset
|
513 B = s->current_picture.motion_val[0][xy - wrap]; |
30746f429df6
move motion_val & mb_type to AVFrame patch by (Wolfgang Hesseler <qv at multimediaware dot com>)
michael
parents:
1651
diff
changeset
|
514 C = s->current_picture.motion_val[0][xy + 2 - wrap]; |
936 | 515 |
516 diff= FFMAX(ABS(A[0] - B[0]), ABS(A[1] - B[1])); | |
517 | |
1043 | 518 if(s->mb_x && !s->first_slice_line && !s->mspel && w->top_left_mv_flag && diff >= 8) |
936 | 519 type= get_bits1(&s->gb); |
520 else | |
521 type= 2; | |
522 | |
523 if(type == 0){ | |
524 *px= A[0]; | |
525 *py= A[1]; | |
526 }else if(type == 1){ | |
527 *px= B[0]; | |
528 *py= B[1]; | |
529 }else{ | |
530 /* special case for first (slice) line */ | |
531 if (s->first_slice_line) { | |
532 *px = A[0]; | |
533 *py = A[1]; | |
534 } else { | |
535 *px = mid_pred(A[0], B[0], C[0]); | |
536 *py = mid_pred(A[1], B[1], C[1]); | |
537 } | |
538 } | |
539 | |
540 return mot_val; | |
541 } | |
542 | |
543 static inline int wmv2_decode_inter_block(Wmv2Context *w, DCTELEM *block, int n, int cbp){ | |
544 MpegEncContext * const s= &w->s; | |
545 static const int sub_cbp_table[3]= {2,3,1}; | |
546 int sub_cbp; | |
547 | |
548 if(!cbp){ | |
549 s->block_last_index[n] = -1; | |
550 | |
551 return 0; | |
552 } | |
553 | |
554 if(w->per_block_abt) | |
555 w->abt_type= decode012(&s->gb); | |
556 #if 0 | |
557 if(w->per_block_abt) | |
558 printf("B%d", w->abt_type); | |
559 #endif | |
560 w->abt_type_table[n]= w->abt_type; | |
561 | |
562 if(w->abt_type){ | |
563 // const uint8_t *scantable= w->abt_scantable[w->abt_type-1].permutated; | |
564 const uint8_t *scantable= w->abt_scantable[w->abt_type-1].scantable; | |
565 // const uint8_t *scantable= w->abt_type-1 ? w->abt_scantable[1].permutated : w->abt_scantable[0].scantable; | |
566 | |
567 sub_cbp= sub_cbp_table[ decode012(&s->gb) ]; | |
568 // printf("S%d", sub_cbp); | |
569 | |
570 if(sub_cbp&1){ | |
571 if (msmpeg4_decode_block(s, block, n, 1, scantable) < 0) | |
572 return -1; | |
573 } | |
574 | |
575 if(sub_cbp&2){ | |
576 if (msmpeg4_decode_block(s, w->abt_block2[n], n, 1, scantable) < 0) | |
577 return -1; | |
578 } | |
579 s->block_last_index[n] = 63; | |
580 | |
581 return 0; | |
582 }else{ | |
583 return msmpeg4_decode_block(s, block, n, 1, s->inter_scantable.permutated); | |
584 } | |
585 } | |
586 | |
587 static void wmv2_add_block(Wmv2Context *w, DCTELEM *block1, uint8_t *dst, int stride, int n){ | |
588 MpegEncContext * const s= &w->s; | |
1064 | 589 |
2655
ab7bd4722cef
fix block corruption caused by clear_blocks() optimization
michael
parents:
2637
diff
changeset
|
590 if (s->block_last_index[n] >= 0) { |
936 | 591 switch(w->abt_type_table[n]){ |
592 case 0: | |
2655
ab7bd4722cef
fix block corruption caused by clear_blocks() optimization
michael
parents:
2637
diff
changeset
|
593 s->dsp.idct_add (dst, stride, block1); |
936 | 594 break; |
595 case 1: | |
596 simple_idct84_add(dst , stride, block1); | |
597 simple_idct84_add(dst + 4*stride, stride, w->abt_block2[n]); | |
598 memset(w->abt_block2[n], 0, 64*sizeof(DCTELEM)); | |
599 break; | |
600 case 2: | |
601 simple_idct48_add(dst , stride, block1); | |
602 simple_idct48_add(dst + 4 , stride, w->abt_block2[n]); | |
603 memset(w->abt_block2[n], 0, 64*sizeof(DCTELEM)); | |
604 break; | |
605 default: | |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1524
diff
changeset
|
606 av_log(s->avctx, AV_LOG_ERROR, "internal error in WMV2 abt\n"); |
936 | 607 } |
2655
ab7bd4722cef
fix block corruption caused by clear_blocks() optimization
michael
parents:
2637
diff
changeset
|
608 } |
936 | 609 } |
610 | |
611 void ff_wmv2_add_mb(MpegEncContext *s, DCTELEM block1[6][64], uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr){ | |
612 Wmv2Context * const w= (Wmv2Context*)s; | |
613 | |
614 wmv2_add_block(w, block1[0], dest_y , s->linesize, 0); | |
615 wmv2_add_block(w, block1[1], dest_y + 8 , s->linesize, 1); | |
616 wmv2_add_block(w, block1[2], dest_y + 8*s->linesize, s->linesize, 2); | |
617 wmv2_add_block(w, block1[3], dest_y + 8 + 8*s->linesize, s->linesize, 3); | |
618 | |
619 if(s->flags&CODEC_FLAG_GRAY) return; | |
620 | |
621 wmv2_add_block(w, block1[4], dest_cb , s->uvlinesize, 4); | |
622 wmv2_add_block(w, block1[5], dest_cr , s->uvlinesize, 5); | |
623 } | |
624 | |
625 void ff_mspel_motion(MpegEncContext *s, | |
1064 | 626 uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr, |
627 uint8_t **ref_picture, op_pixels_func (*pix_op)[4], | |
936 | 628 int motion_x, int motion_y, int h) |
629 { | |
630 Wmv2Context * const w= (Wmv2Context*)s; | |
1064 | 631 uint8_t *ptr; |
936 | 632 int dxy, offset, mx, my, src_x, src_y, v_edge_pos, linesize, uvlinesize; |
633 int emu=0; | |
634 | |
635 dxy = ((motion_y & 1) << 1) | (motion_x & 1); | |
636 dxy = 2*dxy + w->hshift; | |
637 src_x = s->mb_x * 16 + (motion_x >> 1); | |
638 src_y = s->mb_y * 16 + (motion_y >> 1); | |
639 | |
640 /* WARNING: do no forget half pels */ | |
641 v_edge_pos = s->v_edge_pos; | |
642 src_x = clip(src_x, -16, s->width); | |
643 src_y = clip(src_y, -16, s->height); | |
644 linesize = s->linesize; | |
645 uvlinesize = s->uvlinesize; | |
646 ptr = ref_picture[0] + (src_y * linesize) + src_x; | |
647 | |
648 if(s->flags&CODEC_FLAG_EMU_EDGE){ | |
649 if(src_x<1 || src_y<1 || src_x + 17 >= s->h_edge_pos | |
650 || src_y + h+1 >= v_edge_pos){ | |
1318 | 651 ff_emulated_edge_mc(s->edge_emu_buffer, ptr - 1 - s->linesize, s->linesize, 19, 19, |
936 | 652 src_x-1, src_y-1, s->h_edge_pos, s->v_edge_pos); |
653 ptr= s->edge_emu_buffer + 1 + s->linesize; | |
654 emu=1; | |
655 } | |
656 } | |
657 | |
658 s->dsp.put_mspel_pixels_tab[dxy](dest_y , ptr , linesize); | |
659 s->dsp.put_mspel_pixels_tab[dxy](dest_y+8 , ptr+8 , linesize); | |
660 s->dsp.put_mspel_pixels_tab[dxy](dest_y +8*linesize, ptr +8*linesize, linesize); | |
661 s->dsp.put_mspel_pixels_tab[dxy](dest_y+8+8*linesize, ptr+8+8*linesize, linesize); | |
662 | |
663 if(s->flags&CODEC_FLAG_GRAY) return; | |
664 | |
665 if (s->out_format == FMT_H263) { | |
666 dxy = 0; | |
667 if ((motion_x & 3) != 0) | |
668 dxy |= 1; | |
669 if ((motion_y & 3) != 0) | |
670 dxy |= 2; | |
671 mx = motion_x >> 2; | |
672 my = motion_y >> 2; | |
673 } else { | |
674 mx = motion_x / 2; | |
675 my = motion_y / 2; | |
676 dxy = ((my & 1) << 1) | (mx & 1); | |
677 mx >>= 1; | |
678 my >>= 1; | |
679 } | |
680 | |
681 src_x = s->mb_x * 8 + mx; | |
682 src_y = s->mb_y * 8 + my; | |
683 src_x = clip(src_x, -8, s->width >> 1); | |
684 if (src_x == (s->width >> 1)) | |
685 dxy &= ~1; | |
686 src_y = clip(src_y, -8, s->height >> 1); | |
687 if (src_y == (s->height >> 1)) | |
688 dxy &= ~2; | |
689 offset = (src_y * uvlinesize) + src_x; | |
690 ptr = ref_picture[1] + offset; | |
691 if(emu){ | |
1317
26c44d2433c1
make ff_emulated_edge_mc() independant of MpegEncContext
michaelni
parents:
1273
diff
changeset
|
692 ff_emulated_edge_mc(s->edge_emu_buffer, ptr, s->uvlinesize, 9, 9, |
936 | 693 src_x, src_y, s->h_edge_pos>>1, s->v_edge_pos>>1); |
694 ptr= s->edge_emu_buffer; | |
695 } | |
696 pix_op[1][dxy](dest_cb, ptr, uvlinesize, h >> 1); | |
697 | |
698 ptr = ref_picture[2] + offset; | |
699 if(emu){ | |
1317
26c44d2433c1
make ff_emulated_edge_mc() independant of MpegEncContext
michaelni
parents:
1273
diff
changeset
|
700 ff_emulated_edge_mc(s->edge_emu_buffer, ptr, s->uvlinesize, 9, 9, |
936 | 701 src_x, src_y, s->h_edge_pos>>1, s->v_edge_pos>>1); |
702 ptr= s->edge_emu_buffer; | |
703 } | |
704 pix_op[1][dxy](dest_cr, ptr, uvlinesize, h >> 1); | |
705 } | |
706 | |
707 | |
708 static int wmv2_decode_mb(MpegEncContext *s, DCTELEM block[6][64]) | |
709 { | |
710 Wmv2Context * const w= (Wmv2Context*)s; | |
711 int cbp, code, i; | |
1064 | 712 uint8_t *coded_val; |
936 | 713 |
714 if(w->j_type) return 0; | |
715 | |
716 if (s->pict_type == P_TYPE) { | |
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:
1163
diff
changeset
|
717 if(IS_SKIP(s->current_picture.mb_type[s->mb_y * s->mb_stride + s->mb_x])){ |
936 | 718 /* skip mb */ |
719 s->mb_intra = 0; | |
720 for(i=0;i<6;i++) | |
721 s->block_last_index[i] = -1; | |
722 s->mv_dir = MV_DIR_FORWARD; | |
723 s->mv_type = MV_TYPE_16X16; | |
724 s->mv[0][0][0] = 0; | |
725 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:
2522
diff
changeset
|
726 s->mb_skipped = 1; |
1185 | 727 w->hshift=0; |
936 | 728 return 0; |
729 } | |
730 | |
731 code = get_vlc2(&s->gb, mb_non_intra_vlc[w->cbp_table_index].table, MB_NON_INTRA_VLC_BITS, 3); | |
732 if (code < 0) | |
733 return -1; | |
734 s->mb_intra = (~code & 0x40) >> 6; | |
735 | |
736 cbp = code & 0x3f; | |
737 } else { | |
738 s->mb_intra = 1; | |
2474 | 739 code = get_vlc2(&s->gb, ff_msmp4_mb_i_vlc.table, MB_INTRA_VLC_BITS, 2); |
936 | 740 if (code < 0){ |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1524
diff
changeset
|
741 av_log(s->avctx, AV_LOG_ERROR, "II-cbp illegal at %d %d\n", s->mb_x, s->mb_y); |
936 | 742 return -1; |
743 } | |
744 /* predict coded block pattern */ | |
745 cbp = 0; | |
746 for(i=0;i<6;i++) { | |
747 int val = ((code >> (5 - i)) & 1); | |
748 if (i < 4) { | |
749 int pred = coded_block_pred(s, i, &coded_val); | |
750 val = val ^ pred; | |
751 *coded_val = val; | |
752 } | |
753 cbp |= val << (5 - i); | |
754 } | |
755 } | |
756 | |
757 if (!s->mb_intra) { | |
758 int mx, my; | |
759 //printf("P at %d %d\n", s->mb_x, s->mb_y); | |
760 wmv2_pred_motion(w, &mx, &my); | |
761 | |
762 if(cbp){ | |
2632 | 763 s->dsp.clear_blocks(s->block[0]); |
936 | 764 if(s->per_mb_rl_table){ |
765 s->rl_table_index = decode012(&s->gb); | |
766 s->rl_chroma_table_index = s->rl_table_index; | |
767 } | |
768 | |
769 if(w->abt_flag && w->per_mb_abt){ | |
770 w->per_block_abt= get_bits1(&s->gb); | |
771 if(!w->per_block_abt) | |
772 w->abt_type= decode012(&s->gb); | |
773 }else | |
774 w->per_block_abt=0; | |
775 } | |
776 | |
777 if (wmv2_decode_motion(w, &mx, &my) < 0) | |
778 return -1; | |
779 | |
780 s->mv_dir = MV_DIR_FORWARD; | |
781 s->mv_type = MV_TYPE_16X16; | |
782 s->mv[0][0][0] = mx; | |
783 s->mv[0][0][1] = my; | |
784 | |
785 for (i = 0; i < 6; i++) { | |
786 if (wmv2_decode_inter_block(w, block[i], i, (cbp >> (5 - i)) & 1) < 0) | |
787 { | |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1524
diff
changeset
|
788 av_log(s->avctx, AV_LOG_ERROR, "\nerror while decoding inter block: %d x %d (%d)\n", s->mb_x, s->mb_y, i); |
936 | 789 return -1; |
790 } | |
791 } | |
792 } else { | |
793 //if(s->pict_type==P_TYPE) | |
794 // printf("%d%d ", s->inter_intra_pred, cbp); | |
795 //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)); | |
796 s->ac_pred = get_bits1(&s->gb); | |
797 if(s->inter_intra_pred){ | |
798 s->h263_aic_dir= get_vlc2(&s->gb, inter_intra_vlc.table, INTER_INTRA_VLC_BITS, 1); | |
799 // printf("%d%d %d %d/", s->ac_pred, s->h263_aic_dir, s->mb_x, s->mb_y); | |
800 } | |
801 if(s->per_mb_rl_table && cbp){ | |
802 s->rl_table_index = decode012(&s->gb); | |
803 s->rl_chroma_table_index = s->rl_table_index; | |
804 } | |
805 | |
2632 | 806 s->dsp.clear_blocks(s->block[0]); |
936 | 807 for (i = 0; i < 6; i++) { |
808 if (msmpeg4_decode_block(s, block[i], i, (cbp >> (5 - i)) & 1, NULL) < 0) | |
809 { | |
1598
932d306bf1dc
av_log() patch by (Michel Bardiaux <mbardiaux at peaktime dot be>)
michael
parents:
1524
diff
changeset
|
810 av_log(s->avctx, AV_LOG_ERROR, "\nerror while decoding intra block: %d x %d (%d)\n", s->mb_x, s->mb_y, i); |
936 | 811 return -1; |
812 } | |
813 } | |
814 } | |
815 | |
816 return 0; | |
817 } | |
818 | |
819 static int wmv2_decode_init(AVCodecContext *avctx){ | |
820 Wmv2Context * const w= avctx->priv_data; | |
821 | |
822 if(ff_h263_decode_init(avctx) < 0) | |
823 return -1; | |
824 | |
825 wmv2_common_init(w); | |
826 | |
827 return 0; | |
828 } | |
829 | |
830 AVCodec wmv2_decoder = { | |
831 "wmv2", | |
832 CODEC_TYPE_VIDEO, | |
833 CODEC_ID_WMV2, | |
834 sizeof(Wmv2Context), | |
835 wmv2_decode_init, | |
836 NULL, | |
837 ff_h263_decode_end, | |
838 ff_h263_decode_frame, | |
839 CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1, | |
840 }; | |
841 | |
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
|
842 #ifdef CONFIG_ENCODERS |
936 | 843 AVCodec wmv2_encoder = { |
844 "wmv2", | |
845 CODEC_TYPE_VIDEO, | |
846 CODEC_ID_WMV2, | |
847 sizeof(Wmv2Context), | |
848 wmv2_encode_init, | |
849 MPV_encode_picture, | |
850 MPV_encode_end, | |
851 }; | |
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
|
852 #endif |