FFmpeg
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 "config_components.h"
31 
32 #include <limits.h>
33 
34 #include "libavutil/attributes.h"
35 #include "libavutil/thread.h"
36 #include "avcodec.h"
37 #include "codec_internal.h"
38 #include "mpegvideo.h"
39 #include "mpegvideodata.h"
40 #include "flvenc.h"
41 #include "mpegvideoenc.h"
42 #include "h263.h"
43 #include "h263enc.h"
44 #include "h263data.h"
45 #include "mathops.h"
46 #include "mpegutils.h"
47 #include "internal.h"
48 
49 /**
50  * Table of number of bits a motion vector component needs.
51  */
52 static uint8_t mv_penalty[MAX_FCODE+1][MAX_DMV*2+1];
53 
54 /**
55  * Minimal fcode that a motion vector component would need.
56  */
57 static uint8_t fcode_tab[MAX_MV*2+1];
58 
59 /**
60  * Minimal fcode that a motion vector component would need in umv.
61  * All entries in this table are 1.
62  */
63 static uint8_t umv_fcode_tab[MAX_MV*2+1];
64 
65 //unified encoding tables for run length encoding of coefficients
66 //unified in the sense that the specification specifies the encoding in several steps.
67 static uint8_t uni_h263_intra_aic_rl_len [64*64*2*2];
68 static uint8_t uni_h263_inter_rl_len [64*64*2*2];
69 //#define UNI_MPEG4_ENC_INDEX(last,run,level) ((last)*128 + (run)*256 + (level))
70 //#define UNI_MPEG4_ENC_INDEX(last,run,level) ((last)*128*64 + (run) + (level)*64)
71 #define UNI_MPEG4_ENC_INDEX(last,run,level) ((last)*128*64 + (run)*128 + (level))
72 
73 static const uint8_t wrong_run[102] = {
74  1, 2, 3, 5, 4, 10, 9, 8,
75 11, 15, 17, 16, 23, 22, 21, 20,
76 19, 18, 25, 24, 27, 26, 11, 7,
77  6, 1, 2, 13, 2, 2, 2, 2,
78  6, 12, 3, 9, 1, 3, 4, 3,
79  7, 4, 1, 1, 5, 5, 14, 6,
80  1, 7, 1, 8, 1, 1, 1, 1,
81 10, 1, 1, 5, 9, 17, 25, 24,
82 29, 33, 32, 41, 2, 23, 28, 31,
83  3, 22, 30, 4, 27, 40, 8, 26,
84  6, 39, 7, 38, 16, 37, 15, 10,
85 11, 12, 13, 14, 1, 21, 20, 18,
86 19, 2, 1, 34, 35, 36
87 };
88 
89 /**
90  * Return the 4 bit value that specifies the given aspect ratio.
91  * This may be one of the standard aspect ratios or it specifies
92  * that the aspect will be stored explicitly later.
93  */
95  int i;
96 
97  if(aspect.num==0 || aspect.den==0) aspect= (AVRational){1,1};
98 
99  for(i=1; i<6; i++){
100  if(av_cmp_q(ff_h263_pixel_aspect[i], aspect) == 0){
101  return i;
102  }
103  }
104 
105  return FF_ASPECT_EXTENDED;
106 }
107 
108 void ff_h263_encode_picture_header(MpegEncContext * s, int picture_number)
109 {
110  int format, coded_frame_rate, coded_frame_rate_base, i, temp_ref;
111  int best_clock_code=1;
112  int best_divisor=60;
113  int best_error= INT_MAX;
114  int custom_pcf;
115 
116  if(s->h263_plus){
117  for(i=0; i<2; i++){
118  int div, error;
119  div= (s->avctx->time_base.num*1800000LL + 500LL*s->avctx->time_base.den) / ((1000LL+i)*s->avctx->time_base.den);
120  div= av_clip(div, 1, 127);
121  error= FFABS(s->avctx->time_base.num*1800000LL - (1000LL+i)*s->avctx->time_base.den*div);
122  if(error < best_error){
123  best_error= error;
124  best_divisor= div;
125  best_clock_code= i;
126  }
127  }
128  }
129  custom_pcf = best_clock_code != 1 || best_divisor != 60;
130  coded_frame_rate= 1800000;
131  coded_frame_rate_base= (1000+best_clock_code)*best_divisor;
132 
133  align_put_bits(&s->pb);
134 
135  /* Update the pointer to last GOB */
136  s->ptr_lastgob = put_bits_ptr(&s->pb);
137  put_bits(&s->pb, 22, 0x20); /* PSC */
138  temp_ref= s->picture_number * (int64_t)coded_frame_rate * s->avctx->time_base.num / //FIXME use timestamp
139  (coded_frame_rate_base * (int64_t)s->avctx->time_base.den);
140  put_sbits(&s->pb, 8, temp_ref); /* TemporalReference */
141 
142  put_bits(&s->pb, 1, 1); /* marker */
143  put_bits(&s->pb, 1, 0); /* H.263 id */
144  put_bits(&s->pb, 1, 0); /* split screen off */
145  put_bits(&s->pb, 1, 0); /* camera off */
146  put_bits(&s->pb, 1, 0); /* freeze picture release off */
147 
149  if (!s->h263_plus) {
150  /* H.263v1 */
151  put_bits(&s->pb, 3, format);
152  put_bits(&s->pb, 1, (s->pict_type == AV_PICTURE_TYPE_P));
153  /* By now UMV IS DISABLED ON H.263v1, since the restrictions
154  of H.263v1 UMV implies to check the predicted MV after
155  calculation of the current MB to see if we're on the limits */
156  put_bits(&s->pb, 1, 0); /* Unrestricted Motion Vector: off */
157  put_bits(&s->pb, 1, 0); /* SAC: off */
158  put_bits(&s->pb, 1, s->obmc); /* Advanced Prediction */
159  put_bits(&s->pb, 1, 0); /* only I/P-frames, no PB-frame */
160  put_bits(&s->pb, 5, s->qscale);
161  put_bits(&s->pb, 1, 0); /* Continuous Presence Multipoint mode: off */
162  } else {
163  int ufep=1;
164  /* H.263v2 */
165  /* H.263 Plus PTYPE */
166 
167  put_bits(&s->pb, 3, 7);
168  put_bits(&s->pb,3,ufep); /* Update Full Extended PTYPE */
169  if (format == 8)
170  put_bits(&s->pb,3,6); /* Custom Source Format */
171  else
172  put_bits(&s->pb, 3, format);
173 
174  put_bits(&s->pb,1, custom_pcf);
175  put_bits(&s->pb,1, s->umvplus); /* Unrestricted Motion Vector */
176  put_bits(&s->pb,1,0); /* SAC: off */
177  put_bits(&s->pb,1,s->obmc); /* Advanced Prediction Mode */
178  put_bits(&s->pb,1,s->h263_aic); /* Advanced Intra Coding */
179  put_bits(&s->pb,1,s->loop_filter); /* Deblocking Filter */
180  put_bits(&s->pb,1,s->h263_slice_structured); /* Slice Structured */
181  put_bits(&s->pb,1,0); /* Reference Picture Selection: off */
182  put_bits(&s->pb,1,0); /* Independent Segment Decoding: off */
183  put_bits(&s->pb,1,s->alt_inter_vlc); /* Alternative Inter VLC */
184  put_bits(&s->pb,1,s->modified_quant); /* Modified Quantization: */
185  put_bits(&s->pb,1,1); /* "1" to prevent start code emulation */
186  put_bits(&s->pb,3,0); /* Reserved */
187 
188  put_bits(&s->pb, 3, s->pict_type == AV_PICTURE_TYPE_P);
189 
190  put_bits(&s->pb,1,0); /* Reference Picture Resampling: off */
191  put_bits(&s->pb,1,0); /* Reduced-Resolution Update: off */
192  put_bits(&s->pb,1,s->no_rounding); /* Rounding Type */
193  put_bits(&s->pb,2,0); /* Reserved */
194  put_bits(&s->pb,1,1); /* "1" to prevent start code emulation */
195 
196  /* This should be here if PLUSPTYPE */
197  put_bits(&s->pb, 1, 0); /* Continuous Presence Multipoint mode: off */
198 
199  if (format == 8) {
200  /* Custom Picture Format (CPFMT) */
201  unsigned aspect_ratio_info = ff_h263_aspect_to_info(s->avctx->sample_aspect_ratio);
202 
203  put_bits(&s->pb,4, aspect_ratio_info);
204  put_bits(&s->pb,9,(s->width >> 2) - 1);
205  put_bits(&s->pb,1,1); /* "1" to prevent start code emulation */
206  put_bits(&s->pb,9,(s->height >> 2));
207  if (aspect_ratio_info == FF_ASPECT_EXTENDED){
208  put_bits(&s->pb, 8, s->avctx->sample_aspect_ratio.num);
209  put_bits(&s->pb, 8, s->avctx->sample_aspect_ratio.den);
210  }
211  }
212  if (custom_pcf) {
213  if(ufep){
214  put_bits(&s->pb, 1, best_clock_code);
215  put_bits(&s->pb, 7, best_divisor);
216  }
217  put_sbits(&s->pb, 2, temp_ref>>8);
218  }
219 
220  /* Unlimited Unrestricted Motion Vectors Indicator (UUI) */
221  if (s->umvplus)
222 // put_bits(&s->pb,1,1); /* Limited according tables of Annex D */
223 //FIXME check actual requested range
224  put_bits(&s->pb,2,1); /* unlimited */
225  if(s->h263_slice_structured)
226  put_bits(&s->pb,2,0); /* no weird submodes */
227 
228  put_bits(&s->pb, 5, s->qscale);
229  }
230 
231  put_bits(&s->pb, 1, 0); /* no PEI */
232 
233  if(s->h263_slice_structured){
234  put_bits(&s->pb, 1, 1);
235 
236  av_assert1(s->mb_x == 0 && s->mb_y == 0);
238 
239  put_bits(&s->pb, 1, 1);
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 H.263 (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(pb, 1, 1);
427  else if (val == 1)
428  put_bits(pb, 3, 0);
429  else if (val == -1)
430  put_bits(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(pb, (2*n_bits)+1, code);
450  }
451 }
452 
453 static int h263_pred_dc(MpegEncContext * s, int n, int16_t **dc_val_ptr)
454 {
455  int x, y, wrap, a, c, pred_dc;
456  int16_t *dc_val;
457 
458  /* find prediction */
459  if (n < 4) {
460  x = 2 * s->mb_x + (n & 1);
461  y = 2 * s->mb_y + ((n & 2) >> 1);
462  wrap = s->b8_stride;
463  dc_val = s->dc_val[0];
464  } else {
465  x = s->mb_x;
466  y = s->mb_y;
467  wrap = s->mb_stride;
468  dc_val = s->dc_val[n - 4 + 1];
469  }
470  /* B C
471  * A X
472  */
473  a = dc_val[(x - 1) + (y) * wrap];
474  c = dc_val[(x) + (y - 1) * wrap];
475 
476  /* No prediction outside GOB boundary */
477  if (s->first_slice_line && n != 3) {
478  if (n != 2) c = 1024;
479  if (n != 1 && s->mb_x == s->resync_mb_x) a = 1024;
480  }
481  /* just DC prediction */
482  if (a != 1024 && c != 1024)
483  pred_dc = (a + c) >> 1;
484  else if (a != 1024)
485  pred_dc = a;
486  else
487  pred_dc = c;
488 
489  /* we assume pred is positive */
490  *dc_val_ptr = &dc_val[x + y * wrap];
491  return pred_dc;
492 }
493 
495  int16_t block[6][64],
496  int motion_x, int motion_y)
497 {
498  int cbpc, cbpy, i, cbp, pred_x, pred_y;
499  int16_t pred_dc;
500  int16_t rec_intradc[6];
501  int16_t *dc_ptr[6];
502  const int interleaved_stats = s->avctx->flags & AV_CODEC_FLAG_PASS1;
503 
504  if (!s->mb_intra) {
505  /* compute cbp */
506  cbp= get_p_cbp(s, block, motion_x, motion_y);
507 
508  if ((cbp | motion_x | motion_y | s->dquant | (s->mv_type - MV_TYPE_16X16)) == 0) {
509  /* skip macroblock */
510  put_bits(&s->pb, 1, 1);
511  if(interleaved_stats){
512  s->misc_bits++;
513  s->last_bits++;
514  }
515  s->skip_count++;
516 
517  return;
518  }
519  put_bits(&s->pb, 1, 0); /* mb coded */
520 
521  cbpc = cbp & 3;
522  cbpy = cbp >> 2;
523  if(s->alt_inter_vlc==0 || cbpc!=3)
524  cbpy ^= 0xF;
525  if(s->dquant) cbpc+= 8;
526  if(s->mv_type==MV_TYPE_16X16){
527  put_bits(&s->pb,
530 
531  put_bits(&s->pb, ff_h263_cbpy_tab[cbpy][1], ff_h263_cbpy_tab[cbpy][0]);
532  if(s->dquant)
533  put_bits(&s->pb, 2, dquant_code[s->dquant+2]);
534 
535  if(interleaved_stats){
536  s->misc_bits+= get_bits_diff(s);
537  }
538 
539  /* motion vectors: 16x16 mode */
540  ff_h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
541 
542  if (!s->umvplus) {
543  ff_h263_encode_motion_vector(s, motion_x - pred_x,
544  motion_y - pred_y, 1);
545  }
546  else {
547  h263p_encode_umotion(&s->pb, motion_x - pred_x);
548  h263p_encode_umotion(&s->pb, motion_y - pred_y);
549  if (((motion_x - pred_x) == 1) && ((motion_y - pred_y) == 1))
550  /* To prevent Start Code emulation */
551  put_bits(&s->pb,1,1);
552  }
553  }else{
554  put_bits(&s->pb,
555  ff_h263_inter_MCBPC_bits[cbpc+16],
556  ff_h263_inter_MCBPC_code[cbpc+16]);
557  put_bits(&s->pb, ff_h263_cbpy_tab[cbpy][1], ff_h263_cbpy_tab[cbpy][0]);
558  if(s->dquant)
559  put_bits(&s->pb, 2, dquant_code[s->dquant+2]);
560 
561  if(interleaved_stats){
562  s->misc_bits+= get_bits_diff(s);
563  }
564 
565  for(i=0; i<4; i++){
566  /* motion vectors: 8x8 mode*/
567  ff_h263_pred_motion(s, i, 0, &pred_x, &pred_y);
568 
569  motion_x = s->current_picture.motion_val[0][s->block_index[i]][0];
570  motion_y = s->current_picture.motion_val[0][s->block_index[i]][1];
571  if (!s->umvplus) {
572  ff_h263_encode_motion_vector(s, motion_x - pred_x,
573  motion_y - pred_y, 1);
574  }
575  else {
576  h263p_encode_umotion(&s->pb, motion_x - pred_x);
577  h263p_encode_umotion(&s->pb, motion_y - pred_y);
578  if (((motion_x - pred_x) == 1) && ((motion_y - pred_y) == 1))
579  /* To prevent Start Code emulation */
580  put_bits(&s->pb,1,1);
581  }
582  }
583  }
584 
585  if(interleaved_stats){
586  s->mv_bits+= get_bits_diff(s);
587  }
588  } else {
589  av_assert2(s->mb_intra);
590 
591  cbp = 0;
592  if (s->h263_aic) {
593  /* Predict DC */
594  for(i=0; i<6; i++) {
595  int16_t level = block[i][0];
596  int scale;
597 
598  if(i<4) scale= s->y_dc_scale;
599  else scale= s->c_dc_scale;
600 
601  pred_dc = h263_pred_dc(s, i, &dc_ptr[i]);
602  level -= pred_dc;
603  /* Quant */
604  if (level >= 0)
605  level = (level + (scale>>1))/scale;
606  else
607  level = (level - (scale>>1))/scale;
608 
609  if(!s->modified_quant){
610  if (level < -127)
611  level = -127;
612  else if (level > 127)
613  level = 127;
614  }
615 
616  block[i][0] = level;
617  /* Reconstruction */
618  rec_intradc[i] = scale*level + pred_dc;
619  /* Oddify */
620  rec_intradc[i] |= 1;
621  //if ((rec_intradc[i] % 2) == 0)
622  // rec_intradc[i]++;
623  /* Clipping */
624  if (rec_intradc[i] < 0)
625  rec_intradc[i] = 0;
626  else if (rec_intradc[i] > 2047)
627  rec_intradc[i] = 2047;
628 
629  /* Update AC/DC tables */
630  *dc_ptr[i] = rec_intradc[i];
631  /* AIC can change CBP */
632  if (s->block_last_index[i] > 0 ||
633  (s->block_last_index[i] == 0 && level !=0))
634  cbp |= 1 << (5 - i);
635  }
636  }else{
637  for(i=0; i<6; i++) {
638  /* compute cbp */
639  if (s->block_last_index[i] >= 1)
640  cbp |= 1 << (5 - i);
641  }
642  }
643 
644  cbpc = cbp & 3;
645  if (s->pict_type == AV_PICTURE_TYPE_I) {
646  if(s->dquant) cbpc+=4;
647  put_bits(&s->pb,
650  } else {
651  if(s->dquant) cbpc+=8;
652  put_bits(&s->pb, 1, 0); /* mb coded */
653  put_bits(&s->pb,
654  ff_h263_inter_MCBPC_bits[cbpc + 4],
655  ff_h263_inter_MCBPC_code[cbpc + 4]);
656  }
657  if (s->h263_aic) {
658  /* XXX: currently, we do not try to use ac prediction */
659  put_bits(&s->pb, 1, 0); /* no AC prediction */
660  }
661  cbpy = cbp >> 2;
662  put_bits(&s->pb, ff_h263_cbpy_tab[cbpy][1], ff_h263_cbpy_tab[cbpy][0]);
663  if(s->dquant)
664  put_bits(&s->pb, 2, dquant_code[s->dquant+2]);
665 
666  if(interleaved_stats){
667  s->misc_bits+= get_bits_diff(s);
668  }
669  }
670 
671  for(i=0; i<6; i++) {
672  /* encode each block */
674 
675  /* Update INTRADC for decoding */
676  if (s->h263_aic && s->mb_intra) {
677  block[i][0] = rec_intradc[i];
678 
679  }
680  }
681 
682  if(interleaved_stats){
683  if (!s->mb_intra) {
684  s->p_tex_bits+= get_bits_diff(s);
685  }else{
686  s->i_tex_bits+= get_bits_diff(s);
687  s->i_count++;
688  }
689  }
690 }
691 
692 void ff_h263_encode_motion(PutBitContext *pb, int val, int f_code)
693 {
694  int range, bit_size, sign, code, bits;
695 
696  if (val == 0) {
697  /* zero vector */
698  code = 0;
699  put_bits(pb, ff_mvtab[code][1], ff_mvtab[code][0]);
700  } else {
701  bit_size = f_code - 1;
702  range = 1 << bit_size;
703  /* modulo encoding */
704  val = sign_extend(val, 6 + bit_size);
705  sign = val>>31;
706  val= (val^sign)-sign;
707  sign&=1;
708 
709  val--;
710  code = (val >> bit_size) + 1;
711  bits = val & (range - 1);
712 
713  put_bits(pb, ff_mvtab[code][1] + 1, (ff_mvtab[code][0] << 1) | sign);
714  if (bit_size > 0) {
715  put_bits(pb, bit_size, bits);
716  }
717  }
718 }
719 
721 {
722  int f_code;
723  int mv;
724 
725  for(f_code=1; f_code<=MAX_FCODE; f_code++){
726  for(mv=-MAX_DMV; mv<=MAX_DMV; mv++){
727  int len;
728 
729  if(mv==0) len= ff_mvtab[0][1];
730  else{
731  int val, bit_size, code;
732 
733  bit_size = f_code - 1;
734 
735  val=mv;
736  if (val < 0)
737  val = -val;
738  val--;
739  code = (val >> bit_size) + 1;
740  if(code<33){
741  len= ff_mvtab[code][1] + 1 + bit_size;
742  }else{
743  len= ff_mvtab[32][1] + av_log2(code>>5) + 2 + bit_size;
744  }
745  }
746 
747  mv_penalty[f_code][mv+MAX_DMV]= len;
748  }
749  }
750 
751  for(f_code=MAX_FCODE; f_code>0; f_code--){
752  for(mv=-(16<<f_code); mv<(16<<f_code); mv++){
753  fcode_tab[mv+MAX_MV]= f_code;
754  }
755  }
756 
757  for(mv=0; mv<MAX_MV*2+1; mv++){
758  umv_fcode_tab[mv]= 1;
759  }
760 }
761 
762 static av_cold void init_uni_h263_rl_tab(const RLTable *rl, uint8_t *len_tab)
763 {
764  int slevel, run, last;
765 
766  av_assert0(MAX_LEVEL >= 64);
767  av_assert0(MAX_RUN >= 63);
768 
769  for(slevel=-64; slevel<64; slevel++){
770  if(slevel==0) continue;
771  for(run=0; run<64; run++){
772  for(last=0; last<=1; last++){
773  const int index= UNI_MPEG4_ENC_INDEX(last, run, slevel+64);
774  int level= slevel < 0 ? -slevel : slevel;
775  int sign= slevel < 0 ? 1 : 0;
776  int bits, len, code;
777 
778  len_tab[index]= 100;
779 
780  /* ESC0 */
781  code= get_rl_index(rl, last, run, level);
782  bits= rl->table_vlc[code][0];
783  len= rl->table_vlc[code][1];
784  bits=bits*2+sign; len++;
785 
786  if (code != rl->n && len < len_tab[index])
787  len_tab [index]= len;
788 
789  /* ESC */
790  bits= rl->table_vlc[rl->n][0];
791  len = rl->table_vlc[rl->n][1];
792  bits=bits*2+last; len++;
793  bits=bits*64+run; len+=6;
794  bits=bits*256+(level&0xff); len+=8;
795 
796  if (len < len_tab[index])
797  len_tab [index]= len;
798  }
799  }
800  }
801 }
802 
804 {
805  static uint8_t rl_intra_table[2][2 * MAX_RUN + MAX_LEVEL + 3];
806 
807  ff_rl_init(&ff_rl_intra_aic, rl_intra_table);
809 
812 
814 }
815 
817 {
818  static AVOnce init_static_once = AV_ONCE_INIT;
819 
820  s->me.mv_penalty= mv_penalty; // FIXME exact table for MSMPEG4 & H.263+
821 
822  s->intra_ac_vlc_length =s->inter_ac_vlc_length = uni_h263_inter_rl_len;
823  s->intra_ac_vlc_last_length=s->inter_ac_vlc_last_length= uni_h263_inter_rl_len + 128*64;
824  if(s->h263_aic){
825  s->intra_ac_vlc_length = uni_h263_intra_aic_rl_len;
826  s->intra_ac_vlc_last_length= uni_h263_intra_aic_rl_len + 128*64;
827  }
828  s->ac_esc_length= 7+1+6+8;
829 
830  // use fcodes >1 only for MPEG-4 & H.263 & H.263+ FIXME
831  switch(s->codec_id){
832  case AV_CODEC_ID_MPEG4:
833  s->fcode_tab= fcode_tab;
834  break;
835  case AV_CODEC_ID_H263P:
836  if(s->umvplus)
837  s->fcode_tab= umv_fcode_tab;
838  if(s->modified_quant){
839  s->min_qcoeff= -2047;
840  s->max_qcoeff= 2047;
841  }else{
842  s->min_qcoeff= -127;
843  s->max_qcoeff= 127;
844  }
845  break;
846  // Note for MPEG-4 & H.263 the dc-scale table will be set per frame as needed later
847  case AV_CODEC_ID_FLV1:
848  if (s->h263_flv > 1) {
849  s->min_qcoeff= -1023;
850  s->max_qcoeff= 1023;
851  } else {
852  s->min_qcoeff= -127;
853  s->max_qcoeff= 127;
854  }
855  break;
856  default: //nothing needed - default table already set in mpegvideo.c
857  s->min_qcoeff= -127;
858  s->max_qcoeff= 127;
859  }
860  if(s->h263_aic){
861  s->y_dc_scale_table=
862  s->c_dc_scale_table= ff_aic_dc_scale_table;
863  }else{
864  s->y_dc_scale_table=
865  s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
866  }
867 
868  ff_thread_once(&init_static_once, h263_encode_init_static);
869 }
870 
872 {
873  int i, mb_pos;
874 
875  for(i=0; i<6; i++){
876  if(s->mb_num-1 <= ff_mba_max[i]) break;
877  }
878  mb_pos= s->mb_x + s->mb_width*s->mb_y;
879  put_bits(&s->pb, ff_mba_length[i], mb_pos);
880 }
881 
882 #define OFFSET(x) offsetof(MpegEncContext, x)
883 #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
884 static const AVOption h263_options[] = {
885  { "obmc", "use overlapped block motion compensation.", OFFSET(obmc), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, VE },
886  { "mb_info", "emit macroblock info for RFC 2190 packetization, the parameter value is the maximum payload size", OFFSET(mb_info), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, INT_MAX, VE },
889  { NULL },
890 };
891 
892 static const AVClass h263_class = {
893  .class_name = "H.263 encoder",
894  .item_name = av_default_item_name,
895  .option = h263_options,
896  .version = LIBAVUTIL_VERSION_INT,
897 };
898 
900  .p.name = "h263",
901  .p.long_name = NULL_IF_CONFIG_SMALL("H.263 / H.263-1996"),
902  .p.type = AVMEDIA_TYPE_VIDEO,
903  .p.id = AV_CODEC_ID_H263,
904  .p.pix_fmts = (const enum AVPixelFormat[]){AV_PIX_FMT_YUV420P, AV_PIX_FMT_NONE},
905  .p.priv_class = &h263_class,
906  .caps_internal = FF_CODEC_CAP_INIT_CLEANUP,
907  .priv_data_size = sizeof(MpegEncContext),
910  .close = ff_mpv_encode_end,
911 };
912 
913 static const AVOption h263p_options[] = {
914  { "umv", "Use unlimited motion vectors.", OFFSET(umvplus), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, VE },
915  { "aiv", "Use alternative inter VLC.", OFFSET(alt_inter_vlc), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, VE },
916  { "obmc", "use overlapped block motion compensation.", OFFSET(obmc), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, VE },
917  { "structured_slices", "Write slice start position at every GOB header instead of just GOB number.", OFFSET(h263_slice_structured), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, VE},
920  { NULL },
921 };
922 static const AVClass h263p_class = {
923  .class_name = "H.263p encoder",
924  .item_name = av_default_item_name,
925  .option = h263p_options,
926  .version = LIBAVUTIL_VERSION_INT,
927 };
928 
930  .p.name = "h263p",
931  .p.long_name = NULL_IF_CONFIG_SMALL("H.263+ / H.263-1998 / H.263 version 2"),
932  .p.type = AVMEDIA_TYPE_VIDEO,
933  .p.id = AV_CODEC_ID_H263P,
934  .p.pix_fmts = (const enum AVPixelFormat[]){ AV_PIX_FMT_YUV420P, AV_PIX_FMT_NONE },
935  .p.priv_class = &h263p_class,
936  .p.capabilities = AV_CODEC_CAP_SLICE_THREADS,
937  .caps_internal = FF_CODEC_CAP_INIT_CLEANUP,
938  .priv_data_size = sizeof(MpegEncContext),
941  .close = ff_mpv_encode_end,
942 };
error
static void error(const char *err)
Definition: target_bsf_fuzzer.c:31
MV_TYPE_16X16
#define MV_TYPE_16X16
1 vector for the whole mb
Definition: mpegvideo.h:255
h263data.h
AVPixelFormat
AVPixelFormat
Pixel format.
Definition: pixfmt.h:64
FF_ASPECT_EXTENDED
#define FF_ASPECT_EXTENDED
Definition: h263.h:26
level
uint8_t level
Definition: svq3.c:206
av_clip
#define av_clip
Definition: common.h:95
FF_CODEC_CAP_INIT_CLEANUP
#define FF_CODEC_CAP_INIT_CLEANUP
The codec allows calling the close function for deallocation even if the init function returned a fai...
Definition: codec_internal.h:41
get_bits_diff
static int get_bits_diff(MpegEncContext *s)
Definition: mpegvideoenc.h:139
wrong_run
static const uint8_t wrong_run[102]
Definition: ituh263enc.c:73
fcode_tab
static uint8_t fcode_tab[MAX_MV *2+1]
Minimal fcode that a motion vector component would need.
Definition: ituh263enc.c:57
align_put_bits
static void align_put_bits(PutBitContext *s)
Pad the bitstream with zeros up to the next byte boundary.
Definition: put_bits.h:413
uni_h263_inter_rl_len
static uint8_t uni_h263_inter_rl_len[64 *64 *2 *2]
Definition: ituh263enc.c:68
UNI_MPEG4_ENC_INDEX
#define UNI_MPEG4_ENC_INDEX(last, run, level)
Definition: ituh263enc.c:71
h263p_options
static const AVOption h263p_options[]
Definition: ituh263enc.c:913
thread.h
ff_mpeg1_dc_scale_table
const uint8_t ff_mpeg1_dc_scale_table[128]
Definition: mpegvideodata.c:33
VE
#define VE
Definition: ituh263enc.c:883
mpegvideoenc.h
mv
static const int8_t mv[256][2]
Definition: 4xm.c:80
put_sbits
static void put_sbits(PutBitContext *pb, int n, int32_t value)
Definition: put_bits.h:281
MAX_RUN
#define MAX_RUN
Definition: rl.h:35
h263enc.h
AV_CODEC_ID_MPEG4
@ AV_CODEC_ID_MPEG4
Definition: codec_id.h:62
put_bits
static void put_bits(Jpeg2000EncoderContext *s, int val, int n)
put n times val bit
Definition: j2kenc.c:221
MAX_DMV
#define MAX_DMV
Definition: motion_est.h:37
internal.h
av_const
#define av_const
Definition: attributes.h:84
AVOption
AVOption.
Definition: opt.h:251
OFFSET
#define OFFSET(x)
Definition: ituh263enc.c:882
FFCodec
Definition: codec_internal.h:118
init_uni_h263_rl_tab
static av_cold void init_uni_h263_rl_tab(const RLTable *rl, uint8_t *len_tab)
Definition: ituh263enc.c:762
mpegvideo.h
CANDIDATE_MB_TYPE_INTER
#define CANDIDATE_MB_TYPE_INTER
Definition: mpegutils.h:98
mpegutils.h
h263_pred_dc
static int h263_pred_dc(MpegEncContext *s, int n, int16_t **dc_val_ptr)
Definition: ituh263enc.c:453
init
static int init
Definition: av_tx.c:47
FF_MPV_COMMON_MOTION_EST_OPTS
#define FF_MPV_COMMON_MOTION_EST_OPTS
Definition: mpegvideoenc.h:108
MAX_FCODE
#define MAX_FCODE
Definition: mpegutils.h:41
ff_mpv_encode_picture
int ff_mpv_encode_picture(AVCodecContext *avctx, AVPacket *pkt, const AVFrame *pic_arg, int *got_packet)
Definition: mpegvideo_enc.c:1671
FF_MPV_COMMON_OPTS
#define FF_MPV_COMMON_OPTS
Definition: mpegvideoenc.h:65
FFCodec::p
AVCodec p
The public AVCodec.
Definition: codec_internal.h:122
h263p_class
static const AVClass h263p_class
Definition: ituh263enc.c:922
ff_match_2uint16
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:872
ff_h263_pred_motion
int16_t * ff_h263_pred_motion(MpegEncContext *s, int block, int dir, int *px, int *py)
Definition: h263.c:190
wrap
#define wrap(func)
Definition: neontest.h:65
ff_h263_pixel_aspect
const AVRational ff_h263_pixel_aspect[16]
Definition: h263data.c:273
RLTable
RLTable.
Definition: rl.h:39
mv_penalty
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:52
val
static double val(void *priv, double ch)
Definition: aeval.c:77
scale
static av_always_inline float scale(float x, float s)
Definition: vf_v360.c:1389
ff_h263_encode_motion_vector
static void ff_h263_encode_motion_vector(MpegEncContext *s, int x, int y, int f_code)
Definition: h263enc.h:60
ff_h263_aspect_to_info
av_const int ff_h263_aspect_to_info(AVRational aspect)
Return the 4 bit value that specifies the given aspect ratio.
Definition: ituh263enc.c:94
FF_CODEC_ENCODE_CB
#define FF_CODEC_ENCODE_CB(func)
Definition: codec_internal.h:269
AVRational::num
int num
Numerator.
Definition: rational.h:59
CANDIDATE_MB_TYPE_INTER4V
#define CANDIDATE_MB_TYPE_INTER4V
Definition: mpegutils.h:99
h263_encode_block
static void h263_encode_block(MpegEncContext *s, int16_t *block, int n)
Encode an 8x8 block.
Definition: ituh263enc.c:305
RLTable::n
int n
number of entries of table_vlc minus 1
Definition: rl.h:40
ff_thread_once
static int ff_thread_once(char *control, void(*routine)(void))
Definition: thread.h:179
ff_h263_encode_motion
void ff_h263_encode_motion(PutBitContext *pb, int val, int f_code)
Definition: ituh263enc.c:692
FF_ARRAY_ELEMS
#define FF_ARRAY_ELEMS(a)
Definition: sinewin_tablegen.c:29
av_cold
#define av_cold
Definition: attributes.h:90
MAX_MV
#define MAX_MV
Definition: motion_est.h:35
ff_h263_encode_picture_header
void ff_h263_encode_picture_header(MpegEncContext *s, int picture_number)
Definition: ituh263enc.c:108
s
#define s(width, name)
Definition: cbs_vp9.c:256
format
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample format(the sample packing is implied by the sample format) and sample rate. The lists are not just lists
get_rl_index
static int get_rl_index(const RLTable *rl, int last, int run, int level)
Definition: rl.h:91
get_p_cbp
static int get_p_cbp(MpegEncContext *s, int16_t block[6][64], int motion_x, int motion_y)
Definition: h263enc.h:73
bits
uint8_t bits
Definition: vp3data.h:141
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
limits.h
ff_h263p_encoder
const FFCodec ff_h263p_encoder
Definition: ituh263enc.c:929
ff_h263_encode_init
av_cold void ff_h263_encode_init(MpegEncContext *s)
Definition: ituh263enc.c:816
AV_PIX_FMT_YUV420P
@ AV_PIX_FMT_YUV420P
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
Definition: pixfmt.h:66
PutBitContext
Definition: put_bits.h:50
ff_rl_init
av_cold void ff_rl_init(RLTable *rl, uint8_t static_store[2][2 *MAX_RUN+MAX_LEVEL+3])
Initialize index_run, max_level and max_run from n, last, table_vlc, table_run and table_level.
Definition: rl.c:27
ff_h263_encode_mb
void ff_h263_encode_mb(MpegEncContext *s, int16_t block[6][64], int motion_x, int motion_y)
Definition: ituh263enc.c:494
FFABS
#define FFABS(a)
Absolute value, Note, INT_MIN / INT64_MIN result in undefined behavior as they are not representable ...
Definition: common.h:64
LIBAVUTIL_VERSION_INT
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
AV_ONCE_INIT
#define AV_ONCE_INIT
Definition: thread.h:177
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:66
NULL
#define NULL
Definition: coverity.c:32
init_mv_penalty_and_fcode
static av_cold void init_mv_penalty_and_fcode(void)
Definition: ituh263enc.c:720
run
uint8_t run
Definition: svq3.c:205
RLTable::table_vlc
const uint16_t(* table_vlc)[2]
Definition: rl.h:42
ff_h263_encoder
const FFCodec ff_h263_encoder
Definition: ituh263enc.c:899
AVRational
Rational number (pair of numerator and denominator).
Definition: rational.h:58
uni_h263_intra_aic_rl_len
static uint8_t uni_h263_intra_aic_rl_len[64 *64 *2 *2]
Definition: ituh263enc.c:67
av_default_item_name
const char * av_default_item_name(void *ptr)
Return the context name.
Definition: log.c:237
AV_PICTURE_TYPE_I
@ AV_PICTURE_TYPE_I
Intra.
Definition: avutil.h:274
mathops.h
ff_mba_max
const uint16_t ff_mba_max[6]
Definition: h263data.c:265
ff_mpv_encode_end
av_cold int ff_mpv_encode_end(AVCodecContext *avctx)
Definition: mpegvideo_enc.c:932
ff_init_qscale_tab
void ff_init_qscale_tab(MpegEncContext *s)
init s->current_picture.qscale_table from s->lambda_table
Definition: mpegvideo_enc.c:236
AVOnce
#define AVOnce
Definition: thread.h:176
index
int index
Definition: gxfenc.c:89
c
Undefined Behavior In the C some operations are like signed integer dereferencing freed accessing outside allocated Undefined Behavior must not occur in a C it is not safe even if the output of undefined operations is unused The unsafety may seem nit picking but Optimizing compilers have in fact optimized code on the assumption that no undefined Behavior occurs Optimizing code based on wrong assumptions can and has in some cases lead to effects beyond the output of computations The signed integer overflow problem in speed critical code Code which is highly optimized and works with signed integers sometimes has the problem that often the output of the computation does not c
Definition: undefined.txt:32
MAX_LEVEL
#define MAX_LEVEL
Definition: rl.h:36
ff_clean_h263_qscales
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:272
ff_h263_rl_inter
RLTable ff_h263_rl_inter
Definition: h263data.c:159
NULL_IF_CONFIG_SMALL
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
Definition: internal.h:117
codec_internal.h
AV_CODEC_ID_H263
@ AV_CODEC_ID_H263
Definition: codec_id.h:54
ff_h263_cbpy_tab
const uint8_t ff_h263_cbpy_tab[16][2]
Definition: h263data.c:82
ff_rl_intra_aic
RLTable ff_rl_intra_aic
Definition: h263data.c:228
a
The reader does not expect b to be semantically here and if the code is changed by maybe adding a a division or other the signedness will almost certainly be mistaken To avoid this confusion a new type was SUINT is the C unsigned type but it holds a signed int to use the same example SUINT a
Definition: undefined.txt:41
AV_CODEC_CAP_SLICE_THREADS
#define AV_CODEC_CAP_SLICE_THREADS
Codec supports slice-based (or partition-based) multithreading.
Definition: codec.h:117
mpegvideodata.h
attributes.h
ff_h263_inter_MCBPC_bits
const uint8_t ff_h263_inter_MCBPC_bits[28]
Definition: h263data.c:47
h263_options
static const AVOption h263_options[]
Definition: ituh263enc.c:884
av_assert2
#define av_assert2(cond)
assert() equivalent, that does lie in speed critical code.
Definition: avassert.h:64
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:269
code
and forward the test the status of outputs and forward it to the corresponding return FFERROR_NOT_READY If the filters stores internally one or a few frame for some it can consider them to be part of the FIFO and delay acknowledging a status change accordingly Example code
Definition: filter_design.txt:178
av_assert1
#define av_assert1(cond)
assert() equivalent, that does not lie in speed critical code.
Definition: avassert.h:53
ff_h263_format
const uint16_t ff_h263_format[8][2]
Definition: h263data.c:236
AVCodec::name
const char * name
Name of the codec implementation.
Definition: codec.h:211
ff_h263_encode_mba
void ff_h263_encode_mba(MpegEncContext *s)
Definition: ituh263enc.c:871
len
int len
Definition: vorbis_enc_data.h:426
ff_flv2_encode_ac_esc
void ff_flv2_encode_ac_esc(PutBitContext *pb, int slevel, int level, int run, int last)
Definition: flvenc.c:76
avcodec.h
av_cmp_q
static int av_cmp_q(AVRational a, AVRational b)
Compare two rationals.
Definition: rational.h:89
h263_encode_init_static
static av_cold void h263_encode_init_static(void)
Definition: ituh263enc.c:803
AVClass::class_name
const char * class_name
The name of the class; usually it is the same name as the context structure type to which the AVClass...
Definition: log.h:71
ff_aic_dc_scale_table
const uint8_t ff_aic_dc_scale_table[32]
Definition: h263data.c:245
ff_mvtab
const uint8_t ff_mvtab[33][2]
Definition: h263data.c:88
ff_h263_intra_MCBPC_bits
const uint8_t ff_h263_intra_MCBPC_bits[9]
Definition: h263data.c:33
dquant_code
static const int dquant_code[5]
Definition: ituh263enc.c:298
AV_CODEC_ID_H263P
@ AV_CODEC_ID_H263P
Definition: codec_id.h:69
put_bits_ptr
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:370
ff_h263_intra_MCBPC_code
const uint8_t ff_h263_intra_MCBPC_code[9]
Definition: h263data.c:32
AVRational::den
int den
Denominator.
Definition: rational.h:60
AV_PIX_FMT_NONE
@ AV_PIX_FMT_NONE
Definition: pixfmt.h:65
umv_fcode_tab
static uint8_t umv_fcode_tab[MAX_MV *2+1]
Minimal fcode that a motion vector component would need in umv.
Definition: ituh263enc.c:63
AV_OPT_TYPE_INT
@ AV_OPT_TYPE_INT
Definition: opt.h:225
sign_extend
static av_const int sign_extend(int val, unsigned bits)
Definition: mathops.h:132
ff_mba_length
const uint8_t ff_mba_length[7]
Definition: h263data.c:269
flvenc.h
ff_h263_encode_gob_header
void ff_h263_encode_gob_header(MpegEncContext *s, int mb_line)
Encode a group of blocks header.
Definition: ituh263enc.c:246
ff_h263_inter_MCBPC_code
const uint8_t ff_h263_inter_MCBPC_code[28]
Definition: h263data.c:38
AV_PICTURE_TYPE_P
@ AV_PICTURE_TYPE_P
Predicted.
Definition: avutil.h:275
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
ff_mpv_encode_init
av_cold int ff_mpv_encode_init(AVCodecContext *avctx)
Definition: mpegvideo_enc.c:311
pred_dc
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)
Definition: hevcpred_template.c:390
AV_OPT_TYPE_BOOL
@ AV_OPT_TYPE_BOOL
Definition: opt.h:244
h263p_encode_umotion
static void h263p_encode_umotion(PutBitContext *pb, int val)
Definition: ituh263enc.c:416
block
The exact code depends on how similar the blocks are and how related they are to the block
Definition: filter_design.txt:207
ff_h263_init_rl_inter
av_cold void ff_h263_init_rl_inter(void)
Definition: h263.c:47
AV_CODEC_ID_FLV1
@ AV_CODEC_ID_FLV1
Definition: codec_id.h:71
MpegEncContext
MpegEncContext.
Definition: mpegvideo.h:62
h263_class
static const AVClass h263_class
Definition: ituh263enc.c:892
av_log2
int av_log2(unsigned v)
Definition: intmath.c:26
mb_info
Definition: cinepakenc.c:88
AV_CODEC_FLAG_PASS1
#define AV_CODEC_FLAG_PASS1
Use internal 2pass ratecontrol in first pass mode.
Definition: avcodec.h:247
h263.h