1 |
|
|
/* |
2 |
|
|
* MPEG-4 decoder / encoder common code |
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 "mpegutils.h" |
24 |
|
|
#include "mpegvideo.h" |
25 |
|
|
#include "mpeg4video.h" |
26 |
|
|
#include "mpeg4data.h" |
27 |
|
|
|
28 |
|
|
uint8_t ff_mpeg4_static_rl_table_store[3][2][2 * MAX_RUN + MAX_LEVEL + 3]; |
29 |
|
|
|
30 |
|
11288 |
int ff_mpeg4_get_video_packet_prefix_length(MpegEncContext *s) |
31 |
|
|
{ |
32 |
✓✓✓✗
|
11288 |
switch (s->pict_type) { |
33 |
|
1437 |
case AV_PICTURE_TYPE_I: |
34 |
|
1437 |
return 16; |
35 |
|
3746 |
case AV_PICTURE_TYPE_P: |
36 |
|
|
case AV_PICTURE_TYPE_S: |
37 |
|
3746 |
return s->f_code + 15; |
38 |
|
6105 |
case AV_PICTURE_TYPE_B: |
39 |
|
6105 |
return FFMAX3(s->f_code, s->b_code, 2) + 15; |
40 |
|
|
default: |
41 |
|
|
return -1; |
42 |
|
|
} |
43 |
|
|
} |
44 |
|
|
|
45 |
|
7615 |
void ff_mpeg4_clean_buffers(MpegEncContext *s) |
46 |
|
|
{ |
47 |
|
|
int c_wrap, c_xy, l_wrap, l_xy; |
48 |
|
|
|
49 |
|
7615 |
l_wrap = s->b8_stride; |
50 |
|
7615 |
l_xy = (2 * s->mb_y - 1) * l_wrap + s->mb_x * 2 - 1; |
51 |
|
7615 |
c_wrap = s->mb_stride; |
52 |
|
7615 |
c_xy = (s->mb_y - 1) * c_wrap + s->mb_x - 1; |
53 |
|
|
|
54 |
|
|
/* clean AC */ |
55 |
|
7615 |
memset(s->ac_val[0] + l_xy, 0, (l_wrap * 2 + 1) * 16 * sizeof(int16_t)); |
56 |
|
7615 |
memset(s->ac_val[1] + c_xy, 0, (c_wrap + 1) * 16 * sizeof(int16_t)); |
57 |
|
7615 |
memset(s->ac_val[2] + c_xy, 0, (c_wrap + 1) * 16 * sizeof(int16_t)); |
58 |
|
|
|
59 |
|
|
/* clean MV */ |
60 |
|
|
// we can't clear the MVs as they might be needed by a B-frame |
61 |
|
7615 |
s->last_mv[0][0][0] = |
62 |
|
7615 |
s->last_mv[0][0][1] = |
63 |
|
7615 |
s->last_mv[1][0][0] = |
64 |
|
7615 |
s->last_mv[1][0][1] = 0; |
65 |
|
7615 |
} |
66 |
|
|
|
67 |
|
|
#define tab_size ((signed)FF_ARRAY_ELEMS(s->direct_scale_mv[0])) |
68 |
|
|
#define tab_bias (tab_size / 2) |
69 |
|
|
|
70 |
|
|
// used by MPEG-4 and rv10 decoder |
71 |
|
2168 |
void ff_mpeg4_init_direct_mv(MpegEncContext *s) |
72 |
|
|
{ |
73 |
|
|
int i; |
74 |
✓✓ |
140920 |
for (i = 0; i < tab_size; i++) { |
75 |
|
138752 |
s->direct_scale_mv[0][i] = (i - tab_bias) * s->pb_time / s->pp_time; |
76 |
|
138752 |
s->direct_scale_mv[1][i] = (i - tab_bias) * (s->pb_time - s->pp_time) / |
77 |
|
138752 |
s->pp_time; |
78 |
|
|
} |
79 |
|
2168 |
} |
80 |
|
|
|
81 |
|
586373 |
static inline void ff_mpeg4_set_one_direct_mv(MpegEncContext *s, int mx, |
82 |
|
|
int my, int i) |
83 |
|
|
{ |
84 |
|
586373 |
int xy = s->block_index[i]; |
85 |
|
586373 |
uint16_t time_pp = s->pp_time; |
86 |
|
586373 |
uint16_t time_pb = s->pb_time; |
87 |
|
|
int p_mx, p_my; |
88 |
|
|
|
89 |
|
586373 |
p_mx = s->next_picture.motion_val[0][xy][0]; |
90 |
✓✓ |
586373 |
if ((unsigned)(p_mx + tab_bias) < tab_size) { |
91 |
|
565682 |
s->mv[0][i][0] = s->direct_scale_mv[0][p_mx + tab_bias] + mx; |
92 |
|
565682 |
s->mv[1][i][0] = mx ? s->mv[0][i][0] - p_mx |
93 |
✓✓ |
565682 |
: s->direct_scale_mv[1][p_mx + tab_bias]; |
94 |
|
|
} else { |
95 |
|
20691 |
s->mv[0][i][0] = p_mx * time_pb / time_pp + mx; |
96 |
|
20691 |
s->mv[1][i][0] = mx ? s->mv[0][i][0] - p_mx |
97 |
✓✓ |
20691 |
: p_mx * (time_pb - time_pp) / time_pp; |
98 |
|
|
} |
99 |
|
586373 |
p_my = s->next_picture.motion_val[0][xy][1]; |
100 |
✓✓ |
586373 |
if ((unsigned)(p_my + tab_bias) < tab_size) { |
101 |
|
566072 |
s->mv[0][i][1] = s->direct_scale_mv[0][p_my + tab_bias] + my; |
102 |
|
566072 |
s->mv[1][i][1] = my ? s->mv[0][i][1] - p_my |
103 |
✓✓ |
566072 |
: s->direct_scale_mv[1][p_my + tab_bias]; |
104 |
|
|
} else { |
105 |
|
20301 |
s->mv[0][i][1] = p_my * time_pb / time_pp + my; |
106 |
|
20301 |
s->mv[1][i][1] = my ? s->mv[0][i][1] - p_my |
107 |
✓✓ |
20301 |
: p_my * (time_pb - time_pp) / time_pp; |
108 |
|
|
} |
109 |
|
586373 |
} |
110 |
|
|
|
111 |
|
|
#undef tab_size |
112 |
|
|
#undef tab_bias |
113 |
|
|
|
114 |
|
|
/** |
115 |
|
|
* @return the mb_type |
116 |
|
|
*/ |
117 |
|
302918 |
int ff_mpeg4_set_direct_mv(MpegEncContext *s, int mx, int my) |
118 |
|
|
{ |
119 |
|
302918 |
const int mb_index = s->mb_x + s->mb_y * s->mb_stride; |
120 |
|
302918 |
const int colocated_mb_type = s->next_picture.mb_type[mb_index]; |
121 |
|
|
uint16_t time_pp; |
122 |
|
|
uint16_t time_pb; |
123 |
|
|
int i; |
124 |
|
|
|
125 |
|
|
// FIXME avoid divides |
126 |
|
|
// try special case with shifts for 1 and 3 B-frames? |
127 |
|
|
|
128 |
✓✓ |
302918 |
if (IS_8X8(colocated_mb_type)) { |
129 |
|
94485 |
s->mv_type = MV_TYPE_8X8; |
130 |
✓✓ |
472425 |
for (i = 0; i < 4; i++) |
131 |
|
377940 |
ff_mpeg4_set_one_direct_mv(s, mx, my, i); |
132 |
|
94485 |
return MB_TYPE_DIRECT2 | MB_TYPE_8x8 | MB_TYPE_L0L1; |
133 |
✗✓ |
208433 |
} else if (IS_INTERLACED(colocated_mb_type)) { |
134 |
|
|
s->mv_type = MV_TYPE_FIELD; |
135 |
|
|
for (i = 0; i < 2; i++) { |
136 |
|
|
int field_select = s->next_picture.ref_index[0][4 * mb_index + 2 * i]; |
137 |
|
|
s->field_select[0][i] = field_select; |
138 |
|
|
s->field_select[1][i] = i; |
139 |
|
|
if (s->top_field_first) { |
140 |
|
|
time_pp = s->pp_field_time - field_select + i; |
141 |
|
|
time_pb = s->pb_field_time - field_select + i; |
142 |
|
|
} else { |
143 |
|
|
time_pp = s->pp_field_time + field_select - i; |
144 |
|
|
time_pb = s->pb_field_time + field_select - i; |
145 |
|
|
} |
146 |
|
|
s->mv[0][i][0] = s->p_field_mv_table[i][0][mb_index][0] * |
147 |
|
|
time_pb / time_pp + mx; |
148 |
|
|
s->mv[0][i][1] = s->p_field_mv_table[i][0][mb_index][1] * |
149 |
|
|
time_pb / time_pp + my; |
150 |
|
|
s->mv[1][i][0] = mx ? s->mv[0][i][0] - |
151 |
|
|
s->p_field_mv_table[i][0][mb_index][0] |
152 |
|
|
: s->p_field_mv_table[i][0][mb_index][0] * |
153 |
|
|
(time_pb - time_pp) / time_pp; |
154 |
|
|
s->mv[1][i][1] = my ? s->mv[0][i][1] - |
155 |
|
|
s->p_field_mv_table[i][0][mb_index][1] |
156 |
|
|
: s->p_field_mv_table[i][0][mb_index][1] * |
157 |
|
|
(time_pb - time_pp) / time_pp; |
158 |
|
|
} |
159 |
|
|
return MB_TYPE_DIRECT2 | MB_TYPE_16x8 | |
160 |
|
|
MB_TYPE_L0L1 | MB_TYPE_INTERLACED; |
161 |
|
|
} else { |
162 |
|
208433 |
ff_mpeg4_set_one_direct_mv(s, mx, my, 0); |
163 |
|
208433 |
s->mv[0][1][0] = |
164 |
|
208433 |
s->mv[0][2][0] = |
165 |
|
208433 |
s->mv[0][3][0] = s->mv[0][0][0]; |
166 |
|
208433 |
s->mv[0][1][1] = |
167 |
|
208433 |
s->mv[0][2][1] = |
168 |
|
208433 |
s->mv[0][3][1] = s->mv[0][0][1]; |
169 |
|
208433 |
s->mv[1][1][0] = |
170 |
|
208433 |
s->mv[1][2][0] = |
171 |
|
208433 |
s->mv[1][3][0] = s->mv[1][0][0]; |
172 |
|
208433 |
s->mv[1][1][1] = |
173 |
|
208433 |
s->mv[1][2][1] = |
174 |
|
208433 |
s->mv[1][3][1] = s->mv[1][0][1]; |
175 |
✓✗ |
208433 |
if ((s->avctx->workaround_bugs & FF_BUG_DIRECT_BLOCKSIZE) || |
176 |
✓✓ |
208433 |
!s->quarter_sample) |
177 |
|
179275 |
s->mv_type = MV_TYPE_16X16; |
178 |
|
|
else |
179 |
|
29158 |
s->mv_type = MV_TYPE_8X8; |
180 |
|
|
// Note see prev line |
181 |
|
208433 |
return MB_TYPE_DIRECT2 | MB_TYPE_16x16 | MB_TYPE_L0L1; |
182 |
|
|
} |
183 |
|
|
} |