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