3 * Copyright (c) 2002-2004 Michael Niedermayer <michaelni@gmx.at>
4 * Copyright (c) 2004 Maarten Daniels
6 * This file is part of FFmpeg.
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.
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.
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
28 #include "libavutil/attributes.h"
29 #include "libavutil/avassert.h"
31 #include "mpegvideo.h"
35 static uint8_t uni_h261_rl_len [64*64*2*2];
36 #define UNI_ENC_INDEX(last,run,level) ((last)*128*64 + (run)*128 + (level))
38 int ff_h261_get_picture_format(int width, int height)
41 if (width == 176 && height == 144)
44 else if (width == 352 && height == 288)
51 void ff_h261_encode_picture_header(MpegEncContext *s, int picture_number)
53 H261Context *h = (H261Context *)s;
56 avpriv_align_put_bits(&s->pb);
58 /* Update the pointer to last GOB */
59 s->ptr_lastgob = put_bits_ptr(&s->pb);
61 put_bits(&s->pb, 20, 0x10); /* PSC */
63 temp_ref = s->picture_number * (int64_t)30000 * s->avctx->time_base.num /
64 (1001 * (int64_t)s->avctx->time_base.den); // FIXME maybe this should use a timestamp
65 put_sbits(&s->pb, 5, temp_ref); /* TemporalReference */
67 put_bits(&s->pb, 1, 0); /* split screen off */
68 put_bits(&s->pb, 1, 0); /* camera off */
69 put_bits(&s->pb, 1, 0); /* freeze picture release off */
71 format = ff_h261_get_picture_format(s->width, s->height);
73 put_bits(&s->pb, 1, format); /* 0 == QCIF, 1 == CIF */
75 put_bits(&s->pb, 1, 0); /* still image mode */
76 put_bits(&s->pb, 1, 0); /* reserved */
78 put_bits(&s->pb, 1, 0); /* no PEI */
87 * Encode a group of blocks header.
89 static void h261_encode_gob_header(MpegEncContext *s, int mb_line)
91 H261Context *h = (H261Context *)s;
92 if (ff_h261_get_picture_format(s->width, s->height) == 0) {
93 h->gob_number += 2; // QCIF
95 h->gob_number++; // CIF
97 put_bits(&s->pb, 16, 1); /* GBSC */
98 put_bits(&s->pb, 4, h->gob_number); /* GN */
99 put_bits(&s->pb, 5, s->qscale); /* GQUANT */
100 put_bits(&s->pb, 1, 0); /* no GEI */
102 s->last_mv[0][0][0] = 0;
103 s->last_mv[0][0][1] = 0;
106 void ff_h261_reorder_mb_index(MpegEncContext *s)
108 int index = s->mb_x + s->mb_y * s->mb_width;
110 if (index % 11 == 0) {
112 h261_encode_gob_header(s, 0);
113 s->last_mv[0][0][0] = 0;
114 s->last_mv[0][0][1] = 0;
117 /* for CIF the GOB's are fragmented in the middle of a scanline
118 * that's why we need to adjust the x and y index of the macroblocks */
119 if (ff_h261_get_picture_format(s->width, s->height) == 1) { // CIF
120 s->mb_x = index % 11;
124 s->mb_x += 11 * (index % 2);
126 s->mb_y += 3 * index;
128 ff_init_block_index(s);
129 ff_update_block_index(s);
133 static void h261_encode_motion(H261Context *h, int val)
135 MpegEncContext *const s = &h->s;
139 put_bits(&s->pb, ff_h261_mv_tab[code][1], ff_h261_mv_tab[code][0]);
146 code = sign ? -val : val;
147 put_bits(&s->pb, ff_h261_mv_tab[code][1], ff_h261_mv_tab[code][0]);
148 put_bits(&s->pb, 1, sign);
152 static inline int get_cbp(MpegEncContext *s, int16_t block[6][64])
156 for (i = 0; i < 6; i++)
157 if (s->block_last_index[i] >= 0)
163 * Encode an 8x8 block.
164 * @param block the 8x8 block
165 * @param n block index (0-3 are luma, 4-5 are chroma)
167 static void h261_encode_block(H261Context *h, int16_t *block, int n)
169 MpegEncContext *const s = &h->s;
170 int level, run, i, j, last_index, last_non_zero, sign, slevel, code;
173 rl = &ff_h261_rl_tcoeff;
177 /* 255 cannot be represented, so we clamp */
182 /* 0 cannot be represented also */
183 else if (level < 1) {
188 put_bits(&s->pb, 8, 0xff);
190 put_bits(&s->pb, 8, level);
192 } else if ((block[0] == 1 || block[0] == -1) &&
193 (s->block_last_index[n] > -1)) {
195 put_bits(&s->pb, 2, block[0] > 0 ? 2 : 3);
202 last_index = s->block_last_index[n];
203 last_non_zero = i - 1;
204 for (; i <= last_index; i++) {
205 j = s->intra_scantable.permutated[i];
208 run = i - last_non_zero - 1;
215 code = get_rl_index(rl, 0 /*no last in H.261, EOB is used*/,
217 if (run == 0 && level < 16)
219 put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
221 put_bits(&s->pb, 6, run);
222 av_assert1(slevel != 0);
223 av_assert1(level <= 127);
224 put_sbits(&s->pb, 8, slevel);
226 put_bits(&s->pb, 1, sign);
232 put_bits(&s->pb, rl->table_vlc[0][1], rl->table_vlc[0][0]); // EOB
235 void ff_h261_encode_mb(MpegEncContext *s, int16_t block[6][64],
236 int motion_x, int motion_y)
238 H261Context *h = (H261Context *)s;
239 int mvd, mv_diff_x, mv_diff_y, i, cbp;
240 cbp = 63; // avoid warning
247 cbp = get_cbp(s, block);
249 /* mvd indicates if this block is motion compensated */
250 mvd = motion_x | motion_y;
252 if ((cbp | mvd | s->dquant) == 0) {
253 /* skip macroblock */
256 s->last_mv[0][0][0] = 0;
257 s->last_mv[0][0][1] = 0;
262 /* MB is not skipped, encode MBA */
264 ff_h261_mba_bits[s->mb_skip_run],
265 ff_h261_mba_code[s->mb_skip_run]);
268 /* calculate MTYPE */
272 if (mvd || s->loop_filter)
276 if (cbp || s->dquant)
278 av_assert1(h->mtype > 1);
285 ff_h261_mtype_bits[h->mtype],
286 ff_h261_mtype_code[h->mtype]);
288 h->mtype = ff_h261_mtype_map[h->mtype];
290 if (IS_QUANT(h->mtype)) {
291 ff_set_qscale(s, s->qscale + s->dquant);
292 put_bits(&s->pb, 5, s->qscale);
295 if (IS_16X16(h->mtype)) {
296 mv_diff_x = (motion_x >> 1) - s->last_mv[0][0][0];
297 mv_diff_y = (motion_y >> 1) - s->last_mv[0][0][1];
298 s->last_mv[0][0][0] = (motion_x >> 1);
299 s->last_mv[0][0][1] = (motion_y >> 1);
300 h261_encode_motion(h, mv_diff_x);
301 h261_encode_motion(h, mv_diff_y);
304 if (HAS_CBP(h->mtype)) {
307 ff_h261_cbp_tab[cbp - 1][1],
308 ff_h261_cbp_tab[cbp - 1][0]);
310 for (i = 0; i < 6; i++)
311 /* encode each block */
312 h261_encode_block(h, block[i], i);
314 if (!IS_16X16(h->mtype)) {
315 s->last_mv[0][0][0] = 0;
316 s->last_mv[0][0][1] = 0;
320 static av_cold void init_uni_h261_rl_tab(RLTable *rl, uint32_t *bits_tab,
323 int slevel, run, last;
325 av_assert0(MAX_LEVEL >= 64);
326 av_assert0(MAX_RUN >= 63);
328 for(slevel=-64; slevel<64; slevel++){
329 if(slevel==0) continue;
330 for(run=0; run<64; run++){
331 for(last=0; last<=1; last++){
332 const int index= UNI_ENC_INDEX(last, run, slevel+64);
333 int level= slevel < 0 ? -slevel : slevel;
339 code= get_rl_index(rl, 0, run, level);
340 len= rl->table_vlc[code][1] + 1;
344 if(code!=rl->n && len < len_tab[index]){
345 len_tab [index]= len;
348 len = rl->table_vlc[rl->n][1];
352 if(len < len_tab[index]){
353 len_tab [index]= len;
360 av_cold void ff_h261_encode_init(MpegEncContext *s)
362 ff_h261_common_init();
364 s->min_qcoeff = -127;
366 s->y_dc_scale_table =
367 s->c_dc_scale_table = ff_mpeg1_dc_scale_table;
368 s->ac_esc_length = 6+6+8;
370 init_uni_h261_rl_tab(&ff_h261_rl_tcoeff, NULL, uni_h261_rl_len);
372 s->intra_ac_vlc_length = s->inter_ac_vlc_length = uni_h261_rl_len;
373 s->intra_ac_vlc_last_length = s->inter_ac_vlc_last_length = uni_h261_rl_len + 128*64;
376 FF_MPV_GENERIC_CLASS(h261)
378 AVCodec ff_h261_encoder = {
380 .long_name = NULL_IF_CONFIG_SMALL("H.261"),
381 .type = AVMEDIA_TYPE_VIDEO,
382 .id = AV_CODEC_ID_H261,
383 .priv_data_size = sizeof(H261Context),
384 .init = ff_MPV_encode_init,
385 .encode2 = ff_MPV_encode_picture,
386 .close = ff_MPV_encode_end,
387 .pix_fmts = (const enum AVPixelFormat[]) { AV_PIX_FMT_YUV420P,
389 .priv_class = &h261_class,