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