FFmpeg: libavcodec/motionpixels.c Source File

FFmpeg

[フレーム]

libavcodec

motionpixels.c

Go to the documentation of this file.

1 /*

2 * Motion Pixels Video Decoder

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 */

22 #include "libavutil/mem.h"

23 #include "libavutil/thread.h"

25 #include "config.h"

27 #include "avcodec.h"

28 #include "get_bits.h"

29 #include "bswapdsp.h"

30 #include "codec_internal.h"

31 #include "decode.h"

33 #define MAX_HUFF_CODES 16

35 #include "motionpixels_tablegen.h"

37 typedef struct HuffCode {

38 uint8_t size;

39 uint8_t delta;

40 } HuffCode;

42 typedef struct MotionPixelsContext {

43 AVCodecContext *avctx;

44 AVFrame *frame;

45 BswapDSPContext bdsp;

46 uint8_t *changes_map;

47 int offset_bits_len;

48 int codes_count, current_codes_count;

49 int max_codes_bits;

50 HuffCode codes[MAX_HUFF_CODES];

51 VLC vlc;

52 YuvPixel *vpt, *hpt;

53 uint8_t gradient_scale[3];

54 uint8_t *bswapbuf;

55 int bswapbuf_size;

56 } MotionPixelsContext;

58 static av_cold int mp_decode_end(AVCodecContext *avctx)

59 {

60 MotionPixelsContext *mp = avctx->priv_data;

62 av_freep(&mp->changes_map);

63 av_freep(&mp->vpt);

64 av_freep(&mp->hpt);

65 av_freep(&mp->bswapbuf);

66 av_frame_free(&mp->frame);

68 return 0;

69 }

71 static av_cold int mp_decode_init(AVCodecContext *avctx)

72 {

73 MotionPixelsContext *mp = avctx->priv_data;

74 int w4 = (avctx->width + 3) & ~3;

75 int h4 = (avctx->height + 3) & ~3;

77 if(avctx->extradata_size < 2){

78 av_log(avctx, AV_LOG_ERROR, "extradata too small\n");

79 return AVERROR_INVALIDDATA;

80 }

82 mp->avctx = avctx;

83 ff_bswapdsp_init(&mp->bdsp);

84 mp->changes_map = av_calloc(avctx->width, h4);

85 mp->offset_bits_len = av_log2(avctx->width * avctx->height) + 1;

86 mp->vpt = av_calloc(avctx->height, sizeof(*mp->vpt));

87 mp->hpt = av_calloc(h4 / 4, w4 / 4 * sizeof(*mp->hpt));

88 if (!mp->changes_map || !mp->vpt || !mp->hpt)

89 return AVERROR(ENOMEM);

90 avctx->pix_fmt = AV_PIX_FMT_RGB555;

92 mp->frame = av_frame_alloc();

93 if (!mp->frame)

94 return AVERROR(ENOMEM);

96 #if !CONFIG_HARDCODED_TABLES

97 static AVOnce init_static_once = AV_ONCE_INIT;

98 ff_thread_once(&init_static_once, motionpixels_tableinit);

99 #endif

100

101 return 0;

102 }

103

104 static void mp_read_changes_map(MotionPixelsContext *mp, GetBitContext *gb, int count, int bits_len, int read_color)

105 {

106 uint16_t *pixels;

107 int offset, w, h, color = 0, x, y, i;

108

109 while (count--) {

110 offset = get_bits_long(gb, mp->offset_bits_len);

111 w = get_bits(gb, bits_len) + 1;

112 h = get_bits(gb, bits_len) + 1;

113 if (read_color)

114 color = get_bits(gb, 15);

115 x = offset % mp->avctx->width;

116 y = offset / mp->avctx->width;

117 if (y >= mp->avctx->height)

118 continue;

119 w = FFMIN(w, mp->avctx->width - x);

120 h = FFMIN(h, mp->avctx->height - y);

121 pixels = (uint16_t *)&mp->frame->data[0][y * mp->frame->linesize[0] + x * 2];

122 while (h--) {

123 mp->changes_map[offset] = w;

124 if (read_color)

125 for (i = 0; i < w; ++i)

126 pixels[i] = color;

127 offset += mp->avctx->width;

128 pixels += mp->frame->linesize[0] / 2;

129 }

130 }

131 }

