blob: 2aaa9f734cdd405ceb59239c74fb9c319d0c76f6
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 | int ff_mpeg4_get_video_packet_prefix_length(MpegEncContext *s) |
31 | { |
32 | switch (s->pict_type) { |
33 | case AV_PICTURE_TYPE_I: |
34 | return 16; |
35 | case AV_PICTURE_TYPE_P: |
36 | case AV_PICTURE_TYPE_S: |
37 | return s->f_code + 15; |
38 | case AV_PICTURE_TYPE_B: |
39 | return FFMAX3(s->f_code, s->b_code, 2) + 15; |
40 | default: |
41 | return -1; |
42 | } |
43 | } |
44 | |
45 | void ff_mpeg4_clean_buffers(MpegEncContext *s) |
46 | { |
47 | int c_wrap, c_xy, l_wrap, l_xy; |
48 | |
49 | l_wrap = s->b8_stride; |
50 | l_xy = (2 * s->mb_y - 1) * l_wrap + s->mb_x * 2 - 1; |
51 | c_wrap = s->mb_stride; |
52 | c_xy = (s->mb_y - 1) * c_wrap + s->mb_x - 1; |
53 | |
54 | /* clean AC */ |
55 | memset(s->ac_val[0] + l_xy, 0, (l_wrap * 2 + 1) * 16 * sizeof(int16_t)); |
56 | memset(s->ac_val[1] + c_xy, 0, (c_wrap + 1) * 16 * sizeof(int16_t)); |
57 | 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 | s->last_mv[0][0][0] = |
62 | s->last_mv[0][0][1] = |
63 | s->last_mv[1][0][0] = |
64 | s->last_mv[1][0][1] = 0; |
65 | } |
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 | void ff_mpeg4_init_direct_mv(MpegEncContext *s) |
72 | { |
73 | int i; |
74 | for (i = 0; i < tab_size; i++) { |
75 | s->direct_scale_mv[0][i] = (i - tab_bias) * s->pb_time / s->pp_time; |
76 | s->direct_scale_mv[1][i] = (i - tab_bias) * (s->pb_time - s->pp_time) / |
77 | s->pp_time; |
78 | } |
79 | } |
80 | |
81 | static inline void ff_mpeg4_set_one_direct_mv(MpegEncContext *s, int mx, |
82 | int my, int i) |
83 | { |
84 | int xy = s->block_index[i]; |
85 | uint16_t time_pp = s->pp_time; |
86 | uint16_t time_pb = s->pb_time; |
87 | int p_mx, p_my; |
88 | |
89 | p_mx = s->next_picture.motion_val[0][xy][0]; |
90 | if ((unsigned)(p_mx + tab_bias) < tab_size) { |
91 | s->mv[0][i][0] = s->direct_scale_mv[0][p_mx + tab_bias] + mx; |
92 | s->mv[1][i][0] = mx ? s->mv[0][i][0] - p_mx |
93 | : s->direct_scale_mv[1][p_mx + tab_bias]; |
94 | } else { |
95 | s->mv[0][i][0] = p_mx * time_pb / time_pp + mx; |
96 | s->mv[1][i][0] = mx ? s->mv[0][i][0] - p_mx |
97 | : p_mx * (time_pb - time_pp) / time_pp; |
98 | } |
99 | p_my = s->next_picture.motion_val[0][xy][1]; |
100 | if ((unsigned)(p_my + tab_bias) < tab_size) { |
101 | s->mv[0][i][1] = s->direct_scale_mv[0][p_my + tab_bias] + my; |
102 | s->mv[1][i][1] = my ? s->mv[0][i][1] - p_my |
103 | : s->direct_scale_mv[1][p_my + tab_bias]; |
104 | } else { |
105 | s->mv[0][i][1] = p_my * time_pb / time_pp + my; |
106 | s->mv[1][i][1] = my ? s->mv[0][i][1] - p_my |
107 | : p_my * (time_pb - time_pp) / time_pp; |
108 | } |
109 | } |
110 | |
111 | #undef tab_size |
112 | #undef tab_bias |
113 | |
114 | /** |
115 | * @return the mb_type |
116 | */ |
117 | int ff_mpeg4_set_direct_mv(MpegEncContext *s, int mx, int my) |
118 | { |
119 | const int mb_index = s->mb_x + s->mb_y * s->mb_stride; |
120 | 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 | if (IS_8X8(colocated_mb_type)) { |
129 | s->mv_type = MV_TYPE_8X8; |
130 | for (i = 0; i < 4; i++) |
131 | ff_mpeg4_set_one_direct_mv(s, mx, my, i); |
132 | return MB_TYPE_DIRECT2 | MB_TYPE_8x8 | MB_TYPE_L0L1; |
133 | } 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 | ff_mpeg4_set_one_direct_mv(s, mx, my, 0); |
163 | s->mv[0][1][0] = |
164 | s->mv[0][2][0] = |
165 | s->mv[0][3][0] = s->mv[0][0][0]; |
166 | s->mv[0][1][1] = |
167 | s->mv[0][2][1] = |
168 | s->mv[0][3][1] = s->mv[0][0][1]; |
169 | s->mv[1][1][0] = |
170 | s->mv[1][2][0] = |
171 | s->mv[1][3][0] = s->mv[1][0][0]; |
172 | s->mv[1][1][1] = |
173 | s->mv[1][2][1] = |
174 | s->mv[1][3][1] = s->mv[1][0][1]; |
175 | if ((s->avctx->workaround_bugs & FF_BUG_DIRECT_BLOCKSIZE) || |
176 | !s->quarter_sample) |
177 | s->mv_type = MV_TYPE_16X16; |
178 | else |
179 | s->mv_type = MV_TYPE_8X8; |
180 | // Note see prev line |
181 | return MB_TYPE_DIRECT2 | MB_TYPE_16x16 | MB_TYPE_L0L1; |
182 | } |
183 | } |
184 |