3daa22bb78cf760df8a0206a1203b86afaf83df8
[libav.git] / libavcodec / h263.c
1 /*
2 * H263/MPEG4 backend for ffmpeg encoder and decoder
3 * Copyright (c) 2000,2001 Fabrice Bellard.
4 * H263+ support.
5 * Copyright (c) 2001 Juan J. Sierralta P.
6 *
7 * This library is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2 of the License, or (at your option) any later version.
11 *
12 * This library is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
16 *
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with this library; if not, write to the Free Software
19 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
20 *
21 * ac prediction encoding & b-frame support by Michael Niedermayer <michaelni@gmx.at>
22 */
23
24 //#define DEBUG
25 #include "common.h"
26 #include "dsputil.h"
27 #include "avcodec.h"
28 #include "mpegvideo.h"
29 #include "h263data.h"
30 #include "mpeg4data.h"
31
32 //rounded divison & shift
33 #define RSHIFT(a,b) ((a) > 0 ? ((a) + (1<<((b)-1)))>>(b) : ((a) + (1<<((b)-1))-1)>>(b))
34
35 #define PRINT_MB_TYPE(a) {}
36 //#define PRINT_MB_TYPE(a) printf(a)
37
38 static void h263_encode_block(MpegEncContext * s, DCTELEM * block,
39 int n);
40 static void h263_encode_motion(MpegEncContext * s, int val, int fcode);
41 static void h263p_encode_umotion(MpegEncContext * s, int val);
42 static void mpeg4_encode_block(MpegEncContext * s, DCTELEM * block,
43 int n, int dc, UINT8 *scan_table,
44 PutBitContext *dc_pb, PutBitContext *ac_pb);
45 static int h263_decode_motion(MpegEncContext * s, int pred, int fcode);
46 static int h263p_decode_umotion(MpegEncContext * s, int pred);
47 static int h263_decode_block(MpegEncContext * s, DCTELEM * block,
48 int n, int coded);
49 static inline int mpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr);
50 static inline int mpeg4_decode_block(MpegEncContext * s, DCTELEM * block,
51 int n, int coded);
52 static int h263_pred_dc(MpegEncContext * s, int n, UINT16 **dc_val_ptr);
53 static void mpeg4_inv_pred_ac(MpegEncContext * s, INT16 *block, int n,
54 int dir);
55 static void mpeg4_decode_sprite_trajectory(MpegEncContext * s);
56
57 extern UINT32 inverse[256];
58
59 static UINT16 mv_penalty[MAX_FCODE+1][MAX_MV*2+1];
60 static UINT8 fcode_tab[MAX_MV*2+1];
61 static UINT8 umv_fcode_tab[MAX_MV*2+1];
62
63 static UINT16 uni_DCtab_lum [512][2];
64 static UINT16 uni_DCtab_chrom[512][2];
65
66 int h263_get_picture_format(int width, int height)
67 {
68 int format;
69
70 if (width == 128 && height == 96)
71 format = 1;
72 else if (width == 176 && height == 144)
73 format = 2;
74 else if (width == 352 && height == 288)
75 format = 3;
76 else if (width == 704 && height == 576)
77 format = 4;
78 else if (width == 1408 && height == 1152)
79 format = 5;
80 else
81 format = 7;
82 return format;
83 }
84
85 void h263_encode_picture_header(MpegEncContext * s, int picture_number)
86 {
87 int format;
88
89 align_put_bits(&s->pb);
90
91 /* Update the pointer to last GOB */
92 s->ptr_lastgob = pbBufPtr(&s->pb);
93 s->gob_number = 0;
94
95 put_bits(&s->pb, 22, 0x20); /* PSC */
96 put_bits(&s->pb, 8, (((INT64)s->picture_number * 30 * FRAME_RATE_BASE) /
97 s->frame_rate) & 0xff);
98
99 put_bits(&s->pb, 1, 1); /* marker */
100 put_bits(&s->pb, 1, 0); /* h263 id */
101 put_bits(&s->pb, 1, 0); /* split screen off */
102 put_bits(&s->pb, 1, 0); /* camera off */
103 put_bits(&s->pb, 1, 0); /* freeze picture release off */
104
105 format = h263_get_picture_format(s->width, s->height);
106 if (!s->h263_plus) {
107 /* H.263v1 */
108 put_bits(&s->pb, 3, format);
109 put_bits(&s->pb, 1, (s->pict_type == P_TYPE));
110 /* By now UMV IS DISABLED ON H.263v1, since the restrictions
111 of H.263v1 UMV implies to check the predicted MV after
112 calculation of the current MB to see if we're on the limits */
113 put_bits(&s->pb, 1, 0); /* unrestricted motion vector: off */
114 put_bits(&s->pb, 1, 0); /* SAC: off */
115 put_bits(&s->pb, 1, 0); /* advanced prediction mode: off */
116 put_bits(&s->pb, 1, 0); /* not PB frame */
117 put_bits(&s->pb, 5, s->qscale);
118 put_bits(&s->pb, 1, 0); /* Continuous Presence Multipoint mode: off */
119 } else {
120 /* H.263v2 */
121 /* H.263 Plus PTYPE */
122 put_bits(&s->pb, 3, 7);
123 put_bits(&s->pb,3,1); /* Update Full Extended PTYPE */
124 if (format == 7)
125 put_bits(&s->pb,3,6); /* Custom Source Format */
126 else
127 put_bits(&s->pb, 3, format);
128
129 put_bits(&s->pb,1,0); /* Custom PCF: off */
130 s->umvplus = (s->pict_type == P_TYPE) && s->unrestricted_mv;
131 put_bits(&s->pb, 1, s->umvplus); /* Unrestricted Motion Vector */
132 put_bits(&s->pb,1,0); /* SAC: off */
133 put_bits(&s->pb,1,0); /* Advanced Prediction Mode: off */
134 put_bits(&s->pb,1,s->h263_aic); /* Advanced Intra Coding */
135 put_bits(&s->pb,1,0); /* Deblocking Filter: off */
136 put_bits(&s->pb,1,0); /* Slice Structured: off */
137 put_bits(&s->pb,1,0); /* Reference Picture Selection: off */
138 put_bits(&s->pb,1,0); /* Independent Segment Decoding: off */
139 put_bits(&s->pb,1,0); /* Alternative Inter VLC: off */
140 put_bits(&s->pb,1,0); /* Modified Quantization: off */
141 put_bits(&s->pb,1,1); /* "1" to prevent start code emulation */
142 put_bits(&s->pb,3,0); /* Reserved */
143
144 put_bits(&s->pb, 3, s->pict_type == P_TYPE);
145
146 put_bits(&s->pb,1,0); /* Reference Picture Resampling: off */
147 put_bits(&s->pb,1,0); /* Reduced-Resolution Update: off */
148 if (s->pict_type == I_TYPE)
149 s->no_rounding = 0;
150 else
151 s->no_rounding ^= 1;
152 put_bits(&s->pb,1,s->no_rounding); /* Rounding Type */
153 put_bits(&s->pb,2,0); /* Reserved */
154 put_bits(&s->pb,1,1); /* "1" to prevent start code emulation */
155
156 /* This should be here if PLUSPTYPE */
157 put_bits(&s->pb, 1, 0); /* Continuous Presence Multipoint mode: off */
158
159 if (format == 7) {
160 /* Custom Picture Format (CPFMT) */
161
162 if (s->aspect_ratio_info)
163 put_bits(&s->pb,4,s->aspect_ratio_info);
164 else
165 put_bits(&s->pb,4,2); /* Aspect ratio: CIF 12:11 (4:3) picture */
166 put_bits(&s->pb,9,(s->width >> 2) - 1);
167 put_bits(&s->pb,1,1); /* "1" to prevent start code emulation */
168 put_bits(&s->pb,9,(s->height >> 2));
169 }
170
171 /* Unlimited Unrestricted Motion Vectors Indicator (UUI) */
172 if (s->umvplus)
173 put_bits(&s->pb,1,1); /* Limited according tables of Annex D */
174 put_bits(&s->pb, 5, s->qscale);
175 }
176
177 put_bits(&s->pb, 1, 0); /* no PEI */
178
179 if(s->h263_aic){
180 s->y_dc_scale_table=
181 s->c_dc_scale_table= h263_aic_dc_scale_table;
182 }else{
183 s->y_dc_scale_table=
184 s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
185 }
186 }
187
188 int h263_encode_gob_header(MpegEncContext * s, int mb_line)
189 {
190 int pdif=0;
191
192 /* Check to see if we need to put a new GBSC */
193 /* for RTP packetization */
194 if (s->rtp_mode) {
195 pdif = pbBufPtr(&s->pb) - s->ptr_lastgob;
196 if (pdif >= s->rtp_payload_size) {
197 /* Bad luck, packet must be cut before */
198 align_put_bits(&s->pb);
199 flush_put_bits(&s->pb);
200 /* Call the RTP callback to send the last GOB */
201 if (s->rtp_callback) {
202 pdif = pbBufPtr(&s->pb) - s->ptr_lastgob;
203 s->rtp_callback(s->ptr_lastgob, pdif, s->gob_number);
204 }
205 s->ptr_lastgob = pbBufPtr(&s->pb);
206 put_bits(&s->pb, 17, 1); /* GBSC */
207 s->gob_number = mb_line / s->gob_index;
208 put_bits(&s->pb, 5, s->gob_number); /* GN */
209 put_bits(&s->pb, 2, s->pict_type == I_TYPE); /* GFID */
210 put_bits(&s->pb, 5, s->qscale); /* GQUANT */
211 //fprintf(stderr,"\nGOB: %2d size: %d", s->gob_number - 1, pdif);
212 return pdif;
213 } else if (pdif + s->mb_line_avgsize >= s->rtp_payload_size) {
214 /* Cut the packet before we can't */
215 align_put_bits(&s->pb);
216 flush_put_bits(&s->pb);
217 /* Call the RTP callback to send the last GOB */
218 if (s->rtp_callback) {
219 pdif = pbBufPtr(&s->pb) - s->ptr_lastgob;
220 s->rtp_callback(s->ptr_lastgob, pdif, s->gob_number);
221 }
222 s->ptr_lastgob = pbBufPtr(&s->pb);
223 put_bits(&s->pb, 17, 1); /* GBSC */
224 s->gob_number = mb_line / s->gob_index;
225 put_bits(&s->pb, 5, s->gob_number); /* GN */
226 put_bits(&s->pb, 2, s->pict_type == I_TYPE); /* GFID */
227 put_bits(&s->pb, 5, s->qscale); /* GQUANT */
228 //fprintf(stderr,"\nGOB: %2d size: %d", s->gob_number - 1, pdif);
229 return pdif;
230 }
231 }
232 return 0;
233 }
234
235 static inline int decide_ac_pred(MpegEncContext * s, DCTELEM block[6][64], int dir[6])
236 {
237 int score0=0, score1=0;
238 int i, n;
239
240 for(n=0; n<6; n++){
241 INT16 *ac_val, *ac_val1;
242
243 ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
244 ac_val1= ac_val;
245 if(dir[n]){
246 ac_val-= s->block_wrap[n]*16;
247 for(i=1; i<8; i++){
248 const int level= block[n][block_permute_op(i )];
249 score0+= ABS(level);
250 score1+= ABS(level - ac_val[i+8]);
251 ac_val1[i ]= block[n][block_permute_op(i<<3)];
252 ac_val1[i+8]= level;
253 }
254 }else{
255 ac_val-= 16;
256 for(i=1; i<8; i++){
257 const int level= block[n][block_permute_op(i<<3)];
258 score0+= ABS(level);
259 score1+= ABS(level - ac_val[i]);
260 ac_val1[i ]= level;
261 ac_val1[i+8]= block[n][block_permute_op(i )];
262 }
263 }
264 }
265
266 return score0 > score1 ? 1 : 0;
267 }
268
269 void mpeg4_encode_mb(MpegEncContext * s,
270 DCTELEM block[6][64],
271 int motion_x, int motion_y)
272 {
273 int cbpc, cbpy, i, pred_x, pred_y;
274 int bits;
275 PutBitContext * const pb2 = s->data_partitioning ? &s->pb2 : &s->pb;
276 PutBitContext * const tex_pb = s->data_partitioning && s->pict_type!=B_TYPE ? &s->tex_pb : &s->pb;
277 PutBitContext * const dc_pb = s->data_partitioning && s->pict_type!=I_TYPE ? &s->pb2 : &s->pb;
278 const int interleaved_stats= (s->flags&CODEC_FLAG_PASS1) && !s->data_partitioning ? 1 : 0;
279
280 // printf("**mb x=%d y=%d\n", s->mb_x, s->mb_y);
281 if (!s->mb_intra) {
282 /* compute cbp */
283 int cbp = 0;
284 for (i = 0; i < 6; i++) {
285 if (s->block_last_index[i] >= 0)
286 cbp |= 1 << (5 - i);
287 }
288
289 if(s->pict_type==B_TYPE){
290 static const int mb_type_table[8]= {-1, 2, 3, 1,-1,-1,-1, 0}; /* convert from mv_dir to type */
291 int mb_type= mb_type_table[s->mv_dir];
292
293 if(s->mb_x==0){
294 s->last_mv[0][0][0]=
295 s->last_mv[0][0][1]=
296 s->last_mv[1][0][0]=
297 s->last_mv[1][0][1]= 0;
298 }
299
300 /* nothing to do if this MB was skiped in the next P Frame */
301 if(s->mbskip_table[s->mb_y * s->mb_width + s->mb_x]){
302 s->skip_count++;
303 s->mv[0][0][0]=
304 s->mv[0][0][1]=
305 s->mv[1][0][0]=
306 s->mv[1][0][1]= 0;
307 s->mv_dir= MV_DIR_FORWARD; //doesnt matter
308 return;
309 }
310
311 if ((cbp | motion_x | motion_y | mb_type) ==0) {
312 /* direct MB with MV={0,0} */
313 put_bits(&s->pb, 1, 1); /* mb not coded modb1=1 */
314
315 if(interleaved_stats){
316 s->misc_bits++;
317 s->last_bits++;
318 }
319 s->skip_count++;
320 return;
321 }
322 put_bits(&s->pb, 1, 0); /* mb coded modb1=0 */
323 put_bits(&s->pb, 1, cbp ? 0 : 1); /* modb2 */ //FIXME merge
324 put_bits(&s->pb, mb_type+1, 1); // this table is so simple that we dont need it :)
325 if(cbp) put_bits(&s->pb, 6, cbp);
326
327 if(cbp && mb_type)
328 put_bits(&s->pb, 1, 0); /* no q-scale change */
329
330 if(interleaved_stats){
331 bits= get_bit_count(&s->pb);
332 s->misc_bits+= bits - s->last_bits;
333 s->last_bits=bits;
334 }
335
336 switch(mb_type)
337 {
338 case 0: /* direct */
339 h263_encode_motion(s, motion_x, 1);
340 h263_encode_motion(s, motion_y, 1);
341 break;
342 case 1: /* bidir */
343 h263_encode_motion(s, s->mv[0][0][0] - s->last_mv[0][0][0], s->f_code);
344 h263_encode_motion(s, s->mv[0][0][1] - s->last_mv[0][0][1], s->f_code);
345 h263_encode_motion(s, s->mv[1][0][0] - s->last_mv[1][0][0], s->b_code);
346 h263_encode_motion(s, s->mv[1][0][1] - s->last_mv[1][0][1], s->b_code);
347 s->last_mv[0][0][0]= s->mv[0][0][0];
348 s->last_mv[0][0][1]= s->mv[0][0][1];
349 s->last_mv[1][0][0]= s->mv[1][0][0];
350 s->last_mv[1][0][1]= s->mv[1][0][1];
351 break;
352 case 2: /* backward */
353 h263_encode_motion(s, motion_x - s->last_mv[1][0][0], s->b_code);
354 h263_encode_motion(s, motion_y - s->last_mv[1][0][1], s->b_code);
355 s->last_mv[1][0][0]= motion_x;
356 s->last_mv[1][0][1]= motion_y;
357 break;
358 case 3: /* forward */
359 h263_encode_motion(s, motion_x - s->last_mv[0][0][0], s->f_code);
360 h263_encode_motion(s, motion_y - s->last_mv[0][0][1], s->f_code);
361 s->last_mv[0][0][0]= motion_x;
362 s->last_mv[0][0][1]= motion_y;
363 break;
364 default:
365 printf("unknown mb type\n");
366 return;
367 }
368
369 if(interleaved_stats){
370 bits= get_bit_count(&s->pb);
371 s->mv_bits+= bits - s->last_bits;
372 s->last_bits=bits;
373 }
374
375 /* encode each block */
376 for (i = 0; i < 6; i++) {
377 mpeg4_encode_block(s, block[i], i, 0, zigzag_direct, NULL, &s->pb);
378 }
379
380 if(interleaved_stats){
381 bits= get_bit_count(&s->pb);
382 s->p_tex_bits+= bits - s->last_bits;
383 s->last_bits=bits;
384 }
385 }else{ /* s->pict_type==B_TYPE */
386 if ((cbp | motion_x | motion_y) == 0 && s->mv_type==MV_TYPE_16X16) {
387 /* check if the B frames can skip it too, as we must skip it if we skip here
388 why didnt they just compress the skip-mb bits instead of reusing them ?! */
389 if(s->max_b_frames>0){
390 int i;
391 int x,y, offset;
392 uint8_t *p_pic;
393
394 x= s->mb_x*16;
395 y= s->mb_y*16;
396 if(x+16 > s->width) x= s->width-16;
397 if(y+16 > s->height) y= s->height-16;
398
399 offset= x + y*s->linesize;
400 p_pic= s->new_picture[0] + offset;
401
402 s->mb_skiped=1;
403 for(i=0; i<s->max_b_frames; i++){
404 uint8_t *b_pic;
405 int diff;
406
407 if(s->coded_order[i+1].pict_type!=B_TYPE) break;
408
409 b_pic= s->coded_order[i+1].picture[0] + offset;
410 diff= pix_abs16x16(p_pic, b_pic, s->linesize);
411 if(diff>s->qscale*70){ //FIXME check that 70 is optimal
412 s->mb_skiped=0;
413 break;
414 }
415 }
416 }else
417 s->mb_skiped=1;
418
419 if(s->mb_skiped==1){
420 /* skip macroblock */
421 put_bits(&s->pb, 1, 1);
422
423 if(interleaved_stats){
424 s->misc_bits++;
425 s->last_bits++;
426 }
427 s->skip_count++;
428 return;
429 }
430 }
431
432 put_bits(&s->pb, 1, 0); /* mb coded */
433 if(s->mv_type==MV_TYPE_16X16){
434 cbpc = cbp & 3;
435 put_bits(&s->pb,
436 inter_MCBPC_bits[cbpc],
437 inter_MCBPC_code[cbpc]);
438 cbpy = cbp >> 2;
439 cbpy ^= 0xf;
440 put_bits(pb2, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
441
442 if(interleaved_stats){
443 bits= get_bit_count(&s->pb);
444 s->misc_bits+= bits - s->last_bits;
445 s->last_bits=bits;
446 }
447
448 /* motion vectors: 16x16 mode */
449 h263_pred_motion(s, 0, &pred_x, &pred_y);
450
451 h263_encode_motion(s, motion_x - pred_x, s->f_code);
452 h263_encode_motion(s, motion_y - pred_y, s->f_code);
453 }else{
454 cbpc = (cbp & 3)+16;
455 put_bits(&s->pb,
456 inter_MCBPC_bits[cbpc],
457 inter_MCBPC_code[cbpc]);
458 cbpy = cbp >> 2;
459 cbpy ^= 0xf;
460 put_bits(pb2, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
461
462 if(interleaved_stats){
463 bits= get_bit_count(&s->pb);
464 s->misc_bits+= bits - s->last_bits;
465 s->last_bits=bits;
466 }
467
468 for(i=0; i<4; i++){
469 /* motion vectors: 8x8 mode*/
470 h263_pred_motion(s, i, &pred_x, &pred_y);
471
472 h263_encode_motion(s, s->motion_val[ s->block_index[i] ][0] - pred_x, s->f_code);
473 h263_encode_motion(s, s->motion_val[ s->block_index[i] ][1] - pred_y, s->f_code);
474 }
475 }
476
477 if(interleaved_stats){
478 bits= get_bit_count(&s->pb);
479 s->mv_bits+= bits - s->last_bits;
480 s->last_bits=bits;
481 }
482
483 /* encode each block */
484 for (i = 0; i < 6; i++) {
485 mpeg4_encode_block(s, block[i], i, 0, zigzag_direct, NULL, tex_pb);
486 }
487
488 if(interleaved_stats){
489 bits= get_bit_count(&s->pb);
490 s->p_tex_bits+= bits - s->last_bits;
491 s->last_bits=bits;
492 }
493 s->p_count++;
494 }
495 } else {
496 int cbp;
497 int dc_diff[6]; //dc values with the dc prediction subtracted
498 int dir[6]; //prediction direction
499 int zigzag_last_index[6];
500 UINT8 *scan_table[6];
501
502 for(i=0; i<6; i++){
503 const int level= block[i][0];
504 UINT16 *dc_ptr;
505
506 dc_diff[i]= level - ff_mpeg4_pred_dc(s, i, &dc_ptr, &dir[i]);
507 if (i < 4) {
508 *dc_ptr = level * s->y_dc_scale;
509 } else {
510 *dc_ptr = level * s->c_dc_scale;
511 }
512 }
513
514 s->ac_pred= decide_ac_pred(s, block, dir);
515
516 if(s->ac_pred){
517 for(i=0; i<6; i++){
518 UINT8 *st;
519 int last_index;
520
521 mpeg4_inv_pred_ac(s, block[i], i, dir[i]);
522 if (dir[i]==0) st = ff_alternate_vertical_scan; /* left */
523 else st = ff_alternate_horizontal_scan; /* top */
524
525 for(last_index=63; last_index>=0; last_index--) //FIXME optimize
526 if(block[i][st[last_index]]) break;
527 zigzag_last_index[i]= s->block_last_index[i];
528 s->block_last_index[i]= last_index;
529 scan_table[i]= st;
530 }
531 }else{
532 for(i=0; i<6; i++)
533 scan_table[i]= zigzag_direct;
534 }
535
536 /* compute cbp */
537 cbp = 0;
538 for (i = 0; i < 6; i++) {
539 if (s->block_last_index[i] >= 1)
540 cbp |= 1 << (5 - i);
541 }
542
543 cbpc = cbp & 3;
544 if (s->pict_type == I_TYPE) {
545 put_bits(&s->pb,
546 intra_MCBPC_bits[cbpc],
547 intra_MCBPC_code[cbpc]);
548 } else {
549 put_bits(&s->pb, 1, 0); /* mb coded */
550 put_bits(&s->pb,
551 inter_MCBPC_bits[cbpc + 4],
552 inter_MCBPC_code[cbpc + 4]);
553 }
554 put_bits(pb2, 1, s->ac_pred);
555 cbpy = cbp >> 2;
556 put_bits(pb2, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
557
558 if(interleaved_stats){
559 bits= get_bit_count(&s->pb);
560 s->misc_bits+= bits - s->last_bits;
561 s->last_bits=bits;
562 }
563
564 /* encode each block */
565 for (i = 0; i < 6; i++) {
566 mpeg4_encode_block(s, block[i], i, dc_diff[i], scan_table[i], dc_pb, tex_pb);
567 }
568
569 if(interleaved_stats){
570 bits= get_bit_count(&s->pb);
571 s->i_tex_bits+= bits - s->last_bits;
572 s->last_bits=bits;
573 }
574 s->i_count++;
575
576 /* restore ac coeffs & last_index stuff if we messed them up with the prediction */
577 if(s->ac_pred){
578 for(i=0; i<6; i++){
579 int j;
580 INT16 *ac_val;
581
582 ac_val = s->ac_val[0][0] + s->block_index[i] * 16;
583
584 if(dir[i]){
585 for(j=1; j<8; j++)
586 block[i][block_permute_op(j )]= ac_val[j+8];
587 }else{
588 for(j=1; j<8; j++)
589 block[i][block_permute_op(j<<3)]= ac_val[j ];
590 }
591 s->block_last_index[i]= zigzag_last_index[i];
592 }
593 }
594 }
595 }
596
597 void h263_encode_mb(MpegEncContext * s,
598 DCTELEM block[6][64],
599 int motion_x, int motion_y)
600 {
601 int cbpc, cbpy, i, cbp, pred_x, pred_y;
602 INT16 pred_dc;
603 INT16 rec_intradc[6];
604 UINT16 *dc_ptr[6];
605
606 //printf("**mb x=%d y=%d\n", s->mb_x, s->mb_y);
607 if (!s->mb_intra) {
608 /* compute cbp */
609 cbp = 0;
610 for (i = 0; i < 6; i++) {
611 if (s->block_last_index[i] >= 0)
612 cbp |= 1 << (5 - i);
613 }
614 if ((cbp | motion_x | motion_y) == 0) {
615 /* skip macroblock */
616 put_bits(&s->pb, 1, 1);
617 return;
618 }
619 put_bits(&s->pb, 1, 0); /* mb coded */
620 cbpc = cbp & 3;
621 put_bits(&s->pb,
622 inter_MCBPC_bits[cbpc],
623 inter_MCBPC_code[cbpc]);
624 cbpy = cbp >> 2;
625 cbpy ^= 0xf;
626 put_bits(&s->pb, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
627
628 /* motion vectors: 16x16 mode only now */
629 h263_pred_motion(s, 0, &pred_x, &pred_y);
630
631 if (!s->umvplus) {
632 h263_encode_motion(s, motion_x - pred_x, s->f_code);
633 h263_encode_motion(s, motion_y - pred_y, s->f_code);
634 }
635 else {
636 h263p_encode_umotion(s, motion_x - pred_x);
637 h263p_encode_umotion(s, motion_y - pred_y);
638 if (((motion_x - pred_x) == 1) && ((motion_y - pred_y) == 1))
639 /* To prevent Start Code emulation */
640 put_bits(&s->pb,1,1);
641 }
642 } else {
643 int li = s->h263_aic ? 0 : 1;
644
645 cbp = 0;
646 for(i=0; i<6; i++) {
647 /* Predict DC */
648 if (s->h263_aic && s->mb_intra) {
649 INT16 level = block[i][0];
650
651 pred_dc = h263_pred_dc(s, i, &dc_ptr[i]);
652 level -= pred_dc;
653 /* Quant */
654 if (level < 0)
655 level = (level + (s->qscale >> 1))/(s->y_dc_scale);
656 else
657 level = (level - (s->qscale >> 1))/(s->y_dc_scale);
658
659 /* AIC can change CBP */
660 if (level == 0 && s->block_last_index[i] == 0)
661 s->block_last_index[i] = -1;
662 else if (level < -127)
663 level = -127;
664 else if (level > 127)
665 level = 127;
666
667 block[i][0] = level;
668 /* Reconstruction */
669 rec_intradc[i] = (s->y_dc_scale*level) + pred_dc;
670 /* Oddify */
671 rec_intradc[i] |= 1;
672 //if ((rec_intradc[i] % 2) == 0)
673 // rec_intradc[i]++;
674 /* Clipping */
675 if (rec_intradc[i] < 0)
676 rec_intradc[i] = 0;
677 else if (rec_intradc[i] > 2047)
678 rec_intradc[i] = 2047;
679
680 /* Update AC/DC tables */
681 *dc_ptr[i] = rec_intradc[i];
682 }
683 /* compute cbp */
684 if (s->block_last_index[i] >= li)
685 cbp |= 1 << (5 - i);
686 }
687
688 cbpc = cbp & 3;
689 if (s->pict_type == I_TYPE) {
690 put_bits(&s->pb,
691 intra_MCBPC_bits[cbpc],
692 intra_MCBPC_code[cbpc]);
693 } else {
694 put_bits(&s->pb, 1, 0); /* mb coded */
695 put_bits(&s->pb,
696 inter_MCBPC_bits[cbpc + 4],
697 inter_MCBPC_code[cbpc + 4]);
698 }
699 if (s->h263_aic) {
700 /* XXX: currently, we do not try to use ac prediction */
701 put_bits(&s->pb, 1, 0); /* no AC prediction */
702 }
703 cbpy = cbp >> 2;
704 put_bits(&s->pb, cbpy_tab[cbpy][1], cbpy_tab[cbpy][0]);
705 }
706
707 for(i=0; i<6; i++) {
708 /* encode each block */
709 h263_encode_block(s, block[i], i);
710
711 /* Update INTRADC for decoding */
712 if (s->h263_aic && s->mb_intra) {
713 block[i][0] = rec_intradc[i];
714
715 }
716 }
717 }
718
719 static int h263_pred_dc(MpegEncContext * s, int n, UINT16 **dc_val_ptr)
720 {
721 int x, y, wrap, a, c, pred_dc, scale;
722 INT16 *dc_val, *ac_val;
723
724 /* find prediction */
725 if (n < 4) {
726 x = 2 * s->mb_x + 1 + (n & 1);
727 y = 2 * s->mb_y + 1 + ((n & 2) >> 1);
728 wrap = s->mb_width * 2 + 2;
729 dc_val = s->dc_val[0];
730 ac_val = s->ac_val[0][0];
731 scale = s->y_dc_scale;
732 } else {
733 x = s->mb_x + 1;
734 y = s->mb_y + 1;
735 wrap = s->mb_width + 2;
736 dc_val = s->dc_val[n - 4 + 1];
737 ac_val = s->ac_val[n - 4 + 1][0];
738 scale = s->c_dc_scale;
739 }
740 /* B C
741 * A X
742 */
743 a = dc_val[(x - 1) + (y) * wrap];
744 c = dc_val[(x) + (y - 1) * wrap];
745
746 /* No prediction outside GOB boundary */
747 if (s->first_slice_line && ((n < 2) || (n > 3)))
748 c = 1024;
749 pred_dc = 1024;
750 /* just DC prediction */
751 if (a != 1024 && c != 1024)
752 pred_dc = (a + c) >> 1;
753 else if (a != 1024)
754 pred_dc = a;
755 else
756 pred_dc = c;
757
758 /* we assume pred is positive */
759 //pred_dc = (pred_dc + (scale >> 1)) / scale;
760 *dc_val_ptr = &dc_val[x + y * wrap];
761 return pred_dc;
762 }
763
764
765 void h263_pred_acdc(MpegEncContext * s, INT16 *block, int n)
766 {
767 int x, y, wrap, a, c, pred_dc, scale, i;
768 INT16 *dc_val, *ac_val, *ac_val1;
769
770 /* find prediction */
771 if (n < 4) {
772 x = 2 * s->mb_x + 1 + (n & 1);
773 y = 2 * s->mb_y + 1 + ((n & 2) >> 1);
774 wrap = s->mb_width * 2 + 2;
775 dc_val = s->dc_val[0];
776 ac_val = s->ac_val[0][0];
777 scale = s->y_dc_scale;
778 } else {
779 x = s->mb_x + 1;
780 y = s->mb_y + 1;
781 wrap = s->mb_width + 2;
782 dc_val = s->dc_val[n - 4 + 1];
783 ac_val = s->ac_val[n - 4 + 1][0];
784 scale = s->c_dc_scale;
785 }
786
787 ac_val += ((y) * wrap + (x)) * 16;
788 ac_val1 = ac_val;
789
790 /* B C
791 * A X
792 */
793 a = dc_val[(x - 1) + (y) * wrap];
794 c = dc_val[(x) + (y - 1) * wrap];
795
796 /* No prediction outside GOB boundary */
797 if (s->first_slice_line && ((n < 2) || (n > 3)))
798 c = 1024;
799 pred_dc = 1024;
800 if (s->ac_pred) {
801 if (s->h263_aic_dir) {
802 /* left prediction */
803 if (a != 1024) {
804 ac_val -= 16;
805 for(i=1;i<8;i++) {
806 block[block_permute_op(i*8)] += ac_val[i];
807 }
808 pred_dc = a;
809 }
810 } else {
811 /* top prediction */
812 if (c != 1024) {
813 ac_val -= 16 * wrap;
814 for(i=1;i<8;i++) {
815 block[block_permute_op(i)] += ac_val[i + 8];
816 }
817 pred_dc = c;
818 }
819 }
820 } else {
821 /* just DC prediction */
822 if (a != 1024 && c != 1024)
823 pred_dc = (a + c) >> 1;
824 else if (a != 1024)
825 pred_dc = a;
826 else
827 pred_dc = c;
828 }
829
830 /* we assume pred is positive */
831 block[0]=block[0]*scale + pred_dc;
832
833 if (block[0] < 0)
834 block[0] = 0;
835 else if (!(block[0] & 1))
836 block[0]++;
837
838 /* Update AC/DC tables */
839 dc_val[(x) + (y) * wrap] = block[0];
840
841 /* left copy */
842 for(i=1;i<8;i++)
843 ac_val1[i] = block[block_permute_op(i * 8)];
844 /* top copy */
845 for(i=1;i<8;i++)
846 ac_val1[8 + i] = block[block_permute_op(i)];
847 }
848
849 INT16 *h263_pred_motion(MpegEncContext * s, int block,
850 int *px, int *py)
851 {
852 int xy, wrap;
853 INT16 *A, *B, *C, *mot_val;
854 static const int off[4]= {2, 1, 1, -1};
855
856 wrap = s->block_wrap[0];
857 xy = s->block_index[block];
858
859 mot_val = s->motion_val[xy];
860
861 A = s->motion_val[xy - 1];
862 /* special case for first (slice) line */
863 if ((s->mb_y == 0 || s->first_slice_line) && block<3) {
864 // we cant just change some MVs to simulate that as we need them for the B frames (and ME)
865 // and if we ever support non rectangular objects than we need to do a few ifs here anyway :(
866 if(block==0){ //most common case
867 if(s->mb_x == s->resync_mb_x){ //rare
868 *px= *py = 0;
869 }else if(s->mb_x + 1 == s->resync_mb_x){ //rare
870 C = s->motion_val[xy + off[block] - wrap];
871 if(s->mb_x==0){
872 *px = C[0];
873 *py = C[1];
874 }else{
875 *px = mid_pred(A[0], 0, C[0]);
876 *py = mid_pred(A[1], 0, C[1]);
877 }
878 }else{
879 *px = A[0];
880 *py = A[1];
881 }
882 }else if(block==1){
883 if(s->mb_x + 1 == s->resync_mb_x){ //rare
884 C = s->motion_val[xy + off[block] - wrap];
885 *px = mid_pred(A[0], 0, C[0]);
886 *py = mid_pred(A[1], 0, C[1]);
887 }else{
888 *px = A[0];
889 *py = A[1];
890 }
891 }else{ /* block==2*/
892 B = s->motion_val[xy - wrap];
893 C = s->motion_val[xy + off[block] - wrap];
894 if(s->mb_x == s->resync_mb_x) //rare
895 A[0]=A[1]=0;
896
897 *px = mid_pred(A[0], B[0], C[0]);
898 *py = mid_pred(A[1], B[1], C[1]);
899 }
900 } else {
901 B = s->motion_val[xy - wrap];
902 C = s->motion_val[xy + off[block] - wrap];
903 *px = mid_pred(A[0], B[0], C[0]);
904 *py = mid_pred(A[1], B[1], C[1]);
905 }
906 return mot_val;
907 }
908
909 static void h263_encode_motion(MpegEncContext * s, int val, int f_code)
910 {
911 int range, l, m, bit_size, sign, code, bits;
912
913 if (val == 0) {
914 /* zero vector */
915 code = 0;
916 put_bits(&s->pb, mvtab[code][1], mvtab[code][0]);
917 } else {
918 bit_size = f_code - 1;
919 range = 1 << bit_size;
920 /* modulo encoding */
921 l = range * 32;
922 m = 2 * l;
923 if (val < -l) {
924 val += m;
925 } else if (val >= l) {
926 val -= m;
927 }
928
929 if (val >= 0) {
930 sign = 0;
931 } else {
932 val = -val;
933 sign = 1;
934 }
935 val--;
936 code = (val >> bit_size) + 1;
937 bits = val & (range - 1);
938
939 put_bits(&s->pb, mvtab[code][1] + 1, (mvtab[code][0] << 1) | sign);
940 if (bit_size > 0) {
941 put_bits(&s->pb, bit_size, bits);
942 }
943 }
944 }
945
946 /* Encode MV differences on H.263+ with Unrestricted MV mode */
947 static void h263p_encode_umotion(MpegEncContext * s, int val)
948 {
949 short sval = 0;
950 short i = 0;
951 short n_bits = 0;
952 short temp_val;
953 int code = 0;
954 int tcode;
955
956 if ( val == 0)
957 put_bits(&s->pb, 1, 1);
958 else if (val == 1)
959 put_bits(&s->pb, 3, 0);
960 else if (val == -1)
961 put_bits(&s->pb, 3, 2);
962 else {
963
964 sval = ((val < 0) ? (short)(-val):(short)val);
965 temp_val = sval;
966
967 while (temp_val != 0) {
968 temp_val = temp_val >> 1;
969 n_bits++;
970 }
971
972 i = n_bits - 1;
973 while (i > 0) {
974 tcode = (sval & (1 << (i-1))) >> (i-1);
975 tcode = (tcode << 1) | 1;
976 code = (code << 2) | tcode;
977 i--;
978 }
979 code = ((code << 1) | (val < 0)) << 1;
980 put_bits(&s->pb, (2*n_bits)+1, code);
981 //printf("\nVal = %d\tCode = %d", sval, code);
982 }
983 }
984
985 static void init_mv_penalty_and_fcode(MpegEncContext *s)
986 {
987 int f_code;
988 int mv;
989 for(f_code=1; f_code<=MAX_FCODE; f_code++){
990 for(mv=-MAX_MV; mv<=MAX_MV; mv++){
991 int len;
992
993 if(mv==0) len= mvtab[0][1];
994 else{
995 int val, bit_size, range, code;
996
997 bit_size = s->f_code - 1;
998 range = 1 << bit_size;
999
1000 val=mv;
1001 if (val < 0)
1002 val = -val;
1003 val--;
1004 code = (val >> bit_size) + 1;
1005 if(code<33){
1006 len= mvtab[code][1] + 1 + bit_size;
1007 }else{
1008 len= mvtab[32][1] + 2 + bit_size;
1009 }
1010 }
1011
1012 mv_penalty[f_code][mv+MAX_MV]= len;
1013 }
1014 }
1015
1016 for(f_code=MAX_FCODE; f_code>0; f_code--){
1017 for(mv=-(16<<f_code); mv<(16<<f_code); mv++){
1018 fcode_tab[mv+MAX_MV]= f_code;
1019 }
1020 }
1021
1022 for(mv=0; mv<MAX_MV*2+1; mv++){
1023 umv_fcode_tab[mv]= 1;
1024 }
1025 }
1026
1027 static void init_uni_dc_tab(void)
1028 {
1029 int level, uni_code, uni_len;
1030
1031 for(level=-256; level<256; level++){
1032 int size, v, l;
1033 /* find number of bits */
1034 size = 0;
1035 v = abs(level);
1036 while (v) {
1037 v >>= 1;
1038 size++;
1039 }
1040
1041 if (level < 0)
1042 l= (-level) ^ ((1 << size) - 1);
1043 else
1044 l= level;
1045
1046 /* luminance */
1047 uni_code= DCtab_lum[size][0];
1048 uni_len = DCtab_lum[size][1];
1049
1050 if (size > 0) {
1051 uni_code<<=size; uni_code|=l;
1052 uni_len+=size;
1053 if (size > 8){
1054 uni_code<<=1; uni_code|=1;
1055 uni_len++;
1056 }
1057 }
1058 uni_DCtab_lum[level+256][0]= uni_code;
1059 uni_DCtab_lum[level+256][1]= uni_len;
1060
1061 /* chrominance */
1062 uni_code= DCtab_chrom[size][0];
1063 uni_len = DCtab_chrom[size][1];
1064
1065 if (size > 0) {
1066 uni_code<<=size; uni_code|=l;
1067 uni_len+=size;
1068 if (size > 8){
1069 uni_code<<=1; uni_code|=1;
1070 uni_len++;
1071 }
1072 }
1073 uni_DCtab_chrom[level+256][0]= uni_code;
1074 uni_DCtab_chrom[level+256][1]= uni_len;
1075
1076 }
1077 }
1078
1079 void h263_encode_init(MpegEncContext *s)
1080 {
1081 static int done = 0;
1082
1083 if (!done) {
1084 done = 1;
1085
1086 init_uni_dc_tab();
1087
1088 init_rl(&rl_inter);
1089 init_rl(&rl_intra);
1090 init_rl(&rl_intra_aic);
1091
1092 init_mv_penalty_and_fcode(s);
1093 }
1094 s->mv_penalty= mv_penalty; //FIXME exact table for msmpeg4 & h263p
1095
1096 // use fcodes >1 only for mpeg4 & h263 & h263p FIXME
1097 switch(s->codec_id){
1098 case CODEC_ID_MPEG4:
1099 s->fcode_tab= fcode_tab;
1100 s->min_qcoeff= -2048;
1101 s->max_qcoeff= 2047;
1102 break;
1103 case CODEC_ID_H263P:
1104 s->fcode_tab= umv_fcode_tab;
1105 s->min_qcoeff= -128;
1106 s->max_qcoeff= 127;
1107 break;
1108 //Note for mpeg4 & h263 the dc-scale table will be set per frame as needed later
1109 default: //nothing needed default table allready set in mpegvideo.c
1110 s->min_qcoeff= -128;
1111 s->max_qcoeff= 127;
1112 s->y_dc_scale_table=
1113 s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
1114 }
1115
1116 /* h263 type bias */
1117 //FIXME mpeg4 mpeg quantizer
1118 s->intra_quant_bias=0;
1119 s->inter_quant_bias=-(1<<(QUANT_BIAS_SHIFT-2)); //(a - x/4)/x
1120 }
1121
1122 static void h263_encode_block(MpegEncContext * s, DCTELEM * block, int n)
1123 {
1124 int level, run, last, i, j, last_index, last_non_zero, sign, slevel, code;
1125 RLTable *rl;
1126
1127 rl = &rl_inter;
1128 if (s->mb_intra && !s->h263_aic) {
1129 /* DC coef */
1130 level = block[0];
1131 /* 255 cannot be represented, so we clamp */
1132 if (level > 254) {
1133 level = 254;
1134 block[0] = 254;
1135 }
1136 /* 0 cannot be represented also */
1137 else if (!level) {
1138 level = 1;
1139 block[0] = 1;
1140 }
1141 if (level == 128)
1142 put_bits(&s->pb, 8, 0xff);
1143 else
1144 put_bits(&s->pb, 8, level & 0xff);
1145 i = 1;
1146 } else {
1147 i = 0;
1148 if (s->h263_aic && s->mb_intra)
1149 rl = &rl_intra_aic;
1150 }
1151
1152 /* AC coefs */
1153 last_index = s->block_last_index[n];
1154 last_non_zero = i - 1;
1155 for (; i <= last_index; i++) {
1156 j = zigzag_direct[i];
1157 level = block[j];
1158 if (level) {
1159 run = i - last_non_zero - 1;
1160 last = (i == last_index);
1161 sign = 0;
1162 slevel = level;
1163 if (level < 0) {
1164 sign = 1;
1165 level = -level;
1166 }
1167 code = get_rl_index(rl, last, run, level);
1168 put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
1169 if (code == rl->n) {
1170 put_bits(&s->pb, 1, last);
1171 put_bits(&s->pb, 6, run);
1172 put_bits(&s->pb, 8, slevel & 0xff);
1173 } else {
1174 put_bits(&s->pb, 1, sign);
1175 }
1176 last_non_zero = i;
1177 }
1178 }
1179 }
1180
1181 /***************************************************/
1182
1183 void ff_mpeg4_stuffing(PutBitContext * pbc)
1184 {
1185 int length;
1186 put_bits(pbc, 1, 0);
1187 length= (-get_bit_count(pbc))&7;
1188 if(length) put_bits(pbc, length, (1<<length)-1);
1189 }
1190
1191 /* must be called before writing the header */
1192 void ff_set_mpeg4_time(MpegEncContext * s, int picture_number){
1193 int time_div, time_mod;
1194
1195 if(s->pict_type==I_TYPE){ //we will encode a vol header
1196 s->time_increment_resolution= s->frame_rate/ff_gcd(s->frame_rate, FRAME_RATE_BASE);
1197 if(s->time_increment_resolution>=256*256) s->time_increment_resolution= 256*128;
1198
1199 s->time_increment_bits = av_log2(s->time_increment_resolution - 1) + 1;
1200 }
1201
1202 s->time= picture_number*(INT64)FRAME_RATE_BASE*s->time_increment_resolution/s->frame_rate;
1203 time_div= s->time/s->time_increment_resolution;
1204 time_mod= s->time%s->time_increment_resolution;
1205
1206 if(s->pict_type==B_TYPE){
1207 s->bp_time= s->last_non_b_time - s->time;
1208 }else{
1209 s->last_time_base= s->time_base;
1210 s->time_base= time_div;
1211 s->pp_time= s->time - s->last_non_b_time;
1212 s->last_non_b_time= s->time;
1213 }
1214 }
1215
1216 static void mpeg4_encode_vol_header(MpegEncContext * s)
1217 {
1218 int vo_ver_id=1; //must be 2 if we want GMC or q-pel
1219 char buf[255];
1220
1221 s->vo_type= s->has_b_frames ? CORE_VO_TYPE : SIMPLE_VO_TYPE;
1222
1223 put_bits(&s->pb, 16, 0);
1224 put_bits(&s->pb, 16, 0x100); /* video obj */
1225 put_bits(&s->pb, 16, 0);
1226 put_bits(&s->pb, 16, 0x120); /* video obj layer */
1227
1228 put_bits(&s->pb, 1, 0); /* random access vol */
1229 put_bits(&s->pb, 8, s->vo_type); /* video obj type indication */
1230 put_bits(&s->pb, 1, 1); /* is obj layer id= yes */
1231 put_bits(&s->pb, 4, vo_ver_id); /* is obj layer ver id */
1232 put_bits(&s->pb, 3, 1); /* is obj layer priority */
1233 if(s->aspect_ratio_info)
1234 put_bits(&s->pb, 4, s->aspect_ratio_info);/* aspect ratio info */
1235 else
1236 put_bits(&s->pb, 4, 1); /* aspect ratio info= sqare pixel */
1237
1238 if(s->low_delay){
1239 put_bits(&s->pb, 1, 1); /* vol control parameters= yes */
1240 put_bits(&s->pb, 2, 1); /* chroma format YUV 420/YV12 */
1241 put_bits(&s->pb, 1, s->low_delay);
1242 put_bits(&s->pb, 1, 0); /* vbv parameters= no */
1243 }else{
1244 put_bits(&s->pb, 1, 0); /* vol control parameters= no */
1245 }
1246
1247 put_bits(&s->pb, 2, RECT_SHAPE); /* vol shape= rectangle */
1248 put_bits(&s->pb, 1, 1); /* marker bit */
1249
1250 put_bits(&s->pb, 16, s->time_increment_resolution);
1251 if (s->time_increment_bits < 1)
1252 s->time_increment_bits = 1;
1253 put_bits(&s->pb, 1, 1); /* marker bit */
1254 put_bits(&s->pb, 1, 0); /* fixed vop rate=no */
1255 put_bits(&s->pb, 1, 1); /* marker bit */
1256 put_bits(&s->pb, 13, s->width); /* vol width */
1257 put_bits(&s->pb, 1, 1); /* marker bit */
1258 put_bits(&s->pb, 13, s->height); /* vol height */
1259 put_bits(&s->pb, 1, 1); /* marker bit */
1260 put_bits(&s->pb, 1, 0); /* interlace */
1261 put_bits(&s->pb, 1, 1); /* obmc disable */
1262 if (vo_ver_id == 1) {
1263 put_bits(&s->pb, 1, s->vol_sprite_usage=0); /* sprite enable */
1264 }else{ /* vo_ver_id == 2 */
1265 put_bits(&s->pb, 2, s->vol_sprite_usage=0); /* sprite enable */
1266 }
1267 put_bits(&s->pb, 1, 0); /* not 8 bit */
1268 put_bits(&s->pb, 1, 0); /* quant type= h263 style*/
1269 if (vo_ver_id != 1)
1270 put_bits(&s->pb, 1, s->quarter_sample=0);
1271 put_bits(&s->pb, 1, 1); /* complexity estimation disable */
1272 s->resync_marker= s->rtp_mode;
1273 put_bits(&s->pb, 1, s->resync_marker ? 0 : 1);/* resync marker disable */
1274 put_bits(&s->pb, 1, s->data_partitioning ? 1 : 0);
1275 if(s->data_partitioning){
1276 put_bits(&s->pb, 1, 0); /* no rvlc */
1277 }
1278
1279 if (vo_ver_id != 1){
1280 put_bits(&s->pb, 1, 0); /* newpred */
1281 put_bits(&s->pb, 1, 0); /* reduced res vop */
1282 }
1283 put_bits(&s->pb, 1, 0); /* scalability */
1284
1285 ff_mpeg4_stuffing(&s->pb);
1286 put_bits(&s->pb, 16, 0);
1287 put_bits(&s->pb, 16, 0x1B2); /* user_data */
1288 sprintf(buf, "FFmpeg%sb%s", FFMPEG_VERSION, LIBAVCODEC_BUILD_STR);
1289 put_string(&s->pb, buf);
1290
1291 ff_mpeg4_stuffing(&s->pb);
1292 }
1293
1294 /* write mpeg4 VOP header */
1295 void mpeg4_encode_picture_header(MpegEncContext * s, int picture_number)
1296 {
1297 int time_incr;
1298 int time_div, time_mod;
1299
1300 if(s->pict_type==I_TYPE){
1301 s->no_rounding=0;
1302 if(picture_number==0 || !s->strict_std_compliance)
1303 mpeg4_encode_vol_header(s);
1304 }
1305
1306 //printf("num:%d rate:%d base:%d\n", s->picture_number, s->frame_rate, FRAME_RATE_BASE);
1307
1308 put_bits(&s->pb, 16, 0); /* vop header */
1309 put_bits(&s->pb, 16, 0x1B6); /* vop header */
1310 put_bits(&s->pb, 2, s->pict_type - 1); /* pict type: I = 0 , P = 1 */
1311
1312 time_div= s->time/s->time_increment_resolution;
1313 time_mod= s->time%s->time_increment_resolution;
1314 time_incr= time_div - s->last_time_base;
1315 while(time_incr--)
1316 put_bits(&s->pb, 1, 1);
1317
1318 put_bits(&s->pb, 1, 0);
1319
1320 put_bits(&s->pb, 1, 1); /* marker */
1321 put_bits(&s->pb, s->time_increment_bits, time_mod); /* time increment */
1322 put_bits(&s->pb, 1, 1); /* marker */
1323 put_bits(&s->pb, 1, 1); /* vop coded */
1324 if ( s->pict_type == P_TYPE
1325 || (s->pict_type == S_TYPE && s->vol_sprite_usage==GMC_SPRITE)) {
1326 s->no_rounding ^= 1;
1327 put_bits(&s->pb, 1, s->no_rounding); /* rounding type */
1328 }
1329 put_bits(&s->pb, 3, 0); /* intra dc VLC threshold */
1330 //FIXME sprite stuff
1331
1332 put_bits(&s->pb, 5, s->qscale);
1333
1334 if (s->pict_type != I_TYPE)
1335 put_bits(&s->pb, 3, s->f_code); /* fcode_for */
1336 if (s->pict_type == B_TYPE)
1337 put_bits(&s->pb, 3, s->b_code); /* fcode_back */
1338 // printf("****frame %d\n", picture_number);
1339
1340 s->y_dc_scale_table= ff_mpeg4_y_dc_scale_table; //FIXME add short header support
1341 s->c_dc_scale_table= ff_mpeg4_c_dc_scale_table;
1342 }
1343
1344 static void h263_dc_scale(MpegEncContext * s)
1345 {
1346 s->y_dc_scale= s->y_dc_scale_table[ s->qscale ];
1347 s->c_dc_scale= s->c_dc_scale_table[ s->qscale ];
1348 }
1349
1350 inline int ff_mpeg4_pred_dc(MpegEncContext * s, int n, UINT16 **dc_val_ptr, int *dir_ptr)
1351 {
1352 int a, b, c, wrap, pred, scale;
1353 UINT16 *dc_val;
1354 int dummy;
1355
1356 /* find prediction */
1357 if (n < 4) {
1358 scale = s->y_dc_scale;
1359 } else {
1360 scale = s->c_dc_scale;
1361 }
1362 wrap= s->block_wrap[n];
1363 dc_val = s->dc_val[0] + s->block_index[n];
1364
1365 /* B C
1366 * A X
1367 */
1368 a = dc_val[ - 1];
1369 b = dc_val[ - 1 - wrap];
1370 c = dc_val[ - wrap];
1371
1372 if (abs(a - b) < abs(b - c)) {
1373 pred = c;
1374 *dir_ptr = 1; /* top */
1375 } else {
1376 pred = a;
1377 *dir_ptr = 0; /* left */
1378 }
1379 /* we assume pred is positive */
1380 #ifdef ARCH_X86
1381 asm volatile (
1382 "xorl %%edx, %%edx \n\t"
1383 "mul %%ecx \n\t"
1384 : "=d" (pred), "=a"(dummy)
1385 : "a" (pred + (scale >> 1)), "c" (inverse[scale])
1386 );
1387 #else
1388 pred = (pred + (scale >> 1)) / scale;
1389 #endif
1390
1391 /* prepare address for prediction update */
1392 *dc_val_ptr = &dc_val[0];
1393
1394 return pred;
1395 }
1396
1397 void mpeg4_pred_ac(MpegEncContext * s, INT16 *block, int n,
1398 int dir)
1399 {
1400 int i;
1401 INT16 *ac_val, *ac_val1;
1402
1403 /* find prediction */
1404 ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
1405 ac_val1 = ac_val;
1406 if (s->ac_pred) {
1407 if (dir == 0) {
1408 /* left prediction */
1409 ac_val -= 16;
1410 for(i=1;i<8;i++) {
1411 block[block_permute_op(i*8)] += ac_val[i];
1412 }
1413 } else {
1414 /* top prediction */
1415 ac_val -= 16 * s->block_wrap[n];
1416 for(i=1;i<8;i++) {
1417 block[block_permute_op(i)] += ac_val[i + 8];
1418 }
1419 }
1420 }
1421 /* left copy */
1422 for(i=1;i<8;i++)
1423 ac_val1[i] = block[block_permute_op(i * 8)];
1424 /* top copy */
1425 for(i=1;i<8;i++)
1426 ac_val1[8 + i] = block[block_permute_op(i)];
1427 }
1428
1429 static void mpeg4_inv_pred_ac(MpegEncContext * s, INT16 *block, int n,
1430 int dir)
1431 {
1432 int i;
1433 INT16 *ac_val;
1434
1435 /* find prediction */
1436 ac_val = s->ac_val[0][0] + s->block_index[n] * 16;
1437
1438 if (dir == 0) {
1439 /* left prediction */
1440 ac_val -= 16;
1441 for(i=1;i<8;i++) {
1442 block[block_permute_op(i*8)] -= ac_val[i];
1443 }
1444 } else {
1445 /* top prediction */
1446 ac_val -= 16 * s->block_wrap[n];
1447 for(i=1;i<8;i++) {
1448 block[block_permute_op(i)] -= ac_val[i + 8];
1449 }
1450 }
1451 }
1452
1453 static inline void mpeg4_encode_dc(PutBitContext * s, int level, int n)
1454 {
1455 #if 1
1456 // if(level<-255 || level>255) printf("dc overflow\n");
1457 level+=256;
1458 if (n < 4) {
1459 /* luminance */
1460 put_bits(s, uni_DCtab_lum[level][1], uni_DCtab_lum[level][0]);
1461 } else {
1462 /* chrominance */
1463 put_bits(s, uni_DCtab_chrom[level][1], uni_DCtab_chrom[level][0]);
1464 }
1465 #else
1466 int size, v;
1467 /* find number of bits */
1468 size = 0;
1469 v = abs(level);
1470 while (v) {
1471 v >>= 1;
1472 size++;
1473 }
1474
1475 if (n < 4) {
1476 /* luminance */
1477 put_bits(&s->pb, DCtab_lum[size][1], DCtab_lum[size][0]);
1478 } else {
1479 /* chrominance */
1480 put_bits(&s->pb, DCtab_chrom[size][1], DCtab_chrom[size][0]);
1481 }
1482
1483 /* encode remaining bits */
1484 if (size > 0) {
1485 if (level < 0)
1486 level = (-level) ^ ((1 << size) - 1);
1487 put_bits(&s->pb, size, level);
1488 if (size > 8)
1489 put_bits(&s->pb, 1, 1);
1490 }
1491 #endif
1492 }
1493
1494 static void mpeg4_encode_block(MpegEncContext * s, DCTELEM * block, int n, int intra_dc,
1495 UINT8 *scan_table, PutBitContext *dc_pb, PutBitContext *ac_pb)
1496 {
1497 int level, run, last, i, j, last_index, last_non_zero, sign, slevel;
1498 int code;
1499 const RLTable *rl;
1500
1501 if (s->mb_intra) {
1502 /* mpeg4 based DC predictor */
1503 mpeg4_encode_dc(dc_pb, intra_dc, n);
1504 i = 1;
1505 rl = &rl_intra;
1506 } else {
1507 i = 0;
1508 rl = &rl_inter;
1509 }
1510
1511 /* AC coefs */
1512 last_index = s->block_last_index[n];
1513 last_non_zero = i - 1;
1514 for (; i <= last_index; i++) {
1515 j = scan_table[i];
1516 level = block[j];
1517 if (level) {
1518 run = i - last_non_zero - 1;
1519 last = (i == last_index);
1520 sign = 0;
1521 slevel = level;
1522 if (level < 0) {
1523 sign = 1;
1524 level = -level;
1525 }
1526 code = get_rl_index(rl, last, run, level);
1527 put_bits(ac_pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
1528 if (code == rl->n) {
1529 int level1, run1;
1530 level1 = level - rl->max_level[last][run];
1531 if (level1 < 1)
1532 goto esc2;
1533 code = get_rl_index(rl, last, run, level1);
1534 if (code == rl->n) {
1535 esc2:
1536 put_bits(ac_pb, 1, 1);
1537 if (level > MAX_LEVEL)
1538 goto esc3;
1539 run1 = run - rl->max_run[last][level] - 1;
1540 if (run1 < 0)
1541 goto esc3;
1542 code = get_rl_index(rl, last, run1, level);
1543 if (code == rl->n) {
1544 esc3:
1545 /* third escape */
1546 put_bits(ac_pb, 1, 1);
1547 put_bits(ac_pb, 1, last);
1548 put_bits(ac_pb, 6, run);
1549 put_bits(ac_pb, 1, 1);
1550 put_bits(ac_pb, 12, slevel & 0xfff);
1551 put_bits(ac_pb, 1, 1);
1552 } else {
1553 /* second escape */
1554 put_bits(ac_pb, 1, 0);
1555 put_bits(ac_pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
1556 put_bits(ac_pb, 1, sign);
1557 }
1558 } else {
1559 /* first escape */
1560 put_bits(ac_pb, 1, 0);
1561 put_bits(ac_pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
1562 put_bits(ac_pb, 1, sign);
1563 }
1564 } else {
1565 put_bits(ac_pb, 1, sign);
1566 }
1567 last_non_zero = i;
1568 }
1569 }
1570 }
1571
1572
1573
1574 /***********************************************/
1575 /* decoding */
1576
1577 static VLC intra_MCBPC_vlc;
1578 static VLC inter_MCBPC_vlc;
1579 static VLC cbpy_vlc;
1580 static VLC mv_vlc;
1581 static VLC dc_lum, dc_chrom;
1582 static VLC sprite_trajectory;
1583 static VLC mb_type_b_vlc;
1584
1585 void init_rl(RLTable *rl)
1586 {
1587 INT8 max_level[MAX_RUN+1], max_run[MAX_LEVEL+1];
1588 UINT8 index_run[MAX_RUN+1];
1589 int last, run, level, start, end, i;
1590
1591 /* compute max_level[], max_run[] and index_run[] */
1592 for(last=0;last<2;last++) {
1593 if (last == 0) {
1594 start = 0;
1595 end = rl->last;
1596 } else {
1597 start = rl->last;
1598 end = rl->n;
1599 }
1600
1601 memset(max_level, 0, MAX_RUN + 1);
1602 memset(max_run, 0, MAX_LEVEL + 1);
1603 memset(index_run, rl->n, MAX_RUN + 1);
1604 for(i=start;i<end;i++) {
1605 run = rl->table_run[i];
1606 level = rl->table_level[i];
1607 if (index_run[run] == rl->n)
1608 index_run[run] = i;
1609 if (level > max_level[run])
1610 max_level[run] = level;
1611 if (run > max_run[level])
1612 max_run[level] = run;
1613 }
1614 rl->max_level[last] = av_malloc(MAX_RUN + 1);
1615 memcpy(rl->max_level[last], max_level, MAX_RUN + 1);
1616 rl->max_run[last] = av_malloc(MAX_LEVEL + 1);
1617 memcpy(rl->max_run[last], max_run, MAX_LEVEL + 1);
1618 rl->index_run[last] = av_malloc(MAX_RUN + 1);
1619 memcpy(rl->index_run[last], index_run, MAX_RUN + 1);
1620 }
1621 }
1622
1623 void init_vlc_rl(RLTable *rl)
1624 {
1625 int i, q;
1626
1627 init_vlc(&rl->vlc, 9, rl->n + 1,
1628 &rl->table_vlc[0][1], 4, 2,
1629 &rl->table_vlc[0][0], 4, 2);
1630
1631
1632 for(q=0; q<32; q++){
1633 int qmul= q*2;
1634 int qadd= (q-1)|1;
1635
1636 if(q==0){
1637 qmul=1;
1638 qadd=0;
1639 }
1640
1641 rl->rl_vlc[q]= av_malloc(rl->vlc.table_size*sizeof(RL_VLC_ELEM));
1642 for(i=0; i<rl->vlc.table_size; i++){
1643 int code= rl->vlc.table[i][0];
1644 int len = rl->vlc.table[i][1];
1645 int level, run;
1646
1647 if(len==0){ // illegal code
1648 run= 65;
1649 level= MAX_LEVEL;
1650 }else if(len<0){ //more bits needed
1651 run= 0;
1652 level= code;
1653 }else{
1654 if(code==rl->n){ //esc
1655 run= 65;
1656 level= 0;
1657 }else{
1658 run= rl->table_run [code] + 1;
1659 level= rl->table_level[code] * qmul + qadd;
1660 if(code >= rl->last) run+=192;
1661 }
1662 }
1663 rl->rl_vlc[q][i].len= len;
1664 rl->rl_vlc[q][i].level= level;
1665 rl->rl_vlc[q][i].run= run;
1666 }
1667 }
1668 }
1669
1670 /* init vlcs */
1671
1672 /* XXX: find a better solution to handle static init */
1673 void h263_decode_init_vlc(MpegEncContext *s)
1674 {
1675 static int done = 0;
1676
1677 if (!done) {
1678 done = 1;
1679
1680 init_vlc(&intra_MCBPC_vlc, 6, 8,
1681 intra_MCBPC_bits, 1, 1,
1682 intra_MCBPC_code, 1, 1);
1683 init_vlc(&inter_MCBPC_vlc, 9, 25,
1684 inter_MCBPC_bits, 1, 1,
1685 inter_MCBPC_code, 1, 1);
1686 init_vlc(&cbpy_vlc, 6, 16,
1687 &cbpy_tab[0][1], 2, 1,
1688 &cbpy_tab[0][0], 2, 1);
1689 init_vlc(&mv_vlc, 9, 33,
1690 &mvtab[0][1], 2, 1,
1691 &mvtab[0][0], 2, 1);
1692 init_rl(&rl_inter);
1693 init_rl(&rl_intra);
1694 init_rl(&rl_intra_aic);
1695 init_vlc_rl(&rl_inter);
1696 init_vlc_rl(&rl_intra);
1697 init_vlc_rl(&rl_intra_aic);
1698 init_vlc(&dc_lum, 9, 13,
1699 &DCtab_lum[0][1], 2, 1,
1700 &DCtab_lum[0][0], 2, 1);
1701 init_vlc(&dc_chrom, 9, 13,
1702 &DCtab_chrom[0][1], 2, 1,
1703 &DCtab_chrom[0][0], 2, 1);
1704 init_vlc(&sprite_trajectory, 9, 15,
1705 &sprite_trajectory_tab[0][1], 4, 2,
1706 &sprite_trajectory_tab[0][0], 4, 2);
1707 init_vlc(&mb_type_b_vlc, 4, 4,
1708 &mb_type_b_tab[0][1], 2, 1,
1709 &mb_type_b_tab[0][0], 2, 1);
1710 }
1711 }
1712
1713 int h263_decode_gob_header(MpegEncContext *s)
1714 {
1715 unsigned int val, gfid;
1716
1717 /* Check for GOB Start Code */
1718 val = show_bits(&s->gb, 16);
1719 if (val == 0) {
1720 /* We have a GBSC probably with GSTUFF */
1721 skip_bits(&s->gb, 16); /* Drop the zeros */
1722 while (get_bits1(&s->gb) == 0); /* Seek the '1' bit */
1723 #ifdef DEBUG
1724 fprintf(stderr,"\nGOB Start Code at MB %d\n", (s->mb_y * s->mb_width) + s->mb_x);
1725 #endif
1726 s->gob_number = get_bits(&s->gb, 5); /* GN */
1727 gfid = get_bits(&s->gb, 2); /* GFID */
1728 s->qscale = get_bits(&s->gb, 5); /* GQUANT */
1729 #ifdef DEBUG
1730 fprintf(stderr, "\nGN: %u GFID: %u Quant: %u\n", s->gob_number, gfid, s->qscale);
1731 #endif
1732 return 1;
1733 }
1734 return 0;
1735
1736 }
1737
1738 static inline void memsetw(short *tab, int val, int n)
1739 {
1740 int i;
1741 for(i=0;i<n;i++)
1742 tab[i] = val;
1743 }
1744
1745 void ff_mpeg4_init_partitions(MpegEncContext *s)
1746 {
1747 init_put_bits(&s->tex_pb, s->tex_pb_buffer, PB_BUFFER_SIZE, NULL, NULL);
1748 init_put_bits(&s->pb2 , s->pb2_buffer , PB_BUFFER_SIZE, NULL, NULL);
1749 }
1750
1751 void ff_mpeg4_merge_partitions(MpegEncContext *s)
1752 {
1753 const int pb2_len = get_bit_count(&s->pb2 );
1754 const int tex_pb_len= get_bit_count(&s->tex_pb);
1755 const int bits= get_bit_count(&s->pb);
1756
1757 if(s->pict_type==I_TYPE){
1758 put_bits(&s->pb, 19, DC_MARKER);
1759 s->misc_bits+=19 + pb2_len + bits - s->last_bits;
1760 s->i_tex_bits+= tex_pb_len;
1761 }else{
1762 put_bits(&s->pb, 17, MOTION_MARKER);
1763 s->misc_bits+=17 + pb2_len;;
1764 s->mv_bits+= bits - s->last_bits;
1765 s->p_tex_bits+= tex_pb_len;
1766 }
1767
1768 flush_put_bits(&s->pb2);
1769 flush_put_bits(&s->tex_pb);
1770
1771 ff_copy_bits(&s->pb, s->pb2_buffer , pb2_len);
1772 ff_copy_bits(&s->pb, s->tex_pb_buffer, tex_pb_len);
1773 s->last_bits= get_bit_count(&s->pb);
1774 }
1775
1776 void ff_mpeg4_encode_video_packet_header(MpegEncContext *s)
1777 {
1778 int mb_num_bits= av_log2(s->mb_num - 1) + 1;
1779
1780 ff_mpeg4_stuffing(&s->pb);
1781 if(s->pict_type==I_TYPE)
1782 put_bits(&s->pb, 16, 0);
1783 else if(s->pict_type==B_TYPE)
1784 put_bits(&s->pb, MAX(MAX(s->f_code, s->b_code)+15, 17), 0);
1785 else /* S/P_TYPE */
1786 put_bits(&s->pb, s->f_code+15, 0);
1787 put_bits(&s->pb, 1, 1);
1788
1789 put_bits(&s->pb, mb_num_bits, s->mb_x + s->mb_y*s->mb_width);
1790 put_bits(&s->pb, 5, s->qscale);
1791 put_bits(&s->pb, 1, 0); /* no HEC */
1792 }
1793
1794 /**
1795 * decodes the next video packet and sets s->next_qscale
1796 * returns mb_num of the next packet or <0 if something went wrong
1797 */
1798 static int decode_video_packet_header(MpegEncContext *s, GetBitContext *gb)
1799 {
1800 int bits;
1801 int mb_num_bits= av_log2(s->mb_num - 1) + 1;
1802 int header_extension=0, mb_num;
1803 //printf("%X\n", show_bits(&gb, 24));
1804 //printf("parse_video_packet_header\n");
1805 // if(show_aligned_bits(gb, 1, 16) != 0) return -1;
1806
1807 /* is there enough space left for a video packet + header */
1808 if( get_bits_count(gb) > gb->size*8-20) return -1;
1809
1810 //printf("resync at %d %d\n", s->mb_x, s->mb_y);
1811 // skip_bits(gb, 1);
1812 // align_get_bits(gb);
1813 if(get_bits(gb, 16)!=0){
1814 printf("internal error while decoding video packet header\n");
1815 }
1816
1817 //printf("%X\n", show_bits(gb, 24));
1818 bits=0;
1819 while(!get_bits1(gb) && bits<30) bits++;
1820 if((s->pict_type == P_TYPE || s->pict_type == S_TYPE) && bits != s->f_code-1){
1821 printf("marker does not match f_code (is: %d should be: %d pos: %d end %d x: %d y: %d)\n",
1822 bits+1, s->f_code, get_bits_count(gb), gb->size*8, s->mb_x, s->mb_y);
1823 return -1;
1824 }else if(s->pict_type == I_TYPE && bits != 0){
1825 printf("marker too long\n");
1826 return -1;
1827 }else if(s->pict_type == B_TYPE && bits != MAX(MAX(s->f_code, s->b_code)-1, 1)){
1828 printf("marker does not match f/b_code\n");
1829 return -1;
1830 }
1831 //printf("%X\n", show_bits(gb, 24));
1832
1833 if(s->shape != RECT_SHAPE){
1834 header_extension= get_bits1(gb);
1835 //FIXME more stuff here
1836 }
1837
1838 mb_num= get_bits(gb, mb_num_bits);
1839 if(mb_num < s->mb_x + s->mb_y*s->mb_width || mb_num>=s->mb_num){
1840 fprintf(stderr, "illegal mb_num in video packet (%d %d) \n", mb_num, s->mb_x + s->mb_y*s->mb_width);
1841 return -1;
1842 }
1843
1844 if(s->shape != BIN_ONLY_SHAPE){
1845 s->next_resync_qscale= get_bits(gb, 5);
1846 if(s->next_resync_qscale==0)
1847 s->next_resync_qscale= s->qscale;
1848 if(s->next_resync_qscale==0){
1849 fprintf(stderr, "qscale==0\n");
1850 return -1;
1851 }
1852 }
1853
1854 if(s->shape == RECT_SHAPE){
1855 header_extension= get_bits1(gb);
1856 }
1857 if(header_extension){
1858 int time_increment;
1859 int time_incr=0;
1860 printf("header extension not supported\n");
1861 return -1;
1862
1863 while (get_bits1(gb) != 0)
1864 time_incr++;
1865
1866 check_marker(gb, "before time_increment in video packed header");
1867 time_increment= get_bits(gb, s->time_increment_bits);
1868 if(s->pict_type!=B_TYPE){
1869 s->last_time_base= s->time_base;
1870 s->time_base+= time_incr;
1871 s->time= s->time_base*s->time_increment_resolution + time_increment;
1872 s->pp_time= s->time - s->last_non_b_time;
1873 s->last_non_b_time= s->time;
1874 }else{
1875 s->time= (s->last_time_base + time_incr)*s->time_increment_resolution + time_increment;
1876 s->bp_time= s->last_non_b_time - s->time;
1877 }
1878 check_marker(gb, "before vop_coding_type in video packed header");
1879
1880 skip_bits(gb, 2); /* vop coding type */
1881 //FIXME not rect stuff here
1882
1883 if(s->shape != BIN_ONLY_SHAPE){
1884 skip_bits(gb, 3); /* intra dc vlc threshold */
1885
1886 if(s->pict_type == S_TYPE && s->vol_sprite_usage==GMC_SPRITE && s->num_sprite_warping_points){
1887 mpeg4_decode_sprite_trajectory(s);
1888 }
1889
1890 //FIXME reduced res stuff here
1891
1892 if (s->pict_type != I_TYPE) {
1893 s->f_code = get_bits(gb, 3); /* fcode_for */
1894 if(s->f_code==0){
1895 printf("Error, video packet header damaged or not MPEG4 header (f_code=0)\n");
1896 return -1; // makes no sense to continue, as the MV decoding will break very quickly
1897 }
1898 }
1899 if (s->pict_type == B_TYPE) {
1900 s->b_code = get_bits(gb, 3);
1901 }
1902 }
1903 }
1904 //FIXME new-pred stuff
1905
1906 //printf("parse ok %d %d %d %d\n", mb_num, s->mb_x + s->mb_y*s->mb_width, get_bits_count(gb), get_bits_count(&s->gb));
1907
1908 return mb_num;
1909 }
1910
1911 void ff_mpeg4_clean_buffers(MpegEncContext *s)
1912 {
1913 int c_wrap, c_xy, l_wrap, l_xy;
1914
1915 l_wrap= s->block_wrap[0];
1916 l_xy= s->mb_y*l_wrap*2 + s->mb_x*2;
1917 c_wrap= s->block_wrap[4];
1918 c_xy= s->mb_y*c_wrap + s->mb_x;
1919
1920 /* clean DC */
1921 memsetw(s->dc_val[0] + l_xy, 1024, l_wrap*2+1);
1922 memsetw(s->dc_val[1] + c_xy, 1024, c_wrap+1);
1923 memsetw(s->dc_val[2] + c_xy, 1024, c_wrap+1);
1924
1925 /* clean AC */
1926 memset(s->ac_val[0] + l_xy, 0, (l_wrap*2+1)*16*sizeof(INT16));
1927 memset(s->ac_val[1] + c_xy, 0, (c_wrap +1)*16*sizeof(INT16));
1928 memset(s->ac_val[2] + c_xy, 0, (c_wrap +1)*16*sizeof(INT16));
1929
1930 /* clean MV */
1931 // we cant clear the MVs as they might be needed by a b frame
1932 // memset(s->motion_val + l_xy, 0, (l_wrap*2+1)*2*sizeof(INT16));
1933 // memset(s->motion_val, 0, 2*sizeof(INT16)*(2 + s->mb_width*2)*(2 + s->mb_height*2));
1934 s->last_mv[0][0][0]=
1935 s->last_mv[0][0][1]=
1936 s->last_mv[1][0][0]=
1937 s->last_mv[1][0][1]= 0;
1938 }
1939
1940 /* searches for the next resync marker clears ac,dc,mc, and sets s->next_resync_gb, s->mb_num_left */
1941 int ff_mpeg4_resync(MpegEncContext *s)
1942 {
1943 GetBitContext gb;
1944
1945 /* search & parse next resync marker */
1946
1947 gb= s->next_resync_gb;
1948 align_get_bits(&gb);
1949 //printf("mpeg4_resync %d next:%d \n", get_bits_count(&gb), get_bits_count(&s->next_resync_gb));
1950 for(;;) {
1951 int v= show_bits(&gb, 24);
1952 if( get_bits_count(&gb) >= gb.size*8-24 || v == 1 /* start-code */){
1953 s->mb_num_left= s->mb_num - s->mb_x - s->mb_y*s->mb_width;
1954 //printf("mpeg4_resync end\n");
1955 s->gb= s->next_resync_gb; //continue at the next resync marker
1956 return -1;
1957 }else if(v>>8 == 0){
1958 int next;
1959 s->next_resync_pos= get_bits_count(&gb);
1960
1961 next= decode_video_packet_header(s, &gb);
1962 if(next >= 0){
1963 s->mb_num_left= next - s->mb_x - s->mb_y*s->mb_width;
1964 break;
1965 }
1966
1967 align_get_bits(&gb);
1968 }
1969 skip_bits(&gb, 8);
1970 }
1971 s->next_resync_gb=gb;
1972
1973 return 0;
1974 }
1975
1976 static inline void init_block_index(MpegEncContext *s)
1977 {
1978 s->block_index[0]= s->block_wrap[0]*(s->mb_y*2 + 1) - 1 + s->mb_x*2;
1979 s->block_index[1]= s->block_wrap[0]*(s->mb_y*2 + 1) + s->mb_x*2;
1980 s->block_index[2]= s->block_wrap[0]*(s->mb_y*2 + 2) - 1 + s->mb_x*2;
1981 s->block_index[3]= s->block_wrap[0]*(s->mb_y*2 + 2) + s->mb_x*2;
1982 s->block_index[4]= s->block_wrap[4]*(s->mb_y + 1) + s->block_wrap[0]*(s->mb_height*2 + 2) + s->mb_x;
1983 s->block_index[5]= s->block_wrap[4]*(s->mb_y + 1 + s->mb_height + 2) + s->block_wrap[0]*(s->mb_height*2 + 2) + s->mb_x;
1984 }
1985
1986 static inline void update_block_index(MpegEncContext *s)
1987 {
1988 s->block_index[0]+=2;
1989 s->block_index[1]+=2;
1990 s->block_index[2]+=2;
1991 s->block_index[3]+=2;
1992 s->block_index[4]++;
1993 s->block_index[5]++;
1994 }
1995
1996 /**
1997 * decodes the first & second partition
1998 * returns error type or 0 if no error
1999 */
2000 int ff_mpeg4_decode_partitions(MpegEncContext *s)
2001 {
2002 static const INT8 quant_tab[4] = { -1, -2, 1, 2 };
2003 int mb_num;
2004
2005 /* decode first partition */
2006 mb_num=0;
2007 s->first_slice_line=1;
2008 s->mb_x= s->resync_mb_x;
2009 for(s->mb_y= s->resync_mb_y; mb_num < s->mb_num_left; s->mb_y++){
2010 init_block_index(s);
2011 for(; mb_num < s->mb_num_left && s->mb_x<s->mb_width; s->mb_x++){
2012 const int xy= s->mb_x + s->mb_y*s->mb_width;
2013 int cbpc;
2014 int dir=0;
2015
2016 mb_num++;
2017 update_block_index(s);
2018 if(s->mb_x == s->resync_mb_x && s->mb_y == s->resync_mb_y+1)
2019 s->first_slice_line=0;
2020
2021 if(s->mb_x==0) PRINT_MB_TYPE("\n");
2022
2023 if(s->pict_type==I_TYPE){
2024 int i;
2025
2026 PRINT_MB_TYPE("I");
2027 cbpc = get_vlc(&s->gb, &intra_MCBPC_vlc);
2028 if (cbpc < 0){
2029 fprintf(stderr, "cbpc corrupted at %d %d\n", s->mb_x, s->mb_y);
2030 return DECODING_DESYNC;
2031 }
2032 s->cbp_table[xy]= cbpc & 3;
2033 s->mb_type[xy]= MB_TYPE_INTRA;
2034 s->mb_intra = 1;
2035
2036 if(cbpc & 4) {
2037 s->qscale += quant_tab[get_bits(&s->gb, 2)];
2038 if (s->qscale < 1)
2039 s->qscale = 1;
2040 else if (s->qscale > 31)
2041 s->qscale = 31;
2042 h263_dc_scale(s);
2043 }
2044 s->qscale_table[xy]= s->qscale;
2045
2046 s->mbintra_table[xy]= 1;
2047 for(i=0; i<6; i++){
2048 int dc_pred_dir;
2049 int dc= mpeg4_decode_dc(s, i, &dc_pred_dir);
2050 if(dc < 0){
2051 fprintf(stderr, "DC corrupted at %d %d\n", s->mb_x, s->mb_y);
2052 return DECODING_DESYNC;
2053 }
2054 dir<<=1;
2055 if(dc_pred_dir) dir|=1;
2056 }
2057 s->pred_dir_table[xy]= dir;
2058 }else{ /* P/S_TYPE */
2059 int mx, my, pred_x, pred_y;
2060 INT16 * const mot_val= s->motion_val[s->block_index[0]];
2061 const int stride= s->block_wrap[0]*2;
2062
2063 if(get_bits1(&s->gb)){
2064 /* skip mb */
2065 s->mb_type[xy]= MB_TYPE_SKIPED;
2066 if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
2067 const int a= s->sprite_warping_accuracy;
2068 PRINT_MB_TYPE("G");
2069 if(s->divx_version==500 && s->divx_build==413){
2070 mx = s->sprite_offset[0][0] / (1<<(a-s->quarter_sample));
2071 my = s->sprite_offset[0][1] / (1<<(a-s->quarter_sample));
2072 }else{
2073 mx = RSHIFT(s->sprite_offset[0][0], a-s->quarter_sample);
2074 my = RSHIFT(s->sprite_offset[0][1], a-s->quarter_sample);
2075 s->mb_type[xy]= MB_TYPE_GMC | MB_TYPE_SKIPED;
2076 }
2077 }else{
2078 PRINT_MB_TYPE("S");
2079 mx = 0;
2080 my = 0;
2081 }
2082 mot_val[0 ]= mot_val[2 ]=
2083 mot_val[0+stride]= mot_val[2+stride]= mx;
2084 mot_val[1 ]= mot_val[3 ]=
2085 mot_val[1+stride]= mot_val[3+stride]= my;
2086
2087 if(s->mbintra_table[xy])
2088 ff_clean_intra_table_entries(s);
2089
2090 continue;
2091 }
2092 cbpc = get_vlc(&s->gb, &inter_MCBPC_vlc);
2093 if (cbpc < 0){
2094 fprintf(stderr, "cbpc corrupted at %d %d\n", s->mb_x, s->mb_y);
2095 return DECODING_DESYNC;
2096 }
2097 if (cbpc > 20)
2098 cbpc+=3;
2099 else if (cbpc == 20)
2100 fprintf(stderr, "Stuffing !");
2101 s->cbp_table[xy]= cbpc&(8+3); //8 is dquant
2102
2103 s->mb_intra = ((cbpc & 4) != 0);
2104
2105 if(s->mb_intra){
2106 PRINT_MB_TYPE("I");
2107 s->mbintra_table[xy]= 1;
2108 s->mb_type[xy]= MB_TYPE_INTRA;
2109 mot_val[0 ]= mot_val[2 ]=
2110 mot_val[0+stride]= mot_val[2+stride]= 0;
2111 mot_val[1 ]= mot_val[3 ]=
2112 mot_val[1+stride]= mot_val[3+stride]= 0;
2113 }else{
2114 if(s->mbintra_table[xy])
2115 ff_clean_intra_table_entries(s);
2116
2117 if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE && (cbpc & 16) == 0)
2118 s->mcsel= get_bits1(&s->gb);
2119 else s->mcsel= 0;
2120
2121 if ((cbpc & 16) == 0) {
2122 PRINT_MB_TYPE("P");
2123 /* 16x16 motion prediction */
2124 s->mb_type[xy]= MB_TYPE_INTER;
2125
2126 h263_pred_motion(s, 0, &pred_x, &pred_y);
2127 if(!s->mcsel)
2128 mx = h263_decode_motion(s, pred_x, s->f_code);
2129 else {
2130 const int a= s->sprite_warping_accuracy;
2131 if(s->divx_version==500 && s->divx_build==413){
2132 mx = s->sprite_offset[0][0] / (1<<(a-s->quarter_sample));
2133 }else{
2134 mx = RSHIFT(s->sprite_offset[0][0], a-s->quarter_sample);
2135 }
2136 }
2137 if (mx >= 0xffff)
2138 return DECODING_DESYNC;
2139
2140 if(!s->mcsel)
2141 my = h263_decode_motion(s, pred_y, s->f_code);
2142 else{
2143 const int a= s->sprite_warping_accuracy;
2144 if(s->divx_version==500 && s->divx_build==413){
2145 my = s->sprite_offset[0][1] / (1<<(a-s->quarter_sample));
2146 }else{
2147 my = RSHIFT(s->sprite_offset[0][1], a-s->quarter_sample);
2148 }
2149 }
2150 if (my >= 0xffff)
2151 return DECODING_DESYNC;
2152 mot_val[0 ]= mot_val[2 ] =
2153 mot_val[0+stride]= mot_val[2+stride]= mx;
2154 mot_val[1 ]= mot_val[3 ]=
2155 mot_val[1+stride]= mot_val[3+stride]= my;
2156 } else {
2157 int i;
2158 PRINT_MB_TYPE("4");
2159 s->mb_type[xy]= MB_TYPE_INTER4V;
2160 for(i=0;i<4;i++) {
2161 INT16 *mot_val= h263_pred_motion(s, i, &pred_x, &pred_y);
2162 mx = h263_decode_motion(s, pred_x, s->f_code);
2163 if (mx >= 0xffff)
2164 return DECODING_DESYNC;
2165
2166 my = h263_decode_motion(s, pred_y, s->f_code);
2167 if (my >= 0xffff)
2168 return DECODING_DESYNC;
2169 mot_val[0] = mx;
2170 mot_val[1] = my;
2171 }
2172 }
2173 }
2174 }
2175 }
2176 s->mb_x= 0;
2177 }
2178
2179 if (s->pict_type==I_TYPE && get_bits(&s->gb, 19)!=DC_MARKER ) s->decoding_error= DECODING_DESYNC;
2180 else if(s->pict_type!=I_TYPE && get_bits(&s->gb, 17)!=MOTION_MARKER) s->decoding_error= DECODING_DESYNC;
2181 if(s->decoding_error== DECODING_DESYNC){
2182 fprintf(stderr, "marker missing after first partition at %d %d\n", s->mb_x, s->mb_y);
2183 return DECODING_DESYNC;
2184 }
2185
2186 /* decode second partition */
2187 mb_num=0;
2188 s->mb_x= s->resync_mb_x;
2189 for(s->mb_y= s->resync_mb_y; mb_num < s->mb_num_left; s->mb_y++){
2190 init_block_index(s);
2191 for(; mb_num < s->mb_num_left && s->mb_x<s->mb_width; s->mb_x++){
2192 const int xy= s->mb_x + s->mb_y*s->mb_width;
2193
2194 mb_num++;
2195 update_block_index(s);
2196
2197 if(s->pict_type==I_TYPE){
2198 int ac_pred= get_bits1(&s->gb);
2199 int cbpy = get_vlc(&s->gb, &cbpy_vlc);
2200 if(cbpy<0){
2201 fprintf(stderr, "cbpy corrupted at %d %d\n", s->mb_x, s->mb_y);
2202 return DECODING_AC_LOST;
2203 }
2204
2205 s->cbp_table[xy]|= cbpy<<2;
2206 s->pred_dir_table[xy]|= ac_pred<<7;
2207 }else{ /* P || S_TYPE */
2208 if(s->mb_type[xy]&MB_TYPE_INTRA){
2209 int dir=0,i;
2210 int ac_pred = get_bits1(&s->gb);
2211 int cbpy = get_vlc(&s->gb, &cbpy_vlc);
2212
2213 if(cbpy<0){
2214 fprintf(stderr, "I cbpy corrupted at %d %d\n", s->mb_x, s->mb_y);
2215 return DECODING_ACDC_LOST;
2216 }
2217
2218 if(s->cbp_table[xy] & 8) {
2219 s->qscale += quant_tab[get_bits(&s->gb, 2)];
2220 if (s->qscale < 1)
2221 s->qscale = 1;
2222 else if (s->qscale > 31)
2223 s->qscale = 31;
2224 h263_dc_scale(s);
2225 }
2226 s->qscale_table[xy]= s->qscale;
2227
2228 for(i=0; i<6; i++){
2229 int dc_pred_dir;
2230 int dc= mpeg4_decode_dc(s, i, &dc_pred_dir);
2231 if(dc < 0){
2232 fprintf(stderr, "DC corrupted at %d %d\n", s->mb_x, s->mb_y);
2233 return DECODING_ACDC_LOST;
2234 }
2235 dir<<=1;
2236 if(dc_pred_dir) dir|=1;
2237 }
2238 s->cbp_table[xy]&= 3; //remove dquant
2239 s->cbp_table[xy]|= cbpy<<2;
2240 s->pred_dir_table[xy]= dir | (ac_pred<<7);
2241 }else if(s->mb_type[xy]&MB_TYPE_SKIPED){
2242 s->qscale_table[xy]= s->qscale;
2243 s->cbp_table[xy]= 0;
2244 }else{
2245 int cbpy = get_vlc(&s->gb, &cbpy_vlc);
2246
2247 if(cbpy<0){
2248 fprintf(stderr, "P cbpy corrupted at %d %d\n", s->mb_x, s->mb_y);
2249 return DECODING_ACDC_LOST;
2250 }
2251
2252 if(s->cbp_table[xy] & 8) {
2253 //fprintf(stderr, "dquant\n");
2254 s->qscale += quant_tab[get_bits(&s->gb, 2)];
2255 if (s->qscale < 1)
2256 s->qscale = 1;
2257 else if (s->qscale > 31)
2258 s->qscale = 31;
2259 h263_dc_scale(s);
2260 }
2261 s->qscale_table[xy]= s->qscale;
2262
2263 s->cbp_table[xy]&= 3; //remove dquant
2264 s->cbp_table[xy]|= (cbpy^0xf)<<2;
2265 }
2266 }
2267 }
2268 s->mb_x= 0;
2269 }
2270
2271
2272 return 0;
2273 }
2274
2275 static int mpeg4_decode_partitioned_mb(MpegEncContext *s,
2276 DCTELEM block[6][64])
2277 {
2278 int cbp, mb_type;
2279 const int xy= s->mb_x + s->mb_y*s->mb_width;
2280
2281 if(s->mb_x==s->resync_mb_x && s->mb_y==s->resync_mb_y){ //Note resync_mb_{x,y}==0 at the start
2282 int i;
2283 int block_index_backup[6];
2284 int qscale= s->qscale;
2285
2286 for(i=0; i<6; i++) block_index_backup[i]= s->block_index[i];
2287
2288 s->decoding_error= ff_mpeg4_decode_partitions(s);
2289
2290 for(i=0; i<6; i++) s->block_index[i]= block_index_backup[i];
2291 s->first_slice_line=1;
2292 s->mb_x= s->resync_mb_x;
2293 s->mb_y= s->resync_mb_y;
2294 s->qscale= qscale;
2295 h263_dc_scale(s);
2296
2297 if(s->decoding_error==DECODING_DESYNC) return -1;
2298 }
2299
2300 mb_type= s->mb_type[xy];
2301 if(s->decoding_error)
2302 cbp=0;
2303 else
2304 cbp = s->cbp_table[xy];
2305
2306 if(s->decoding_error!=DECODING_ACDC_LOST && s->qscale_table[xy] != s->qscale){
2307 s->qscale= s->qscale_table[xy];
2308 h263_dc_scale(s);
2309 }
2310
2311 if (s->pict_type == P_TYPE || s->pict_type==S_TYPE) {
2312 int i;
2313 for(i=0; i<4; i++){
2314 s->mv[0][i][0] = s->motion_val[ s->block_index[i] ][0];
2315 s->mv[0][i][1] = s->motion_val[ s->block_index[i] ][1];
2316 }
2317 s->mb_intra = mb_type&MB_TYPE_INTRA;
2318
2319 if (mb_type&MB_TYPE_SKIPED) {
2320 /* skip mb */
2321 for(i=0;i<6;i++)
2322 s->block_last_index[i] = -1;
2323 s->mv_dir = MV_DIR_FORWARD;
2324 s->mv_type = MV_TYPE_16X16;
2325 if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
2326 s->mcsel=1;
2327 s->mb_skiped = 0;
2328 }else{
2329 s->mcsel=0;
2330 s->mb_skiped = 1;
2331 }
2332 return 0;
2333 }else if(s->mb_intra && s->decoding_error!=DECODING_ACDC_LOST){
2334 s->ac_pred = s->pred_dir_table[xy]>>7;
2335
2336 /* decode each block */
2337 for (i = 0; i < 6; i++) {
2338 int ret= mpeg4_decode_block(s, block[i], i, (cbp >> (5 - i)) & 1);
2339 if(ret==DECODING_AC_LOST){
2340 fprintf(stderr, "texture corrupted at %d %d (trying to continue with mc/dc only)\n", s->mb_x, s->mb_y);
2341 s->decoding_error=DECODING_AC_LOST;
2342 cbp=0;
2343 }else if(ret==DECODING_ACDC_LOST){
2344 fprintf(stderr, "dc corrupted at %d %d (trying to continue with mc only)\n", s->mb_x, s->mb_y);
2345 s->decoding_error=DECODING_ACDC_LOST;
2346 break;
2347 }
2348 }
2349 }else if(!s->mb_intra){
2350 // s->mcsel= 0; //FIXME do we need to init that
2351
2352 s->mv_dir = MV_DIR_FORWARD;
2353 if (mb_type&MB_TYPE_INTER4V) {
2354 s->mv_type = MV_TYPE_8X8;
2355 } else {
2356 s->mv_type = MV_TYPE_16X16;
2357 }
2358 if(s->decoding_error==0 && cbp){
2359 /* decode each block */
2360 for (i = 0; i < 6; i++) {
2361 int ret= mpeg4_decode_block(s, block[i], i, (cbp >> (5 - i)) & 1);
2362 if(ret==DECODING_AC_LOST){
2363 fprintf(stderr, "texture corrupted at %d %d (trying to continue with mc/dc only)\n", s->mb_x, s->mb_y);
2364 s->decoding_error=DECODING_AC_LOST;
2365 break;
2366 }
2367 }
2368 }
2369 }
2370 } else { /* I-Frame */
2371 int i;
2372 s->mb_intra = 1;
2373 s->ac_pred = s->pred_dir_table[xy]>>7;
2374
2375 /* decode each block */
2376 for (i = 0; i < 6; i++) {
2377 int ret= mpeg4_decode_block(s, block[i], i, (cbp >> (5 - i)) & 1);
2378 if(ret==DECODING_AC_LOST){
2379 fprintf(stderr, "texture corrupted at %d %d (trying to continue with dc only)\n", s->mb_x, s->mb_y);
2380 s->decoding_error=DECODING_AC_LOST;
2381 cbp=0;
2382 }else if(ret==DECODING_ACDC_LOST){
2383 fprintf(stderr, "dc corrupted at %d %d\n", s->mb_x, s->mb_y);
2384 return -1;
2385 }
2386 }
2387 }
2388
2389 return 0;
2390 }
2391
2392
2393 int h263_decode_mb(MpegEncContext *s,
2394 DCTELEM block[6][64])
2395 {
2396 int cbpc, cbpy, i, cbp, pred_x, pred_y, mx, my, dquant;
2397 INT16 *mot_val;
2398 static INT8 quant_tab[4] = { -1, -2, 1, 2 };
2399
2400 if(s->mb_x==0) PRINT_MB_TYPE("\n");
2401
2402 if(s->resync_marker){
2403 if(s->resync_mb_x == s->mb_x && s->resync_mb_y+1 == s->mb_y){
2404 s->first_slice_line=0;
2405 }
2406 }
2407
2408 if(s->data_partitioning && s->pict_type!=B_TYPE)
2409 return mpeg4_decode_partitioned_mb(s, block);
2410
2411 if (s->pict_type == P_TYPE || s->pict_type==S_TYPE) {
2412 if (get_bits1(&s->gb)) {
2413 /* skip mb */
2414 s->mb_intra = 0;
2415 for(i=0;i<6;i++)
2416 s->block_last_index[i] = -1;
2417 s->mv_dir = MV_DIR_FORWARD;
2418 s->mv_type = MV_TYPE_16X16;
2419 if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE){
2420 const int a= s->sprite_warping_accuracy;
2421 // int l = (1 << (s->f_code - 1)) * 32;
2422 PRINT_MB_TYPE("G");
2423 s->mcsel=1;
2424 if(s->divx_version==500 && s->divx_build==413){
2425 s->mv[0][0][0] = s->sprite_offset[0][0] / (1<<(a-s->quarter_sample));
2426 s->mv[0][0][1] = s->sprite_offset[0][1] / (1<<(a-s->quarter_sample));
2427 }else{
2428 s->mv[0][0][0] = RSHIFT(s->sprite_offset[0][0], a-s->quarter_sample);
2429 s->mv[0][0][1] = RSHIFT(s->sprite_offset[0][1], a-s->quarter_sample);
2430 }
2431 /* if (s->mv[0][0][0] < -l) s->mv[0][0][0]= -l;
2432 else if (s->mv[0][0][0] >= l) s->mv[0][0][0]= l-1;
2433 if (s->mv[0][0][1] < -l) s->mv[0][0][1]= -l;
2434 else if (s->mv[0][0][1] >= l) s->mv[0][0][1]= l-1;*/
2435
2436 s->mb_skiped = 0;
2437 }else{
2438 PRINT_MB_TYPE("S");
2439 s->mcsel=0;
2440 s->mv[0][0][0] = 0;
2441 s->mv[0][0][1] = 0;
2442 s->mb_skiped = 1;
2443 }
2444 return 0;
2445 }
2446 cbpc = get_vlc(&s->gb, &inter_MCBPC_vlc);
2447 //fprintf(stderr, "\tCBPC: %d", cbpc);
2448 if (cbpc < 0)
2449 return -1;
2450 if (cbpc > 20)
2451 cbpc+=3;
2452 else if (cbpc == 20)
2453 fprintf(stderr, "Stuffing !");
2454
2455 dquant = cbpc & 8;
2456 s->mb_intra = ((cbpc & 4) != 0);
2457 if (s->mb_intra) goto intra;
2458
2459 if(s->pict_type==S_TYPE && s->vol_sprite_usage==GMC_SPRITE && (cbpc & 16) == 0)
2460 s->mcsel= get_bits1(&s->gb);
2461 else s->mcsel= 0;
2462 cbpy = get_vlc(&s->gb, &cbpy_vlc);
2463 cbp = (cbpc & 3) | ((cbpy ^ 0xf) << 2);
2464 if (dquant) {
2465 s->qscale += quant_tab[get_bits(&s->gb, 2)];
2466 if (s->qscale < 1)
2467 s->qscale = 1;
2468 else if (s->qscale > 31)
2469 s->qscale = 31;
2470 h263_dc_scale(s);
2471 }
2472 s->mv_dir = MV_DIR_FORWARD;
2473 if ((cbpc & 16) == 0) {
2474 PRINT_MB_TYPE("P");
2475 /* 16x16 motion prediction */
2476 s->mv_type = MV_TYPE_16X16;
2477 h263_pred_motion(s, 0, &pred_x, &pred_y);
2478 if (s->umvplus_dec)
2479 mx = h263p_decode_umotion(s, pred_x);
2480 else if(!s->mcsel)
2481 mx = h263_decode_motion(s, pred_x, s->f_code);
2482 else {
2483 const int a= s->sprite_warping_accuracy;
2484 // int l = (1 << (s->f_code - 1)) * 32;
2485 if(s->divx_version==500 && s->divx_build==413){
2486 mx = s->sprite_offset[0][0] / (1<<(a-s->quarter_sample));
2487 }else{
2488 mx = RSHIFT(s->sprite_offset[0][0], a-s->quarter_sample);
2489 }
2490 // if (mx < -l) mx= -l, printf("C");
2491 // else if (mx >= l) mx= l-1, printf("C");
2492 }
2493 if (mx >= 0xffff)
2494 return -1;
2495
2496 if (s->umvplus_dec)
2497 my = h263p_decode_umotion(s, pred_y);
2498 else if(!s->mcsel)
2499 my = h263_decode_motion(s, pred_y, s->f_code);
2500 else{
2501 const int a= s->sprite_warping_accuracy;
2502 // int l = (1 << (s->f_code - 1)) * 32;
2503 if(s->divx_version==500 && s->divx_build==413){
2504 my = s->sprite_offset[0][1] / (1<<(a-s->quarter_sample));
2505 }else{
2506 my = RSHIFT(s->sprite_offset[0][1], a-s->quarter_sample);
2507 }
2508 // if (my < -l) my= -l, printf("C");
2509 // else if (my >= l) my= l-1, printf("C");
2510 }
2511 if (my >= 0xffff)
2512 return -1;
2513 s->mv[0][0][0] = mx;
2514 s->mv[0][0][1] = my;
2515 /*fprintf(stderr, "\n MB %d", (s->mb_y * s->mb_width) + s->mb_x);
2516 fprintf(stderr, "\n\tmvx: %d\t\tpredx: %d", mx, pred_x);
2517 fprintf(stderr, "\n\tmvy: %d\t\tpredy: %d", my, pred_y);*/
2518 if (s->umvplus_dec && (mx - pred_x) == 1 && (my - pred_y) == 1)
2519 skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */
2520
2521 } else {
2522 PRINT_MB_TYPE("4");
2523 s->mv_type = MV_TYPE_8X8;
2524 for(i=0;i<4;i++) {
2525 mot_val = h263_pred_motion(s, i, &pred_x, &pred_y);
2526 if (s->umvplus_dec)
2527 mx = h263p_decode_umotion(s, pred_x);
2528 else
2529 mx = h263_decode_motion(s, pred_x, s->f_code);
2530 if (mx >= 0xffff)
2531 return -1;
2532
2533 if (s->umvplus_dec)
2534 my = h263p_decode_umotion(s, pred_y);
2535 else
2536 my = h263_decode_motion(s, pred_y, s->f_code);
2537 if (my >= 0xffff)
2538 return -1;
2539 s->mv[0][i][0] = mx;
2540 s->mv[0][i][1] = my;
2541 if (s->umvplus_dec && (mx - pred_x) == 1 && (my - pred_y) == 1)
2542 skip_bits1(&s->gb); /* Bit stuffing to prevent PSC */
2543 mot_val[0] = mx;
2544 mot_val[1] = my;
2545 }
2546 }
2547 } else if(s->pict_type==B_TYPE) {
2548 int modb1; // first bit of modb
2549 int modb2; // second bit of modb
2550 int mb_type;
2551 uint16_t time_pp;
2552 uint16_t time_pb;
2553 int xy;
2554
2555 s->mb_intra = 0; //B-frames never contain intra blocks
2556 s->mcsel=0; // ... true gmc blocks
2557
2558 if(s->mb_x==0){
2559 s->last_mv[0][0][0]=
2560 s->last_mv[0][0][1]=
2561 s->last_mv[1][0][0]=
2562 s->last_mv[1][0][1]= 0;
2563 }
2564
2565 /* if we skipped it in the future P Frame than skip it now too */
2566 s->mb_skiped= s->mbskip_table[s->mb_y * s->mb_width + s->mb_x]; // Note, skiptab=0 if last was GMC
2567
2568 if(s->mb_skiped){
2569 /* skip mb */
2570 for(i=0;i<6;i++)
2571 s->block_last_index[i] = -1;
2572
2573 s->mv_dir = MV_DIR_FORWARD;
2574 s->mv_type = MV_TYPE_16X16;
2575 s->mv[0][0][0] = 0;
2576 s->mv[0][0][1] = 0;
2577 s->mv[1][0][0] = 0;
2578 s->mv[1][0][1] = 0;
2579 //FIXME is this correct?
2580 /* s->last_mv[0][0][0]=
2581 s->last_mv[0][0][1]=0;*/
2582 PRINT_MB_TYPE("s");
2583 return 0;
2584 }
2585
2586 modb1= get_bits1(&s->gb);
2587 if(modb1==0){
2588 modb2= get_bits1(&s->gb);
2589 mb_type= get_vlc(&s->gb, &mb_type_b_vlc);
2590 if(modb2==0) cbp= get_bits(&s->gb, 6);
2591 else cbp=0;
2592 if (mb_type && cbp) {
2593 if(get_bits1(&s->gb)){
2594 s->qscale +=get_bits1(&s->gb)*4 - 2;
2595 if (s->qscale < 1)
2596 s->qscale = 1;
2597 else if (s->qscale > 31)
2598 s->qscale = 31;
2599 h263_dc_scale(s);
2600 }
2601 }
2602 }else{
2603 mb_type=4; //like 0 but no vectors coded
2604 cbp=0;
2605 }
2606 s->mv_type = MV_TYPE_16X16; // we'll switch to 8x8 only if the last P frame had 8x8 for this MB and mb_type=0 here
2607 mx=my=0; //for case 4, we could put this to the mb_type=4 but than gcc compains about uninitalized mx/my
2608 switch(mb_type)
2609 {
2610 case 0: /* direct */
2611 mx = h263_decode_motion(s, 0, 1);
2612 my = h263_decode_motion(s, 0, 1);
2613 case 4: /* direct with mx=my=0 */
2614 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD | MV_DIRECT;
2615 xy= s->block_index[0];
2616 time_pp= s->pp_time;
2617 time_pb= time_pp - s->bp_time;
2618 //if(time_pp>3000 )printf("%d %d ", time_pp, time_pb);
2619 //FIXME 4MV
2620 //FIXME avoid divides
2621 s->mv[0][0][0] = s->motion_val[xy][0]*time_pb/time_pp + mx;
2622 s->mv[0][0][1] = s->motion_val[xy][1]*time_pb/time_pp + my;
2623 s->mv[1][0][0] = mx ? s->mv[0][0][0] - s->motion_val[xy][0]
2624 : s->motion_val[xy][0]*(time_pb - time_pp)/time_pp + mx;
2625 s->mv[1][0][1] = my ? s->mv[0][0][1] - s->motion_val[xy][1]
2626 : s->motion_val[xy][1]*(time_pb - time_pp)/time_pp + my;
2627 /* s->mv[0][0][0] =
2628 s->mv[0][0][1] =
2629 s->mv[1][0][0] =
2630 s->mv[1][0][1] = 1000;*/
2631 PRINT_MB_TYPE("D");
2632 break;
2633 case 1:
2634 s->mv_dir = MV_DIR_FORWARD | MV_DIR_BACKWARD;
2635 mx = h263_decode_motion(s, s->last_mv[0][0][0], s->f_code);
2636 my = h263_decode_motion(s, s->last_mv[0][0][1], s->f_code);
2637 s->last_mv[0][0][0]= s->mv[0][0][0] = mx;
2638 s->last_mv[0][0][1]= s->mv[0][0][1] = my;
2639
2640 mx = h263_decode_motion(s, s->last_mv[1][0][0], s->b_code);
2641 my = h263_decode_motion(s, s->last_mv[1][0][1], s->b_code);
2642 s->last_mv[1][0][0]= s->mv[1][0][0] = mx;
2643 s->last_mv[1][0][1]= s->mv[1][0][1] = my;
2644 PRINT_MB_TYPE("i");
2645 break;
2646 case 2:
2647 s->mv_dir = MV_DIR_BACKWARD;
2648 mx = h263_decode_motion(s, s->last_mv[1][0][0], s->b_code);
2649 my = h263_decode_motion(s, s->last_mv[1][0][1], s->b_code);
2650 s->last_mv[1][0][0]= s->mv[1][0][0] = mx;
2651 s->last_mv[1][0][1]= s->mv[1][0][1] = my;
2652 PRINT_MB_TYPE("B");
2653 break;
2654 case 3:
2655 s->mv_dir = MV_DIR_FORWARD;
2656 mx = h263_decode_motion(s, s->last_mv[0][0][0], s->f_code);
2657 my = h263_decode_motion(s, s->last_mv[0][0][1], s->f_code);
2658 s->last_mv[0][0][0]= s->mv[0][0][0] = mx;
2659 s->last_mv[0][0][1]= s->mv[0][0][1] = my;
2660 PRINT_MB_TYPE("F");
2661 break;
2662 default:
2663 printf("illegal MB_type\n");
2664 return -1;
2665 }
2666 } else { /* I-Frame */
2667 cbpc = get_vlc(&s->gb, &intra_MCBPC_vlc);
2668 if (cbpc < 0)
2669 return -1;
2670 dquant = cbpc & 4;
2671 s->mb_intra = 1;
2672 intra:
2673 PRINT_MB_TYPE("I");
2674 s->ac_pred = 0;
2675 if (s->h263_pred || s->h263_aic) {
2676 s->ac_pred = get_bits1(&s->gb);
2677 if (s->ac_pred && s->h263_aic)
2678 s->h263_aic_dir = get_bits1(&s->gb);
2679 }
2680 cbpy = get_vlc(&s->gb, &cbpy_vlc);
2681 if(cbpy<0) return -1;
2682 cbp = (cbpc & 3) | (cbpy << 2);
2683 if (dquant) {
2684 s->qscale += quant_tab[get_bits(&s->gb, 2)];
2685 if (s->qscale < 1)
2686 s->qscale = 1;
2687 else if (s->qscale > 31)
2688 s->qscale = 31;
2689 h263_dc_scale(s);
2690 }
2691 }
2692
2693 /* decode each block */
2694 if (s->h263_pred) {
2695 for (i = 0; i < 6; i++) {
2696 if (mpeg4_decode_block(s, block[i], i, (cbp >> (5 - i)) & 1) < 0)
2697 return -1;
2698 }
2699 } else {
2700 for (i = 0; i < 6; i++) {
2701 if (h263_decode_block(s, block[i], i, (cbp >> (5 - i)) & 1) < 0)
2702 return -1;
2703 }
2704 }
2705 return 0;
2706 }
2707
2708 static int h263_decode_motion(MpegEncContext * s, int pred, int f_code)
2709 {
2710 int code, val, sign, shift, l, m;
2711
2712 code = get_vlc(&s->gb, &mv_vlc);
2713 if (code < 0)
2714 return 0xffff;
2715
2716 if (code == 0)
2717 return pred;
2718 sign = get_bits1(&s->gb);
2719 shift = f_code - 1;
2720 val = (code - 1) << shift;
2721 if (shift > 0)
2722 val |= get_bits(&s->gb, shift);
2723 val++;
2724 if (sign)
2725 val = -val;
2726 val += pred;
2727
2728 /* modulo decoding */
2729 if (!s->h263_long_vectors) {
2730 l = (1 << (f_code - 1)) * 32;
2731 m = 2 * l;
2732 if (val < -l) {
2733 val += m;
2734 } else if (val >= l) {
2735 val -= m;
2736 }
2737 } else {
2738 /* horrible h263 long vector mode */
2739 if (pred < -31 && val < -63)
2740 val += 64;
2741 if (pred > 32 && val > 63)
2742 val -= 64;
2743
2744 }
2745 return val;
2746 }
2747
2748 /* Decodes RVLC of H.263+ UMV */
2749 static int h263p_decode_umotion(MpegEncContext * s, int pred)
2750 {
2751 int code = 0, sign;
2752
2753 if (get_bits1(&s->gb)) /* Motion difference = 0 */
2754 return pred;
2755
2756 code = 2 + get_bits1(&s->gb);
2757
2758 while (get_bits1(&s->gb))
2759 {
2760 code <<= 1;
2761 code += get_bits1(&s->gb);
2762 }
2763 sign = code & 1;
2764 code >>= 1;
2765
2766 code = (sign) ? (pred - code) : (pred + code);
2767 #ifdef DEBUG
2768 fprintf(stderr,"H.263+ UMV Motion = %d\n", code);
2769 #endif
2770 return code;
2771
2772 }
2773
2774 static int h263_decode_block(MpegEncContext * s, DCTELEM * block,
2775 int n, int coded)
2776 {
2777 int code, level, i, j, last, run;
2778 RLTable *rl = &rl_inter;
2779 const UINT8 *scan_table;
2780
2781 scan_table = zigzag_direct;
2782 if (s->h263_aic && s->mb_intra) {
2783 rl = &rl_intra_aic;
2784 i = 0;
2785 if (s->ac_pred) {
2786 if (s->h263_aic_dir)
2787 scan_table = ff_alternate_vertical_scan; /* left */
2788 else
2789 scan_table = ff_alternate_horizontal_scan; /* top */
2790 }
2791 } else if (s->mb_intra) {
2792 /* DC coef */
2793 if (s->h263_rv10 && s->rv10_version == 3 && s->pict_type == I_TYPE) {
2794 int component, diff;
2795 component = (n <= 3 ? 0 : n - 4 + 1);
2796 level = s->last_dc[component];
2797 if (s->rv10_first_dc_coded[component]) {
2798 diff = rv_decode_dc(s, n);
2799 if (diff == 0xffff)
2800 return -1;
2801 level += diff;
2802 level = level & 0xff; /* handle wrap round */
2803 s->last_dc[component] = level;
2804 } else {
2805 s->rv10_first_dc_coded[component] = 1;
2806 }
2807 } else {
2808 level = get_bits(&s->gb, 8);
2809 if (level == 255)
2810 level = 128;
2811 }
2812 block[0] = level;
2813 i = 1;
2814 } else {
2815 i = 0;
2816 }
2817 if (!coded) {
2818 if (s->mb_intra && s->h263_aic)
2819 goto not_coded;
2820 s->block_last_index[n] = i - 1;
2821 return 0;
2822 }
2823
2824 for(;;) {
2825 code = get_vlc(&s->gb, &rl->vlc);
2826 if (code < 0)
2827 return -1;
2828 if (code == rl->n) {
2829 /* escape */
2830 last = get_bits1(&s->gb);
2831 run = get_bits(&s->gb, 6);
2832 level = (INT8)get_bits(&s->gb, 8);
2833 if (s->h263_rv10 && level == -128) {
2834 /* XXX: should patch encoder too */
2835 level = get_bits(&s->gb, 12);
2836 level = (level << 20) >> 20;
2837 }
2838 } else {
2839 run = rl->table_run[code];
2840 level = rl->table_level[code];
2841 last = code >= rl->last;
2842 if (get_bits1(&s->gb))
2843 level = -level;
2844 }
2845 i += run;
2846 if (i >= 64)
2847 return -1;
2848 j = scan_table[i];
2849 block[j] = level;
2850 if (last)
2851 break;
2852 i++;
2853 }
2854 not_coded:
2855 if (s->mb_intra && s->h263_aic) {
2856 h263_pred_acdc(s, block, n);
2857 i = 63;
2858 }
2859 s->block_last_index[n] = i;
2860 return 0;
2861 }
2862
2863 static inline int mpeg4_decode_dc(MpegEncContext * s, int n, int *dir_ptr)
2864 {
2865 int level, pred, code;
2866 UINT16 *dc_val;
2867
2868 if (n < 4)
2869 code = get_vlc(&s->gb, &dc_lum);
2870 else
2871 code = get_vlc(&s->gb, &dc_chrom);
2872 if (code < 0 || code > 9 /* && s->nbit<9 */){
2873 fprintf(stderr, "illegal dc vlc\n");
2874 return -1;
2875 }
2876 if (code == 0) {
2877 level = 0;
2878 } else {
2879 level = get_bits(&s->gb, code);
2880 if ((level >> (code - 1)) == 0) /* if MSB not set it is negative*/
2881 level = - (level ^ ((1 << code) - 1));
2882 if (code > 8){
2883 if(get_bits1(&s->gb)==0){ /* marker */
2884 fprintf(stderr, "dc marker bit missing\n");
2885 return -1;
2886 }
2887 }
2888 }
2889
2890 pred = ff_mpeg4_pred_dc(s, n, &dc_val, dir_ptr);
2891 level += pred;
2892 if (level < 0)
2893 level = 0;
2894 if (n < 4) {
2895 *dc_val = level * s->y_dc_scale;
2896 } else {
2897 *dc_val = level * s->c_dc_scale;
2898 }
2899 return level;
2900 }
2901
2902 /**
2903 * decode a block
2904 * returns 0 if everything went ok
2905 * returns DECODING_AC_LOST if an error was detected during AC decoding
2906 * returns DECODING_ACDC_LOST if an error was detected during DC decoding
2907 */
2908 static inline int mpeg4_decode_block(MpegEncContext * s, DCTELEM * block,
2909 int n, int coded)
2910 {
2911 int code, level, i, j, last, run;
2912 int dc_pred_dir;
2913 RLTable *rl;
2914 const UINT8 *scan_table;
2915
2916 if (s->mb_intra) {
2917 /* DC coef */
2918 if(s->data_partitioning && s->pict_type!=B_TYPE){
2919 level = s->dc_val[0][ s->block_index[n] ];
2920 if(n<4) level= (level + (s->y_dc_scale>>1))/s->y_dc_scale; //FIXME optimizs
2921 else level= (level + (s->c_dc_scale>>1))/s->c_dc_scale;
2922 dc_pred_dir= (s->pred_dir_table[s->mb_x + s->mb_y*s->mb_width]<<n)&32;
2923 }else{
2924 level = mpeg4_decode_dc(s, n, &dc_pred_dir);
2925 if (level < 0)
2926 return DECODING_ACDC_LOST;
2927 }
2928 block[0] = level;
2929 i = 1;
2930 if (!coded)
2931 goto not_coded;
2932 rl = &rl_intra;
2933 if (s->ac_pred) {
2934 if (dc_pred_dir == 0)
2935 scan_table = ff_alternate_vertical_scan; /* left */
2936 else
2937 scan_table = ff_alternate_horizontal_scan; /* top */
2938 } else {
2939 scan_table = zigzag_direct;
2940 }
2941 } else {
2942 i = 0;
2943 if (!coded) {
2944 s->block_last_index[n] = i - 1;
2945 return 0;
2946 }
2947 rl = &rl_inter;
2948 scan_table = zigzag_direct;
2949 }
2950
2951 for(;;) {
2952 code = get_vlc(&s->gb, &rl->vlc);
2953 if (code < 0)
2954 return DECODING_AC_LOST;
2955 if (code == rl->n) {
2956 /* escape */
2957 if (get_bits1(&s->gb) != 0) {
2958 if (get_bits1(&s->gb) != 0) {
2959 /* third escape */
2960 last = get_bits1(&s->gb);
2961 run = get_bits(&s->gb, 6);
2962 if(get_bits1(&s->gb)==0){
2963 fprintf(stderr, "1. marker bit missing in 3. esc\n");
2964 return DECODING_AC_LOST;
2965 }
2966 level = get_bits(&s->gb, 12);
2967 level = (level << 20) >> 20; /* sign extend */
2968 if(get_bits1(&s->gb)==0){
2969 fprintf(stderr, "2. marker bit missing in 3. esc\n");
2970 return DECODING_AC_LOST;
2971 }
2972 if(level>512 || level<-512){ //FIXME check that QP=1 is ok with this too
2973 fprintf(stderr, "|level| overflow in 3. esc\n");
2974 return DECODING_AC_LOST;
2975 }
2976 #if 1
2977 {
2978 const int abs_level= ABS(level);
2979 if(abs_level<=MAX_LEVEL && run<=MAX_RUN && s->error_resilience>=0){
2980 const int run1= run - rl->max_run[last][abs_level] - 1;
2981 if(abs_level <= rl->max_level[last][run]){
2982 fprintf(stderr, "illegal 3. esc, vlc encoding possible\n");
2983 return DECODING_AC_LOST;
2984 }
2985 if(abs_level <= rl->max_level[last][run]*2){
2986 fprintf(stderr, "illegal 3. esc, esc 1 encoding possible\n");
2987 return DECODING_AC_LOST;
2988 }
2989 if(run1 >= 0 && abs_level <= rl->max_level[last][run1]){
2990 fprintf(stderr, "illegal 3. esc, esc 2 encoding possible\n");
2991 return DECODING_AC_LOST;
2992 }
2993 }
2994 }
2995 #endif
2996 } else {
2997 /* second escape */
2998 code = get_vlc(&s->gb, &rl->vlc);
2999 if (code < 0 || code >= rl->n)
3000 return DECODING_AC_LOST;
3001 run = rl->table_run[code];
3002 level = rl->table_level[code];
3003 last = code >= rl->last;
3004 run += rl->max_run[last][level] + 1;
3005 if (get_bits1(&s->gb))
3006 level = -level;
3007 }
3008 } else {
3009 /* first escape */
3010 code = get_vlc(&s->gb, &rl->vlc);
3011 if (code < 0 || code >= rl->n)
3012 return DECODING_AC_LOST;
3013 run = rl->table_run[code];
3014 level = rl->table_level[code];
3015 last = code >= rl->last;
3016 level += rl->max_level[last][run];
3017 if (get_bits1(&s->gb))
3018 level = -level;
3019 }
3020 } else {
3021 run = rl->table_run[code];
3022 level = rl->table_level[code];
3023 last = code >= rl->last;
3024 if (get_bits1(&s->gb))
3025 level = -level;
3026 }
3027 i += run;
3028 if (i >= 64)
3029 return DECODING_AC_LOST;
3030 j = scan_table[i];
3031 block[j] = level;
3032 i++;
3033 if (last)
3034 break;
3035 }
3036 not_coded:
3037 if (s->mb_intra) {
3038 mpeg4_pred_ac(s, block, n, dc_pred_dir);
3039 if (s->ac_pred) {
3040 i = 64; /* XXX: not optimal */
3041 }
3042 }
3043 s->block_last_index[n] = i - 1;
3044 return 0;
3045 }
3046
3047 /* most is hardcoded. should extend to handle all h263 streams */
3048 int h263_decode_picture_header(MpegEncContext *s)
3049 {
3050 int format, width, height;
3051
3052 /* picture start code */
3053 if (get_bits(&s->gb, 22) != 0x20) {
3054 fprintf(stderr, "Bad picture start code\n");
3055 return -1;
3056 }
3057 /* temporal reference */
3058 s->picture_number = get_bits(&s->gb, 8); /* picture timestamp */
3059
3060 /* PTYPE starts here */
3061 if (get_bits1(&s->gb) != 1) {
3062 /* marker */
3063 fprintf(stderr, "Bad marker\n");
3064 return -1;
3065 }
3066 if (get_bits1(&s->gb) != 0) {
3067 fprintf(stderr, "Bad H263 id\n");
3068 return -1; /* h263 id */
3069 }
3070 skip_bits1(&s->gb); /* split screen off */
3071 skip_bits1(&s->gb); /* camera off */
3072 skip_bits1(&s->gb); /* freeze picture release off */
3073
3074 /* Reset GOB number */
3075 s->gob_number = 0;
3076
3077 format = get_bits(&s->gb, 3);
3078 /*
3079 0 forbidden
3080 1 sub-QCIF
3081 10 QCIF
3082 7 extended PTYPE (PLUSPTYPE)
3083 */
3084
3085 if (format != 7 && format != 6) {
3086 s->h263_plus = 0;
3087 /* H.263v1 */
3088 width = h263_format[format][0];
3089 height = h263_format[format][1];
3090 if (!width)
3091 return -1;
3092
3093 s->width = width;
3094 s->height = height;
3095 s->pict_type = I_TYPE + get_bits1(&s->gb);
3096
3097 s->unrestricted_mv = get_bits1(&s->gb);
3098 s->h263_long_vectors = s->unrestricted_mv;
3099
3100 if (get_bits1(&s->gb) != 0) {
3101 fprintf(stderr, "H263 SAC not supported\n");
3102 return -1; /* SAC: off */
3103 }
3104 if (get_bits1(&s->gb) != 0) {
3105 s->mv_type = MV_TYPE_8X8; /* Advanced prediction mode */
3106 }
3107
3108 if (get_bits1(&s->gb) != 0) {
3109 fprintf(stderr, "H263 PB frame not supported\n");
3110 return -1; /* not PB frame */
3111 }
3112 s->qscale = get_bits(&s->gb, 5);
3113 skip_bits1(&s->gb); /* Continuous Presence Multipoint mode: off */
3114 } else {
3115 int ufep;
3116
3117 /* H.263v2 */
3118 s->h263_plus = 1;
3119 ufep = get_bits(&s->gb, 3); /* Update Full Extended PTYPE */
3120
3121 /* ufep other than 0 and 1 are reserved */
3122 if (ufep == 1) {
3123 /* OPPTYPE */
3124 format = get_bits(&s->gb, 3);
3125 dprintf("ufep=1, format: %d\n", format);
3126 skip_bits(&s->gb,1); /* Custom PCF */
3127 s->umvplus_dec = get_bits(&s->gb, 1); /* Unrestricted Motion Vector */
3128 skip_bits1(&s->gb); /* Syntax-based Arithmetic Coding (SAC) */
3129 if (get_bits1(&s->gb) != 0) {
3130 s->mv_type = MV_TYPE_8X8; /* Advanced prediction mode */
3131 }
3132 if (get_bits1(&s->gb) != 0) { /* Advanced Intra Coding (AIC) */
3133 s->h263_aic = 1;
3134 }
3135
3136 skip_bits(&s->gb, 7);
3137 /* these are the 7 bits: (in order of appearence */
3138 /* Deblocking Filter */
3139 /* Slice Structured */
3140 /* Reference Picture Selection */
3141 /* Independent Segment Decoding */
3142 /* Alternative Inter VLC */
3143 /* Modified Quantization */
3144 /* Prevent start code emulation */
3145
3146 skip_bits(&s->gb, 3); /* Reserved */
3147 } else if (ufep != 0) {
3148 fprintf(stderr, "Bad UFEP type (%d)\n", ufep);
3149 return -1;
3150 }
3151
3152 /* MPPTYPE */
3153 s->pict_type = get_bits(&s->gb, 3) + I_TYPE;
3154 dprintf("pict_type: %d\n", s->pict_type);
3155 if (s->pict_type != I_TYPE &&
3156 s->pict_type != P_TYPE)
3157 return -1;
3158 skip_bits(&s->gb, 2);
3159 s->no_rounding = get_bits1(&s->gb);
3160 dprintf("RTYPE: %d\n", s->no_rounding);
3161 skip_bits(&s->gb, 4);
3162
3163 /* Get the picture dimensions */
3164 if (ufep) {
3165 if (format == 6) {
3166 /* Custom Picture Format (CPFMT) */
3167 s->aspect_ratio_info = get_bits(&s->gb, 4);
3168 dprintf("aspect: %d\n", s->aspect_ratio_info);
3169 /* aspect ratios:
3170 0 - forbidden
3171 1 - 1:1
3172 2 - 12:11 (CIF 4:3)
3173 3 - 10:11 (525-type 4:3)
3174 4 - 16:11 (CIF 16:9)
3175 5 - 40:33 (525-type 16:9)
3176 6-14 - reserved
3177 */
3178 width = (get_bits(&s->gb, 9) + 1) * 4;
3179 skip_bits1(&s->gb);
3180 height = get_bits(&s->gb, 9) * 4;
3181 dprintf("\nH.263+ Custom picture: %dx%d\n",width,height);
3182 if (s->aspect_ratio_info == EXTENDED_PAR) {
3183 /* aspected dimensions */
3184 skip_bits(&s->gb, 8); /* width */
3185 skip_bits(&s->gb, 8); /* height */
3186 }
3187 } else {
3188 width = h263_format[format][0];
3189 height = h263_format[format][1];
3190 }
3191 if ((width == 0) || (height == 0))
3192 return -1;
3193 s->width = width;
3194 s->height = height;
3195 if (s->umvplus_dec) {
3196 skip_bits1(&s->gb); /* Unlimited Unrestricted Motion Vectors Indicator (UUI) */
3197 }
3198 }
3199
3200 s->qscale = get_bits(&s->gb, 5);
3201 }
3202 /* PEI */
3203 while (get_bits1(&s->gb) != 0) {
3204 skip_bits(&s->gb, 8);
3205 }
3206 s->f_code = 1;
3207
3208 if(s->h263_aic){
3209 s->y_dc_scale_table=
3210 s->c_dc_scale_table= h263_aic_dc_scale_table;
3211 }else{
3212 s->y_dc_scale_table=
3213 s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
3214 }
3215
3216 return 0;
3217 }
3218
3219 static void mpeg4_decode_sprite_trajectory(MpegEncContext * s)
3220 {
3221 int i;
3222 int a= 2<<s->sprite_warping_accuracy;
3223 int rho= 3-s->sprite_warping_accuracy;
3224 int r=16/a;
3225 const int vop_ref[4][2]= {{0,0}, {s->width,0}, {0, s->height}, {s->width, s->height}}; // only true for rectangle shapes
3226 int d[4][2]={{0,0}, {0,0}, {0,0}, {0,0}};
3227 int sprite_ref[4][2];
3228 int virtual_ref[2][2];
3229 int w2, h2;
3230 int alpha=0, beta=0;
3231 int w= s->width;
3232 int h= s->height;
3233 //printf("SP %d\n", s->sprite_warping_accuracy);
3234 for(i=0; i<s->num_sprite_warping_points; i++){
3235 int length;
3236 int x=0, y=0;
3237
3238 length= get_vlc(&s->gb, &sprite_trajectory);
3239 if(length){
3240 x= get_bits(&s->gb, length);
3241 //printf("lx %d %d\n", length, x);
3242 if ((x >> (length - 1)) == 0) /* if MSB not set it is negative*/
3243 x = - (x ^ ((1 << length) - 1));
3244 }
3245 if(!(s->divx_version==500 && s->divx_build==413)) skip_bits1(&s->gb); /* marker bit */
3246
3247 length= get_vlc(&s->gb, &sprite_trajectory);
3248 if(length){
3249 y=get_bits(&s->gb, length);
3250 //printf("ly %d %d\n", length, y);
3251 if ((y >> (length - 1)) == 0) /* if MSB not set it is negative*/
3252 y = - (y ^ ((1 << length) - 1));
3253 }
3254 skip_bits1(&s->gb); /* marker bit */
3255 //printf("%d %d %d %d\n", x, y, i, s->sprite_warping_accuracy);
3256 //if(i>0 && (x!=0 || y!=0)) printf("AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\n");
3257 //x=y=0;
3258 d[i][0]= x;
3259 d[i][1]= y;
3260 }
3261
3262 while((1<<alpha)<w) alpha++;
3263 while((1<<beta )<h) beta++; // there seems to be a typo in the mpeg4 std for the definition of w' and h'
3264 w2= 1<<alpha;
3265 h2= 1<<beta;
3266
3267 // Note, the 4th point isnt used for GMC
3268 if(s->divx_version==500 && s->divx_build==413){
3269 sprite_ref[0][0]= a*vop_ref[0][0] + d[0][0];
3270 sprite_ref[0][1]= a*vop_ref[0][1] + d[0][1];
3271 sprite_ref[1][0]= a*vop_ref[1][0] + d[0][0] + d[1][0];
3272 sprite_ref[1][1]= a*vop_ref[1][1] + d[0][1] + d[1][1];
3273 sprite_ref[2][0]= a*vop_ref[2][0] + d[0][0] + d[2][0];
3274 sprite_ref[2][1]= a*vop_ref[2][1] + d[0][1] + d[2][1];
3275 } else {
3276 sprite_ref[0][0]= (a>>1)*(2*vop_ref[0][0] + d[0][0]);
3277 sprite_ref[0][1]= (a>>1)*(2*vop_ref[0][1] + d[0][1]);
3278 sprite_ref[1][0]= (a>>1)*(2*vop_ref[1][0] + d[0][0] + d[1][0]);
3279 sprite_ref[1][1]= (a>>1)*(2*vop_ref[1][1] + d[0][1] + d[1][1]);
3280 sprite_ref[2][0]= (a>>1)*(2*vop_ref[2][0] + d[0][0] + d[2][0]);
3281 sprite_ref[2][1]= (a>>1)*(2*vop_ref[2][1] + d[0][1] + d[2][1]);
3282 }
3283 /* sprite_ref[3][0]= (a>>1)*(2*vop_ref[3][0] + d[0][0] + d[1][0] + d[2][0] + d[3][0]);
3284 sprite_ref[3][1]= (a>>1)*(2*vop_ref[3][1] + d[0][1] + d[1][1] + d[2][1] + d[3][1]); */
3285
3286 // this is mostly identical to the mpeg4 std (and is totally unreadable because of that ...)
3287 // perhaps it should be reordered to be more readable ...
3288 // the idea behind this virtual_ref mess is to be able to use shifts later per pixel instead of divides
3289 // so the distance between points is converted from w&h based to w2&h2 based which are of the 2^x form
3290 virtual_ref[0][0]= 16*(vop_ref[0][0] + w2)
3291 + ROUNDED_DIV(((w - w2)*(r*sprite_ref[0][0] - 16*vop_ref[0][0]) + w2*(r*sprite_ref[1][0] - 16*vop_ref[1][0])),w);
3292 virtual_ref[0][1]= 16*vop_ref[0][1]
3293 + ROUNDED_DIV(((w - w2)*(r*sprite_ref[0][1] - 16*vop_ref[0][1]) + w2*(r*sprite_ref[1][1] - 16*vop_ref[1][1])),w);
3294 virtual_ref[1][0]= 16*vop_ref[0][0]
3295 + ROUNDED_DIV(((h - h2)*(r*sprite_ref[0][0] - 16*vop_ref[0][0]) + h2*(r*sprite_ref[2][0] - 16*vop_ref[2][0])),h);
3296 virtual_ref[1][1]= 16*(vop_ref[0][1] + h2)
3297 + ROUNDED_DIV(((h - h2)*(r*sprite_ref[0][1] - 16*vop_ref[0][1]) + h2*(r*sprite_ref[2][1] - 16*vop_ref[2][1])),h);
3298
3299 switch(s->num_sprite_warping_points)
3300 {
3301 case 0:
3302 s->sprite_offset[0][0]= 0;
3303 s->sprite_offset[0][1]= 0;
3304 s->sprite_offset[1][0]= 0;
3305 s->sprite_offset[1][1]= 0;
3306 s->sprite_delta[0][0][0]= a;
3307 s->sprite_delta[0][0][1]= 0;
3308 s->sprite_delta[0][1][