FFmpeg  4.4
h261enc.c
Go to the documentation of this file.
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 "mpegutils.h"
33 #include "mpegvideo.h"
34 #include "h263.h"
35 #include "h261.h"
36 #include "mpegvideodata.h"
37 
38 static uint8_t uni_h261_rl_len [64*64*2*2];
39 #define UNI_ENC_INDEX(last,run,level) ((last)*128*64 + (run)*128 + (level))
40 
42 {
43  // QCIF
44  if (width == 176 && height == 144)
45  return 0;
46  // CIF
47  else if (width == 352 && height == 288)
48  return 1;
49  // ERROR
50  else
51  return AVERROR(EINVAL);
52 }
53 
55 {
56  H261Context *h = (H261Context *)s;
57  int format, temp_ref;
58 
59  align_put_bits(&s->pb);
60 
61  /* Update the pointer to last GOB */
62  s->ptr_lastgob = put_bits_ptr(&s->pb);
63 
64  put_bits(&s->pb, 20, 0x10); /* PSC */
65 
66  temp_ref = s->picture_number * 30000LL * s->avctx->time_base.num /
67  (1001LL * s->avctx->time_base.den); // FIXME maybe this should use a timestamp
68  put_sbits(&s->pb, 5, temp_ref); /* TemporalReference */
69 
70  put_bits(&s->pb, 1, 0); /* split screen off */
71  put_bits(&s->pb, 1, 0); /* camera off */
72  put_bits(&s->pb, 1, s->pict_type == AV_PICTURE_TYPE_I); /* freeze picture release on/off */
73 
74  format = ff_h261_get_picture_format(s->width, s->height);
75 
76  put_bits(&s->pb, 1, format); /* 0 == QCIF, 1 == CIF */
77 
78  put_bits(&s->pb, 1, 1); /* still image mode */
79  put_bits(&s->pb, 1, 1); /* reserved */
80 
81  put_bits(&s->pb, 1, 0); /* no PEI */
82  if (format == 0)
83  h->gob_number = -1;
84  else
85  h->gob_number = 0;
86  s->mb_skip_run = 0;
87 }
88 
89 /**
90  * Encode a group of blocks header.
91  */
92 static void h261_encode_gob_header(MpegEncContext *s, int mb_line)
93 {
94  H261Context *h = (H261Context *)s;
95  if (ff_h261_get_picture_format(s->width, s->height) == 0) {
96  h->gob_number += 2; // QCIF
97  } else {
98  h->gob_number++; // CIF
99  }
100  put_bits(&s->pb, 16, 1); /* GBSC */
101  put_bits(&s->pb, 4, h->gob_number); /* GN */
102  put_bits(&s->pb, 5, s->qscale); /* GQUANT */
103  put_bits(&s->pb, 1, 0); /* no GEI */
104  s->mb_skip_run = 0;
105  s->last_mv[0][0][0] = 0;
106  s->last_mv[0][0][1] = 0;
107 }
108 
110 {
111  int index = s->mb_x + s->mb_y * s->mb_width;
112 
113  if (index % 11 == 0) {
114  if (index % 33 == 0)
116  s->last_mv[0][0][0] = 0;
117  s->last_mv[0][0][1] = 0;
118  }
119 
120  /* for CIF the GOB's are fragmented in the middle of a scanline
121  * that's why we need to adjust the x and y index of the macroblocks */
122  if (ff_h261_get_picture_format(s->width, s->height) == 1) { // CIF
123  s->mb_x = index % 11;
124  index /= 11;
125  s->mb_y = index % 3;
126  index /= 3;
127  s->mb_x += 11 * (index % 2);
128  index /= 2;
129  s->mb_y += 3 * index;
130 
133  }
134 }
135 
137 {
138  MpegEncContext *const s = &h->s;
139  int sign, code;
140  if (val == 0) {
141  code = 0;
143  } else {
144  if (val > 15)
145  val -= 32;
146  if (val < -16)
147  val += 32;
148  sign = val < 0;
149  code = sign ? -val : val;
151  put_bits(&s->pb, 1, sign);
152  }
153 }
154 
155 static inline int get_cbp(MpegEncContext *s, int16_t block[6][64])
156 {
157  int i, cbp;
158  cbp = 0;
159  for (i = 0; i < 6; i++)
160  if (s->block_last_index[i] >= 0)
161  cbp |= 1 << (5 - i);
162  return cbp;
163 }
164 
165 /**
166  * Encode an 8x8 block.
167  * @param block the 8x8 block
168  * @param n block index (0-3 are luma, 4-5 are chroma)
169  */
170 static void h261_encode_block(H261Context *h, int16_t *block, int n)
171 {
172  MpegEncContext *const s = &h->s;
173  int level, run, i, j, last_index, last_non_zero, sign, slevel, code;
174  RLTable *rl;
175 
176  rl = &ff_h261_rl_tcoeff;
177  if (s->mb_intra) {
178  /* DC coef */
179  level = block[0];
180  /* 255 cannot be represented, so we clamp */
181  if (level > 254) {
182  level = 254;
183  block[0] = 254;
184  }
185  /* 0 cannot be represented also */
186  else if (level < 1) {
187  level = 1;
188  block[0] = 1;
189  }
190  if (level == 128)
191  put_bits(&s->pb, 8, 0xff);
192  else
193  put_bits(&s->pb, 8, level);
194  i = 1;
195  } else if ((block[0] == 1 || block[0] == -1) &&
196  (s->block_last_index[n] > -1)) {
197  // special case
198  put_bits(&s->pb, 2, block[0] > 0 ? 2 : 3);
199  i = 1;
200  } else {
201  i = 0;
202  }
203 
204  /* AC coefs */
205  last_index = s->block_last_index[n];
206  last_non_zero = i - 1;
207  for (; i <= last_index; i++) {
208  j = s->intra_scantable.permutated[i];
209  level = block[j];
210  if (level) {
211  run = i - last_non_zero - 1;
212  sign = 0;
213  slevel = level;
214  if (level < 0) {
215  sign = 1;
216  level = -level;
217  }
218  code = get_rl_index(rl, 0 /*no last in H.261, EOB is used*/,
219  run, level);
220  if (run == 0 && level < 16)
221  code += 1;
222  put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
223  if (code == rl->n) {
224  put_bits(&s->pb, 6, run);
225  av_assert1(slevel != 0);
226  av_assert1(level <= 127);
227  put_sbits(&s->pb, 8, slevel);
228  } else {
229  put_bits(&s->pb, 1, sign);
230  }
231  last_non_zero = i;
232  }
233  }
234  if (last_index > -1)
235  put_bits(&s->pb, rl->table_vlc[0][1], rl->table_vlc[0][0]); // EOB
236 }
237 
238 void ff_h261_encode_mb(MpegEncContext *s, int16_t block[6][64],
239  int motion_x, int motion_y)
240 {
241  H261Context *h = (H261Context *)s;
242  int mvd, mv_diff_x, mv_diff_y, i, cbp;
243  cbp = 63; // avoid warning
244  mvd = 0;
245 
246  h->mtype = 0;
247 
248  if (!s->mb_intra) {
249  /* compute cbp */
250  cbp = get_cbp(s, block);
251 
252  /* mvd indicates if this block is motion compensated */
253  mvd = motion_x | motion_y;
254 
255  if ((cbp | mvd) == 0) {
256  /* skip macroblock */
257  s->skip_count++;
258  s->mb_skip_run++;
259  s->last_mv[0][0][0] = 0;
260  s->last_mv[0][0][1] = 0;
261  s->qscale -= s->dquant;
262  return;
263  }
264  }
265 
266  /* MB is not skipped, encode MBA */
267  put_bits(&s->pb,
268  ff_h261_mba_bits[s->mb_skip_run],
269  ff_h261_mba_code[s->mb_skip_run]);
270  s->mb_skip_run = 0;
271 
272  /* calculate MTYPE */
273  if (!s->mb_intra) {
274  h->mtype++;
275 
276  if (mvd || s->loop_filter)
277  h->mtype += 3;
278  if (s->loop_filter)
279  h->mtype += 3;
280  if (cbp)
281  h->mtype++;
282  av_assert1(h->mtype > 1);
283  }
284 
285  if (s->dquant && cbp) {
286  h->mtype++;
287  } else
288  s->qscale -= s->dquant;
289 
290  put_bits(&s->pb,
291  ff_h261_mtype_bits[h->mtype],
292  ff_h261_mtype_code[h->mtype]);
293 
294  h->mtype = ff_h261_mtype_map[h->mtype];
295 
296  if (IS_QUANT(h->mtype)) {
297  ff_set_qscale(s, s->qscale + s->dquant);
298  put_bits(&s->pb, 5, s->qscale);
299  }
300 
301  if (IS_16X16(h->mtype)) {
302  mv_diff_x = (motion_x >> 1) - s->last_mv[0][0][0];
303  mv_diff_y = (motion_y >> 1) - s->last_mv[0][0][1];
304  s->last_mv[0][0][0] = (motion_x >> 1);
305  s->last_mv[0][0][1] = (motion_y >> 1);
306  h261_encode_motion(h, mv_diff_x);
307  h261_encode_motion(h, mv_diff_y);
308  }
309 
310  if (HAS_CBP(h->mtype)) {
311  av_assert1(cbp > 0);
312  put_bits(&s->pb,
313  ff_h261_cbp_tab[cbp - 1][1],
314  ff_h261_cbp_tab[cbp - 1][0]);
315  }
316  for (i = 0; i < 6; i++)
317  /* encode each block */
319 
320  if (!IS_16X16(h->mtype)) {
321  s->last_mv[0][0][0] = 0;
322  s->last_mv[0][0][1] = 0;
323  }
324 }
325 
326 static av_cold void init_uni_h261_rl_tab(const RLTable *rl, 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 
366 {
367  static uint8_t h261_rl_table_store[2][2 * MAX_RUN + MAX_LEVEL + 3];
368 
369  ff_rl_init(&ff_h261_rl_tcoeff, h261_rl_table_store);
371 }
372 
374 {
375  static AVOnce init_static_once = AV_ONCE_INIT;
376 
377  s->min_qcoeff = -127;
378  s->max_qcoeff = 127;
379  s->y_dc_scale_table =
380  s->c_dc_scale_table = ff_mpeg1_dc_scale_table;
381  s->ac_esc_length = 6+6+8;
382 
383  s->intra_ac_vlc_length = s->inter_ac_vlc_length = uni_h261_rl_len;
384  s->intra_ac_vlc_last_length = s->inter_ac_vlc_last_length = uni_h261_rl_len + 128*64;
385  ff_thread_once(&init_static_once, h261_encode_init_static);
386 }
387 
388 static const AVClass h261_class = {
389  .class_name = "h261 encoder",
390  .item_name = av_default_item_name,
391  .option = ff_mpv_generic_options,
392  .version = LIBAVUTIL_VERSION_INT,
393 };
394 
396  .name = "h261",
397  .long_name = NULL_IF_CONFIG_SMALL("H.261"),
398  .type = AVMEDIA_TYPE_VIDEO,
399  .id = AV_CODEC_ID_H261,
400  .priv_data_size = sizeof(H261Context),
402  .encode2 = ff_mpv_encode_picture,
403  .close = ff_mpv_encode_end,
405  .pix_fmts = (const enum AVPixelFormat[]) { AV_PIX_FMT_YUV420P,
406  AV_PIX_FMT_NONE },
407  .priv_class = &h261_class,
408 };
static double val(void *priv, double ch)
Definition: aeval.c:76
static const char *const format[]
Definition: af_aiir.c:456
Macro definitions for various function/variable attributes.
#define av_cold
Definition: attributes.h:88
uint8_t
simple assert() macros that are a bit more flexible than ISO C assert().
#define av_assert1(cond)
assert() equivalent, that does not lie in speed critical code.
Definition: avassert.h:53
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
Libavcodec external API header.
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:31
#define s(width, name)
Definition: cbs_vp9.c:257
@ AV_CODEC_ID_H261
Definition: codec_id.h:52
#define AVERROR(e)
Definition: error.h:43
const char * av_default_item_name(void *ptr)
Return the context name.
Definition: log.c:235
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
@ AV_PICTURE_TYPE_I
Intra.
Definition: avutil.h:274
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
int index
Definition: gxfenc.c:89
H.261 codec.
const int ff_h261_mtype_map[10]
Definition: h261data.c:75
RLTable ff_h261_rl_tcoeff
Definition: h261data.c:150
const uint8_t ff_h261_mv_tab[17][2]
Definition: h261data.c:89
const uint8_t ff_h261_mtype_bits[10]
Definition: h261data.c:69
const uint8_t ff_h261_mtype_code[10]
Definition: h261data.c:63
const uint8_t ff_h261_mba_code[35]
Definition: h261data.c:34
const uint8_t ff_h261_cbp_tab[63][2]
Definition: h261data.c:95
const uint8_t ff_h261_mba_bits[35]
Definition: h261data.c:48
static av_cold void h261_encode_init_static(void)
Definition: h261enc.c:365
static av_cold void init_uni_h261_rl_tab(const RLTable *rl, uint8_t *len_tab)
Definition: h261enc.c:326
AVCodec ff_h261_encoder
Definition: h261enc.c:395
av_cold void ff_h261_encode_init(MpegEncContext *s)
Definition: h261enc.c:373
#define UNI_ENC_INDEX(last, run, level)
Definition: h261enc.c:39
static void h261_encode_gob_header(MpegEncContext *s, int mb_line)
Encode a group of blocks header.
Definition: h261enc.c:92
static uint8_t uni_h261_rl_len[64 *64 *2 *2]
Definition: h261enc.c:38
void ff_h261_encode_mb(MpegEncContext *s, int16_t block[6][64], int motion_x, int motion_y)
Definition: h261enc.c:238
static void h261_encode_motion(H261Context *h, int val)
Definition: h261enc.c:136
void ff_h261_encode_picture_header(MpegEncContext *s, int picture_number)
Definition: h261enc.c:54
static const AVClass h261_class
Definition: h261enc.c:388
static int get_cbp(MpegEncContext *s, int16_t block[6][64])
Definition: h261enc.c:155
void ff_h261_reorder_mb_index(MpegEncContext *s)
Definition: h261enc.c:109
int ff_h261_get_picture_format(int width, int height)
Definition: h261enc.c:41
static void h261_encode_block(H261Context *h, int16_t *block, int n)
Encode an 8x8 block.
Definition: h261enc.c:170
int i
Definition: input.c:407
static void put_bits(Jpeg2000EncoderContext *s, int val, int n)
put n times val bit
Definition: j2kenc.c:218
#define FF_CODEC_CAP_INIT_THREADSAFE
The codec does not modify any global variables in the init function, allowing to call the init functi...
Definition: internal.h:41
#define FF_CODEC_CAP_INIT_CLEANUP
The codec allows calling the close function for deallocation even if the init function returned a fai...
Definition: internal.h:49
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
Definition: internal.h:117
#define AVOnce
Definition: thread.h:172
static int ff_thread_once(char *control, void(*routine)(void))
Definition: thread.h:175
#define AV_ONCE_INIT
Definition: thread.h:173
static enum AVPixelFormat pix_fmts[]
Definition: libkvazaar.c:303
#define HAS_CBP(a)
Definition: mpegutils.h:101
#define IS_16X16(a)
Definition: mpegutils.h:86
#define IS_QUANT(a)
Definition: mpegutils.h:95
void ff_set_qscale(MpegEncContext *s, int qscale)
set qscale and update qscale dependent variables.
Definition: mpegvideo.c:2331
void ff_init_block_index(MpegEncContext *s)
Definition: mpegvideo.c:2267
mpegvideo header.
const AVOption ff_mpv_generic_options[]
Definition: mpegvideo_enc.c:87
int ff_mpv_encode_end(AVCodecContext *avctx)
int ff_mpv_encode_picture(AVCodecContext *avctx, AVPacket *pkt, const AVFrame *frame, int *got_packet)
int ff_mpv_encode_init(AVCodecContext *avctx)
static void ff_update_block_index(MpegEncContext *s)
Definition: mpegvideo.h:750
const uint8_t ff_mpeg1_dc_scale_table[128]
Definition: mpegvideodata.c:33
AVPixelFormat
Pixel format.
Definition: pixfmt.h:64
@ AV_PIX_FMT_NONE
Definition: pixfmt.h:65
@ AV_PIX_FMT_YUV420P
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
Definition: pixfmt.h:66
static void put_sbits(PutBitContext *pb, int n, int32_t value)
Definition: put_bits.h:253
static uint8_t * put_bits_ptr(PutBitContext *s)
Return the pointer to the byte where the bitstream writer will put the next bit.
Definition: put_bits.h:342
static void align_put_bits(PutBitContext *s)
Pad the bitstream with zeros up to the next byte boundary.
Definition: put_bits.h:386
av_cold void ff_rl_init(RLTable *rl, uint8_t static_store[2][2 *MAX_RUN+MAX_LEVEL+3])
Definition: rl.c:28
#define MAX_LEVEL
Definition: rl.h:36
#define MAX_RUN
Definition: rl.h:35
static int get_rl_index(const RLTable *rl, int last, int run, int level)
Definition: rl.h:79
const uint8_t * code
Definition: spdifenc.c:413
Describe the class of an AVClass context structure.
Definition: log.h:67
const char * class_name
The name of the class; usually it is the same name as the context structure type to which the AVClass...
Definition: log.h:72
AVCodec.
Definition: codec.h:197
const char * name
Name of the codec implementation.
Definition: codec.h:204
H261Context.
Definition: h261.h:37
MpegEncContext.
Definition: mpegvideo.h:81
RLTable.
Definition: rl.h:39
int n
number of entries of table_vlc minus 1
Definition: rl.h:40
const uint16_t(* table_vlc)[2]
Definition: rl.h:42
uint8_t run
Definition: svq3.c:205
uint8_t level
Definition: svq3.c:206
static int16_t block[64]
Definition: dct.c:116
#define height
#define width
int len