132

133 static int mp_get_code(MotionPixelsContext *mp, GetBitContext *gb, int size)

134 {

135 while (get_bits1(gb)) {

136 ++size;

137 if (size > mp->max_codes_bits) {

138 av_log(mp->avctx, AV_LOG_ERROR, "invalid code size %d/%d\n", size, mp->max_codes_bits);

139 return AVERROR_INVALIDDATA;

140 }

141 if (mp_get_code(mp, gb, size) < 0)

142 return AVERROR_INVALIDDATA;

143 }

144 if (mp->current_codes_count >= mp->codes_count) {

145 av_log(mp->avctx, AV_LOG_ERROR, "too many codes\n");

146 return AVERROR_INVALIDDATA;

147 }

148

149 mp->codes[mp->current_codes_count++].size = size;

150 return 0;

151 }

152

153 static int mp_read_codes_table(MotionPixelsContext *mp, GetBitContext *gb)

154 {

155 if (mp->codes_count == 1) {

156 mp->codes[0].delta = get_bits(gb, 4);

157 } else {

158 int i;

159 int ret;

160

161 mp->max_codes_bits = get_bits(gb, 4);

162 for (i = 0; i < mp->codes_count; ++i)

163 mp->codes[i].delta = get_bits(gb, 4);

164 mp->current_codes_count = 0;

165 if ((ret = mp_get_code(mp, gb, 0)) < 0)

166 return ret;

167 if (mp->current_codes_count < mp->codes_count) {

168 av_log(mp->avctx, AV_LOG_ERROR, "too few codes\n");

169 return AVERROR_INVALIDDATA;

170 }

171 }

172 return 0;

173 }

174

175 static av_always_inline int mp_gradient(MotionPixelsContext *mp, int component, int v)

176 {

177 int delta;

178

179 delta = (v - 7) * mp->gradient_scale[component];

180 mp->gradient_scale[component] = (v == 0 || v == 14) ? 2 : 1;

181 return delta;

182 }

183

184 static YuvPixel mp_get_yuv_from_rgb(MotionPixelsContext *mp, int x, int y)

185 {

186 int color;

187

188 color = *(uint16_t *)&mp->frame->data[0][y * mp->frame->linesize[0] + x * 2];

189 return mp_rgb_yuv_table[color & 0x7FFF];

190 }

191

192 static void mp_set_rgb_from_yuv(MotionPixelsContext *mp, int x, int y, const YuvPixel *p)

193 {

194 int color;

195

196 color = mp_yuv_to_rgb(p->y, p->v, p->u, 1);

197 *(uint16_t *)&mp->frame->data[0][y * mp->frame->linesize[0] + x * 2] = color;

198 }

199

200 static av_always_inline int mp_get_vlc(MotionPixelsContext *mp, GetBitContext *gb)

201 {

202 return mp->vlc.table ? get_vlc2(gb, mp->vlc.table, mp->max_codes_bits, 1)

203 : mp->codes[0].delta;

204 }

205

206 static void mp_decode_line(MotionPixelsContext *mp, GetBitContext *gb, int y)

