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 "mpegvideodata.h"
38 #include "mpegvideoenc.h"
39 
40 static uint8_t uni_h261_rl_len [64*64*2*2];
41 #define UNI_ENC_INDEX(last,run,level) ((last)*128*64 + (run)*128 + (level))
42 
43 typedef struct H261EncContext {
45 
47 
50 
52 {
53  // QCIF
54  if (width == 176 && height == 144)
55  return 0;
56  // CIF
57  else if (width == 352 && height == 288)
58  return 1;
59  // ERROR
60  else
61  return AVERROR(EINVAL);
62 }
63 
65 {
66  H261EncContext *const h = (H261EncContext *)s;
67  int format, temp_ref;
68 
69  align_put_bits(&s->pb);
70 
71  /* Update the pointer to last GOB */
72  s->ptr_lastgob = put_bits_ptr(&s->pb);
73 
74  put_bits(&s->pb, 20, 0x10); /* PSC */
75 
76  temp_ref = s->picture_number * 30000LL * s->avctx->time_base.num /
77  (1001LL * s->avctx->time_base.den); // FIXME maybe this should use a timestamp
78  put_sbits(&s->pb, 5, temp_ref); /* TemporalReference */
79 
80  put_bits(&s->pb, 1, 0); /* split screen off */
81  put_bits(&s->pb, 1, 0); /* camera off */
82  put_bits(&s->pb, 1, s->pict_type == AV_PICTURE_TYPE_I); /* freeze picture release on/off */
83 
84  format = ff_h261_get_picture_format(s->width, s->height);
85 
86  put_bits(&s->pb, 1, format); /* 0 == QCIF, 1 == CIF */
87 
88  put_bits(&s->pb, 1, 1); /* still image mode */
89  put_bits(&s->pb, 1, 1); /* reserved */
90 
91  put_bits(&s->pb, 1, 0); /* no PEI */
92  if (format == 0)
93  h->gob_number = -1;
94  else
95  h->gob_number = 0;
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 (ff_h261_get_picture_format(s->width, s->height) == 0) {
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  int index = s->mb_x + s->mb_y * s->mb_width;
122 
123  if (index % 11 == 0) {
124  if (index % 33 == 0)
126  s->last_mv[0][0][0] = 0;
127  s->last_mv[0][0][1] = 0;
128  }
129 
130  /* for CIF the GOB's are fragmented in the middle of a scanline
131  * that's why we need to adjust the x and y index of the macroblocks */
132  if (ff_h261_get_picture_format(s->width, s->height) == 1) { // CIF
133  s->mb_x = index % 11;
134  index /= 11;
135  s->mb_y = index % 3;
136  index /= 3;
137  s->mb_x += 11 * (index % 2);
138  index /= 2;
139  s->mb_y += 3 * index;
140 
143  }
144 }
145 
146 static void h261_encode_motion(PutBitContext *pb, int val)
147 {
148  int sign, code;
149  if (val == 0) {
150  code = 0;
152  } else {
153  if (val > 15)
154  val -= 32;
155  if (val < -16)
156  val += 32;
157  sign = val < 0;
158  code = sign ? -val : val;
160  put_bits(pb, 1, sign);
161  }
162 }
163 
164 static inline int get_cbp(MpegEncContext *s, int16_t block[6][64])
165 {
166  int i, cbp;
167  cbp = 0;
168  for (i = 0; i < 6; i++)
169  if (s->block_last_index[i] >= 0)
170  cbp |= 1 << (5 - i);
171  return cbp;
172 }
173 
174 /**
175  * Encode an 8x8 block.
176  * @param block the 8x8 block
177  * @param n block index (0-3 are luma, 4-5 are chroma)
178  */
179 static void h261_encode_block(H261EncContext *h, int16_t *block, int n)
180 {
181  MpegEncContext *const s = &h->s;
182  int level, run, i, j, last_index, last_non_zero, sign, slevel, code;
183  RLTable *rl;
184 
185  rl = &ff_h261_rl_tcoeff;
186  if (s->mb_intra) {
187  /* DC coef */
188  level = block[0];
189  /* 255 cannot be represented, so we clamp */
190  if (level > 254) {
191  level = 254;
192  block[0] = 254;
193  }
194  /* 0 cannot be represented also */
195  else if (level < 1) {
196  level = 1;
197  block[0] = 1;
198  }
199  if (level == 128)
200  put_bits(&s->pb, 8, 0xff);
201  else
202  put_bits(&s->pb, 8, level);
203  i = 1;
204  } else if ((block[0] == 1 || block[0] == -1) &&
205  (s->block_last_index[n] > -1)) {
206  // special case
207  put_bits(&s->pb, 2, block[0] > 0 ? 2 : 3);
208  i = 1;
209  } else {
210  i = 0;
211  }
212 
213  /* AC coefs */
214  last_index = s->block_last_index[n];
215  last_non_zero = i - 1;
216  for (; i <= last_index; i++) {
217  j = s->intra_scantable.permutated[i];
218  level = block[j];
219  if (level) {
220  run = i - last_non_zero - 1;
221  sign = 0;
222  slevel = level;
223  if (level < 0) {
224  sign = 1;
225  level = -level;
226  }
227  code = get_rl_index(rl, 0 /*no last in H.261, EOB is used*/,
228  run, level);
229  if (run == 0 && level < 16)
230  code += 1;
231  put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
232  if (code == rl->n) {
233  put_bits(&s->pb, 6, run);
234  av_assert1(slevel != 0);
235  av_assert1(level <= 127);
236  put_sbits(&s->pb, 8, slevel);
237  } else {
238  put_bits(&s->pb, 1, sign);
239  }
240  last_non_zero = i;
241  }
242  }
243  if (last_index > -1)
244  put_bits(&s->pb, rl->table_vlc[0][1], rl->table_vlc[0][0]); // EOB
245 }
246 
247 void ff_h261_encode_mb(MpegEncContext *s, int16_t block[6][64],
248  int motion_x, int motion_y)
249 {
250  /* The following is only allowed because this encoder
251  * does not use slice threading. */
252  H261EncContext *const h = (H261EncContext *)s;
253  H261Context *const com = &h->common;
254  int mvd, mv_diff_x, mv_diff_y, i, cbp;
255  cbp = 63; // avoid warning
256  mvd = 0;
257 
258  com->mtype = 0;
259 
260  if (!s->mb_intra) {
261  /* compute cbp */
262  cbp = get_cbp(s, block);
263 
264  /* mvd indicates if this block is motion compensated */
265  mvd = motion_x | motion_y;
266 
267  if ((cbp | mvd) == 0) {
268  /* skip macroblock */
269  s->skip_count++;
270  s->mb_skip_run++;
271  s->last_mv[0][0][0] = 0;
272  s->last_mv[0][0][1] = 0;
273  s->qscale -= s->dquant;
274  return;
275  }
276  }
277 
278  /* MB is not skipped, encode MBA */
279  put_bits(&s->pb,
280  ff_h261_mba_bits[s->mb_skip_run],
281  ff_h261_mba_code[s->mb_skip_run]);
282  s->mb_skip_run = 0;
283 
284  /* calculate MTYPE */
285  if (!s->mb_intra) {
286  com->mtype++;
287 
288  if (mvd || s->loop_filter)
289  com->mtype += 3;
290  if (s->loop_filter)
291  com->mtype += 3;
292  if (cbp)
293  com->mtype++;
294  av_assert1(com->mtype > 1);
295  }
296 
297  if (s->dquant && cbp) {
298  com->mtype++;
299  } else
300  s->qscale -= s->dquant;
301 
302  put_bits(&s->pb,
304  ff_h261_mtype_code[com->mtype]);
305 
306  com->mtype = ff_h261_mtype_map[com->mtype];
307 
308  if (IS_QUANT(com->mtype)) {
309  ff_set_qscale(s, s->qscale + s->dquant);
310  put_bits(&s->pb, 5, s->qscale);
311  }
312 
313  if (IS_16X16(com->mtype)) {
314  mv_diff_x = (motion_x >> 1) - s->last_mv[0][0][0];
315  mv_diff_y = (motion_y >> 1) - s->last_mv[0][0][1];
316  s->last_mv[0][0][0] = (motion_x >> 1);
317  s->last_mv[0][0][1] = (motion_y >> 1);
318  h261_encode_motion(&s->pb, mv_diff_x);
319  h261_encode_motion(&s->pb, mv_diff_y);
320  }
321 
322  if (HAS_CBP(com->mtype)) {
323  av_assert1(cbp > 0);
324  put_bits(&s->pb,
325  ff_h261_cbp_tab[cbp - 1][1],
326  ff_h261_cbp_tab[cbp - 1][0]);
327  }
328  for (i = 0; i < 6; i++)
329  /* encode each block */
331 
332  if (!IS_16X16(com->mtype)) {
333  s->last_mv[0][0][0] = 0;
334  s->last_mv[0][0][1] = 0;
335  }
336 }
337 
338 static av_cold void init_uni_h261_rl_tab(const RLTable *rl, uint8_t *len_tab)
339 {
340  int slevel, run, last;
341 
342  av_assert0(MAX_LEVEL >= 64);
343  av_assert0(MAX_RUN >= 63);
344 
345  for(slevel=-64; slevel<64; slevel++){
346  if(slevel==0) continue;
347  for(run=0; run<64; run++){
348  for(last=0; last<=1; last++){
349  const int index= UNI_ENC_INDEX(last, run, slevel+64);
350  int level= slevel < 0 ? -slevel : slevel;
351  int len, code;
352 
353  len_tab[index]= 100;
354 
355  /* ESC0 */
356  code= get_rl_index(rl, 0, run, level);
357  len= rl->table_vlc[code][1] + 1;
358  if(last)
359  len += 2;
360 
361  if(code!=rl->n && len < len_tab[index]){
362  len_tab [index]= len;
363  }
364  /* ESC */
365  len = rl->table_vlc[rl->n][1];
366  if(last)
367  len += 2;
368 
369  if(len < len_tab[index]){
370  len_tab [index]= len;
371  }
372  }
373  }
374  }
375 }
376 
378 {
379  static uint8_t h261_rl_table_store[2][2 * MAX_RUN + MAX_LEVEL + 3];
380 
381  ff_rl_init(&ff_h261_rl_tcoeff, h261_rl_table_store);
383 }
384 
386 {
387  H261EncContext *const h = (H261EncContext*)s;
388  static AVOnce init_static_once = AV_ONCE_INIT;
389 
390  s->private_ctx = &h->common;
391 
392  s->min_qcoeff = -127;
393  s->max_qcoeff = 127;
394  s->y_dc_scale_table =
395  s->c_dc_scale_table = ff_mpeg1_dc_scale_table;
396  s->ac_esc_length = 6+6+8;
397 
398  s->intra_ac_vlc_length = s->inter_ac_vlc_length = uni_h261_rl_len;
399  s->intra_ac_vlc_last_length = s->inter_ac_vlc_last_length = uni_h261_rl_len + 128*64;
400  ff_thread_once(&init_static_once, h261_encode_init_static);
401 }
402 
404  .p.name = "h261",
405  .p.long_name = NULL_IF_CONFIG_SMALL("H.261"),
406  .p.type = AVMEDIA_TYPE_VIDEO,
407  .p.id = AV_CODEC_ID_H261,
408  .p.priv_class = &ff_mpv_enc_class,
409  .priv_data_size = sizeof(H261EncContext),
412  .close = ff_mpv_encode_end,
414  .p.pix_fmts = (const enum AVPixelFormat[]) { AV_PIX_FMT_YUV420P,
415  AV_PIX_FMT_NONE },
416 };
AVPixelFormat
AVPixelFormat
Pixel format.
Definition: pixfmt.h:64
ff_mpv_enc_class
const AVClass ff_mpv_enc_class
Definition: mpegvideo_enc.c:101
level
uint8_t level
Definition: svq3.c:206
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:39
H261EncContext
Definition: h261enc.c:43
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:413
thread.h
ff_mpeg1_dc_scale_table
const uint8_t ff_mpeg1_dc_scale_table[128]
Definition: mpegvideodata.c:33
H261EncContext::s
MpegEncContext s
Definition: h261enc.c:44
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:46
MAX_RUN
#define MAX_RUN
Definition: rl.h:35
put_bits
static void put_bits(Jpeg2000EncoderContext *s, int val, int n)
put n times val bit
Definition: j2kenc.c:221
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:247
FFCodec
Definition: codec_internal.h:112
ff_init_block_index
void ff_init_block_index(MpegEncContext *s)
Definition: mpegvideo.c:1673
mpegvideo.h
mpegutils.h
AV_CODEC_ID_H261
@ AV_CODEC_ID_H261
Definition: codec_id.h:53
ff_h261_encode_picture_header
void ff_h261_encode_picture_header(MpegEncContext *s, int picture_number)
Definition: h261enc.c:64
init
static int init
Definition: av_tx.c:47
ff_h261_encoder
const FFCodec ff_h261_encoder
Definition: h261enc.c:403
ff_mpv_encode_picture
int ff_mpv_encode_picture(AVCodecContext *avctx, AVPacket *pkt, const AVFrame *pic_arg, int *got_packet)
Definition: mpegvideo_enc.c:1662
ff_h261_mtype_map
const int ff_h261_mtype_map[10]
Definition: h261data.c:75
FFCodec::p
AVCodec p
The public AVCodec.
Definition: codec_internal.h:116
h261.h
RLTable
RLTable.
Definition: rl.h:39
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:263
HAS_CBP
#define HAS_CBP(a)
Definition: mpegutils.h:94
avassert.h
RLTable::n
int n
number of entries of table_vlc minus 1
Definition: rl.h:40
ff_thread_once
static int ff_thread_once(char *control, void(*routine)(void))
Definition: thread.h:179
av_cold
#define av_cold
Definition: attributes.h:90
width
#define width
s
#define s(width, name)
Definition: cbs_vp9.c:256
format
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
get_rl_index
static int get_rl_index(const RLTable *rl, int last, int run, int level)
Definition: rl.h:91
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
ff_h261_mba_code
const uint8_t ff_h261_mba_code[35]
Definition: h261data.c:34
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
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:66
PutBitContext
Definition: put_bits.h:50
ff_rl_init
av_cold void ff_rl_init(RLTable *rl, uint8_t static_store[2][2 *MAX_RUN+MAX_LEVEL+3])
Initialize index_run, max_level and max_run from n, last, table_vlc, table_run and table_level.
Definition: rl.c:27
AV_ONCE_INIT
#define AV_ONCE_INIT
Definition: thread.h:177
h261_encode_block
static void h261_encode_block(H261EncContext *h, int16_t *block, int n)
Encode an 8x8 block.
Definition: h261enc.c:179
run
uint8_t run
Definition: svq3.c:205
RLTable::table_vlc
const uint16_t(* table_vlc)[2]
Definition: rl.h:42
AV_PICTURE_TYPE_I
@ AV_PICTURE_TYPE_I
Intra.
Definition: avutil.h:274
ff_set_qscale
void ff_set_qscale(MpegEncContext *s, int qscale)
set qscale and update qscale dependent variables.
Definition: mpegvideo.c:1709
ff_mpv_encode_end
av_cold int ff_mpv_encode_end(AVCodecContext *avctx)
Definition: mpegvideo_enc.c:925
AVOnce
#define AVOnce
Definition: thread.h:176
index
int index
Definition: gxfenc.c:89
MAX_LEVEL
#define MAX_LEVEL
Definition: rl.h:36
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:117
codec_internal.h
height
#define height
mpegvideodata.h
attributes.h
H261EncContext::gob_number
int gob_number
Definition: h261enc.c:48
IS_16X16
#define IS_16X16(a)
Definition: mpegutils.h:79
H261Context
H261Context.
Definition: h261.h:37
ff_update_block_index
static void ff_update_block_index(MpegEncContext *s)
Definition: mpegvideo.h:593
h261_encode_init_static
static av_cold void h261_encode_init_static(void)
Definition: h261enc.c:377
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:271
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:53
IS_QUANT
#define IS_QUANT(a)
Definition: mpegutils.h:88
ff_h261_reorder_mb_index
void ff_h261_reorder_mb_index(MpegEncContext *s)
Definition: h261enc.c:119
FF_CODEC_CAP_INIT_THREADSAFE
#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: codec_internal.h:31
ff_h261_mtype_code
const uint8_t ff_h261_mtype_code[10]
Definition: h261data.c:63
ff_h261_get_picture_format
int ff_h261_get_picture_format(int width, int height)
Definition: h261enc.c:51
AVCodec::name
const char * name
Name of the codec implementation.
Definition: codec.h:203
len
int len
Definition: vorbis_enc_data.h:426
get_cbp
static int get_cbp(MpegEncContext *s, int16_t block[6][64])
Definition: h261enc.c:164
avcodec.h
init_uni_h261_rl_tab
static av_cold void init_uni_h261_rl_tab(const RLTable *rl, uint8_t *len_tab)
Definition: h261enc.c:338
ff_h261_rl_tcoeff
RLTable ff_h261_rl_tcoeff
Definition: h261data.c:150
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:370
AV_PIX_FMT_NONE
@ AV_PIX_FMT_NONE
Definition: pixfmt.h:65
ff_h261_mtype_bits
const uint8_t ff_h261_mtype_bits[10]
Definition: h261data.c:69
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:311
h261_encode_motion
static void h261_encode_motion(PutBitContext *pb, int val)
Definition: h261enc.c:146
ff_h261_encode_init
av_cold void ff_h261_encode_init(MpegEncContext *s)
Definition: h261enc.c:385
block
The exact code depends on how similar the blocks are and how related they are to the block
Definition: filter_design.txt:207
uni_h261_rl_len
static uint8_t uni_h261_rl_len[64 *64 *2 *2]
Definition: h261enc.c:40
h
h
Definition: vp9dsp_template.c:2038
ff_h261_mba_bits
const uint8_t ff_h261_mba_bits[35]
Definition: h261data.c:48
MpegEncContext
MpegEncContext.
Definition: mpegvideo.h:62
UNI_ENC_INDEX
#define UNI_ENC_INDEX(last, run, level)
Definition: h261enc.c:41