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