207 {

208 YuvPixel p;

209 const int y0 = y * mp->avctx->width;

210 int w, i, x = 0;

211

212 p = mp->vpt[y];

213 if (mp->changes_map[y0 + x] == 0) {

214 memset(mp->gradient_scale, 1, sizeof(mp->gradient_scale));

215 ++x;

216 }

217 while (x < mp->avctx->width) {

218 w = mp->changes_map[y0 + x];

219 if (w != 0) {

220 if ((y & 3) == 0) {

221 if (mp->changes_map[y0 + x + mp->avctx->width] < w ||

222 mp->changes_map[y0 + x + mp->avctx->width * 2] < w ||

223 mp->changes_map[y0 + x + mp->avctx->width * 3] < w) {

224 for (i = (x + 3) & ~3; i < x + w; i += 4) {

225 mp->hpt[((y / 4) * mp->avctx->width + i) / 4] = mp_get_yuv_from_rgb(mp, i, y);

226 }

227 }

228 }

229 x += w;

230 memset(mp->gradient_scale, 1, sizeof(mp->gradient_scale));

231 p = mp_get_yuv_from_rgb(mp, x - 1, y);

232 } else {

233 p.y += mp_gradient(mp, 0, mp_get_vlc(mp, gb));

234 p.y = av_clip_uintp2(p.y, 5);

235 if ((x & 3) == 0) {

236 if ((y & 3) == 0) {

237 p.v += mp_gradient(mp, 1, mp_get_vlc(mp, gb));

238 p.v = av_clip_intp2(p.v, 5);

239 p.u += mp_gradient(mp, 2, mp_get_vlc(mp, gb));

240 p.u = av_clip_intp2(p.u, 5);

241 mp->hpt[((y / 4) * mp->avctx->width + x) / 4] = p;

242 } else {

243 p.v = mp->hpt[((y / 4) * mp->avctx->width + x) / 4].v;

244 p.u = mp->hpt[((y / 4) * mp->avctx->width + x) / 4].u;

245 }

246 }

247 mp_set_rgb_from_yuv(mp, x, y, &p);

248 ++x;

249 }

250 }

251 }

252

253 static void mp_decode_frame_helper(MotionPixelsContext *mp, GetBitContext *gb)

254 {

255 YuvPixel p;

256 int y, y0;

257

258 av_assert1(mp->changes_map[0]);

259

260 for (y = 0; y < mp->avctx->height; ++y) {

261 if (mp->changes_map[y * mp->avctx->width] != 0) {

262 memset(mp->gradient_scale, 1, sizeof(mp->gradient_scale));

263 p = mp_get_yuv_from_rgb(mp, 0, y);

264 } else {

265 p.y += mp_gradient(mp, 0, mp_get_vlc(mp, gb));

266 p.y = av_clip_uintp2(p.y, 5);

267 if ((y & 3) == 0) {

268 p.v += mp_gradient(mp, 1, mp_get_vlc(mp, gb));

269 p.v = av_clip_intp2(p.v, 5);

270 p.u += mp_gradient(mp, 2, mp_get_vlc(mp, gb));

271 p.u = av_clip_intp2(p.u, 5);

272 }

273 mp->vpt[y] = p;

274 mp_set_rgb_from_yuv(mp, 0, y, &p);

275 }

276 }

277 for (y0 = 0; y0 < 2; ++y0)

278 for (y = y0; y < mp->avctx->height; y += 2)

279 mp_decode_line(mp, gb, y);

280 }

281

282 static int mp_decode_frame(AVCodecContext *avctx, AVFrame *rframe,

283 int *got_frame, AVPacket *avpkt)

284 {

285 const uint8_t *buf = avpkt->data;

286 int buf_size = avpkt->size;

287 MotionPixelsContext *mp = avctx->priv_data;

288 GetBitContext gb;

289 int i, count1, count2, sz, ret;

290

291 if ((ret = ff_reget_buffer(avctx, mp->frame, 0)) < 0)

292 return ret;

293

294 /* le32 bitstream msb first */

295 av_fast_padded_malloc(&mp->bswapbuf, &mp->bswapbuf_size, buf_size);

296 if (!mp->bswapbuf)

297 return AVERROR(ENOMEM);

298 mp->bdsp.bswap_buf((uint32_t *) mp->bswapbuf, (const uint32_t *) buf,

299 buf_size / 4);

300 if (buf_size & 3)

301 memcpy(mp->bswapbuf + (buf_size & ~3), buf + (buf_size & ~3), buf_size & 3);

302 init_get_bits(&gb, mp->bswapbuf, buf_size * 8);

303

304 memset(mp->changes_map, 0, avctx->width * avctx->height);

305 for (i = !(avctx->extradata[1] & 2); i < 2; ++i) {

306 count1 = get_bits(&gb, 12);

307 count2 = get_bits(&gb, 12);

308 mp_read_changes_map(mp, &gb, count1, 8, i);

309 mp_read_changes_map(mp, &gb, count2, 4, i);

310 }

311

312 mp->codes_count = get_bits(&gb, 4);

313 if (mp->codes_count == 0)

314 goto end;

315

316 if (mp->changes_map[0] == 0) {

317 *(uint16_t *)mp->frame->data[0] = get_bits(&gb, 15);

318 mp->changes_map[0] = 1;

319 }

320 if (mp_read_codes_table(mp, &gb) < 0)

321 goto end;

322

323 sz = get_bits(&gb, 18);

324 if (avctx->extradata[0] != 5)

325 sz += get_bits(&gb, 18);

326 if (sz == 0)

327 goto end;

328

329 if (mp->codes_count > 1) {

330 /* The entries of the mp->codes array are sorted from right to left

331 * in the Huffman tree, hence -(int)sizeof(HuffCode). */

332 ret = ff_vlc_init_from_lengths(&mp->vlc, mp->max_codes_bits, mp->codes_count,

333 &mp->codes[mp->codes_count - 1].size, -(int)sizeof(HuffCode),

334 &mp->codes[mp->codes_count - 1].delta, -(int)sizeof(HuffCode), 1,

335 0, 0, avctx);

336 if (ret < 0)

337 goto end;

338 }

339 mp_decode_frame_helper(mp, &gb);

340 ff_vlc_free(&mp->vlc);

341

342 end:

343 if ((ret = av_frame_ref(rframe, mp->frame)) < 0)

344 return ret;

345 *got_frame = 1;

346 return buf_size;

347 }

