FFmpeg
mpeg4videoenc.c
Go to the documentation of this file.
1 /*
2  * MPEG-4 encoder
3  * Copyright (c) 2000,2001 Fabrice Bellard
4  * Copyright (c) 2002-2010 Michael Niedermayer <michaelni@gmx.at>
5  *
6  * This file is part of FFmpeg.
7  *
8  * FFmpeg is free software; you can redistribute it and/or
9  * modify it under the terms of the GNU Lesser General Public
10  * License as published by the Free Software Foundation; either
11  * version 2.1 of the License, or (at your option) any later version.
12  *
13  * FFmpeg is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16  * Lesser General Public License for more details.
17  *
18  * You should have received a copy of the GNU Lesser General Public
19  * License along with FFmpeg; if not, write to the Free Software
20  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
21  */
22 
23 #include "libavutil/attributes.h"
24 #include "libavutil/log.h"
25 #include "libavutil/opt.h"
26 #include "mpegutils.h"
27 #include "mpegvideo.h"
28 #include "h263.h"
29 #include "mpeg4video.h"
30 #include "profiles.h"
31 
32 /* The uni_DCtab_* tables below contain unified bits+length tables to encode DC
33  * differences in MPEG-4. Unified in the sense that the specification specifies
34  * this encoding in several steps. */
37 static uint16_t uni_DCtab_lum_bits[512];
38 static uint16_t uni_DCtab_chrom_bits[512];
39 
40 /* Unified encoding tables for run length encoding of coefficients.
41  * Unified in the sense that the specification specifies the encoding in several steps. */
42 static uint32_t uni_mpeg4_intra_rl_bits[64 * 64 * 2 * 2];
43 static uint8_t uni_mpeg4_intra_rl_len[64 * 64 * 2 * 2];
44 static uint32_t uni_mpeg4_inter_rl_bits[64 * 64 * 2 * 2];
45 static uint8_t uni_mpeg4_inter_rl_len[64 * 64 * 2 * 2];
46 
47 //#define UNI_MPEG4_ENC_INDEX(last, run, level) ((last) * 128 + (run) * 256 + (level))
48 //#define UNI_MPEG4_ENC_INDEX(last, run, level) ((last) * 128 * 64 + (run) + (level) * 64)
49 #define UNI_MPEG4_ENC_INDEX(last, run, level) ((last) * 128 * 64 + (run) * 128 + (level))
50 
51 /* MPEG-4
52  * inter
53  * max level: 24/6
54  * max run: 53/63
55  *
56  * intra
57  * max level: 53/16
58  * max run: 29/41
59  */
60 
61 /**
62  * Return the number of bits that encoding the 8x8 block in block would need.
63  * @param[in] block_last_index last index in scantable order that refers to a non zero element in block.
64  */
65 static inline int get_block_rate(MpegEncContext *s, int16_t block[64],
66  int block_last_index, uint8_t scantable[64])
67 {
68  int last = 0;
69  int j;
70  int rate = 0;
71 
72  for (j = 1; j <= block_last_index; j++) {
73  const int index = scantable[j];
74  int level = block[index];
75  if (level) {
76  level += 64;
77  if ((level & (~127)) == 0) {
78  if (j < block_last_index)
79  rate += s->intra_ac_vlc_length[UNI_AC_ENC_INDEX(j - last - 1, level)];
80  else
81  rate += s->intra_ac_vlc_last_length[UNI_AC_ENC_INDEX(j - last - 1, level)];
82  } else
83  rate += s->ac_esc_length;
84 
85  last = j;
86  }
87  }
88 
89  return rate;
90 }
91 
92 /**
93  * Restore the ac coefficients in block that have been changed by decide_ac_pred().
94  * This function also restores s->block_last_index.
95  * @param[in,out] block MB coefficients, these will be restored
96  * @param[in] dir ac prediction direction for each 8x8 block
97  * @param[out] st scantable for each 8x8 block
98  * @param[in] zigzag_last_index index referring to the last non zero coefficient in zigzag order
99  */
100 static inline void restore_ac_coeffs(MpegEncContext *s, int16_t block[6][64],
101  const int dir[6], uint8_t *st[6],
102  const int zigzag_last_index[6])
103 {
104  int i, n;
105  memcpy(s->block_last_index, zigzag_last_index, sizeof(int) * 6);
106 
107  for (n = 0; n < 6; n++) {
108  int16_t *ac_val = &s->ac_val[0][0][0] + s->block_index[n] * 16;
109 
110  st[n] = s->intra_scantable.permutated;
111  if (dir[n]) {
112  /* top prediction */
113  for (i = 1; i < 8; i++)
114  block[n][s->idsp.idct_permutation[i]] = ac_val[i + 8];
115  } else {
116  /* left prediction */
117  for (i = 1; i < 8; i++)
118  block[n][s->idsp.idct_permutation[i << 3]] = ac_val[i];
119  }
120  }
121 }
122 
123 /**
124  * Return the optimal value (0 or 1) for the ac_pred element for the given MB in MPEG-4.
125  * This function will also update s->block_last_index and s->ac_val.
126  * @param[in,out] block MB coefficients, these will be updated if 1 is returned
127  * @param[in] dir ac prediction direction for each 8x8 block
128  * @param[out] st scantable for each 8x8 block
129  * @param[out] zigzag_last_index index referring to the last non zero coefficient in zigzag order
130  */
131 static inline int decide_ac_pred(MpegEncContext *s, int16_t block[6][64],
132  const int dir[6], uint8_t *st[6],
133  int zigzag_last_index[6])
134 {
135  int score = 0;
136  int i, n;
137  int8_t *const qscale_table = s->current_picture.qscale_table;
138 
139  memcpy(zigzag_last_index, s->block_last_index, sizeof(int) * 6);
140 
141  for (n = 0; n < 6; n++) {
142  int16_t *ac_val, *ac_val1;
143 
144  score -= get_block_rate(s, block[n], s->block_last_index[n],
146 
147  ac_val = &s->ac_val[0][0][0] + s->block_index[n] * 16;
148  ac_val1 = ac_val;
149  if (dir[n]) {
150  const int xy = s->mb_x + s->mb_y * s->mb_stride - s->mb_stride;
151  /* top prediction */
152  ac_val -= s->block_wrap[n] * 16;
153  if (s->mb_y == 0 || s->qscale == qscale_table[xy] || n == 2 || n == 3) {
154  /* same qscale */
155  for (i = 1; i < 8; i++) {
156  const int level = block[n][s->idsp.idct_permutation[i]];
157  block[n][s->idsp.idct_permutation[i]] = level - ac_val[i + 8];
158  ac_val1[i] = block[n][s->idsp.idct_permutation[i << 3]];
159  ac_val1[i + 8] = level;
160  }
161  } else {
162  /* different qscale, we must rescale */
163  for (i = 1; i < 8; i++) {
164  const int level = block[n][s->idsp.idct_permutation[i]];
165  block[n][s->idsp.idct_permutation[i]] = level - ROUNDED_DIV(ac_val[i + 8] * qscale_table[xy], s->qscale);
166  ac_val1[i] = block[n][s->idsp.idct_permutation[i << 3]];
167  ac_val1[i + 8] = level;
168  }
169  }
170  st[n] = s->intra_h_scantable.permutated;
171  } else {
172  const int xy = s->mb_x - 1 + s->mb_y * s->mb_stride;
173  /* left prediction */
174  ac_val -= 16;
175  if (s->mb_x == 0 || s->qscale == qscale_table[xy] || n == 1 || n == 3) {
176  /* same qscale */
177  for (i = 1; i < 8; i++) {
178  const int level = block[n][s->idsp.idct_permutation[i << 3]];
179  block[n][s->idsp.idct_permutation[i << 3]] = level - ac_val[i];
180  ac_val1[i] = level;
181  ac_val1[i + 8] = block[n][s->idsp.idct_permutation[i]];
182  }
183  } else {
184  /* different qscale, we must rescale */
185  for (i = 1; i < 8; i++) {
186  const int level = block[n][s->idsp.idct_permutation[i << 3]];
187  block[n][s->idsp.idct_permutation[i << 3]] = level - ROUNDED_DIV(ac_val[i] * qscale_table[xy], s->qscale);
188  ac_val1[i] = level;
189  ac_val1[i + 8] = block[n][s->idsp.idct_permutation[i]];
190  }
191  }
192  st[n] = s->intra_v_scantable.permutated;
193  }
194 
195  for (i = 63; i > 0; i--) // FIXME optimize
196  if (block[n][st[n][i]])
197  break;
198  s->block_last_index[n] = i;
199 
200  score += get_block_rate(s, block[n], s->block_last_index[n], st[n]);
201  }
202 
203  if (score < 0) {
204  return 1;
205  } else {
206  restore_ac_coeffs(s, block, dir, st, zigzag_last_index);
207  return 0;
208  }
209 }
210 
211 /**
212  * modify mb_type & qscale so that encoding is actually possible in MPEG-4
213  */
215 {
216  int i;
217  int8_t *const qscale_table = s->current_picture.qscale_table;
218 
220 
221  if (s->pict_type == AV_PICTURE_TYPE_B) {
222  int odd = 0;
223  /* ok, come on, this isn't funny anymore, there's more code for
224  * handling this MPEG-4 mess than for the actual adaptive quantization */
225 
226  for (i = 0; i < s->mb_num; i++) {
227  int mb_xy = s->mb_index2xy[i];
228  odd += qscale_table[mb_xy] & 1;
229  }
230 
231  if (2 * odd > s->mb_num)
232  odd = 1;
233  else
234  odd = 0;
235 
236  for (i = 0; i < s->mb_num; i++) {
237  int mb_xy = s->mb_index2xy[i];
238  if ((qscale_table[mb_xy] & 1) != odd)
239  qscale_table[mb_xy]++;
240  if (qscale_table[mb_xy] > 31)
241  qscale_table[mb_xy] = 31;
242  }
243 
244  for (i = 1; i < s->mb_num; i++) {
245  int mb_xy = s->mb_index2xy[i];
246  if (qscale_table[mb_xy] != qscale_table[s->mb_index2xy[i - 1]] &&
247  (s->mb_type[mb_xy] & CANDIDATE_MB_TYPE_DIRECT)) {
248  s->mb_type[mb_xy] |= CANDIDATE_MB_TYPE_BIDIR;
249  }
250  }
251  }
252 }
253 
254 /**
255  * Encode the dc value.
256  * @param n block index (0-3 are luma, 4-5 are chroma)
257  */
258 static inline void mpeg4_encode_dc(PutBitContext *s, int level, int n)
259 {
260  /* DC will overflow if level is outside the [-255,255] range. */
261  level += 256;
262  if (n < 4) {
263  /* luminance */
264  put_bits(s, uni_DCtab_lum_len[level], uni_DCtab_lum_bits[level]);
265  } else {
266  /* chrominance */
268  }
269 }
270 
271 static inline int mpeg4_get_dc_length(int level, int n)
272 {
273  if (n < 4)
274  return uni_DCtab_lum_len[level + 256];
275  else
276  return uni_DCtab_chrom_len[level + 256];
277 }
278 
279 /**
280  * Encode an 8x8 block.
281  * @param n block index (0-3 are luma, 4-5 are chroma)
282  */
283 static inline void mpeg4_encode_block(MpegEncContext *s,
284  int16_t *block, int n, int intra_dc,
285  uint8_t *scan_table, PutBitContext *dc_pb,
286  PutBitContext *ac_pb)
287 {
288  int i, last_non_zero;
289  uint32_t *bits_tab;
290  uint8_t *len_tab;
291  const int last_index = s->block_last_index[n];
292 
293  if (s->mb_intra) { // Note gcc (3.2.1 at least) will optimize this away
294  /* MPEG-4 based DC predictor */
295  mpeg4_encode_dc(dc_pb, intra_dc, n);
296  if (last_index < 1)
297  return;
298  i = 1;
299  bits_tab = uni_mpeg4_intra_rl_bits;
300  len_tab = uni_mpeg4_intra_rl_len;
301  } else {
302  if (last_index < 0)
303  return;
304  i = 0;
305  bits_tab = uni_mpeg4_inter_rl_bits;
306  len_tab = uni_mpeg4_inter_rl_len;
307  }
308 
309  /* AC coefs */
310  last_non_zero = i - 1;
311  for (; i < last_index; i++) {
312  int level = block[scan_table[i]];
313  if (level) {
314  int run = i - last_non_zero - 1;
315  level += 64;
316  if ((level & (~127)) == 0) {
317  const int index = UNI_MPEG4_ENC_INDEX(0, run, level);
318  put_bits(ac_pb, len_tab[index], bits_tab[index]);
319  } else { // ESC3
320  put_bits(ac_pb,
321  7 + 2 + 1 + 6 + 1 + 12 + 1,
322  (3 << 23) + (3 << 21) + (0 << 20) + (run << 14) +
323  (1 << 13) + (((level - 64) & 0xfff) << 1) + 1);
324  }
325  last_non_zero = i;
326  }
327  }
328  /* if (i <= last_index) */ {
329  int level = block[scan_table[i]];
330  int run = i - last_non_zero - 1;
331  level += 64;
332  if ((level & (~127)) == 0) {
333  const int index = UNI_MPEG4_ENC_INDEX(1, run, level);
334  put_bits(ac_pb, len_tab[index], bits_tab[index]);
335  } else { // ESC3
336  put_bits(ac_pb,
337  7 + 2 + 1 + 6 + 1 + 12 + 1,
338  (3 << 23) + (3 << 21) + (1 << 20) + (run << 14) +
339  (1 << 13) + (((level - 64) & 0xfff) << 1) + 1);
340  }
341  }
342 }
343 
345  int16_t *block, int n,
346  int intra_dc, uint8_t *scan_table)
347 {
348  int i, last_non_zero;
349  uint8_t *len_tab;
350  const int last_index = s->block_last_index[n];
351  int len = 0;
352 
353  if (s->mb_intra) { // Note gcc (3.2.1 at least) will optimize this away
354  /* MPEG-4 based DC predictor */
355  len += mpeg4_get_dc_length(intra_dc, n);
356  if (last_index < 1)
357  return len;
358  i = 1;
359  len_tab = uni_mpeg4_intra_rl_len;
360  } else {
361  if (last_index < 0)
362  return 0;
363  i = 0;
364  len_tab = uni_mpeg4_inter_rl_len;
365  }
366 
367  /* AC coefs */
368  last_non_zero = i - 1;
369  for (; i < last_index; i++) {
370  int level = block[scan_table[i]];
371  if (level) {
372  int run = i - last_non_zero - 1;
373  level += 64;
374  if ((level & (~127)) == 0) {
375  const int index = UNI_MPEG4_ENC_INDEX(0, run, level);
376  len += len_tab[index];
377  } else { // ESC3
378  len += 7 + 2 + 1 + 6 + 1 + 12 + 1;
379  }
380  last_non_zero = i;
381  }
382  }
383  /* if (i <= last_index) */ {
384  int level = block[scan_table[i]];
385  int run = i - last_non_zero - 1;
386  level += 64;
387  if ((level & (~127)) == 0) {
388  const int index = UNI_MPEG4_ENC_INDEX(1, run, level);
389  len += len_tab[index];
390  } else { // ESC3
391  len += 7 + 2 + 1 + 6 + 1 + 12 + 1;
392  }
393  }
394 
395  return len;
396 }
397 
398 static inline void mpeg4_encode_blocks(MpegEncContext *s, int16_t block[6][64],
399  int intra_dc[6], uint8_t **scan_table,
400  PutBitContext *dc_pb,
401  PutBitContext *ac_pb)
402 {
403  int i;
404 
405  if (scan_table) {
407  for (i = 0; i < 6; i++)
408  skip_put_bits(&s->pb,
409  mpeg4_get_block_length(s, block[i], i,
410  intra_dc[i], scan_table[i]));
411  } else {
412  /* encode each block */
413  for (i = 0; i < 6; i++)
414  mpeg4_encode_block(s, block[i], i,
415  intra_dc[i], scan_table[i], dc_pb, ac_pb);
416  }
417  } else {
419  for (i = 0; i < 6; i++)
420  skip_put_bits(&s->pb,
421  mpeg4_get_block_length(s, block[i], i, 0,
423  } else {
424  /* encode each block */
425  for (i = 0; i < 6; i++)
426  mpeg4_encode_block(s, block[i], i, 0,
427  s->intra_scantable.permutated, dc_pb, ac_pb);
428  }
429  }
430 }
431 
432 static inline int get_b_cbp(MpegEncContext *s, int16_t block[6][64],
433  int motion_x, int motion_y, int mb_type)
434 {
435  int cbp = 0, i;
436 
437  if (s->mpv_flags & FF_MPV_FLAG_CBP_RD) {
438  int score = 0;
439  const int lambda = s->lambda2 >> (FF_LAMBDA_SHIFT - 6);
440 
441  for (i = 0; i < 6; i++) {
442  if (s->coded_score[i] < 0) {
443  score += s->coded_score[i];
444  cbp |= 1 << (5 - i);
445  }
446  }
447 
448  if (cbp) {
449  int zero_score = -6;
450  if ((motion_x | motion_y | s->dquant | mb_type) == 0)
451  zero_score -= 4; // 2 * MV + mb_type + cbp bit
452 
453  zero_score *= lambda;
454  if (zero_score <= score)
455  cbp = 0;
456  }
457 
458  for (i = 0; i < 6; i++) {
459  if (s->block_last_index[i] >= 0 && ((cbp >> (5 - i)) & 1) == 0) {
460  s->block_last_index[i] = -1;
461  s->bdsp.clear_block(s->block[i]);
462  }
463  }
464  } else {
465  for (i = 0; i < 6; i++) {
466  if (s->block_last_index[i] >= 0)
467  cbp |= 1 << (5 - i);
468  }
469  }
470  return cbp;
471 }
472 
473 // FIXME this is duplicated to h263.c
474 static const int dquant_code[5] = { 1, 0, 9, 2, 3 };
475 
476 void ff_mpeg4_encode_mb(MpegEncContext *s, int16_t block[6][64],
477  int motion_x, int motion_y)
478 {
479  int cbpc, cbpy, pred_x, pred_y;
480  PutBitContext *const pb2 = s->data_partitioning ? &s->pb2 : &s->pb;
481  PutBitContext *const tex_pb = s->data_partitioning && s->pict_type != AV_PICTURE_TYPE_B ? &s->tex_pb : &s->pb;
482  PutBitContext *const dc_pb = s->data_partitioning && s->pict_type != AV_PICTURE_TYPE_I ? &s->pb2 : &s->pb;
483  const int interleaved_stats = (s->avctx->flags & AV_CODEC_FLAG_PASS1) && !s->data_partitioning ? 1 : 0;
484 
485  if (!s->mb_intra) {
486  int i, cbp;
487 
488  if (s->pict_type == AV_PICTURE_TYPE_B) {
489  /* convert from mv_dir to type */
490  static const int mb_type_table[8] = { -1, 3, 2, 1, -1, -1, -1, 0 };
491  int mb_type = mb_type_table[s->mv_dir];
492 
493  if (s->mb_x == 0) {
494  for (i = 0; i < 2; i++)
495  s->last_mv[i][0][0] =
496  s->last_mv[i][0][1] =
497  s->last_mv[i][1][0] =
498  s->last_mv[i][1][1] = 0;
499  }
500 
501  av_assert2(s->dquant >= -2 && s->dquant <= 2);
502  av_assert2((s->dquant & 1) == 0);
503  av_assert2(mb_type >= 0);
504 
505  /* nothing to do if this MB was skipped in the next P-frame */
506  if (s->next_picture.mbskip_table[s->mb_y * s->mb_stride + s->mb_x]) { // FIXME avoid DCT & ...
507  s->skip_count++;
508  s->mv[0][0][0] =
509  s->mv[0][0][1] =
510  s->mv[1][0][0] =
511  s->mv[1][0][1] = 0;
512  s->mv_dir = MV_DIR_FORWARD; // doesn't matter
513  s->qscale -= s->dquant;
514 // s->mb_skipped = 1;
515 
516  return;
517  }
518 
519  cbp = get_b_cbp(s, block, motion_x, motion_y, mb_type);
520 
521  if ((cbp | motion_x | motion_y | mb_type) == 0) {
522  /* direct MB with MV={0,0} */
523  av_assert2(s->dquant == 0);
524 
525  put_bits(&s->pb, 1, 1); /* mb not coded modb1=1 */
526 
527  if (interleaved_stats) {
528  s->misc_bits++;
529  s->last_bits++;
530  }
531  s->skip_count++;
532  return;
533  }
534 
535  put_bits(&s->pb, 1, 0); /* mb coded modb1=0 */
536  put_bits(&s->pb, 1, cbp ? 0 : 1); /* modb2 */ // FIXME merge
537  put_bits(&s->pb, mb_type + 1, 1); // this table is so simple that we don't need it :)
538  if (cbp)
539  put_bits(&s->pb, 6, cbp);
540 
541  if (cbp && mb_type) {
542  if (s->dquant)
543  put_bits(&s->pb, 2, (s->dquant >> 2) + 3);
544  else
545  put_bits(&s->pb, 1, 0);
546  } else
547  s->qscale -= s->dquant;
548 
549  if (!s->progressive_sequence) {
550  if (cbp)
551  put_bits(&s->pb, 1, s->interlaced_dct);
552  if (mb_type) // not direct mode
553  put_bits(&s->pb, 1, s->mv_type == MV_TYPE_FIELD);
554  }
555 
556  if (interleaved_stats)
557  s->misc_bits += get_bits_diff(s);
558 
559  if (!mb_type) {
561  ff_h263_encode_motion_vector(s, motion_x, motion_y, 1);
562  s->b_count++;
563  s->f_count++;
564  } else {
565  av_assert2(mb_type > 0 && mb_type < 4);
566  if (s->mv_type != MV_TYPE_FIELD) {
567  if (s->mv_dir & MV_DIR_FORWARD) {
569  s->mv[0][0][0] - s->last_mv[0][0][0],
570  s->mv[0][0][1] - s->last_mv[0][0][1],
571  s->f_code);
572  s->last_mv[0][0][0] =
573  s->last_mv[0][1][0] = s->mv[0][0][0];
574  s->last_mv[0][0][1] =
575  s->last_mv[0][1][1] = s->mv[0][0][1];
576  s->f_count++;
577  }
578  if (s->mv_dir & MV_DIR_BACKWARD) {
580  s->mv[1][0][0] - s->last_mv[1][0][0],
581  s->mv[1][0][1] - s->last_mv[1][0][1],
582  s->b_code);
583  s->last_mv[1][0][0] =
584  s->last_mv[1][1][0] = s->mv[1][0][0];
585  s->last_mv[1][0][1] =
586  s->last_mv[1][1][1] = s->mv[1][0][1];
587  s->b_count++;
588  }
589  } else {
590  if (s->mv_dir & MV_DIR_FORWARD) {
591  put_bits(&s->pb, 1, s->field_select[0][0]);
592  put_bits(&s->pb, 1, s->field_select[0][1]);
593  }
594  if (s->mv_dir & MV_DIR_BACKWARD) {
595  put_bits(&s->pb, 1, s->field_select[1][0]);
596  put_bits(&s->pb, 1, s->field_select[1][1]);
597  }
598  if (s->mv_dir & MV_DIR_FORWARD) {
599  for (i = 0; i < 2; i++) {
601  s->mv[0][i][0] - s->last_mv[0][i][0],
602  s->mv[0][i][1] - s->last_mv[0][i][1] / 2,
603  s->f_code);
604  s->last_mv[0][i][0] = s->mv[0][i][0];
605  s->last_mv[0][i][1] = s->mv[0][i][1] * 2;
606  }
607  s->f_count++;
608  }
609  if (s->mv_dir & MV_DIR_BACKWARD) {
610  for (i = 0; i < 2; i++) {
612  s->mv[1][i][0] - s->last_mv[1][i][0],
613  s->mv[1][i][1] - s->last_mv[1][i][1] / 2,
614  s->b_code);
615  s->last_mv[1][i][0] = s->mv[1][i][0];
616  s->last_mv[1][i][1] = s->mv[1][i][1] * 2;
617  }
618  s->b_count++;
619  }
620  }
621  }
622 
623  if (interleaved_stats)
624  s->mv_bits += get_bits_diff(s);
625 
626  mpeg4_encode_blocks(s, block, NULL, NULL, NULL, &s->pb);
627 
628  if (interleaved_stats)
629  s->p_tex_bits += get_bits_diff(s);
630  } else { /* s->pict_type==AV_PICTURE_TYPE_B */
631  cbp = get_p_cbp(s, block, motion_x, motion_y);
632 
633  if ((cbp | motion_x | motion_y | s->dquant) == 0 &&
634  s->mv_type == MV_TYPE_16X16) {
635  /* Check if the B-frames can skip it too, as we must skip it
636  * if we skip here why didn't they just compress
637  * the skip-mb bits instead of reusing them ?! */
638  if (s->max_b_frames > 0) {
639  int i;
640  int x, y, offset;
641  uint8_t *p_pic;
642 
643  x = s->mb_x * 16;
644  y = s->mb_y * 16;
645 
646  offset = x + y * s->linesize;
647  p_pic = s->new_picture.f->data[0] + offset;
648 
649  s->mb_skipped = 1;
650  for (i = 0; i < s->max_b_frames; i++) {
651  uint8_t *b_pic;
652  int diff;
653  Picture *pic = s->reordered_input_picture[i + 1];
654 
655  if (!pic || pic->f->pict_type != AV_PICTURE_TYPE_B)
656  break;
657 
658  b_pic = pic->f->data[0] + offset;
659  if (!pic->shared)
660  b_pic += INPLACE_OFFSET;
661 
662  if (x + 16 > s->width || y + 16 > s->height) {
663  int x1, y1;
664  int xe = FFMIN(16, s->width - x);
665  int ye = FFMIN(16, s->height - y);
666  diff = 0;
667  for (y1 = 0; y1 < ye; y1++) {
668  for (x1 = 0; x1 < xe; x1++) {
669  diff += FFABS(p_pic[x1 + y1 * s->linesize] - b_pic[x1 + y1 * s->linesize]);
670  }
671  }
672  diff = diff * 256 / (xe * ye);
673  } else {
674  diff = s->mecc.sad[0](NULL, p_pic, b_pic, s->linesize, 16);
675  }
676  if (diff > s->qscale * 70) { // FIXME check that 70 is optimal
677  s->mb_skipped = 0;
678  break;
679  }
680  }
681  } else
682  s->mb_skipped = 1;
683 
684  if (s->mb_skipped == 1) {
685  /* skip macroblock */
686  put_bits(&s->pb, 1, 1);
687 
688  if (interleaved_stats) {
689  s->misc_bits++;
690  s->last_bits++;
691  }
692  s->skip_count++;
693 
694  return;
695  }
696  }
697 
698  put_bits(&s->pb, 1, 0); /* mb coded */
699  cbpc = cbp & 3;
700  cbpy = cbp >> 2;
701  cbpy ^= 0xf;
702  if (s->mv_type == MV_TYPE_16X16) {
703  if (s->dquant)
704  cbpc += 8;
705  put_bits(&s->pb,
708 
709  put_bits(pb2, ff_h263_cbpy_tab[cbpy][1], ff_h263_cbpy_tab[cbpy][0]);
710  if (s->dquant)
711  put_bits(pb2, 2, dquant_code[s->dquant + 2]);
712 
713  if (!s->progressive_sequence) {
714  if (cbp)
715  put_bits(pb2, 1, s->interlaced_dct);
716  put_bits(pb2, 1, 0);
717  }
718 
719  if (interleaved_stats)
720  s->misc_bits += get_bits_diff(s);
721 
722  /* motion vectors: 16x16 mode */
723  ff_h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
724 
726  motion_x - pred_x,
727  motion_y - pred_y,
728  s->f_code);
729  } else if (s->mv_type == MV_TYPE_FIELD) {
730  if (s->dquant)
731  cbpc += 8;
732  put_bits(&s->pb,
735 
736  put_bits(pb2, ff_h263_cbpy_tab[cbpy][1], ff_h263_cbpy_tab[cbpy][0]);
737  if (s->dquant)
738  put_bits(pb2, 2, dquant_code[s->dquant + 2]);
739 
741  if (cbp)
742  put_bits(pb2, 1, s->interlaced_dct);
743  put_bits(pb2, 1, 1);
744 
745  if (interleaved_stats)
746  s->misc_bits += get_bits_diff(s);
747 
748  /* motion vectors: 16x8 interlaced mode */
749  ff_h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
750  pred_y /= 2;
751 
752  put_bits(&s->pb, 1, s->field_select[0][0]);
753  put_bits(&s->pb, 1, s->field_select[0][1]);
754 
756  s->mv[0][0][0] - pred_x,
757  s->mv[0][0][1] - pred_y,
758  s->f_code);
760  s->mv[0][1][0] - pred_x,
761  s->mv[0][1][1] - pred_y,
762  s->f_code);
763  } else {
765  put_bits(&s->pb,
766  ff_h263_inter_MCBPC_bits[cbpc + 16],
767  ff_h263_inter_MCBPC_code[cbpc + 16]);
768  put_bits(pb2, ff_h263_cbpy_tab[cbpy][1], ff_h263_cbpy_tab[cbpy][0]);
769 
770  if (!s->progressive_sequence && cbp)
771  put_bits(pb2, 1, s->interlaced_dct);
772 
773  if (interleaved_stats)
774  s->misc_bits += get_bits_diff(s);
775 
776  for (i = 0; i < 4; i++) {
777  /* motion vectors: 8x8 mode*/
778  ff_h263_pred_motion(s, i, 0, &pred_x, &pred_y);
779 
781  s->current_picture.motion_val[0][s->block_index[i]][0] - pred_x,
782  s->current_picture.motion_val[0][s->block_index[i]][1] - pred_y,
783  s->f_code);
784  }
785  }
786 
787  if (interleaved_stats)
788  s->mv_bits += get_bits_diff(s);
789 
790  mpeg4_encode_blocks(s, block, NULL, NULL, NULL, tex_pb);
791 
792  if (interleaved_stats)
793  s->p_tex_bits += get_bits_diff(s);
794 
795  s->f_count++;
796  }
797  } else {
798  int cbp;
799  int dc_diff[6]; // dc values with the dc prediction subtracted
800  int dir[6]; // prediction direction
801  int zigzag_last_index[6];
802  uint8_t *scan_table[6];
803  int i;
804 
805  for (i = 0; i < 6; i++)
806  dc_diff[i] = ff_mpeg4_pred_dc(s, i, block[i][0], &dir[i], 1);
807 
808  if (s->avctx->flags & AV_CODEC_FLAG_AC_PRED) {
809  s->ac_pred = decide_ac_pred(s, block, dir, scan_table, zigzag_last_index);
810  } else {
811  for (i = 0; i < 6; i++)
812  scan_table[i] = s->intra_scantable.permutated;
813  }
814 
815  /* compute cbp */
816  cbp = 0;
817  for (i = 0; i < 6; i++)
818  if (s->block_last_index[i] >= 1)
819  cbp |= 1 << (5 - i);
820 
821  cbpc = cbp & 3;
822  if (s->pict_type == AV_PICTURE_TYPE_I) {
823  if (s->dquant)
824  cbpc += 4;
825  put_bits(&s->pb,
828  } else {
829  if (s->dquant)
830  cbpc += 8;
831  put_bits(&s->pb, 1, 0); /* mb coded */
832  put_bits(&s->pb,
833  ff_h263_inter_MCBPC_bits[cbpc + 4],
834  ff_h263_inter_MCBPC_code[cbpc + 4]);
835  }
836  put_bits(pb2, 1, s->ac_pred);
837  cbpy = cbp >> 2;
838  put_bits(pb2, ff_h263_cbpy_tab[cbpy][1], ff_h263_cbpy_tab[cbpy][0]);
839  if (s->dquant)
840  put_bits(dc_pb, 2, dquant_code[s->dquant + 2]);
841 
842  if (!s->progressive_sequence)
843  put_bits(dc_pb, 1, s->interlaced_dct);
844 
845  if (interleaved_stats)
846  s->misc_bits += get_bits_diff(s);
847 
848  mpeg4_encode_blocks(s, block, dc_diff, scan_table, dc_pb, tex_pb);
849 
850  if (interleaved_stats)
851  s->i_tex_bits += get_bits_diff(s);
852  s->i_count++;
853 
854  /* restore ac coeffs & last_index stuff
855  * if we messed them up with the prediction */
856  if (s->ac_pred)
857  restore_ac_coeffs(s, block, dir, scan_table, zigzag_last_index);
858  }
859 }
860 
861 /**
862  * add MPEG-4 stuffing bits (01...1)
863  */
865 {
866  int length;
867  put_bits(pbc, 1, 0);
868  length = (-put_bits_count(pbc)) & 7;
869  if (length)
870  put_bits(pbc, length, (1 << length) - 1);
871 }
872 
873 /* must be called before writing the header */
875 {
876  if (s->pict_type == AV_PICTURE_TYPE_B) {
878  } else {
879  s->last_time_base = s->time_base;
880  s->time_base = FFUDIV(s->time, s->avctx->time_base.den);
881  }
882 }
883 
885 {
886  int64_t hours, minutes, seconds;
887  int64_t time;
888 
889  put_bits(&s->pb, 16, 0);
890  put_bits(&s->pb, 16, GOP_STARTCODE);
891 
892  time = s->current_picture_ptr->f->pts;
893  if (s->reordered_input_picture[1])
894  time = FFMIN(time, s->reordered_input_picture[1]->f->pts);
895  time = time * s->avctx->time_base.num;
896  s->last_time_base = FFUDIV(time, s->avctx->time_base.den);
897 
898  seconds = FFUDIV(time, s->avctx->time_base.den);
899  minutes = FFUDIV(seconds, 60); seconds = FFUMOD(seconds, 60);
900  hours = FFUDIV(minutes, 60); minutes = FFUMOD(minutes, 60);
901  hours = FFUMOD(hours , 24);
902 
903  put_bits(&s->pb, 5, hours);
904  put_bits(&s->pb, 6, minutes);
905  put_bits(&s->pb, 1, 1);
906  put_bits(&s->pb, 6, seconds);
907 
908  put_bits(&s->pb, 1, !!(s->avctx->flags & AV_CODEC_FLAG_CLOSED_GOP));
909  put_bits(&s->pb, 1, 0); // broken link == NO
910 
911  ff_mpeg4_stuffing(&s->pb);
912 }
913 
915 {
916  int profile_and_level_indication;
917  int vo_ver_id;
918 
919  if (s->avctx->profile != FF_PROFILE_UNKNOWN) {
920  profile_and_level_indication = s->avctx->profile << 4;
921  } else if (s->max_b_frames || s->quarter_sample) {
922  profile_and_level_indication = 0xF0; // adv simple
923  } else {
924  profile_and_level_indication = 0x00; // simple
925  }
926 
927  if (s->avctx->level != FF_LEVEL_UNKNOWN)
928  profile_and_level_indication |= s->avctx->level;
929  else
930  profile_and_level_indication |= 1; // level 1
931 
932  if (profile_and_level_indication >> 4 == 0xF)
933  vo_ver_id = 5;
934  else
935  vo_ver_id = 1;
936 
937  // FIXME levels
938 
939  put_bits(&s->pb, 16, 0);
940  put_bits(&s->pb, 16, VOS_STARTCODE);
941 
942  put_bits(&s->pb, 8, profile_and_level_indication);
943 
944  put_bits(&s->pb, 16, 0);
945  put_bits(&s->pb, 16, VISUAL_OBJ_STARTCODE);
946 
947  put_bits(&s->pb, 1, 1);
948  put_bits(&s->pb, 4, vo_ver_id);
949  put_bits(&s->pb, 3, 1); // priority
950 
951  put_bits(&s->pb, 4, 1); // visual obj type== video obj
952 
953  put_bits(&s->pb, 1, 0); // video signal type == no clue // FIXME
954 
955  ff_mpeg4_stuffing(&s->pb);
956 }
957 
959  int vo_number,
960  int vol_number)
961 {
962  int vo_ver_id;
963 
964  if (s->max_b_frames || s->quarter_sample) {
965  vo_ver_id = 5;
967  } else {
968  vo_ver_id = 1;
969  s->vo_type = SIMPLE_VO_TYPE;
970  }
971 
972  put_bits(&s->pb, 16, 0);
973  put_bits(&s->pb, 16, 0x100 + vo_number); /* video obj */
974  put_bits(&s->pb, 16, 0);
975  put_bits(&s->pb, 16, 0x120 + vol_number); /* video obj layer */
976 
977  put_bits(&s->pb, 1, 0); /* random access vol */
978  put_bits(&s->pb, 8, s->vo_type); /* video obj type indication */
979  if (s->workaround_bugs & FF_BUG_MS) {
980  put_bits(&s->pb, 1, 0); /* is obj layer id= no */
981  } else {
982  put_bits(&s->pb, 1, 1); /* is obj layer id= yes */
983  put_bits(&s->pb, 4, vo_ver_id); /* is obj layer ver id */
984  put_bits(&s->pb, 3, 1); /* is obj layer priority */
985  }
986 
988 
989  put_bits(&s->pb, 4, s->aspect_ratio_info); /* aspect ratio info */
993  put_bits(&s->pb, 8, s->avctx->sample_aspect_ratio.num);
994  put_bits(&s->pb, 8, s->avctx->sample_aspect_ratio.den);
995  }
996 
997  if (s->workaround_bugs & FF_BUG_MS) {
998  put_bits(&s->pb, 1, 0); /* vol control parameters= no @@@ */
999  } else {
1000  put_bits(&s->pb, 1, 1); /* vol control parameters= yes */
1001  put_bits(&s->pb, 2, 1); /* chroma format YUV 420/YV12 */
1002  put_bits(&s->pb, 1, s->low_delay);
1003  put_bits(&s->pb, 1, 0); /* vbv parameters= no */
1004  }
1005 
1006  put_bits(&s->pb, 2, RECT_SHAPE); /* vol shape= rectangle */
1007  put_bits(&s->pb, 1, 1); /* marker bit */
1008 
1009  put_bits(&s->pb, 16, s->avctx->time_base.den);
1010  if (s->time_increment_bits < 1)
1011  s->time_increment_bits = 1;
1012  put_bits(&s->pb, 1, 1); /* marker bit */
1013  put_bits(&s->pb, 1, 0); /* fixed vop rate=no */
1014  put_bits(&s->pb, 1, 1); /* marker bit */
1015  put_bits(&s->pb, 13, s->width); /* vol width */
1016  put_bits(&s->pb, 1, 1); /* marker bit */
1017  put_bits(&s->pb, 13, s->height); /* vol height */
1018  put_bits(&s->pb, 1, 1); /* marker bit */
1019  put_bits(&s->pb, 1, s->progressive_sequence ? 0 : 1);
1020  put_bits(&s->pb, 1, 1); /* obmc disable */
1021  if (vo_ver_id == 1)
1022  put_bits(&s->pb, 1, 0); /* sprite enable */
1023  else
1024  put_bits(&s->pb, 2, 0); /* sprite enable */
1025 
1026  put_bits(&s->pb, 1, 0); /* not 8 bit == false */
1027  put_bits(&s->pb, 1, s->mpeg_quant); /* quant type = (0 = H.263 style) */
1028 
1029  if (s->mpeg_quant) {
1032  }
1033 
1034  if (vo_ver_id != 1)
1035  put_bits(&s->pb, 1, s->quarter_sample);
1036  put_bits(&s->pb, 1, 1); /* complexity estimation disable */
1037  put_bits(&s->pb, 1, s->rtp_mode ? 0 : 1); /* resync marker disable */
1038  put_bits(&s->pb, 1, s->data_partitioning ? 1 : 0);
1039  if (s->data_partitioning)
1040  put_bits(&s->pb, 1, 0); /* no rvlc */
1041 
1042  if (vo_ver_id != 1) {
1043  put_bits(&s->pb, 1, 0); /* newpred */
1044  put_bits(&s->pb, 1, 0); /* reduced res vop */
1045  }
1046  put_bits(&s->pb, 1, 0); /* scalability */
1047 
1048  ff_mpeg4_stuffing(&s->pb);
1049 
1050  /* user data */
1051  if (!(s->avctx->flags & AV_CODEC_FLAG_BITEXACT)) {
1052  put_bits(&s->pb, 16, 0);
1053  put_bits(&s->pb, 16, 0x1B2); /* user_data */
1055  }
1056 }
1057 
1058 /* write MPEG-4 VOP header */
1060 {
1061  uint64_t time_incr;
1062  int64_t time_div, time_mod;
1063 
1064  if (s->pict_type == AV_PICTURE_TYPE_I) {
1065  if (!(s->avctx->flags & AV_CODEC_FLAG_GLOBAL_HEADER)) {
1066  if (s->strict_std_compliance < FF_COMPLIANCE_VERY_STRICT) // HACK, the reference sw is buggy
1068  if (s->strict_std_compliance < FF_COMPLIANCE_VERY_STRICT || picture_number == 0) // HACK, the reference sw is buggy
1069  mpeg4_encode_vol_header(s, 0, 0);
1070  }
1071  if (!(s->workaround_bugs & FF_BUG_MS))
1073  }
1074 
1076 
1077  put_bits(&s->pb, 16, 0); /* vop header */
1078  put_bits(&s->pb, 16, VOP_STARTCODE); /* vop header */
1079  put_bits(&s->pb, 2, s->pict_type - 1); /* pict type: I = 0 , P = 1 */
1080 
1081  time_div = FFUDIV(s->time, s->avctx->time_base.den);
1082  time_mod = FFUMOD(s->time, s->avctx->time_base.den);
1083  time_incr = time_div - s->last_time_base;
1084 
1085  // This limits the frame duration to max 1 hour
1086  if (time_incr > 3600) {
1087  av_log(s->avctx, AV_LOG_ERROR, "time_incr %"PRIu64" too large\n", time_incr);
1088  return AVERROR(EINVAL);
1089  }
1090  while (time_incr--)
1091  put_bits(&s->pb, 1, 1);
1092 
1093  put_bits(&s->pb, 1, 0);
1094 
1095  put_bits(&s->pb, 1, 1); /* marker */
1096  put_bits(&s->pb, s->time_increment_bits, time_mod); /* time increment */
1097  put_bits(&s->pb, 1, 1); /* marker */
1098  put_bits(&s->pb, 1, 1); /* vop coded */
1099  if (s->pict_type == AV_PICTURE_TYPE_P) {
1100  put_bits(&s->pb, 1, s->no_rounding); /* rounding type */
1101  }
1102  put_bits(&s->pb, 3, 0); /* intra dc VLC threshold */
1103  if (!s->progressive_sequence) {
1105  put_bits(&s->pb, 1, s->alternate_scan);
1106  }
1107  // FIXME sprite stuff
1108 
1109  put_bits(&s->pb, 5, s->qscale);
1110 
1111  if (s->pict_type != AV_PICTURE_TYPE_I)
1112  put_bits(&s->pb, 3, s->f_code); /* fcode_for */
1113  if (s->pict_type == AV_PICTURE_TYPE_B)
1114  put_bits(&s->pb, 3, s->b_code); /* fcode_back */
1115 
1116  return 0;
1117 }
1118 
1119 static av_cold void init_uni_dc_tab(void)
1120 {
1121  int level, uni_code, uni_len;
1122 
1123  for (level = -256; level < 256; level++) {
1124  int size, v, l;
1125  /* find number of bits */
1126  size = 0;
1127  v = abs(level);
1128  while (v) {
1129  v >>= 1;
1130  size++;
1131  }
1132 
1133  if (level < 0)
1134  l = (-level) ^ ((1 << size) - 1);
1135  else
1136  l = level;
1137 
1138  /* luminance */
1139  uni_code = ff_mpeg4_DCtab_lum[size][0];
1140  uni_len = ff_mpeg4_DCtab_lum[size][1];
1141 
1142  if (size > 0) {
1143  uni_code <<= size;
1144  uni_code |= l;
1145  uni_len += size;
1146  if (size > 8) {
1147  uni_code <<= 1;
1148  uni_code |= 1;
1149  uni_len++;
1150  }
1151  }
1152  uni_DCtab_lum_bits[level + 256] = uni_code;
1153  uni_DCtab_lum_len[level + 256] = uni_len;
1154 
1155  /* chrominance */
1156  uni_code = ff_mpeg4_DCtab_chrom[size][0];
1157  uni_len = ff_mpeg4_DCtab_chrom[size][1];
1158 
1159  if (size > 0) {
1160  uni_code <<= size;
1161  uni_code |= l;
1162  uni_len += size;
1163  if (size > 8) {
1164  uni_code <<= 1;
1165  uni_code |= 1;
1166  uni_len++;
1167  }
1168  }
1169  uni_DCtab_chrom_bits[level + 256] = uni_code;
1170  uni_DCtab_chrom_len[level + 256] = uni_len;
1171  }
1172 }
1173 
1174 static av_cold void init_uni_mpeg4_rl_tab(RLTable *rl, uint32_t *bits_tab,
1175  uint8_t *len_tab)
1176 {
1177  int slevel, run, last;
1178 
1179  av_assert0(MAX_LEVEL >= 64);
1180  av_assert0(MAX_RUN >= 63);
1181 
1182  for (slevel = -64; slevel < 64; slevel++) {
1183  if (slevel == 0)
1184  continue;
1185  for (run = 0; run < 64; run++) {
1186  for (last = 0; last <= 1; last++) {
1187  const int index = UNI_MPEG4_ENC_INDEX(last, run, slevel + 64);
1188  int level = slevel < 0 ? -slevel : slevel;
1189  int sign = slevel < 0 ? 1 : 0;
1190  int bits, len, code;
1191  int level1, run1;
1192 
1193  len_tab[index] = 100;
1194 
1195  /* ESC0 */
1196  code = get_rl_index(rl, last, run, level);
1197  bits = rl->table_vlc[code][0];
1198  len = rl->table_vlc[code][1];
1199  bits = bits * 2 + sign;
1200  len++;
1201 
1202  if (code != rl->n && len < len_tab[index]) {
1203  bits_tab[index] = bits;
1204  len_tab[index] = len;
1205  }
1206  /* ESC1 */
1207  bits = rl->table_vlc[rl->n][0];
1208  len = rl->table_vlc[rl->n][1];
1209  bits = bits * 2;
1210  len++; // esc1
1211  level1 = level - rl->max_level[last][run];
1212  if (level1 > 0) {
1213  code = get_rl_index(rl, last, run, level1);
1214  bits <<= rl->table_vlc[code][1];
1215  len += rl->table_vlc[code][1];
1216  bits += rl->table_vlc[code][0];
1217  bits = bits * 2 + sign;
1218  len++;
1219 
1220  if (code != rl->n && len < len_tab[index]) {
1221  bits_tab[index] = bits;
1222  len_tab[index] = len;
1223  }
1224  }
1225  /* ESC2 */
1226  bits = rl->table_vlc[rl->n][0];
1227  len = rl->table_vlc[rl->n][1];
1228  bits = bits * 4 + 2;
1229  len += 2; // esc2
1230  run1 = run - rl->max_run[last][level] - 1;
1231  if (run1 >= 0) {
1232  code = get_rl_index(rl, last, run1, level);
1233  bits <<= rl->table_vlc[code][1];
1234  len += rl->table_vlc[code][1];
1235  bits += rl->table_vlc[code][0];
1236  bits = bits * 2 + sign;
1237  len++;
1238 
1239  if (code != rl->n && len < len_tab[index]) {
1240  bits_tab[index] = bits;
1241  len_tab[index] = len;
1242  }
1243  }
1244  /* ESC3 */
1245  bits = rl->table_vlc[rl->n][0];
1246  len = rl->table_vlc[rl->n][1];
1247  bits = bits * 4 + 3;
1248  len += 2; // esc3
1249  bits = bits * 2 + last;
1250  len++;
1251  bits = bits * 64 + run;
1252  len += 6;
1253  bits = bits * 2 + 1;
1254  len++; // marker
1255  bits = bits * 4096 + (slevel & 0xfff);
1256  len += 12;
1257  bits = bits * 2 + 1;
1258  len++; // marker
1259 
1260  if (len < len_tab[index]) {
1261  bits_tab[index] = bits;
1262  len_tab[index] = len;
1263  }
1264  }
1265  }
1266  }
1267 }
1268 
1270 {
1271  MpegEncContext *s = avctx->priv_data;
1272  int ret;
1273  static int done = 0;
1274 
1275  if (avctx->width >= (1<<13) || avctx->height >= (1<<13)) {
1276  av_log(avctx, AV_LOG_ERROR, "dimensions too large for MPEG-4\n");
1277  return AVERROR(EINVAL);
1278  }
1279 
1280  if ((ret = ff_mpv_encode_init(avctx)) < 0)
1281  return ret;
1282 
1283  if (!done) {
1284  done = 1;
1285 
1286  init_uni_dc_tab();
1287 
1289 
1292  }
1293 
1294  s->min_qcoeff = -2048;
1295  s->max_qcoeff = 2047;
1301  s->ac_esc_length = 7 + 2 + 1 + 6 + 1 + 12 + 1;
1304 
1306  s->avctx->extradata = av_malloc(1024);
1307  if (!s->avctx->extradata)
1308  return AVERROR(ENOMEM);
1309  init_put_bits(&s->pb, s->avctx->extradata, 1024);
1310 
1311  if (!(s->workaround_bugs & FF_BUG_MS))
1313  mpeg4_encode_vol_header(s, 0, 0);
1314 
1315 // ff_mpeg4_stuffing(&s->pb); ?
1316  flush_put_bits(&s->pb);
1318  }
1319  return 0;
1320 }
1321 
1323 {
1324  uint8_t *start = put_bits_ptr(&s->pb);
1325  uint8_t *end = s->pb.buf_end;
1326  int size = end - start;
1327  int pb_size = (((intptr_t)start + size / 3) & (~3)) - (intptr_t)start;
1328  int tex_size = (size - 2 * pb_size) & (~3);
1329 
1330  set_put_bits_buffer_size(&s->pb, pb_size);
1331  init_put_bits(&s->tex_pb, start + pb_size, tex_size);
1332  init_put_bits(&s->pb2, start + pb_size + tex_size, pb_size);
1333 }
1334 
1336 {
1337  const int pb2_len = put_bits_count(&s->pb2);
1338  const int tex_pb_len = put_bits_count(&s->tex_pb);
1339  const int bits = put_bits_count(&s->pb);
1340 
1341  if (s->pict_type == AV_PICTURE_TYPE_I) {
1342  put_bits(&s->pb, 19, DC_MARKER);
1343  s->misc_bits += 19 + pb2_len + bits - s->last_bits;
1344  s->i_tex_bits += tex_pb_len;
1345  } else {
1346  put_bits(&s->pb, 17, MOTION_MARKER);
1347  s->misc_bits += 17 + pb2_len;
1348  s->mv_bits += bits - s->last_bits;
1349  s->p_tex_bits += tex_pb_len;
1350  }
1351 
1352  flush_put_bits(&s->pb2);
1353  flush_put_bits(&s->tex_pb);
1354 
1355  set_put_bits_buffer_size(&s->pb, s->pb2.buf_end - s->pb.buf);
1356  ff_copy_bits(&s->pb, s->pb2.buf, pb2_len);
1357  ff_copy_bits(&s->pb, s->tex_pb.buf, tex_pb_len);
1358  s->last_bits = put_bits_count(&s->pb);
1359 }
1360 
1362 {
1363  int mb_num_bits = av_log2(s->mb_num - 1) + 1;
1364 
1366  put_bits(&s->pb, 1, 1);
1367 
1368  put_bits(&s->pb, mb_num_bits, s->mb_x + s->mb_y * s->mb_width);
1369  put_bits(&s->pb, s->quant_precision, s->qscale);
1370  put_bits(&s->pb, 1, 0); /* no HEC */
1371 }
1372 
1373 #define OFFSET(x) offsetof(MpegEncContext, x)
1374 #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
1375 static const AVOption options[] = {
1376  { "data_partitioning", "Use data partitioning.", OFFSET(data_partitioning), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, VE },
1377  { "alternate_scan", "Enable alternate scantable.", OFFSET(alternate_scan), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, VE },
1378  { "mpeg_quant", "Use MPEG quantizers instead of H.263",
1379  OFFSET(mpeg_quant), AV_OPT_TYPE_INT, {.i64 = 0 }, 0, 1, VE },
1382 #if FF_API_MPEGVIDEO_OPTS
1385 #endif
1387  { NULL },
1388 };
1389 
1390 static const AVClass mpeg4enc_class = {
1391  .class_name = "MPEG4 encoder",
1392  .item_name = av_default_item_name,
1393  .option = options,
1394  .version = LIBAVUTIL_VERSION_INT,
1395 };
1396 
1398  .name = "mpeg4",
1399  .long_name = NULL_IF_CONFIG_SMALL("MPEG-4 part 2"),
1400  .type = AVMEDIA_TYPE_VIDEO,
1401  .id = AV_CODEC_ID_MPEG4,
1402  .priv_data_size = sizeof(MpegEncContext),
1403  .init = encode_init,
1404  .encode2 = ff_mpv_encode_picture,
1405  .close = ff_mpv_encode_end,
1408  .caps_internal = FF_CODEC_CAP_INIT_CLEANUP,
1409  .priv_class = &mpeg4enc_class,
1410 };
int last_time_base
Definition: mpegvideo.h:390
#define FF_CODEC_CAP_INIT_CLEANUP
The codec allows calling the close function for deallocation even if the init function returned a fai...
Definition: internal.h:49
static void mpeg4_encode_visual_object_header(MpegEncContext *s)
#define INPLACE_OFFSET
Definition: mpegutils.h:121
IDCTDSPContext idsp
Definition: mpegvideo.h:230
#define NULL
Definition: coverity.c:32
int aspect_ratio_info
Definition: mpegvideo.h:404
ScanTable intra_v_scantable
Definition: mpegvideo.h:93
RLTable ff_mpeg4_rl_intra
Definition: mpeg4data.h:109
const uint8_t ff_mpeg4_c_dc_scale_table[32]
Definition: mpeg4data.h:361
int time_increment_bits
Definition: mpegvideo.h:389
AVOption.
Definition: opt.h:248
#define MV_TYPE_FIELD
2 vectors, one per field
Definition: mpegvideo.h:269
static uint8_t uni_mpeg4_intra_rl_len[64 *64 *2 *2]
Definition: mpeg4videoenc.c:43
const uint8_t * y_dc_scale_table
qscale -> y_dc_scale table
Definition: mpegvideo.h:188
#define FF_MPV_DEPRECATED_A53_CC_OPT
Definition: mpegvideo.h:685
static void mpeg4_encode_block(MpegEncContext *s, int16_t *block, int n, int intra_dc, uint8_t *scan_table, PutBitContext *dc_pb, PutBitContext *ac_pb)
Encode an 8x8 block.
int last_mv[2][2][2]
last MV, used for MV prediction in MPEG-1 & B-frame MPEG-4
Definition: mpegvideo.h:278
static void put_bits(Jpeg2000EncoderContext *s, int val, int n)
put n times val bit
Definition: j2kenc.c:218
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
void ff_clean_mpeg4_qscales(MpegEncContext *s)
modify mb_type & qscale so that encoding is actually possible in MPEG-4
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:31
int16_t(*[3] ac_val)[16]
used for MPEG-4 AC prediction, all 3 arrays must be continuous
Definition: mpegvideo.h:194
void(* clear_block)(int16_t *block)
Definition: blockdsp.h:36
static int get_block_rate(MpegEncContext *s, int16_t block[64], int block_last_index, uint8_t scantable[64])
Return the number of bits that encoding the 8x8 block in block would need.
Definition: mpeg4videoenc.c:65
#define FF_COMPLIANCE_VERY_STRICT
Strictly conform to an older more strict version of the spec or reference software.
Definition: avcodec.h:1602
#define FF_MPV_COMMON_OPTS
Definition: mpegvideo.h:629
int num
Numerator.
Definition: rational.h:59
#define CANDIDATE_MB_TYPE_BIDIR
Definition: mpegutils.h:112
static void skip_put_bits(PutBitContext *s, int n)
Skip the given number of bits.
Definition: put_bits.h:401
const char * av_default_item_name(void *ptr)
Return the context name.
Definition: log.c:235
int av_log2(unsigned v)
Definition: intmath.c:26
AVRational sample_aspect_ratio
sample aspect ratio (0 if unknown) That is the width of a pixel divided by the height of the pixel...
Definition: avcodec.h:915
int min_qcoeff
minimum encodable coefficient
Definition: mpegvideo.h:308
int coded_score[12]
Definition: mpegvideo.h:320
mpegvideo header.
static uint32_t uni_mpeg4_intra_rl_bits[64 *64 *2 *2]
Definition: mpeg4videoenc.c:42
#define DC_MARKER
Definition: mpeg4video.h:59
int mpv_flags
flags set by private options
Definition: mpegvideo.h:546
uint8_t permutated[64]
Definition: idctdsp.h:33
uint8_t run
Definition: svq3.c:203
uint8_t * intra_ac_vlc_length
Definition: mpegvideo.h:311
#define UNI_AC_ENC_INDEX(run, level)
Definition: mpegvideo.h:318
int mb_num
number of MBs of a picture
Definition: mpegvideo.h:133
fg index
int profile
profile
Definition: avcodec.h:1858
#define FF_LAMBDA_SHIFT
Definition: avutil.h:225
AVCodec.
Definition: codec.h:197
int time_base
time in seconds of last I,P,S Frame
Definition: mpegvideo.h:391
RLTable.
Definition: rl.h:39
int qscale
QP.
Definition: mpegvideo.h:204
int16_t * ff_h263_pred_motion(MpegEncContext *s, int block, int dir, int *px, int *py)
Definition: h263.c:307
static av_cold void init_uni_dc_tab(void)
int field_select[2][2]
Definition: mpegvideo.h:277
int block_wrap[6]
Definition: mpegvideo.h:294
Macro definitions for various function/variable attributes.
int quant_precision
Definition: mpegvideo.h:402
AVRational time_base
This is the fundamental unit of time (in seconds) in terms of which frame timestamps are represented...
Definition: avcodec.h:659
#define FF_BUG_MS
Work around various bugs in Microsoft&#39;s broken decoders.
Definition: avcodec.h:1585
#define FF_MPV_FLAG_CBP_RD
Definition: mpegvideo.h:596
#define FF_LEVEL_UNKNOWN
Definition: avcodec.h:1985
void ff_mpeg4_stuffing(PutBitContext *pbc)
add MPEG-4 stuffing bits (01...1)
const char * class_name
The name of the class; usually it is the same name as the context structure type to which the AVClass...
Definition: log.h:72
#define AV_CODEC_CAP_DELAY
Encoder or decoder requires flushing with NULL input at the end in order to give the complete and cor...
Definition: codec.h:77
static uint8_t uni_DCtab_chrom_len[512]
Definition: mpeg4videoenc.c:36
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
int8_t * max_run[2]
encoding & decoding
Definition: rl.h:47
int64_t time
time of current frame
Definition: mpegvideo.h:392
#define MV_DIRECT
bidirectional mode where the difference equals the MV of the last P/S/I-Frame (MPEG-4) ...
Definition: mpegvideo.h:264
The exact code depends on how similar the blocks are and how related they are to the block
uint8_t
#define av_cold
Definition: attributes.h:88
#define av_malloc(s)
#define av_assert2(cond)
assert() equivalent, that does lie in speed critical code.
Definition: avassert.h:64
AVOptions.
PutBitContext pb2
used for data partitioned VOPs
Definition: mpegvideo.h:411
#define VOP_STARTCODE
Definition: mpeg4video.h:65
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf offset
void ff_copy_bits(PutBitContext *pb, const uint8_t *src, int length)
Copy the content of src to the bitstream.
Definition: bitstream.c:69
static int decide_ac_pred(MpegEncContext *s, int16_t block[6][64], const int dir[6], uint8_t *st[6], int zigzag_last_index[6])
Return the optimal value (0 or 1) for the ac_pred element for the given MB in MPEG-4.
int64_t pts
Presentation timestamp in time_base units (time when frame should be shown to user).
Definition: frame.h:411
int misc_bits
cbp, mb_type
Definition: mpegvideo.h:352
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
Definition: avcodec.h:637
int no_rounding
apply no rounding to motion compensation (MPEG-4, msmpeg4, ...) for B-frames rounding mode is always ...
Definition: mpegvideo.h:284
int interlaced_dct
Definition: mpegvideo.h:496
Picture current_picture
copy of the current picture structure.
Definition: mpegvideo.h:180
const uint8_t ff_mpeg4_DCtab_chrom[13][2]
Definition: mpeg4data.h:41
#define RECT_SHAPE
Definition: mpeg4video.h:33
int8_t * max_level[2]
encoding & decoding
Definition: rl.h:46
const uint8_t ff_h263_intra_MCBPC_bits[9]
Definition: h263data.c:35
ptrdiff_t size
Definition: opengl_enc.c:100
int av_reduce(int *dst_num, int *dst_den, int64_t num, int64_t den, int64_t max)
Reduce a fraction.
Definition: rational.c:35
int max_qcoeff
maximum encodable coefficient
Definition: mpegvideo.h:309
static const int dquant_code[5]
#define MAX_LEVEL
Definition: rl.h:36
static uint32_t uni_mpeg4_inter_rl_bits[64 *64 *2 *2]
Definition: mpeg4videoenc.c:44
static int ff_mpeg4_pred_dc(MpegEncContext *s, int n, int level, int *dir_ptr, int encoding)
Predict the dc.
Definition: mpeg4video.h:198
int dquant
qscale difference to prev qscale
Definition: mpegvideo.h:210
#define av_log(a,...)
#define MOTION_MARKER
Definition: mpeg4video.h:58
#define UNI_MPEG4_ENC_INDEX(last, run, level)
Definition: mpeg4videoenc.c:49
#define ROUNDED_DIV(a, b)
Definition: common.h:56
static void mpeg4_encode_gop_header(MpegEncContext *s)
static int get_bits_diff(MpegEncContext *s)
Definition: mpegvideo.h:777
void ff_mpeg4_init_partitions(MpegEncContext *s)
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:194
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:379
uint8_t * mbskip_table
Definition: mpegpicture.h:59
const uint8_t ff_h263_inter_MCBPC_code[28]
Definition: h263data.c:40
static void restore_ac_coeffs(MpegEncContext *s, int16_t block[6][64], const int dir[6], uint8_t *st[6], const int zigzag_last_index[6])
Restore the ac coefficients in block that have been changed by decide_ac_pred().
uint8_t * inter_ac_vlc_last_length
Definition: mpegvideo.h:316
void ff_mpeg4_merge_partitions(MpegEncContext *s)
int mb_skipped
MUST BE SET only during DECODING.
Definition: mpegvideo.h:195
int strict_std_compliance
strictly follow the std (MPEG-4, ...)
Definition: mpegvideo.h:118
int partitioned_frame
is current frame partitioned
Definition: mpegvideo.h:407
int ff_mpeg4_encode_picture_header(MpegEncContext *s, int picture_number)
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:117
void ff_mpeg4_encode_mb(MpegEncContext *s, int16_t block[6][64], int motion_x, int motion_y)
int flags
AV_CODEC_FLAG_*.
Definition: avcodec.h:616
#define SIMPLE_VO_TYPE
Definition: mpeg4video.h:38
uint8_t * buf
Definition: put_bits.h:54
GLsizei GLsizei * length
Definition: opengl_enc.c:114
void ff_mpeg4_init_direct_mv(MpegEncContext *s)
Definition: mpeg4video.c:71
const char * name
Name of the codec implementation.
Definition: codec.h:204
uint8_t bits
Definition: vp3data.h:141
int quarter_sample
1->qpel, 0->half pel ME/MC
Definition: mpegvideo.h:403
uint16_t * mb_type
Table for candidate MB types for encoding (defines in mpegutils.h)
Definition: mpegvideo.h:291
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
int low_delay
no reordering needed / has no B-frames
Definition: mpegvideo.h:408
static av_cold void init_uni_mpeg4_rl_tab(RLTable *rl, uint32_t *bits_tab, uint8_t *len_tab)
static int put_bits_count(PutBitContext *s)
Definition: put_bits.h:84
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
uint8_t * intra_ac_vlc_last_length
Definition: mpegvideo.h:312
#define ADV_SIMPLE_VO_TYPE
Definition: mpeg4video.h:46
const uint8_t ff_mpeg4_DCtab_lum[13][2]
Definition: mpeg4data.h:35
uint8_t ff_mpeg4_static_rl_table_store[3][2][2 *MAX_RUN+MAX_LEVEL+3]
Definition: mpeg4video.c:28
int n
number of entries of table_vlc minus 1
Definition: rl.h:40
const uint8_t ff_h263_inter_MCBPC_bits[28]
Definition: h263data.c:49
enum AVPictureType pict_type
Picture type of the frame.
Definition: frame.h:401
#define AV_CODEC_FLAG_BITEXACT
Use only bitexact stuff (except (I)DCT).
Definition: avcodec.h:333
#define FFMIN(a, b)
Definition: common.h:105
const uint8_t ff_mpeg4_y_dc_scale_table[32]
Definition: mpeg4data.h:357
const uint16_t(* table_vlc)[2]
Definition: rl.h:42
#define AV_CODEC_FLAG_AC_PRED
H.263 advanced intra coding / MPEG-4 AC prediction.
Definition: avcodec.h:338
Picture new_picture
copy of the source picture structure for encoding.
Definition: mpegvideo.h:174
static uint8_t uni_mpeg4_inter_rl_len[64 *64 *2 *2]
Definition: mpeg4videoenc.c:45
int width
picture width / height.
Definition: avcodec.h:709
int16_t(*[2] motion_val)[2]
Definition: mpegpicture.h:53
Picture * current_picture_ptr
pointer to the current picture
Definition: mpegvideo.h:184
#define FF_PROFILE_UNKNOWN
Definition: avcodec.h:1859
Picture.
Definition: mpegpicture.h:45
static const AVClass mpeg4enc_class
int alternate_scan
Definition: mpegvideo.h:476
static uint16_t uni_DCtab_lum_bits[512]
Definition: mpeg4videoenc.c:37
static uint16_t uni_DCtab_chrom_bits[512]
Definition: mpeg4videoenc.c:38
static int get_b_cbp(MpegEncContext *s, int16_t block[6][64], int motion_x, int motion_y, int mb_type)
#define AV_CODEC_FLAG_PASS1
Use internal 2pass ratecontrol in first pass mode.
Definition: avcodec.h:296
static uint8_t uni_DCtab_lum_len[512]
Definition: mpeg4videoenc.c:35
#define FFABS(a)
Absolute value, Note, INT_MIN / INT64_MIN result in undefined behavior as they are not representable ...
Definition: common.h:72
#define s(width, name)
Definition: cbs_vp9.c:257
int level
level
Definition: avcodec.h:1984
int block_last_index[12]
last non zero coefficient in block
Definition: mpegvideo.h:86
#define FF_MPEG4_PROFILE_OPTS
Definition: profiles.h:40
uint8_t idct_permutation[64]
IDCT input permutation.
Definition: idctdsp.h:96
static int put_bytes_output(const PutBitContext *s)
Definition: put_bits.h:93
int ac_esc_length
num of bits needed to encode the longest esc
Definition: mpegvideo.h:310
av_cold void ff_rl_init(RLTable *rl, uint8_t static_store[2][2 *MAX_RUN+MAX_LEVEL+3])
Definition: rl.c:28
static void set_put_bits_buffer_size(PutBitContext *s, int size)
Change the end of the buffer.
Definition: put_bits.h:413
void ff_write_quant_matrix(PutBitContext *pb, uint16_t *matrix)
int block_index[6]
index to current MB in block based arrays with edges
Definition: mpegvideo.h:293
if(ret)
int * mb_index2xy
mb_index -> mb_x + mb_y*mb_stride
Definition: mpegvideo.h:297
#define AV_CODEC_CAP_SLICE_THREADS
Codec supports slice-based (or partition-based) multithreading.
Definition: codec.h:112
#define VE
#define MV_TYPE_16X16
1 vector for the whole mb
Definition: mpegvideo.h:266
#define MV_DIR_BACKWARD
Definition: mpegvideo.h:263
#define FFUDIV(a, b)
Definition: common.h:63
uint8_t * luma_dc_vlc_length
Definition: mpegvideo.h:317
unsigned int lambda2
(lambda*lambda) >> FF_LAMBDA_SHIFT
Definition: mpegvideo.h:207
#define FF_ASPECT_EXTENDED
Definition: h263.h:30
ptrdiff_t linesize
line size, in bytes, may be different from width
Definition: mpegvideo.h:134
BlockDSPContext bdsp
Definition: mpegvideo.h:226
#define abs(x)
Definition: cuda_runtime.h:35
const uint8_t ff_h263_intra_MCBPC_code[9]
Definition: h263data.c:34
main external API structure.
Definition: avcodec.h:536
ScanTable intra_scantable
Definition: mpegvideo.h:91
int height
picture size. must be a multiple of 16
Definition: mpegvideo.h:100
uint8_t * buf_end
Definition: put_bits.h:54
int ff_mpv_encode_init(AVCodecContext *avctx)
int data_partitioning
data partitioning flag from header
Definition: mpegvideo.h:406
int extradata_size
Definition: avcodec.h:638
uint8_t * inter_ac_vlc_length
Definition: mpegvideo.h:315
int progressive_sequence
Definition: mpegvideo.h:461
uint16_t * intra_matrix
custom intra quantization matrix Must be allocated with the av_malloc() family of functions...
Definition: avcodec.h:1036
Describe the class of an AVClass context structure.
Definition: log.h:67
ScanTable intra_h_scantable
Definition: mpegvideo.h:92
#define CANDIDATE_MB_TYPE_DIRECT
Definition: mpegutils.h:109
static av_cold int encode_init(AVCodecContext *avctx)
struct AVFrame * f
Definition: mpegpicture.h:46
static int mpeg4_get_block_length(MpegEncContext *s, int16_t *block, int n, int intra_dc, uint8_t *scan_table)
static void ff_h263_encode_motion_vector(MpegEncContext *s, int x, int y, int f_code)
Definition: h263.h:118
RLTable ff_h263_rl_inter
Definition: h263data.c:161
int f_code
forward MV resolution
Definition: mpegvideo.h:238
const uint8_t ff_h263_cbpy_tab[16][2]
Definition: h263data.c:84
uint16_t * inter_matrix
custom inter quantization matrix Must be allocated with the av_malloc() family of functions...
Definition: avcodec.h:1045
#define MV_DIR_FORWARD
Definition: mpegvideo.h:262
int max_b_frames
max number of B-frames for encoding
Definition: mpegvideo.h:115
int pict_type
AV_PICTURE_TYPE_I, AV_PICTURE_TYPE_P, AV_PICTURE_TYPE_B, ...
Definition: mpegvideo.h:212
static enum AVPixelFormat pix_fmts[]
Definition: libkvazaar.c:303
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
int ff_mpeg4_get_video_packet_prefix_length(MpegEncContext *s)
Definition: mpeg4video.c:30
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:332
const uint8_t * c_dc_scale_table
qscale -> c_dc_scale table
Definition: mpegvideo.h:189
uint8_t level
Definition: svq3.c:204
me_cmp_func sad[6]
Definition: me_cmp.h:56
#define AV_CODEC_FLAG_GLOBAL_HEADER
Place global headers in extradata instead of every keyframe.
Definition: avcodec.h:329
int mv[2][4][2]
motion vectors for a macroblock first coordinate : 0 = forward 1 = backward second " : depend...
Definition: mpegvideo.h:276
MpegEncContext.
Definition: mpegvideo.h:81
int8_t * qscale_table
Definition: mpegpicture.h:50
#define MAX_RUN
Definition: rl.h:35
struct AVCodecContext * avctx
Definition: mpegvideo.h:98
PutBitContext pb
bit output
Definition: mpegvideo.h:151
#define VISUAL_OBJ_STARTCODE
Definition: mpeg4video.h:64
void ff_put_string(PutBitContext *pb, const char *string, int terminate_string)
Put the string string in the bitstream.
Definition: bitstream.c:59
MECmpContext mecc
Definition: mpegvideo.h:231
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
Definition: pixfmt.h:66
int mb_stride
mb_width+1 used for some arrays to allow simple addressing of left & top MBs without sig11 ...
Definition: mpegvideo.h:130
static void flush_put_bits(PutBitContext *s)
Pad the end of the output stream with zeros.
Definition: put_bits.h:147
int shared
Definition: mpegpicture.h:89
#define AV_CODEC_FLAG2_NO_OUTPUT
Skip bitstream encoding.
Definition: avcodec.h:352
Bi-dir predicted.
Definition: avutil.h:276
static const AVOption options[]
static void init_put_bits(PutBitContext *s, uint8_t *buffer, int buffer_size)
Initialize the PutBitContext s.
Definition: put_bits.h:66
int den
Denominator.
Definition: rational.h:60
int ff_mpv_encode_end(AVCodecContext *avctx)
static int get_rl_index(const RLTable *rl, int last, int run, int level)
Definition: rl.h:79
void ff_mpeg4_encode_video_packet_header(MpegEncContext *s)
void * priv_data
Definition: avcodec.h:563
int last_bits
temp var used for calculating the above vars
Definition: mpegvideo.h:353
static av_always_inline int diff(const uint32_t a, const uint32_t b)
int top_field_first
If the content is interlaced, is top field displayed first.
Definition: frame.h:470
int len
#define FFUMOD(a, b)
Definition: common.h:64
int16_t(* block)[64]
points to one of the following blocks
Definition: mpegvideo.h:513
PutBitContext tex_pb
used for data partitioned VOPs
Definition: mpegvideo.h:410
Picture next_picture
copy of the next picture structure.
Definition: mpegvideo.h:168
static int get_p_cbp(MpegEncContext *s, int16_t block[6][64], int motion_x, int motion_y)
Definition: h263.h:129
Picture ** reordered_input_picture
pointer to the next pictures in coded order for encoding
Definition: mpegvideo.h:138
int flags2
AV_CODEC_FLAG2_*.
Definition: avcodec.h:623
#define LIBAVCODEC_IDENT
Definition: version.h:42
int workaround_bugs
workaround bugs in encoders which cannot be detected automatically
Definition: mpegvideo.h:119
#define FF_MPV_DEPRECATED_MATRIX_OPT
Definition: mpegvideo.h:687
static int mpeg4_get_dc_length(int level, int n)
void ff_set_mpeg4_time(MpegEncContext *s)
#define FF_MPV_COMMON_BFRAME_OPTS
Definition: mpegvideo.h:677
#define AV_CODEC_FLAG_CLOSED_GOP
Definition: avcodec.h:343
static void mpeg4_encode_blocks(MpegEncContext *s, int16_t block[6][64], int intra_dc[6], uint8_t **scan_table, PutBitContext *dc_pb, PutBitContext *ac_pb)
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later.That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another.Frame references ownership and permissions
#define MV_TYPE_8X8
4 vectors (H.263, MPEG-4 4MV)
Definition: mpegvideo.h:267
int b_code
backward MV resolution for B-frames (MPEG-4)
Definition: mpegvideo.h:239
int ff_mpv_encode_picture(AVCodecContext *avctx, AVPacket *pkt, const AVFrame *frame, int *got_packet)
static void mpeg4_encode_dc(PutBitContext *s, int level, int n)
Encode the dc value.
AVPixelFormat
Pixel format.
Definition: pixfmt.h:64
static void mpeg4_encode_vol_header(MpegEncContext *s, int vo_number, int vol_number)
#define OFFSET(x)
AVCodec ff_mpeg4_encoder
int i
Definition: input.c:407
Predicted.
Definition: avutil.h:275
#define GOP_STARTCODE
Definition: mpeg4video.h:63
#define VOS_STARTCODE
Definition: mpeg4video.h:61