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