FFmpeg
 All Data Structures Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
ituh263enc.c
Go to the documentation of this file.
1 /*
2  * ITU H263 bitstream encoder
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 file is part of FFmpeg.
9  *
10  * FFmpeg is free software; you can redistribute it and/or
11  * modify it under the terms of the GNU Lesser General Public
12  * License as published by the Free Software Foundation; either
13  * version 2.1 of the License, or (at your option) any later version.
14  *
15  * FFmpeg is distributed in the hope that it will be useful,
16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
18  * Lesser General Public License for more details.
19  *
20  * You should have received a copy of the GNU Lesser General Public
21  * License along with FFmpeg; if not, write to the Free Software
22  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
23  */
24 
25 /**
26  * @file
27  * h263 bitstream encoder.
28  */
29 
30 //#define DEBUG
31 #include <limits.h>
32 
33 #include "dsputil.h"
34 #include "avcodec.h"
35 #include "mpegvideo.h"
36 #include "h263.h"
37 #include "mathops.h"
38 #include "unary.h"
39 #include "flv.h"
40 #include "mpeg4video.h"
41 #include "internal.h"
42 
43 /**
44  * Table of number of bits a motion vector component needs.
45  */
47 
48 /**
49  * Minimal fcode that a motion vector component would need.
50  */
51 static uint8_t fcode_tab[MAX_MV*2+1];
52 
53 /**
54  * Minimal fcode that a motion vector component would need in umv.
55  * All entries in this table are 1.
56  */
58 
59 //unified encoding tables for run length encoding of coefficients
60 //unified in the sense that the specification specifies the encoding in several steps.
62 static uint8_t uni_h263_inter_rl_len [64*64*2*2];
63 //#define UNI_MPEG4_ENC_INDEX(last,run,level) ((last)*128 + (run)*256 + (level))
64 //#define UNI_MPEG4_ENC_INDEX(last,run,level) ((last)*128*64 + (run) + (level)*64)
65 #define UNI_MPEG4_ENC_INDEX(last,run,level) ((last)*128*64 + (run)*128 + (level))
66 
67 static const uint8_t wrong_run[102] = {
68  1, 2, 3, 5, 4, 10, 9, 8,
69 11, 15, 17, 16, 23, 22, 21, 20,
70 19, 18, 25, 24, 27, 26, 11, 7,
71  6, 1, 2, 13, 2, 2, 2, 2,
72  6, 12, 3, 9, 1, 3, 4, 3,
73  7, 4, 1, 1, 5, 5, 14, 6,
74  1, 7, 1, 8, 1, 1, 1, 1,
75 10, 1, 1, 5, 9, 17, 25, 24,
76 29, 33, 32, 41, 2, 23, 28, 31,
77  3, 22, 30, 4, 27, 40, 8, 26,
78  6, 39, 7, 38, 16, 37, 15, 10,
79 11, 12, 13, 14, 1, 21, 20, 18,
80 19, 2, 1, 34, 35, 36
81 };
82 
83 /**
84  * Return the 4 bit value that specifies the given aspect ratio.
85  * This may be one of the standard aspect ratios or it specifies
86  * that the aspect will be stored explicitly later.
87  */
89  int i;
90 
91  if(aspect.num==0) aspect= (AVRational){1,1};
92 
93  for(i=1; i<6; i++){
94  if(av_cmp_q(ff_h263_pixel_aspect[i], aspect) == 0){
95  return i;
96  }
97  }
98 
99  return FF_ASPECT_EXTENDED;
100 }
101 
102 void ff_h263_encode_picture_header(MpegEncContext * s, int picture_number)
103 {
104  int format, coded_frame_rate, coded_frame_rate_base, i, temp_ref;
105  int best_clock_code=1;
106  int best_divisor=60;
107  int best_error= INT_MAX;
108 
109  if(s->h263_plus){
110  for(i=0; i<2; i++){
111  int div, error;
112  div= (s->avctx->time_base.num*1800000LL + 500LL*s->avctx->time_base.den) / ((1000LL+i)*s->avctx->time_base.den);
113  div= av_clip(div, 1, 127);
114  error= FFABS(s->avctx->time_base.num*1800000LL - (1000LL+i)*s->avctx->time_base.den*div);
115  if(error < best_error){
116  best_error= error;
117  best_divisor= div;
118  best_clock_code= i;
119  }
120  }
121  }
122  s->custom_pcf= best_clock_code!=1 || best_divisor!=60;
123  coded_frame_rate= 1800000;
124  coded_frame_rate_base= (1000+best_clock_code)*best_divisor;
125 
127 
128  /* Update the pointer to last GOB */
129  s->ptr_lastgob = put_bits_ptr(&s->pb);
130  put_bits(&s->pb, 22, 0x20); /* PSC */
131  temp_ref= s->picture_number * (int64_t)coded_frame_rate * s->avctx->time_base.num / //FIXME use timestamp
132  (coded_frame_rate_base * (int64_t)s->avctx->time_base.den);
133  put_sbits(&s->pb, 8, temp_ref); /* TemporalReference */
134 
135  put_bits(&s->pb, 1, 1); /* marker */
136  put_bits(&s->pb, 1, 0); /* h263 id */
137  put_bits(&s->pb, 1, 0); /* split screen off */
138  put_bits(&s->pb, 1, 0); /* camera off */
139  put_bits(&s->pb, 1, 0); /* freeze picture release off */
140 
142  if (!s->h263_plus) {
143  /* H.263v1 */
144  put_bits(&s->pb, 3, format);
145  put_bits(&s->pb, 1, (s->pict_type == AV_PICTURE_TYPE_P));
146  /* By now UMV IS DISABLED ON H.263v1, since the restrictions
147  of H.263v1 UMV implies to check the predicted MV after
148  calculation of the current MB to see if we're on the limits */
149  put_bits(&s->pb, 1, 0); /* Unrestricted Motion Vector: off */
150  put_bits(&s->pb, 1, 0); /* SAC: off */
151  put_bits(&s->pb, 1, s->obmc); /* Advanced Prediction */
152  put_bits(&s->pb, 1, 0); /* only I/P frames, no PB frame */
153  put_bits(&s->pb, 5, s->qscale);
154  put_bits(&s->pb, 1, 0); /* Continuous Presence Multipoint mode: off */
155  } else {
156  int ufep=1;
157  /* H.263v2 */
158  /* H.263 Plus PTYPE */
159 
160  put_bits(&s->pb, 3, 7);
161  put_bits(&s->pb,3,ufep); /* Update Full Extended PTYPE */
162  if (format == 8)
163  put_bits(&s->pb,3,6); /* Custom Source Format */
164  else
165  put_bits(&s->pb, 3, format);
166 
167  put_bits(&s->pb,1, s->custom_pcf);
168  put_bits(&s->pb,1, s->umvplus); /* Unrestricted Motion Vector */
169  put_bits(&s->pb,1,0); /* SAC: off */
170  put_bits(&s->pb,1,s->obmc); /* Advanced Prediction Mode */
171  put_bits(&s->pb,1,s->h263_aic); /* Advanced Intra Coding */
172  put_bits(&s->pb,1,s->loop_filter); /* Deblocking Filter */
173  put_bits(&s->pb,1,s->h263_slice_structured); /* Slice Structured */
174  put_bits(&s->pb,1,0); /* Reference Picture Selection: off */
175  put_bits(&s->pb,1,0); /* Independent Segment Decoding: off */
176  put_bits(&s->pb,1,s->alt_inter_vlc); /* Alternative Inter VLC */
177  put_bits(&s->pb,1,s->modified_quant); /* Modified Quantization: */
178  put_bits(&s->pb,1,1); /* "1" to prevent start code emulation */
179  put_bits(&s->pb,3,0); /* Reserved */
180 
181  put_bits(&s->pb, 3, s->pict_type == AV_PICTURE_TYPE_P);
182 
183  put_bits(&s->pb,1,0); /* Reference Picture Resampling: off */
184  put_bits(&s->pb,1,0); /* Reduced-Resolution Update: off */
185  put_bits(&s->pb,1,s->no_rounding); /* Rounding Type */
186  put_bits(&s->pb,2,0); /* Reserved */
187  put_bits(&s->pb,1,1); /* "1" to prevent start code emulation */
188 
189  /* This should be here if PLUSPTYPE */
190  put_bits(&s->pb, 1, 0); /* Continuous Presence Multipoint mode: off */
191 
192  if (format == 8) {
193  /* Custom Picture Format (CPFMT) */
195 
196  put_bits(&s->pb,4,s->aspect_ratio_info);
197  put_bits(&s->pb,9,(s->width >> 2) - 1);
198  put_bits(&s->pb,1,1); /* "1" to prevent start code emulation */
199  put_bits(&s->pb,9,(s->height >> 2));
201  put_bits(&s->pb, 8, s->avctx->sample_aspect_ratio.num);
202  put_bits(&s->pb, 8, s->avctx->sample_aspect_ratio.den);
203  }
204  }
205  if(s->custom_pcf){
206  if(ufep){
207  put_bits(&s->pb, 1, best_clock_code);
208  put_bits(&s->pb, 7, best_divisor);
209  }
210  put_sbits(&s->pb, 2, temp_ref>>8);
211  }
212 
213  /* Unlimited Unrestricted Motion Vectors Indicator (UUI) */
214  if (s->umvplus)
215 // put_bits(&s->pb,1,1); /* Limited according tables of Annex D */
216 //FIXME check actual requested range
217  put_bits(&s->pb,2,1); /* unlimited */
218  if(s->h263_slice_structured)
219  put_bits(&s->pb,2,0); /* no weird submodes */
220 
221  put_bits(&s->pb, 5, s->qscale);
222  }
223 
224  put_bits(&s->pb, 1, 0); /* no PEI */
225 
226  if(s->h263_slice_structured){
227  put_bits(&s->pb, 1, 1);
228 
229  av_assert1(s->mb_x == 0 && s->mb_y == 0);
231 
232  put_bits(&s->pb, 1, 1);
233  }
234 
235  if(s->h263_aic){
236  s->y_dc_scale_table=
238  }else{
239  s->y_dc_scale_table=
241  }
242 }
243 
244 /**
245  * Encode a group of blocks header.
246  */
248 {
249  put_bits(&s->pb, 17, 1); /* GBSC */
250 
251  if(s->h263_slice_structured){
252  put_bits(&s->pb, 1, 1);
253 
255 
256  if(s->mb_num > 1583)
257  put_bits(&s->pb, 1, 1);
258  put_bits(&s->pb, 5, s->qscale); /* GQUANT */
259  put_bits(&s->pb, 1, 1);
260  put_bits(&s->pb, 2, s->pict_type == AV_PICTURE_TYPE_I); /* GFID */
261  }else{
262  int gob_number= mb_line / s->gob_index;
263 
264  put_bits(&s->pb, 5, gob_number); /* GN */
265  put_bits(&s->pb, 2, s->pict_type == AV_PICTURE_TYPE_I); /* GFID */
266  put_bits(&s->pb, 5, s->qscale); /* GQUANT */
267  }
268 }
269 
270 /**
271  * modify qscale so that encoding is actually possible in h263 (limit difference to -2..2)
272  */
274  int i;
275  int8_t * const qscale_table = s->current_picture.f.qscale_table;
276 
278 
279  for(i=1; i<s->mb_num; i++){
280  if(qscale_table[ s->mb_index2xy[i] ] - qscale_table[ s->mb_index2xy[i-1] ] >2)
281  qscale_table[ s->mb_index2xy[i] ]= qscale_table[ s->mb_index2xy[i-1] ]+2;
282  }
283  for(i=s->mb_num-2; i>=0; i--){
284  if(qscale_table[ s->mb_index2xy[i] ] - qscale_table[ s->mb_index2xy[i+1] ] >2)
285  qscale_table[ s->mb_index2xy[i] ]= qscale_table[ s->mb_index2xy[i+1] ]+2;
286  }
287 
288  if(s->codec_id != AV_CODEC_ID_H263P){
289  for(i=1; i<s->mb_num; i++){
290  int mb_xy= s->mb_index2xy[i];
291 
292  if(qscale_table[mb_xy] != qscale_table[s->mb_index2xy[i-1]] && (s->mb_type[mb_xy]&CANDIDATE_MB_TYPE_INTER4V)){
293  s->mb_type[mb_xy]|= CANDIDATE_MB_TYPE_INTER;
294  }
295  }
296  }
297 }
298 
299 static const int dquant_code[5]= {1,0,9,2,3};
300 
301 /**
302  * Encode an 8x8 block.
303  * @param block the 8x8 block
304  * @param n block index (0-3 are luma, 4-5 are chroma)
305  */
306 static void h263_encode_block(MpegEncContext * s, DCTELEM * block, int n)
307 {
308  int level, run, last, i, j, last_index, last_non_zero, sign, slevel, code;
309  RLTable *rl;
310 
311  rl = &ff_h263_rl_inter;
312  if (s->mb_intra && !s->h263_aic) {
313  /* DC coef */
314  level = block[0];
315  /* 255 cannot be represented, so we clamp */
316  if (level > 254) {
317  level = 254;
318  block[0] = 254;
319  }
320  /* 0 cannot be represented also */
321  else if (level < 1) {
322  level = 1;
323  block[0] = 1;
324  }
325  if (level == 128) //FIXME check rv10
326  put_bits(&s->pb, 8, 0xff);
327  else
328  put_bits(&s->pb, 8, level);
329  i = 1;
330  } else {
331  i = 0;
332  if (s->h263_aic && s->mb_intra)
333  rl = &ff_rl_intra_aic;
334 
335  if(s->alt_inter_vlc && !s->mb_intra){
336  int aic_vlc_bits=0;
337  int inter_vlc_bits=0;
338  int wrong_pos=-1;
339  int aic_code;
340 
341  last_index = s->block_last_index[n];
342  last_non_zero = i - 1;
343  for (; i <= last_index; i++) {
344  j = s->intra_scantable.permutated[i];
345  level = block[j];
346  if (level) {
347  run = i - last_non_zero - 1;
348  last = (i == last_index);
349 
350  if(level<0) level= -level;
351 
352  code = get_rl_index(rl, last, run, level);
353  aic_code = get_rl_index(&ff_rl_intra_aic, last, run, level);
354  inter_vlc_bits += rl->table_vlc[code][1]+1;
355  aic_vlc_bits += ff_rl_intra_aic.table_vlc[aic_code][1]+1;
356 
357  if (code == rl->n) {
358  inter_vlc_bits += 1+6+8-1;
359  }
360  if (aic_code == ff_rl_intra_aic.n) {
361  aic_vlc_bits += 1+6+8-1;
362  wrong_pos += run + 1;
363  }else
364  wrong_pos += wrong_run[aic_code];
365  last_non_zero = i;
366  }
367  }
368  i = 0;
369  if(aic_vlc_bits < inter_vlc_bits && wrong_pos > 63)
370  rl = &ff_rl_intra_aic;
371  }
372  }
373 
374  /* AC coefs */
375  last_index = s->block_last_index[n];
376  last_non_zero = i - 1;
377  for (; i <= last_index; i++) {
378  j = s->intra_scantable.permutated[i];
379  level = block[j];
380  if (level) {
381  run = i - last_non_zero - 1;
382  last = (i == last_index);
383  sign = 0;
384  slevel = level;
385  if (level < 0) {
386  sign = 1;
387  level = -level;
388  }
389  code = get_rl_index(rl, last, run, level);
390  put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
391  if (code == rl->n) {
392  if(!CONFIG_FLV_ENCODER || s->h263_flv <= 1){
393  put_bits(&s->pb, 1, last);
394  put_bits(&s->pb, 6, run);
395 
396  av_assert2(slevel != 0);
397 
398  if(level < 128)
399  put_sbits(&s->pb, 8, slevel);
400  else{
401  put_bits(&s->pb, 8, 128);
402  put_sbits(&s->pb, 5, slevel);
403  put_sbits(&s->pb, 6, slevel>>5);
404  }
405  }else{
406  ff_flv2_encode_ac_esc(&s->pb, slevel, level, run, last);
407  }
408  } else {
409  put_bits(&s->pb, 1, sign);
410  }
411  last_non_zero = i;
412  }
413  }
414 }
415 
416 /* Encode MV differences on H.263+ with Unrestricted MV mode */
417 static void h263p_encode_umotion(MpegEncContext * s, int val)
418 {
419  short sval = 0;
420  short i = 0;
421  short n_bits = 0;
422  short temp_val;
423  int code = 0;
424  int tcode;
425 
426  if ( val == 0)
427  put_bits(&s->pb, 1, 1);
428  else if (val == 1)
429  put_bits(&s->pb, 3, 0);
430  else if (val == -1)
431  put_bits(&s->pb, 3, 2);
432  else {
433 
434  sval = ((val < 0) ? (short)(-val):(short)val);
435  temp_val = sval;
436 
437  while (temp_val != 0) {
438  temp_val = temp_val >> 1;
439  n_bits++;
440  }
441 
442  i = n_bits - 1;
443  while (i > 0) {
444  tcode = (sval & (1 << (i-1))) >> (i-1);
445  tcode = (tcode << 1) | 1;
446  code = (code << 2) | tcode;
447  i--;
448  }
449  code = ((code << 1) | (val < 0)) << 1;
450  put_bits(&s->pb, (2*n_bits)+1, code);
451  }
452 }
453 
455  DCTELEM block[6][64],
456  int motion_x, int motion_y)
457 {
458  int cbpc, cbpy, i, cbp, pred_x, pred_y;
459  int16_t pred_dc;
460  int16_t rec_intradc[6];
461  int16_t *dc_ptr[6];
462  const int interleaved_stats= (s->flags&CODEC_FLAG_PASS1);
463 
464  if (!s->mb_intra) {
465  /* compute cbp */
466  cbp= get_p_cbp(s, block, motion_x, motion_y);
467 
468  if ((cbp | motion_x | motion_y | s->dquant | (s->mv_type - MV_TYPE_16X16)) == 0) {
469  /* skip macroblock */
470  put_bits(&s->pb, 1, 1);
471  if(interleaved_stats){
472  s->misc_bits++;
473  s->last_bits++;
474  }
475  s->skip_count++;
476 
477  return;
478  }
479  put_bits(&s->pb, 1, 0); /* mb coded */
480 
481  cbpc = cbp & 3;
482  cbpy = cbp >> 2;
483  if(s->alt_inter_vlc==0 || cbpc!=3)
484  cbpy ^= 0xF;
485  if(s->dquant) cbpc+= 8;
486  if(s->mv_type==MV_TYPE_16X16){
487  put_bits(&s->pb,
490 
491  put_bits(&s->pb, ff_h263_cbpy_tab[cbpy][1], ff_h263_cbpy_tab[cbpy][0]);
492  if(s->dquant)
493  put_bits(&s->pb, 2, dquant_code[s->dquant+2]);
494 
495  if(interleaved_stats){
496  s->misc_bits+= get_bits_diff(s);
497  }
498 
499  /* motion vectors: 16x16 mode */
500  ff_h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
501 
502  if (!s->umvplus) {
503  ff_h263_encode_motion_vector(s, motion_x - pred_x,
504  motion_y - pred_y, 1);
505  }
506  else {
507  h263p_encode_umotion(s, motion_x - pred_x);
508  h263p_encode_umotion(s, motion_y - pred_y);
509  if (((motion_x - pred_x) == 1) && ((motion_y - pred_y) == 1))
510  /* To prevent Start Code emulation */
511  put_bits(&s->pb,1,1);
512  }
513  }else{
514  put_bits(&s->pb,
515  ff_h263_inter_MCBPC_bits[cbpc+16],
516  ff_h263_inter_MCBPC_code[cbpc+16]);
517  put_bits(&s->pb, ff_h263_cbpy_tab[cbpy][1], ff_h263_cbpy_tab[cbpy][0]);
518  if(s->dquant)
519  put_bits(&s->pb, 2, dquant_code[s->dquant+2]);
520 
521  if(interleaved_stats){
522  s->misc_bits+= get_bits_diff(s);
523  }
524 
525  for(i=0; i<4; i++){
526  /* motion vectors: 8x8 mode*/
527  ff_h263_pred_motion(s, i, 0, &pred_x, &pred_y);
528 
529  motion_x = s->current_picture.f.motion_val[0][s->block_index[i]][0];
530  motion_y = s->current_picture.f.motion_val[0][s->block_index[i]][1];
531  if (!s->umvplus) {
532  ff_h263_encode_motion_vector(s, motion_x - pred_x,
533  motion_y - pred_y, 1);
534  }
535  else {
536  h263p_encode_umotion(s, motion_x - pred_x);
537  h263p_encode_umotion(s, motion_y - pred_y);
538  if (((motion_x - pred_x) == 1) && ((motion_y - pred_y) == 1))
539  /* To prevent Start Code emulation */
540  put_bits(&s->pb,1,1);
541  }
542  }
543  }
544 
545  if(interleaved_stats){
546  s->mv_bits+= get_bits_diff(s);
547  }
548  } else {
549  av_assert2(s->mb_intra);
550 
551  cbp = 0;
552  if (s->h263_aic) {
553  /* Predict DC */
554  for(i=0; i<6; i++) {
555  int16_t level = block[i][0];
556  int scale;
557 
558  if(i<4) scale= s->y_dc_scale;
559  else scale= s->c_dc_scale;
560 
561  pred_dc = ff_h263_pred_dc(s, i, &dc_ptr[i]);
562  level -= pred_dc;
563  /* Quant */
564  if (level >= 0)
565  level = (level + (scale>>1))/scale;
566  else
567  level = (level - (scale>>1))/scale;
568 
569  /* AIC can change CBP */
570  if (level == 0 && s->block_last_index[i] == 0)
571  s->block_last_index[i] = -1;
572 
573  if(!s->modified_quant){
574  if (level < -127)
575  level = -127;
576  else if (level > 127)
577  level = 127;
578  }
579 
580  block[i][0] = level;
581  /* Reconstruction */
582  rec_intradc[i] = scale*level + pred_dc;
583  /* Oddify */
584  rec_intradc[i] |= 1;
585  //if ((rec_intradc[i] % 2) == 0)
586  // rec_intradc[i]++;
587  /* Clipping */
588  if (rec_intradc[i] < 0)
589  rec_intradc[i] = 0;
590  else if (rec_intradc[i] > 2047)
591  rec_intradc[i] = 2047;
592 
593  /* Update AC/DC tables */
594  *dc_ptr[i] = rec_intradc[i];
595  if (s->block_last_index[i] >= 0)
596  cbp |= 1 << (5 - i);
597  }
598  }else{
599  for(i=0; i<6; i++) {
600  /* compute cbp */
601  if (s->block_last_index[i] >= 1)
602  cbp |= 1 << (5 - i);
603  }
604  }
605 
606  cbpc = cbp & 3;
607  if (s->pict_type == AV_PICTURE_TYPE_I) {
608  if(s->dquant) cbpc+=4;
609  put_bits(&s->pb,
612  } else {
613  if(s->dquant) cbpc+=8;
614  put_bits(&s->pb, 1, 0); /* mb coded */
615  put_bits(&s->pb,
616  ff_h263_inter_MCBPC_bits[cbpc + 4],
617  ff_h263_inter_MCBPC_code[cbpc + 4]);
618  }
619  if (s->h263_aic) {
620  /* XXX: currently, we do not try to use ac prediction */
621  put_bits(&s->pb, 1, 0); /* no AC prediction */
622  }
623  cbpy = cbp >> 2;
624  put_bits(&s->pb, ff_h263_cbpy_tab[cbpy][1], ff_h263_cbpy_tab[cbpy][0]);
625  if(s->dquant)
626  put_bits(&s->pb, 2, dquant_code[s->dquant+2]);
627 
628  if(interleaved_stats){
629  s->misc_bits+= get_bits_diff(s);
630  }
631  }
632 
633  for(i=0; i<6; i++) {
634  /* encode each block */
635  h263_encode_block(s, block[i], i);
636 
637  /* Update INTRADC for decoding */
638  if (s->h263_aic && s->mb_intra) {
639  block[i][0] = rec_intradc[i];
640 
641  }
642  }
643 
644  if(interleaved_stats){
645  if (!s->mb_intra) {
646  s->p_tex_bits+= get_bits_diff(s);
647  s->f_count++;
648  }else{
649  s->i_tex_bits+= get_bits_diff(s);
650  s->i_count++;
651  }
652  }
653 }
654 
655 void ff_h263_encode_motion(MpegEncContext * s, int val, int f_code)
656 {
657  int range, bit_size, sign, code, bits;
658 
659  if (val == 0) {
660  /* zero vector */
661  code = 0;
662  put_bits(&s->pb, ff_mvtab[code][1], ff_mvtab[code][0]);
663  } else {
664  bit_size = f_code - 1;
665  range = 1 << bit_size;
666  /* modulo encoding */
667  val = sign_extend(val, 6 + bit_size);
668  sign = val>>31;
669  val= (val^sign)-sign;
670  sign&=1;
671 
672  val--;
673  code = (val >> bit_size) + 1;
674  bits = val & (range - 1);
675 
676  put_bits(&s->pb, ff_mvtab[code][1] + 1, (ff_mvtab[code][0] << 1) | sign);
677  if (bit_size > 0) {
678  put_bits(&s->pb, bit_size, bits);
679  }
680  }
681 }
682 
684 {
685  int f_code;
686  int mv;
687 
688  for(f_code=1; f_code<=MAX_FCODE; f_code++){
689  for(mv=-MAX_MV; mv<=MAX_MV; mv++){
690  int len;
691 
692  if(mv==0) len= ff_mvtab[0][1];
693  else{
694  int val, bit_size, code;
695 
696  bit_size = f_code - 1;
697 
698  val=mv;
699  if (val < 0)
700  val = -val;
701  val--;
702  code = (val >> bit_size) + 1;
703  if(code<33){
704  len= ff_mvtab[code][1] + 1 + bit_size;
705  }else{
706  len= ff_mvtab[32][1] + av_log2(code>>5) + 2 + bit_size;
707  }
708  }
709 
710  mv_penalty[f_code][mv+MAX_MV]= len;
711  }
712  }
713 
714  for(f_code=MAX_FCODE; f_code>0; f_code--){
715  for(mv=-(16<<f_code); mv<(16<<f_code); mv++){
716  fcode_tab[mv+MAX_MV]= f_code;
717  }
718  }
719 
720  for(mv=0; mv<MAX_MV*2+1; mv++){
721  umv_fcode_tab[mv]= 1;
722  }
723 }
724 
725 static void init_uni_h263_rl_tab(RLTable *rl, uint32_t *bits_tab, uint8_t *len_tab){
726  int slevel, run, last;
727 
728  av_assert0(MAX_LEVEL >= 64);
729  av_assert0(MAX_RUN >= 63);
730 
731  for(slevel=-64; slevel<64; slevel++){
732  if(slevel==0) continue;
733  for(run=0; run<64; run++){
734  for(last=0; last<=1; last++){
735  const int index= UNI_MPEG4_ENC_INDEX(last, run, slevel+64);
736  int level= slevel < 0 ? -slevel : slevel;
737  int sign= slevel < 0 ? 1 : 0;
738  int bits, len, code;
739 
740  len_tab[index]= 100;
741 
742  /* ESC0 */
743  code= get_rl_index(rl, last, run, level);
744  bits= rl->table_vlc[code][0];
745  len= rl->table_vlc[code][1];
746  bits=bits*2+sign; len++;
747 
748  if(code!=rl->n && len < len_tab[index]){
749  if(bits_tab) bits_tab[index]= bits;
750  len_tab [index]= len;
751  }
752  /* ESC */
753  bits= rl->table_vlc[rl->n][0];
754  len = rl->table_vlc[rl->n][1];
755  bits=bits*2+last; len++;
756  bits=bits*64+run; len+=6;
757  bits=bits*256+(level&0xff); len+=8;
758 
759  if(len < len_tab[index]){
760  if(bits_tab) bits_tab[index]= bits;
761  len_tab [index]= len;
762  }
763  }
764  }
765  }
766 }
767 
769 {
770  static int done = 0;
771 
772  if (!done) {
773  done = 1;
774 
777 
780 
782  }
783  s->me.mv_penalty= mv_penalty; //FIXME exact table for msmpeg4 & h263p
784 
787  if(s->h263_aic){
790  }
791  s->ac_esc_length= 7+1+6+8;
792 
793  // use fcodes >1 only for mpeg4 & h263 & h263p FIXME
794  switch(s->codec_id){
795  case AV_CODEC_ID_MPEG4:
796  s->fcode_tab= fcode_tab;
797  break;
798  case AV_CODEC_ID_H263P:
799  if(s->umvplus)
801  if(s->modified_quant){
802  s->min_qcoeff= -2047;
803  s->max_qcoeff= 2047;
804  }else{
805  s->min_qcoeff= -127;
806  s->max_qcoeff= 127;
807  }
808  break;
809  //Note for mpeg4 & h263 the dc-scale table will be set per frame as needed later
810  case AV_CODEC_ID_FLV1:
811  if (s->h263_flv > 1) {
812  s->min_qcoeff= -1023;
813  s->max_qcoeff= 1023;
814  } else {
815  s->min_qcoeff= -127;
816  s->max_qcoeff= 127;
817  }
818  s->y_dc_scale_table=
820  break;
821  default: //nothing needed - default table already set in mpegvideo.c
822  s->min_qcoeff= -127;
823  s->max_qcoeff= 127;
824  s->y_dc_scale_table=
826  }
827 }
828 
830 {
831  int i, mb_pos;
832 
833  for(i=0; i<6; i++){
834  if(s->mb_num-1 <= ff_mba_max[i]) break;
835  }
836  mb_pos= s->mb_x + s->mb_width*s->mb_y;
837  put_bits(&s->pb, ff_mba_length[i], mb_pos);
838 }