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