348

349 const FFCodec ff_motionpixels_decoder = {

350 .p.name = "motionpixels",

351 CODEC_LONG_NAME("Motion Pixels video"),

352 .p.type = AVMEDIA_TYPE_VIDEO,

353 .p.id = AV_CODEC_ID_MOTIONPIXELS,

354 .priv_data_size = sizeof(MotionPixelsContext),

355 .init = mp_decode_init,

356 .close = mp_decode_end,

357 FF_CODEC_DECODE_CB(mp_decode_frame),

358 .p.capabilities = AV_CODEC_CAP_DR1,

359 .caps_internal = FF_CODEC_CAP_INIT_CLEANUP,

360 };

bswapdsp.h

ff_vlc_init_from_lengths

int ff_vlc_init_from_lengths(VLC *vlc, int nb_bits, int nb_codes, const int8_t *lens, int lens_wrap, const void *symbols, int symbols_wrap, int symbols_size, int offset, int flags, void *logctx)

Build VLC decoding tables suitable for use with get_vlc2()

Definition: vlc.c:306

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

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:513

thread.h

av_clip_uintp2

#define av_clip_uintp2

Definition: common.h:124

get_bits_long

static unsigned int get_bits_long(GetBitContext *s, int n)

Read 0-32 bits.

Definition: get_bits.h:419

MotionPixelsContext::gradient_scale

uint8_t gradient_scale[3]

Definition: motionpixels.c:53

av_frame_free

void av_frame_free(AVFrame **frame)

Free the frame and any dynamically allocated objects in it, e.g.

Definition: frame.c:64

static double mp(int i, double w0, double r)

Definition: af_atilt.c:60

AVFrame

This structure describes decoded (raw) audio or video data.

Definition: frame.h:427

uint8_t w

Definition: llviddspenc.c:38

AVPacket::data

uint8_t * data

Definition: packet.h:558

MotionPixelsContext::max_codes_bits

int max_codes_bits

Definition: motionpixels.c:49

FFCodec

Definition: codec_internal.h:127

init_get_bits

static int init_get_bits(GetBitContext *s, const uint8_t *buffer, int bit_size)

Initialize GetBitContext.

Definition: get_bits.h:512

HuffCode::delta

uint8_t delta

Definition: motionpixels.c:39

static av_cold void close(AVCodecParserContext *s)

Definition: apv_parser.c:135

get_bits

static unsigned int get_bits(GetBitContext *s, int n)

Read 1-25 bits.

Definition: get_bits.h:333

MotionPixelsContext::offset_bits_len

int offset_bits_len

Definition: motionpixels.c:47

FFCodec::p

AVCodec p

The public AVCodec.

Definition: codec_internal.h:131

GetBitContext

Definition: get_bits.h:109

mp_decode_init

static av_cold int mp_decode_init(AVCodecContext *avctx)

Definition: motionpixels.c:71

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:104

