FFmpeg  4.0
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 "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 
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 
54 {
55  H261Context *h = (H261Context *)s;
56  int format, temp_ref;
57 
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 
109 {
110  int index = s->mb_x + s->mb_y * s->mb_width;
111 
112  if (index % 11 == 0) {
113  if (index % 33 == 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 
132  }
133 }
134 
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,
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,
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 
366 {
368 
369  s->min_qcoeff = -127;
370  s->max_qcoeff = 127;
371  s->y_dc_scale_table =
373  s->ac_esc_length = 6+6+8;
374 
376 
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 
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),
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 };
#define NULL
Definition: coverity.c:32
const char const char void * val
Definition: avisynth_c.h:771
void ff_init_block_index(MpegEncContext *s)
Definition: mpegvideo.c:2231
#define UNI_ENC_INDEX(last, run, level)
Definition: h261enc.c:38
int picture_number
Definition: mpegvideo.h:127
const char * s
Definition: avisynth_c.h:768
static const char * format[]
Definition: af_aiir.c:311
const uint8_t * y_dc_scale_table
qscale -> y_dc_scale table
Definition: mpegvideo.h:188
int last_mv[2][2][2]
last MV, used for MV prediction in MPEG-1 & B-frame MPEG-4
Definition: mpegvideo.h:278
static void put_sbits(PutBitContext *pb, int n, int32_t value)
Definition: put_bits.h:240
void ff_h261_encode_mb(MpegEncContext *s, int16_t block[6][64], int motion_x, int motion_y)
Definition: h261enc.c:237
static void put_bits(Jpeg2000EncoderContext *s, int val, int n)
put n times val bit
Definition: j2kenc.c:207
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
MpegEncContext s
Definition: h261.h:38
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:35
const uint8_t ff_h261_mba_bits[35]
Definition: h261data.c:48
int num
Numerator.
Definition: rational.h:59
const char * av_default_item_name(void *ptr)
Return the context name.
Definition: log.c:191
void avpriv_align_put_bits(PutBitContext *s)
Pad the bitstream with zeros up to the next byte boundary.
Definition: bitstream.c:48
H261Context.
Definition: h261.h:37
int min_qcoeff
minimum encodable coefficient
Definition: mpegvideo.h:308
int gob_number
Definition: h261.h:45
mpegvideo header.
#define HAS_CBP(a)
Definition: mpegutils.h:101
uint8_t permutated[64]
Definition: idctdsp.h:33
void ff_h261_encode_picture_header(MpegEncContext *s, int picture_number)
Definition: h261enc.c:53
uint8_t run
Definition: svq3.c:206
uint8_t * intra_ac_vlc_length
Definition: mpegvideo.h:311
AVCodec.
Definition: avcodec.h:3408
const uint8_t ff_h261_mba_code[35]
Definition: h261data.c:34
RLTable.
Definition: rl.h:39
int qscale
QP.
Definition: mpegvideo.h:204
Macro definitions for various function/variable attributes.
const uint8_t ff_h261_cbp_tab[63][2]
Definition: h261data.c:95
AVRational time_base
This is the fundamental unit of time (in seconds) in terms of which frame timestamps are represented...
Definition: avcodec.h:1640
static int16_t block[64]
Definition: dct.c:115
AVCodec ff_h261_encoder
Definition: h261enc.c:388
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
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
uint8_t * ptr_lastgob
Definition: mpegvideo.h:502
const AVOption ff_mpv_generic_options[]
Definition: mpegvideo_enc.c:85
const uint8_t ff_mpeg1_dc_scale_table[128]
Definition: mpegvideodata.c:34
uint8_t
#define av_cold
Definition: attributes.h:82
#define height
static void h261_encode_gob_header(MpegEncContext *s, int mb_line)
Encode a group of blocks header.
Definition: h261enc.c:91
int max_qcoeff
maximum encodable coefficient
Definition: mpegvideo.h:309
#define MAX_LEVEL
Definition: rl.h:36
int dquant
qscale difference to prev qscale
Definition: mpegvideo.h:210
static void ff_update_block_index(MpegEncContext *s)
Definition: mpegvideo.h:739
void ff_set_qscale(MpegEncContext *s, int qscale)
set qscale and update qscale dependent variables.
Definition: mpegvideo.c:2295
static void h261_encode_block(H261Context *h, int16_t *block, int n)
Encode an 8x8 block.
Definition: h261enc.c:169
av_cold void ff_h261_common_init(void)
Definition: h261.c:83
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:324
static const AVClass h261_class
Definition: h261enc.c:381
uint8_t * inter_ac_vlc_last_length
Definition: mpegvideo.h:316
#define AVERROR(e)
Definition: error.h:43
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:186
uint16_t width
Definition: gdv.c:47
simple assert() macros that are a bit more flexible than ISO C assert().
int mtype
Definition: h261.h:42
const char * name
Name of the codec implementation.
Definition: avcodec.h:3415
uint8_t * intra_ac_vlc_last_length
Definition: mpegvideo.h:312
int n
number of entries of table_vlc minus 1
Definition: rl.h:40
#define av_assert1(cond)
assert() equivalent, that does not lie in speed critical code.
Definition: avassert.h:53
const uint16_t(* table_vlc)[2]
Definition: rl.h:42
int block_last_index[12]
last non zero coefficient in block
Definition: mpegvideo.h:86
int n
Definition: avisynth_c.h:684
const uint8_t ff_h261_mtype_code[10]
Definition: h261data.c:63
const uint8_t ff_h261_mtype_bits[10]
Definition: h261data.c:69
int ac_esc_length
num of bits needed to encode the longest esc
Definition: mpegvideo.h:310
const uint8_t ff_h261_mv_tab[17][2]
Definition: h261data.c:89
const int ff_h261_mtype_map[10]
Definition: h261data.c:75
Libavcodec external API header.
void ff_h261_reorder_mb_index(MpegEncContext *s)
Definition: h261enc.c:108
ScanTable intra_scantable
Definition: mpegvideo.h:91
int height
picture size. must be a multiple of 16
Definition: mpegvideo.h:100
#define IS_QUANT(a)
Definition: mpegutils.h:95
int ff_h261_get_picture_format(int width, int height)
Definition: h261enc.c:40
int ff_mpv_encode_init(AVCodecContext *avctx)
uint8_t * inter_ac_vlc_length
Definition: mpegvideo.h:315
H.261 codec.
Describe the class of an AVClass context structure.
Definition: log.h:67
#define IS_16X16(a)
Definition: mpegutils.h:86
static int get_cbp(MpegEncContext *s, int16_t block[6][64])
Definition: h261enc.c:154
int index
Definition: gxfenc.c:89
static void h261_encode_motion(H261Context *h, int val)
Definition: h261enc.c:135
RLTable ff_h261_rl_tcoeff
Definition: h261data.c:150
int pict_type
AV_PICTURE_TYPE_I, AV_PICTURE_TYPE_P, AV_PICTURE_TYPE_B, ...
Definition: mpegvideo.h:212
static enum AVPixelFormat pix_fmts[]
Definition: libkvazaar.c:266
const uint8_t * c_dc_scale_table
qscale -> c_dc_scale table
Definition: mpegvideo.h:189
uint8_t level
Definition: svq3.c:207
MpegEncContext.
Definition: mpegvideo.h:81
#define MAX_RUN
Definition: rl.h:35
struct AVCodecContext * avctx
Definition: mpegvideo.h:98
PutBitContext pb
bit output
Definition: mpegvideo.h:151
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
Definition: pixfmt.h:62
int den
Denominator.
Definition: rational.h:60
int ff_mpv_encode_end(AVCodecContext *avctx)
static int get_rl_index(const RLTable *rl, int last, int run, int level)
Definition: rl.h:76
static uint8_t uni_h261_rl_len[64 *64 *2 *2]
Definition: h261enc.c:37
int len
int ff_mpv_encode_picture(AVCodecContext *avctx, AVPacket *pkt, const AVFrame *frame, int *got_packet)
static av_cold void init_uni_h261_rl_tab(RLTable *rl, uint32_t *bits_tab, uint8_t *len_tab)
Definition: h261enc.c:325
av_cold void ff_h261_encode_init(MpegEncContext *s)
Definition: h261enc.c:365
AVPixelFormat
Pixel format.
Definition: pixfmt.h:60