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