1 |
|
|
/* |
2 |
|
|
* H.261 encoder |
3 |
|
|
* Copyright (c) 2002-2004 Michael Niedermayer <michaelni@gmx.at> |
4 |
|
|
* Copyright (c) 2004 Maarten Daniels |
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 |
|
|
/** |
24 |
|
|
* @file |
25 |
|
|
* H.261 encoder. |
26 |
|
|
*/ |
27 |
|
|
|
28 |
|
|
#include "libavutil/attributes.h" |
29 |
|
|
#include "libavutil/avassert.h" |
30 |
|
|
#include "avcodec.h" |
31 |
|
|
#include "mpegutils.h" |
32 |
|
|
#include "mpegvideo.h" |
33 |
|
|
#include "h263.h" |
34 |
|
|
#include "h261.h" |
35 |
|
|
#include "mpegvideodata.h" |
36 |
|
|
|
37 |
|
|
static uint8_t uni_h261_rl_len [64*64*2*2]; |
38 |
|
|
#define UNI_ENC_INDEX(last,run,level) ((last)*128*64 + (run)*128 + (level)) |
39 |
|
|
|
40 |
|
122706 |
int ff_h261_get_picture_format(int width, int height) |
41 |
|
|
{ |
42 |
|
|
// QCIF |
43 |
✗✓✗✗
|
122706 |
if (width == 176 && height == 144) |
44 |
|
|
return 0; |
45 |
|
|
// CIF |
46 |
✓✗✓✗
|
122706 |
else if (width == 352 && height == 288) |
47 |
|
122706 |
return 1; |
48 |
|
|
// ERROR |
49 |
|
|
else |
50 |
|
|
return AVERROR(EINVAL); |
51 |
|
|
} |
52 |
|
|
|
53 |
|
300 |
void ff_h261_encode_picture_header(MpegEncContext *s, int picture_number) |
54 |
|
|
{ |
55 |
|
300 |
H261Context *h = (H261Context *)s; |
56 |
|
|
int format, temp_ref; |
57 |
|
|
|
58 |
|
300 |
align_put_bits(&s->pb); |
59 |
|
|
|
60 |
|
|
/* Update the pointer to last GOB */ |
61 |
|
300 |
s->ptr_lastgob = put_bits_ptr(&s->pb); |
62 |
|
|
|
63 |
|
300 |
put_bits(&s->pb, 20, 0x10); /* PSC */ |
64 |
|
|
|
65 |
|
300 |
temp_ref = s->picture_number * 30000LL * s->avctx->time_base.num / |
66 |
|
300 |
(1001LL * s->avctx->time_base.den); // FIXME maybe this should use a timestamp |
67 |
|
300 |
put_sbits(&s->pb, 5, temp_ref); /* TemporalReference */ |
68 |
|
|
|
69 |
|
300 |
put_bits(&s->pb, 1, 0); /* split screen off */ |
70 |
|
300 |
put_bits(&s->pb, 1, 0); /* camera off */ |
71 |
|
300 |
put_bits(&s->pb, 1, s->pict_type == AV_PICTURE_TYPE_I); /* freeze picture release on/off */ |
72 |
|
|
|
73 |
|
300 |
format = ff_h261_get_picture_format(s->width, s->height); |
74 |
|
|
|
75 |
|
300 |
put_bits(&s->pb, 1, format); /* 0 == QCIF, 1 == CIF */ |
76 |
|
|
|
77 |
|
300 |
put_bits(&s->pb, 1, 1); /* still image mode */ |
78 |
|
300 |
put_bits(&s->pb, 1, 1); /* reserved */ |
79 |
|
|
|
80 |
|
300 |
put_bits(&s->pb, 1, 0); /* no PEI */ |
81 |
✗✓ |
300 |
if (format == 0) |
82 |
|
|
h->gob_number = -1; |
83 |
|
|
else |
84 |
|
300 |
h->gob_number = 0; |
85 |
|
300 |
s->mb_skip_run = 0; |
86 |
|
300 |
} |
87 |
|
|
|
88 |
|
|
/** |
89 |
|
|
* Encode a group of blocks header. |
90 |
|
|
*/ |
91 |
|
3600 |
static void h261_encode_gob_header(MpegEncContext *s, int mb_line) |
92 |
|
|
{ |
93 |
|
3600 |
H261Context *h = (H261Context *)s; |
94 |
✗✓ |
3600 |
if (ff_h261_get_picture_format(s->width, s->height) == 0) { |
95 |
|
|
h->gob_number += 2; // QCIF |
96 |
|
|
} else { |
97 |
|
3600 |
h->gob_number++; // CIF |
98 |
|
|
} |
99 |
|
3600 |
put_bits(&s->pb, 16, 1); /* GBSC */ |
100 |
|
3600 |
put_bits(&s->pb, 4, h->gob_number); /* GN */ |
101 |
|
3600 |
put_bits(&s->pb, 5, s->qscale); /* GQUANT */ |
102 |
|
3600 |
put_bits(&s->pb, 1, 0); /* no GEI */ |
103 |
|
3600 |
s->mb_skip_run = 0; |
104 |
|
3600 |
s->last_mv[0][0][0] = 0; |
105 |
|
3600 |
s->last_mv[0][0][1] = 0; |
106 |
|
3600 |
} |
107 |
|
|
|
108 |
|
118800 |
void ff_h261_reorder_mb_index(MpegEncContext *s) |
109 |
|
|
{ |
110 |
|
118800 |
int index = s->mb_x + s->mb_y * s->mb_width; |
111 |
|
|
|
112 |
✓✓ |
118800 |
if (index % 11 == 0) { |
113 |
✓✓ |
10800 |
if (index % 33 == 0) |
114 |
|
3600 |
h261_encode_gob_header(s, 0); |
115 |
|
10800 |
s->last_mv[0][0][0] = 0; |
116 |
|
10800 |
s->last_mv[0][0][1] = 0; |
117 |
|
|
} |
118 |
|
|
|
119 |
|
|
/* for CIF the GOB's are fragmented in the middle of a scanline |
120 |
|
|
* that's why we need to adjust the x and y index of the macroblocks */ |
121 |
✓✗ |
118800 |
if (ff_h261_get_picture_format(s->width, s->height) == 1) { // CIF |
122 |
|
118800 |
s->mb_x = index % 11; |
123 |
|
118800 |
index /= 11; |
124 |
|
118800 |
s->mb_y = index % 3; |
125 |
|
118800 |
index /= 3; |
126 |
|
118800 |
s->mb_x += 11 * (index % 2); |
127 |
|
118800 |
index /= 2; |
128 |
|
118800 |
s->mb_y += 3 * index; |
129 |
|
|
|
130 |
|
118800 |
ff_init_block_index(s); |
131 |
|
118800 |
ff_update_block_index(s); |
132 |
|
|
} |
133 |
|
118800 |
} |
134 |
|
|
|
135 |
|
201048 |
static void h261_encode_motion(H261Context *h, int val) |
136 |
|
|
{ |
137 |
|
201048 |
MpegEncContext *const s = &h->s; |
138 |
|
|
int sign, code; |
139 |
✓✓ |
201048 |
if (val == 0) { |
140 |
|
113914 |
code = 0; |
141 |
|
113914 |
put_bits(&s->pb, ff_h261_mv_tab[code][1], ff_h261_mv_tab[code][0]); |
142 |
|
|
} else { |
143 |
✓✓ |
87134 |
if (val > 15) |
144 |
|
45 |
val -= 32; |
145 |
✓✓ |
87134 |
if (val < -16) |
146 |
|
35 |
val += 32; |
147 |
|
87134 |
sign = val < 0; |
148 |
✓✓ |
87134 |
code = sign ? -val : val; |
149 |
|
87134 |
put_bits(&s->pb, ff_h261_mv_tab[code][1], ff_h261_mv_tab[code][0]); |
150 |
|
87134 |
put_bits(&s->pb, 1, sign); |
151 |
|
|
} |
152 |
|
201048 |
} |
153 |
|
|
|
154 |
|
104856 |
static inline int get_cbp(MpegEncContext *s, int16_t block[6][64]) |
155 |
|
|
{ |
156 |
|
|
int i, cbp; |
157 |
|
104856 |
cbp = 0; |
158 |
✓✓ |
733992 |
for (i = 0; i < 6; i++) |
159 |
✓✓ |
629136 |
if (s->block_last_index[i] >= 0) |
160 |
|
261040 |
cbp |= 1 << (5 - i); |
161 |
|
104856 |
return cbp; |
162 |
|
|
} |
163 |
|
|
|
164 |
|
|
/** |
165 |
|
|
* Encode an 8x8 block. |
166 |
|
|
* @param block the 8x8 block |
167 |
|
|
* @param n block index (0-3 are luma, 4-5 are chroma) |
168 |
|
|
*/ |
169 |
|
796752 |
static void h261_encode_block(H261Context *h, int16_t *block, int n) |
170 |
|
|
{ |
171 |
|
796752 |
MpegEncContext *const s = &h->s; |
172 |
|
|
int level, run, i, j, last_index, last_non_zero, sign, slevel, code; |
173 |
|
|
RLTable *rl; |
174 |
|
|
|
175 |
|
796752 |
rl = &ff_h261_rl_tcoeff; |
176 |
✓✓ |
796752 |
if (s->mb_intra) { |
177 |
|
|
/* DC coef */ |
178 |
|
172932 |
level = block[0]; |
179 |
|
|
/* 255 cannot be represented, so we clamp */ |
180 |
✗✓ |
172932 |
if (level > 254) { |
181 |
|
|
level = 254; |
182 |
|
|
block[0] = 254; |
183 |
|
|
} |
184 |
|
|
/* 0 cannot be represented also */ |
185 |
✗✓ |
172932 |
else if (level < 1) { |
186 |
|
|
level = 1; |
187 |
|
|
block[0] = 1; |
188 |
|
|
} |
189 |
✓✓ |
172932 |
if (level == 128) |
190 |
|
2093 |
put_bits(&s->pb, 8, 0xff); |
191 |
|
|
else |
192 |
|
170839 |
put_bits(&s->pb, 8, level); |
193 |
|
172932 |
i = 1; |
194 |
✓✓✓✓
|
623820 |
} else if ((block[0] == 1 || block[0] == -1) && |
195 |
✓✓ |
121289 |
(s->block_last_index[n] > -1)) { |
196 |
|
|
// special case |
197 |
✓✓ |
85981 |
put_bits(&s->pb, 2, block[0] > 0 ? 2 : 3); |
198 |
|
85981 |
i = 1; |
199 |
|
|
} else { |
200 |
|
537839 |
i = 0; |
201 |
|
|
} |
202 |
|
|
|
203 |
|
|
/* AC coefs */ |
204 |
|
796752 |
last_index = s->block_last_index[n]; |
205 |
|
796752 |
last_non_zero = i - 1; |
206 |
✓✓ |
10146069 |
for (; i <= last_index; i++) { |
207 |
|
9349317 |
j = s->intra_scantable.permutated[i]; |
208 |
|
9349317 |
level = block[j]; |
209 |
✓✓ |
9349317 |
if (level) { |
210 |
|
2765550 |
run = i - last_non_zero - 1; |
211 |
|
2765550 |
sign = 0; |
212 |
|
2765550 |
slevel = level; |
213 |
✓✓ |
2765550 |
if (level < 0) { |
214 |
|
1382173 |
sign = 1; |
215 |
|
1382173 |
level = -level; |
216 |
|
|
} |
217 |
|
2765550 |
code = get_rl_index(rl, 0 /*no last in H.261, EOB is used*/, |
218 |
|
|
run, level); |
219 |
✓✓✓✓
|
2765550 |
if (run == 0 && level < 16) |
220 |
|
1458226 |
code += 1; |
221 |
|
2765550 |
put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]); |
222 |
✓✓ |
2765550 |
if (code == rl->n) { |
223 |
|
72326 |
put_bits(&s->pb, 6, run); |
224 |
|
|
av_assert1(slevel != 0); |
225 |
|
|
av_assert1(level <= 127); |
226 |
|
72326 |
put_sbits(&s->pb, 8, slevel); |
227 |
|
|
} else { |
228 |
|
2693224 |
put_bits(&s->pb, 1, sign); |
229 |
|
|
} |
230 |
|
2765550 |
last_non_zero = i; |
231 |
|
|
} |
232 |
|
|
} |
233 |
✓✓ |
796752 |
if (last_index > -1) |
234 |
|
433972 |
put_bits(&s->pb, rl->table_vlc[0][1], rl->table_vlc[0][0]); // EOB |
235 |
|
796752 |
} |
236 |
|
|
|
237 |
|
133678 |
void ff_h261_encode_mb(MpegEncContext *s, int16_t block[6][64], |
238 |
|
|
int motion_x, int motion_y) |
239 |
|
|
{ |
240 |
|
133678 |
H261Context *h = (H261Context *)s; |
241 |
|
|
int mvd, mv_diff_x, mv_diff_y, i, cbp; |
242 |
|
133678 |
cbp = 63; // avoid warning |
243 |
|
133678 |
mvd = 0; |
244 |
|
|
|
245 |
|
133678 |
h->mtype = 0; |
246 |
|
|
|
247 |
✓✓ |
133678 |
if (!s->mb_intra) { |
248 |
|
|
/* compute cbp */ |
249 |
|
104856 |
cbp = get_cbp(s, block); |
250 |
|
|
|
251 |
|
|
/* mvd indicates if this block is motion compensated */ |
252 |
|
104856 |
mvd = motion_x | motion_y; |
253 |
|
|
|
254 |
✓✓ |
104856 |
if ((cbp | mvd) == 0) { |
255 |
|
|
/* skip macroblock */ |
256 |
|
886 |
s->skip_count++; |
257 |
|
886 |
s->mb_skip_run++; |
258 |
|
886 |
s->last_mv[0][0][0] = 0; |
259 |
|
886 |
s->last_mv[0][0][1] = 0; |
260 |
|
886 |
s->qscale -= s->dquant; |
261 |
|
886 |
return; |
262 |
|
|
} |
263 |
|
|
} |
264 |
|
|
|
265 |
|
|
/* MB is not skipped, encode MBA */ |
266 |
|
132792 |
put_bits(&s->pb, |
267 |
|
132792 |
ff_h261_mba_bits[s->mb_skip_run], |
268 |
|
132792 |
ff_h261_mba_code[s->mb_skip_run]); |
269 |
|
132792 |
s->mb_skip_run = 0; |
270 |
|
|
|
271 |
|
|
/* calculate MTYPE */ |
272 |
✓✓ |
132792 |
if (!s->mb_intra) { |
273 |
|
103970 |
h->mtype++; |
274 |
|
|
|
275 |
✓✓✗✓
|
103970 |
if (mvd || s->loop_filter) |
276 |
|
100524 |
h->mtype += 3; |
277 |
✗✓ |
103970 |
if (s->loop_filter) |
278 |
|
|
h->mtype += 3; |
279 |
✓✓ |
103970 |
if (cbp) |
280 |
|
84380 |
h->mtype++; |
281 |
|
|
av_assert1(h->mtype > 1); |
282 |
|
|
} |
283 |
|
|
|
284 |
✗✓✗✗
|
132792 |
if (s->dquant && cbp) { |
285 |
|
|
h->mtype++; |
286 |
|
|
} else |
287 |
|
132792 |
s->qscale -= s->dquant; |
288 |
|
|
|
289 |
|
132792 |
put_bits(&s->pb, |
290 |
|
132792 |
ff_h261_mtype_bits[h->mtype], |
291 |
|
132792 |
ff_h261_mtype_code[h->mtype]); |
292 |
|
|
|
293 |
|
132792 |
h->mtype = ff_h261_mtype_map[h->mtype]; |
294 |
|
|
|
295 |
✗✓ |
132792 |
if (IS_QUANT(h->mtype)) { |
296 |
|
|
ff_set_qscale(s, s->qscale + s->dquant); |
297 |
|
|
put_bits(&s->pb, 5, s->qscale); |
298 |
|
|
} |
299 |
|
|
|
300 |
✓✓ |
132792 |
if (IS_16X16(h->mtype)) { |
301 |
|
100524 |
mv_diff_x = (motion_x >> 1) - s->last_mv[0][0][0]; |
302 |
|
100524 |
mv_diff_y = (motion_y >> 1) - s->last_mv[0][0][1]; |
303 |
|
100524 |
s->last_mv[0][0][0] = (motion_x >> 1); |
304 |
|
100524 |
s->last_mv[0][0][1] = (motion_y >> 1); |
305 |
|
100524 |
h261_encode_motion(h, mv_diff_x); |
306 |
|
100524 |
h261_encode_motion(h, mv_diff_y); |
307 |
|
|
} |
308 |
|
|
|
309 |
✓✓ |
132792 |
if (HAS_CBP(h->mtype)) { |
310 |
|
|
av_assert1(cbp > 0); |
311 |
|
84380 |
put_bits(&s->pb, |
312 |
|
84380 |
ff_h261_cbp_tab[cbp - 1][1], |
313 |
|
84380 |
ff_h261_cbp_tab[cbp - 1][0]); |
314 |
|
|
} |
315 |
✓✓ |
929544 |
for (i = 0; i < 6; i++) |
316 |
|
|
/* encode each block */ |
317 |
|
796752 |
h261_encode_block(h, block[i], i); |
318 |
|
|
|
319 |
✓✓ |
132792 |
if (!IS_16X16(h->mtype)) { |
320 |
|
32268 |
s->last_mv[0][0][0] = 0; |
321 |
|
32268 |
s->last_mv[0][0][1] = 0; |
322 |
|
|
} |
323 |
|
|
} |
324 |
|
|
|
325 |
|
6 |
static av_cold void init_uni_h261_rl_tab(const RLTable *rl, uint8_t *len_tab) |
326 |
|
|
{ |
327 |
|
|
int slevel, run, last; |
328 |
|
|
|
329 |
|
|
av_assert0(MAX_LEVEL >= 64); |
330 |
|
|
av_assert0(MAX_RUN >= 63); |
331 |
|
|
|
332 |
✓✓ |
774 |
for(slevel=-64; slevel<64; slevel++){ |
333 |
✓✓ |
768 |
if(slevel==0) continue; |
334 |
✓✓ |
49530 |
for(run=0; run<64; run++){ |
335 |
✓✓ |
146304 |
for(last=0; last<=1; last++){ |
336 |
|
97536 |
const int index= UNI_ENC_INDEX(last, run, slevel+64); |
337 |
|
97536 |
int level= slevel < 0 ? -slevel : slevel; |
338 |
|
|
int len, code; |
339 |
|
|
|
340 |
|
97536 |
len_tab[index]= 100; |
341 |
|
|
|
342 |
|
|
/* ESC0 */ |
343 |
|
97536 |
code= get_rl_index(rl, 0, run, level); |
344 |
|
97536 |
len= rl->table_vlc[code][1] + 1; |
345 |
✓✓ |
97536 |
if(last) |
346 |
|
48768 |
len += 2; |
347 |
|
|
|
348 |
✓✓✓✗
|
97536 |
if(code!=rl->n && len < len_tab[index]){ |
349 |
|
1512 |
len_tab [index]= len; |
350 |
|
|
} |
351 |
|
|
/* ESC */ |
352 |
|
97536 |
len = rl->table_vlc[rl->n][1]; |
353 |
✓✓ |
97536 |
if(last) |
354 |
|
48768 |
len += 2; |
355 |
|
|
|
356 |
✓✓ |
97536 |
if(len < len_tab[index]){ |
357 |
|
97344 |
len_tab [index]= len; |
358 |
|
|
} |
359 |
|
|
} |
360 |
|
|
} |
361 |
|
|
} |
362 |
|
6 |
} |
363 |
|
|
|
364 |
|
6 |
av_cold void ff_h261_encode_init(MpegEncContext *s) |
365 |
|
|
{ |
366 |
|
6 |
ff_h261_common_init(); |
367 |
|
|
|
368 |
|
6 |
s->min_qcoeff = -127; |
369 |
|
6 |
s->max_qcoeff = 127; |
370 |
|
6 |
s->y_dc_scale_table = |
371 |
|
6 |
s->c_dc_scale_table = ff_mpeg1_dc_scale_table; |
372 |
|
6 |
s->ac_esc_length = 6+6+8; |
373 |
|
|
|
374 |
|
6 |
init_uni_h261_rl_tab(&ff_h261_rl_tcoeff, uni_h261_rl_len); |
375 |
|
|
|
376 |
|
6 |
s->intra_ac_vlc_length = s->inter_ac_vlc_length = uni_h261_rl_len; |
377 |
|
6 |
s->intra_ac_vlc_last_length = s->inter_ac_vlc_last_length = uni_h261_rl_len + 128*64; |
378 |
|
6 |
} |
379 |
|
|
|
380 |
|
|
static const AVClass h261_class = { |
381 |
|
|
.class_name = "h261 encoder", |
382 |
|
|
.item_name = av_default_item_name, |
383 |
|
|
.option = ff_mpv_generic_options, |
384 |
|
|
.version = LIBAVUTIL_VERSION_INT, |
385 |
|
|
}; |
386 |
|
|
|
387 |
|
|
AVCodec ff_h261_encoder = { |
388 |
|
|
.name = "h261", |
389 |
|
|
.long_name = NULL_IF_CONFIG_SMALL("H.261"), |
390 |
|
|
.type = AVMEDIA_TYPE_VIDEO, |
391 |
|
|
.id = AV_CODEC_ID_H261, |
392 |
|
|
.priv_data_size = sizeof(H261Context), |
393 |
|
|
.init = ff_mpv_encode_init, |
394 |
|
|
.encode2 = ff_mpv_encode_picture, |
395 |
|
|
.close = ff_mpv_encode_end, |
396 |
|
|
.caps_internal = FF_CODEC_CAP_INIT_CLEANUP, |
397 |
|
|
.pix_fmts = (const enum AVPixelFormat[]) { AV_PIX_FMT_YUV420P, |
398 |
|
|
AV_PIX_FMT_NONE }, |
399 |
|
|
.priv_class = &h261_class, |
400 |
|
|
}; |