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