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