FFmpeg  2.6.3
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Modules 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 #include <limits.h>
31 
32 #include "libavutil/attributes.h"
33 #include "avcodec.h"
34 #include "mpegvideo.h"
35 #include "h263.h"
36 #include "mathops.h"
37 #include "mpegutils.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.den==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 
236 /**
237  * Encode a group of blocks header.
238  */
240 {
241  put_bits(&s->pb, 17, 1); /* GBSC */
242 
243  if(s->h263_slice_structured){
244  put_bits(&s->pb, 1, 1);
245 
247 
248  if(s->mb_num > 1583)
249  put_bits(&s->pb, 1, 1);
250  put_bits(&s->pb, 5, s->qscale); /* GQUANT */
251  put_bits(&s->pb, 1, 1);
252  put_bits(&s->pb, 2, s->pict_type == AV_PICTURE_TYPE_I); /* GFID */
253  }else{
254  int gob_number= mb_line / s->gob_index;
255 
256  put_bits(&s->pb, 5, gob_number); /* GN */
257  put_bits(&s->pb, 2, s->pict_type == AV_PICTURE_TYPE_I); /* GFID */
258  put_bits(&s->pb, 5, s->qscale); /* GQUANT */
259  }
260 }
261 
262 /**
263  * modify qscale so that encoding is actually possible in h263 (limit difference to -2..2)
264  */
266  int i;
267  int8_t * const qscale_table = s->current_picture.qscale_table;
268 
270 
271  for(i=1; i<s->mb_num; i++){
272  if(qscale_table[ s->mb_index2xy[i] ] - qscale_table[ s->mb_index2xy[i-1] ] >2)
273  qscale_table[ s->mb_index2xy[i] ]= qscale_table[ s->mb_index2xy[i-1] ]+2;
274  }
275  for(i=s->mb_num-2; i>=0; i--){
276  if(qscale_table[ s->mb_index2xy[i] ] - qscale_table[ s->mb_index2xy[i+1] ] >2)
277  qscale_table[ s->mb_index2xy[i] ]= qscale_table[ s->mb_index2xy[i+1] ]+2;
278  }
279 
280  if(s->codec_id != AV_CODEC_ID_H263P){
281  for(i=1; i<s->mb_num; i++){
282  int mb_xy= s->mb_index2xy[i];
283 
284  if(qscale_table[mb_xy] != qscale_table[s->mb_index2xy[i-1]] && (s->mb_type[mb_xy]&CANDIDATE_MB_TYPE_INTER4V)){
285  s->mb_type[mb_xy]|= CANDIDATE_MB_TYPE_INTER;
286  }
287  }
288  }
289 }
290 
291 static const int dquant_code[5]= {1,0,9,2,3};
292 
293 /**
294  * Encode an 8x8 block.
295  * @param block the 8x8 block
296  * @param n block index (0-3 are luma, 4-5 are chroma)
297  */
298 static void h263_encode_block(MpegEncContext * s, int16_t * block, int n)
299 {
300  int level, run, last, i, j, last_index, last_non_zero, sign, slevel, code;
301  RLTable *rl;
302 
303  rl = &ff_h263_rl_inter;
304  if (s->mb_intra && !s->h263_aic) {
305  /* DC coef */
306  level = block[0];
307  /* 255 cannot be represented, so we clamp */
308  if (level > 254) {
309  level = 254;
310  block[0] = 254;
311  }
312  /* 0 cannot be represented also */
313  else if (level < 1) {
314  level = 1;
315  block[0] = 1;
316  }
317  if (level == 128) //FIXME check rv10
318  put_bits(&s->pb, 8, 0xff);
319  else
320  put_bits(&s->pb, 8, level);
321  i = 1;
322  } else {
323  i = 0;
324  if (s->h263_aic && s->mb_intra)
325  rl = &ff_rl_intra_aic;
326 
327  if(s->alt_inter_vlc && !s->mb_intra){
328  int aic_vlc_bits=0;
329  int inter_vlc_bits=0;
330  int wrong_pos=-1;
331  int aic_code;
332 
333  last_index = s->block_last_index[n];
334  last_non_zero = i - 1;
335  for (; i <= last_index; i++) {
336  j = s->intra_scantable.permutated[i];
337  level = block[j];
338  if (level) {
339  run = i - last_non_zero - 1;
340  last = (i == last_index);
341 
342  if(level<0) level= -level;
343 
344  code = get_rl_index(rl, last, run, level);
345  aic_code = get_rl_index(&ff_rl_intra_aic, last, run, level);
346  inter_vlc_bits += rl->table_vlc[code][1]+1;
347  aic_vlc_bits += ff_rl_intra_aic.table_vlc[aic_code][1]+1;
348 
349  if (code == rl->n) {
350  inter_vlc_bits += 1+6+8-1;
351  }
352  if (aic_code == ff_rl_intra_aic.n) {
353  aic_vlc_bits += 1+6+8-1;
354  wrong_pos += run + 1;
355  }else
356  wrong_pos += wrong_run[aic_code];
357  last_non_zero = i;
358  }
359  }
360  i = 0;
361  if(aic_vlc_bits < inter_vlc_bits && wrong_pos > 63)
362  rl = &ff_rl_intra_aic;
363  }
364  }
365 
366  /* AC coefs */
367  last_index = s->block_last_index[n];
368  last_non_zero = i - 1;
369  for (; i <= last_index; i++) {
370  j = s->intra_scantable.permutated[i];
371  level = block[j];
372  if (level) {
373  run = i - last_non_zero - 1;
374  last = (i == last_index);
375  sign = 0;
376  slevel = level;
377  if (level < 0) {
378  sign = 1;
379  level = -level;
380  }
381  code = get_rl_index(rl, last, run, level);
382  put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
383  if (code == rl->n) {
384  if(!CONFIG_FLV_ENCODER || s->h263_flv <= 1){
385  put_bits(&s->pb, 1, last);
386  put_bits(&s->pb, 6, run);
387 
388  av_assert2(slevel != 0);
389 
390  if(level < 128)
391  put_sbits(&s->pb, 8, slevel);
392  else{
393  put_bits(&s->pb, 8, 128);
394  put_sbits(&s->pb, 5, slevel);
395  put_sbits(&s->pb, 6, slevel>>5);
396  }
397  }else{
398  ff_flv2_encode_ac_esc(&s->pb, slevel, level, run, last);
399  }
400  } else {
401  put_bits(&s->pb, 1, sign);
402  }
403  last_non_zero = i;
404  }
405  }
406 }
407 
408 /* Encode MV differences on H.263+ with Unrestricted MV mode */
410 {
411  short sval = 0;
412  short i = 0;
413  short n_bits = 0;
414  short temp_val;
415  int code = 0;
416  int tcode;
417 
418  if ( val == 0)
419  put_bits(&s->pb, 1, 1);
420  else if (val == 1)
421  put_bits(&s->pb, 3, 0);
422  else if (val == -1)
423  put_bits(&s->pb, 3, 2);
424  else {
425 
426  sval = ((val < 0) ? (short)(-val):(short)val);
427  temp_val = sval;
428 
429  while (temp_val != 0) {
430  temp_val = temp_val >> 1;
431  n_bits++;
432  }
433 
434  i = n_bits - 1;
435  while (i > 0) {
436  tcode = (sval & (1 << (i-1))) >> (i-1);
437  tcode = (tcode << 1) | 1;
438  code = (code << 2) | tcode;
439  i--;
440  }
441  code = ((code << 1) | (val < 0)) << 1;
442  put_bits(&s->pb, (2*n_bits)+1, code);
443  }
444 }
445 
447  int16_t block[6][64],
448  int motion_x, int motion_y)
449 {
450  int cbpc, cbpy, i, cbp, pred_x, pred_y;
451  int16_t pred_dc;
452  int16_t rec_intradc[6];
453  int16_t *dc_ptr[6];
454  const int interleaved_stats= (s->flags&CODEC_FLAG_PASS1);
455 
456  if (!s->mb_intra) {
457  /* compute cbp */
458  cbp= get_p_cbp(s, block, motion_x, motion_y);
459 
460  if ((cbp | motion_x | motion_y | s->dquant | (s->mv_type - MV_TYPE_16X16)) == 0) {
461  /* skip macroblock */
462  put_bits(&s->pb, 1, 1);
463  if(interleaved_stats){
464  s->misc_bits++;
465  s->last_bits++;
466  }
467  s->skip_count++;
468 
469  return;
470  }
471  put_bits(&s->pb, 1, 0); /* mb coded */
472 
473  cbpc = cbp & 3;
474  cbpy = cbp >> 2;
475  if(s->alt_inter_vlc==0 || cbpc!=3)
476  cbpy ^= 0xF;
477  if(s->dquant) cbpc+= 8;
478  if(s->mv_type==MV_TYPE_16X16){
479  put_bits(&s->pb,
482 
483  put_bits(&s->pb, ff_h263_cbpy_tab[cbpy][1], ff_h263_cbpy_tab[cbpy][0]);
484  if(s->dquant)
485  put_bits(&s->pb, 2, dquant_code[s->dquant+2]);
486 
487  if(interleaved_stats){
488  s->misc_bits+= get_bits_diff(s);
489  }
490 
491  /* motion vectors: 16x16 mode */
492  ff_h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
493 
494  if (!s->umvplus) {
495  ff_h263_encode_motion_vector(s, motion_x - pred_x,
496  motion_y - pred_y, 1);
497  }
498  else {
499  h263p_encode_umotion(s, motion_x - pred_x);
500  h263p_encode_umotion(s, motion_y - pred_y);
501  if (((motion_x - pred_x) == 1) && ((motion_y - pred_y) == 1))
502  /* To prevent Start Code emulation */
503  put_bits(&s->pb,1,1);
504  }
505  }else{
506  put_bits(&s->pb,
507  ff_h263_inter_MCBPC_bits[cbpc+16],
508  ff_h263_inter_MCBPC_code[cbpc+16]);
509  put_bits(&s->pb, ff_h263_cbpy_tab[cbpy][1], ff_h263_cbpy_tab[cbpy][0]);
510  if(s->dquant)
511  put_bits(&s->pb, 2, dquant_code[s->dquant+2]);
512 
513  if(interleaved_stats){
514  s->misc_bits+= get_bits_diff(s);
515  }
516 
517  for(i=0; i<4; i++){
518  /* motion vectors: 8x8 mode*/
519  ff_h263_pred_motion(s, i, 0, &pred_x, &pred_y);
520 
521  motion_x = s->current_picture.motion_val[0][s->block_index[i]][0];
522  motion_y = s->current_picture.motion_val[0][s->block_index[i]][1];
523  if (!s->umvplus) {
524  ff_h263_encode_motion_vector(s, motion_x - pred_x,
525  motion_y - pred_y, 1);
526  }
527  else {
528  h263p_encode_umotion(s, motion_x - pred_x);
529  h263p_encode_umotion(s, motion_y - pred_y);
530  if (((motion_x - pred_x) == 1) && ((motion_y - pred_y) == 1))
531  /* To prevent Start Code emulation */
532  put_bits(&s->pb,1,1);
533  }
534  }
535  }
536 
537  if(interleaved_stats){
538  s->mv_bits+= get_bits_diff(s);
539  }
540  } else {
541  av_assert2(s->mb_intra);
542 
543  cbp = 0;
544  if (s->h263_aic) {
545  /* Predict DC */
546  for(i=0; i<6; i++) {
547  int16_t level = block[i][0];
548  int scale;
549 
550  if(i<4) scale= s->y_dc_scale;
551  else scale= s->c_dc_scale;
552 
553  pred_dc = ff_h263_pred_dc(s, i, &dc_ptr[i]);
554  level -= pred_dc;
555  /* Quant */
556  if (level >= 0)
557  level = (level + (scale>>1))/scale;
558  else
559  level = (level - (scale>>1))/scale;
560 
561  if(!s->modified_quant){
562  if (level < -127)
563  level = -127;
564  else if (level > 127)
565  level = 127;
566  }
567 
568  block[i][0] = level;
569  /* Reconstruction */
570  rec_intradc[i] = scale*level + pred_dc;
571  /* Oddify */
572  rec_intradc[i] |= 1;
573  //if ((rec_intradc[i] % 2) == 0)
574  // rec_intradc[i]++;
575  /* Clipping */
576  if (rec_intradc[i] < 0)
577  rec_intradc[i] = 0;
578  else if (rec_intradc[i] > 2047)
579  rec_intradc[i] = 2047;
580 
581  /* Update AC/DC tables */
582  *dc_ptr[i] = rec_intradc[i];
583  /* AIC can change CBP */
584  if (s->block_last_index[i] > 0 ||
585  (s->block_last_index[i] == 0 && level !=0))
586  cbp |= 1 << (5 - i);
587  }
588  }else{
589  for(i=0; i<6; i++) {
590  /* compute cbp */
591  if (s->block_last_index[i] >= 1)
592  cbp |= 1 << (5 - i);
593  }
594  }
595 
596  cbpc = cbp & 3;
597  if (s->pict_type == AV_PICTURE_TYPE_I) {
598  if(s->dquant) cbpc+=4;
599  put_bits(&s->pb,
602  } else {
603  if(s->dquant) cbpc+=8;
604  put_bits(&s->pb, 1, 0); /* mb coded */
605  put_bits(&s->pb,
606  ff_h263_inter_MCBPC_bits[cbpc + 4],
607  ff_h263_inter_MCBPC_code[cbpc + 4]);
608  }
609  if (s->h263_aic) {
610  /* XXX: currently, we do not try to use ac prediction */
611  put_bits(&s->pb, 1, 0); /* no AC prediction */
612  }
613  cbpy = cbp >> 2;
614  put_bits(&s->pb, ff_h263_cbpy_tab[cbpy][1], ff_h263_cbpy_tab[cbpy][0]);
615  if(s->dquant)
616  put_bits(&s->pb, 2, dquant_code[s->dquant+2]);
617 
618  if(interleaved_stats){
619  s->misc_bits+= get_bits_diff(s);
620  }
621  }
622 
623  for(i=0; i<6; i++) {
624  /* encode each block */
625  h263_encode_block(s, block[i], i);
626 
627  /* Update INTRADC for decoding */
628  if (s->h263_aic && s->mb_intra) {
629  block[i][0] = rec_intradc[i];
630 
631  }
632  }
633 
634  if(interleaved_stats){
635  if (!s->mb_intra) {
636  s->p_tex_bits+= get_bits_diff(s);
637  s->f_count++;
638  }else{
639  s->i_tex_bits+= get_bits_diff(s);
640  s->i_count++;
641  }
642  }
643 }
644 
645 void ff_h263_encode_motion(MpegEncContext * s, int val, int f_code)
646 {
647  int range, bit_size, sign, code, bits;
648 
649  if (val == 0) {
650  /* zero vector */
651  code = 0;
652  put_bits(&s->pb, ff_mvtab[code][1], ff_mvtab[code][0]);
653  } else {
654  bit_size = f_code - 1;
655  range = 1 << bit_size;
656  /* modulo encoding */
657  val = sign_extend(val, 6 + bit_size);
658  sign = val>>31;
659  val= (val^sign)-sign;
660  sign&=1;
661 
662  val--;
663  code = (val >> bit_size) + 1;
664  bits = val & (range - 1);
665 
666  put_bits(&s->pb, ff_mvtab[code][1] + 1, (ff_mvtab[code][0] << 1) | sign);
667  if (bit_size > 0) {
668  put_bits(&s->pb, bit_size, bits);
669  }
670  }
671 }
672 
674 {
675  int f_code;
676  int mv;
677 
678  for(f_code=1; f_code<=MAX_FCODE; f_code++){
679  for(mv=-MAX_MV; mv<=MAX_MV; mv++){
680  int len;
681 
682  if(mv==0) len= ff_mvtab[0][1];
683  else{
684  int val, bit_size, code;
685 
686  bit_size = f_code - 1;
687 
688  val=mv;
689  if (val < 0)
690  val = -val;
691  val--;
692  code = (val >> bit_size) + 1;
693  if(code<33){
694  len= ff_mvtab[code][1] + 1 + bit_size;
695  }else{
696  len= ff_mvtab[32][1] + av_log2(code>>5) + 2 + bit_size;
697  }
698  }
699 
700  mv_penalty[f_code][mv+MAX_MV]= len;
701  }
702  }
703 
704  for(f_code=MAX_FCODE; f_code>0; f_code--){
705  for(mv=-(16<<f_code); mv<(16<<f_code); mv++){
706  fcode_tab[mv+MAX_MV]= f_code;
707  }
708  }
709 
710  for(mv=0; mv<MAX_MV*2+1; mv++){
711  umv_fcode_tab[mv]= 1;
712  }
713 }
714 
715 static av_cold void init_uni_h263_rl_tab(RLTable *rl, uint32_t *bits_tab,
716  uint8_t *len_tab)
717 {
718  int slevel, run, last;
719 
720  av_assert0(MAX_LEVEL >= 64);
721  av_assert0(MAX_RUN >= 63);
722 
723  for(slevel=-64; slevel<64; slevel++){
724  if(slevel==0) continue;
725  for(run=0; run<64; run++){
726  for(last=0; last<=1; last++){
727  const int index= UNI_MPEG4_ENC_INDEX(last, run, slevel+64);
728  int level= slevel < 0 ? -slevel : slevel;
729  int sign= slevel < 0 ? 1 : 0;
730  int bits, len, code;
731 
732  len_tab[index]= 100;
733 
734  /* ESC0 */
735  code= get_rl_index(rl, last, run, level);
736  bits= rl->table_vlc[code][0];
737  len= rl->table_vlc[code][1];
738  bits=bits*2+sign; len++;
739 
740  if(code!=rl->n && len < len_tab[index]){
741  if(bits_tab) bits_tab[index]= bits;
742  len_tab [index]= len;
743  }
744  /* ESC */
745  bits= rl->table_vlc[rl->n][0];
746  len = rl->table_vlc[rl->n][1];
747  bits=bits*2+last; len++;
748  bits=bits*64+run; len+=6;
749  bits=bits*256+(level&0xff); len+=8;
750 
751  if(len < len_tab[index]){
752  if(bits_tab) bits_tab[index]= bits;
753  len_tab [index]= len;
754  }
755  }
756  }
757  }
758 }
759 
761 {
762  static int done = 0;
763 
764  if (!done) {
765  done = 1;
766 
769 
772 
774  }
775  s->me.mv_penalty= mv_penalty; //FIXME exact table for msmpeg4 & h263p
776 
779  if(s->h263_aic){
782  }
783  s->ac_esc_length= 7+1+6+8;
784 
785  // use fcodes >1 only for mpeg4 & h263 & h263p FIXME
786  switch(s->codec_id){
787  case AV_CODEC_ID_MPEG4:
788  s->fcode_tab= fcode_tab;
789  break;
790  case AV_CODEC_ID_H263P:
791  if(s->umvplus)
793  if(s->modified_quant){
794  s->min_qcoeff= -2047;
795  s->max_qcoeff= 2047;
796  }else{
797  s->min_qcoeff= -127;
798  s->max_qcoeff= 127;
799  }
800  break;
801  //Note for mpeg4 & h263 the dc-scale table will be set per frame as needed later
802  case AV_CODEC_ID_FLV1:
803  if (s->h263_flv > 1) {
804  s->min_qcoeff= -1023;
805  s->max_qcoeff= 1023;
806  } else {
807  s->min_qcoeff= -127;
808  s->max_qcoeff= 127;
809  }
810  break;
811  default: //nothing needed - default table already set in mpegvideo.c
812  s->min_qcoeff= -127;
813  s->max_qcoeff= 127;
814  }
815  if(s->h263_aic){
816  s->y_dc_scale_table=
818  }else{
819  s->y_dc_scale_table=
821  }
822 }
823 
825 {
826  int i, mb_pos;
827 
828  for(i=0; i<6; i++){
829  if(s->mb_num-1 <= ff_mba_max[i]) break;
830  }
831  mb_pos= s->mb_x + s->mb_width*s->mb_y;
832  put_bits(&s->pb, ff_mba_length[i], mb_pos);
833 }
#define av_const
Definition: attributes.h:68
#define NULL
Definition: coverity.c:32
static const int dquant_code[5]
Definition: ituh263enc.c:291
const char const char void * val
Definition: avisynth_c.h:672
int aspect_ratio_info
Definition: mpegvideo.h:533
int picture_number
Definition: mpegvideo.h:261
const char * s
Definition: avisynth_c.h:669
av_cold void ff_h263_encode_init(MpegEncContext *s)
Definition: ituh263enc.c:760
uint8_t * fcode_tab
smallest fcode needed for each MV
Definition: mpegvideo.h:413
const uint8_t * y_dc_scale_table
qscale -> y_dc_scale table
Definition: mpegvideo.h:322
static void put_sbits(PutBitContext *pb, int n, int32_t value)
Definition: put_bits.h:192
static void put_bits(Jpeg2000EncoderContext *s, int val, int n)
put n times val bit
Definition: j2kenc.c:160
#define CODEC_FLAG_PASS1
Use internal 2pass ratecontrol in first pass mode.
Definition: avcodec.h:734
RLTable ff_h263_rl_inter
Definition: h263data.h:162
const uint8_t ff_h263_intra_MCBPC_code[9]
Definition: h263data.h:36
const uint8_t ff_h263_cbpy_tab[16][2]
Definition: h263data.h:85
int num
numerator
Definition: rational.h:44
enum AVCodecID codec_id
Definition: mpegvideo.h:243
int obmc
overlapped block motion compensation
Definition: mpegvideo.h:500
void avpriv_align_put_bits(PutBitContext *s)
Pad the bitstream with zeros up to the next byte boundary.
Definition: bitstream.c:47
AVRational sample_aspect_ratio
sample aspect ratio (0 if unknown) That is the width of a pixel divided by the height of the pixel...
Definition: avcodec.h:1621
static int av_cmp_q(AVRational a, AVRational b)
Compare two rationals.
Definition: rational.h:66
int min_qcoeff
minimum encodable coefficient
Definition: mpegvideo.h:441
#define UNI_MPEG4_ENC_INDEX(last, run, level)
Definition: ituh263enc.c:65
mpegvideo header.
#define FF_ARRAY_ELEMS(a)
uint8_t permutated[64]
Definition: idctdsp.h:31
uint8_t run
Definition: svq3.c:149
uint8_t * intra_ac_vlc_length
Definition: mpegvideo.h:444
const uint16_t ff_h263_format[8][2]
Definition: h263data.h:239
int mb_num
number of MBs of a picture
Definition: mpegvideo.h:267
void ff_h263_encode_motion(MpegEncContext *s, int val, int f_code)
Definition: ituh263enc.c:645
void ff_h263_encode_gob_header(MpegEncContext *s, int mb_line)
Encode a group of blocks header.
Definition: ituh263enc.c:239
RLTable.
Definition: rl.h:38
int qscale
QP.
Definition: mpegvideo.h:340
void ff_h263_encode_mba(MpegEncContext *s)
Definition: ituh263enc.c:824
int h263_aic
Advanded INTRA Coding (AIC)
Definition: mpegvideo.h:218
int16_t * ff_h263_pred_motion(MpegEncContext *s, int block, int dir, int *px, int *py)
Definition: h263.c:313
Macro definitions for various function/variable attributes.
AVRational time_base
This is the fundamental unit of time (in seconds) in terms of which frame timestamps are represented...
Definition: avcodec.h:1367
int modified_quant
Definition: mpegvideo.h:512
static uint8_t uni_h263_inter_rl_len[64 *64 *2 *2]
Definition: ituh263enc.c:62
#define CANDIDATE_MB_TYPE_INTER
Definition: mpegutils.h:101
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
int alt_inter_vlc
alternative inter vlc
Definition: mpegvideo.h:511
uint8_t * ptr_lastgob
Definition: mpegvideo.h:621
uint8_t bits
Definition: crc.c:295
uint8_t
#define av_cold
Definition: attributes.h:74
static av_cold void init_uni_h263_rl_tab(RLTable *rl, uint32_t *bits_tab, uint8_t *len_tab)
Definition: ituh263enc.c:715
#define av_assert2(cond)
assert() equivalent, that does lie in speed critical code.
Definition: avassert.h:63
#define CANDIDATE_MB_TYPE_INTER4V
Definition: mpegutils.h:102
const uint8_t ff_h263_intra_MCBPC_bits[9]
Definition: h263data.h:37
const uint8_t ff_mvtab[33][2]
Definition: h263data.h:91
int misc_bits
cbp, mb_type
Definition: mpegvideo.h:485
int no_rounding
apply no rounding to motion compensation (MPEG4, msmpeg4, ...) for b-frames rounding mode is always 0...
Definition: mpegvideo.h:418
const uint8_t ff_h263_inter_MCBPC_bits[28]
Definition: h263data.h:50
Picture current_picture
copy of the current picture structure.
Definition: mpegvideo.h:314
uint8_t(* mv_penalty)[MAX_MV *2+1]
amount of bits needed to encode a MV
Definition: mpegvideo.h:201
static void h263p_encode_umotion(MpegEncContext *s, int val)
Definition: ituh263enc.c:409
RLTable ff_rl_intra_aic
Definition: h263data.h:231
void ff_init_qscale_tab(MpegEncContext *s)
init s->current_picture.qscale_table from s->lambda_table
int ff_h263_pred_dc(MpegEncContext *s, int n, int16_t **dc_val_ptr)
Definition: h263.c:98
int max_qcoeff
maximum encodable coefficient
Definition: mpegvideo.h:442
const AVRational ff_h263_pixel_aspect[16]
Definition: h263data.h:275
#define MAX_LEVEL
Definition: rl.h:35
int dquant
qscale difference to prev qscale
Definition: mpegvideo.h:346
static int get_bits_diff(MpegEncContext *s)
Definition: mpegvideo.h:833
const uint8_t ff_mba_length[7]
Definition: h263data.h:271
int h263_plus
h263 plus headers
Definition: mpegvideo.h:240
static uint8_t * put_bits_ptr(PutBitContext *s)
Return the pointer to the byte where the bitstream writer will put the next bit.
Definition: put_bits.h:219
uint8_t * inter_ac_vlc_last_length
Definition: mpegvideo.h:449
void ff_flv2_encode_ac_esc(PutBitContext *pb, int slevel, int level, int run, int last)
Definition: flvenc.c:73
static uint8_t fcode_tab[MAX_MV *2+1]
Minimal fcode that a motion vector component would need.
Definition: ituh263enc.c:51
int h263_slice_structured
Definition: mpegvideo.h:510
uint16_t * mb_type
Table for candidate MB types for encoding (defines in mpegutils.h)
Definition: mpegvideo.h:425
static void h263_encode_block(MpegEncContext *s, int16_t *block, int n)
Encode an 8x8 block.
Definition: ituh263enc.c:298
Libavcodec external API header.
uint8_t * intra_ac_vlc_last_length
Definition: mpegvideo.h:445
int n
number of entries of table_vlc minus 1
Definition: rl.h:39
#define av_assert1(cond)
assert() equivalent, that does not lie in speed critical code.
Definition: avassert.h:53
const uint16_t(* table_vlc)[2]
Definition: rl.h:41
int umvplus
== H263+ && unrestricted_mv
Definition: mpegvideo.h:508
int16_t(*[2] motion_val)[2]
Definition: mpegvideo.h:110
static void FUNC() pred_dc(uint8_t *_src, const uint8_t *_top, const uint8_t *_left, ptrdiff_t stride, int log2_size, int c_idx)
const uint16_t ff_mba_max[6]
Definition: h263data.h:267
#define FFABS(a)
Definition: common.h:61
int block_last_index[12]
last non zero coefficient in block
Definition: mpegvideo.h:217
MotionEstContext me
Definition: mpegvideo.h:416
int n
Definition: avisynth_c.h:589
const uint8_t ff_aic_dc_scale_table[32]
Definition: h263data.h:248
#define CONFIG_FLV_ENCODER
Definition: config.h:1237
const uint8_t ff_h263_inter_MCBPC_code[28]
Definition: h263data.h:41
int ac_esc_length
num of bits needed to encode the longest esc
Definition: mpegvideo.h:443
int block_index[6]
index to current MB in block based arrays with edges
Definition: mpegvideo.h:427
static av_cold void init_mv_penalty_and_fcode(MpegEncContext *s)
Definition: ituh263enc.c:673
int * mb_index2xy
mb_index -> mb_x + mb_y*mb_stride
Definition: mpegvideo.h:431
static const int8_t mv[256][2]
Definition: 4xm.c:77
#define MV_TYPE_16X16
1 vector for the whole mb
Definition: mpegvideo.h:400
int h263_flv
use flv h263 header
Definition: mpegvideo.h:241
uint8_t ff_h263_static_rl_table_store[2][2][2 *MAX_RUN+MAX_LEVEL+3]
Definition: h263.c:43
static uint8_t umv_fcode_tab[MAX_MV *2+1]
Minimal fcode that a motion vector component would need in umv.
Definition: ituh263enc.c:57
void ff_h263_encode_picture_header(MpegEncContext *s, int picture_number)
Definition: ituh263enc.c:102
ScanTable intra_scantable
Definition: mpegvideo.h:222
int height
picture size. must be a multiple of 16
Definition: mpegvideo.h:231
const uint8_t ff_mpeg1_dc_scale_table[128]
Definition: mpegvideo.c:56
uint8_t * inter_ac_vlc_length
Definition: mpegvideo.h:448
static const uint8_t wrong_run[102]
Definition: ituh263enc.c:67
int index
Definition: gxfenc.c:89
rational number numerator/denominator
Definition: rational.h:43
static void ff_h263_encode_motion_vector(MpegEncContext *s, int x, int y, int f_code)
Definition: h263.h:145
static uint8_t uni_h263_intra_aic_rl_len[64 *64 *2 *2]
Definition: ituh263enc.c:61
#define MAX_MV
Definition: mpegvideo.h:68
#define MAX_FCODE
Definition: mpegvideo.h:67
int pict_type
AV_PICTURE_TYPE_I, AV_PICTURE_TYPE_P, AV_PICTURE_TYPE_B, ...
Definition: mpegvideo.h:348
static av_const int sign_extend(int val, unsigned bits)
Definition: mathops.h:139
const uint8_t * c_dc_scale_table
qscale -> c_dc_scale table
Definition: mpegvideo.h:323
#define FF_ASPECT_EXTENDED
Definition: avcodec.h:1425
uint8_t level
Definition: svq3.c:150
MpegEncContext.
Definition: mpegvideo.h:212
int8_t * qscale_table
Definition: mpegvideo.h:107
#define MAX_RUN
Definition: rl.h:34
struct AVCodecContext * avctx
Definition: mpegvideo.h:229
PutBitContext pb
bit output
Definition: mpegvideo.h:285
static uint8_t mv_penalty[MAX_FCODE+1][MAX_MV *2+1]
Table of number of bits a motion vector component needs.
Definition: ituh263enc.c:46
common internal api header.
int den
denominator
Definition: rational.h:45
av_const int ff_h263_aspect_to_info(AVRational aspect)
Return the 4 bit value that specifies the given aspect ratio.
Definition: ituh263enc.c:88
void ff_h263_encode_mb(MpegEncContext *s, int16_t block[6][64], int motion_x, int motion_y)
Definition: ituh263enc.c:446
static int get_rl_index(const RLTable *rl, int last, int run, int level)
Definition: rl.h:71
void ff_clean_h263_qscales(MpegEncContext *s)
modify qscale so that encoding is actually possible in h263 (limit difference to -2..2)
Definition: ituh263enc.c:265
int last_bits
temp var used for calculating the above vars
Definition: mpegvideo.h:486
int len
#define av_log2
Definition: intmath.h:105
av_cold void ff_init_rl(RLTable *rl, uint8_t static_store[2][2 *MAX_RUN+MAX_LEVEL+3])
Definition: mpegvideo.c:1584
static int get_p_cbp(MpegEncContext *s, int16_t block[6][64], int motion_x, int motion_y)
Definition: h263.h:156
int flags
AVCodecContext.flags (HQ, MV4, ...)
Definition: mpegvideo.h:246
int ff_match_2uint16(const uint16_t(*tab)[2], int size, int a, int b)
Return the index into tab at which {a,b} match elements {[0],[1]} of tab.
Definition: utils.c:3512
Predicted.
Definition: avutil.h:268
static int16_t block[64]
Definition: dct-test.c:110