mpegvideo: move mpegvideo formats-related defines to mpegutils.h
[ffmpeg.git] / libavcodec / h261enc.c
1 /*
2  * H261 encoder
3  * Copyright (c) 2002-2004 Michael Niedermayer <michaelni@gmx.at>
4  * Copyright (c) 2004 Maarten Daniels
5  *
6  * This file is part of Libav.
7  *
8  * Libav 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  * Libav 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 Libav; 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 "avcodec.h"
30 #include "mpegutils.h"
31 #include "mpegvideo.h"
32 #include "h263.h"
33 #include "h261.h"
34
35 int ff_h261_get_picture_format(int width, int height)
36 {
37     // QCIF
38     if (width == 176 && height == 144)
39         return 0;
40     // CIF
41     else if (width == 352 && height == 288)
42         return 1;
43     // ERROR
44     else
45         return -1;
46 }
47
48 void ff_h261_encode_picture_header(MpegEncContext *s, int picture_number)
49 {
50     H261Context *h = (H261Context *)s;
51     int format, temp_ref;
52
53     avpriv_align_put_bits(&s->pb);
54
55     /* Update the pointer to last GOB */
56     s->ptr_lastgob = put_bits_ptr(&s->pb);
57
58     put_bits(&s->pb, 20, 0x10); /* PSC */
59
60     temp_ref = s->picture_number * (int64_t)30000 * s->avctx->time_base.num /
61                (1001 * (int64_t)s->avctx->time_base.den);   // FIXME maybe this should use a timestamp
62     put_sbits(&s->pb, 5, temp_ref); /* TemporalReference */
63
64     put_bits(&s->pb, 1, 0); /* split screen off */
65     put_bits(&s->pb, 1, 0); /* camera  off */
66     put_bits(&s->pb, 1, 0); /* freeze picture release off */
67
68     format = ff_h261_get_picture_format(s->width, s->height);
69
70     put_bits(&s->pb, 1, format); /* 0 == QCIF, 1 == CIF */
71
72     put_bits(&s->pb, 1, 0); /* still image mode */
73     put_bits(&s->pb, 1, 0); /* reserved */
74
75     put_bits(&s->pb, 1, 0); /* no PEI */
76     if (format == 0)
77         h->gob_number = -1;
78     else
79         h->gob_number = 0;
80     h->current_mba = 0;
81 }
82
83 /**
84  * Encode a group of blocks header.
85  */
86 static void h261_encode_gob_header(MpegEncContext *s, int mb_line)
87 {
88     H261Context *h = (H261Context *)s;
89     if (ff_h261_get_picture_format(s->width, s->height) == 0) {
90         h->gob_number += 2; // QCIF
91     } else {
92         h->gob_number++;    // CIF
93     }
94     put_bits(&s->pb, 16, 1);            /* GBSC */
95     put_bits(&s->pb, 4, h->gob_number); /* GN */
96     put_bits(&s->pb, 5, s->qscale);     /* GQUANT */
97     put_bits(&s->pb, 1, 0);             /* no GEI */
98     h->current_mba  = 0;
99     h->previous_mba = 0;
100     h->current_mv_x = 0;
101     h->current_mv_y = 0;
102 }
103
104 void ff_h261_reorder_mb_index(MpegEncContext *s)
105 {
106     int index = s->mb_x + s->mb_y * s->mb_width;
107
108     if (index % 33 == 0)
109         h261_encode_gob_header(s, 0);
110
111     /* for CIF the GOB's are fragmented in the middle of a scanline
112      * that's why we need to adjust the x and y index of the macroblocks */
113     if (ff_h261_get_picture_format(s->width, s->height) == 1) { // CIF
114         s->mb_x  = index % 11;
115         index   /= 11;
116         s->mb_y  = index % 3;
117         index   /= 3;
118         s->mb_x += 11 * (index % 2);
119         index   /= 2;
120         s->mb_y += 3 * index;
121
122         ff_init_block_index(s);
123         ff_update_block_index(s);
124     }
125 }
126
127 static void h261_encode_motion(H261Context *h, int val)
128 {
129     MpegEncContext *const s = &h->s;
130     int sign, code;
131     if (val == 0) {
132         code = 0;
133         put_bits(&s->pb, ff_h261_mv_tab[code][1], ff_h261_mv_tab[code][0]);
134     } else {
135         if (val > 15)
136             val -= 32;
137         if (val < -16)
138             val += 32;
139         sign = val < 0;
140         code = sign ? -val : val;
141         put_bits(&s->pb, ff_h261_mv_tab[code][1], ff_h261_mv_tab[code][0]);
142         put_bits(&s->pb, 1, sign);
143     }
144 }
145
146 static inline int get_cbp(MpegEncContext *s, int16_t block[6][64])
147 {
148     int i, cbp;
149     cbp = 0;
150     for (i = 0; i < 6; i++)
151         if (s->block_last_index[i] >= 0)
152             cbp |= 1 << (5 - i);
153     return cbp;
154 }
155
156 /**
157  * Encode an 8x8 block.
158  * @param block the 8x8 block
159  * @param n block index (0-3 are luma, 4-5 are chroma)
160  */
161 static void h261_encode_block(H261Context *h, int16_t *block, int n)
162 {
163     MpegEncContext *const s = &h->s;
164     int level, run, i, j, last_index, last_non_zero, sign, slevel, code;
165     RLTable *rl;
166
167     rl = &ff_h261_rl_tcoeff;
168     if (s->mb_intra) {
169         /* DC coef */
170         level = block[0];
171         /* 255 cannot be represented, so we clamp */
172         if (level > 254) {
173             level    = 254;
174             block[0] = 254;
175         }
176         /* 0 cannot be represented also */
177         else if (level < 1) {
178             level    = 1;
179             block[0] = 1;
180         }
181         if (level == 128)
182             put_bits(&s->pb, 8, 0xff);
183         else
184             put_bits(&s->pb, 8, level);
185         i = 1;
186     } else if ((block[0] == 1 || block[0] == -1) &&
187                (s->block_last_index[n] > -1)) {
188         // special case
189         put_bits(&s->pb, 2, block[0] > 0 ? 2 : 3);
190         i = 1;
191     } else {
192         i = 0;
193     }
194
195     /* AC coefs */
196     last_index    = s->block_last_index[n];
197     last_non_zero = i - 1;
198     for (; i <= last_index; i++) {
199         j     = s->intra_scantable.permutated[i];
200         level = block[j];
201         if (level) {
202             run    = i - last_non_zero - 1;
203             sign   = 0;
204             slevel = level;
205             if (level < 0) {
206                 sign  = 1;
207                 level = -level;
208             }
209             code = get_rl_index(rl, 0 /*no last in H.261, EOB is used*/,
210                                 run, level);
211             if (run == 0 && level < 16)
212                 code += 1;
213             put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
214             if (code == rl->n) {
215                 put_bits(&s->pb, 6, run);
216                 assert(slevel != 0);
217                 assert(level <= 127);
218                 put_sbits(&s->pb, 8, slevel);
219             } else {
220                 put_bits(&s->pb, 1, sign);
221             }
222             last_non_zero = i;
223         }
224     }
225     if (last_index > -1)
226         put_bits(&s->pb, rl->table_vlc[0][1], rl->table_vlc[0][0]); // EOB
227 }
228
229 void ff_h261_encode_mb(MpegEncContext *s, int16_t block[6][64],
230                        int motion_x, int motion_y)
231 {
232     H261Context *h = (H261Context *)s;
233     int mvd, mv_diff_x, mv_diff_y, i, cbp;
234     cbp = 63; // avoid warning
235     mvd = 0;
236
237     h->current_mba++;
238     h->mtype = 0;
239
240     if (!s->mb_intra) {
241         /* compute cbp */
242         cbp = get_cbp(s, block);
243
244         /* mvd indicates if this block is motion compensated */
245         mvd = motion_x | motion_y;
246
247         if ((cbp | mvd | s->dquant) == 0) {
248             /* skip macroblock */
249             s->skip_count++;
250             h->current_mv_x = 0;
251             h->current_mv_y = 0;
252             return;
253         }
254     }
255
256     /* MB is not skipped, encode MBA */
257     put_bits(&s->pb,
258              ff_h261_mba_bits[(h->current_mba - h->previous_mba) - 1],
259              ff_h261_mba_code[(h->current_mba - h->previous_mba) - 1]);
260
261     /* calculate MTYPE */
262     if (!s->mb_intra) {
263         h->mtype++;
264
265         if (mvd || s->loop_filter)
266             h->mtype += 3;
267         if (s->loop_filter)
268             h->mtype += 3;
269         if (cbp || s->dquant)
270             h->mtype++;
271         assert(h->mtype > 1);
272     }
273
274     if (s->dquant)
275         h->mtype++;
276
277     put_bits(&s->pb,
278              ff_h261_mtype_bits[h->mtype],
279              ff_h261_mtype_code[h->mtype]);
280
281     h->mtype = ff_h261_mtype_map[h->mtype];
282
283     if (IS_QUANT(h->mtype)) {
284         ff_set_qscale(s, s->qscale + s->dquant);
285         put_bits(&s->pb, 5, s->qscale);
286     }
287
288     if (IS_16X16(h->mtype)) {
289         mv_diff_x       = (motion_x >> 1) - h->current_mv_x;
290         mv_diff_y       = (motion_y >> 1) - h->current_mv_y;
291         h->current_mv_x = (motion_x >> 1);
292         h->current_mv_y = (motion_y >> 1);
293         h261_encode_motion(h, mv_diff_x);
294         h261_encode_motion(h, mv_diff_y);
295     }
296
297     h->previous_mba = h->current_mba;
298
299     if (HAS_CBP(h->mtype)) {
300         assert(cbp > 0);
301         put_bits(&s->pb,
302                  ff_h261_cbp_tab[cbp - 1][1],
303                  ff_h261_cbp_tab[cbp - 1][0]);
304     }
305     for (i = 0; i < 6; i++)
306         /* encode each block */
307         h261_encode_block(h, block[i], i);
308
309     if ((h->current_mba == 11) || (h->current_mba == 22) ||
310         (h->current_mba == 33) || (!IS_16X16(h->mtype))) {
311         h->current_mv_x = 0;
312         h->current_mv_y = 0;
313     }
314 }
315
316 av_cold void ff_h261_encode_init(MpegEncContext *s)
317 {
318     ff_h261_common_init();
319
320     s->min_qcoeff       = -127;
321     s->max_qcoeff       = 127;
322     s->y_dc_scale_table =
323     s->c_dc_scale_table = ff_mpeg1_dc_scale_table;
324 }
325
326 FF_MPV_GENERIC_CLASS(h261)
327
328 AVCodec ff_h261_encoder = {
329     .name           = "h261",
330     .long_name      = NULL_IF_CONFIG_SMALL("H.261"),
331     .type           = AVMEDIA_TYPE_VIDEO,
332     .id             = AV_CODEC_ID_H261,
333     .priv_data_size = sizeof(H261Context),
334     .init           = ff_MPV_encode_init,
335     .encode2        = ff_MPV_encode_picture,
336     .close          = ff_MPV_encode_end,
337     .pix_fmts       = (const enum AVPixelFormat[]) { AV_PIX_FMT_YUV420P,
338                                                      AV_PIX_FMT_NONE },
339     .priv_class     = &h261_class,
340 };