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