av_frame_alloc

AVFrame * av_frame_alloc(void)

Allocate an AVFrame and set its fields to default values.

Definition: frame.c:52

mp_yuv_to_rgb

static int mp_yuv_to_rgb(int y, int v, int u, int clip_rgb)

Definition: motionpixels_tablegen.h:33

ff_thread_once

static int ff_thread_once(char *control, void(*routine)(void))

Definition: thread.h:205

AV_LOG_ERROR

#define AV_LOG_ERROR

Something went wrong and cannot losslessly be recovered.

Definition: log.h:210

av_cold

#define av_cold

Definition: attributes.h:106

MotionPixelsContext::frame

AVFrame * frame

Definition: motionpixels.c:44

mp_get_yuv_from_rgb

static YuvPixel mp_get_yuv_from_rgb(MotionPixelsContext *mp, int x, int y)

Definition: motionpixels.c:184

HuffCode::size

uint8_t size

Definition: motionpixels.c:38

AVCodecContext::extradata_size

int extradata_size

Definition: avcodec.h:515

FF_CODEC_DECODE_CB

#define FF_CODEC_DECODE_CB(func)

Definition: codec_internal.h:346

MotionPixelsContext::bswapbuf

uint8_t * bswapbuf

Definition: motionpixels.c:54

decode.h

get_bits.h

MotionPixelsContext::bdsp

BswapDSPContext bdsp

Definition: motionpixels.c:45

CODEC_LONG_NAME

#define CODEC_LONG_NAME(str)

Definition: codec_internal.h:331

motionpixels_tableinit

static av_cold void motionpixels_tableinit(void)

Definition: motionpixels_tablegen.h:85

AV_ONCE_INIT

#define AV_ONCE_INIT

Definition: thread.h:203

ff_bswapdsp_init

av_cold void ff_bswapdsp_init(BswapDSPContext *c)

Definition: bswapdsp.c:49

av_clip_intp2

#define av_clip_intp2

Definition: common.h:121

mp_decode_frame_helper

static void mp_decode_frame_helper(MotionPixelsContext *mp, GetBitContext *gb)

Definition: motionpixels.c:253

AV_CODEC_ID_MOTIONPIXELS

@ AV_CODEC_ID_MOTIONPIXELS

Definition: codec_id.h:171

mp_gradient

static av_always_inline int mp_gradient(MotionPixelsContext *mp, int component, int v)

Definition: motionpixels.c:175

get_bits1

static unsigned int get_bits1(GetBitContext *s)

Definition: get_bits.h:386

mp_decode_frame

static int mp_decode_frame(AVCodecContext *avctx, AVFrame *rframe, int *got_frame, AVPacket *avpkt)

Definition: motionpixels.c:282

get_vlc2

static av_always_inline int get_vlc2(GetBitContext *s, const VLCElem *table, int bits, int max_depth)

Parse a vlc code.

Definition: get_bits.h:646

AVOnce

#define AVOnce

Definition: thread.h:202

MotionPixelsContext

Definition: motionpixels.c:42

init

int(* init)(AVBSFContext *ctx)

Definition: dts2pts.c:368

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

AVPacket::size

int size

Definition: packet.h:559

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:278

codec_internal.h

size

int size

Definition: twinvq_data.h:10344

color

static const uint32_t color[16+AV_CLASS_CATEGORY_NB]

Definition: log.c:97

MotionPixelsContext::avctx

AVCodecContext * avctx

Definition: motionpixels.c:43

MotionPixelsContext::current_codes_count

int current_codes_count

Definition: motionpixels.c:48

motionpixels_tablegen.h

MotionPixelsContext::vlc

VLC vlc

Definition: motionpixels.c:51

MotionPixelsContext::changes_map

uint8_t * changes_map

Definition: motionpixels.c:46

mp_get_vlc

static av_always_inline int mp_get_vlc(MotionPixelsContext *mp, GetBitContext *gb)

Definition: motionpixels.c:200

MAX_HUFF_CODES

#define MAX_HUFF_CODES

Definition: motionpixels.c:33

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

#define i(width, name, range_min, range_max)

Definition: cbs_h2645.c:256

AVCodecContext::extradata

