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 "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;
142  put_bits(&s->pb, ff_h261_mv_tab[code][1], ff_h261_mv_tab[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;
150  put_bits(&s->pb, ff_h261_mv_tab[code][1], ff_h261_mv_tab[code][0]);
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,
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,
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 */
318  h261_encode_block(h, block[i], i);
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 =
381  s->ac_esc_length = 6+6+8;
382 
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 };
#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:48
void ff_init_block_index(MpegEncContext *s)
Definition: mpegvideo.c:2272
#define UNI_ENC_INDEX(last, run, level)
Definition: h261enc.c:39
int picture_number
Definition: mpegvideo.h:127
static void align_put_bits(PutBitContext *s)
Pad the bitstream with zeros up to the next byte boundary.
Definition: put_bits.h:393
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:260
void ff_h261_encode_mb(MpegEncContext *s, int16_t block[6][64], int motion_x, int motion_y)
Definition: h261enc.c:238
static void put_bits(Jpeg2000EncoderContext *s, int val, int n)
put n times val bit
Definition: j2kenc.c:218
#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:235
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:54
uint8_t run
Definition: svq3.c:205
uint8_t * intra_ac_vlc_length
Definition: mpegvideo.h:311
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 format(the sample packing is implied by the sample format) and sample rate.The lists are not just lists
AVCodec.
Definition: codec.h:190
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:654
AVCodec ff_h261_encoder
Definition: h261enc.c:395
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:506
const AVOption ff_mpv_generic_options[]
Definition: mpegvideo_enc.c:88
const uint8_t ff_mpeg1_dc_scale_table[128]
Definition: mpegvideodata.c:33
#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:40
The exact code depends on how similar the blocks are and how related they are to the block
uint8_t
#define av_cold
Definition: attributes.h:88
#define height
static void h261_encode_gob_header(MpegEncContext *s, int mb_line)
Encode a group of blocks header.
Definition: h261enc.c:92
int max_qcoeff
maximum encodable coefficient
Definition: mpegvideo.h:309
#define AVOnce
Definition: thread.h:172
#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:742
void ff_set_qscale(MpegEncContext *s, int qscale)
set qscale and update qscale dependent variables.
Definition: mpegvideo.c:2336
static void h261_encode_block(H261Context *h, int16_t *block, int n)
Encode an 8x8 block.
Definition: h261enc.c:170
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:349
static const AVClass h261_class
Definition: h261enc.c:388
uint8_t * inter_ac_vlc_last_length
Definition: mpegvideo.h:316
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:115
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: codec.h:197
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
#define width
#define s(width, name)
Definition: cbs_vp9.c:257
int block_last_index[12]
last non zero coefficient in block
Definition: mpegvideo.h:86
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
av_cold void ff_rl_init(RLTable *rl, uint8_t static_store[2][2 *MAX_RUN+MAX_LEVEL+3])
Definition: rl.c:28
const uint8_t ff_h261_mv_tab[17][2]
Definition: h261data.c:89
static av_cold void h261_encode_init_static(void)
Definition: h261enc.c:365
const int ff_h261_mtype_map[10]
Definition: h261data.c:75
#define AV_ONCE_INIT
Definition: thread.h:173
Libavcodec external API header.
void ff_h261_reorder_mb_index(MpegEncContext *s)
Definition: h261enc.c:109
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:41
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:155
int index
Definition: gxfenc.c:89
static av_cold void init_uni_h261_rl_tab(const RLTable *rl, uint8_t *len_tab)
Definition: h261enc.c:326
static void h261_encode_motion(H261Context *h, int val)
Definition: h261enc.c:136
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:303
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
const uint8_t * c_dc_scale_table
qscale -> c_dc_scale table
Definition: mpegvideo.h:189
uint8_t level
Definition: svq3.c:206
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:66
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:79
static uint8_t uni_h261_rl_len[64 *64 *2 *2]
Definition: h261enc.c:38
int len
static int ff_thread_once(char *control, void(*routine)(void))
Definition: thread.h:175
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
int ff_mpv_encode_picture(AVCodecContext *avctx, AVPacket *pkt, const AVFrame *frame, int *got_packet)
av_cold void ff_h261_encode_init(MpegEncContext *s)
Definition: h261enc.c:373
AVPixelFormat
Pixel format.
Definition: pixfmt.h:64
static double val(void *priv, double ch)
Definition: aeval.c:76
int i
Definition: input.c:407