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