Merge commit 'a6a750c7ef240b72ce01e9653343a0ddf247d196'
[ffmpeg.git] / libavcodec / h261enc.c
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 };