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