FFmpeg
motionpixels.c
Go to the documentation of this file.
1 /*
2  * Motion Pixels Video Decoder
3  * Copyright (c) 2008 Gregory Montoir (cyx@users.sourceforge.net)
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 #include "avcodec.h"
23 #include "get_bits.h"
24 #include "bswapdsp.h"
25 #include "internal.h"
26 
27 #define MAX_HUFF_CODES 16
28 
29 #include "motionpixels_tablegen.h"
30 
31 typedef struct HuffCode {
32  int code;
33  uint8_t size;
34  uint8_t delta;
35 } HuffCode;
36 
37 typedef struct MotionPixelsContext {
38  AVCodecContext *avctx;
39  AVFrame *frame;
40  BswapDSPContext bdsp;
41  uint8_t *changes_map;
42  int offset_bits_len;
43  int codes_count, current_codes_count;
44  int max_codes_bits;
45  HuffCode codes[MAX_HUFF_CODES];
46  VLC vlc;
47  YuvPixel *vpt, *hpt;
48  uint8_t gradient_scale[3];
49  uint8_t *bswapbuf;
50  int bswapbuf_size;
51 } MotionPixelsContext;
52 
53 static av_cold int mp_decode_end(AVCodecContext *avctx)
54 {
55  MotionPixelsContext *mp = avctx->priv_data;
56 
57  av_freep(&mp->changes_map);
58  av_freep(&mp->vpt);
59  av_freep(&mp->hpt);
60  av_freep(&mp->bswapbuf);
61  av_frame_free(&mp->frame);
62 
63  return 0;
64 }
65 
66 static av_cold int mp_decode_init(AVCodecContext *avctx)
67 {
68  MotionPixelsContext *mp = avctx->priv_data;
69  int w4 = (avctx->width + 3) & ~3;
70  int h4 = (avctx->height + 3) & ~3;
71 
72  if(avctx->extradata_size < 2){
73  av_log(avctx, AV_LOG_ERROR, "extradata too small\n");
74  return AVERROR_INVALIDDATA;
75  }
76 
77  motionpixels_tableinit();
78  mp->avctx = avctx;
79  ff_bswapdsp_init(&mp->bdsp);
80  mp->changes_map = av_mallocz_array(avctx->width, h4);
81  mp->offset_bits_len = av_log2(avctx->width * avctx->height) + 1;
82  mp->vpt = av_mallocz_array(avctx->height, sizeof(YuvPixel));
83  mp->hpt = av_mallocz_array(h4 / 4, w4 / 4 * sizeof(YuvPixel));
84  if (!mp->changes_map || !mp->vpt || !mp->hpt) {
85  av_freep(&mp->changes_map);
86  av_freep(&mp->vpt);
87  av_freep(&mp->hpt);
88  return AVERROR(ENOMEM);
89  }
90  avctx->pix_fmt = AV_PIX_FMT_RGB555;
91 
92  mp->frame = av_frame_alloc();
93  if (!mp->frame) {
94  mp_decode_end(avctx);
95  return AVERROR(ENOMEM);
96  }
97 
98  return 0;
99 }
100 
101 static void mp_read_changes_map(MotionPixelsContext *mp, GetBitContext *gb, int count, int bits_len, int read_color)
102 {
103  uint16_t *pixels;
104  int offset, w, h, color = 0, x, y, i;
105 
106  while (count--) {
107  offset = get_bits_long(gb, mp->offset_bits_len);
108  w = get_bits(gb, bits_len) + 1;
109  h = get_bits(gb, bits_len) + 1;
110  if (read_color)
111  color = get_bits(gb, 15);
112  x = offset % mp->avctx->width;
113  y = offset / mp->avctx->width;
114  if (y >= mp->avctx->height)
115  continue;
116  w = FFMIN(w, mp->avctx->width - x);
117  h = FFMIN(h, mp->avctx->height - y);
118  pixels = (uint16_t *)&mp->frame->data[0][y * mp->frame->linesize[0] + x * 2];
119  while (h--) {
120  mp->changes_map[offset] = w;
121  if (read_color)
122  for (i = 0; i < w; ++i)
123  pixels[i] = color;
124  offset += mp->avctx->width;
125  pixels += mp->frame->linesize[0] / 2;
126  }
127  }
128 }
129 
130 static int mp_get_code(MotionPixelsContext *mp, GetBitContext *gb, int size, int code)
131 {
132  while (get_bits1(gb)) {
133  ++size;
134  if (size > mp->max_codes_bits) {
135  av_log(mp->avctx, AV_LOG_ERROR, "invalid code size %d/%d\n", size, mp->max_codes_bits);
136  return AVERROR_INVALIDDATA;
137  }
138  code <<= 1;
139  if (mp_get_code(mp, gb, size, code + 1) < 0)
140  return AVERROR_INVALIDDATA;
141  }
142  if (mp->current_codes_count >= MAX_HUFF_CODES) {
143  av_log(mp->avctx, AV_LOG_ERROR, "too many codes\n");
144  return AVERROR_INVALIDDATA;
145  }
146 
147  mp->codes[mp->current_codes_count ].code = code;
148  mp->codes[mp->current_codes_count++].size = size;
149  return 0;
150 }
151 
152 static int mp_read_codes_table(MotionPixelsContext *mp, GetBitContext *gb)
153 {
154  if (mp->codes_count == 1) {
155  mp->codes[0].delta = get_bits(gb, 4);
156  } else {
157  int i;
158  int ret;
159 
160  mp->max_codes_bits = get_bits(gb, 4);
161  for (i = 0; i < mp->codes_count; ++i)
162  mp->codes[i].delta = get_bits(gb, 4);
163  mp->current_codes_count = 0;
164  if ((ret = mp_get_code(mp, gb, 0, 0)) < 0)
165  return ret;
166  if (mp->current_codes_count < mp->codes_count) {
167  av_log(mp->avctx, AV_LOG_ERROR, "too few codes\n");
168  return AVERROR_INVALIDDATA;
169  }
170  }
171  return 0;
172 }
173 
174 static av_always_inline int mp_gradient(MotionPixelsContext *mp, int component, int v)
175 {
176  int delta;
177 
178  delta = (v - 7) * mp->gradient_scale[component];
179  mp->gradient_scale[component] = (v == 0 || v == 14) ? 2 : 1;
180  return delta;
181 }
182 
183 static YuvPixel mp_get_yuv_from_rgb(MotionPixelsContext *mp, int x, int y)
184 {
185  int color;
186 
187  color = *(uint16_t *)&mp->frame->data[0][y * mp->frame->linesize[0] + x * 2];
188  return mp_rgb_yuv_table[color];
189 }
190 
191 static void mp_set_rgb_from_yuv(MotionPixelsContext *mp, int x, int y, const YuvPixel *p)
192 {
193  int color;
194 
195  color = mp_yuv_to_rgb(p->y, p->v, p->u, 1);
196  *(uint16_t *)&mp->frame->data[0][y * mp->frame->linesize[0] + x * 2] = color;
197 }
198 
199 static av_always_inline int mp_get_vlc(MotionPixelsContext *mp, GetBitContext *gb)
200 {
201  int i;
202 
203  i = (mp->codes_count == 1) ? 0 : get_vlc2(gb, mp->vlc.table, mp->max_codes_bits, 1);
204  if (i < 0)
205  return i;
206  return mp->codes[i].delta;
207 }
208 
209 static void mp_decode_line(MotionPixelsContext *mp, GetBitContext *gb, int y)
210 {
211  YuvPixel p;
212  const int y0 = y * mp->avctx->width;
213  int w, i, x = 0;
214 
215  p = mp->vpt[y];
216  if (mp->changes_map[y0 + x] == 0) {
217  memset(mp->gradient_scale, 1, sizeof(mp->gradient_scale));
218  ++x;
219  }
220  while (x < mp->avctx->width) {
221  w = mp->changes_map[y0 + x];
222  if (w != 0) {
223  if ((y & 3) == 0) {
224  if (mp->changes_map[y0 + x + mp->avctx->width] < w ||
225  mp->changes_map[y0 + x + mp->avctx->width * 2] < w ||
226  mp->changes_map[y0 + x + mp->avctx->width * 3] < w) {
227  for (i = (x + 3) & ~3; i < x + w; i += 4) {
228  mp->hpt[((y / 4) * mp->avctx->width + i) / 4] = mp_get_yuv_from_rgb(mp, i, y);
229  }
230  }
231  }
232  x += w;
233  memset(mp->gradient_scale, 1, sizeof(mp->gradient_scale));
234  p = mp_get_yuv_from_rgb(mp, x - 1, y);
235  } else {
236  p.y += mp_gradient(mp, 0, mp_get_vlc(mp, gb));
237  p.y = av_clip_uintp2(p.y, 5);
238  if ((x & 3) == 0) {
239  if ((y & 3) == 0) {
240  p.v += mp_gradient(mp, 1, mp_get_vlc(mp, gb));
241  p.v = av_clip_intp2(p.v, 5);
242  p.u += mp_gradient(mp, 2, mp_get_vlc(mp, gb));
243  p.u = av_clip_intp2(p.u, 5);
244  mp->hpt[((y / 4) * mp->avctx->width + x) / 4] = p;
245  } else {
246  p.v = mp->hpt[((y / 4) * mp->avctx->width + x) / 4].v;
247  p.u = mp->hpt[((y / 4) * mp->avctx->width + x) / 4].u;
248  }
249  }
250  mp_set_rgb_from_yuv(mp, x, y, &p);
251  ++x;
252  }
253  }
254 }
255 
256 static void mp_decode_frame_helper(MotionPixelsContext *mp, GetBitContext *gb)
257 {
258  YuvPixel p;
259  int y, y0;
260 
261  av_assert1(mp->changes_map[0]);
262 
263  for (y = 0; y < mp->avctx->height; ++y) {
264  if (mp->changes_map[y * mp->avctx->width] != 0) {
265  memset(mp->gradient_scale, 1, sizeof(mp->gradient_scale));
266  p = mp_get_yuv_from_rgb(mp, 0, y);
267  } else {
268  p.y += mp_gradient(mp, 0, mp_get_vlc(mp, gb));
269  p.y = av_clip_uintp2(p.y, 5);
270  if ((y & 3) == 0) {
271  p.v += mp_gradient(mp, 1, mp_get_vlc(mp, gb));
272  p.v = av_clip_intp2(p.v, 5);
273  p.u += mp_gradient(mp, 2, mp_get_vlc(mp, gb));
274  p.u = av_clip_intp2(p.u, 5);
275  }
276  mp->vpt[y] = p;
277  mp_set_rgb_from_yuv(mp, 0, y, &p);
278  }
279  }
280  for (y0 = 0; y0 < 2; ++y0)
281  for (y = y0; y < mp->avctx->height; y += 2)
282  mp_decode_line(mp, gb, y);
283 }
284 
285 static int mp_decode_frame(AVCodecContext *avctx,
286  void *data, int *got_frame,
287  AVPacket *avpkt)
288 {
289  const uint8_t *buf = avpkt->data;
290  int buf_size = avpkt->size;
291  MotionPixelsContext *mp = avctx->priv_data;
292  GetBitContext gb;
293  int i, count1, count2, sz, ret;
294 
295  if ((ret = ff_reget_buffer(avctx, mp->frame)) < 0)
296  return ret;
297 
298  /* le32 bitstream msb first */
299  av_fast_padded_malloc(&mp->bswapbuf, &mp->bswapbuf_size, buf_size);
300  if (!mp->bswapbuf)
301  return AVERROR(ENOMEM);
302  mp->bdsp.bswap_buf((uint32_t *) mp->bswapbuf, (const uint32_t *) buf,
303  buf_size / 4);
304  if (buf_size & 3)
305  memcpy(mp->bswapbuf + (buf_size & ~3), buf + (buf_size & ~3), buf_size & 3);
306  init_get_bits(&gb, mp->bswapbuf, buf_size * 8);
307 
308  memset(mp->changes_map, 0, avctx->width * avctx->height);
309  for (i = !(avctx->extradata[1] & 2); i < 2; ++i) {
310  count1 = get_bits(&gb, 12);
311  count2 = get_bits(&gb, 12);
312  mp_read_changes_map(mp, &gb, count1, 8, i);
313  mp_read_changes_map(mp, &gb, count2, 4, i);
314  }
315 
316  mp->codes_count = get_bits(&gb, 4);
317  if (mp->codes_count == 0)
318  goto end;
319 
320  if (mp->changes_map[0] == 0) {
321  *(uint16_t *)mp->frame->data[0] = get_bits(&gb, 15);
322  mp->changes_map[0] = 1;
323  }
324  if (mp_read_codes_table(mp, &gb) < 0)
325  goto end;
326 
327  sz = get_bits(&gb, 18);
328  if (avctx->extradata[0] != 5)
329  sz += get_bits(&gb, 18);
330  if (sz == 0)
331  goto end;
332 
333  if (mp->max_codes_bits <= 0)
334  goto end;
335  if (init_vlc(&mp->vlc, mp->max_codes_bits, mp->codes_count, &mp->codes[0].size, sizeof(HuffCode), 1, &mp->codes[0].code, sizeof(HuffCode), 4, 0))
336  goto end;
337  mp_decode_frame_helper(mp, &gb);
338  ff_free_vlc(&mp->vlc);
339 
340 end:
341  if ((ret = av_frame_ref(data, mp->frame)) < 0)
342  return ret;
343  *got_frame = 1;
344  return buf_size;
345 }
346 
347 AVCodec ff_motionpixels_decoder = {
348  .name = "motionpixels",
349  .long_name = NULL_IF_CONFIG_SMALL("Motion Pixels video"),
350  .type = AVMEDIA_TYPE_VIDEO,
351  .id = AV_CODEC_ID_MOTIONPIXELS,
352  .priv_data_size = sizeof(MotionPixelsContext),
353  .init = mp_decode_init,
354  .close = mp_decode_end,
355  .decode = mp_decode_frame,
356  .capabilities = AV_CODEC_CAP_DR1,
357 };
YuvPixel::y
int8_t y
Definition: motionpixels_tablegen.h:30
AVCodec
AVCodec.
Definition: avcodec.h:3481
bswapdsp.h
init
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:35
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
YuvPixel
Definition: motionpixels_tablegen.h:29
color
Definition: vf_paletteuse.c:588
get_bits_long
static unsigned int get_bits_long(GetBitContext *s, int n)
Read 0-32 bits.
Definition: get_bits.h:546
MotionPixelsContext::gradient_scale
uint8_t gradient_scale[3]
Definition: motionpixels.c:48
count
void INT64 INT64 count
Definition: avisynth_c.h:767
av_frame_free
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:202
end
static av_cold int end(AVCodecContext *avctx)
Definition: avrndec.c:90
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:295
w
uint8_t w
Definition: llviddspenc.c:38
pixels
int pixels
Definition: avisynth_c.h:390
internal.h
AVPacket::data
uint8_t * data
Definition: avcodec.h:1477
MotionPixelsContext::max_codes_bits
int max_codes_bits
Definition: motionpixels.c:44
init_vlc
#define init_vlc(vlc, nb_bits, nb_codes, bits, bits_wrap, bits_size, codes, codes_wrap, codes_size, flags)
Definition: vlc.h:38
data
const char data[16]
Definition: mxf.c:91
av_mallocz_array
void * av_mallocz_array(size_t nmemb, size_t size)
Definition: mem.c:191
get_vlc2
static av_always_inline int get_vlc2(GetBitContext *s, VLC_TYPE(*table)[2], int bits, int max_depth)
Parse a vlc code.
Definition: get_bits.h:797
ff_reget_buffer
int ff_reget_buffer(AVCodecContext *avctx, AVFrame *frame)
Identical in function to av_frame_make_writable(), except it uses ff_get_buffer() to allocate the buf...
Definition: decode.c:2012
mp_decode_frame
static int mp_decode_frame(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *avpkt)
Definition: motionpixels.c:285
init_get_bits
static int init_get_bits(GetBitContext *s, const uint8_t *buffer, int bit_size)
Initialize GetBitContext.
Definition: get_bits.h:659
AVFrame::data
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:309
HuffCode::delta
uint8_t delta
Definition: motionpixels.c:34
get_bits
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:379
MotionPixelsContext::offset_bits_len
int offset_bits_len
Definition: motionpixels.c:42
GetBitContext
Definition: get_bits.h:61
mp_decode_init
static av_cold int mp_decode_init(AVCodecContext *avctx)
Definition: motionpixels.c:66
mp_read_changes_map
static void mp_read_changes_map(MotionPixelsContext *mp, GetBitContext *gb, int count, int bits_len, int read_color)
Definition: motionpixels.c:101
av_frame_alloc
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
Definition: frame.c:189
mp_yuv_to_rgb
static int mp_yuv_to_rgb(int y, int v, int u, int clip_rgb)
Definition: motionpixels_tablegen.h:33
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
buf
void * buf
Definition: avisynth_c.h:766
av_cold
#define av_cold
Definition: attributes.h:84
MotionPixelsContext::frame
AVFrame * frame
Definition: motionpixels.c:39
mp_get_yuv_from_rgb
static YuvPixel mp_get_yuv_from_rgb(MotionPixelsContext *mp, int x, int y)
Definition: motionpixels.c:183
HuffCode::size
uint8_t size
Definition: motionpixels.c:33
decode
static void decode(AVCodecContext *dec_ctx, AVPacket *pkt, AVFrame *frame, FILE *outfile)
Definition: decode_audio.c:42
AVCodecContext::extradata_size
int extradata_size
Definition: avcodec.h:1667
BswapDSPContext::bswap_buf
void(* bswap_buf)(uint32_t *dst, const uint32_t *src, int w)
Definition: bswapdsp.h:25
MotionPixelsContext::bswapbuf
uint8_t * bswapbuf
Definition: motionpixels.c:49
get_bits.h
MotionPixelsContext::bdsp
BswapDSPContext bdsp
Definition: motionpixels.c:40
ff_free_vlc
void ff_free_vlc(VLC *vlc)
Definition: bitstream.c:359
motionpixels_tableinit
static av_cold void motionpixels_tableinit(void)
Definition: motionpixels_tablegen.h:85
ff_bswapdsp_init
av_cold void ff_bswapdsp_init(BswapDSPContext *c)
Definition: bswapdsp.c:49
mp_decode_frame_helper
static void mp_decode_frame_helper(MotionPixelsContext *mp, GetBitContext *gb)
Definition: motionpixels.c:256
AV_CODEC_ID_MOTIONPIXELS
@ AV_CODEC_ID_MOTIONPIXELS
Definition: avcodec.h:337
mp_gradient
static av_always_inline int mp_gradient(MotionPixelsContext *mp, int component, int v)
Definition: motionpixels.c:174
get_bits1
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:498
MotionPixelsContext
Definition: motionpixels.c:37
AV_CODEC_CAP_DR1
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() for allocating buffers and supports custom allocators.
Definition: avcodec.h:981
AVPacket::size
int size
Definition: avcodec.h:1478
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:188
av_frame_ref
int av_frame_ref(AVFrame *dst, const AVFrame *src)
Set up a new reference to the data described by the source frame.
Definition: frame.c:443
size
int size
Definition: twinvq_data.h:11134
color
static const uint32_t color[16+AV_CLASS_CATEGORY_NB]
Definition: log.c:92
MotionPixelsContext::avctx
AVCodecContext * avctx
Definition: motionpixels.c:38
MotionPixelsContext::current_codes_count
int current_codes_count
Definition: motionpixels.c:43
motionpixels_tablegen.h
MotionPixelsContext::vlc
VLC vlc
Definition: motionpixels.c:46
MotionPixelsContext::changes_map
uint8_t * changes_map
Definition: motionpixels.c:41
mp_get_code
static int mp_get_code(MotionPixelsContext *mp, GetBitContext *gb, int size, int code)
Definition: motionpixels.c:130
mp_get_vlc
static av_always_inline int mp_get_vlc(MotionPixelsContext *mp, GetBitContext *gb)
Definition: motionpixels.c:199
FFMIN
#define FFMIN(a, b)
Definition: common.h:96
MAX_HUFF_CODES
#define MAX_HUFF_CODES
Definition: motionpixels.c:27
offset
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf offset
Definition: writing_filters.txt:86
HuffCode::code
int code
Definition: motionpixels.c:32
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:259
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
AVCodecContext::extradata
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
Definition: avcodec.h:1666
mp_rgb_yuv_table
static YuvPixel mp_rgb_yuv_table[1<< 15]
Definition: motionpixels_tablegen.h:51
av_assert1
#define av_assert1(cond)
assert() equivalent, that does not lie in speed critical code.
Definition: avassert.h:53
delta
float delta
Definition: vorbis_enc_data.h:457
av_fast_padded_malloc
void av_fast_padded_malloc(void *ptr, unsigned int *size, size_t min_size)
Same behaviour av_fast_malloc but the buffer has additional AV_INPUT_BUFFER_PADDING_SIZE at the end w...
Definition: utils.c:70
AV_PIX_FMT_RGB555
#define AV_PIX_FMT_RGB555
Definition: pixfmt.h:375
av_always_inline
#define av_always_inline
Definition: attributes.h:43
mp_set_rgb_from_yuv
static void mp_set_rgb_from_yuv(MotionPixelsContext *mp, int x, int y, const YuvPixel *p)
Definition: motionpixels.c:191
MotionPixelsContext::codes
HuffCode codes[MAX_HUFF_CODES]
Definition: motionpixels.c:45
uint8_t
uint8_t
Definition: audio_convert.c:194
mp_read_codes_table
static int mp_read_codes_table(MotionPixelsContext *mp, GetBitContext *gb)
Definition: motionpixels.c:152
AVCodec::name
const char * name
Name of the codec implementation.
Definition: avcodec.h:3488
AVCodecContext::height
int height
Definition: avcodec.h:1738
AVCodecContext::pix_fmt
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:1775
avcodec.h
ret
ret
Definition: filter_design.txt:187
AVCodecContext
main external API structure.
Definition: avcodec.h:1565
MotionPixelsContext::hpt
YuvPixel * hpt
Definition: motionpixels.c:47
VLC
Definition: vlc.h:26
mp_decode_line
static void mp_decode_line(MotionPixelsContext *mp, GetBitContext *gb, int y)
Definition: motionpixels.c:209
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
YuvPixel::v
int8_t v
Definition: motionpixels_tablegen.h:30
MotionPixelsContext::bswapbuf_size
int bswapbuf_size
Definition: motionpixels.c:50
AVPacket
This structure stores compressed data.
Definition: avcodec.h:1454
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:1592
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:35
AVCodecContext::width
int width
picture width / height.
Definition: avcodec.h:1738
HuffCode
Definition: motionpixels.c:31
AVFrame::linesize
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
Definition: frame.h:326
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:28
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
BswapDSPContext
Definition: bswapdsp.h:24
h
h
Definition: vp9dsp_template.c:2038
YuvPixel::u
int8_t u
Definition: motionpixels_tablegen.h:30
MotionPixelsContext::codes_count
int codes_count
Definition: motionpixels.c:43
VLC::table
VLC_TYPE(* table)[2]
code, bits
Definition: vlc.h:28
av_log2
int av_log2(unsigned v)
Definition: intmath.c:26
ff_motionpixels_decoder
AVCodec ff_motionpixels_decoder
Definition: motionpixels.c:347
MotionPixelsContext::vpt
YuvPixel * vpt
Definition: motionpixels.c:47
mp_decode_end
static av_cold int mp_decode_end(AVCodecContext *avctx)
Definition: motionpixels.c:53
Generated on Wed Aug 24 2022 21:26:51 for FFmpeg by   doxygen 1.8.17