uint8_t * extradata

Out-of-band global headers that may be used by some codecs.

Definition: avcodec.h:514

mp_rgb_yuv_table

static YuvPixel mp_rgb_yuv_table[1<< 15]

Definition: motionpixels_tablegen.h:51

mp_get_code

static int mp_get_code(MotionPixelsContext *mp, GetBitContext *gb, int size)

Definition: motionpixels.c:133

av_assert1

#define av_assert1(cond)

assert() equivalent, that does not lie in speed critical code.

Definition: avassert.h:57

delta

float delta

Definition: vorbis_enc_data.h:430

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:53

AV_PIX_FMT_RGB555

#define AV_PIX_FMT_RGB555

Definition: pixfmt.h:527

av_always_inline

#define av_always_inline

Definition: attributes.h:63

mp_set_rgb_from_yuv

static void mp_set_rgb_from_yuv(MotionPixelsContext *mp, int x, int y, const YuvPixel *p)

Definition: motionpixels.c:192

FFMIN

#define FFMIN(a, b)

Definition: macros.h:49

MotionPixelsContext::codes

HuffCode codes[MAX_HUFF_CODES]

Definition: motionpixels.c:50

mp_read_codes_table

static int mp_read_codes_table(MotionPixelsContext *mp, GetBitContext *gb)

Definition: motionpixels.c:153

AVCodec::name

const char * name

Name of the codec implementation.

Definition: codec.h:179

AVCodecContext::height

int height

Definition: avcodec.h:592

AVCodecContext::pix_fmt

enum AVPixelFormat pix_fmt

Pixel format, see AV_PIX_FMT_xxx.

Definition: avcodec.h:631

av_calloc

void * av_calloc(size_t nmemb, size_t size)

Definition: mem.c:264

avcodec.h

ff_vlc_free

void ff_vlc_free(VLC *vlc)

Definition: vlc.c:580

ff_reget_buffer

int ff_reget_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)

Identical in function to ff_get_buffer(), except it reuses the existing buffer if available.

Definition: decode.c:1840

ret

Definition: filter_design.txt:187

AVCodecContext

main external API structure.

Definition: avcodec.h:431

MotionPixelsContext::hpt

YuvPixel * hpt

Definition: motionpixels.c:52

VLC

Definition: vlc.h:50

mp_decode_line

static void mp_decode_line(MotionPixelsContext *mp, GetBitContext *gb, int y)

Definition: motionpixels.c:206

Windows::Graphics::DirectX::Direct3D11::p

IDirect3DDxgiInterfaceAccess _COM_Outptr_ void ** p

Definition: vsrc_gfxcapture_winrt.hpp:53

AVMEDIA_TYPE_VIDEO

@ AVMEDIA_TYPE_VIDEO

Definition: avutil.h:200

mem.h

MotionPixelsContext::bswapbuf_size

int bswapbuf_size

Definition: motionpixels.c:55

AVPacket

This structure stores compressed data.

Definition: packet.h:535

AVCodecContext::priv_data

void * priv_data

Definition: avcodec.h:458

av_freep

#define av_freep(p)

Definition: tableprint_vlc.h:35

AVCodecContext::width

int width

picture width / height.

Definition: avcodec.h:592

HuffCode

Definition: motionpixels.c:37

av_log

#define av_log(a,...)

Definition: tableprint_vlc.h:27

AVERROR_INVALIDDATA

#define AVERROR_INVALIDDATA

Invalid data found when processing input.

Definition: error.h:61

BswapDSPContext

Definition: bswapdsp.h:24

Definition: vp9dsp_template.c:2070

MotionPixelsContext::codes_count

int codes_count

Definition: motionpixels.c:48

av_log2

int av_log2(unsigned v)

Definition: intmath.c:26

MotionPixelsContext::vpt

YuvPixel * vpt

Definition: motionpixels.c:52

ff_motionpixels_decoder

const FFCodec ff_motionpixels_decoder

Definition: motionpixels.c:349

mp_decode_end

static av_cold int mp_decode_end(AVCodecContext *avctx)

Definition: motionpixels.c:58

Generated on Fri Oct 17 2025 19:22:19 for FFmpeg by doxygen 1.8.17