FFmpeg
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
h261enc.c
Go to the documentation of this file.
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 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 "mpegvideo.h"
32 #include "h263.h"
33 #include "h261.h"
34 
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))
37 
39 {
40  // QCIF
41  if (width == 176 && height == 144)
42  return 0;
43  // CIF
44  else if (width == 352 && height == 288)
45  return 1;
46  // ERROR
47  else
48  return -1;
49 }
50 
52 {
53  H261Context *h = (H261Context *)s;
54  int format, temp_ref;
55 
57 
58  /* Update the pointer to last GOB */
59  s->ptr_lastgob = put_bits_ptr(&s->pb);
60 
61  put_bits(&s->pb, 20, 0x10); /* PSC */
62 
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 */
66 
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 */
70 
71  format = ff_h261_get_picture_format(s->width, s->height);
72 
73  put_bits(&s->pb, 1, format); /* 0 == QCIF, 1 == CIF */
74 
75  put_bits(&s->pb, 1, 0); /* still image mode */
76  put_bits(&s->pb, 1, 0); /* reserved */
77 
78  put_bits(&s->pb, 1, 0); /* no PEI */
79  if (format == 0)
80  h->gob_number = -1;
81  else
82  h->gob_number = 0;
83  s->mb_skip_run = 0;
84 }
85 
86 /**
87  * Encode a group of blocks header.
88  */
89 static void h261_encode_gob_header(MpegEncContext *s, int mb_line)
90 {
91  H261Context *h = (H261Context *)s;
92  if (ff_h261_get_picture_format(s->width, s->height) == 0) {
93  h->gob_number += 2; // QCIF
94  } else {
95  h->gob_number++; // CIF
96  }
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 */
101  s->mb_skip_run = 0;
102  s->last_mv[0][0][0] = 0;
103  s->last_mv[0][0][1] = 0;
104 }
105 
107 {
108  int index = s->mb_x + s->mb_y * s->mb_width;
109 
110  if (index % 11 == 0) {
111  if (index % 33 == 0)
113  s->last_mv[0][0][0] = 0;
114  s->last_mv[0][0][1] = 0;
115  }
116 
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;
121  index /= 11;
122  s->mb_y = index % 3;
123  index /= 3;
124  s->mb_x += 11 * (index % 2);
125  index /= 2;
126  s->mb_y += 3 * index;
127 
130  }
131 }
132 
133 static void h261_encode_motion(H261Context *h, int val)
134 {
135  MpegEncContext *const s = &h->s;
136  int sign, code;
137  if (val == 0) {
138  code = 0;
139  put_bits(&s->pb, ff_h261_mv_tab[code][1], ff_h261_mv_tab[code][0]);
140  } else {
141  if (val > 15)
142  val -= 32;
143  if (val < -16)
144  val += 32;
145  sign = val < 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);
149  }
150 }
151 
152 static inline int get_cbp(MpegEncContext *s, int16_t block[6][64])
153 {
154  int i, cbp;
155  cbp = 0;
156  for (i = 0; i < 6; i++)
157  if (s->block_last_index[i] >= 0)
158  cbp |= 1 << (5 - i);
159  return cbp;
160 }
161 
162 /**
163  * Encode an 8x8 block.
164  * @param block the 8x8 block
165  * @param n block index (0-3 are luma, 4-5 are chroma)
166  */
167 static void h261_encode_block(H261Context *h, int16_t *block, int n)
168 {
169  MpegEncContext *const s = &h->s;
170  int level, run, i, j, last_index, last_non_zero, sign, slevel, code;
171  RLTable *rl;
172 
173  rl = &ff_h261_rl_tcoeff;
174  if (s->mb_intra) {
175  /* DC coef */
176  level = block[0];
177  /* 255 cannot be represented, so we clamp */
178  if (level > 254) {
179  level = 254;
180  block[0] = 254;
181  }
182  /* 0 cannot be represented also */
183  else if (level < 1) {
184  level = 1;
185  block[0] = 1;
186  }
187  if (level == 128)
188  put_bits(&s->pb, 8, 0xff);
189  else
190  put_bits(&s->pb, 8, level);
191  i = 1;
192  } else if ((block[0] == 1 || block[0] == -1) &&
193  (s->block_last_index[n] > -1)) {
194  // special case
195  put_bits(&s->pb, 2, block[0] > 0 ? 2 : 3);
196  i = 1;
197  } else {
198  i = 0;
199  }
200 
201  /* AC coefs */
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];
206  level = block[j];
207  if (level) {
208  run = i - last_non_zero - 1;
209  sign = 0;
210  slevel = level;
211  if (level < 0) {
212  sign = 1;
213  level = -level;
214  }
215  code = get_rl_index(rl, 0 /*no last in H.261, EOB is used*/,
216  run, level);
217  if (run == 0 && level < 16)
218  code += 1;
219  put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
220  if (code == rl->n) {
221  put_bits(&s->pb, 6, run);
222  av_assert1(slevel != 0);
223  av_assert1(level <= 127);
224  put_sbits(&s->pb, 8, slevel);
225  } else {
226  put_bits(&s->pb, 1, sign);
227  }
228  last_non_zero = i;
229  }
230  }
231  if (last_index > -1)
232  put_bits(&s->pb, rl->table_vlc[0][1], rl->table_vlc[0][0]); // EOB
233 }
234 
235 void ff_h261_encode_mb(MpegEncContext *s, int16_t block[6][64],
236  int motion_x, int motion_y)
237 {
238  H261Context *h = (H261Context *)s;
239  int mvd, mv_diff_x, mv_diff_y, i, cbp;
240  cbp = 63; // avoid warning
241  mvd = 0;
242 
243  h->mtype = 0;
244 
245  if (!s->mb_intra) {
246  /* compute cbp */
247  cbp = get_cbp(s, block);
248 
249  /* mvd indicates if this block is motion compensated */
250  mvd = motion_x | motion_y;
251 
252  if ((cbp | mvd | s->dquant) == 0) {
253  /* skip macroblock */
254  s->skip_count++;
255  s->mb_skip_run++;
256  s->last_mv[0][0][0] = 0;
257  s->last_mv[0][0][1] = 0;
258  return;
259  }
260  }
261 
262  /* MB is not skipped, encode MBA */
263  put_bits(&s->pb,
266  s->mb_skip_run = 0;
267 
268  /* calculate MTYPE */
269  if (!s->mb_intra) {
270  h->mtype++;
271 
272  if (mvd || s->loop_filter)
273  h->mtype += 3;
274  if (s->loop_filter)
275  h->mtype += 3;
276  if (cbp || s->dquant)
277  h->mtype++;
278  av_assert1(h->mtype > 1);
279  }
280 
281  if (s->dquant)
282  h->mtype++;
283 
284  put_bits(&s->pb,
287 
288  h->mtype = ff_h261_mtype_map[h->mtype];
289 
290  if (IS_QUANT(h->mtype)) {
291  ff_set_qscale(s, s->qscale + s->dquant);
292  put_bits(&s->pb, 5, s->qscale);
293  }
294 
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);
302  }
303 
304  if (HAS_CBP(h->mtype)) {
305  av_assert1(cbp > 0);
306  put_bits(&s->pb,
307  ff_h261_cbp_tab[cbp - 1][1],
308  ff_h261_cbp_tab[cbp - 1][0]);
309  }
310  for (i = 0; i < 6; i++)
311  /* encode each block */
312  h261_encode_block(h, block[i], i);
313 
314  if (!IS_16X16(h->mtype)) {
315  s->last_mv[0][0][0] = 0;
316  s->last_mv[0][0][1] = 0;
317  }
318 }
319 
320 static av_cold void init_uni_h261_rl_tab(RLTable *rl, uint32_t *bits_tab,
321  uint8_t *len_tab)
322 {
323  int slevel, run, last;
324 
325  av_assert0(MAX_LEVEL >= 64);
326  av_assert0(MAX_RUN >= 63);
327 
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;
334  int len, code;
335 
336  len_tab[index]= 100;
337 
338  /* ESC0 */
339  code= get_rl_index(rl, 0, run, level);
340  len= rl->table_vlc[code][1] + 1;
341  if(last)
342  len += 2;
343 
344  if(code!=rl->n && len < len_tab[index]){
345  len_tab [index]= len;
346  }
347  /* ESC */
348  len = rl->table_vlc[rl->n][1];
349  if(last)
350  len += 2;
351 
352  if(len < len_tab[index]){
353  len_tab [index]= len;
354  }
355  }
356  }
357  }
358 }
359 
361 {
363 
364  s->min_qcoeff = -127;
365  s->max_qcoeff = 127;
366  s->y_dc_scale_table =
368  s->ac_esc_length = 6+6+8;
369 
371 
374 }
375 
377 
379  .name = "h261",
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),
385  .encode2 = ff_MPV_encode_picture,
387  .pix_fmts = (const enum AVPixelFormat[]) { AV_PIX_FMT_YUV420P,
388  AV_PIX_FMT_NONE },
389  .priv_class = &h261_class,
390 };