FFmpeg: libavcodec/ituh263enc.c Source File

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

AltStyle によって変換されたページ (->オリジナル) /