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 "libavutil/thread.h"
34 #include "avcodec.h"
35 #include "mpegvideo.h"
36 #include "mpegvideodata.h"
37 #include "h263.h"
38 #include "h263data.h"
39 #include "mathops.h"
40 #include "mpegutils.h"
41 #include "flv.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  */
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  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 
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);
232 
233  put_bits(&s->pb, 1, 1);
234  }
235 }
236 
237 /**
238  * Encode a group of blocks header.
239  */
241 {
242  put_bits(&s->pb, 17, 1); /* GBSC */
243 
244  if(s->h263_slice_structured){
245  put_bits(&s->pb, 1, 1);
246 
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  */
267  int i;
268  int8_t * const qscale_table = s->current_picture.qscale_table;
269 
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 */
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 static int h263_pred_dc(MpegEncContext * s, int n, int16_t **dc_val_ptr)
448 {
449  int x, y, wrap, a, c, pred_dc;
450  int16_t *dc_val;
451 
452  /* find prediction */
453  if (n < 4) {
454  x = 2 * s->mb_x + (n & 1);
455  y = 2 * s->mb_y + ((n & 2) >> 1);
456  wrap = s->b8_stride;
457  dc_val = s->dc_val[0];
458  } else {
459  x = s->mb_x;
460  y = s->mb_y;
461  wrap = s->mb_stride;
462  dc_val = s->dc_val[n - 4 + 1];
463  }
464  /* B C
465  * A X
466  */
467  a = dc_val[(x - 1) + (y) * wrap];
468  c = dc_val[(x) + (y - 1) * wrap];
469 
470  /* No prediction outside GOB boundary */
471  if (s->first_slice_line && n != 3) {
472  if (n != 2) c = 1024;
473  if (n != 1 && s->mb_x == s->resync_mb_x) a = 1024;
474  }
475  /* just DC prediction */
476  if (a != 1024 && c != 1024)
477  pred_dc = (a + c) >> 1;
478  else if (a != 1024)
479  pred_dc = a;
480  else
481  pred_dc = c;
482 
483  /* we assume pred is positive */
484  *dc_val_ptr = &dc_val[x + y * wrap];
485  return pred_dc;
486 }
487 
489  int16_t block[6][64],
490  int motion_x, int motion_y)
491 {
492  int cbpc, cbpy, i, cbp, pred_x, pred_y;
493  int16_t pred_dc;
494  int16_t rec_intradc[6];
495  int16_t *dc_ptr[6];
496  const int interleaved_stats = s->avctx->flags & AV_CODEC_FLAG_PASS1;
497 
498  if (!s->mb_intra) {
499  /* compute cbp */
500  cbp= get_p_cbp(s, block, motion_x, motion_y);
501 
502  if ((cbp | motion_x | motion_y | s->dquant | (s->mv_type - MV_TYPE_16X16)) == 0) {
503  /* skip macroblock */
504  put_bits(&s->pb, 1, 1);
505  if(interleaved_stats){
506  s->misc_bits++;
507  s->last_bits++;
508  }
509  s->skip_count++;
510 
511  return;
512  }
513  put_bits(&s->pb, 1, 0); /* mb coded */
514 
515  cbpc = cbp & 3;
516  cbpy = cbp >> 2;
517  if(s->alt_inter_vlc==0 || cbpc!=3)
518  cbpy ^= 0xF;
519  if(s->dquant) cbpc+= 8;
520  if(s->mv_type==MV_TYPE_16X16){
521  put_bits(&s->pb,
524 
525  put_bits(&s->pb, ff_h263_cbpy_tab[cbpy][1], ff_h263_cbpy_tab[cbpy][0]);
526  if(s->dquant)
527  put_bits(&s->pb, 2, dquant_code[s->dquant+2]);
528 
529  if(interleaved_stats){
530  s->misc_bits+= get_bits_diff(s);
531  }
532 
533  /* motion vectors: 16x16 mode */
534  ff_h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
535 
536  if (!s->umvplus) {
537  ff_h263_encode_motion_vector(s, motion_x - pred_x,
538  motion_y - pred_y, 1);
539  }
540  else {
541  h263p_encode_umotion(&s->pb, motion_x - pred_x);
542  h263p_encode_umotion(&s->pb, motion_y - pred_y);
543  if (((motion_x - pred_x) == 1) && ((motion_y - pred_y) == 1))
544  /* To prevent Start Code emulation */
545  put_bits(&s->pb,1,1);
546  }
547  }else{
548  put_bits(&s->pb,
549  ff_h263_inter_MCBPC_bits[cbpc+16],
550  ff_h263_inter_MCBPC_code[cbpc+16]);
551  put_bits(&s->pb, ff_h263_cbpy_tab[cbpy][1], ff_h263_cbpy_tab[cbpy][0]);
552  if(s->dquant)
553  put_bits(&s->pb, 2, dquant_code[s->dquant+2]);
554 
555  if(interleaved_stats){
556  s->misc_bits+= get_bits_diff(s);
557  }
558 
559  for(i=0; i<4; i++){
560  /* motion vectors: 8x8 mode*/
561  ff_h263_pred_motion(s, i, 0, &pred_x, &pred_y);
562 
563  motion_x = s->current_picture.motion_val[0][s->block_index[i]][0];
564  motion_y = s->current_picture.motion_val[0][s->block_index[i]][1];
565  if (!s->umvplus) {
566  ff_h263_encode_motion_vector(s, motion_x - pred_x,
567  motion_y - pred_y, 1);
568  }
569  else {
570  h263p_encode_umotion(&s->pb, motion_x - pred_x);
571  h263p_encode_umotion(&s->pb, motion_y - pred_y);
572  if (((motion_x - pred_x) == 1) && ((motion_y - pred_y) == 1))
573  /* To prevent Start Code emulation */
574  put_bits(&s->pb,1,1);
575  }
576  }
577  }
578 
579  if(interleaved_stats){
580  s->mv_bits+= get_bits_diff(s);
581  }
582  } else {
583  av_assert2(s->mb_intra);
584 
585  cbp = 0;
586  if (s->h263_aic) {
587  /* Predict DC */
588  for(i=0; i<6; i++) {
589  int16_t level = block[i][0];
590  int scale;
591 
592  if(i<4) scale= s->y_dc_scale;
593  else scale= s->c_dc_scale;
594 
595  pred_dc = h263_pred_dc(s, i, &dc_ptr[i]);
596  level -= pred_dc;
597  /* Quant */
598  if (level >= 0)
599  level = (level + (scale>>1))/scale;
600  else
601  level = (level - (scale>>1))/scale;
602 
603  if(!s->modified_quant){
604  if (level < -127)
605  level = -127;
606  else if (level > 127)
607  level = 127;
608  }
609 
610  block[i][0] = level;
611  /* Reconstruction */
612  rec_intradc[i] = scale*level + pred_dc;
613  /* Oddify */
614  rec_intradc[i] |= 1;
615  //if ((rec_intradc[i] % 2) == 0)
616  // rec_intradc[i]++;
617  /* Clipping */
618  if (rec_intradc[i] < 0)
619  rec_intradc[i] = 0;
620  else if (rec_intradc[i] > 2047)
621  rec_intradc[i] = 2047;
622 
623  /* Update AC/DC tables */
624  *dc_ptr[i] = rec_intradc[i];
625  /* AIC can change CBP */
626  if (s->block_last_index[i] > 0 ||
627  (s->block_last_index[i] == 0 && level !=0))
628  cbp |= 1 << (5 - i);
629  }
630  }else{
631  for(i=0; i<6; i++) {
632  /* compute cbp */
633  if (s->block_last_index[i] >= 1)
634  cbp |= 1 << (5 - i);
635  }
636  }
637 
638  cbpc = cbp & 3;
639  if (s->pict_type == AV_PICTURE_TYPE_I) {
640  if(s->dquant) cbpc+=4;
641  put_bits(&s->pb,
644  } else {
645  if(s->dquant) cbpc+=8;
646  put_bits(&s->pb, 1, 0); /* mb coded */
647  put_bits(&s->pb,
648  ff_h263_inter_MCBPC_bits[cbpc + 4],
649  ff_h263_inter_MCBPC_code[cbpc + 4]);
650  }
651  if (s->h263_aic) {
652  /* XXX: currently, we do not try to use ac prediction */
653  put_bits(&s->pb, 1, 0); /* no AC prediction */
654  }
655  cbpy = cbp >> 2;
656  put_bits(&s->pb, ff_h263_cbpy_tab[cbpy][1], ff_h263_cbpy_tab[cbpy][0]);
657  if(s->dquant)
658  put_bits(&s->pb, 2, dquant_code[s->dquant+2]);
659 
660  if(interleaved_stats){
661  s->misc_bits+= get_bits_diff(s);
662  }
663  }
664 
665  for(i=0; i<6; i++) {
666  /* encode each block */
668 
669  /* Update INTRADC for decoding */
670  if (s->h263_aic && s->mb_intra) {
671  block[i][0] = rec_intradc[i];
672 
673  }
674  }
675 
676  if(interleaved_stats){
677  if (!s->mb_intra) {
678  s->p_tex_bits+= get_bits_diff(s);
679  s->f_count++;
680  }else{
681  s->i_tex_bits+= get_bits_diff(s);
682  s->i_count++;
683  }
684  }
685 }
686 
687 void ff_h263_encode_motion(PutBitContext *pb, int val, int f_code)
688 {
689  int range, bit_size, sign, code, bits;
690 
691  if (val == 0) {
692  /* zero vector */
693  code = 0;
694  put_bits(pb, ff_mvtab[code][1], ff_mvtab[code][0]);
695  } else {
696  bit_size = f_code - 1;
697  range = 1 << bit_size;
698  /* modulo encoding */
699  val = sign_extend(val, 6 + bit_size);
700  sign = val>>31;
701  val= (val^sign)-sign;
702  sign&=1;
703 
704  val--;
705  code = (val >> bit_size) + 1;
706  bits = val & (range - 1);
707 
708  put_bits(pb, ff_mvtab[code][1] + 1, (ff_mvtab[code][0] << 1) | sign);
709  if (bit_size > 0) {
710  put_bits(pb, bit_size, bits);
711  }
712  }
713 }
714 
716 {
717  int f_code;
718  int mv;
719 
720  for(f_code=1; f_code<=MAX_FCODE; f_code++){
721  for(mv=-MAX_DMV; mv<=MAX_DMV; mv++){
722  int len;
723 
724  if(mv==0) len= ff_mvtab[0][1];
725  else{
726  int val, bit_size, code;
727 
728  bit_size = f_code - 1;
729 
730  val=mv;
731  if (val < 0)
732  val = -val;
733  val--;
734  code = (val >> bit_size) + 1;
735  if(code<33){
736  len= ff_mvtab[code][1] + 1 + bit_size;
737  }else{
738  len= ff_mvtab[32][1] + av_log2(code>>5) + 2 + bit_size;
739  }
740  }
741 
742  mv_penalty[f_code][mv+MAX_DMV]= len;
743  }
744  }
745 
746  for(f_code=MAX_FCODE; f_code>0; f_code--){
747  for(mv=-(16<<f_code); mv<(16<<f_code); mv++){
748  fcode_tab[mv+MAX_MV]= f_code;
749  }
750  }
751 
752  for(mv=0; mv<MAX_MV*2+1; mv++){
753  umv_fcode_tab[mv]= 1;
754  }
755 }
756 
757 static av_cold void init_uni_h263_rl_tab(const RLTable *rl, uint8_t *len_tab)
758 {
759  int slevel, run, last;
760 
761  av_assert0(MAX_LEVEL >= 64);
762  av_assert0(MAX_RUN >= 63);
763 
764  for(slevel=-64; slevel<64; slevel++){
765  if(slevel==0) continue;
766  for(run=0; run<64; run++){
767  for(last=0; last<=1; last++){
768  const int index= UNI_MPEG4_ENC_INDEX(last, run, slevel+64);
769  int level= slevel < 0 ? -slevel : slevel;
770  int sign= slevel < 0 ? 1 : 0;
771  int bits, len, code;
772 
773  len_tab[index]= 100;
774 
775  /* ESC0 */
776  code= get_rl_index(rl, last, run, level);
777  bits= rl->table_vlc[code][0];
778  len= rl->table_vlc[code][1];
779  bits=bits*2+sign; len++;
780 
781  if (code != rl->n && len < len_tab[index])
782  len_tab [index]= len;
783 
784  /* ESC */
785  bits= rl->table_vlc[rl->n][0];
786  len = rl->table_vlc[rl->n][1];
787  bits=bits*2+last; len++;
788  bits=bits*64+run; len+=6;
789  bits=bits*256+(level&0xff); len+=8;
790 
791  if (len < len_tab[index])
792  len_tab [index]= len;
793  }
794  }
795  }
796 }
797 
799 {
800  static uint8_t rl_intra_table[2][2 * MAX_RUN + MAX_LEVEL + 3];
801 
802  ff_rl_init(&ff_rl_intra_aic, rl_intra_table);
804 
807 
809 }
810 
812 {
813  static AVOnce init_static_once = AV_ONCE_INIT;
814 
815  s->me.mv_penalty= mv_penalty; // FIXME exact table for MSMPEG4 & H.263+
816 
817  s->intra_ac_vlc_length =s->inter_ac_vlc_length = uni_h263_inter_rl_len;
818  s->intra_ac_vlc_last_length=s->inter_ac_vlc_last_length= uni_h263_inter_rl_len + 128*64;
819  if(s->h263_aic){
820  s->intra_ac_vlc_length = uni_h263_intra_aic_rl_len;
821  s->intra_ac_vlc_last_length= uni_h263_intra_aic_rl_len + 128*64;
822  }
823  s->ac_esc_length= 7+1+6+8;
824 
825  // use fcodes >1 only for MPEG-4 & H.263 & H.263+ FIXME
826  switch(s->codec_id){
827  case AV_CODEC_ID_MPEG4:
828  s->fcode_tab= fcode_tab;
829  break;
830  case AV_CODEC_ID_H263P:
831  if(s->umvplus)
832  s->fcode_tab= umv_fcode_tab;
833  if(s->modified_quant){
834  s->min_qcoeff= -2047;
835  s->max_qcoeff= 2047;
836  }else{
837  s->min_qcoeff= -127;
838  s->max_qcoeff= 127;
839  }
840  break;
841  // Note for MPEG-4 & H.263 the dc-scale table will be set per frame as needed later
842  case AV_CODEC_ID_FLV1:
843  if (s->h263_flv > 1) {
844  s->min_qcoeff= -1023;
845  s->max_qcoeff= 1023;
846  } else {
847  s->min_qcoeff= -127;
848  s->max_qcoeff= 127;
849  }
850  break;
851  default: //nothing needed - default table already set in mpegvideo.c
852  s->min_qcoeff= -127;
853  s->max_qcoeff= 127;
854  }
855  if(s->h263_aic){
856  s->y_dc_scale_table=
857  s->c_dc_scale_table= ff_aic_dc_scale_table;
858  }else{
859  s->y_dc_scale_table=
860  s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
861  }
862 
863  ff_thread_once(&init_static_once, h263_encode_init_static);
864 }
865 
867 {
868  int i, mb_pos;
869 
870  for(i=0; i<6; i++){
871  if(s->mb_num-1 <= ff_mba_max[i]) break;
872  }
873  mb_pos= s->mb_x + s->mb_width*s->mb_y;
874  put_bits(&s->pb, ff_mba_length[i], mb_pos);
875 }
error
static void error(const char *err)
Definition: target_bsf_fuzzer.c:31
MV_TYPE_16X16
#define MV_TYPE_16X16
1 vector for the whole mb
Definition: mpegvideo.h:252
h263data.h
FF_ASPECT_EXTENDED
#define FF_ASPECT_EXTENDED
Definition: h263.h:30
level
uint8_t level
Definition: svq3.c:202
av_clip
#define av_clip
Definition: common.h:96
wrong_run
static const uint8_t wrong_run[102]
Definition: ituh263enc.c:68
fcode_tab
static uint8_t fcode_tab[MAX_MV *2+1]
Minimal fcode that a motion vector component would need.
Definition: ituh263enc.c:52
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:412
uni_h263_inter_rl_len
static uint8_t uni_h263_inter_rl_len[64 *64 *2 *2]
Definition: ituh263enc.c:63
UNI_MPEG4_ENC_INDEX
#define UNI_MPEG4_ENC_INDEX(last, run, level)
Definition: ituh263enc.c:66
thread.h
ff_mpeg1_dc_scale_table
const uint8_t ff_mpeg1_dc_scale_table[128]
Definition: mpegvideodata.c:33
mv
static const int8_t mv[256][2]
Definition: 4xm.c:79
put_sbits
static void put_sbits(PutBitContext *pb, int n, int32_t value)
Definition: put_bits.h:280
MAX_RUN
#define MAX_RUN
Definition: rl.h:35
AV_CODEC_ID_MPEG4
@ AV_CODEC_ID_MPEG4
Definition: codec_id.h:62
put_bits
static void put_bits(Jpeg2000EncoderContext *s, int val, int n)
put n times val bit
Definition: j2kenc.c:220
ff_init_qscale_tab
void ff_init_qscale_tab(MpegEncContext *s)
init s->current_picture.qscale_table from s->lambda_table
Definition: mpegvideo_enc.c:236
index
fg index
Definition: ffmpeg_filter.c:167
MAX_DMV
#define MAX_DMV
Definition: motion_est.h:37
internal.h
av_const
#define av_const
Definition: attributes.h:84
init_uni_h263_rl_tab
static av_cold void init_uni_h263_rl_tab(const RLTable *rl, uint8_t *len_tab)
Definition: ituh263enc.c:757
mpegvideo.h
CANDIDATE_MB_TYPE_INTER
#define CANDIDATE_MB_TYPE_INTER
Definition: mpegutils.h:104
mpegutils.h
h263_pred_dc
static int h263_pred_dc(MpegEncContext *s, int n, int16_t **dc_val_ptr)
Definition: ituh263enc.c:447
MAX_FCODE
#define MAX_FCODE
Definition: mpegutils.h:47
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:848
ff_h263_pred_motion
int16_t * ff_h263_pred_motion(MpegEncContext *s, int block, int dir, int *px, int *py)
Definition: h263.c:190
wrap
#define wrap(func)
Definition: neontest.h:65
ff_h263_pixel_aspect
const AVRational ff_h263_pixel_aspect[16]
Definition: h263data.c:273
RLTable
RLTable.
Definition: rl.h:39
mv_penalty
static uint8_t mv_penalty[MAX_FCODE+1][MAX_DMV *2+1]
Table of number of bits a motion vector component needs.
Definition: ituh263enc.c:47
val
static double val(void *priv, double ch)
Definition: aeval.c:76
scale
static av_always_inline float scale(float x, float s)
Definition: vf_v360.c:1388
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_flv2_encode_ac_esc
void ff_flv2_encode_ac_esc(PutBitContext *pb, int slevel, int level, int run, int last)
Definition: flvenc.c:74
AVRational::num
int num
Numerator.
Definition: rational.h:59
CANDIDATE_MB_TYPE_INTER4V
#define CANDIDATE_MB_TYPE_INTER4V
Definition: mpegutils.h:105
h263_encode_block
static void h263_encode_block(MpegEncContext *s, int16_t *block, int n)
Encode an 8x8 block.
Definition: ituh263enc.c:299
flv.h
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:175
ff_h263_encode_motion
void ff_h263_encode_motion(PutBitContext *pb, int val, int f_code)
Definition: ituh263enc.c:687
FF_ARRAY_ELEMS
#define FF_ARRAY_ELEMS(a)
Definition: sinewin_tablegen.c:29
av_cold
#define av_cold
Definition: attributes.h:90
MAX_MV
#define MAX_MV
Definition: motion_est.h:35
ff_h263_encode_picture_header
void ff_h263_encode_picture_header(MpegEncContext *s, int picture_number)
Definition: ituh263enc.c:103
s
#define s(width, name)
Definition: cbs_vp9.c:257
get_rl_index
static int get_rl_index(const RLTable *rl, int last, int run, int level)
Definition: rl.h:91
bits
uint8_t bits
Definition: vp3data.h:141
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
get_p_cbp
static int get_p_cbp(MpegEncContext *s, int16_t block[6][64], int motion_x, int motion_y)
Definition: h263.h:122
limits.h
ff_h263_encode_init
av_cold void ff_h263_encode_init(MpegEncContext *s)
Definition: ituh263enc.c:811
PutBitContext
Definition: put_bits.h:49
ff_rl_init
av_cold void ff_rl_init(RLTable *rl, uint8_t static_store[2][2 *MAX_RUN+MAX_LEVEL+3])
Initialize index_run, max_level and max_run from n, last, table_vlc, table_run and table_level.
Definition: rl.c:27
ff_h263_encode_mb
void ff_h263_encode_mb(MpegEncContext *s, int16_t block[6][64], int motion_x, int motion_y)
Definition: ituh263enc.c:488
FFABS
#define FFABS(a)
Absolute value, Note, INT_MIN / INT64_MIN result in undefined behavior as they are not representable ...
Definition: common.h:65
AV_ONCE_INIT
#define AV_ONCE_INIT
Definition: thread.h:173
init_mv_penalty_and_fcode
static av_cold void init_mv_penalty_and_fcode(void)
Definition: ituh263enc.c:715
run
uint8_t run
Definition: svq3.c:201
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
uni_h263_intra_aic_rl_len
static uint8_t uni_h263_intra_aic_rl_len[64 *64 *2 *2]
Definition: ituh263enc.c:62
AV_PICTURE_TYPE_I
@ AV_PICTURE_TYPE_I
Intra.
Definition: avutil.h:274
mathops.h
ff_mba_max
const uint16_t ff_mba_max[6]
Definition: h263data.c:265
AVOnce
#define AVOnce
Definition: thread.h:172
c
Undefined Behavior In the C some operations are like signed integer dereferencing freed accessing outside allocated Undefined Behavior must not occur in a C it is not safe even if the output of undefined operations is unused The unsafety may seem nit picking but Optimizing compilers have in fact optimized code on the assumption that no undefined Behavior occurs Optimizing code based on wrong assumptions can and has in some cases lead to effects beyond the output of computations The signed integer overflow problem in speed critical code Code which is highly optimized and works with signed integers sometimes has the problem that often the output of the computation does not c
Definition: undefined.txt:32
MAX_LEVEL
#define MAX_LEVEL
Definition: rl.h:36
ff_clean_h263_qscales
void ff_clean_h263_qscales(MpegEncContext *s)
modify qscale so that encoding is actually possible in H.263 (limit difference to -2....
Definition: ituh263enc.c:266
ff_h263_rl_inter
RLTable ff_h263_rl_inter
Definition: h263data.c:159
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
format
ofilter format
Definition: ffmpeg_filter.c:172
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
mpegvideodata.h
attributes.h
ff_h263_inter_MCBPC_bits
const uint8_t ff_h263_inter_MCBPC_bits[28]
Definition: h263data.c:47
av_assert2
#define av_assert2(cond)
assert() equivalent, that does lie in speed critical code.
Definition: avassert.h:64
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:271
code
and forward the test the status of outputs and forward it to the corresponding return FFERROR_NOT_READY If the filters stores internally one or a few frame for some it can consider them to be part of the FIFO and delay acknowledging a status change accordingly Example code
Definition: filter_design.txt:178
av_assert1
#define av_assert1(cond)
assert() equivalent, that does not lie in speed critical code.
Definition: avassert.h:53
ff_h263_format
const uint16_t ff_h263_format[8][2]
Definition: h263data.c:236
ff_h263_encode_mba
void ff_h263_encode_mba(MpegEncContext *s)
Definition: ituh263enc.c:866
len
int len
Definition: vorbis_enc_data.h:426
avcodec.h
av_cmp_q
static int av_cmp_q(AVRational a, AVRational b)
Compare two rationals.
Definition: rational.h:89
get_bits_diff
static int get_bits_diff(MpegEncContext *s)
Definition: mpegvideo.h:767
h263_encode_init_static
static av_cold void h263_encode_init_static(void)
Definition: ituh263enc.c:798
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:292
AV_CODEC_ID_H263P
@ AV_CODEC_ID_H263P
Definition: codec_id.h:69
put_bits_ptr
static uint8_t * put_bits_ptr(PutBitContext *s)
Return the pointer to the byte where the bitstream writer will put the next bit.
Definition: put_bits.h:369
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:58
sign_extend
static av_const int sign_extend(int val, unsigned bits)
Definition: mathops.h:130
ff_mba_length
const uint8_t ff_mba_length[7]
Definition: h263data.c:269
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
ff_h263_inter_MCBPC_code
const uint8_t ff_h263_inter_MCBPC_code[28]
Definition: h263data.c:38
AV_PICTURE_TYPE_P
@ AV_PICTURE_TYPE_P
Predicted.
Definition: avutil.h:275
ff_h263_encode_motion_vector
static void ff_h263_encode_motion_vector(MpegEncContext *s, int x, int y, int f_code)
Definition: h263.h:111
pred_dc
static void FUNC() pred_dc(uint8_t *_src, const uint8_t *_top, const uint8_t *_left, ptrdiff_t stride, int log2_size, int c_idx)
Definition: hevcpred_template.c:390
h263p_encode_umotion
static void h263p_encode_umotion(PutBitContext *pb, int val)
Definition: ituh263enc.c:410
block
The exact code depends on how similar the blocks are and how related they are to the block
Definition: filter_design.txt:207
ff_h263_init_rl_inter
av_cold void ff_h263_init_rl_inter(void)
Definition: h263.c:47
AV_CODEC_ID_FLV1
@ AV_CODEC_ID_FLV1
Definition: codec_id.h:71
MpegEncContext
MpegEncContext.
Definition: mpegvideo.h:69
av_log2
int av_log2(unsigned v)
Definition: intmath.c:26
AV_CODEC_FLAG_PASS1
#define AV_CODEC_FLAG_PASS1
Use internal 2pass ratecontrol in first pass mode.
Definition: avcodec.h:231
h263.h