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