ffmpeg / libavcodec / wmv2.c @ 5509bffa
History | View | Annotate | Download (25 KB)
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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
|
17 |
*
|
18 |
*/
|
19 |
|
20 |
/**
|
21 |
* @file wmv2.c
|
22 |
* wmv2 codec.
|
23 |
*/
|
24 |
|
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 |
|
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);
|
60 |
} |
61 |
|
62 |
#ifdef CONFIG_ENCODERS
|
63 |
|
64 |
static int encode_ext_header(Wmv2Context *w){ |
65 |
MpegEncContext * const s= &w->s;
|
66 |
PutBitContext pb; |
67 |
int code;
|
68 |
|
69 |
init_put_bits(&pb, s->avctx->extradata, s->avctx->extradata_size); |
70 |
|
71 |
put_bits(&pb, 5, s->avctx->time_base.den / s->avctx->time_base.num); //yes 29.97 -> 29 |
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 |
|
104 |
#if 0 /* unused, remove? */
|
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 |
}
|
115 |
#endif
|
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 |
|
136 |
assert(s->flipflop_rounding); |
137 |
|
138 |
if (s->pict_type == I_TYPE) {
|
139 |
assert(s->no_rounding==1);
|
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 |
|
187 |
s->inter_intra_pred= 0;//(s->width*s->height < 320*240 && s->bit_rate<=II_BITRATE); |
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;
|
204 |
uint8_t *coded_block; |
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 */
|
222 |
h263_pred_motion(s, 0, 0, &pred_x, &pred_y); |
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, |
249 |
ff_msmp4_mb_i_table[coded_cbp][1], ff_msmp4_mb_i_table[coded_cbp][0]); |
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 |
} |
267 |
#endif //CONFIG_ENCODERS |
268 |
|
269 |
static void parse_mb_skip(Wmv2Context * w){ |
270 |
int mb_x, mb_y;
|
271 |
MpegEncContext * const s= &w->s;
|
272 |
uint32_t * const mb_type= s->current_picture_ptr->mb_type;
|
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++){ |
279 |
mb_type[mb_y*s->mb_stride + mb_x]= MB_TYPE_16x16 | MB_TYPE_L0; |
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++){ |
286 |
mb_type[mb_y*s->mb_stride + mb_x]= (get_bits1(&s->gb) ? MB_TYPE_SKIP : 0) | MB_TYPE_16x16 | MB_TYPE_L0;
|
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++){ |
294 |
mb_type[mb_y*s->mb_stride + mb_x]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0; |
295 |
} |
296 |
}else{
|
297 |
for(mb_x=0; mb_x<s->mb_width; mb_x++){ |
298 |
mb_type[mb_y*s->mb_stride + mb_x]= (get_bits1(&s->gb) ? MB_TYPE_SKIP : 0) | MB_TYPE_16x16 | MB_TYPE_L0;
|
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++){ |
307 |
mb_type[mb_y*s->mb_stride + mb_x]= MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0; |
308 |
} |
309 |
}else{
|
310 |
for(mb_y=0; mb_y<s->mb_height; mb_y++){ |
311 |
mb_type[mb_y*s->mb_stride + mb_x]= (get_bits1(&s->gb) ? MB_TYPE_SKIP : 0) | MB_TYPE_16x16 | MB_TYPE_L0;
|
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 |
|
327 |
init_get_bits(&gb, s->avctx->extradata, s->avctx->extradata_size*8);
|
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; |
340 |
|
341 |
s->slice_height = s->mb_height / code; |
342 |
|
343 |
if(s->avctx->debug&FF_DEBUG_PICT_INFO){
|
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",
|
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); |
347 |
} |
348 |
return 0; |
349 |
} |
350 |
|
351 |
int ff_wmv2_decode_picture_header(MpegEncContext * s)
|
352 |
{ |
353 |
Wmv2Context * const w= (Wmv2Context*)s;
|
354 |
int code;
|
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);
|
372 |
av_log(s->avctx, AV_LOG_DEBUG, "I7:%X/\n", code);
|
373 |
} |
374 |
s->chroma_qscale= s->qscale = get_bits(&s->gb, 5);
|
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;
|
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){
|
403 |
av_log(s->avctx, AV_LOG_DEBUG, "qscale:%d rlc:%d rl:%d dc:%d mbrl:%d j_type:%d \n",
|
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 |
|
449 |
s->inter_intra_pred= 0;//(s->width*s->height < 320*240 && s->bit_rate<=II_BITRATE); |
450 |
s->no_rounding ^= 1;
|
451 |
|
452 |
if(s->avctx->debug&FF_DEBUG_PICT_INFO){
|
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",
|
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){
|
477 |
av_log(s->avctx, AV_LOG_ERROR, "J-type picture is not supported\n");
|
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;
|
505 |
int16_t *A, *B, *C, *mot_val; |
506 |
|
507 |
wrap = s->b8_stride; |
508 |
xy = s->block_index[0];
|
509 |
|
510 |
mot_val = s->current_picture.motion_val[0][xy];
|
511 |
|
512 |
A = s->current_picture.motion_val[0][xy - 1]; |
513 |
B = s->current_picture.motion_val[0][xy - wrap];
|
514 |
C = s->current_picture.motion_val[0][xy + 2 - wrap]; |
515 |
|
516 |
if(s->mb_x && !s->first_slice_line && !s->mspel && w->top_left_mv_flag)
|
517 |
diff= FFMAX(ABS(A[0] - B[0]), ABS(A[1] - B[1])); |
518 |
else
|
519 |
diff=0;
|
520 |
|
521 |
if(diff >= 8) |
522 |
type= get_bits1(&s->gb); |
523 |
else
|
524 |
type= 2;
|
525 |
|
526 |
if(type == 0){ |
527 |
*px= A[0];
|
528 |
*py= A[1];
|
529 |
}else if(type == 1){ |
530 |
*px= B[0];
|
531 |
*py= B[1];
|
532 |
}else{
|
533 |
/* special case for first (slice) line */
|
534 |
if (s->first_slice_line) {
|
535 |
*px = A[0];
|
536 |
*py = A[1];
|
537 |
} else {
|
538 |
*px = mid_pred(A[0], B[0], C[0]); |
539 |
*py = mid_pred(A[1], B[1], C[1]); |
540 |
} |
541 |
} |
542 |
|
543 |
return mot_val;
|
544 |
} |
545 |
|
546 |
static inline int wmv2_decode_inter_block(Wmv2Context *w, DCTELEM *block, int n, int cbp){ |
547 |
MpegEncContext * const s= &w->s;
|
548 |
static const int sub_cbp_table[3]= {2,3,1}; |
549 |
int sub_cbp;
|
550 |
|
551 |
if(!cbp){
|
552 |
s->block_last_index[n] = -1;
|
553 |
|
554 |
return 0; |
555 |
} |
556 |
|
557 |
if(w->per_block_abt)
|
558 |
w->abt_type= decode012(&s->gb); |
559 |
#if 0
|
560 |
if(w->per_block_abt)
|
561 |
printf("B%d", w->abt_type);
|
562 |
#endif
|
563 |
w->abt_type_table[n]= w->abt_type; |
564 |
|
565 |
if(w->abt_type){
|
566 |
// const uint8_t *scantable= w->abt_scantable[w->abt_type-1].permutated;
|
567 |
const uint8_t *scantable= w->abt_scantable[w->abt_type-1].scantable; |
568 |
// const uint8_t *scantable= w->abt_type-1 ? w->abt_scantable[1].permutated : w->abt_scantable[0].scantable;
|
569 |
|
570 |
sub_cbp= sub_cbp_table[ decode012(&s->gb) ]; |
571 |
// printf("S%d", sub_cbp);
|
572 |
|
573 |
if(sub_cbp&1){ |
574 |
if (msmpeg4_decode_block(s, block, n, 1, scantable) < 0) |
575 |
return -1; |
576 |
} |
577 |
|
578 |
if(sub_cbp&2){ |
579 |
if (msmpeg4_decode_block(s, w->abt_block2[n], n, 1, scantable) < 0) |
580 |
return -1; |
581 |
} |
582 |
s->block_last_index[n] = 63;
|
583 |
|
584 |
return 0; |
585 |
}else{
|
586 |
return msmpeg4_decode_block(s, block, n, 1, s->inter_scantable.permutated); |
587 |
} |
588 |
} |
589 |
|
590 |
static void wmv2_add_block(Wmv2Context *w, DCTELEM *block1, uint8_t *dst, int stride, int n){ |
591 |
MpegEncContext * const s= &w->s;
|
592 |
|
593 |
if (s->block_last_index[n] >= 0) { |
594 |
switch(w->abt_type_table[n]){
|
595 |
case 0: |
596 |
s->dsp.idct_add (dst, stride, block1); |
597 |
break;
|
598 |
case 1: |
599 |
simple_idct84_add(dst , stride, block1); |
600 |
simple_idct84_add(dst + 4*stride, stride, w->abt_block2[n]);
|
601 |
memset(w->abt_block2[n], 0, 64*sizeof(DCTELEM)); |
602 |
break;
|
603 |
case 2: |
604 |
simple_idct48_add(dst , stride, block1); |
605 |
simple_idct48_add(dst + 4 , stride, w->abt_block2[n]);
|
606 |
memset(w->abt_block2[n], 0, 64*sizeof(DCTELEM)); |
607 |
break;
|
608 |
default:
|
609 |
av_log(s->avctx, AV_LOG_ERROR, "internal error in WMV2 abt\n");
|
610 |
} |
611 |
} |
612 |
} |
613 |
|
614 |
void ff_wmv2_add_mb(MpegEncContext *s, DCTELEM block1[6][64], uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr){ |
615 |
Wmv2Context * const w= (Wmv2Context*)s;
|
616 |
|
617 |
wmv2_add_block(w, block1[0], dest_y , s->linesize, 0); |
618 |
wmv2_add_block(w, block1[1], dest_y + 8 , s->linesize, 1); |
619 |
wmv2_add_block(w, block1[2], dest_y + 8*s->linesize, s->linesize, 2); |
620 |
wmv2_add_block(w, block1[3], dest_y + 8 + 8*s->linesize, s->linesize, 3); |
621 |
|
622 |
if(s->flags&CODEC_FLAG_GRAY) return; |
623 |
|
624 |
wmv2_add_block(w, block1[4], dest_cb , s->uvlinesize, 4); |
625 |
wmv2_add_block(w, block1[5], dest_cr , s->uvlinesize, 5); |
626 |
} |
627 |
|
628 |
void ff_mspel_motion(MpegEncContext *s,
|
629 |
uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr, |
630 |
uint8_t **ref_picture, op_pixels_func (*pix_op)[4],
|
631 |
int motion_x, int motion_y, int h) |
632 |
{ |
633 |
Wmv2Context * const w= (Wmv2Context*)s;
|
634 |
uint8_t *ptr; |
635 |
int dxy, offset, mx, my, src_x, src_y, v_edge_pos, linesize, uvlinesize;
|
636 |
int emu=0; |
637 |
|
638 |
dxy = ((motion_y & 1) << 1) | (motion_x & 1); |
639 |
dxy = 2*dxy + w->hshift;
|
640 |
src_x = s->mb_x * 16 + (motion_x >> 1); |
641 |
src_y = s->mb_y * 16 + (motion_y >> 1); |
642 |
|
643 |
/* WARNING: do no forget half pels */
|
644 |
v_edge_pos = s->v_edge_pos; |
645 |
src_x = clip(src_x, -16, s->width);
|
646 |
src_y = clip(src_y, -16, s->height);
|
647 |
linesize = s->linesize; |
648 |
uvlinesize = s->uvlinesize; |
649 |
ptr = ref_picture[0] + (src_y * linesize) + src_x;
|
650 |
|
651 |
if(s->flags&CODEC_FLAG_EMU_EDGE){
|
652 |
if(src_x<1 || src_y<1 || src_x + 17 >= s->h_edge_pos |
653 |
|| src_y + h+1 >= v_edge_pos){
|
654 |
ff_emulated_edge_mc(s->edge_emu_buffer, ptr - 1 - s->linesize, s->linesize, 19, 19, |
655 |
src_x-1, src_y-1, s->h_edge_pos, s->v_edge_pos); |
656 |
ptr= s->edge_emu_buffer + 1 + s->linesize;
|
657 |
emu=1;
|
658 |
} |
659 |
} |
660 |
|
661 |
s->dsp.put_mspel_pixels_tab[dxy](dest_y , ptr , linesize); |
662 |
s->dsp.put_mspel_pixels_tab[dxy](dest_y+8 , ptr+8 , linesize); |
663 |
s->dsp.put_mspel_pixels_tab[dxy](dest_y +8*linesize, ptr +8*linesize, linesize); |
664 |
s->dsp.put_mspel_pixels_tab[dxy](dest_y+8+8*linesize, ptr+8+8*linesize, linesize); |
665 |
|
666 |
if(s->flags&CODEC_FLAG_GRAY) return; |
667 |
|
668 |
if (s->out_format == FMT_H263) {
|
669 |
dxy = 0;
|
670 |
if ((motion_x & 3) != 0) |
671 |
dxy |= 1;
|
672 |
if ((motion_y & 3) != 0) |
673 |
dxy |= 2;
|
674 |
mx = motion_x >> 2;
|
675 |
my = motion_y >> 2;
|
676 |
} else {
|
677 |
mx = motion_x / 2;
|
678 |
my = motion_y / 2;
|
679 |
dxy = ((my & 1) << 1) | (mx & 1); |
680 |
mx >>= 1;
|
681 |
my >>= 1;
|
682 |
} |
683 |
|
684 |
src_x = s->mb_x * 8 + mx;
|
685 |
src_y = s->mb_y * 8 + my;
|
686 |
src_x = clip(src_x, -8, s->width >> 1); |
687 |
if (src_x == (s->width >> 1)) |
688 |
dxy &= ~1;
|
689 |
src_y = clip(src_y, -8, s->height >> 1); |
690 |
if (src_y == (s->height >> 1)) |
691 |
dxy &= ~2;
|
692 |
offset = (src_y * uvlinesize) + src_x; |
693 |
ptr = ref_picture[1] + offset;
|
694 |
if(emu){
|
695 |
ff_emulated_edge_mc(s->edge_emu_buffer, ptr, s->uvlinesize, 9, 9, |
696 |
src_x, src_y, s->h_edge_pos>>1, s->v_edge_pos>>1); |
697 |
ptr= s->edge_emu_buffer; |
698 |
} |
699 |
pix_op[1][dxy](dest_cb, ptr, uvlinesize, h >> 1); |
700 |
|
701 |
ptr = ref_picture[2] + offset;
|
702 |
if(emu){
|
703 |
ff_emulated_edge_mc(s->edge_emu_buffer, ptr, s->uvlinesize, 9, 9, |
704 |
src_x, src_y, s->h_edge_pos>>1, s->v_edge_pos>>1); |
705 |
ptr= s->edge_emu_buffer; |
706 |
} |
707 |
pix_op[1][dxy](dest_cr, ptr, uvlinesize, h >> 1); |
708 |
} |
709 |
|
710 |
|
711 |
static int wmv2_decode_mb(MpegEncContext *s, DCTELEM block[6][64]) |
712 |
{ |
713 |
Wmv2Context * const w= (Wmv2Context*)s;
|
714 |
int cbp, code, i;
|
715 |
uint8_t *coded_val; |
716 |
|
717 |
if(w->j_type) return 0; |
718 |
|
719 |
if (s->pict_type == P_TYPE) {
|
720 |
if(IS_SKIP(s->current_picture.mb_type[s->mb_y * s->mb_stride + s->mb_x])){
|
721 |
/* skip mb */
|
722 |
s->mb_intra = 0;
|
723 |
for(i=0;i<6;i++) |
724 |
s->block_last_index[i] = -1;
|
725 |
s->mv_dir = MV_DIR_FORWARD; |
726 |
s->mv_type = MV_TYPE_16X16; |
727 |
s->mv[0][0][0] = 0; |
728 |
s->mv[0][0][1] = 0; |
729 |
s->mb_skipped = 1;
|
730 |
w->hshift=0;
|
731 |
return 0; |
732 |
} |
733 |
|
734 |
code = get_vlc2(&s->gb, mb_non_intra_vlc[w->cbp_table_index].table, MB_NON_INTRA_VLC_BITS, 3);
|
735 |
if (code < 0) |
736 |
return -1; |
737 |
s->mb_intra = (~code & 0x40) >> 6; |
738 |
|
739 |
cbp = code & 0x3f;
|
740 |
} else {
|
741 |
s->mb_intra = 1;
|
742 |
code = get_vlc2(&s->gb, ff_msmp4_mb_i_vlc.table, MB_INTRA_VLC_BITS, 2);
|
743 |
if (code < 0){ |
744 |
av_log(s->avctx, AV_LOG_ERROR, "II-cbp illegal at %d %d\n", s->mb_x, s->mb_y);
|
745 |
return -1; |
746 |
} |
747 |
/* predict coded block pattern */
|
748 |
cbp = 0;
|
749 |
for(i=0;i<6;i++) { |
750 |
int val = ((code >> (5 - i)) & 1); |
751 |
if (i < 4) { |
752 |
int pred = coded_block_pred(s, i, &coded_val);
|
753 |
val = val ^ pred; |
754 |
*coded_val = val; |
755 |
} |
756 |
cbp |= val << (5 - i);
|
757 |
} |
758 |
} |
759 |
|
760 |
if (!s->mb_intra) {
|
761 |
int mx, my;
|
762 |
//printf("P at %d %d\n", s->mb_x, s->mb_y);
|
763 |
wmv2_pred_motion(w, &mx, &my); |
764 |
|
765 |
if(cbp){
|
766 |
s->dsp.clear_blocks(s->block[0]);
|
767 |
if(s->per_mb_rl_table){
|
768 |
s->rl_table_index = decode012(&s->gb); |
769 |
s->rl_chroma_table_index = s->rl_table_index; |
770 |
} |
771 |
|
772 |
if(w->abt_flag && w->per_mb_abt){
|
773 |
w->per_block_abt= get_bits1(&s->gb); |
774 |
if(!w->per_block_abt)
|
775 |
w->abt_type= decode012(&s->gb); |
776 |
}else
|
777 |
w->per_block_abt=0;
|
778 |
} |
779 |
|
780 |
if (wmv2_decode_motion(w, &mx, &my) < 0) |
781 |
return -1; |
782 |
|
783 |
s->mv_dir = MV_DIR_FORWARD; |
784 |
s->mv_type = MV_TYPE_16X16; |
785 |
s->mv[0][0][0] = mx; |
786 |
s->mv[0][0][1] = my; |
787 |
|
788 |
for (i = 0; i < 6; i++) { |
789 |
if (wmv2_decode_inter_block(w, block[i], i, (cbp >> (5 - i)) & 1) < 0) |
790 |
{ |
791 |
av_log(s->avctx, AV_LOG_ERROR, "\nerror while decoding inter block: %d x %d (%d)\n", s->mb_x, s->mb_y, i);
|
792 |
return -1; |
793 |
} |
794 |
} |
795 |
} else {
|
796 |
//if(s->pict_type==P_TYPE)
|
797 |
// printf("%d%d ", s->inter_intra_pred, cbp);
|
798 |
//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));
|
799 |
s->ac_pred = get_bits1(&s->gb); |
800 |
if(s->inter_intra_pred){
|
801 |
s->h263_aic_dir= get_vlc2(&s->gb, inter_intra_vlc.table, INTER_INTRA_VLC_BITS, 1);
|
802 |
// printf("%d%d %d %d/", s->ac_pred, s->h263_aic_dir, s->mb_x, s->mb_y);
|
803 |
} |
804 |
if(s->per_mb_rl_table && cbp){
|
805 |
s->rl_table_index = decode012(&s->gb); |
806 |
s->rl_chroma_table_index = s->rl_table_index; |
807 |
} |
808 |
|
809 |
s->dsp.clear_blocks(s->block[0]);
|
810 |
for (i = 0; i < 6; i++) { |
811 |
if (msmpeg4_decode_block(s, block[i], i, (cbp >> (5 - i)) & 1, NULL) < 0) |
812 |
{ |
813 |
av_log(s->avctx, AV_LOG_ERROR, "\nerror while decoding intra block: %d x %d (%d)\n", s->mb_x, s->mb_y, i);
|
814 |
return -1; |
815 |
} |
816 |
} |
817 |
} |
818 |
|
819 |
return 0; |
820 |
} |
821 |
|
822 |
static int wmv2_decode_init(AVCodecContext *avctx){ |
823 |
Wmv2Context * const w= avctx->priv_data;
|
824 |
|
825 |
if(ff_h263_decode_init(avctx) < 0) |
826 |
return -1; |
827 |
|
828 |
wmv2_common_init(w); |
829 |
|
830 |
return 0; |
831 |
} |
832 |
|
833 |
AVCodec wmv2_decoder = { |
834 |
"wmv2",
|
835 |
CODEC_TYPE_VIDEO, |
836 |
CODEC_ID_WMV2, |
837 |
sizeof(Wmv2Context),
|
838 |
wmv2_decode_init, |
839 |
NULL,
|
840 |
ff_h263_decode_end, |
841 |
ff_h263_decode_frame, |
842 |
CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1, |
843 |
}; |
844 |
|
845 |
#ifdef CONFIG_ENCODERS
|
846 |
AVCodec wmv2_encoder = { |
847 |
"wmv2",
|
848 |
CODEC_TYPE_VIDEO, |
849 |
CODEC_ID_WMV2, |
850 |
sizeof(Wmv2Context),
|
851 |
wmv2_encode_init, |
852 |
MPV_encode_picture, |
853 |
MPV_encode_end, |
854 |
}; |
855 |
#endif
|