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