FFmpeg
zmbvenc.c
Go to the documentation of this file.
1 /*
2  * Zip Motion Blocks Video (ZMBV) encoder
3  * Copyright (c) 2006 Konstantin Shishkov
4  *
5  * This file is part of FFmpeg.
6  *
7  * FFmpeg is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU Lesser General Public
9  * License as published by the Free Software Foundation; either
10  * version 2.1 of the License, or (at your option) any later version.
11  *
12  * FFmpeg is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15  * Lesser General Public License for more details.
16  *
17  * You should have received a copy of the GNU Lesser General Public
18  * License along with FFmpeg; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20  */
21 
22 /**
23  * @file
24  * Zip Motion Blocks Video encoder
25  */
26 
27 #include <stdio.h>
28 #include <stdlib.h>
29 
30 #include "libavutil/common.h"
31 #include "libavutil/intreadwrite.h"
32 #include "avcodec.h"
33 #include "codec_internal.h"
34 #include "encode.h"
35 #include "zlib_wrapper.h"
36 
37 #include <zlib.h>
38 
39 /* Frame header flags */
40 #define ZMBV_KEYFRAME 1
41 #define ZMBV_DELTAPAL 2
42 
43 /* Motion block width/height (maximum allowed value is 255)
44  * Note: histogram datatype in block_cmp() must be big enough to hold values
45  * up to (4 * ZMBV_BLOCK * ZMBV_BLOCK)
46  */
47 #define ZMBV_BLOCK 16
48 
49 /* Keyframe header format values */
50 enum ZmbvFormat {
60 };
61 
62 /**
63  * Encoder context
64  */
65 typedef struct ZmbvEncContext {
67 
68  int lrange, urange;
69  uint8_t *comp_buf, *work_buf;
70  uint8_t pal[768];
71  uint32_t pal2[256]; //for quick comparisons
72  uint8_t *prev, *prev_buf;
73  int pstride;
74  int comp_size;
75  int keyint, curfrm;
76  int bypp;
79 
82 
83 
84 /** Block comparing function
85  * XXX should be optimized and moved to DSPContext
86  */
87 static inline int block_cmp(ZmbvEncContext *c, const uint8_t *src, int stride,
88  const uint8_t *src2, int stride2, int bw, int bh,
89  int *xored)
90 {
91  int sum = 0;
92  int i, j;
93  uint16_t histogram[256] = {0};
94  int bw_bytes = bw * c->bypp;
95 
96  /* Build frequency histogram of byte values for src[] ^ src2[] */
97  for(j = 0; j < bh; j++){
98  for(i = 0; i < bw_bytes; i++){
99  int t = src[i] ^ src2[i];
100  histogram[t]++;
101  }
102  src += stride;
103  src2 += stride2;
104  }
105 
106  /* If not all the xored values were 0, then the blocks are different */
107  *xored = (histogram[0] < bw_bytes * bh);
108 
109  /* Exit early if blocks are equal */
110  if (!*xored) return 0;
111 
112  /* Sum the entropy of all values */
113  for(i = 0; i < 256; i++)
114  sum += c->score_tab[histogram[i]];
115 
116  return sum;
117 }
118 
119 /** Motion estimation function
120  * TODO make better ME decisions
121  */
122 static int zmbv_me(ZmbvEncContext *c, const uint8_t *src, int sstride, const uint8_t *prev,
123  int pstride, int x, int y, int *mx, int *my, int *xored)
124 {
125  int dx, dy, txored, tv, bv, bw, bh;
126  int mx0, my0;
127 
128  mx0 = *mx;
129  my0 = *my;
130  bw = FFMIN(ZMBV_BLOCK, c->avctx->width - x);
131  bh = FFMIN(ZMBV_BLOCK, c->avctx->height - y);
132 
133  /* Try (0,0) */
134  bv = block_cmp(c, src, sstride, prev, pstride, bw, bh, xored);
135  *mx = *my = 0;
136  if(!bv) return 0;
137 
138  /* Try previous block's MV (if not 0,0) */
139  if (mx0 || my0){
140  tv = block_cmp(c, src, sstride, prev + mx0 * c->bypp + my0 * pstride, pstride, bw, bh, &txored);
141  if(tv < bv){
142  bv = tv;
143  *mx = mx0;
144  *my = my0;
145  *xored = txored;
146  if(!bv) return 0;
147  }
148  }
149 
150  /* Try other MVs from top-to-bottom, left-to-right */
151  for(dy = -c->lrange; dy <= c->urange; dy++){
152  for(dx = -c->lrange; dx <= c->urange; dx++){
153  if(!dx && !dy) continue; // we already tested this block
154  if(dx == mx0 && dy == my0) continue; // this one too
155  tv = block_cmp(c, src, sstride, prev + dx * c->bypp + dy * pstride, pstride, bw, bh, &txored);
156  if(tv < bv){
157  bv = tv;
158  *mx = dx;
159  *my = dy;
160  *xored = txored;
161  if(!bv) return 0;
162  }
163  }
164  }
165  return bv;
166 }
167 
169  const AVFrame *pict, int *got_packet)
170 {
171  ZmbvEncContext * const c = avctx->priv_data;
172  z_stream *const zstream = &c->zstream.zstream;
173  const AVFrame * const p = pict;
174  const uint8_t *src;
175  uint8_t *prev, *buf;
176  uint32_t *palptr;
177  int keyframe, chpal;
178  int fl;
179  int work_size = 0, pkt_size;
180  int bw, bh;
181  int i, j, ret;
182 
183  keyframe = !c->curfrm;
184  c->curfrm++;
185  if(c->curfrm == c->keyint)
186  c->curfrm = 0;
187 
188  palptr = (avctx->pix_fmt == AV_PIX_FMT_PAL8) ? (uint32_t *)p->data[1] : NULL;
189  chpal = !keyframe && palptr && memcmp(palptr, c->pal2, 1024);
190 
191  src = p->data[0];
192  prev = c->prev;
193  if(chpal){
194  uint8_t tpal[3];
195  for(i = 0; i < 256; i++){
196  AV_WB24(tpal, palptr[i]);
197  c->work_buf[work_size++] = tpal[0] ^ c->pal[i * 3 + 0];
198  c->work_buf[work_size++] = tpal[1] ^ c->pal[i * 3 + 1];
199  c->work_buf[work_size++] = tpal[2] ^ c->pal[i * 3 + 2];
200  c->pal[i * 3 + 0] = tpal[0];
201  c->pal[i * 3 + 1] = tpal[1];
202  c->pal[i * 3 + 2] = tpal[2];
203  }
204  memcpy(c->pal2, palptr, 1024);
205  }
206  if(keyframe){
207  if (palptr){
208  for(i = 0; i < 256; i++){
209  AV_WB24(c->pal+(i*3), palptr[i]);
210  }
211  memcpy(c->work_buf, c->pal, 768);
212  memcpy(c->pal2, palptr, 1024);
213  work_size = 768;
214  }
215  for(i = 0; i < avctx->height; i++){
216  memcpy(c->work_buf + work_size, src, avctx->width * c->bypp);
217  src += p->linesize[0];
218  work_size += avctx->width * c->bypp;
219  }
220  }else{
221  int x, y, bh2, bw2, xored;
222  const uint8_t *tsrc, *tprev;
223  uint8_t *mv;
224  int mx = 0, my = 0;
225 
226  bw = (avctx->width + ZMBV_BLOCK - 1) / ZMBV_BLOCK;
227  bh = (avctx->height + ZMBV_BLOCK - 1) / ZMBV_BLOCK;
228  mv = c->work_buf + work_size;
229  memset(c->work_buf + work_size, 0, (bw * bh * 2 + 3) & ~3);
230  work_size += (bw * bh * 2 + 3) & ~3;
231  /* for now just XOR'ing */
232  for(y = 0; y < avctx->height; y += ZMBV_BLOCK) {
233  bh2 = FFMIN(avctx->height - y, ZMBV_BLOCK);
234  for(x = 0; x < avctx->width; x += ZMBV_BLOCK, mv += 2) {
235  bw2 = FFMIN(avctx->width - x, ZMBV_BLOCK);
236 
237  tsrc = src + x * c->bypp;
238  tprev = prev + x * c->bypp;
239 
240  zmbv_me(c, tsrc, p->linesize[0], tprev, c->pstride, x, y, &mx, &my, &xored);
241  mv[0] = (mx * 2) | !!xored;
242  mv[1] = my * 2;
243  tprev += mx * c->bypp + my * c->pstride;
244  if(xored){
245  for(j = 0; j < bh2; j++){
246  for(i = 0; i < bw2 * c->bypp; i++)
247  c->work_buf[work_size++] = tsrc[i] ^ tprev[i];
248  tsrc += p->linesize[0];
249  tprev += c->pstride;
250  }
251  }
252  }
253  src += p->linesize[0] * ZMBV_BLOCK;
254  prev += c->pstride * ZMBV_BLOCK;
255  }
256  }
257  /* save the previous frame */
258  src = p->data[0];
259  prev = c->prev;
260  for(i = 0; i < avctx->height; i++){
261  memcpy(prev, src, avctx->width * c->bypp);
262  prev += c->pstride;
263  src += p->linesize[0];
264  }
265 
266  if (keyframe)
267  deflateReset(zstream);
268 
269  zstream->next_in = c->work_buf;
270  zstream->avail_in = work_size;
271  zstream->total_in = 0;
272 
273  zstream->next_out = c->comp_buf;
274  zstream->avail_out = c->comp_size;
275  zstream->total_out = 0;
276  if (deflate(zstream, Z_SYNC_FLUSH) != Z_OK) {
277  av_log(avctx, AV_LOG_ERROR, "Error compressing data\n");
278  return -1;
279  }
280 
281  pkt_size = zstream->total_out + 1 + 6 * keyframe;
282  if ((ret = ff_get_encode_buffer(avctx, pkt, pkt_size, 0)) < 0)
283  return ret;
284  buf = pkt->data;
285 
286  fl = (keyframe ? ZMBV_KEYFRAME : 0) | (chpal ? ZMBV_DELTAPAL : 0);
287  *buf++ = fl;
288  if (keyframe) {
289  *buf++ = 0; // hi ver
290  *buf++ = 1; // lo ver
291  *buf++ = 1; // comp
292  *buf++ = c->fmt; // format
293  *buf++ = ZMBV_BLOCK; // block width
294  *buf++ = ZMBV_BLOCK; // block height
296  }
297  memcpy(buf, c->comp_buf, zstream->total_out);
298 
299  *got_packet = 1;
300 
301  return 0;
302 }
303 
305 {
306  ZmbvEncContext * const c = avctx->priv_data;
307 
308  av_freep(&c->comp_buf);
309  av_freep(&c->work_buf);
310 
311  av_freep(&c->prev_buf);
312  ff_deflate_end(&c->zstream);
313 
314  return 0;
315 }
316 
317 /**
318  * Init zmbv encoder
319  */
321 {
322  ZmbvEncContext * const c = avctx->priv_data;
323  int i;
324  int lvl = 9;
325  int prev_size, prev_offset;
326 
327  switch (avctx->pix_fmt) {
328  case AV_PIX_FMT_PAL8:
329  c->fmt = ZMBV_FMT_8BPP;
330  c->bypp = 1;
331  break;
332  case AV_PIX_FMT_RGB555LE:
333  c->fmt = ZMBV_FMT_15BPP;
334  c->bypp = 2;
335  break;
336  case AV_PIX_FMT_RGB565LE:
337  c->fmt = ZMBV_FMT_16BPP;
338  c->bypp = 2;
339  break;
340 #ifdef ZMBV_ENABLE_24BPP
341  case AV_PIX_FMT_BGR24:
342  c->fmt = ZMBV_FMT_24BPP;
343  c->bypp = 3;
344  break;
345 #endif //ZMBV_ENABLE_24BPP
346  case AV_PIX_FMT_BGR0:
347  c->fmt = ZMBV_FMT_32BPP;
348  c->bypp = 4;
349  break;
350  }
351 
352  /* Entropy-based score tables for comparing blocks.
353  * Suitable for blocks up to (ZMBV_BLOCK * ZMBV_BLOCK) bytes.
354  * Scores are nonnegative, lower is better.
355  */
356  for(i = 1; i <= ZMBV_BLOCK * ZMBV_BLOCK * c->bypp; i++)
357  c->score_tab[i] = -i * log2(i / (double)(ZMBV_BLOCK * ZMBV_BLOCK * c->bypp)) * 256;
358 
359  c->avctx = avctx;
360 
361  c->curfrm = 0;
362  c->keyint = avctx->keyint_min;
363 
364  /* Motion estimation range: maximum distance is -64..63 */
365  c->lrange = c->urange = 8;
366  if(avctx->me_range > 0){
367  c->lrange = FFMIN(avctx->me_range, 64);
368  c->urange = FFMIN(avctx->me_range, 63);
369  }
370 
371  if(avctx->compression_level >= 0)
372  lvl = avctx->compression_level;
373  if(lvl < 0 || lvl > 9){
374  av_log(avctx, AV_LOG_ERROR, "Compression level should be 0-9, not %i\n", lvl);
375  return AVERROR(EINVAL);
376  }
377 
378  c->comp_size = avctx->width * c->bypp * avctx->height + 1024 +
379  ((avctx->width + ZMBV_BLOCK - 1) / ZMBV_BLOCK) * ((avctx->height + ZMBV_BLOCK - 1) / ZMBV_BLOCK) * 2 + 4;
380  if (!(c->work_buf = av_malloc(c->comp_size))) {
381  av_log(avctx, AV_LOG_ERROR, "Can't allocate work buffer.\n");
382  return AVERROR(ENOMEM);
383  }
384  /* Conservative upper bound taken from zlib v1.2.1 source via lcl.c */
385  c->comp_size = c->comp_size + ((c->comp_size + 7) >> 3) +
386  ((c->comp_size + 63) >> 6) + 11;
387 
388  /* Allocate compression buffer */
389  if (!(c->comp_buf = av_malloc(c->comp_size))) {
390  av_log(avctx, AV_LOG_ERROR, "Can't allocate compression buffer.\n");
391  return AVERROR(ENOMEM);
392  }
393 
394  /* Allocate prev buffer - pad around the image to allow out-of-edge ME:
395  * - The image should be padded with `lrange` rows before and `urange` rows
396  * after.
397  * - The stride should be padded with `lrange` pixels, then rounded up to a
398  * multiple of 16 bytes.
399  * - The first row should also be padded with `lrange` pixels before, then
400  * aligned up to a multiple of 16 bytes.
401  */
402  c->pstride = FFALIGN((avctx->width + c->lrange) * c->bypp, 16);
403  prev_size = FFALIGN(c->lrange * c->bypp, 16) + c->pstride * (c->lrange + avctx->height + c->urange);
404  prev_offset = FFALIGN(c->lrange * c->bypp, 16) + c->pstride * c->lrange;
405  if (!(c->prev_buf = av_mallocz(prev_size))) {
406  av_log(avctx, AV_LOG_ERROR, "Can't allocate picture.\n");
407  return AVERROR(ENOMEM);
408  }
409  c->prev = c->prev_buf + prev_offset;
410 
411  return ff_deflate_init(&c->zstream, lvl, avctx);
412 }
413 
415  .p.name = "zmbv",
416  .p.long_name = NULL_IF_CONFIG_SMALL("Zip Motion Blocks Video"),
417  .p.type = AVMEDIA_TYPE_VIDEO,
418  .p.id = AV_CODEC_ID_ZMBV,
419  .p.capabilities = AV_CODEC_CAP_DR1,
420  .priv_data_size = sizeof(ZmbvEncContext),
421  .init = encode_init,
423  .close = encode_end,
424  .p.pix_fmts = (const enum AVPixelFormat[]) { AV_PIX_FMT_PAL8,
427 #ifdef ZMBV_ENABLE_24BPP
429 #endif //ZMBV_ENABLE_24BPP
431  AV_PIX_FMT_NONE },
432  .caps_internal = FF_CODEC_CAP_INIT_CLEANUP,
433 };
ZmbvEncContext::work_buf
uint8_t * work_buf
Definition: zmbvenc.c:69
ZmbvEncContext::comp_buf
uint8_t * comp_buf
Definition: zmbvenc.c:69
zmbv_me
static int zmbv_me(ZmbvEncContext *c, const uint8_t *src, int sstride, const uint8_t *prev, int pstride, int x, int y, int *mx, int *my, int *xored)
Motion estimation function TODO make better ME decisions.
Definition: zmbvenc.c:122
AVPixelFormat
AVPixelFormat
Pixel format.
Definition: pixfmt.h:64
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:41
AVCodecContext::keyint_min
int keyint_min
minimum GOP size
Definition: avcodec.h:940
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
AV_CODEC_ID_ZMBV
@ AV_CODEC_ID_ZMBV
Definition: codec_id.h:131
mv
static const int8_t mv[256][2]
Definition: 4xm.c:80
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:325
AVPacket::data
uint8_t * data
Definition: packet.h:374
ZmbvEncContext::prev_buf
uint8_t * prev_buf
Definition: zmbvenc.c:72
encode.h
ZMBV_FMT_15BPP
@ ZMBV_FMT_15BPP
Definition: zmbvenc.c:56
FFCodec
Definition: codec_internal.h:118
AV_PIX_FMT_BGR24
@ AV_PIX_FMT_BGR24
packed RGB 8:8:8, 24bpp, BGRBGR...
Definition: pixfmt.h:69
ZMBV_FMT_NONE
@ ZMBV_FMT_NONE
Definition: zmbvenc.c:51
ff_deflate_end
void ff_deflate_end(FFZStream *zstream)
Wrapper around deflateEnd().
ZmbvEncContext::keyint
int keyint
Definition: zmbvenc.c:75
AV_PKT_FLAG_KEY
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
Definition: packet.h:429
encode_end
static av_cold int encode_end(AVCodecContext *avctx)
Definition: zmbvenc.c:304
AVFrame::data
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:346
ZmbvEncContext::zstream
FFZStream zstream
Definition: zmbvenc.c:78
av_malloc
#define av_malloc(s)
Definition: tableprint_vlc.h:30
init
static int init
Definition: av_tx.c:47
ZmbvEncContext::prev
uint8_t * prev
Definition: zmbvenc.c:72
FFCodec::p
AVCodec p
The public AVCodec.
Definition: codec_internal.h:122
ZmbvEncContext::pal2
uint32_t pal2[256]
Definition: zmbvenc.c:71
ZMBV_KEYFRAME
#define ZMBV_KEYFRAME
Definition: zmbvenc.c:40
ZMBV_FMT_8BPP
@ ZMBV_FMT_8BPP
Definition: zmbvenc.c:55
FF_CODEC_ENCODE_CB
#define FF_CODEC_ENCODE_CB(func)
Definition: codec_internal.h:269
pkt
AVPacket * pkt
Definition: movenc.c:59
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:180
zlib_wrapper.h
av_cold
#define av_cold
Definition: attributes.h:90
encode_init
static av_cold int encode_init(AVCodecContext *avctx)
Init zmbv encoder.
Definition: zmbvenc.c:320
intreadwrite.h
block_cmp
static int block_cmp(ZmbvEncContext *c, const uint8_t *src, int stride, const uint8_t *src2, int stride2, int bw, int bh, int *xored)
Block comparing function XXX should be optimized and moved to DSPContext.
Definition: zmbvenc.c:87
ZmbvEncContext::comp_size
int comp_size
Definition: zmbvenc.c:74
AV_PIX_FMT_RGB565LE
@ AV_PIX_FMT_RGB565LE
packed RGB 5:6:5, 16bpp, (msb) 5R 6G 5B(lsb), little-endian
Definition: pixfmt.h:106
NULL
#define NULL
Definition: coverity.c:32
ZmbvEncContext
Encoder context.
Definition: zmbvenc.c:65
ff_zmbv_encoder
const FFCodec ff_zmbv_encoder
Definition: zmbvenc.c:414
ZmbvEncContext::fmt
enum ZmbvFormat fmt
Definition: zmbvenc.c:77
deflate
static void deflate(uint8_t *dst, const uint8_t *p1, int width, int threshold, const uint8_t *coordinates[], int coord, int maxc)
Definition: vf_neighbor.c:162
ZmbvEncContext::pal
uint8_t pal[768]
Definition: zmbvenc.c:70
AV_PIX_FMT_BGR0
@ AV_PIX_FMT_BGR0
packed BGR 8:8:8, 32bpp, BGRXBGRX... X=unused/undefined
Definition: pixfmt.h:230
c
Undefined Behavior In the C some operations are like signed integer dereferencing freed accessing outside allocated Undefined Behavior must not occur in a C it is not safe even if the output of undefined operations is unused The unsafety may seem nit picking but Optimizing compilers have in fact optimized code on the assumption that no undefined Behavior occurs Optimizing code based on wrong assumptions can and has in some cases lead to effects beyond the output of computations The signed integer overflow problem in speed critical code Code which is highly optimized and works with signed integers sometimes has the problem that often the output of the computation does not c
Definition: undefined.txt:32
ZmbvFormat
ZmbvFormat
Definition: zmbv.c:43
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
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
AVCodecContext::me_range
int me_range
maximum motion estimation search range in subpel units If 0 then no limit.
Definition: avcodec.h:854
ZmbvEncContext::avctx
AVCodecContext * avctx
Definition: zmbvenc.c:66
AV_WB24
#define AV_WB24(p, d)
Definition: intreadwrite.h:450
ZMBV_FMT_24BPP
@ ZMBV_FMT_24BPP
Definition: zmbvenc.c:58
AVPacket::flags
int flags
A combination of AV_PKT_FLAG values.
Definition: packet.h:380
ZmbvEncContext::pstride
int pstride
Definition: zmbvenc.c:73
ZMBV_BLOCK
#define ZMBV_BLOCK
Definition: zmbvenc.c:47
ZMBV_FMT_1BPP
@ ZMBV_FMT_1BPP
Definition: zmbvenc.c:52
AV_PIX_FMT_RGB555LE
@ AV_PIX_FMT_RGB555LE
packed RGB 5:5:5, 16bpp, (msb)1X 5R 5G 5B(lsb), little-endian, X=unused/undefined
Definition: pixfmt.h:108
ZMBV_DELTAPAL
#define ZMBV_DELTAPAL
Definition: zmbvenc.c:41
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:269
encode_frame
static int encode_frame(AVCodecContext *avctx, AVPacket *pkt, const AVFrame *pict, int *got_packet)
Definition: zmbvenc.c:168
src2
const pixel * src2
Definition: h264pred_template.c:422
common.h
FFMIN
#define FFMIN(a, b)
Definition: macros.h:49
av_mallocz
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
Definition: mem.c:264
AVCodec::name
const char * name
Name of the codec implementation.
Definition: codec.h:211
ZMBV_FMT_4BPP
@ ZMBV_FMT_4BPP
Definition: zmbvenc.c:54
ZMBV_FMT_2BPP
@ ZMBV_FMT_2BPP
Definition: zmbvenc.c:53
AVCodecContext::height
int height
Definition: avcodec.h:571
AVCodecContext::pix_fmt
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:608
ZmbvEncContext::lrange
int lrange
Definition: zmbvenc.c:68
log2
#define log2(x)
Definition: libm.h:404
avcodec.h
stride
#define stride
Definition: h264pred_template.c:537
AV_PIX_FMT_PAL8
@ AV_PIX_FMT_PAL8
8 bits with AV_PIX_FMT_RGB32 palette
Definition: pixfmt.h:77
ret
ret
Definition: filter_design.txt:187
ZMBV_FMT_16BPP
@ ZMBV_FMT_16BPP
Definition: zmbvenc.c:57
AVCodecContext
main external API structure.
Definition: avcodec.h:398
ff_get_encode_buffer
int ff_get_encode_buffer(AVCodecContext *avctx, AVPacket *avpkt, int64_t size, int flags)
Get a buffer for a packet.
Definition: encode.c:79
AV_PIX_FMT_NONE
@ AV_PIX_FMT_NONE
Definition: pixfmt.h:65
ZmbvEncContext::urange
int urange
Definition: zmbvenc.c:68
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
FFZStream
Definition: zlib_wrapper.h:27
FFALIGN
#define FFALIGN(x, a)
Definition: macros.h:78
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:425
AVPacket
This structure stores compressed data.
Definition: packet.h:351
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:34
src
INIT_CLIP pixel * src
Definition: h264pred_template.c:418
AVCodecContext::width
int width
picture width / height.
Definition: avcodec.h:571
AVFrame::linesize
int linesize[AV_NUM_DATA_POINTERS]
For video, a positive or negative value, which is typically indicating the size in bytes of each pict...
Definition: frame.h:370
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
ZmbvEncContext::bypp
int bypp
Definition: zmbvenc.c:76
ZmbvEncContext::curfrm
int curfrm
Definition: zmbvenc.c:75
ZmbvEncContext::score_tab
int score_tab[ZMBV_BLOCK *ZMBV_BLOCK *4+1]
Definition: zmbvenc.c:80
ff_deflate_init
int ff_deflate_init(FFZStream *zstream, int level, void *logctx)
Wrapper around deflateInit().
AVCodecContext::compression_level
int compression_level
Definition: avcodec.h:470
ZMBV_FMT_32BPP
@ ZMBV_FMT_32BPP
Definition: zmbvenc.c:59