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