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 
49  enum {
50  H261_QCIF = 0,
51  H261_CIF = 1,
52  } format;
54 
56 {
57  H261EncContext *const h = (H261EncContext *)s;
58  int temp_ref;
59 
60  align_put_bits(&s->pb);
61 
62  /* Update the pointer to last GOB */
63  s->ptr_lastgob = put_bits_ptr(&s->pb);
64 
65  put_bits(&s->pb, 20, 0x10); /* PSC */
66 
67  temp_ref = s->picture_number * 30000LL * s->avctx->time_base.num /
68  (1001LL * s->avctx->time_base.den); // FIXME maybe this should use a timestamp
69  put_sbits(&s->pb, 5, temp_ref); /* TemporalReference */
70 
71  put_bits(&s->pb, 1, 0); /* split screen off */
72  put_bits(&s->pb, 1, 0); /* camera off */
73  put_bits(&s->pb, 1, s->pict_type == AV_PICTURE_TYPE_I); /* freeze picture release on/off */
74 
75  put_bits(&s->pb, 1, h->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  h->gob_number = h->format - 1;
82  s->mb_skip_run = 0;
83 }
84 
85 /**
86  * Encode a group of blocks header.
87  */
88 static void h261_encode_gob_header(MpegEncContext *s, int mb_line)
89 {
90  H261EncContext *const h = (H261EncContext *)s;
91  if (h->format == H261_QCIF) {
92  h->gob_number += 2; // QCIF
93  } else {
94  h->gob_number++; // CIF
95  }
96  put_bits(&s->pb, 16, 1); /* GBSC */
97  put_bits(&s->pb, 4, h->gob_number); /* GN */
98  put_bits(&s->pb, 5, s->qscale); /* GQUANT */
99  put_bits(&s->pb, 1, 0); /* no GEI */
100  s->mb_skip_run = 0;
101  s->last_mv[0][0][0] = 0;
102  s->last_mv[0][0][1] = 0;
103 }
104 
106 {
107  const H261EncContext *const h = (H261EncContext*)s;
108  int index = s->mb_x + s->mb_y * s->mb_width;
109 
110  if (index % 11 == 0) {
111  if (index % 33 == 0)
113  s->last_mv[0][0][0] = 0;
114  s->last_mv[0][0][1] = 0;
115  }
116 
117  /* for CIF the GOB's are fragmented in the middle of a scanline
118  * that's why we need to adjust the x and y index of the macroblocks */
119  if (h->format == H261_CIF) {
120  s->mb_x = index % 11;
121  index /= 11;
122  s->mb_y = index % 3;
123  index /= 3;
124  s->mb_x += 11 * (index % 2);
125  index /= 2;
126  s->mb_y += 3 * index;
127 
129  ff_update_block_index(s, 8, 0, 1);
130  }
131 }
132 
133 static void h261_encode_motion(PutBitContext *pb, int val)
134 {
135  int sign, code;
136  if (val == 0) {
137  code = 0;
139  } else {
140  if (val > 15)
141  val -= 32;
142  if (val < -16)
143  val += 32;
144  sign = val < 0;
145  code = sign ? -val : val;
147  put_bits(pb, 1, sign);
148  }
149 }
150 
151 static inline int get_cbp(MpegEncContext *s, int16_t block[6][64])
152 {
153  int i, cbp;
154  cbp = 0;
155  for (i = 0; i < 6; i++)
156  if (s->block_last_index[i] >= 0)
157  cbp |= 1 << (5 - i);
158  return cbp;
159 }
160 
161 /**
162  * Encode an 8x8 block.
163  * @param block the 8x8 block
164  * @param n block index (0-3 are luma, 4-5 are chroma)
165  */
166 static void h261_encode_block(H261EncContext *h, int16_t *block, int n)
167 {
168  MpegEncContext *const s = &h->s;
169  int level, run, i, j, last_index, last_non_zero, sign, slevel, code;
170  RLTable *rl;
171 
172  rl = &ff_h261_rl_tcoeff;
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  sign = 0;
209  slevel = level;
210  if (level < 0) {
211  sign = 1;
212  level = -level;
213  }
214  code = get_rl_index(rl, 0 /*no last in H.261, EOB is used*/,
215  run, level);
216  if (run == 0 && level < 16)
217  code += 1;
218  put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
219  if (code == rl->n) {
220  put_bits(&s->pb, 6, run);
221  av_assert1(slevel != 0);
222  av_assert1(level <= 127);
223  put_sbits(&s->pb, 8, slevel);
224  } else {
225  put_bits(&s->pb, 1, sign);
226  }
227  last_non_zero = i;
228  }
229  }
230  if (last_index > -1)
231  put_bits(&s->pb, rl->table_vlc[0][1], rl->table_vlc[0][0]); // EOB
232 }
233 
234 void ff_h261_encode_mb(MpegEncContext *s, int16_t block[6][64],
235  int motion_x, int motion_y)
236 {
237  /* The following is only allowed because this encoder
238  * does not use slice threading. */
239  H261EncContext *const h = (H261EncContext *)s;
240  H261Context *const com = &h->common;
241  int mvd, mv_diff_x, mv_diff_y, i, cbp;
242  cbp = 63; // avoid warning
243  mvd = 0;
244 
245  com->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  com->mtype++;
274 
275  if (mvd || s->loop_filter)
276  com->mtype += 3;
277  if (s->loop_filter)
278  com->mtype += 3;
279  if (cbp)
280  com->mtype++;
281  av_assert1(com->mtype > 1);
282  }
283 
284  if (s->dquant && cbp) {
285  com->mtype++;
286  } else
287  s->qscale -= s->dquant;
288 
289  put_bits(&s->pb,
291  ff_h261_mtype_code[com->mtype]);
292 
293  com->mtype = ff_h261_mtype_map[com->mtype];
294 
295  if (IS_QUANT(com->mtype)) {
296  ff_set_qscale(s, s->qscale + s->dquant);
297  put_bits(&s->pb, 5, s->qscale);
298  }
299 
300  if (IS_16X16(com->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(&s->pb, mv_diff_x);
306  h261_encode_motion(&s->pb, mv_diff_y);
307  }
308 
309  if (HAS_CBP(com->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 */
318 
319  if (!IS_16X16(com->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(const RLTable *rl, uint8_t *len_tab)
326 {
327  int slevel, run, last;
328 
329  av_assert0(MAX_LEVEL >= 64);
330  av_assert0(MAX_RUN >= 63);
331 
332  for(slevel=-64; slevel<64; slevel++){
333  if(slevel==0) continue;
334  for(run=0; run<64; run++){
335  for(last=0; last<=1; last++){
336  const int index= UNI_ENC_INDEX(last, run, slevel+64);
337  int level= slevel < 0 ? -slevel : slevel;
338  int len, code;
339 
340  len_tab[index]= 100;
341 
342  /* ESC0 */
343  code= get_rl_index(rl, 0, run, level);
344  len= rl->table_vlc[code][1] + 1;
345  if(last)
346  len += 2;
347 
348  if(code!=rl->n && len < len_tab[index]){
349  len_tab [index]= len;
350  }
351  /* ESC */
352  len = rl->table_vlc[rl->n][1];
353  if(last)
354  len += 2;
355 
356  if(len < len_tab[index]){
357  len_tab [index]= len;
358  }
359  }
360  }
361  }
362 }
363 
365 {
366  static uint8_t h261_rl_table_store[2][2 * MAX_RUN + MAX_LEVEL + 3];
367 
368  ff_rl_init(&ff_h261_rl_tcoeff, h261_rl_table_store);
370 }
371 
373 {
374  H261EncContext *const h = (H261EncContext*)s;
375  static AVOnce init_static_once = AV_ONCE_INIT;
376 
377  if (s->width == 176 && s->height == 144) {
378  h->format = H261_QCIF;
379  } else if (s->width == 352 && s->height == 288) {
380  h->format = H261_CIF;
381  } else {
382  av_log(s->avctx, AV_LOG_ERROR,
383  "The specified picture size of %dx%d is not valid for the "
384  "H.261 codec.\nValid sizes are 176x144, 352x288\n",
385  s->width, s->height);
386  return AVERROR(EINVAL);
387  }
388  s->private_ctx = &h->common;
389 
390  s->min_qcoeff = -127;
391  s->max_qcoeff = 127;
392  s->y_dc_scale_table =
393  s->c_dc_scale_table = ff_mpeg1_dc_scale_table;
394  s->ac_esc_length = 6+6+8;
395 
396  s->intra_ac_vlc_length = s->inter_ac_vlc_length = uni_h261_rl_len;
397  s->intra_ac_vlc_last_length = s->inter_ac_vlc_last_length = uni_h261_rl_len + 128*64;
398  ff_thread_once(&init_static_once, h261_encode_init_static);
399 
400  return 0;
401 }
402 
404  .p.name = "h261",
405  CODEC_LONG_NAME("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,
413  .caps_internal = FF_CODEC_CAP_INIT_CLEANUP,
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:204
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:43
ff_h261_encode_init
av_cold int ff_h261_encode_init(MpegEncContext *s)
Definition: h261enc.c:372
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
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:234
FFCodec
Definition: codec_internal.h:119
ff_init_block_index
void ff_init_block_index(MpegEncContext *s)
Definition: mpegvideo.c:857
mpegvideo.h
mpegutils.h
AV_CODEC_ID_H261
@ AV_CODEC_ID_H261
Definition: codec_id.h:55
ff_h261_encode_picture_header
void ff_h261_encode_picture_header(MpegEncContext *s, int picture_number)
Definition: h261enc.c:55
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:1744
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:123
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:307
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:184
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:180
av_cold
#define av_cold
Definition: attributes.h:90
H261EncContext::H261_CIF
@ H261_CIF
Definition: h261enc.c:51
s
#define s(width, name)
Definition: cbs_vp9.c:256
get_rl_index
static int get_rl_index(const RLTable *rl, int last, int run, int level)
Definition: rl.h:101
init
int(* init)(AVBSFContext *ctx)
Definition: dts2pts_bsf.c:363
h261_encode_gob_header
static void h261_encode_gob_header(MpegEncContext *s, int mb_line)
Encode a group of blocks header.
Definition: h261enc.c:88
ff_h261_mba_code
const uint8_t ff_h261_mba_code[35]
Definition: h261data.c:34
ff_mpeg1_dc_scale_table
static const uint8_t *const ff_mpeg1_dc_scale_table
Definition: mpegvideodata.h:32
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:44
CODEC_LONG_NAME
#define CODEC_LONG_NAME(str)
Definition: codec_internal.h:264
AV_ONCE_INIT
#define AV_ONCE_INIT
Definition: thread.h:182
h261_encode_block
static void h261_encode_block(H261EncContext *h, int16_t *block, int n)
Encode an 8x8 block.
Definition: h261enc.c:166
run
uint8_t run
Definition: svq3.c:203
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:890
ff_mpv_encode_end
av_cold int ff_mpv_encode_end(AVCodecContext *avctx)
Definition: mpegvideo_enc.c:980
AVOnce
#define AVOnce
Definition: thread.h:181
index
int index
Definition: gxfenc.c:89
MAX_LEVEL
#define MAX_LEVEL
Definition: rl.h:36
H261EncContext::format
enum H261EncContext::@70 format
codec_internal.h
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:600
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
h261_encode_init_static
static av_cold void h261_encode_init_static(void)
Definition: h261enc.c:364
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:269
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:105
ff_h261_mtype_code
const uint8_t ff_h261_mtype_code[10]
Definition: h261data.c:63
AVCodec::name
const char * name
Name of the codec implementation.
Definition: codec.h:211
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:151
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:325
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:133
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
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:70
H261EncContext::H261_QCIF
@ H261_QCIF
Definition: h261enc.c:50
UNI_ENC_INDEX
#define UNI_ENC_INDEX(last, run, level)
Definition: h261enc.c:41