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