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