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/thread.h"

24 #include "config.h"

26 #include "avcodec.h"

27 #include "get_bits.h"

28 #include "bswapdsp.h"

29 #include "internal.h"

31 #define MAX_HUFF_CODES 16

33 #include "motionpixels_tablegen.h"

35 typedef struct HuffCode {

36 uint8_t size;

37 uint8_t delta;

38 } HuffCode;

40 typedef struct MotionPixelsContext {

41 AVCodecContext *avctx;

42 AVFrame *frame;

43 BswapDSPContext bdsp;

44 uint8_t *changes_map;

45 int offset_bits_len;

46 int codes_count, current_codes_count;

47 int max_codes_bits;

48 HuffCode codes[MAX_HUFF_CODES];

49 VLC vlc;

50 YuvPixel *vpt, *hpt;

51 uint8_t gradient_scale[3];

52 uint8_t *bswapbuf;

53 int bswapbuf_size;

54 } MotionPixelsContext;

56 static av_cold int mp_decode_end(AVCodecContext *avctx)

57 {

58 MotionPixelsContext *mp = avctx->priv_data;

60 av_freep(&mp->changes_map);

61 av_freep(&mp->vpt);

62 av_freep(&mp->hpt);

63 av_freep(&mp->bswapbuf);

64 av_frame_free(&mp->frame);

66 return 0;

67 }

69 static av_cold int mp_decode_init(AVCodecContext *avctx)

70 {

71 av_unused static AVOnce init_static_once = AV_ONCE_INIT;

72 MotionPixelsContext *mp = avctx->priv_data;

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

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

76 if(avctx->extradata_size < 2){

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

78 return AVERROR_INVALIDDATA;

79 }

81 mp->avctx = avctx;

82 ff_bswapdsp_init(&mp->bdsp);

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

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

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

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

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

88 return AVERROR(ENOMEM);

89 avctx->pix_fmt = AV_PIX_FMT_RGB555;

91 mp->frame = av_frame_alloc();

92 if (!mp->frame)

93 return AVERROR(ENOMEM);

95 #if !CONFIG_HARDCODED_TABLES

96 ff_thread_once(&init_static_once, motionpixels_tableinit);

97 #endif

99 return 0;

100 }

101

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

103 {

104 uint16_t *pixels;

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

106

107 while (count--) {

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

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

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

111 if (read_color)

112 color = get_bits(gb, 15);

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

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

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

116 continue;

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

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

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

120 while (h--) {

121 mp->changes_map[offset] = w;

122 if (read_color)

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

124 pixels[i] = color;

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

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

127 }

128 }

129 }

130

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

132 {

133 while (get_bits1(gb)) {

134 ++size;

135 if (size > mp->max_codes_bits) {

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

137 return AVERROR_INVALIDDATA;

138 }

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

140 return AVERROR_INVALIDDATA;

141 }

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

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++].size = size;

148 return 0;

149 }

150

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

152 {

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

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

155 } else {

156 int i;

157 int ret;

158

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

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

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

162 mp->current_codes_count = 0;

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

164 return ret;

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

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

167 return AVERROR_INVALIDDATA;

168 }

169 }

170 return 0;

171 }

172

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

174 {

175 int delta;

176

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

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

179 return delta;

180 }

181

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

183 {

184 int color;

185

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

187 return mp_rgb_yuv_table[color];

188 }

189

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

191 {

192 int color;

193

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

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

196 }

197

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

199 {

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

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

202 }

203

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

205 {

206 YuvPixel p;

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

208 int w, i, x = 0;

209

210 p = mp->vpt[y];

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

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

213 ++x;

214 }

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

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

217 if (w != 0) {

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

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

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

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

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

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

224 }

225 }

226 }

227 x += w;

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

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

230 } else {

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

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

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

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

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

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

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

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

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

240 } else {

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

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

243 }

244 }

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

246 ++x;

247 }

248 }

249 }

250

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

252 {

253 YuvPixel p;

254 int y, y0;

255

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

257

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

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

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

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

262 } else {

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

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

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

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

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

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

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

270 }

271 mp->vpt[y] = p;

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

273 }

274 }

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

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

277 mp_decode_line(mp, gb, y);

278 }

279

280 static int mp_decode_frame(AVCodecContext *avctx,

281 void *data, int *got_frame,

282 AVPacket *avpkt)

