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 #include <string.h>
34 
35 #include "libavutil/attributes.h"
36 #include "libavutil/thread.h"
37 #include "avcodec.h"
38 #include "codec_internal.h"
39 #include "mpegvideo.h"
40 #include "flvenc.h"
41 #include "mpegvideoenc.h"
42 #include "h263.h"
43 #include "h263enc.h"
44 #include "h263data.h"
45 #include "h263dsp.h"
46 #include "mathops.h"
47 #include "mpegutils.h"
48 #include "internal.h"
49 #include "put_bits.h"
50 
51 /**
52  * Table of number of bits a motion vector component needs.
53  */
54 static uint8_t mv_penalty[MAX_FCODE+1][MAX_DMV*2+1];
55 
56 /**
57  * Minimal fcode that a motion vector component would need in umv.
58  * All entries in this table are 1.
59  */
60 static uint8_t umv_fcode_tab[MAX_MV*2+1];
61 
62 //unified encoding tables for run length encoding of coefficients
63 //unified in the sense that the specification specifies the encoding in several steps.
64 static uint8_t uni_h263_intra_aic_rl_len [64*64*2*2];
65 static uint8_t uni_h263_inter_rl_len [64*64*2*2];
66 //#define UNI_MPEG4_ENC_INDEX(last,run,level) ((last)*128 + (run)*256 + (level))
67 //#define UNI_MPEG4_ENC_INDEX(last,run,level) ((last)*128*64 + (run) + (level)*64)
68 #define UNI_MPEG4_ENC_INDEX(last,run,level) ((last)*128*64 + (run)*128 + (level))
69 
71 {
72  for (int f_code = 1; f_code <= MAX_FCODE; f_code++) {
73  for (int mv = -MAX_DMV; mv <= MAX_DMV; mv++) {
74  int len;
75 
76  if (mv == 0) len = 1; // ff_mvtab[0][1]
77  else {
78  int val, bit_size, code;
79 
80  bit_size = f_code - 1;
81 
82  val = mv;
83  if (val < 0)
84  val = -val;
85  val--;
86  code = (val >> bit_size) + 1;
87  if (code < 33) {
88  len = ff_mvtab[code][1] + 1 + bit_size;
89  } else {
90  len = 12 /* ff_mvtab[32][1] */ + av_log2(code>>5) + 2 + bit_size;
91  }
92  }
93 
94  mv_penalty[f_code][mv + MAX_DMV] = len;
95  }
96  }
97 
98  memset(umv_fcode_tab, 1, sizeof(umv_fcode_tab));
99 }
100 
101 static av_cold void init_uni_h263_rl_tab(const RLTable *rl, uint8_t *len_tab)
102 {
103  av_assert0(MAX_LEVEL >= 64);
104  av_assert0(MAX_RUN >= 63);
105 
106  for (int slevel = -64; slevel < 64; slevel++) {
107  if (slevel == 0) continue;
108  for (int run = 0; run < 64; run++) {
109  for (int last = 0; last <= 1; last++) {
110  const int index = UNI_MPEG4_ENC_INDEX(last, run, slevel + 64);
111  int level = slevel < 0 ? -slevel : slevel;
112  int sign = slevel < 0 ? 1 : 0;
113  int bits, len, code;
114 
115  len_tab[index] = 100;
116 
117  /* ESC0 */
118  code = get_rl_index(rl, last, run, level);
119  bits = rl->table_vlc[code][0];
120  len = rl->table_vlc[code][1];
121  bits = bits * 2 + sign;
122  len++;
123 
124  if (code != rl->n && len < len_tab[index])
125  len_tab[index] = len;
126 
127  /* ESC */
128  bits = rl->table_vlc[rl->n][0];
129  len = rl->table_vlc[rl->n][1];
130  bits = bits * 2 + last; len++;
131  bits = bits * 64 + run; len += 6;
132  bits = bits * 256 + (level & 0xff); len += 8;
133 
134  if (len < len_tab[index])
135  len_tab[index] = len;
136  }
137  }
138  }
139 }
140 
142 {
143  static uint8_t rl_intra_table[2][2 * MAX_RUN + MAX_LEVEL + 3];
144 
145  ff_rl_init(&ff_rl_intra_aic, rl_intra_table);
147 
150 
152 }
153 
154 av_cold const uint8_t (*ff_h263_get_mv_penalty(void))[MAX_DMV*2+1]
155 {
156  static AVOnce init_static_once = AV_ONCE_INIT;
157 
158  ff_thread_once(&init_static_once, h263_encode_init_static);
159 
160  return mv_penalty;
161 }
162 
163 void ff_h263_encode_motion(PutBitContext *pb, int val, int f_code)
164 {
165  if (val == 0) {
166  /* zero vector -- corresponds to ff_mvtab[0] */
167  put_bits(pb, 1, 1);
168  } else {
169  int sign, code, bits;
170  int bit_size = f_code - 1;
171  int range = 1 << bit_size;
172  /* modulo encoding */
173  val = sign_extend(val, 6 + bit_size);
174  sign = val>>31;
175  val= (val^sign)-sign;
176  sign&=1;
177 
178  val--;
179  code = (val >> bit_size) + 1;
180  bits = val & (range - 1);
181 
182  put_bits(pb, ff_mvtab[code][1] + 1, (ff_mvtab[code][0] << 1) | sign);
183  if (bit_size > 0) {
184  put_bits(pb, bit_size, bits);
185  }
186  }
187 }
188 
189 #if CONFIG_H263_ENCODER // Snow and SVQ1 need the above
190 static const uint8_t wrong_run[102] = {
191  1, 2, 3, 5, 4, 10, 9, 8,
192 11, 15, 17, 16, 23, 22, 21, 20,
193 19, 18, 25, 24, 27, 26, 11, 7,
194  6, 1, 2, 13, 2, 2, 2, 2,
195  6, 12, 3, 9, 1, 3, 4, 3,
196  7, 4, 1, 1, 5, 5, 14, 6,
197  1, 7, 1, 8, 1, 1, 1, 1,
198 10, 1, 1, 5, 9, 17, 25, 24,
199 29, 33, 32, 41, 2, 23, 28, 31,
200  3, 22, 30, 4, 27, 40, 8, 26,
201  6, 39, 7, 38, 16, 37, 15, 10,
202 11, 12, 13, 14, 1, 21, 20, 18,
203 19, 2, 1, 34, 35, 36
204 };
205 
206 /**
207  * Return the 4 bit value that specifies the given aspect ratio.
208  * This may be one of the standard aspect ratios or it specifies
209  * that the aspect will be stored explicitly later.
210  */
212  int i;
213 
214  if(aspect.num==0 || aspect.den==0) aspect= (AVRational){1,1};
215 
216  for(i=1; i<6; i++){
217  if(av_cmp_q(ff_h263_pixel_aspect[i], aspect) == 0){
218  return i;
219  }
220  }
221 
222  return FF_ASPECT_EXTENDED;
223 }
224 
225 static int h263_encode_picture_header(MPVMainEncContext *const m)
226 {
227  MPVEncContext *const s = &m->s;
228  int format, coded_frame_rate, coded_frame_rate_base, i, temp_ref;
229  int best_clock_code=1;
230  int best_divisor=60;
231  int best_error= INT_MAX;
232  int custom_pcf;
233 
235 
236  if (s->c.codec_id == AV_CODEC_ID_H263P) {
237  for(i=0; i<2; i++){
238  int div, error;
239  div= (s->c.avctx->time_base.num*1800000LL + 500LL*s->c.avctx->time_base.den) / ((1000LL+i)*s->c.avctx->time_base.den);
240  div= av_clip(div, 1, 127);
241  error= FFABS(s->c.avctx->time_base.num*1800000LL - (1000LL+i)*s->c.avctx->time_base.den*div);
242  if(error < best_error){
243  best_error= error;
244  best_divisor= div;
245  best_clock_code= i;
246  }
247  }
248  }
249  custom_pcf = best_clock_code != 1 || best_divisor != 60;
250  coded_frame_rate= 1800000;
251  coded_frame_rate_base= (1000+best_clock_code)*best_divisor;
252 
253  put_bits(&s->pb, 22, 0x20); /* PSC */
254  temp_ref= s->c.picture_number * (int64_t)coded_frame_rate * s->c.avctx->time_base.num / //FIXME use timestamp
255  (coded_frame_rate_base * (int64_t)s->c.avctx->time_base.den);
256  put_sbits(&s->pb, 8, temp_ref); /* TemporalReference */
257 
258  put_bits(&s->pb, 1, 1); /* marker */
259  put_bits(&s->pb, 1, 0); /* H.263 id */
260  put_bits(&s->pb, 1, 0); /* split screen off */
261  put_bits(&s->pb, 1, 0); /* camera off */
262  put_bits(&s->pb, 1, 0); /* freeze picture release off */
263 
265  if (s->c.codec_id != AV_CODEC_ID_H263P) {
266  /* H.263v1 */
267  put_bits(&s->pb, 3, format);
268  put_bits(&s->pb, 1, (s->c.pict_type == AV_PICTURE_TYPE_P));
269  /* By now UMV IS DISABLED ON H.263v1, since the restrictions
270  of H.263v1 UMV implies to check the predicted MV after
271  calculation of the current MB to see if we're on the limits */
272  put_bits(&s->pb, 1, 0); /* Unrestricted Motion Vector: off */
273  put_bits(&s->pb, 1, 0); /* SAC: off */
274  put_bits(&s->pb, 1, s->c.obmc); /* Advanced Prediction */
275  put_bits(&s->pb, 1, 0); /* only I/P-frames, no PB-frame */
276  put_bits(&s->pb, 5, s->c.qscale);
277  put_bits(&s->pb, 1, 0); /* Continuous Presence Multipoint mode: off */
278  } else {
279  int ufep=1;
280  /* H.263v2 */
281  /* H.263 Plus PTYPE */
282 
283  put_bits(&s->pb, 3, 7);
284  put_bits(&s->pb,3,ufep); /* Update Full Extended PTYPE */
285  if (format == 8)
286  put_bits(&s->pb,3,6); /* Custom Source Format */
287  else
288  put_bits(&s->pb, 3, format);
289 
290  put_bits(&s->pb,1, custom_pcf);
291  put_bits(&s->pb,1, s->c.umvplus); /* Unrestricted Motion Vector */
292  put_bits(&s->pb,1,0); /* SAC: off */
293  put_bits(&s->pb,1,s->c.obmc); /* Advanced Prediction Mode */
294  put_bits(&s->pb,1,s->c.h263_aic); /* Advanced Intra Coding */
295  put_bits(&s->pb,1,s->c.loop_filter); /* Deblocking Filter */
296  put_bits(&s->pb,1,s->c.h263_slice_structured); /* Slice Structured */
297  put_bits(&s->pb,1,0); /* Reference Picture Selection: off */
298  put_bits(&s->pb,1,0); /* Independent Segment Decoding: off */
299  put_bits(&s->pb,1,s->c.alt_inter_vlc); /* Alternative Inter VLC */
300  put_bits(&s->pb,1,s->c.modified_quant); /* Modified Quantization: */
301  put_bits(&s->pb,1,1); /* "1" to prevent start code emulation */
302  put_bits(&s->pb,3,0); /* Reserved */
303 
304  put_bits(&s->pb, 3, s->c.pict_type == AV_PICTURE_TYPE_P);
305 
306  put_bits(&s->pb,1,0); /* Reference Picture Resampling: off */
307  put_bits(&s->pb,1,0); /* Reduced-Resolution Update: off */
308  put_bits(&s->pb,1,s->c.no_rounding); /* Rounding Type */
309  put_bits(&s->pb,2,0); /* Reserved */
310  put_bits(&s->pb,1,1); /* "1" to prevent start code emulation */
311 
312  /* This should be here if PLUSPTYPE */
313  put_bits(&s->pb, 1, 0); /* Continuous Presence Multipoint mode: off */
314 
315  if (format == 8) {
316  /* Custom Picture Format (CPFMT) */
317  unsigned aspect_ratio_info = ff_h263_aspect_to_info(s->c.avctx->sample_aspect_ratio);
318 
319  put_bits(&s->pb,4, aspect_ratio_info);
320  put_bits(&s->pb,9,(s->c.width >> 2) - 1);
321  put_bits(&s->pb,1,1); /* "1" to prevent start code emulation */
322  put_bits(&s->pb,9,(s->c.height >> 2));
323  if (aspect_ratio_info == FF_ASPECT_EXTENDED){
324  put_bits(&s->pb, 8, s->c.avctx->sample_aspect_ratio.num);
325  put_bits(&s->pb, 8, s->c.avctx->sample_aspect_ratio.den);
326  }
327  }
328  if (custom_pcf) {
329  if(ufep){
330  put_bits(&s->pb, 1, best_clock_code);
331  put_bits(&s->pb, 7, best_divisor);
332  }
333  put_sbits(&s->pb, 2, temp_ref>>8);
334  }
335 
336  /* Unlimited Unrestricted Motion Vectors Indicator (UUI) */
337  if (s->c.umvplus)
338 // put_bits(&s->pb,1,1); /* Limited according tables of Annex D */
339 //FIXME check actual requested range
340  put_bits(&s->pb,2,1); /* unlimited */
341  if(s->c.h263_slice_structured)
342  put_bits(&s->pb,2,0); /* no weird submodes */
343 
344  put_bits(&s->pb, 5, s->c.qscale);
345  }
346 
347  put_bits(&s->pb, 1, 0); /* no PEI */
348 
349  if(s->c.h263_slice_structured){
350  put_bits(&s->pb, 1, 1);
351 
352  av_assert1(s->c.mb_x == 0 && s->c.mb_y == 0);
354 
355  put_bits(&s->pb, 1, 1);
356  }
357 
358  return 0;
359 }
360 
361 /**
362  * Encode a group of blocks header.
363  */
364 void ff_h263_encode_gob_header(MPVEncContext *const s, int mb_line)
365 {
366  put_bits(&s->pb, 17, 1); /* GBSC */
367 
368  if(s->c.h263_slice_structured){
369  put_bits(&s->pb, 1, 1);
370 
372 
373  if(s->c.mb_num > 1583)
374  put_bits(&s->pb, 1, 1);
375  put_bits(&s->pb, 5, s->c.qscale); /* GQUANT */
376  put_bits(&s->pb, 1, 1);
377  put_bits(&s->pb, 2, s->c.pict_type == AV_PICTURE_TYPE_I); /* GFID */
378  }else{
379  int gob_number= mb_line / s->c.gob_index;
380 
381  put_bits(&s->pb, 5, gob_number); /* GN */
382  put_bits(&s->pb, 2, s->c.pict_type == AV_PICTURE_TYPE_I); /* GFID */
383  put_bits(&s->pb, 5, s->c.qscale); /* GQUANT */
384  }
385 }
386 
387 /**
388  * modify qscale so that encoding is actually possible in H.263 (limit difference to -2..2)
389  */
391 {
392  int8_t * const qscale_table = s->c.cur_pic.qscale_table;
393 
394  for (int i = 1; i < s->c.mb_num; i++) {
395  if (qscale_table[ s->c.mb_index2xy[i] ] - qscale_table[ s->c.mb_index2xy[i-1] ] > 2)
396  qscale_table[ s->c.mb_index2xy[i] ] = qscale_table[ s->c.mb_index2xy[i-1] ] + 2;
397  }
398  for(int i = s->c.mb_num - 2; i >= 0; i--) {
399  if (qscale_table[ s->c.mb_index2xy[i] ] - qscale_table[ s->c.mb_index2xy[i+1] ] > 2)
400  qscale_table[ s->c.mb_index2xy[i] ] = qscale_table[ s->c.mb_index2xy[i+1] ] + 2;
401  }
402 
403  if (s->c.codec_id != AV_CODEC_ID_H263P) {
404  for (int i = 1; i < s->c.mb_num; i++) {
405  int mb_xy = s->c.mb_index2xy[i];
406 
407  if (qscale_table[mb_xy] != qscale_table[s->c.mb_index2xy[i - 1]] &&
408  (s->mb_type[mb_xy] & CANDIDATE_MB_TYPE_INTER4V)) {
409  s->mb_type[mb_xy]|= CANDIDATE_MB_TYPE_INTER;
410  }
411  }
412  }
413 }
414 
415 static const int dquant_code[5]= {1,0,9,2,3};
416 
417 /**
418  * Encode an 8x8 block.
419  * @param block the 8x8 block
420  * @param n block index (0-3 are luma, 4-5 are chroma)
421  */
422 static void h263_encode_block(MPVEncContext *const s, int16_t block[], int n)
423 {
424  int level, run, last, i, j, last_index, last_non_zero, sign, slevel, code;
425  const RLTable *rl;
426 
427  rl = &ff_h263_rl_inter;
428  if (s->c.mb_intra && !s->c.h263_aic) {
429  /* DC coef */
430  level = block[0];
431  /* 255 cannot be represented, so we clamp */
432  if (level > 254) {
433  level = 254;
434  block[0] = 254;
435  }
436  /* 0 cannot be represented also */
437  else if (level < 1) {
438  level = 1;
439  block[0] = 1;
440  }
441  if (level == 128) //FIXME check rv10
442  put_bits(&s->pb, 8, 0xff);
443  else
444  put_bits(&s->pb, 8, level);
445  i = 1;
446  } else {
447  i = 0;
448  if (s->c.h263_aic && s->c.mb_intra)
449  rl = &ff_rl_intra_aic;
450 
451  if(s->c.alt_inter_vlc && !s->c.mb_intra){
452  int aic_vlc_bits=0;
453  int inter_vlc_bits=0;
454  int wrong_pos=-1;
455  int aic_code;
456 
457  last_index = s->c.block_last_index[n];
458  last_non_zero = i - 1;
459  for (; i <= last_index; i++) {
460  j = s->c.intra_scantable.permutated[i];
461  level = block[j];
462  if (level) {
463  run = i - last_non_zero - 1;
464  last = (i == last_index);
465 
466  if(level<0) level= -level;
467 
468  code = get_rl_index(rl, last, run, level);
469  aic_code = get_rl_index(&ff_rl_intra_aic, last, run, level);
470  inter_vlc_bits += rl->table_vlc[code][1]+1;
471  aic_vlc_bits += ff_rl_intra_aic.table_vlc[aic_code][1]+1;
472 
473  if (code == rl->n) {
474  inter_vlc_bits += 1+6+8-1;
475  }
476  if (aic_code == ff_rl_intra_aic.n) {
477  aic_vlc_bits += 1+6+8-1;
478  wrong_pos += run + 1;
479  }else
480  wrong_pos += wrong_run[aic_code];
481  last_non_zero = i;
482  }
483  }
484  i = 0;
485  if(aic_vlc_bits < inter_vlc_bits && wrong_pos > 63)
486  rl = &ff_rl_intra_aic;
487  }
488  }
489 
490  /* AC coefs */
491  last_index = s->c.block_last_index[n];
492  last_non_zero = i - 1;
493  for (; i <= last_index; i++) {
494  j = s->c.intra_scantable.permutated[i];
495  level = block[j];
496  if (level) {
497  run = i - last_non_zero - 1;
498  last = (i == last_index);
499  sign = 0;
500  slevel = level;
501  if (level < 0) {
502  sign = 1;
503  level = -level;
504  }
505  code = get_rl_index(rl, last, run, level);
506  put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
507  if (code == rl->n) {
508  if(!CONFIG_FLV_ENCODER || s->c.h263_flv <= 1){
509  put_bits(&s->pb, 1, last);
510  put_bits(&s->pb, 6, run);
511 
512  av_assert2(slevel != 0);
513 
514  if(level < 128)
515  put_sbits(&s->pb, 8, slevel);
516  else{
517  put_bits(&s->pb, 8, 128);
518  put_sbits(&s->pb, 5, slevel);
519  put_sbits(&s->pb, 6, slevel>>5);
520  }
521  }else{
522  ff_flv2_encode_ac_esc(&s->pb, slevel, level, run, last);
523  }
524  } else {
525  put_bits(&s->pb, 1, sign);
526  }
527  last_non_zero = i;
528  }
529  }
530 }
531 
532 /* Encode MV differences on H.263+ with Unrestricted MV mode */
533 static void h263p_encode_umotion(PutBitContext *pb, int val)
534 {
535  short sval = 0;
536  short i = 0;
537  short n_bits = 0;
538  short temp_val;
539  int code = 0;
540  int tcode;
541 
542  if ( val == 0)
543  put_bits(pb, 1, 1);
544  else if (val == 1)
545  put_bits(pb, 3, 0);
546  else if (val == -1)
547  put_bits(pb, 3, 2);
548  else {
549 
550  sval = ((val < 0) ? (short)(-val):(short)val);
551  temp_val = sval;
552 
553  while (temp_val != 0) {
554  temp_val = temp_val >> 1;
555  n_bits++;
556  }
557 
558  i = n_bits - 1;
559  while (i > 0) {
560  tcode = (sval & (1 << (i-1))) >> (i-1);
561  tcode = (tcode << 1) | 1;
562  code = (code << 2) | tcode;
563  i--;
564  }
565  code = ((code << 1) | (val < 0)) << 1;
566  put_bits(pb, (2*n_bits)+1, code);
567  }
568 }
569 
570 static int h263_pred_dc(MPVEncContext *const s, int n, int16_t **dc_val_ptr)
571 {
572  int x, y, wrap, a, c, pred_dc;
573  int16_t *dc_val;
574 
575  /* find prediction */
576  if (n < 4) {
577  x = 2 * s->c.mb_x + (n & 1);
578  y = 2 * s->c.mb_y + ((n & 2) >> 1);
579  wrap = s->c.b8_stride;
580  dc_val = s->c.dc_val[0];
581  } else {
582  x = s->c.mb_x;
583  y = s->c.mb_y;
584  wrap = s->c.mb_stride;
585  dc_val = s->c.dc_val[n - 4 + 1];
586  }
587  /* B C
588  * A X
589  */
590  a = dc_val[(x - 1) + (y) * wrap];
591  c = dc_val[(x) + (y - 1) * wrap];
592 
593  /* No prediction outside GOB boundary */
594  if (s->c.first_slice_line && n != 3) {
595  if (n != 2) c = 1024;
596  if (n != 1 && s->c.mb_x == s->c.resync_mb_x) a = 1024;
597  }
598  /* just DC prediction */
599  if (a != 1024 && c != 1024)
600  pred_dc = (a + c) >> 1;
601  else if (a != 1024)
602  pred_dc = a;
603  else
604  pred_dc = c;
605 
606  /* we assume pred is positive */
607  *dc_val_ptr = &dc_val[x + y * wrap];
608  return pred_dc;
609 }
610 
611 static void h263_encode_mb(MPVEncContext *const s,
612  int16_t block[][64],
613  int motion_x, int motion_y)
614 {
615  int cbpc, cbpy, i, cbp, pred_x, pred_y;
616  int16_t pred_dc;
617  int16_t rec_intradc[6];
618  int16_t *dc_ptr[6];
619  const int interleaved_stats = s->c.avctx->flags & AV_CODEC_FLAG_PASS1;
620 
621  if (!s->c.mb_intra) {
622  /* compute cbp */
623  cbp= get_p_cbp(s, block, motion_x, motion_y);
624 
625  if ((cbp | motion_x | motion_y | s->dquant | (s->c.mv_type - MV_TYPE_16X16)) == 0) {
626  /* skip macroblock */
627  put_bits(&s->pb, 1, 1);
628  if(interleaved_stats){
629  s->misc_bits++;
630  s->last_bits++;
631  }
632 
633  return;
634  }
635  put_bits(&s->pb, 1, 0); /* mb coded */
636 
637  cbpc = cbp & 3;
638  cbpy = cbp >> 2;
639  if(s->c.alt_inter_vlc==0 || cbpc!=3)
640  cbpy ^= 0xF;
641  if(s->dquant) cbpc+= 8;
642  if(s->c.mv_type==MV_TYPE_16X16){
643  put_bits(&s->pb,
646 
647  put_bits(&s->pb, ff_h263_cbpy_tab[cbpy][1], ff_h263_cbpy_tab[cbpy][0]);
648  if(s->dquant)
649  put_bits(&s->pb, 2, dquant_code[s->dquant+2]);
650 
651  if(interleaved_stats){
652  s->misc_bits+= get_bits_diff(s);
653  }
654 
655  /* motion vectors: 16x16 mode */
656  ff_h263_pred_motion(&s->c, 0, 0, &pred_x, &pred_y);
657 
658  if (!s->c.umvplus) {
659  ff_h263_encode_motion_vector(s, motion_x - pred_x,
660  motion_y - pred_y, 1);
661  }
662  else {
663  h263p_encode_umotion(&s->pb, motion_x - pred_x);
664  h263p_encode_umotion(&s->pb, motion_y - pred_y);
665  if (((motion_x - pred_x) == 1) && ((motion_y - pred_y) == 1))
666  /* To prevent Start Code emulation */
667  put_bits(&s->pb,1,1);
668  }
669  }else{
670  put_bits(&s->pb,
671  ff_h263_inter_MCBPC_bits[cbpc+16],
672  ff_h263_inter_MCBPC_code[cbpc+16]);
673  put_bits(&s->pb, ff_h263_cbpy_tab[cbpy][1], ff_h263_cbpy_tab[cbpy][0]);
674  if(s->dquant)
675  put_bits(&s->pb, 2, dquant_code[s->dquant+2]);
676 
677  if(interleaved_stats){
678  s->misc_bits+= get_bits_diff(s);
679  }
680 
681  for(i=0; i<4; i++){
682  /* motion vectors: 8x8 mode*/
683  ff_h263_pred_motion(&s->c, i, 0, &pred_x, &pred_y);
684 
685  motion_x = s->c.cur_pic.motion_val[0][s->c.block_index[i]][0];
686  motion_y = s->c.cur_pic.motion_val[0][s->c.block_index[i]][1];
687  if (!s->c.umvplus) {
688  ff_h263_encode_motion_vector(s, motion_x - pred_x,
689  motion_y - pred_y, 1);
690  }
691  else {
692  h263p_encode_umotion(&s->pb, motion_x - pred_x);
693  h263p_encode_umotion(&s->pb, motion_y - pred_y);
694  if (((motion_x - pred_x) == 1) && ((motion_y - pred_y) == 1))
695  /* To prevent Start Code emulation */
696  put_bits(&s->pb,1,1);
697  }
698  }
699  }
700 
701  if(interleaved_stats){
702  s->mv_bits+= get_bits_diff(s);
703  }
704  } else {
705  av_assert2(s->c.mb_intra);
706 
707  cbp = 0;
708  if (s->c.h263_aic) {
709  /* Predict DC */
710  for(i=0; i<6; i++) {
711  int16_t level = block[i][0];
712  int scale = i < 4 ? s->c.y_dc_scale : s->c.c_dc_scale;
713 
714  pred_dc = h263_pred_dc(s, i, &dc_ptr[i]);
715  level -= pred_dc;
716  /* Quant */
717  if (level >= 0)
718  level = (level + (scale>>1))/scale;
719  else
720  level = (level - (scale>>1))/scale;
721 
722  if (!s->c.modified_quant) {
723  if (level < -127)
724  level = -127;
725  else if (level > 127)
726  level = 127;
727  }
728 
729  block[i][0] = level;
730  /* Reconstruction */
731  rec_intradc[i] = scale*level + pred_dc;
732  /* Oddify */
733  rec_intradc[i] |= 1;
734  //if ((rec_intradc[i] % 2) == 0)
735  // rec_intradc[i]++;
736  /* Clipping */
737  if (rec_intradc[i] < 0)
738  rec_intradc[i] = 0;
739  else if (rec_intradc[i] > 2047)
740  rec_intradc[i] = 2047;
741 
742  /* Update AC/DC tables */
743  *dc_ptr[i] = rec_intradc[i];
744  /* AIC can change CBP */
745  if (s->c.block_last_index[i] > 0 ||
746  (s->c.block_last_index[i] == 0 && level !=0))
747  cbp |= 1 << (5 - i);
748  }
749  }else{
750  for(i=0; i<6; i++) {
751  /* compute cbp */
752  if (s->c.block_last_index[i] >= 1)
753  cbp |= 1 << (5 - i);
754  }
755  }
756 
757  cbpc = cbp & 3;
758  if (s->c.pict_type == AV_PICTURE_TYPE_I) {
759  if(s->dquant) cbpc+=4;
760  put_bits(&s->pb,
763  } else {
764  if(s->dquant) cbpc+=8;
765  put_bits(&s->pb, 1, 0); /* mb coded */
766  put_bits(&s->pb,
767  ff_h263_inter_MCBPC_bits[cbpc + 4],
768  ff_h263_inter_MCBPC_code[cbpc + 4]);
769  }
770  if (s->c.h263_aic) {
771  /* XXX: currently, we do not try to use ac prediction */
772  put_bits(&s->pb, 1, 0); /* no AC prediction */
773  }
774  cbpy = cbp >> 2;
775  put_bits(&s->pb, ff_h263_cbpy_tab[cbpy][1], ff_h263_cbpy_tab[cbpy][0]);
776  if(s->dquant)
777  put_bits(&s->pb, 2, dquant_code[s->dquant+2]);
778 
779  if(interleaved_stats){
780  s->misc_bits+= get_bits_diff(s);
781  }
782  }
783 
784  for(i=0; i<6; i++) {
785  /* encode each block */
786  h263_encode_block(s, block[i], i);
787 
788  /* Update INTRADC for decoding */
789  if (s->c.h263_aic && s->c.mb_intra)
790  block[i][0] = rec_intradc[i];
791  }
792 
793  if(interleaved_stats){
794  if (!s->c.mb_intra) {
795  s->p_tex_bits+= get_bits_diff(s);
796  }else{
797  s->i_tex_bits+= get_bits_diff(s);
798  s->i_count++;
799  }
800  }
801 }
802 
803 void ff_h263_update_mb(MPVEncContext *const s)
804 {
805  const int mb_xy = s->c.mb_y * s->c.mb_stride + s->c.mb_x;
806 
807  if (s->c.cur_pic.mbskip_table)
808  s->c.cur_pic.mbskip_table[mb_xy] = s->c.mb_skipped;
809 
810  if (s->c.mv_type == MV_TYPE_8X8)
811  s->c.cur_pic.mb_type[mb_xy] = MB_TYPE_FORWARD_MV | MB_TYPE_8x8;
812  else if(s->c.mb_intra)
813  s->c.cur_pic.mb_type[mb_xy] = MB_TYPE_INTRA;
814  else
815  s->c.cur_pic.mb_type[mb_xy] = MB_TYPE_FORWARD_MV | MB_TYPE_16x16;
816 
818 }
819 
821 {
822  MPVEncContext *const s = &m->s;
823 
824  s->me.mv_penalty = ff_h263_get_mv_penalty(); // FIXME exact table for MSMPEG4 & H.263+
825 
826  ff_h263dsp_init(&s->c.h263dsp);
827 
828  if (s->c.codec_id == AV_CODEC_ID_MPEG4)
829  return;
830 
831  s->intra_ac_vlc_length =s->inter_ac_vlc_length = uni_h263_inter_rl_len;
832  s->intra_ac_vlc_last_length=s->inter_ac_vlc_last_length= uni_h263_inter_rl_len + 128*64;
833  if (s->c.h263_aic) {
834  s->intra_ac_vlc_length = uni_h263_intra_aic_rl_len;
835  s->intra_ac_vlc_last_length= uni_h263_intra_aic_rl_len + 128*64;
836 
837  s->c.y_dc_scale_table =
838  s->c.c_dc_scale_table = ff_aic_dc_scale_table;
839  }
840  s->ac_esc_length= 7+1+6+8;
841 
842  if (s->c.modified_quant)
843  s->c.chroma_qscale_table = ff_h263_chroma_qscale_table;
844 
845  // Only used for H.263 and H.263+
846  s->c.gob_index = H263_GOB_HEIGHT(s->c.height);
847 
848  // use fcodes >1 only for MPEG-4 & H.263 & H.263+ FIXME
849  switch(s->c.codec_id){
850  case AV_CODEC_ID_H263P:
851  if (s->c.umvplus)
853  if (s->c.modified_quant) {
854  s->min_qcoeff= -2047;
855  s->max_qcoeff= 2047;
856  }else{
857  s->min_qcoeff= -127;
858  s->max_qcoeff= 127;
859  }
860  break;
861  // Note for MPEG-4 & H.263 the dc-scale table will be set per frame as needed later
862 #if CONFIG_FLV_ENCODER
863  case AV_CODEC_ID_FLV1:
865  if (s->c.h263_flv > 1) {
866  s->min_qcoeff= -1023;
867  s->max_qcoeff= 1023;
868  } else {
869  s->min_qcoeff= -127;
870  s->max_qcoeff= 127;
871  }
872  break;
873 #endif
874  default: //nothing needed - default table already set in mpegvideo.c
875  s->min_qcoeff= -127;
876  s->max_qcoeff= 127;
877  }
878  // H.263, H.263+; will be overwritten for MSMPEG-4 later
879  if (!m->encode_picture_header)
880  m->encode_picture_header = h263_encode_picture_header;
881  if (!s->encode_mb)
882  s->encode_mb = h263_encode_mb;
883 }
884 
886 {
887  int i, mb_pos;
888 
889  for(i=0; i<6; i++){
890  if(s->c.mb_num-1 <= ff_mba_max[i]) break;
891  }
892  mb_pos= s->c.mb_x + s->c.mb_width*s->c.mb_y;
893  put_bits(&s->pb, ff_mba_length[i], mb_pos);
894 }
895 
896 #define OFFSET(x) offsetof(MpegEncContext, x)
897 #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
898 static const AVOption h263_options[] = {
899  { "obmc", "use overlapped block motion compensation.", OFFSET(obmc), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, VE },
900  { "mb_info", "emit macroblock info for RFC 2190 packetization, the parameter value is the maximum payload size", FF_MPV_OFFSET(mb_info), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, INT_MAX, VE },
903  { NULL },
904 };
905 
906 static const AVClass h263_class = {
907  .class_name = "H.263 encoder",
908  .item_name = av_default_item_name,
909  .option = h263_options,
910  .version = LIBAVUTIL_VERSION_INT,
911 };
912 
913 const FFCodec ff_h263_encoder = {
914  .p.name = "h263",
915  CODEC_LONG_NAME("H.263 / H.263-1996"),
916  .p.type = AVMEDIA_TYPE_VIDEO,
917  .p.id = AV_CODEC_ID_H263,
919  .color_ranges = AVCOL_RANGE_MPEG,
920  .p.priv_class = &h263_class,
922  .caps_internal = FF_CODEC_CAP_INIT_CLEANUP,
923  .priv_data_size = sizeof(MPVMainEncContext),
926  .close = ff_mpv_encode_end,
927 };
928 
929 static const AVOption h263p_options[] = {
930  { "umv", "Use unlimited motion vectors.", OFFSET(umvplus), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, VE },
931  { "aiv", "Use alternative inter VLC.", OFFSET(alt_inter_vlc), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, VE },
932  { "obmc", "use overlapped block motion compensation.", OFFSET(obmc), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, VE },
933  { "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},
936  { NULL },
937 };
938 static const AVClass h263p_class = {
939  .class_name = "H.263p encoder",
940  .item_name = av_default_item_name,
941  .option = h263p_options,
942  .version = LIBAVUTIL_VERSION_INT,
943 };
944 
945 const FFCodec ff_h263p_encoder = {
946  .p.name = "h263p",
947  CODEC_LONG_NAME("H.263+ / H.263-1998 / H.263 version 2"),
948  .p.type = AVMEDIA_TYPE_VIDEO,
949  .p.id = AV_CODEC_ID_H263P,
951  .color_ranges = AVCOL_RANGE_MPEG,
952  .p.priv_class = &h263p_class,
953  .p.capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_SLICE_THREADS |
955  .caps_internal = FF_CODEC_CAP_INIT_CLEANUP,
956  .priv_data_size = sizeof(MPVMainEncContext),
959  .close = ff_mpv_encode_end,
960 };
961 #endif
error
static void error(const char *err)
Definition: target_bsf_fuzzer.c:32
MPVMainEncContext::fcode_tab
const uint8_t * fcode_tab
smallest fcode needed for each MV
Definition: mpegvideoenc.h:218
CODEC_PIXFMTS
#define CODEC_PIXFMTS(...)
Definition: codec_internal.h:386
MV_TYPE_16X16
#define MV_TYPE_16X16
1 vector for the whole mb
Definition: mpegvideo.h:185
h263data.h
FF_ASPECT_EXTENDED
#define FF_ASPECT_EXTENDED
Definition: h263.h:26
level
uint8_t level
Definition: svq3.c:208
av_clip
#define av_clip
Definition: common.h:100
MPVEncContext
Definition: mpegvideoenc.h:45
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:42
H263_GOB_HEIGHT
#define H263_GOB_HEIGHT(h)
Definition: h263.h:28
uni_h263_inter_rl_len
static uint8_t uni_h263_inter_rl_len[64 *64 *2 *2]
Definition: ituh263enc.c:65
UNI_MPEG4_ENC_INDEX
#define UNI_MPEG4_ENC_INDEX(last, run, level)
Definition: ituh263enc.c:68
MAX_FCODE
#define MAX_FCODE
Definition: mpegvideoenc.h:264
thread.h
mpegvideoenc.h
int64_t
long long int64_t
Definition: coverity.c:34
mv
static const int8_t mv[256][2]
Definition: 4xm.c:81
put_sbits
static void put_sbits(PutBitContext *pb, int n, int32_t value)
Definition: put_bits.h:291
MAX_RUN
#define MAX_RUN
Definition: rl.h:35
h263enc.h
ff_clean_h263_qscales
void ff_clean_h263_qscales(MPVEncContext *s)
AV_CODEC_ID_MPEG4
@ AV_CODEC_ID_MPEG4
Definition: codec_id.h:64
CANDIDATE_MB_TYPE_INTER
#define CANDIDATE_MB_TYPE_INTER
Definition: mpegvideoenc.h:270
put_bits
static void put_bits(Jpeg2000EncoderContext *s, int val, int n)
put n times val bit
Definition: j2kenc.c:223
MAX_DMV
#define MAX_DMV
Definition: motion_est.h:39
internal.h
av_const
#define av_const
Definition: attributes.h:84
h263dsp.h
AVOption
AVOption.
Definition: opt.h:429
MB_TYPE_16x16
#define MB_TYPE_16x16
Definition: mpegutils.h:41
FFCodec
Definition: codec_internal.h:127
init_uni_h263_rl_tab
static av_cold void init_uni_h263_rl_tab(const RLTable *rl, uint8_t *len_tab)
Definition: ituh263enc.c:101
mpegvideo.h
mpegutils.h
MPVMainEncContext::encode_picture_header
int(* encode_picture_header)(struct MPVMainEncContext *m)
Definition: mpegvideoenc.h:227
FF_MPV_COMMON_MOTION_EST_OPTS
#define FF_MPV_COMMON_MOTION_EST_OPTS
Definition: mpegvideoenc.h:356
ff_mpv_encode_picture
int ff_mpv_encode_picture(AVCodecContext *avctx, AVPacket *pkt, const AVFrame *pic_arg, int *got_packet)
Definition: mpegvideo_enc.c:1929
FF_MPV_COMMON_OPTS
#define FF_MPV_COMMON_OPTS
Definition: mpegvideoenc.h:315
FFCodec::p
AVCodec p
The public AVCodec.
Definition: codec_internal.h:131
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:829
ff_h263_pred_motion
int16_t * ff_h263_pred_motion(MpegEncContext *s, int block, int dir, int *px, int *py)
Definition: h263.c:179
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:54
ff_h263_encode_init
void ff_h263_encode_init(MPVMainEncContext *m)
val
static double val(void *priv, double ch)
Definition: aeval.c:77
FF_CODEC_ENCODE_CB
#define FF_CODEC_ENCODE_CB(func)
Definition: codec_internal.h:353
ff_h263_update_motion_val
void ff_h263_update_motion_val(MpegEncContext *s)
Definition: h263.c:53
AVRational::num
int num
Numerator.
Definition: rational.h:59
dquant_code
static const int dquant_code[5]
Definition: mpeg4videoenc.c:419
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:205
ff_h263_encode_motion
void ff_h263_encode_motion(PutBitContext *pb, int val, int f_code)
Definition: ituh263enc.c:163
FF_ARRAY_ELEMS
#define FF_ARRAY_ELEMS(a)
Definition: sinewin_tablegen.c:29
av_cold
#define av_cold
Definition: attributes.h:90
ff_h263_encode_gob_header
void ff_h263_encode_gob_header(MPVEncContext *s, int mb_line)
MAX_MV
#define MAX_MV
Definition: motion_est.h:37
ff_h263_chroma_qscale_table
const uint8_t ff_h263_chroma_qscale_table[32]
Definition: h263data.c:260
s
#define s(width, name)
Definition: cbs_vp9.c:198
get_rl_index
static int get_rl_index(const RLTable *rl, int last, int run, int level)
Definition: rl.h:101
AV_CODEC_CAP_ENCODER_REORDERED_OPAQUE
#define AV_CODEC_CAP_ENCODER_REORDERED_OPAQUE
This encoder can reorder user opaque values from input AVFrames and return them with corresponding ou...
Definition: codec.h:144
bits
uint8_t bits
Definition: vp3data.h:128
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:41
limits.h
FF_MPV_OFFSET
#define FF_MPV_OFFSET(x)
Definition: mpegvideoenc.h:311
ff_h263_get_mv_penalty
const av_cold uint8_t(* ff_h263_get_mv_penalty(void))[MAX_DMV *2+1]
Definition: ituh263enc.c:154
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:73
ff_h263_encode_mba
void ff_h263_encode_mba(MPVEncContext *s)
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:43
CODEC_LONG_NAME
#define CODEC_LONG_NAME(str)
Definition: codec_internal.h:326
FFABS
#define FFABS(a)
Absolute value, Note, INT_MIN / INT64_MIN result in undefined behavior as they are not representable ...
Definition: common.h:74
LIBAVUTIL_VERSION_INT
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
AV_ONCE_INIT
#define AV_ONCE_INIT
Definition: thread.h:203
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:76
NULL
#define NULL
Definition: coverity.c:32
format
New swscale design to change SwsGraph is what coordinates multiple passes These can include cascaded scaling error diffusion and so on Or we could have separate passes for the vertical and horizontal scaling In between each SwsPass lies a fully allocated image buffer Graph passes may have different levels of e g we can have a single threaded error diffusion pass following a multi threaded scaling pass SwsGraph is internally recreated whenever the image format
Definition: swscale-v2.txt:14
init_mv_penalty_and_fcode
static av_cold void init_mv_penalty_and_fcode(void)
Definition: ituh263enc.c:70
run
uint8_t run
Definition: svq3.c:207
RLTable::table_vlc
const uint16_t(* table_vlc)[2]
Definition: rl.h:42
AVRational
Rational number (pair of numerator and denominator).
Definition: rational.h:58
MB_TYPE_8x8
#define MB_TYPE_8x8
Definition: mpegutils.h:44
uni_h263_intra_aic_rl_len
static uint8_t uni_h263_intra_aic_rl_len[64 *64 *2 *2]
Definition: ituh263enc.c:64
av_default_item_name
const char * av_default_item_name(void *ptr)
Return the context name.
Definition: log.c:240
AV_PICTURE_TYPE_I
@ AV_PICTURE_TYPE_I
Intra.
Definition: avutil.h:278
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:1107
get_p_cbp
static int get_p_cbp(MPVEncContext *const s, int16_t block[6][64], int motion_x, int motion_y)
Definition: h263enc.h:45
MPVMainEncContext
Definition: mpegvideoenc.h:178
AVOnce
#define AVOnce
Definition: thread.h:202
index
int index
Definition: gxfenc.c:90
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
MV_TYPE_8X8
#define MV_TYPE_8X8
4 vectors (H.263, MPEG-4 4MV)
Definition: mpegvideo.h:186
MAX_LEVEL
#define MAX_LEVEL
Definition: rl.h:36
init
int(* init)(AVBSFContext *ctx)
Definition: dts2pts.c:368
AV_CODEC_CAP_DR1
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() or get_encode_buffer() for allocating buffers and supports custom allocators.
Definition: codec.h:52
ff_h263_rl_inter
RLTable ff_h263_rl_inter
Definition: h263data.c:159
codec_internal.h
AV_CODEC_ID_H263
@ AV_CODEC_ID_H263
Definition: codec_id.h:56
put_bits_assume_flushed
static void put_bits_assume_flushed(const PutBitContext *s)
Inform the compiler that a PutBitContext is flushed (i.e.
Definition: put_bits.h:82
ff_h263_cbpy_tab
const uint8_t ff_h263_cbpy_tab[16][2]
Definition: h263data.c:82
ff_h263p_encoder
const FFCodec ff_h263p_encoder
ff_rl_intra_aic
RLTable ff_rl_intra_aic
Definition: h263data.c:228
ff_h263dsp_init
av_cold void ff_h263dsp_init(H263DSPContext *ctx)
Definition: h263dsp.c:117
range
enum AVColorRange range
Definition: mediacodec_wrapper.c:2594
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:99
attributes.h
ff_h263_inter_MCBPC_bits
const uint8_t ff_h263_inter_MCBPC_bits[28]
Definition: h263data.c:47
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: pred_template.c:391
CANDIDATE_MB_TYPE_INTER4V
#define CANDIDATE_MB_TYPE_INTER4V
Definition: mpegvideoenc.h:271
get_bits_diff
static int get_bits_diff(MPVEncContext *s)
Definition: mpegvideoenc.h:388
av_assert2
#define av_assert2(cond)
assert() equivalent, that does lie in speed critical code.
Definition: avassert.h:68
ff_h263_encoder
const FFCodec ff_h263_encoder
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:256
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
ff_h263_update_mb
void ff_h263_update_mb(MPVEncContext *s)
av_assert1
#define av_assert1(cond)
assert() equivalent, that does not lie in speed critical code.
Definition: avassert.h:57
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:179
ff_h263_aspect_to_info
av_const int ff_h263_aspect_to_info(AVRational aspect)
len
int len
Definition: vorbis_enc_data.h:426
ff_flv_encode_picture_header
int ff_flv_encode_picture_header(MPVMainEncContext *const m)
Definition: flvenc.c:27
AVCOL_RANGE_MPEG
@ AVCOL_RANGE_MPEG
Narrow or limited range content.
Definition: pixfmt.h:733
ff_flv2_encode_ac_esc
void ff_flv2_encode_ac_esc(PutBitContext *pb, int slevel, int level, int run, int last)
Definition: flvenc.c:70
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:141
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:81
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
OFFSET
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf default minimum maximum flags name is the option keep it simple and lowercase description are in without and describe what they for example set the foo of the bar offset is the offset of the field in your see the OFFSET() macro
AV_CODEC_ID_H263P
@ AV_CODEC_ID_H263P
Definition: codec_id.h:71
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
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:60
AV_OPT_TYPE_INT
@ AV_OPT_TYPE_INT
Underlying C type is int.
Definition: opt.h:259
sign_extend
static av_const int sign_extend(int val, unsigned bits)
Definition: mathops.h:131
ff_mba_length
const uint8_t ff_mba_length[7]
Definition: h263data.c:269
flvenc.h
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:279
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:200
ff_mpv_encode_init
av_cold int ff_mpv_encode_init(AVCodecContext *avctx)
Definition: mpegvideo_enc.c:545
scale
static void scale(int *out, const int *in, const int w, const int h, const int shift)
Definition: intra.c:273
AV_OPT_TYPE_BOOL
@ AV_OPT_TYPE_BOOL
Underlying C type is int.
Definition: opt.h:327
ff_h263_encode_motion_vector
static void ff_h263_encode_motion_vector(MPVEncContext *s, int x, int y, int f_code)
Definition: h263enc.h:38
block
The exact code depends on how similar the blocks are and how related they are to the block
Definition: filter_design.txt:207
VE
#define VE
Definition: amfenc_av1.c:30
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:73
put_bits.h
av_log2
int av_log2(unsigned v)
Definition: intmath.c:26
MPVMainEncContext::s
MPVEncContext s
The main slicecontext.
Definition: mpegvideoenc.h:179
mb_info
Definition: cinepakenc.c:87
MB_TYPE_FORWARD_MV
#define MB_TYPE_FORWARD_MV
Definition: mpegutils.h:49
MB_TYPE_INTRA
#define MB_TYPE_INTRA
Definition: mpegutils.h:64
AV_CODEC_FLAG_PASS1
#define AV_CODEC_FLAG_PASS1
Use internal 2pass ratecontrol in first pass mode.
Definition: avcodec.h:290
h263.h