FFmpeg
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 "codec_internal.h"
33 #include "mpegutils.h"
34 #include "mpegvideo.h"
35 #include "h261.h"
36 #include "h261enc.h"
37 #include "mpegvideoenc.h"
38 
39 #define H261_MAX_RUN 26
40 #define H261_MAX_LEVEL 15
41 #define H261_ESC_LEN (6 + 6 + 8)
42 #define MV_TAB_OFFSET 32
43 
44 static struct VLCLUT {
45  uint8_t len;
46  uint16_t code;
47 } vlc_lut[H261_MAX_RUN + 1][32 /* 0..2 * H261_MAX_LEN are used */];
48 
49 // Not const despite never being initialized because doing so would
50 // put it into .rodata instead of .bss and bloat the binary.
51 // mv_penalty exists so that the motion estimation code can avoid branches.
52 static uint8_t mv_penalty[MAX_FCODE + 1][MAX_DMV * 2 + 1];
53 static uint8_t uni_h261_rl_len [64 * 128];
54 static uint8_t uni_h261_rl_len_last[64 * 128];
55 static uint8_t h261_mv_codes[64][2];
56 
57 typedef struct H261EncContext {
59 
61 
63  enum {
64  H261_QCIF = 0,
65  H261_CIF = 1,
66  } format;
68 
70 {
71  H261EncContext *const h = (H261EncContext *)s;
72  int temp_ref;
73 
74  align_put_bits(&s->pb);
75 
76  /* Update the pointer to last GOB */
77  s->ptr_lastgob = put_bits_ptr(&s->pb);
78 
79  put_bits(&s->pb, 20, 0x10); /* PSC */
80 
81  temp_ref = s->picture_number * 30000LL * s->avctx->time_base.num /
82  (1001LL * s->avctx->time_base.den); // FIXME maybe this should use a timestamp
83  put_sbits(&s->pb, 5, temp_ref); /* TemporalReference */
84 
85  put_bits(&s->pb, 1, 0); /* split screen off */
86  put_bits(&s->pb, 1, 0); /* camera off */
87  put_bits(&s->pb, 1, s->pict_type == AV_PICTURE_TYPE_I); /* freeze picture release on/off */
88 
89  put_bits(&s->pb, 1, h->format); /* 0 == QCIF, 1 == CIF */
90 
91  put_bits(&s->pb, 1, 1); /* still image mode */
92  put_bits(&s->pb, 1, 1); /* reserved */
93 
94  put_bits(&s->pb, 1, 0); /* no PEI */
95  h->gob_number = h->format - 1;
96  s->mb_skip_run = 0;
97 }
98 
99 /**
100  * Encode a group of blocks header.
101  */
102 static void h261_encode_gob_header(MpegEncContext *s, int mb_line)
103 {
104  H261EncContext *const h = (H261EncContext *)s;
105  if (h->format == H261_QCIF) {
106  h->gob_number += 2; // QCIF
107  } else {
108  h->gob_number++; // CIF
109  }
110  put_bits(&s->pb, 16, 1); /* GBSC */
111  put_bits(&s->pb, 4, h->gob_number); /* GN */
112  put_bits(&s->pb, 5, s->qscale); /* GQUANT */
113  put_bits(&s->pb, 1, 0); /* no GEI */
114  s->mb_skip_run = 0;
115  s->last_mv[0][0][0] = 0;
116  s->last_mv[0][0][1] = 0;
117 }
118 
120 {
121  const H261EncContext *const h = (H261EncContext*)s;
122  int index = s->mb_x + s->mb_y * s->mb_width;
123 
124  if (index % 11 == 0) {
125  if (index % 33 == 0)
127  s->last_mv[0][0][0] = 0;
128  s->last_mv[0][0][1] = 0;
129  }
130 
131  /* for CIF the GOB's are fragmented in the middle of a scanline
132  * that's why we need to adjust the x and y index of the macroblocks */
133  if (h->format == H261_CIF) {
134  s->mb_x = index % 11;
135  index /= 11;
136  s->mb_y = index % 3;
137  index /= 3;
138  s->mb_x += 11 * (index % 2);
139  index /= 2;
140  s->mb_y += 3 * index;
141 
143  ff_update_block_index(s, 8, 0, 1);
144  }
145 }
146 
147 static void h261_encode_motion(PutBitContext *pb, int val)
148 {
151 }
152 
153 static inline int get_cbp(MpegEncContext *s, int16_t block[6][64])
154 {
155  int i, cbp;
156  cbp = 0;
157  for (i = 0; i < 6; i++)
158  if (s->block_last_index[i] >= 0)
159  cbp |= 1 << (5 - i);
160  return cbp;
161 }
162 
163 /**
164  * Encode an 8x8 block.
165  * @param block the 8x8 block
166  * @param n block index (0-3 are luma, 4-5 are chroma)
167  */
168 static void h261_encode_block(H261EncContext *h, int16_t *block, int n)
169 {
170  MpegEncContext *const s = &h->s;
171  int level, run, i, j, last_index, last_non_zero;
172 
173  if (s->mb_intra) {
174  /* DC coef */
175  level = block[0];
176  /* 255 cannot be represented, so we clamp */
177  if (level > 254) {
178  level = 254;
179  block[0] = 254;
180  }
181  /* 0 cannot be represented also */
182  else if (level < 1) {
183  level = 1;
184  block[0] = 1;
185  }
186  if (level == 128)
187  put_bits(&s->pb, 8, 0xff);
188  else
189  put_bits(&s->pb, 8, level);
190  i = 1;
191  } else if ((block[0] == 1 || block[0] == -1) &&
192  (s->block_last_index[n] > -1)) {
193  // special case
194  put_bits(&s->pb, 2, block[0] > 0 ? 2 : 3);
195  i = 1;
196  } else {
197  i = 0;
198  }
199 
200  /* AC coefs */
201  last_index = s->block_last_index[n];
202  last_non_zero = i - 1;
203  for (; i <= last_index; i++) {
204  j = s->intra_scantable.permutated[i];
205  level = block[j];
206  if (level) {
207  run = i - last_non_zero - 1;
208 
209  if (run <= H261_MAX_RUN &&
210  (unsigned)(level + H261_MAX_LEVEL) <= 2 * H261_MAX_LEVEL &&
214  } else {
215  /* Escape */
216  put_bits(&s->pb, 6 + 6, (1 << 6) | run);
217  av_assert1(level != 0);
218  av_assert1(FFABS(level) <= 127);
219  put_sbits(&s->pb, 8, level);
220  }
221  last_non_zero = i;
222  }
223  }
224  if (last_index > -1)
225  put_bits(&s->pb, 2, 0x2); // EOB
226 }
227 
228 void ff_h261_encode_mb(MpegEncContext *s, int16_t block[6][64],
229  int motion_x, int motion_y)
230 {
231  /* The following is only allowed because this encoder
232  * does not use slice threading. */
233  H261EncContext *const h = (H261EncContext *)s;
234  H261Context *const com = &h->common;
235  int mvd, mv_diff_x, mv_diff_y, i, cbp;
236  cbp = 63; // avoid warning
237  mvd = 0;
238 
239  com->mtype = 0;
240 
241  if (!s->mb_intra) {
242  /* compute cbp */
243  cbp = get_cbp(s, block);
244 
245  /* mvd indicates if this block is motion compensated */
246  mvd = motion_x | motion_y;
247 
248  if ((cbp | mvd) == 0) {
249  /* skip macroblock */
250  s->mb_skip_run++;
251  s->last_mv[0][0][0] = 0;
252  s->last_mv[0][0][1] = 0;
253  s->qscale -= s->dquant;
254  return;
255  }
256  }
257 
258  /* MB is not skipped, encode MBA */
259  put_bits(&s->pb,
260  ff_h261_mba_bits[s->mb_skip_run],
261  ff_h261_mba_code[s->mb_skip_run]);
262  s->mb_skip_run = 0;
263 
264  /* calculate MTYPE */
265  if (!s->mb_intra) {
266  com->mtype++;
267 
268  if (mvd || s->loop_filter)
269  com->mtype += 3;
270  if (s->loop_filter)
271  com->mtype += 3;
272  if (cbp)
273  com->mtype++;
274  av_assert1(com->mtype > 1);
275  }
276 
277  if (s->dquant && cbp) {
278  com->mtype++;
279  } else
280  s->qscale -= s->dquant;
281 
282  put_bits(&s->pb,
284  ff_h261_mtype_code[com->mtype]);
285 
286  com->mtype = ff_h261_mtype_map[com->mtype];
287 
288  if (IS_QUANT(com->mtype)) {
289  ff_set_qscale(s, s->qscale + s->dquant);
290  put_bits(&s->pb, 5, s->qscale);
291  }
292 
293  if (IS_16X16(com->mtype)) {
294  mv_diff_x = (motion_x >> 1) - s->last_mv[0][0][0];
295  mv_diff_y = (motion_y >> 1) - s->last_mv[0][0][1];
296  s->last_mv[0][0][0] = (motion_x >> 1);
297  s->last_mv[0][0][1] = (motion_y >> 1);
298  h261_encode_motion(&s->pb, mv_diff_x);
299  h261_encode_motion(&s->pb, mv_diff_y);
300  }
301 
302  if (HAS_CBP(com->mtype)) {
303  av_assert1(cbp > 0);
304  put_bits(&s->pb,
305  ff_h261_cbp_tab[cbp - 1][1],
306  ff_h261_cbp_tab[cbp - 1][0]);
307  }
308  for (i = 0; i < 6; i++)
309  /* encode each block */
311 
312  if (!IS_16X16(com->mtype)) {
313  s->last_mv[0][0][0] = 0;
314  s->last_mv[0][0][1] = 0;
315  }
316 }
317 
319 {
320  uint8_t (*const mv_codes)[2] = h261_mv_codes + MV_TAB_OFFSET;
321  memset(uni_h261_rl_len, H261_ESC_LEN, sizeof(uni_h261_rl_len));
322  memset(uni_h261_rl_len_last, H261_ESC_LEN + 2 /* EOB */, sizeof(uni_h261_rl_len_last));
323 
324  // The following loop is over the ordinary elements, not EOB or escape.
325  for (size_t i = 1; i < FF_ARRAY_ELEMS(ff_h261_tcoeff_vlc) - 1; i++) {
326  unsigned run = ff_h261_tcoeff_run[i];
327  unsigned level = ff_h261_tcoeff_level[i];
328  unsigned len = ff_h261_tcoeff_vlc[i][1] + 1 /* sign */;
329  unsigned code = ff_h261_tcoeff_vlc[i][0];
330 
331  vlc_lut[run][H261_MAX_LEVEL + level] = (struct VLCLUT){ len, code << 1 };
332  vlc_lut[run][H261_MAX_LEVEL - level] = (struct VLCLUT){ len, (code << 1) | 1 };
333 
338  }
339 
340  for (size_t i = 1;; i++) {
341  // sign-one MV codes; diff -16..-1, 16..31
342  mv_codes[32 - i][0] = mv_codes[-i][0] = (ff_h261_mv_tab[i][0] << 1) | 1 /* sign */;
343  mv_codes[32 - i][1] = mv_codes[-i][1] = ff_h261_mv_tab[i][1] + 1;
344  if (i == 16)
345  break;
346  // sign-zero MV codes: diff -31..-17, 1..15
347  mv_codes[i][0] = mv_codes[i - 32][0] = ff_h261_mv_tab[i][0] << 1;
348  mv_codes[i][1] = mv_codes[i - 32][1] = ff_h261_mv_tab[i][1] + 1;
349  }
350  // MV code for difference zero; has no sign
351  mv_codes[0][0] = 1;
352  mv_codes[0][1] = 1;
353 }
354 
356 {
357  H261EncContext *const h = (H261EncContext*)s;
358  static AVOnce init_static_once = AV_ONCE_INIT;
359 
360  if (s->width == 176 && s->height == 144) {
361  h->format = H261_QCIF;
362  } else if (s->width == 352 && s->height == 288) {
363  h->format = H261_CIF;
364  } else {
365  av_log(s->avctx, AV_LOG_ERROR,
366  "The specified picture size of %dx%d is not valid for the "
367  "H.261 codec.\nValid sizes are 176x144, 352x288\n",
368  s->width, s->height);
369  return AVERROR(EINVAL);
370  }
371  s->private_ctx = &h->common;
372 
373  s->min_qcoeff = -127;
374  s->max_qcoeff = 127;
375  s->ac_esc_length = H261_ESC_LEN;
376 
377  s->me.mv_penalty = mv_penalty;
378 
379  s->intra_ac_vlc_length = s->inter_ac_vlc_length = uni_h261_rl_len;
380  s->intra_ac_vlc_last_length = s->inter_ac_vlc_last_length = uni_h261_rl_len_last;
381  ff_thread_once(&init_static_once, h261_encode_init_static);
382 
383  return 0;
384 }
385 
387  .p.name = "h261",
388  CODEC_LONG_NAME("H.261"),
389  .p.type = AVMEDIA_TYPE_VIDEO,
390  .p.id = AV_CODEC_ID_H261,
391  .p.priv_class = &ff_mpv_enc_class,
393  .priv_data_size = sizeof(H261EncContext),
396  .close = ff_mpv_encode_end,
397  .caps_internal = FF_CODEC_CAP_INIT_CLEANUP,
399  .color_ranges = AVCOL_RANGE_MPEG,
400 };
CODEC_PIXFMTS
#define CODEC_PIXFMTS(...)
Definition: codec_internal.h:386
ff_mpv_enc_class
const AVClass ff_mpv_enc_class
Definition: mpegvideo_enc.c:104
level
uint8_t level
Definition: svq3.c:205
FF_CODEC_CAP_INIT_CLEANUP
#define FF_CODEC_CAP_INIT_CLEANUP
The codec allows calling the close function for deallocation even if the init function returned a fai...
Definition: codec_internal.h:42
H261EncContext
Definition: h261enc.c:57
ff_h261_encode_init
av_cold int ff_h261_encode_init(MpegEncContext *s)
Definition: h261enc.c:355
AVERROR
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later. That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another. Frame references ownership and permissions
H261Context::mtype
int mtype
Definition: h261.h:38
align_put_bits
static void align_put_bits(PutBitContext *s)
Pad the bitstream with zeros up to the next byte boundary.
Definition: put_bits.h:435
MAX_FCODE
#define MAX_FCODE
Definition: mpegvideoenc.h:36
thread.h
ff_h261_encode_picture_header
void ff_h261_encode_picture_header(MpegEncContext *s)
Definition: h261enc.c:69
H261EncContext::s
MpegEncContext s
Definition: h261enc.c:58
ff_h261_tcoeff_run
const int8_t ff_h261_tcoeff_run[64]
Definition: h261data.c:138
mpegvideoenc.h
put_sbits
static void put_sbits(PutBitContext *pb, int n, int32_t value)
Definition: put_bits.h:281
H261EncContext::common
H261Context common
Definition: h261enc.c:60
VLCLUT::code
uint16_t code
Definition: h261enc.c:46
put_bits
static void put_bits(Jpeg2000EncoderContext *s, int val, int n)
put n times val bit
Definition: j2kenc.c:223
MAX_DMV
#define MAX_DMV
Definition: motion_est.h:38
ff_h261_encode_mb
void ff_h261_encode_mb(MpegEncContext *s, int16_t block[6][64], int motion_x, int motion_y)
Definition: h261enc.c:228
mv_penalty
static uint8_t mv_penalty[MAX_FCODE+1][MAX_DMV *2+1]
Definition: h261enc.c:52
FFCodec
Definition: codec_internal.h:127
ff_init_block_index
void ff_init_block_index(MpegEncContext *s)
Definition: mpegvideo.c:815
mpegvideo.h
mpegutils.h
AV_CODEC_ID_H261
@ AV_CODEC_ID_H261
Definition: codec_id.h:55
ff_h261_encoder
const FFCodec ff_h261_encoder
Definition: h261enc.c:386
ff_mpv_encode_picture
int ff_mpv_encode_picture(AVCodecContext *avctx, AVPacket *pkt, const AVFrame *pic_arg, int *got_packet)
Definition: mpegvideo_enc.c:1867
FFCodec::p
AVCodec p
The public AVCodec.
Definition: codec_internal.h:131
H261_MAX_LEVEL
#define H261_MAX_LEVEL
Definition: h261enc.c:40
h261.h
val
static double val(void *priv, double ch)
Definition: aeval.c:77
FF_CODEC_ENCODE_CB
#define FF_CODEC_ENCODE_CB(func)
Definition: codec_internal.h:353
H261EncContext::format
enum H261EncContext::@120 format
HAS_CBP
#define HAS_CBP(a)
Definition: mpegutils.h:87
avassert.h
ff_thread_once
static int ff_thread_once(char *control, void(*routine)(void))
Definition: thread.h:205
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:209
FF_ARRAY_ELEMS
#define FF_ARRAY_ELEMS(a)
Definition: sinewin_tablegen.c:29
av_cold
#define av_cold
Definition: attributes.h:90
s
#define s(width, name)
Definition: cbs_vp9.c:198
VLCLUT
Definition: h261enc.c:44
h261_encode_gob_header
static void h261_encode_gob_header(MpegEncContext *s, int mb_line)
Encode a group of blocks header.
Definition: h261enc.c:102
AV_CODEC_CAP_ENCODER_REORDERED_OPAQUE
#define AV_CODEC_CAP_ENCODER_REORDERED_OPAQUE
This encoder can reorder user opaque values from input AVFrames and return them with corresponding ou...
Definition: codec.h:159
ff_h261_mba_code
const uint8_t ff_h261_mba_code[35]
Definition: h261data.c:34
MV_TAB_OFFSET
#define MV_TAB_OFFSET
Definition: h261enc.c:42
vlc_lut
static struct VLCLUT vlc_lut[H261_MAX_RUN+1][32/*0..2 *H261_MAX_LEN are used */]
ff_h261_mv_tab
const uint8_t ff_h261_mv_tab[17][2]
Definition: h261data.c:89
AV_PIX_FMT_YUV420P
@ AV_PIX_FMT_YUV420P
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
Definition: pixfmt.h:73
PutBitContext
Definition: put_bits.h:50
CODEC_LONG_NAME
#define CODEC_LONG_NAME(str)
Definition: codec_internal.h:326
FFABS
#define FFABS(a)
Absolute value, Note, INT_MIN / INT64_MIN result in undefined behavior as they are not representable ...
Definition: common.h:74
AV_ONCE_INIT
#define AV_ONCE_INIT
Definition: thread.h:203
h261_encode_block
static void h261_encode_block(H261EncContext *h, int16_t *block, int n)
Encode an 8x8 block.
Definition: h261enc.c:168
run
uint8_t run
Definition: svq3.c:204
AV_PICTURE_TYPE_I
@ AV_PICTURE_TYPE_I
Intra.
Definition: avutil.h:279
ff_set_qscale
void ff_set_qscale(MpegEncContext *s, int qscale)
set qscale and update qscale dependent variables.
Definition: mpegvideo.c:848
ff_mpv_encode_end
av_cold int ff_mpv_encode_end(AVCodecContext *avctx)
Definition: mpegvideo_enc.c:1040
ff_h261_tcoeff_level
const int8_t ff_h261_tcoeff_level[64]
Definition: h261data.c:127
AVOnce
#define AVOnce
Definition: thread.h:202
H261_MAX_RUN
#define H261_MAX_RUN
Definition: h261enc.c:39
index
int index
Definition: gxfenc.c:90
uni_h261_rl_len_last
static uint8_t uni_h261_rl_len_last[64 *128]
Definition: h261enc.c:54
init
int(* init)(AVBSFContext *ctx)
Definition: dts2pts.c:368
AV_CODEC_CAP_DR1
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() or get_encode_buffer() for allocating buffers and supports custom allocators.
Definition: codec.h:52
codec_internal.h
H261EncContext::H261_QCIF
@ H261_QCIF
Definition: h261enc.c:64
ff_update_block_index
static void ff_update_block_index(MpegEncContext *s, int bits_per_raw_sample, int lowres, int chroma_x_shift)
Definition: mpegvideo.h:590
attributes.h
H261EncContext::gob_number
int gob_number
Definition: h261enc.c:62
ff_h261_tcoeff_vlc
const uint16_t ff_h261_tcoeff_vlc[65][2]
Definition: h261data.c:107
UNI_AC_ENC_INDEX
#define UNI_AC_ENC_INDEX(run, level)
Definition: mpegvideoenc.h:37
IS_16X16
#define IS_16X16(a)
Definition: mpegutils.h:80
H261Context
H261Context.
Definition: h261.h:37
h261_encode_init_static
static av_cold void h261_encode_init_static(void)
Definition: h261enc.c:318
ff_h261_cbp_tab
const uint8_t ff_h261_cbp_tab[63][2]
Definition: h261data.c:95
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:256
code
and forward the test the status of outputs and forward it to the corresponding return FFERROR_NOT_READY If the filters stores internally one or a few frame for some it can consider them to be part of the FIFO and delay acknowledging a status change accordingly Example code
Definition: filter_design.txt:178
av_assert1
#define av_assert1(cond)
assert() equivalent, that does not lie in speed critical code.
Definition: avassert.h:56
IS_QUANT
#define IS_QUANT(a)
Definition: mpegutils.h:85
ff_h261_reorder_mb_index
void ff_h261_reorder_mb_index(MpegEncContext *s)
Definition: h261enc.c:119
ff_h261_mtype_code
const uint8_t ff_h261_mtype_code[10]
Definition: h261data.c:63
uni_h261_rl_len
static uint8_t uni_h261_rl_len[64 *128]
Definition: h261enc.c:53
AVCodec::name
const char * name
Name of the codec implementation.
Definition: codec.h:194
len
int len
Definition: vorbis_enc_data.h:426
AVCOL_RANGE_MPEG
@ AVCOL_RANGE_MPEG
Narrow or limited range content.
Definition: pixfmt.h:729
get_cbp
static int get_cbp(MpegEncContext *s, int16_t block[6][64])
Definition: h261enc.c:153
avcodec.h
h261enc.h
put_bits_ptr
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:392
h261_mv_codes
static uint8_t h261_mv_codes[64][2]
Definition: h261enc.c:55
ff_h261_mtype_map
const uint16_t ff_h261_mtype_map[10]
Definition: h261data.c:75
ff_h261_mtype_bits
const uint8_t ff_h261_mtype_bits[10]
Definition: h261data.c:69
VLCLUT::len
uint8_t len
Definition: h261enc.c:45
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
ff_mpv_encode_init
av_cold int ff_mpv_encode_init(AVCodecContext *avctx)
Definition: mpegvideo_enc.c:420
h261_encode_motion
static void h261_encode_motion(PutBitContext *pb, int val)
Definition: h261enc.c:147
block
The exact code depends on how similar the blocks are and how related they are to the block
Definition: filter_design.txt:207
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
h
h
Definition: vp9dsp_template.c:2070
H261_ESC_LEN
#define H261_ESC_LEN
Definition: h261enc.c:41
H261EncContext::H261_CIF
@ H261_CIF
Definition: h261enc.c:65
ff_h261_mba_bits
const uint8_t ff_h261_mba_bits[35]
Definition: h261data.c:48
MpegEncContext
MpegEncContext.
Definition: mpegvideo.h:73