283 {

284 const uint8_t *buf = avpkt->data;

285 int buf_size = avpkt->size;

286 MotionPixelsContext *mp = avctx->priv_data;

287 GetBitContext gb;

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

289

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

291 return ret;

292

293 /* le32 bitstream msb first */

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

295 if (!mp->bswapbuf)

296 return AVERROR(ENOMEM);

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

298 buf_size / 4);

299 if (buf_size & 3)

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

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

302

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

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

305 count1 = get_bits(&gb, 12);

306 count2 = get_bits(&gb, 12);

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

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

309 }

310

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

312 if (mp->codes_count == 0)

313 goto end;

314

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

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

317 mp->changes_map[0] = 1;

318 }

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

320 goto end;

321

322 sz = get_bits(&gb, 18);

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

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

325 if (sz == 0)

326 goto end;

327

328 if (mp->codes_count > 1) {

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

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

331 ret = ff_init_vlc_from_lengths(&mp->vlc, mp->max_codes_bits, mp->codes_count,

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

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

334 0, 0, avctx);

335 if (ret < 0)

336 goto end;

337 }

338 mp_decode_frame_helper(mp, &gb);

339 ff_free_vlc(&mp->vlc);

340

341 end:

342 if ((ret = av_frame_ref(data, mp->frame)) < 0)

343 return ret;

344 *got_frame = 1;

345 return buf_size;

346 }

347

348 const AVCodec ff_motionpixels_decoder = {

349 .name = "motionpixels",

350 .long_name = NULL_IF_CONFIG_SMALL("Motion Pixels video"),

351 .type = AVMEDIA_TYPE_VIDEO,

352 .id = AV_CODEC_ID_MOTIONPIXELS,

353 .priv_data_size = sizeof(MotionPixelsContext),

354 .init = mp_decode_init,

355 .close = mp_decode_end,

356 .decode = mp_decode_frame,

357 .capabilities = AV_CODEC_CAP_DR1,

358 .caps_internal = FF_CODEC_CAP_INIT_CLEANUP | FF_CODEC_CAP_INIT_THREADSAFE,

359 };

YuvPixel::y

int8_t y

Definition: motionpixels_tablegen.h:30

AVCodec

AVCodec.

Definition: codec.h:202

bswapdsp.h

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

thread.h

av_clip_uintp2

#define av_clip_uintp2

Definition: common.h:120

get_bits_long

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

Read 0-32 bits.

Definition: get_bits.h:547

MotionPixelsContext::gradient_scale

uint8_t gradient_scale[3]

Definition: motionpixels.c:51

av_unused

#define av_unused

Definition: attributes.h:131

av_frame_free

void av_frame_free(AVFrame **frame)

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

Definition: frame.c:109

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

uint8_t w

Definition: llviddspenc.c:38

internal.h

AVPacket::data

uint8_t * data

Definition: packet.h:373

MotionPixelsContext::max_codes_bits

int max_codes_bits

Definition: motionpixels.c:47

data

const char data[16]

Definition: mxf.c:143

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

mp_decode_frame

static int mp_decode_frame(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *avpkt)

Definition: motionpixels.c:280

init_get_bits

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

Initialize GetBitContext.

Definition: get_bits.h:660

init

static int init

Definition: av_tx.c:47

HuffCode::delta

uint8_t delta

Definition: motionpixels.c:37

get_bits

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

Read 1-25 bits.

Definition: get_bits.h:380

MotionPixelsContext::offset_bits_len

int offset_bits_len

Definition: motionpixels.c:45

ff_motionpixels_decoder

const AVCodec ff_motionpixels_decoder

Definition: motionpixels.c:348

GetBitContext

Definition: get_bits.h:62

mp_decode_init

static av_cold int mp_decode_init(AVCodecContext *avctx)

Definition: motionpixels.c:69

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

ff_init_vlc_from_lengths

