FFmpeg  2.1.1
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 "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.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 */
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.motion_val[0][s->block_index[i]][0];
529  motion_y = s->current_picture.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 av_cold void init_uni_h263_rl_tab(RLTable *rl, uint32_t *bits_tab,
725  uint8_t *len_tab)
726 {
727  int slevel, run, last;
728 
729  av_assert0(MAX_LEVEL >= 64);
730  av_assert0(MAX_RUN >= 63);
731 
732  for(slevel=-64; slevel<64; slevel++){
733  if(slevel==0) continue;
734  for(run=0; run<64; run++){
735  for(last=0; last<=1; last++){
736  const int index= UNI_MPEG4_ENC_INDEX(last, run, slevel+64);
737  int level= slevel < 0 ? -slevel : slevel;
738  int sign= slevel < 0 ? 1 : 0;
739  int bits, len, code;
740 
741  len_tab[index]= 100;
742 
743  /* ESC0 */
744  code= get_rl_index(rl, last, run, level);
745  bits= rl->table_vlc[code][0];
746  len= rl->table_vlc[code][1];
747  bits=bits*2+sign; len++;
748 
749  if(code!=rl->n && len < len_tab[index]){
750  if(bits_tab) bits_tab[index]= bits;
751  len_tab [index]= len;
752  }
753  /* ESC */
754  bits= rl->table_vlc[rl->n][0];
755  len = rl->table_vlc[rl->n][1];
756  bits=bits*2+last; len++;
757  bits=bits*64+run; len+=6;
758  bits=bits*256+(level&0xff); len+=8;
759 
760  if(len < len_tab[index]){
761  if(bits_tab) bits_tab[index]= bits;
762  len_tab [index]= len;
763  }
764  }
765  }
766  }
767 }
768 
770 {
771  static int done = 0;
772 
773  if (!done) {
774  done = 1;
775 
778 
781 
783  }
784  s->me.mv_penalty= mv_penalty; //FIXME exact table for msmpeg4 & h263p
785 
788  if(s->h263_aic){
791  }
792  s->ac_esc_length= 7+1+6+8;
793 
794  // use fcodes >1 only for mpeg4 & h263 & h263p FIXME
795  switch(s->codec_id){
796  case AV_CODEC_ID_MPEG4:
797  s->fcode_tab= fcode_tab;
798  break;
799  case AV_CODEC_ID_H263P:
800  if(s->umvplus)
802  if(s->modified_quant){
803  s->min_qcoeff= -2047;
804  s->max_qcoeff= 2047;
805  }else{
806  s->min_qcoeff= -127;
807  s->max_qcoeff= 127;
808  }
809  break;
810  //Note for mpeg4 & h263 the dc-scale table will be set per frame as needed later
811  case AV_CODEC_ID_FLV1:
812  if (s->h263_flv > 1) {
813  s->min_qcoeff= -1023;
814  s->max_qcoeff= 1023;
815  } else {
816  s->min_qcoeff= -127;
817  s->max_qcoeff= 127;
818  }
819  s->y_dc_scale_table=
821  break;
822  default: //nothing needed - default table already set in mpegvideo.c
823  s->min_qcoeff= -127;
824  s->max_qcoeff= 127;
825  s->y_dc_scale_table=
827  }
828 }
829 
831 {
832  int i, mb_pos;
833 
834  for(i=0; i<6; i++){
835  if(s->mb_num-1 <= ff_mba_max[i]) break;
836  }
837  mb_pos= s->mb_x + s->mb_width*s->mb_y;
838  put_bits(&s->pb, ff_mba_length[i], mb_pos);
839 }
static const int dquant_code[5]
Definition: ituh263enc.c:298
const char const char void * val
Definition: avisynth_c.h:671
int aspect_ratio_info
Definition: mpegvideo.h:590
int picture_number
Definition: mpegvideo.h:279
const char * s
Definition: avisynth_c.h:668
void ff_h263_encode_picture_header(MpegEncContext *s, int picture_number)
Definition: ituh263enc.c:101
uint8_t * fcode_tab
smallest fcode needed for each MV
Definition: mpegvideo.h:438
const uint8_t * y_dc_scale_table
qscale -&gt; y_dc_scale table
Definition: mpegvideo.h:355
static void put_sbits(PutBitContext *pb, int n, int32_t value)
Definition: put_bits.h:180
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:703
void ff_h263_encode_init(MpegEncContext *s)
Definition: ituh263enc.c:769
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:261
int obmc
overlapped block motion compensation
Definition: mpegvideo.h:542
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:1517
static int av_cmp_q(AVRational a, AVRational b)
Compare two rationals.
Definition: rational.h:55
int min_qcoeff
minimum encodable coefficient
Definition: mpegvideo.h:483
#define UNI_MPEG4_ENC_INDEX(last, run, level)
Definition: ituh263enc.c:64
mpegvideo header.
uint8_t permutated[64]
Definition: dsputil.h:113
uint8_t run
Definition: svq3.c:145
uint8_t * intra_ac_vlc_length
Definition: mpegvideo.h:486
const uint16_t ff_h263_format[8][2]
Definition: h263data.h:239
int mb_num
number of MBs of a picture
Definition: mpegvideo.h:286
#define av_cold
Definition: avcodec.h:653
RLTable.
Definition: rl.h:38
int qscale
QP.
Definition: mpegvideo.h:373
int h263_aic
Advanded INTRA Coding (AIC)
Definition: mpegvideo.h:296
int16_t * ff_h263_pred_motion(MpegEncContext *s, int block, int dir, int *px, int *py)
Definition: h263.c:312
Predicted.
Definition: avcodec.h:2305
AVRational time_base
This is the fundamental unit of time (in seconds) in terms of which frame timestamps are represented...
Definition: avcodec.h:1265
int modified_quant
Definition: mpegvideo.h:555
static uint8_t uni_h263_inter_rl_len[64 *64 *2 *2]
Definition: ituh263enc.c:61
#define av_const
Definition: avcodec.h:647
int alt_inter_vlc
alternative inter vlc
Definition: mpegvideo.h:554
uint8_t * ptr_lastgob
Definition: mpegvideo.h:701
uint8_t bits
Definition: crc.c:260
uint8_t
static av_cold void init_uni_h263_rl_tab(RLTable *rl, uint32_t *bits_tab, uint8_t *len_tab)
Definition: ituh263enc.c:724
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:527
int no_rounding
apply no rounding to motion compensation (MPEG4, msmpeg4, ...) for b-frames rounding mode is always 0...
Definition: mpegvideo.h:443
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:347
uint8_t(* mv_penalty)[MAX_MV *2+1]
amount of bits needed to encode a MV
Definition: mpegvideo.h:234
static void h263p_encode_umotion(MpegEncContext *s, int val)
Definition: ituh263enc.c:416
RLTable ff_rl_intra_aic
Definition: h263data.h:231
void ff_init_qscale_tab(MpegEncContext *s)
init s-&gt;current_picture.qscale_table from s-&gt;lambda_table
int ff_h263_pred_dc(MpegEncContext *s, int n, int16_t **dc_val_ptr)
Definition: h263.c:97
int max_qcoeff
maximum encodable coefficient
Definition: mpegvideo.h:484
const AVRational ff_h263_pixel_aspect[16]
Definition: h263data.h:280
#define MAX_LEVEL
Definition: rl.h:35
int dquant
qscale difference to prev qscale
Definition: mpegvideo.h:379
static int get_bits_diff(MpegEncContext *s)
Definition: mpegvideo.h:880
const uint8_t ff_mba_length[7]
Definition: h263data.h:271
int h263_plus
h263 plus headers
Definition: mpegvideo.h:258
#define FF_ASPECT_EXTENDED
Definition: avcodec.h:1326
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:207
uint8_t * inter_ac_vlc_last_length
Definition: mpegvideo.h:489
void ff_flv2_encode_ac_esc(PutBitContext *pb, int slevel, int level, int run, int last)
Definition: flvenc.c:70
static uint8_t fcode_tab[MAX_MV *2+1]
Minimal fcode that a motion vector component would need.
Definition: ituh263enc.c:50
int h263_slice_structured
Definition: mpegvideo.h:553
#define CANDIDATE_MB_TYPE_INTER
Definition: mpegvideo.h:452
uint16_t * mb_type
Table for candidate MB types for encoding.
Definition: mpegvideo.h:450
av_const int ff_h263_aspect_to_info(AVRational aspect)
Return the 4 bit value that specifies the given aspect ratio.
Definition: ituh263enc.c:87
static void h263_encode_block(MpegEncContext *s, int16_t *block, int n)
Encode an 8x8 block.
Definition: ituh263enc.c:305
Libavcodec external API header.
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:272
void ff_h263_encode_motion(MpegEncContext *s, int val, int f_code)
Definition: ituh263enc.c:654
uint8_t * intra_ac_vlc_last_length
Definition: mpegvideo.h:487
#define FF_ARRAY_ELEMS(a)
Definition: avcodec.h:929
int n
number of entries of table_vlc minus 1
Definition: rl.h:39
const uint16_t(* table_vlc)[2]
Definition: rl.h:41
int umvplus
== H263+ &amp;&amp; unrestricted_mv
Definition: mpegvideo.h:551
int16_t(*[2] motion_val)[2]
Definition: mpegvideo.h:105
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)
#define CANDIDATE_MB_TYPE_INTER4V
Definition: mpegvideo.h:453
const uint16_t ff_mba_max[6]
Definition: h263data.h:267
int block_last_index[12]
last non zero coefficient in block
Definition: mpegvideo.h:295
MotionEstContext me
Definition: mpegvideo.h:441
int n
Definition: avisynth_c.h:588
#define CONFIG_FLV_ENCODER
Definition: config.h:1078
const uint8_t ff_aic_dc_scale_table[32]
Definition: h263data.h:248
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:485
int block_index[6]
index to current MB in block based arrays with edges
Definition: mpegvideo.h:469
static av_cold void init_mv_penalty_and_fcode(MpegEncContext *s)
Definition: ituh263enc.c:682
int * mb_index2xy
mb_index -&gt; mb_x + mb_y*mb_stride
Definition: mpegvideo.h:473
static const int8_t mv[256][2]
Definition: 4xm.c:73
#define MV_TYPE_16X16
1 vector for the whole mb
Definition: mpegvideo.h:425
int h263_flv
use flv h263 header
Definition: mpegvideo.h:259
uint8_t ff_h263_static_rl_table_store[2][2][2 *MAX_RUN+MAX_LEVEL+3]
Definition: h263.c:42
static uint8_t umv_fcode_tab[MAX_MV *2+1]
Minimal fcode that a motion vector component would need in umv.
Definition: ituh263enc.c:56
ScanTable intra_scantable
Definition: mpegvideo.h:300
int height
picture size. must be a multiple of 16
Definition: mpegvideo.h:249
const uint8_t ff_mpeg1_dc_scale_table[128]
Definition: mpegvideo.c:66
uint8_t * inter_ac_vlc_length
Definition: mpegvideo.h:488
void ff_h263_encode_mba(MpegEncContext *s)
Definition: ituh263enc.c:830
static const uint8_t wrong_run[102]
Definition: ituh263enc.c:66
void ff_h263_encode_gob_header(MpegEncContext *s, int mb_line)
Encode a group of blocks header.
Definition: ituh263enc.c:246
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:141
static uint8_t uni_h263_intra_aic_rl_len[64 *64 *2 *2]
Definition: ituh263enc.c:60
#define MAX_MV
Definition: mpegvideo.h:63
#define MAX_FCODE
Definition: mpegvideo.h:62
int pict_type
AV_PICTURE_TYPE_I, AV_PICTURE_TYPE_P, AV_PICTURE_TYPE_B, ...
Definition: mpegvideo.h:381
#define av_assert1(cond)
assert() equivalent, that does not lie in speed critical code.
Definition: avassert.h:53
static av_const int sign_extend(int val, unsigned bits)
Definition: mathops.h:123
#define FFABS(a)
Definition: avcodec.h:920
static const uint16_t scale[4]
const uint8_t * c_dc_scale_table
qscale -&gt; c_dc_scale table
Definition: mpegvideo.h:356
uint8_t level
Definition: svq3.c:146
MpegEncContext.
Definition: mpegvideo.h:245
int8_t * qscale_table
Definition: mpegvideo.h:102
#define MAX_RUN
Definition: rl.h:34
struct AVCodecContext * avctx
Definition: mpegvideo.h:247
PutBitContext pb
bit output
Definition: mpegvideo.h:318
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:45
common internal api header.
void ff_h263_encode_mb(MpegEncContext *s, int16_t block[6][64], int motion_x, int motion_y)
Definition: ituh263enc.c:453
int den
denominator
Definition: rational.h:45
static int get_rl_index(const RLTable *rl, int last, int run, int level)
Definition: rl.h:75
int last_bits
temp var used for calculating the above vars
Definition: mpegvideo.h:528
int len
#define av_log2
Definition: intmath.h:89
av_cold void ff_init_rl(RLTable *rl, uint8_t static_store[2][2 *MAX_RUN+MAX_LEVEL+3])
Definition: mpegvideo.c:1317
static int get_p_cbp(MpegEncContext *s, int16_t block[6][64], int motion_x, int motion_y)
Definition: h263.h:152
int flags
AVCodecContext.flags (HQ, MV4, ...)
Definition: mpegvideo.h:264
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
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:3133
#define av_assert2(cond)
assert() equivalent, that does lie in speed critical code.
Definition: avassert.h:63
static int16_t block[64]
Definition: dct-test.c:198