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