int ff_init_vlc_from_lengths(VLC *vlc_arg, 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: bitstream.c:381

av_frame_alloc

AVFrame * av_frame_alloc(void)

Allocate an AVFrame and set its fields to default values.

Definition: frame.c:97

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

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

MotionPixelsContext::frame

AVFrame * frame

Definition: motionpixels.c:42

mp_get_yuv_from_rgb

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

Definition: motionpixels.c:182

HuffCode::size

uint8_t size

Definition: motionpixels.c:36

decode

static void decode(AVCodecContext *dec_ctx, AVPacket *pkt, AVFrame *frame, FILE *outfile)

Definition: decode_audio.c:71

AVCodecContext::extradata_size

int extradata_size

Definition: avcodec.h:485

MotionPixelsContext::bswapbuf

uint8_t * bswapbuf

Definition: motionpixels.c:52

get_bits.h

MotionPixelsContext::bdsp

BswapDSPContext bdsp

Definition: motionpixels.c:43

ff_free_vlc

void ff_free_vlc(VLC *vlc)

Definition: bitstream.c:431

motionpixels_tableinit

static av_cold void motionpixels_tableinit(void)

Definition: motionpixels_tablegen.h:85

AV_ONCE_INIT

#define AV_ONCE_INIT

Definition: thread.h:173

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

mp_decode_frame_helper

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

Definition: motionpixels.c:251

AV_CODEC_ID_MOTIONPIXELS

@ AV_CODEC_ID_MOTIONPIXELS

Definition: codec_id.h:169

mp_gradient

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

Definition: motionpixels.c:173

get_bits1

static unsigned int get_bits1(GetBitContext *s)

Definition: get_bits.h:499

AVOnce

#define AVOnce

Definition: thread.h:172

MotionPixelsContext

Definition: motionpixels.c:40

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

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

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

size

int size

Definition: twinvq_data.h:10344

color

static const uint32_t color[16+AV_CLASS_CATEGORY_NB]

Definition: log.c:92

MotionPixelsContext::avctx

AVCodecContext * avctx

Definition: motionpixels.c:41

MotionPixelsContext::current_codes_count

int current_codes_count

Definition: motionpixels.c:46

motionpixels_tablegen.h

MotionPixelsContext::vlc

VLC vlc

Definition: motionpixels.c:49

MotionPixelsContext::changes_map

uint8_t * changes_map

Definition: motionpixels.c:44

mp_get_vlc

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

Definition: motionpixels.c:198

MAX_HUFF_CODES

#define MAX_HUFF_CODES

Definition: motionpixels.c:31

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

AVCodecContext::extradata

uint8_t * extradata

some codecs need / can use extradata like Huffman tables.

Definition: avcodec.h:484

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: internal.h:50

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

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

AV_PIX_FMT_RGB555

#define AV_PIX_FMT_RGB555

Definition: pixfmt.h:392

av_always_inline

#define av_always_inline

Definition: attributes.h:49

mp_set_rgb_from_yuv

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

Definition: motionpixels.c:190

FFMIN

#define FFMIN(a, b)

Definition: macros.h:49

MotionPixelsContext::codes

HuffCode codes[MAX_HUFF_CODES]

Definition: motionpixels.c:48

mp_read_codes_table

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

Definition: motionpixels.c:151

AVCodec::name

const char * name

Name of the codec implementation.

Definition: codec.h:209

AVCodecContext::height

int height

Definition: avcodec.h:556

AVCodecContext::pix_fmt

enum AVPixelFormat pix_fmt

Pixel format, see AV_PIX_FMT_xxx.

Definition: avcodec.h:593

av_calloc

void * av_calloc(size_t nmemb, size_t size)

Definition: mem.c:271

avcodec.h

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

ret

Definition: filter_design.txt:187

AVCodecContext

main external API structure.

Definition: avcodec.h:383

MotionPixelsContext::hpt

YuvPixel * hpt

Definition: motionpixels.c:50

VLC

Definition: vlc.h:26

mp_decode_line

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

Definition: motionpixels.c:204

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

AVPacket

This structure stores compressed data.

Definition: packet.h:350

AVCodecContext::priv_data

void * priv_data

Definition: avcodec.h:410

av_freep

#define av_freep(p)

Definition: tableprint_vlc.h:35

AVCodecContext::width

int width

picture width / height.

Definition: avcodec.h:556

HuffCode

Definition: motionpixels.c:35

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

BswapDSPContext

Definition: bswapdsp.h:24

Definition: vp9dsp_template.c:2038

YuvPixel::u

int8_t u

Definition: motionpixels_tablegen.h:30

MotionPixelsContext::codes_count

int codes_count

Definition: motionpixels.c:46

av_log2

int av_log2(unsigned v)

Definition: intmath.c:26

MotionPixelsContext::vpt

YuvPixel * vpt

Definition: motionpixels.c:50

mp_decode_end

static av_cold int mp_decode_end(AVCodecContext *avctx)

Definition: motionpixels.c:56

Generated on Wed Aug 24 2022 21:37:47 for FFmpeg by doxygen 1.8.17