FFmpeg: libavcodec/h261enc.c Source File

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

AltStyle によって変換されたページ (->オリジナル) /