2 * MSMPEG4 encoder backend
3 * Copyright (c) 2001 Fabrice Bellard
4 * Copyright (c) 2002-2004 Michael Niedermayer <michaelni@gmx.at>
6 * msmpeg4v1 & v2 stuff by Michael Niedermayer <michaelni@gmx.at>
8 * This file is part of FFmpeg.
10 * FFmpeg is free software; you can redistribute it and/or
11 * modify it under the terms of the GNU Lesser General Public
12 * License as published by the Free Software Foundation; either
13 * version 2.1 of the License, or (at your option) any later version.
15 * FFmpeg is distributed in the hope that it will be useful,
16 * but WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
18 * Lesser General Public License for more details.
20 * You should have received a copy of the GNU Lesser General Public
21 * License along with FFmpeg; if not, write to the Free Software
22 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
27 * MSMPEG4 encoder backend
33 #include "libavutil/attributes.h"
34 #include "libavutil/avutil.h"
35 #include "libavutil/mem.h"
36 #include "mpegvideo.h"
38 #include "mpeg4video.h"
40 #include "msmpeg4data.h"
45 static uint8_t rl_length
[NB_RL_TABLES
][MAX_LEVEL
+1][MAX_RUN
+1][2];
47 /* build the table which associate a (x,y) motion vector to a vlc */
48 static av_cold
void init_mv_table(MVTable
*tab
)
52 tab
->table_mv_index
= av_malloc(sizeof(uint16_t) * 4096);
53 /* mark all entries as not used */
55 tab
->table_mv_index
[i
] = tab
->n
;
57 for(i
=0;i
<tab
->n
;i
++) {
58 x
= tab
->table_mvx
[i
];
59 y
= tab
->table_mvy
[i
];
60 tab
->table_mv_index
[(x
<< 6) | y
] = i
;
64 void ff_msmpeg4_code012(PutBitContext
*pb
, int n
)
70 put_bits(pb
, 1, (n
>= 2));
74 static int get_size_of_code(MpegEncContext
* s
, RLTable
*rl
, int last
, int run
, int level
, int intra
){
77 int run_diff
= intra
? 0 : 1;
79 code
= get_rl_index(rl
, last
, run
, level
);
80 size
+= rl
->table_vlc
[code
][1];
84 level1
= level
- rl
->max_level
[last
][run
];
87 code
= get_rl_index(rl
, last
, run
, level1
);
91 if (level
> MAX_LEVEL
)
93 run1
= run
- rl
->max_run
[last
][level
] - run_diff
;
96 code
= get_rl_index(rl
, last
, run1
, level
);
103 size
+= 1+1+ rl
->table_vlc
[code
][1];
107 size
+= 1+1+ rl
->table_vlc
[code
][1];
115 av_cold
void ff_msmpeg4_encode_init(MpegEncContext
*s
)
117 static int init_done
=0;
120 ff_msmpeg4_common_init(s
);
121 if(s
->msmpeg4_version
>=4){
127 /* init various encoding tables */
129 init_mv_table(&ff_mv_tables
[0]);
130 init_mv_table(&ff_mv_tables
[1]);
131 for(i
=0;i
<NB_RL_TABLES
;i
++)
132 ff_init_rl(&ff_rl_table
[i
], ff_static_rl_table_store
[i
]);
134 for(i
=0; i
<NB_RL_TABLES
; i
++){
136 for (level
= 1; level
<= MAX_LEVEL
; level
++) {
138 for(run
=0; run
<=MAX_RUN
; run
++){
140 for(last
=0; last
<2; last
++){
141 rl_length
[i
][level
][run
][last
]= get_size_of_code(s
, &ff_rl_table
[ i
], last
, run
, level
, 0);
149 static void find_best_tables(MpegEncContext
* s
)
152 int best
= 0, best_size
= INT_MAX
;
153 int chroma_best
= 0, best_chroma_size
= INT_MAX
;
164 for(level
=0; level
<=MAX_LEVEL
; level
++){
166 for(run
=0; run
<=MAX_RUN
; run
++){
168 const int last_size
= size
+ chroma_size
;
169 for(last
=0; last
<2; last
++){
170 int inter_count
= s
->ac_stats
[0][0][level
][run
][last
] + s
->ac_stats
[0][1][level
][run
][last
];
171 int intra_luma_count
= s
->ac_stats
[1][0][level
][run
][last
];
172 int intra_chroma_count
= s
->ac_stats
[1][1][level
][run
][last
];
174 if(s
->pict_type
==AV_PICTURE_TYPE_I
){
175 size
+= intra_luma_count
*rl_length
[i
][level
][run
][last
];
176 chroma_size
+= intra_chroma_count
*rl_length
[i
+3][level
][run
][last
];
178 size
+= intra_luma_count
*rl_length
[i
][level
][run
][last
]
179 +intra_chroma_count
*rl_length
[i
+3][level
][run
][last
]
180 +inter_count
*rl_length
[i
+3][level
][run
][last
];
183 if(last_size
== size
+chroma_size
) break;
190 if(chroma_size
<best_chroma_size
){
191 best_chroma_size
= chroma_size
;
196 if(s
->pict_type
==AV_PICTURE_TYPE_P
) chroma_best
= best
;
198 memset(s
->ac_stats
, 0, sizeof(int)*(MAX_LEVEL
+1)*(MAX_RUN
+1)*2*2*2);
200 s
->rl_table_index
= best
;
201 s
->rl_chroma_table_index
= chroma_best
;
203 if(s
->pict_type
!= s
->last_non_b_pict_type
){
204 s
->rl_table_index
= 2;
205 if(s
->pict_type
==AV_PICTURE_TYPE_I
)
206 s
->rl_chroma_table_index
= 1;
208 s
->rl_chroma_table_index
= 2;
213 /* write MSMPEG4 compatible frame header */
214 void ff_msmpeg4_encode_picture_header(MpegEncContext
* s
, int picture_number
)
218 avpriv_align_put_bits(&s
->pb
);
219 put_bits(&s
->pb
, 2, s
->pict_type
- 1);
221 put_bits(&s
->pb
, 5, s
->qscale
);
222 if(s
->msmpeg4_version
<=2){
223 s
->rl_table_index
= 2;
224 s
->rl_chroma_table_index
= 2;
227 s
->dc_table_index
= 1;
228 s
->mv_table_index
= 1; /* only if P frame */
229 s
->use_skip_mb_code
= 1; /* only if P frame */
230 s
->per_mb_rl_table
= 0;
231 if(s
->msmpeg4_version
==4)
232 s
->inter_intra_pred
= (s
->width
*s
->height
< 320*240 && s
->bit_rate
<=II_BITRATE
&& s
->pict_type
==AV_PICTURE_TYPE_P
);
233 av_dlog(s
, "%d %d %d %d %d\n", s
->pict_type
, s
->bit_rate
,
234 s
->inter_intra_pred
, s
->width
, s
->height
);
236 if (s
->pict_type
== AV_PICTURE_TYPE_I
) {
237 s
->slice_height
= s
->mb_height
/1;
238 put_bits(&s
->pb
, 5, 0x16 + s
->mb_height
/s
->slice_height
);
240 if(s
->msmpeg4_version
==4){
241 ff_msmpeg4_encode_ext_header(s
);
242 if(s
->bit_rate
>MBAC_BITRATE
)
243 put_bits(&s
->pb
, 1, s
->per_mb_rl_table
);
246 if(s
->msmpeg4_version
>2){
247 if(!s
->per_mb_rl_table
){
248 ff_msmpeg4_code012(&s
->pb
, s
->rl_chroma_table_index
);
249 ff_msmpeg4_code012(&s
->pb
, s
->rl_table_index
);
252 put_bits(&s
->pb
, 1, s
->dc_table_index
);
255 put_bits(&s
->pb
, 1, s
->use_skip_mb_code
);
257 if(s
->msmpeg4_version
==4 && s
->bit_rate
>MBAC_BITRATE
)
258 put_bits(&s
->pb
, 1, s
->per_mb_rl_table
);
260 if(s
->msmpeg4_version
>2){
261 if(!s
->per_mb_rl_table
)
262 ff_msmpeg4_code012(&s
->pb
, s
->rl_table_index
);
264 put_bits(&s
->pb
, 1, s
->dc_table_index
);
266 put_bits(&s
->pb
, 1, s
->mv_table_index
);
270 s
->esc3_level_length
= 0;
271 s
->esc3_run_length
= 0;
274 void ff_msmpeg4_encode_ext_header(MpegEncContext
* s
)
276 unsigned fps
= s
->avctx
->time_base
.den
/ s
->avctx
->time_base
.num
/ FFMAX(s
->avctx
->ticks_per_frame
, 1);
277 put_bits(&s
->pb
, 5, FFMIN(fps
, 31)); //yes 29.97 -> 29
279 put_bits(&s
->pb
, 11, FFMIN(s
->bit_rate
/1024, 2047));
281 if(s
->msmpeg4_version
>=3)
282 put_bits(&s
->pb
, 1, s
->flipflop_rounding
);
284 av_assert0(s
->flipflop_rounding
==0);
287 void ff_msmpeg4_encode_motion(MpegEncContext
* s
,
293 /* modulo encoding */
294 /* WARNING : you cannot reach all the MVs even with the modulo
295 encoding. This is a somewhat strange compromise they took !!! */
308 if ((unsigned)mx
>= 64 ||
310 av_log(s
->avctx
, AV_LOG_ERROR
, "error mx=%d my=%d\n", mx
, my
);
312 mv
= &ff_mv_tables
[s
->mv_table_index
];
314 code
= mv
->table_mv_index
[(mx
<< 6) | my
];
316 mv
->table_mv_bits
[code
],
317 mv
->table_mv_code
[code
]);
319 /* escape : code literally */
320 put_bits(&s
->pb
, 6, mx
);
321 put_bits(&s
->pb
, 6, my
);
325 void ff_msmpeg4_handle_slices(MpegEncContext
*s
){
327 if (s
->slice_height
&& (s
->mb_y
% s
->slice_height
) == 0) {
328 if(s
->msmpeg4_version
< 4){
329 ff_mpeg4_clean_buffers(s
);
331 s
->first_slice_line
= 1;
333 s
->first_slice_line
= 0;
338 static void msmpeg4v2_encode_motion(MpegEncContext
* s
, int val
)
340 int range
, bit_size
, sign
, code
, bits
;
345 put_bits(&s
->pb
, ff_mvtab
[code
][1], ff_mvtab
[code
][0]);
347 bit_size
= s
->f_code
- 1;
348 range
= 1 << bit_size
;
361 code
= (val
>> bit_size
) + 1;
362 bits
= val
& (range
- 1);
364 put_bits(&s
->pb
, ff_mvtab
[code
][1] + 1, (ff_mvtab
[code
][0] << 1) | sign
);
366 put_bits(&s
->pb
, bit_size
, bits
);
371 void ff_msmpeg4_encode_mb(MpegEncContext
* s
,
372 int16_t block
[6][64],
373 int motion_x
, int motion_y
)
375 int cbp
, coded_cbp
, i
;
377 uint8_t *coded_block
;
379 ff_msmpeg4_handle_slices(s
);
384 for (i
= 0; i
< 6; i
++) {
385 if (s
->block_last_index
[i
] >= 0)
388 if (s
->use_skip_mb_code
&& (cbp
| motion_x
| motion_y
) == 0) {
389 /* skip macroblock */
390 put_bits(&s
->pb
, 1, 1);
397 if (s
->use_skip_mb_code
)
398 put_bits(&s
->pb
, 1, 0); /* mb coded */
400 if(s
->msmpeg4_version
<=2){
402 ff_v2_mb_type
[cbp
&3][1],
403 ff_v2_mb_type
[cbp
&3][0]);
404 if((cbp
&3) != 3) coded_cbp
= cbp
^ 0x3C;
408 ff_h263_cbpy_tab
[coded_cbp
>>2][1],
409 ff_h263_cbpy_tab
[coded_cbp
>>2][0]);
411 s
->misc_bits
+= get_bits_diff(s
);
413 ff_h263_pred_motion(s
, 0, 0, &pred_x
, &pred_y
);
414 msmpeg4v2_encode_motion(s
, motion_x
- pred_x
);
415 msmpeg4v2_encode_motion(s
, motion_y
- pred_y
);
418 ff_table_mb_non_intra
[cbp
+ 64][1],
419 ff_table_mb_non_intra
[cbp
+ 64][0]);
421 s
->misc_bits
+= get_bits_diff(s
);
424 ff_h263_pred_motion(s
, 0, 0, &pred_x
, &pred_y
);
425 ff_msmpeg4_encode_motion(s
, motion_x
- pred_x
,
429 s
->mv_bits
+= get_bits_diff(s
);
431 for (i
= 0; i
< 6; i
++) {
432 ff_msmpeg4_encode_block(s
, block
[i
], i
);
434 s
->p_tex_bits
+= get_bits_diff(s
);
439 for (i
= 0; i
< 6; i
++) {
441 val
= (s
->block_last_index
[i
] >= 1);
442 cbp
|= val
<< (5 - i
);
444 /* predict value for close blocks only for luma */
445 pred
= ff_msmpeg4_coded_block_pred(s
, i
, &coded_block
);
449 coded_cbp
|= val
<< (5 - i
);
452 if(s
->msmpeg4_version
<=2){
453 if (s
->pict_type
== AV_PICTURE_TYPE_I
) {
455 ff_v2_intra_cbpc
[cbp
&3][1], ff_v2_intra_cbpc
[cbp
&3][0]);
457 if (s
->use_skip_mb_code
)
458 put_bits(&s
->pb
, 1, 0); /* mb coded */
460 ff_v2_mb_type
[(cbp
&3) + 4][1],
461 ff_v2_mb_type
[(cbp
&3) + 4][0]);
463 put_bits(&s
->pb
, 1, 0); /* no AC prediction yet */
465 ff_h263_cbpy_tab
[cbp
>>2][1],
466 ff_h263_cbpy_tab
[cbp
>>2][0]);
468 if (s
->pict_type
== AV_PICTURE_TYPE_I
) {
470 ff_msmp4_mb_i_table
[coded_cbp
][1], ff_msmp4_mb_i_table
[coded_cbp
][0]);
472 if (s
->use_skip_mb_code
)
473 put_bits(&s
->pb
, 1, 0); /* mb coded */
475 ff_table_mb_non_intra
[cbp
][1],
476 ff_table_mb_non_intra
[cbp
][0]);
478 put_bits(&s
->pb
, 1, 0); /* no AC prediction yet */
479 if(s
->inter_intra_pred
){
481 put_bits(&s
->pb
, ff_table_inter_intra
[s
->h263_aic_dir
][1], ff_table_inter_intra
[s
->h263_aic_dir
][0]);
484 s
->misc_bits
+= get_bits_diff(s
);
486 for (i
= 0; i
< 6; i
++) {
487 ff_msmpeg4_encode_block(s
, block
[i
], i
);
489 s
->i_tex_bits
+= get_bits_diff(s
);
494 static void msmpeg4_encode_dc(MpegEncContext
* s
, int level
, int n
, int *dir_ptr
)
497 int pred
, av_uninit(extquant
);
501 pred
= ff_msmpeg4_pred_dc(s
, n
, &dc_val
, dir_ptr
);
503 /* update predictor */
505 *dc_val
= level
* s
->y_dc_scale
;
507 *dc_val
= level
* s
->c_dc_scale
;
510 /* do the prediction */
513 if(s
->msmpeg4_version
<=2){
516 ff_v2_dc_lum_table
[level
+ 256][1],
517 ff_v2_dc_lum_table
[level
+ 256][0]);
520 ff_v2_dc_chroma_table
[level
+ 256][1],
521 ff_v2_dc_chroma_table
[level
+ 256][0]);
532 else if( s
->msmpeg4_version
>=6 ) {
533 if( s
->qscale
== 1 ) {
534 extquant
= (level
+ 3) & 0x3;
535 code
= ((level
+3)>>2);
536 } else if( s
->qscale
== 2 ) {
537 extquant
= (level
+ 1) & 0x1;
538 code
= ((level
+1)>>1);
542 if (s
->dc_table_index
== 0) {
544 put_bits(&s
->pb
, ff_table0_dc_lum
[code
][1], ff_table0_dc_lum
[code
][0]);
546 put_bits(&s
->pb
, ff_table0_dc_chroma
[code
][1], ff_table0_dc_chroma
[code
][0]);
550 put_bits(&s
->pb
, ff_table1_dc_lum
[code
][1], ff_table1_dc_lum
[code
][0]);
552 put_bits(&s
->pb
, ff_table1_dc_chroma
[code
][1], ff_table1_dc_chroma
[code
][0]);
556 if(s
->msmpeg4_version
>=6 && s
->qscale
<=2)
557 extrabits
= 3 - s
->qscale
;
560 put_bits(&s
->pb
, 8 + extrabits
, level
);
561 else if(extrabits
> 0)//== VC1 && s->qscale<=2
562 put_bits(&s
->pb
, extrabits
, extquant
);
565 put_bits(&s
->pb
, 1, sign
);
570 /* Encoding of a block. Very similar to MPEG4 except for a different
571 escape coding (same as H263) and more vlc tables.
573 void ff_msmpeg4_encode_block(MpegEncContext
* s
, int16_t * block
, int n
)
575 int level
, run
, last
, i
, j
, last_index
;
576 int last_non_zero
, sign
, slevel
;
577 int code
, run_diff
, dc_pred_dir
;
579 const uint8_t *scantable
;
582 msmpeg4_encode_dc(s
, block
[0], n
, &dc_pred_dir
);
585 rl
= &ff_rl_table
[s
->rl_table_index
];
587 rl
= &ff_rl_table
[3 + s
->rl_chroma_table_index
];
589 run_diff
= s
->msmpeg4_version
>=4;
590 scantable
= s
->intra_scantable
.permutated
;
593 rl
= &ff_rl_table
[3 + s
->rl_table_index
];
594 if(s
->msmpeg4_version
<=2)
598 scantable
= s
->inter_scantable
.permutated
;
601 /* recalculate block_last_index for M$ wmv1 */
602 if(s
->msmpeg4_version
>=4 && s
->msmpeg4_version
<6 && s
->block_last_index
[n
]>0){
603 for(last_index
=63; last_index
>=0; last_index
--){
604 if(block
[scantable
[last_index
]]) break;
606 s
->block_last_index
[n
]= last_index
;
608 last_index
= s
->block_last_index
[n
];
610 last_non_zero
= i
- 1;
611 for (; i
<= last_index
; i
++) {
615 run
= i
- last_non_zero
- 1;
616 last
= (i
== last_index
);
624 if(level
<=MAX_LEVEL
&& run
<=MAX_RUN
){
625 s
->ac_stats
[s
->mb_intra
][n
>3][level
][run
][last
]++;
628 s
->ac_stats
[s
->mb_intra
][n
> 3][40][63][0]++; //esc3 like
630 code
= get_rl_index(rl
, last
, run
, level
);
631 put_bits(&s
->pb
, rl
->table_vlc
[code
][1], rl
->table_vlc
[code
][0]);
635 level1
= level
- rl
->max_level
[last
][run
];
638 code
= get_rl_index(rl
, last
, run
, level1
);
641 put_bits(&s
->pb
, 1, 0);
642 if (level
> MAX_LEVEL
)
644 run1
= run
- rl
->max_run
[last
][level
] - run_diff
;
647 code
= get_rl_index(rl
, last
, run1
+1, level
);
648 if (s
->msmpeg4_version
== 4 && code
== rl
->n
)
650 code
= get_rl_index(rl
, last
, run1
, level
);
654 put_bits(&s
->pb
, 1, 0);
655 put_bits(&s
->pb
, 1, last
);
656 if(s
->msmpeg4_version
>=4){
657 if(s
->esc3_level_length
==0){
658 s
->esc3_level_length
=8;
659 s
->esc3_run_length
= 6;
660 //ESCLVLSZ + ESCRUNSZ
662 put_bits(&s
->pb
, 6 + (s
->msmpeg4_version
>=6), 3);
664 put_bits(&s
->pb
, 8, 3);
666 put_bits(&s
->pb
, s
->esc3_run_length
, run
);
667 put_bits(&s
->pb
, 1, sign
);
668 put_bits(&s
->pb
, s
->esc3_level_length
, level
);
670 put_bits(&s
->pb
, 6, run
);
671 put_sbits(&s
->pb
, 8, slevel
);
675 put_bits(&s
->pb
, 1, 1);
676 put_bits(&s
->pb
, rl
->table_vlc
[code
][1], rl
->table_vlc
[code
][0]);
677 put_bits(&s
->pb
, 1, sign
);
681 put_bits(&s
->pb
, 1, 1);
682 put_bits(&s
->pb
, rl
->table_vlc
[code
][1], rl
->table_vlc
[code
][0]);
683 put_bits(&s
->pb
, 1, sign
);
686 put_bits(&s
->pb
, 1, sign
);