3 * Copyright (c) 2000,2001 Fabrice Bellard
4 * Copyright (c) 2002-2010 Michael Niedermayer <michaelni@gmx.at>
6 * This file is part of FFmpeg.
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.
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.
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
23 #include "libavutil/attributes.h"
24 #include "libavutil/log.h"
25 #include "libavutil/opt.h"
26 #include "mpegutils.h"
27 #include "mpegvideo.h"
29 #include "mpeg4video.h"
31 /* The uni_DCtab_* tables below contain unified bits+length tables to encode DC
32 * differences in mpeg4. Unified in the sense that the specification specifies
33 * this encoding in several steps. */
34 static uint8_t uni_DCtab_lum_len
[512];
35 static uint8_t uni_DCtab_chrom_len
[512];
36 static uint16_t uni_DCtab_lum_bits
[512];
37 static uint16_t uni_DCtab_chrom_bits
[512];
39 /* Unified encoding tables for run length encoding of coefficients.
40 * Unified in the sense that the specification specifies the encoding in several steps. */
41 static uint32_t uni_mpeg4_intra_rl_bits
[64 * 64 * 2 * 2];
42 static uint8_t uni_mpeg4_intra_rl_len
[64 * 64 * 2 * 2];
43 static uint32_t uni_mpeg4_inter_rl_bits
[64 * 64 * 2 * 2];
44 static uint8_t uni_mpeg4_inter_rl_len
[64 * 64 * 2 * 2];
46 //#define UNI_MPEG4_ENC_INDEX(last, run, level) ((last) * 128 + (run) * 256 + (level))
47 //#define UNI_MPEG4_ENC_INDEX(last, run, level) ((last) * 128 * 64 + (run) + (level) * 64)
48 #define UNI_MPEG4_ENC_INDEX(last, run, level) ((last) * 128 * 64 + (run) * 128 + (level))
61 * Return the number of bits that encoding the 8x8 block in block would need.
62 * @param[in] block_last_index last index in scantable order that refers to a non zero element in block.
64 static inline int get_block_rate(MpegEncContext
*s
, int16_t block
[64],
65 int block_last_index
, uint8_t scantable
[64])
71 for (j
= 1; j
<= block_last_index
; j
++) {
72 const int index
= scantable
[j
];
73 int level
= block
[index
];
76 if ((level
& (~127)) == 0) {
77 if (j
< block_last_index
)
78 rate
+= s
->intra_ac_vlc_length
[UNI_AC_ENC_INDEX(j
- last
- 1, level
)];
80 rate
+= s
->intra_ac_vlc_last_length
[UNI_AC_ENC_INDEX(j
- last
- 1, level
)];
82 rate
+= s
->ac_esc_length
;
92 * Restore the ac coefficients in block that have been changed by decide_ac_pred().
93 * This function also restores s->block_last_index.
94 * @param[in,out] block MB coefficients, these will be restored
95 * @param[in] dir ac prediction direction for each 8x8 block
96 * @param[out] st scantable for each 8x8 block
97 * @param[in] zigzag_last_index index referring to the last non zero coefficient in zigzag order
99 static inline void restore_ac_coeffs(MpegEncContext
*s
, int16_t block
[6][64],
100 const int dir
[6], uint8_t *st
[6],
101 const int zigzag_last_index
[6])
104 memcpy(s
->block_last_index
, zigzag_last_index
, sizeof(int) * 6);
106 for (n
= 0; n
< 6; n
++) {
107 int16_t *ac_val
= s
->ac_val
[0][0] + s
->block_index
[n
] * 16;
109 st
[n
] = s
->intra_scantable
.permutated
;
112 for (i
= 1; i
< 8; i
++)
113 block
[n
][s
->idsp
.idct_permutation
[i
]] = ac_val
[i
+ 8];
115 /* left prediction */
116 for (i
= 1; i
< 8; i
++)
117 block
[n
][s
->idsp
.idct_permutation
[i
<< 3]] = ac_val
[i
];
123 * Return the optimal value (0 or 1) for the ac_pred element for the given MB in mpeg4.
124 * This function will also update s->block_last_index and s->ac_val.
125 * @param[in,out] block MB coefficients, these will be updated if 1 is returned
126 * @param[in] dir ac prediction direction for each 8x8 block
127 * @param[out] st scantable for each 8x8 block
128 * @param[out] zigzag_last_index index referring to the last non zero coefficient in zigzag order
130 static inline int decide_ac_pred(MpegEncContext
*s
, int16_t block
[6][64],
131 const int dir
[6], uint8_t *st
[6],
132 int zigzag_last_index
[6])
136 int8_t *const qscale_table
= s
->current_picture
.qscale_table
;
138 memcpy(zigzag_last_index
, s
->block_last_index
, sizeof(int) * 6);
140 for (n
= 0; n
< 6; n
++) {
141 int16_t *ac_val
, *ac_val1
;
143 score
-= get_block_rate(s
, block
[n
], s
->block_last_index
[n
],
144 s
->intra_scantable
.permutated
);
146 ac_val
= s
->ac_val
[0][0] + s
->block_index
[n
] * 16;
149 const int xy
= s
->mb_x
+ s
->mb_y
* s
->mb_stride
- s
->mb_stride
;
151 ac_val
-= s
->block_wrap
[n
] * 16;
152 if (s
->mb_y
== 0 || s
->qscale
== qscale_table
[xy
] || n
== 2 || n
== 3) {
154 for (i
= 1; i
< 8; i
++) {
155 const int level
= block
[n
][s
->idsp
.idct_permutation
[i
]];
156 block
[n
][s
->idsp
.idct_permutation
[i
]] = level
- ac_val
[i
+ 8];
157 ac_val1
[i
] = block
[n
][s
->idsp
.idct_permutation
[i
<< 3]];
158 ac_val1
[i
+ 8] = level
;
161 /* different qscale, we must rescale */
162 for (i
= 1; i
< 8; i
++) {
163 const int level
= block
[n
][s
->idsp
.idct_permutation
[i
]];
164 block
[n
][s
->idsp
.idct_permutation
[i
]] = level
- ROUNDED_DIV(ac_val
[i
+ 8] * qscale_table
[xy
], s
->qscale
);
165 ac_val1
[i
] = block
[n
][s
->idsp
.idct_permutation
[i
<< 3]];
166 ac_val1
[i
+ 8] = level
;
169 st
[n
] = s
->intra_h_scantable
.permutated
;
171 const int xy
= s
->mb_x
- 1 + s
->mb_y
* s
->mb_stride
;
172 /* left prediction */
174 if (s
->mb_x
== 0 || s
->qscale
== qscale_table
[xy
] || n
== 1 || n
== 3) {
176 for (i
= 1; i
< 8; i
++) {
177 const int level
= block
[n
][s
->idsp
.idct_permutation
[i
<< 3]];
178 block
[n
][s
->idsp
.idct_permutation
[i
<< 3]] = level
- ac_val
[i
];
180 ac_val1
[i
+ 8] = block
[n
][s
->idsp
.idct_permutation
[i
]];
183 /* different qscale, we must rescale */
184 for (i
= 1; i
< 8; i
++) {
185 const int level
= block
[n
][s
->idsp
.idct_permutation
[i
<< 3]];
186 block
[n
][s
->idsp
.idct_permutation
[i
<< 3]] = level
- ROUNDED_DIV(ac_val
[i
] * qscale_table
[xy
], s
->qscale
);
188 ac_val1
[i
+ 8] = block
[n
][s
->idsp
.idct_permutation
[i
]];
191 st
[n
] = s
->intra_v_scantable
.permutated
;
194 for (i
= 63; i
> 0; i
--) // FIXME optimize
195 if (block
[n
][st
[n
][i
]])
197 s
->block_last_index
[n
] = i
;
199 score
+= get_block_rate(s
, block
[n
], s
->block_last_index
[n
], st
[n
]);
205 restore_ac_coeffs(s
, block
, dir
, st
, zigzag_last_index
);
211 * modify mb_type & qscale so that encoding is actually possible in mpeg4
213 void ff_clean_mpeg4_qscales(MpegEncContext
*s
)
216 int8_t *const qscale_table
= s
->current_picture
.qscale_table
;
218 ff_clean_h263_qscales(s
);
220 if (s
->pict_type
== AV_PICTURE_TYPE_B
) {
222 /* ok, come on, this isn't funny anymore, there's more code for
223 * handling this mpeg4 mess than for the actual adaptive quantization */
225 for (i
= 0; i
< s
->mb_num
; i
++) {
226 int mb_xy
= s
->mb_index2xy
[i
];
227 odd
+= qscale_table
[mb_xy
] & 1;
230 if (2 * odd
> s
->mb_num
)
235 for (i
= 0; i
< s
->mb_num
; i
++) {
236 int mb_xy
= s
->mb_index2xy
[i
];
237 if ((qscale_table
[mb_xy
] & 1) != odd
)
238 qscale_table
[mb_xy
]++;
239 if (qscale_table
[mb_xy
] > 31)
240 qscale_table
[mb_xy
] = 31;
243 for (i
= 1; i
< s
->mb_num
; i
++) {
244 int mb_xy
= s
->mb_index2xy
[i
];
245 if (qscale_table
[mb_xy
] != qscale_table
[s
->mb_index2xy
[i
- 1]] &&
246 (s
->mb_type
[mb_xy
] & CANDIDATE_MB_TYPE_DIRECT
)) {
247 s
->mb_type
[mb_xy
] |= CANDIDATE_MB_TYPE_BIDIR
;
254 * Encode the dc value.
255 * @param n block index (0-3 are luma, 4-5 are chroma)
257 static inline void mpeg4_encode_dc(PutBitContext
*s
, int level
, int n
)
260 /* DC will overflow if level is outside the [-255,255] range. */
264 put_bits(s
, uni_DCtab_lum_len
[level
], uni_DCtab_lum_bits
[level
]);
267 put_bits(s
, uni_DCtab_chrom_len
[level
], uni_DCtab_chrom_bits
[level
]);
271 /* find number of bits */
281 put_bits(s
, ff_mpeg4_DCtab_lum
[size
][1], ff_mpeg4_DCtab_lum
[size
][0]);
284 put_bits(s
, ff_mpeg4_DCtab_chrom
[size
][1], ff_mpeg4_DCtab_chrom
[size
][0]);
287 /* encode remaining bits */
290 level
= (-level
) ^ ((1 << size
) - 1);
291 put_bits(s
, size
, level
);
298 static inline int mpeg4_get_dc_length(int level
, int n
)
301 return uni_DCtab_lum_len
[level
+ 256];
303 return uni_DCtab_chrom_len
[level
+ 256];
307 * Encode an 8x8 block.
308 * @param n block index (0-3 are luma, 4-5 are chroma)
310 static inline void mpeg4_encode_block(MpegEncContext
*s
,
311 int16_t *block
, int n
, int intra_dc
,
312 uint8_t *scan_table
, PutBitContext
*dc_pb
,
313 PutBitContext
*ac_pb
)
315 int i
, last_non_zero
;
318 const int last_index
= s
->block_last_index
[n
];
320 if (s
->mb_intra
) { // Note gcc (3.2.1 at least) will optimize this away
321 /* mpeg4 based DC predictor */
322 mpeg4_encode_dc(dc_pb
, intra_dc
, n
);
326 bits_tab
= uni_mpeg4_intra_rl_bits
;
327 len_tab
= uni_mpeg4_intra_rl_len
;
332 bits_tab
= uni_mpeg4_inter_rl_bits
;
333 len_tab
= uni_mpeg4_inter_rl_len
;
337 last_non_zero
= i
- 1;
338 for (; i
< last_index
; i
++) {
339 int level
= block
[scan_table
[i
]];
341 int run
= i
- last_non_zero
- 1;
343 if ((level
& (~127)) == 0) {
344 const int index
= UNI_MPEG4_ENC_INDEX(0, run
, level
);
345 put_bits(ac_pb
, len_tab
[index
], bits_tab
[index
]);
348 7 + 2 + 1 + 6 + 1 + 12 + 1,
349 (3 << 23) + (3 << 21) + (0 << 20) + (run
<< 14) +
350 (1 << 13) + (((level
- 64) & 0xfff) << 1) + 1);
355 /* if (i <= last_index) */ {
356 int level
= block
[scan_table
[i
]];
357 int run
= i
- last_non_zero
- 1;
359 if ((level
& (~127)) == 0) {
360 const int index
= UNI_MPEG4_ENC_INDEX(1, run
, level
);
361 put_bits(ac_pb
, len_tab
[index
], bits_tab
[index
]);
364 7 + 2 + 1 + 6 + 1 + 12 + 1,
365 (3 << 23) + (3 << 21) + (1 << 20) + (run
<< 14) +
366 (1 << 13) + (((level
- 64) & 0xfff) << 1) + 1);
371 static int mpeg4_get_block_length(MpegEncContext
*s
,
372 int16_t *block
, int n
,
373 int intra_dc
, uint8_t *scan_table
)
375 int i
, last_non_zero
;
377 const int last_index
= s
->block_last_index
[n
];
380 if (s
->mb_intra
) { // Note gcc (3.2.1 at least) will optimize this away
381 /* mpeg4 based DC predictor */
382 len
+= mpeg4_get_dc_length(intra_dc
, n
);
386 len_tab
= uni_mpeg4_intra_rl_len
;
391 len_tab
= uni_mpeg4_inter_rl_len
;
395 last_non_zero
= i
- 1;
396 for (; i
< last_index
; i
++) {
397 int level
= block
[scan_table
[i
]];
399 int run
= i
- last_non_zero
- 1;
401 if ((level
& (~127)) == 0) {
402 const int index
= UNI_MPEG4_ENC_INDEX(0, run
, level
);
403 len
+= len_tab
[index
];
405 len
+= 7 + 2 + 1 + 6 + 1 + 12 + 1;
410 /* if (i <= last_index) */ {
411 int level
= block
[scan_table
[i
]];
412 int run
= i
- last_non_zero
- 1;
414 if ((level
& (~127)) == 0) {
415 const int index
= UNI_MPEG4_ENC_INDEX(1, run
, level
);
416 len
+= len_tab
[index
];
418 len
+= 7 + 2 + 1 + 6 + 1 + 12 + 1;
425 static inline void mpeg4_encode_blocks(MpegEncContext
*s
, int16_t block
[6][64],
426 int intra_dc
[6], uint8_t **scan_table
,
427 PutBitContext
*dc_pb
,
428 PutBitContext
*ac_pb
)
433 if (s
->flags2
& CODEC_FLAG2_NO_OUTPUT
) {
434 for (i
= 0; i
< 6; i
++)
435 skip_put_bits(&s
->pb
,
436 mpeg4_get_block_length(s
, block
[i
], i
,
437 intra_dc
[i
], scan_table
[i
]));
439 /* encode each block */
440 for (i
= 0; i
< 6; i
++)
441 mpeg4_encode_block(s
, block
[i
], i
,
442 intra_dc
[i
], scan_table
[i
], dc_pb
, ac_pb
);
445 if (s
->flags2
& CODEC_FLAG2_NO_OUTPUT
) {
446 for (i
= 0; i
< 6; i
++)
447 skip_put_bits(&s
->pb
,
448 mpeg4_get_block_length(s
, block
[i
], i
, 0,
449 s
->intra_scantable
.permutated
));
451 /* encode each block */
452 for (i
= 0; i
< 6; i
++)
453 mpeg4_encode_block(s
, block
[i
], i
, 0,
454 s
->intra_scantable
.permutated
, dc_pb
, ac_pb
);
459 static inline int get_b_cbp(MpegEncContext
*s
, int16_t block
[6][64],
460 int motion_x
, int motion_y
, int mb_type
)
464 if (s
->mpv_flags
& FF_MPV_FLAG_CBP_RD
) {
466 const int lambda
= s
->lambda2
>> (FF_LAMBDA_SHIFT
- 6);
468 for (i
= 0; i
< 6; i
++) {
469 if (s
->coded_score
[i
] < 0) {
470 score
+= s
->coded_score
[i
];
477 if ((motion_x
| motion_y
| s
->dquant
| mb_type
) == 0)
478 zero_score
-= 4; // 2 * MV + mb_type + cbp bit
480 zero_score
*= lambda
;
481 if (zero_score
<= score
)
485 for (i
= 0; i
< 6; i
++) {
486 if (s
->block_last_index
[i
] >= 0 && ((cbp
>> (5 - i
)) & 1) == 0) {
487 s
->block_last_index
[i
] = -1;
488 s
->bdsp
.clear_block(s
->block
[i
]);
492 for (i
= 0; i
< 6; i
++) {
493 if (s
->block_last_index
[i
] >= 0)
500 // FIXME this is duplicated to h263.c
501 static const int dquant_code
[5] = { 1, 0, 9, 2, 3 };
503 void ff_mpeg4_encode_mb(MpegEncContext
*s
, int16_t block
[6][64],
504 int motion_x
, int motion_y
)
506 int cbpc
, cbpy
, pred_x
, pred_y
;
507 PutBitContext
*const pb2
= s
->data_partitioning
? &s
->pb2
: &s
->pb
;
508 PutBitContext
*const tex_pb
= s
->data_partitioning
&& s
->pict_type
!= AV_PICTURE_TYPE_B
? &s
->tex_pb
: &s
->pb
;
509 PutBitContext
*const dc_pb
= s
->data_partitioning
&& s
->pict_type
!= AV_PICTURE_TYPE_I
? &s
->pb2
: &s
->pb
;
510 const int interleaved_stats
= (s
->flags
& CODEC_FLAG_PASS1
) && !s
->data_partitioning
? 1 : 0;
515 if (s
->pict_type
== AV_PICTURE_TYPE_B
) {
516 /* convert from mv_dir to type */
517 static const int mb_type_table
[8] = { -1, 3, 2, 1, -1, -1, -1, 0 };
518 int mb_type
= mb_type_table
[s
->mv_dir
];
521 for (i
= 0; i
< 2; i
++)
522 s
->last_mv
[i
][0][0] =
523 s
->last_mv
[i
][0][1] =
524 s
->last_mv
[i
][1][0] =
525 s
->last_mv
[i
][1][1] = 0;
528 av_assert2(s
->dquant
>= -2 && s
->dquant
<= 2);
529 av_assert2((s
->dquant
& 1) == 0);
530 av_assert2(mb_type
>= 0);
532 /* nothing to do if this MB was skipped in the next P Frame */
533 if (s
->next_picture
.mbskip_table
[s
->mb_y
* s
->mb_stride
+ s
->mb_x
]) { // FIXME avoid DCT & ...
539 s
->mv_dir
= MV_DIR_FORWARD
; // doesn't matter
540 s
->qscale
-= s
->dquant
;
541 // s->mb_skipped = 1;
546 cbp
= get_b_cbp(s
, block
, motion_x
, motion_y
, mb_type
);
548 if ((cbp
| motion_x
| motion_y
| mb_type
) == 0) {
549 /* direct MB with MV={0,0} */
550 av_assert2(s
->dquant
== 0);
552 put_bits(&s
->pb
, 1, 1); /* mb not coded modb1=1 */
554 if (interleaved_stats
) {
562 put_bits(&s
->pb
, 1, 0); /* mb coded modb1=0 */
563 put_bits(&s
->pb
, 1, cbp
? 0 : 1); /* modb2 */ // FIXME merge
564 put_bits(&s
->pb
, mb_type
+ 1, 1); // this table is so simple that we don't need it :)
566 put_bits(&s
->pb
, 6, cbp
);
568 if (cbp
&& mb_type
) {
570 put_bits(&s
->pb
, 2, (s
->dquant
>> 2) + 3);
572 put_bits(&s
->pb
, 1, 0);
574 s
->qscale
-= s
->dquant
;
576 if (!s
->progressive_sequence
) {
578 put_bits(&s
->pb
, 1, s
->interlaced_dct
);
579 if (mb_type
) // not direct mode
580 put_bits(&s
->pb
, 1, s
->mv_type
== MV_TYPE_FIELD
);
583 if (interleaved_stats
)
584 s
->misc_bits
+= get_bits_diff(s
);
587 av_assert2(s
->mv_dir
& MV_DIRECT
);
588 ff_h263_encode_motion_vector(s
, motion_x
, motion_y
, 1);
592 av_assert2(mb_type
> 0 && mb_type
< 4);
593 if (s
->mv_type
!= MV_TYPE_FIELD
) {
594 if (s
->mv_dir
& MV_DIR_FORWARD
) {
595 ff_h263_encode_motion_vector(s
,
596 s
->mv
[0][0][0] - s
->last_mv
[0][0][0],
597 s
->mv
[0][0][1] - s
->last_mv
[0][0][1],
599 s
->last_mv
[0][0][0] =
600 s
->last_mv
[0][1][0] = s
->mv
[0][0][0];
601 s
->last_mv
[0][0][1] =
602 s
->last_mv
[0][1][1] = s
->mv
[0][0][1];
605 if (s
->mv_dir
& MV_DIR_BACKWARD
) {
606 ff_h263_encode_motion_vector(s
,
607 s
->mv
[1][0][0] - s
->last_mv
[1][0][0],
608 s
->mv
[1][0][1] - s
->last_mv
[1][0][1],
610 s
->last_mv
[1][0][0] =
611 s
->last_mv
[1][1][0] = s
->mv
[1][0][0];
612 s
->last_mv
[1][0][1] =
613 s
->last_mv
[1][1][1] = s
->mv
[1][0][1];
617 if (s
->mv_dir
& MV_DIR_FORWARD
) {
618 put_bits(&s
->pb
, 1, s
->field_select
[0][0]);
619 put_bits(&s
->pb
, 1, s
->field_select
[0][1]);
621 if (s
->mv_dir
& MV_DIR_BACKWARD
) {
622 put_bits(&s
->pb
, 1, s
->field_select
[1][0]);
623 put_bits(&s
->pb
, 1, s
->field_select
[1][1]);
625 if (s
->mv_dir
& MV_DIR_FORWARD
) {
626 for (i
= 0; i
< 2; i
++) {
627 ff_h263_encode_motion_vector(s
,
628 s
->mv
[0][i
][0] - s
->last_mv
[0][i
][0],
629 s
->mv
[0][i
][1] - s
->last_mv
[0][i
][1] / 2,
631 s
->last_mv
[0][i
][0] = s
->mv
[0][i
][0];
632 s
->last_mv
[0][i
][1] = s
->mv
[0][i
][1] * 2;
636 if (s
->mv_dir
& MV_DIR_BACKWARD
) {
637 for (i
= 0; i
< 2; i
++) {
638 ff_h263_encode_motion_vector(s
,
639 s
->mv
[1][i
][0] - s
->last_mv
[1][i
][0],
640 s
->mv
[1][i
][1] - s
->last_mv
[1][i
][1] / 2,
642 s
->last_mv
[1][i
][0] = s
->mv
[1][i
][0];
643 s
->last_mv
[1][i
][1] = s
->mv
[1][i
][1] * 2;
650 if (interleaved_stats
)
651 s
->mv_bits
+= get_bits_diff(s
);
653 mpeg4_encode_blocks(s
, block
, NULL
, NULL
, NULL
, &s
->pb
);
655 if (interleaved_stats
)
656 s
->p_tex_bits
+= get_bits_diff(s
);
657 } else { /* s->pict_type==AV_PICTURE_TYPE_B */
658 cbp
= get_p_cbp(s
, block
, motion_x
, motion_y
);
660 if ((cbp
| motion_x
| motion_y
| s
->dquant
) == 0 &&
661 s
->mv_type
== MV_TYPE_16X16
) {
662 /* check if the B frames can skip it too, as we must skip it
663 * if we skip here why didn't they just compress
664 * the skip-mb bits instead of reusing them ?! */
665 if (s
->max_b_frames
> 0) {
673 offset
= x
+ y
* s
->linesize
;
674 p_pic
= s
->new_picture
.f
->data
[0] + offset
;
677 for (i
= 0; i
< s
->max_b_frames
; i
++) {
680 Picture
*pic
= s
->reordered_input_picture
[i
+ 1];
682 if (!pic
|| pic
->f
->pict_type
!= AV_PICTURE_TYPE_B
)
685 b_pic
= pic
->f
->data
[0] + offset
;
687 b_pic
+= INPLACE_OFFSET
;
689 if (x
+ 16 > s
->width
|| y
+ 16 > s
->height
) {
691 int xe
= FFMIN(16, s
->width
- x
);
692 int ye
= FFMIN(16, s
->height
- y
);
694 for (y1
= 0; y1
< ye
; y1
++) {
695 for (x1
= 0; x1
< xe
; x1
++) {
696 diff
+= FFABS(p_pic
[x1
+ y1
* s
->linesize
] - b_pic
[x1
+ y1
* s
->linesize
]);
699 diff
= diff
* 256 / (xe
* ye
);
701 diff
= s
->mecc
.sad
[0](NULL
, p_pic
, b_pic
, s
->linesize
, 16);
703 if (diff
> s
->qscale
* 70) { // FIXME check that 70 is optimal
711 if (s
->mb_skipped
== 1) {
712 /* skip macroblock */
713 put_bits(&s
->pb
, 1, 1);
715 if (interleaved_stats
) {
725 put_bits(&s
->pb
, 1, 0); /* mb coded */
729 if (s
->mv_type
== MV_TYPE_16X16
) {
733 ff_h263_inter_MCBPC_bits
[cbpc
],
734 ff_h263_inter_MCBPC_code
[cbpc
]);
736 put_bits(pb2
, ff_h263_cbpy_tab
[cbpy
][1], ff_h263_cbpy_tab
[cbpy
][0]);
738 put_bits(pb2
, 2, dquant_code
[s
->dquant
+ 2]);
740 if (!s
->progressive_sequence
) {
742 put_bits(pb2
, 1, s
->interlaced_dct
);
746 if (interleaved_stats
)
747 s
->misc_bits
+= get_bits_diff(s
);
749 /* motion vectors: 16x16 mode */
750 ff_h263_pred_motion(s
, 0, 0, &pred_x
, &pred_y
);
752 ff_h263_encode_motion_vector(s
,
756 } else if (s
->mv_type
== MV_TYPE_FIELD
) {
760 ff_h263_inter_MCBPC_bits
[cbpc
],
761 ff_h263_inter_MCBPC_code
[cbpc
]);
763 put_bits(pb2
, ff_h263_cbpy_tab
[cbpy
][1], ff_h263_cbpy_tab
[cbpy
][0]);
765 put_bits(pb2
, 2, dquant_code
[s
->dquant
+ 2]);
767 av_assert2(!s
->progressive_sequence
);
769 put_bits(pb2
, 1, s
->interlaced_dct
);
772 if (interleaved_stats
)
773 s
->misc_bits
+= get_bits_diff(s
);
775 /* motion vectors: 16x8 interlaced mode */
776 ff_h263_pred_motion(s
, 0, 0, &pred_x
, &pred_y
);
779 put_bits(&s
->pb
, 1, s
->field_select
[0][0]);
780 put_bits(&s
->pb
, 1, s
->field_select
[0][1]);
782 ff_h263_encode_motion_vector(s
,
783 s
->mv
[0][0][0] - pred_x
,
784 s
->mv
[0][0][1] - pred_y
,
786 ff_h263_encode_motion_vector(s
,
787 s
->mv
[0][1][0] - pred_x
,
788 s
->mv
[0][1][1] - pred_y
,
791 av_assert2(s
->mv_type
== MV_TYPE_8X8
);
793 ff_h263_inter_MCBPC_bits
[cbpc
+ 16],
794 ff_h263_inter_MCBPC_code
[cbpc
+ 16]);
795 put_bits(pb2
, ff_h263_cbpy_tab
[cbpy
][1], ff_h263_cbpy_tab
[cbpy
][0]);
797 if (!s
->progressive_sequence
&& cbp
)
798 put_bits(pb2
, 1, s
->interlaced_dct
);
800 if (interleaved_stats
)
801 s
->misc_bits
+= get_bits_diff(s
);
803 for (i
= 0; i
< 4; i
++) {
804 /* motion vectors: 8x8 mode*/
805 ff_h263_pred_motion(s
, i
, 0, &pred_x
, &pred_y
);
807 ff_h263_encode_motion_vector(s
,
808 s
->current_picture
.motion_val
[0][s
->block_index
[i
]][0] - pred_x
,
809 s
->current_picture
.motion_val
[0][s
->block_index
[i
]][1] - pred_y
,
814 if (interleaved_stats
)
815 s
->mv_bits
+= get_bits_diff(s
);
817 mpeg4_encode_blocks(s
, block
, NULL
, NULL
, NULL
, tex_pb
);
819 if (interleaved_stats
)
820 s
->p_tex_bits
+= get_bits_diff(s
);
826 int dc_diff
[6]; // dc values with the dc prediction subtracted
827 int dir
[6]; // prediction direction
828 int zigzag_last_index
[6];
829 uint8_t *scan_table
[6];
832 for (i
= 0; i
< 6; i
++)
833 dc_diff
[i
] = ff_mpeg4_pred_dc(s
, i
, block
[i
][0], &dir
[i
], 1);
835 if (s
->flags
& CODEC_FLAG_AC_PRED
) {
836 s
->ac_pred
= decide_ac_pred(s
, block
, dir
, scan_table
, zigzag_last_index
);
838 for (i
= 0; i
< 6; i
++)
839 scan_table
[i
] = s
->intra_scantable
.permutated
;
844 for (i
= 0; i
< 6; i
++)
845 if (s
->block_last_index
[i
] >= 1)
849 if (s
->pict_type
== AV_PICTURE_TYPE_I
) {
853 ff_h263_intra_MCBPC_bits
[cbpc
],
854 ff_h263_intra_MCBPC_code
[cbpc
]);
858 put_bits(&s
->pb
, 1, 0); /* mb coded */
860 ff_h263_inter_MCBPC_bits
[cbpc
+ 4],
861 ff_h263_inter_MCBPC_code
[cbpc
+ 4]);
863 put_bits(pb2
, 1, s
->ac_pred
);
865 put_bits(pb2
, ff_h263_cbpy_tab
[cbpy
][1], ff_h263_cbpy_tab
[cbpy
][0]);
867 put_bits(dc_pb
, 2, dquant_code
[s
->dquant
+ 2]);
869 if (!s
->progressive_sequence
)
870 put_bits(dc_pb
, 1, s
->interlaced_dct
);
872 if (interleaved_stats
)
873 s
->misc_bits
+= get_bits_diff(s
);
875 mpeg4_encode_blocks(s
, block
, dc_diff
, scan_table
, dc_pb
, tex_pb
);
877 if (interleaved_stats
)
878 s
->i_tex_bits
+= get_bits_diff(s
);
881 /* restore ac coeffs & last_index stuff
882 * if we messed them up with the prediction */
884 restore_ac_coeffs(s
, block
, dir
, scan_table
, zigzag_last_index
);
889 * add mpeg4 stuffing bits (01...1)
891 void ff_mpeg4_stuffing(PutBitContext
*pbc
)
895 length
= (-put_bits_count(pbc
)) & 7;
897 put_bits(pbc
, length
, (1 << length
) - 1);
900 /* must be called before writing the header */
901 void ff_set_mpeg4_time(MpegEncContext
*s
)
903 if (s
->pict_type
== AV_PICTURE_TYPE_B
) {
904 ff_mpeg4_init_direct_mv(s
);
906 s
->last_time_base
= s
->time_base
;
907 s
->time_base
= FFUDIV(s
->time
, s
->avctx
->time_base
.den
);
911 static void mpeg4_encode_gop_header(MpegEncContext
*s
)
913 int hours
, minutes
, seconds
;
916 put_bits(&s
->pb
, 16, 0);
917 put_bits(&s
->pb
, 16, GOP_STARTCODE
);
919 time
= s
->current_picture_ptr
->f
->pts
;
920 if (s
->reordered_input_picture
[1])
921 time
= FFMIN(time
, s
->reordered_input_picture
[1]->f
->pts
);
922 time
= time
* s
->avctx
->time_base
.num
;
923 s
->last_time_base
= FFUDIV(time
, s
->avctx
->time_base
.den
);
925 seconds
= FFUDIV(time
, s
->avctx
->time_base
.den
);
926 minutes
= FFUDIV(seconds
, 60); seconds
= FFUMOD(seconds
, 60);
927 hours
= FFUDIV(minutes
, 60); minutes
= FFUMOD(minutes
, 60);
928 hours
= FFUMOD(hours
, 24);
930 put_bits(&s
->pb
, 5, hours
);
931 put_bits(&s
->pb
, 6, minutes
);
932 put_bits(&s
->pb
, 1, 1);
933 put_bits(&s
->pb
, 6, seconds
);
935 put_bits(&s
->pb
, 1, !!(s
->flags
& CODEC_FLAG_CLOSED_GOP
));
936 put_bits(&s
->pb
, 1, 0); // broken link == NO
938 ff_mpeg4_stuffing(&s
->pb
);
941 static void mpeg4_encode_visual_object_header(MpegEncContext
*s
)
943 int profile_and_level_indication
;
946 if (s
->avctx
->profile
!= FF_PROFILE_UNKNOWN
) {
947 profile_and_level_indication
= s
->avctx
->profile
<< 4;
948 } else if (s
->max_b_frames
|| s
->quarter_sample
) {
949 profile_and_level_indication
= 0xF0; // adv simple
951 profile_and_level_indication
= 0x00; // simple
954 if (s
->avctx
->level
!= FF_LEVEL_UNKNOWN
)
955 profile_and_level_indication
|= s
->avctx
->level
;
957 profile_and_level_indication
|= 1; // level 1
959 if (profile_and_level_indication
>> 4 == 0xF)
966 put_bits(&s
->pb
, 16, 0);
967 put_bits(&s
->pb
, 16, VOS_STARTCODE
);
969 put_bits(&s
->pb
, 8, profile_and_level_indication
);
971 put_bits(&s
->pb
, 16, 0);
972 put_bits(&s
->pb
, 16, VISUAL_OBJ_STARTCODE
);
974 put_bits(&s
->pb
, 1, 1);
975 put_bits(&s
->pb
, 4, vo_ver_id
);
976 put_bits(&s
->pb
, 3, 1); // priority
978 put_bits(&s
->pb
, 4, 1); // visual obj type== video obj
980 put_bits(&s
->pb
, 1, 0); // video signal type == no clue // FIXME
982 ff_mpeg4_stuffing(&s
->pb
);
985 static void mpeg4_encode_vol_header(MpegEncContext
*s
,
991 if (!CONFIG_MPEG4_ENCODER
)
994 if (s
->max_b_frames
|| s
->quarter_sample
) {
996 s
->vo_type
= ADV_SIMPLE_VO_TYPE
;
999 s
->vo_type
= SIMPLE_VO_TYPE
;
1002 put_bits(&s
->pb
, 16, 0);
1003 put_bits(&s
->pb
, 16, 0x100 + vo_number
); /* video obj */
1004 put_bits(&s
->pb
, 16, 0);
1005 put_bits(&s
->pb
, 16, 0x120 + vol_number
); /* video obj layer */
1007 put_bits(&s
->pb
, 1, 0); /* random access vol */
1008 put_bits(&s
->pb
, 8, s
->vo_type
); /* video obj type indication */
1009 if (s
->workaround_bugs
& FF_BUG_MS
) {
1010 put_bits(&s
->pb
, 1, 0); /* is obj layer id= no */
1012 put_bits(&s
->pb
, 1, 1); /* is obj layer id= yes */
1013 put_bits(&s
->pb
, 4, vo_ver_id
); /* is obj layer ver id */
1014 put_bits(&s
->pb
, 3, 1); /* is obj layer priority */
1017 s
->aspect_ratio_info
= ff_h263_aspect_to_info(s
->avctx
->sample_aspect_ratio
);
1019 put_bits(&s
->pb
, 4, s
->aspect_ratio_info
); /* aspect ratio info */
1020 if (s
->aspect_ratio_info
== FF_ASPECT_EXTENDED
) {
1021 av_reduce(&s
->avctx
->sample_aspect_ratio
.num
, &s
->avctx
->sample_aspect_ratio
.den
,
1022 s
->avctx
->sample_aspect_ratio
.num
, s
->avctx
->sample_aspect_ratio
.den
, 255);
1023 put_bits(&s
->pb
, 8, s
->avctx
->sample_aspect_ratio
.num
);
1024 put_bits(&s
->pb
, 8, s
->avctx
->sample_aspect_ratio
.den
);
1027 if (s
->workaround_bugs
& FF_BUG_MS
) {
1028 put_bits(&s
->pb
, 1, 0); /* vol control parameters= no @@@ */
1030 put_bits(&s
->pb
, 1, 1); /* vol control parameters= yes */
1031 put_bits(&s
->pb
, 2, 1); /* chroma format YUV 420/YV12 */
1032 put_bits(&s
->pb
, 1, s
->low_delay
);
1033 put_bits(&s
->pb
, 1, 0); /* vbv parameters= no */
1036 put_bits(&s
->pb
, 2, RECT_SHAPE
); /* vol shape= rectangle */
1037 put_bits(&s
->pb
, 1, 1); /* marker bit */
1039 put_bits(&s
->pb
, 16, s
->avctx
->time_base
.den
);
1040 if (s
->time_increment_bits
< 1)
1041 s
->time_increment_bits
= 1;
1042 put_bits(&s
->pb
, 1, 1); /* marker bit */
1043 put_bits(&s
->pb
, 1, 0); /* fixed vop rate=no */
1044 put_bits(&s
->pb
, 1, 1); /* marker bit */
1045 put_bits(&s
->pb
, 13, s
->width
); /* vol width */
1046 put_bits(&s
->pb
, 1, 1); /* marker bit */
1047 put_bits(&s
->pb
, 13, s
->height
); /* vol height */
1048 put_bits(&s
->pb
, 1, 1); /* marker bit */
1049 put_bits(&s
->pb
, 1, s
->progressive_sequence
? 0 : 1);
1050 put_bits(&s
->pb
, 1, 1); /* obmc disable */
1052 put_bits(&s
->pb
, 1, 0); /* sprite enable */
1054 put_bits(&s
->pb
, 2, 0); /* sprite enable */
1056 put_bits(&s
->pb
, 1, 0); /* not 8 bit == false */
1057 put_bits(&s
->pb
, 1, s
->mpeg_quant
); /* quant type= (0=h263 style)*/
1059 if (s
->mpeg_quant
) {
1060 ff_write_quant_matrix(&s
->pb
, s
->avctx
->intra_matrix
);
1061 ff_write_quant_matrix(&s
->pb
, s
->avctx
->inter_matrix
);
1065 put_bits(&s
->pb
, 1, s
->quarter_sample
);
1066 put_bits(&s
->pb
, 1, 1); /* complexity estimation disable */
1067 put_bits(&s
->pb
, 1, s
->rtp_mode
? 0 : 1); /* resync marker disable */
1068 put_bits(&s
->pb
, 1, s
->data_partitioning
? 1 : 0);
1069 if (s
->data_partitioning
)
1070 put_bits(&s
->pb
, 1, 0); /* no rvlc */
1072 if (vo_ver_id
!= 1) {
1073 put_bits(&s
->pb
, 1, 0); /* newpred */
1074 put_bits(&s
->pb
, 1, 0); /* reduced res vop */
1076 put_bits(&s
->pb
, 1, 0); /* scalability */
1078 ff_mpeg4_stuffing(&s
->pb
);
1081 if (!(s
->flags
& CODEC_FLAG_BITEXACT
)) {
1082 put_bits(&s
->pb
, 16, 0);
1083 put_bits(&s
->pb
, 16, 0x1B2); /* user_data */
1084 avpriv_put_string(&s
->pb
, LIBAVCODEC_IDENT
, 0);
1088 /* write mpeg4 VOP header */
1089 void ff_mpeg4_encode_picture_header(MpegEncContext
*s
, int picture_number
)
1092 int time_div
, time_mod
;
1094 if (s
->pict_type
== AV_PICTURE_TYPE_I
) {
1095 if (!(s
->flags
& CODEC_FLAG_GLOBAL_HEADER
)) {
1096 if (s
->strict_std_compliance
< FF_COMPLIANCE_VERY_STRICT
) // HACK, the reference sw is buggy
1097 mpeg4_encode_visual_object_header(s
);
1098 if (s
->strict_std_compliance
< FF_COMPLIANCE_VERY_STRICT
|| picture_number
== 0) // HACK, the reference sw is buggy
1099 mpeg4_encode_vol_header(s
, 0, 0);
1101 if (!(s
->workaround_bugs
& FF_BUG_MS
))
1102 mpeg4_encode_gop_header(s
);
1105 s
->partitioned_frame
= s
->data_partitioning
&& s
->pict_type
!= AV_PICTURE_TYPE_B
;
1107 put_bits(&s
->pb
, 16, 0); /* vop header */
1108 put_bits(&s
->pb
, 16, VOP_STARTCODE
); /* vop header */
1109 put_bits(&s
->pb
, 2, s
->pict_type
- 1); /* pict type: I = 0 , P = 1 */
1111 time_div
= FFUDIV(s
->time
, s
->avctx
->time_base
.den
);
1112 time_mod
= FFUMOD(s
->time
, s
->avctx
->time_base
.den
);
1113 time_incr
= time_div
- s
->last_time_base
;
1114 av_assert0(time_incr
>= 0);
1116 put_bits(&s
->pb
, 1, 1);
1118 put_bits(&s
->pb
, 1, 0);
1120 put_bits(&s
->pb
, 1, 1); /* marker */
1121 put_bits(&s
->pb
, s
->time_increment_bits
, time_mod
); /* time increment */
1122 put_bits(&s
->pb
, 1, 1); /* marker */
1123 put_bits(&s
->pb
, 1, 1); /* vop coded */
1124 if (s
->pict_type
== AV_PICTURE_TYPE_P
) {
1125 put_bits(&s
->pb
, 1, s
->no_rounding
); /* rounding type */
1127 put_bits(&s
->pb
, 3, 0); /* intra dc VLC threshold */
1128 if (!s
->progressive_sequence
) {
1129 put_bits(&s
->pb
, 1, s
->current_picture_ptr
->f
->top_field_first
);
1130 put_bits(&s
->pb
, 1, s
->alternate_scan
);
1132 // FIXME sprite stuff
1134 put_bits(&s
->pb
, 5, s
->qscale
);
1136 if (s
->pict_type
!= AV_PICTURE_TYPE_I
)
1137 put_bits(&s
->pb
, 3, s
->f_code
); /* fcode_for */
1138 if (s
->pict_type
== AV_PICTURE_TYPE_B
)
1139 put_bits(&s
->pb
, 3, s
->b_code
); /* fcode_back */
1142 static av_cold
void init_uni_dc_tab(void)
1144 int level
, uni_code
, uni_len
;
1146 for (level
= -256; level
< 256; level
++) {
1148 /* find number of bits */
1157 l
= (-level
) ^ ((1 << size
) - 1);
1162 uni_code
= ff_mpeg4_DCtab_lum
[size
][0];
1163 uni_len
= ff_mpeg4_DCtab_lum
[size
][1];
1175 uni_DCtab_lum_bits
[level
+ 256] = uni_code
;
1176 uni_DCtab_lum_len
[level
+ 256] = uni_len
;
1179 uni_code
= ff_mpeg4_DCtab_chrom
[size
][0];
1180 uni_len
= ff_mpeg4_DCtab_chrom
[size
][1];
1192 uni_DCtab_chrom_bits
[level
+ 256] = uni_code
;
1193 uni_DCtab_chrom_len
[level
+ 256] = uni_len
;
1197 static av_cold
void init_uni_mpeg4_rl_tab(RLTable
*rl
, uint32_t *bits_tab
,
1200 int slevel
, run
, last
;
1202 av_assert0(MAX_LEVEL
>= 64);
1203 av_assert0(MAX_RUN
>= 63);
1205 for (slevel
= -64; slevel
< 64; slevel
++) {
1208 for (run
= 0; run
< 64; run
++) {
1209 for (last
= 0; last
<= 1; last
++) {
1210 const int index
= UNI_MPEG4_ENC_INDEX(last
, run
, slevel
+ 64);
1211 int level
= slevel
< 0 ? -slevel
: slevel
;
1212 int sign
= slevel
< 0 ? 1 : 0;
1213 int bits
, len
, code
;
1216 len_tab
[index
] = 100;
1219 code
= get_rl_index(rl
, last
, run
, level
);
1220 bits
= rl
->table_vlc
[code
][0];
1221 len
= rl
->table_vlc
[code
][1];
1222 bits
= bits
* 2 + sign
;
1225 if (code
!= rl
->n
&& len
< len_tab
[index
]) {
1226 bits_tab
[index
] = bits
;
1227 len_tab
[index
] = len
;
1230 bits
= rl
->table_vlc
[rl
->n
][0];
1231 len
= rl
->table_vlc
[rl
->n
][1];
1234 level1
= level
- rl
->max_level
[last
][run
];
1236 code
= get_rl_index(rl
, last
, run
, level1
);
1237 bits
<<= rl
->table_vlc
[code
][1];
1238 len
+= rl
->table_vlc
[code
][1];
1239 bits
+= rl
->table_vlc
[code
][0];
1240 bits
= bits
* 2 + sign
;
1243 if (code
!= rl
->n
&& len
< len_tab
[index
]) {
1244 bits_tab
[index
] = bits
;
1245 len_tab
[index
] = len
;
1249 bits
= rl
->table_vlc
[rl
->n
][0];
1250 len
= rl
->table_vlc
[rl
->n
][1];
1251 bits
= bits
* 4 + 2;
1253 run1
= run
- rl
->max_run
[last
][level
] - 1;
1255 code
= get_rl_index(rl
, last
, run1
, level
);
1256 bits
<<= rl
->table_vlc
[code
][1];
1257 len
+= rl
->table_vlc
[code
][1];
1258 bits
+= rl
->table_vlc
[code
][0];
1259 bits
= bits
* 2 + sign
;
1262 if (code
!= rl
->n
&& len
< len_tab
[index
]) {
1263 bits_tab
[index
] = bits
;
1264 len_tab
[index
] = len
;
1268 bits
= rl
->table_vlc
[rl
->n
][0];
1269 len
= rl
->table_vlc
[rl
->n
][1];
1270 bits
= bits
* 4 + 3;
1272 bits
= bits
* 2 + last
;
1274 bits
= bits
* 64 + run
;
1276 bits
= bits
* 2 + 1;
1278 bits
= bits
* 4096 + (slevel
& 0xfff);
1280 bits
= bits
* 2 + 1;
1283 if (len
< len_tab
[index
]) {
1284 bits_tab
[index
] = bits
;
1285 len_tab
[index
] = len
;
1292 static av_cold
int encode_init(AVCodecContext
*avctx
)
1294 MpegEncContext
*s
= avctx
->priv_data
;
1296 static int done
= 0;
1298 if (avctx
->width
>= (1<<13) || avctx
->height
>= (1<<13)) {
1299 av_log(avctx
, AV_LOG_ERROR
, "dimensions too large for MPEG-4\n");
1300 return AVERROR(EINVAL
);
1303 if ((ret
= ff_mpv_encode_init(avctx
)) < 0)
1311 ff_init_rl(&ff_mpeg4_rl_intra
, ff_mpeg4_static_rl_table_store
[0]);
1313 init_uni_mpeg4_rl_tab(&ff_mpeg4_rl_intra
, uni_mpeg4_intra_rl_bits
, uni_mpeg4_intra_rl_len
);
1314 init_uni_mpeg4_rl_tab(&ff_h263_rl_inter
, uni_mpeg4_inter_rl_bits
, uni_mpeg4_inter_rl_len
);
1317 s
->min_qcoeff
= -2048;
1318 s
->max_qcoeff
= 2047;
1319 s
->intra_ac_vlc_length
= uni_mpeg4_intra_rl_len
;
1320 s
->intra_ac_vlc_last_length
= uni_mpeg4_intra_rl_len
+ 128 * 64;
1321 s
->inter_ac_vlc_length
= uni_mpeg4_inter_rl_len
;
1322 s
->inter_ac_vlc_last_length
= uni_mpeg4_inter_rl_len
+ 128 * 64;
1323 s
->luma_dc_vlc_length
= uni_DCtab_lum_len
;
1324 s
->ac_esc_length
= 7 + 2 + 1 + 6 + 1 + 12 + 1;
1325 s
->y_dc_scale_table
= ff_mpeg4_y_dc_scale_table
;
1326 s
->c_dc_scale_table
= ff_mpeg4_c_dc_scale_table
;
1328 if (s
->flags
& CODEC_FLAG_GLOBAL_HEADER
) {
1329 s
->avctx
->extradata
= av_malloc(1024);
1330 init_put_bits(&s
->pb
, s
->avctx
->extradata
, 1024);
1332 if (!(s
->workaround_bugs
& FF_BUG_MS
))
1333 mpeg4_encode_visual_object_header(s
);
1334 mpeg4_encode_vol_header(s
, 0, 0);
1336 // ff_mpeg4_stuffing(&s->pb); ?
1337 flush_put_bits(&s
->pb
);
1338 s
->avctx
->extradata_size
= (put_bits_count(&s
->pb
) + 7) >> 3;
1343 void ff_mpeg4_init_partitions(MpegEncContext
*s
)
1345 uint8_t *start
= put_bits_ptr(&s
->pb
);
1346 uint8_t *end
= s
->pb
.buf_end
;
1347 int size
= end
- start
;
1348 int pb_size
= (((intptr_t)start
+ size
/ 3) & (~3)) - (intptr_t)start
;
1349 int tex_size
= (size
- 2 * pb_size
) & (~3);
1351 set_put_bits_buffer_size(&s
->pb
, pb_size
);
1352 init_put_bits(&s
->tex_pb
, start
+ pb_size
, tex_size
);
1353 init_put_bits(&s
->pb2
, start
+ pb_size
+ tex_size
, pb_size
);
1356 void ff_mpeg4_merge_partitions(MpegEncContext
*s
)
1358 const int pb2_len
= put_bits_count(&s
->pb2
);
1359 const int tex_pb_len
= put_bits_count(&s
->tex_pb
);
1360 const int bits
= put_bits_count(&s
->pb
);
1362 if (s
->pict_type
== AV_PICTURE_TYPE_I
) {
1363 put_bits(&s
->pb
, 19, DC_MARKER
);
1364 s
->misc_bits
+= 19 + pb2_len
+ bits
- s
->last_bits
;
1365 s
->i_tex_bits
+= tex_pb_len
;
1367 put_bits(&s
->pb
, 17, MOTION_MARKER
);
1368 s
->misc_bits
+= 17 + pb2_len
;
1369 s
->mv_bits
+= bits
- s
->last_bits
;
1370 s
->p_tex_bits
+= tex_pb_len
;
1373 flush_put_bits(&s
->pb2
);
1374 flush_put_bits(&s
->tex_pb
);
1376 set_put_bits_buffer_size(&s
->pb
, s
->pb2
.buf_end
- s
->pb
.buf
);
1377 avpriv_copy_bits(&s
->pb
, s
->pb2
.buf
, pb2_len
);
1378 avpriv_copy_bits(&s
->pb
, s
->tex_pb
.buf
, tex_pb_len
);
1379 s
->last_bits
= put_bits_count(&s
->pb
);
1382 void ff_mpeg4_encode_video_packet_header(MpegEncContext
*s
)
1384 int mb_num_bits
= av_log2(s
->mb_num
- 1) + 1;
1386 put_bits(&s
->pb
, ff_mpeg4_get_video_packet_prefix_length(s
), 0);
1387 put_bits(&s
->pb
, 1, 1);
1389 put_bits(&s
->pb
, mb_num_bits
, s
->mb_x
+ s
->mb_y
* s
->mb_width
);
1390 put_bits(&s
->pb
, s
->quant_precision
, s
->qscale
);
1391 put_bits(&s
->pb
, 1, 0); /* no HEC */
1394 #define OFFSET(x) offsetof(MpegEncContext, x)
1395 #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
1396 static const AVOption options
[] = {
1397 { "data_partitioning", "Use data partitioning.", OFFSET(data_partitioning
), AV_OPT_TYPE_INT
, { .i64
= 0 }, 0, 1, VE
},
1398 { "alternate_scan", "Enable alternate scantable.", OFFSET(alternate_scan
), AV_OPT_TYPE_INT
, { .i64
= 0 }, 0, 1, VE
},
1403 static const AVClass mpeg4enc_class
= {
1404 .class_name
= "MPEG4 encoder",
1405 .item_name
= av_default_item_name
,
1407 .version
= LIBAVUTIL_VERSION_INT
,
1410 AVCodec ff_mpeg4_encoder
= {
1412 .long_name
= NULL_IF_CONFIG_SMALL("MPEG-4 part 2"),
1413 .type
= AVMEDIA_TYPE_VIDEO
,
1414 .id
= AV_CODEC_ID_MPEG4
,
1415 .priv_data_size
= sizeof(MpegEncContext
),
1416 .init
= encode_init
,
1417 .encode2
= ff_mpv_encode_picture
,
1418 .close
= ff_mpv_encode_end
,
1419 .pix_fmts
= (const enum AVPixelFormat
[]) { AV_PIX_FMT_YUV420P
, AV_PIX_FMT_NONE
},
1420 .capabilities
= CODEC_CAP_DELAY
| CODEC_CAP_SLICE_THREADS
,
1421 .priv_class
= &mpeg4enc_class
,