FFmpeg: libavcodec/cri.c Source File

FFmpeg

[フレーム]

libavcodec

cri.c

Go to the documentation of this file.

1 /*

2 * CRI image decoder

3 *

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

23 /**

24 * @file

25 * Cintel RAW image decoder

26 */

28 #define BITSTREAM_READER_LE

30 #include "libavutil/intfloat.h"

31 #include "libavutil/display.h"

32 #include "avcodec.h"

33 #include "bytestream.h"

34 #include "get_bits.h"

35 #include "internal.h"

36 #include "thread.h"

38 typedef struct CRIContext {

39 AVCodecContext *jpeg_avctx; // wrapper context for MJPEG

40 AVPacket *jpkt; // encoded JPEG tile

41 AVFrame *jpgframe; // decoded JPEG tile

43 GetByteContext gb;

44 int color_model;

45 const uint8_t *data;

46 unsigned data_size;

47 uint64_t tile_size[4];

48 } CRIContext;

50 static av_cold int cri_decode_init(AVCodecContext *avctx)

51 {

52 CRIContext *s = avctx->priv_data;

53 const AVCodec *codec;

54 int ret;

56 s->jpgframe = av_frame_alloc();

57 if (!s->jpgframe)

58 return AVERROR(ENOMEM);

60 s->jpkt = av_packet_alloc();

61 if (!s->jpkt)

62 return AVERROR(ENOMEM);

64 codec = avcodec_find_decoder(AV_CODEC_ID_MJPEG);

65 if (!codec)

66 return AVERROR_BUG;

67 s->jpeg_avctx = avcodec_alloc_context3(codec);

68 if (!s->jpeg_avctx)

69 return AVERROR(ENOMEM);

70 s->jpeg_avctx->flags = avctx->flags;

71 s->jpeg_avctx->flags2 = avctx->flags2;

72 s->jpeg_avctx->dct_algo = avctx->dct_algo;

73 s->jpeg_avctx->idct_algo = avctx->idct_algo;

74 ret = avcodec_open2(s->jpeg_avctx, codec, NULL);

75 if (ret < 0)

76 return ret;

78 return 0;

79 }

81 static void unpack_10bit(GetByteContext *gb, uint16_t *dst, int shift,

82 int w, int h, ptrdiff_t stride)

83 {

84 int count = w * h;

85 int pos = 0;

87 while (count > 0) {

88 uint32_t a0, a1, a2, a3;

89 if (bytestream2_get_bytes_left(gb) < 4)

90 break;

91 a0 = bytestream2_get_le32(gb);

92 a1 = bytestream2_get_le32(gb);

93 a2 = bytestream2_get_le32(gb);

94 a3 = bytestream2_get_le32(gb);

95 dst[pos] = (((a0 >> 1) & 0xE00) | (a0 & 0x1FF)) << shift;

96 pos++;

97 if (pos >= w) {

98 if (count == 1)

99 break;

100 dst += stride;

101 pos = 0;

102 }

103 dst[pos] = (((a0 >> 13) & 0x3F) | ((a0 >> 14) & 0xFC0)) << shift;

104 pos++;

105 if (pos >= w) {

106 if (count == 2)

107 break;

108 dst += stride;

109 pos = 0;

110 }

111 dst[pos] = (((a0 >> 26) & 7) | ((a1 & 0x1FF) << 3)) << shift;

112 pos++;

113 if (pos >= w) {

114 if (count == 3)

115 break;

116 dst += stride;

117 pos = 0;

118 }

119 dst[pos] = (((a1 >> 10) & 0x1FF) | ((a1 >> 11) & 0xE00)) << shift;

120 pos++;

121 if (pos >= w) {

122 if (count == 4)

123 break;

124 dst += stride;

125 pos = 0;

126 }

127 dst[pos] = (((a1 >> 23) & 0x3F) | ((a2 & 0x3F) << 6)) << shift;

128 pos++;

129 if (pos >= w) {

130 if (count == 5)

131 break;

132 dst += stride;

133 pos = 0;

134 }

135 dst[pos] = (((a2 >> 7) & 0xFF8) | ((a2 >> 6) & 7)) << shift;

136 pos++;

137 if (pos >= w) {

138 if (count == 6)

139 break;

140 dst += stride;

141 pos = 0;

142 }

143 dst[pos] = (((a3 & 7) << 9) | ((a2 >> 20) & 0x1FF)) << shift;

144 pos++;

145 if (pos >= w) {

146 if (count == 7)

147 break;

148 dst += stride;

149 pos = 0;

150 }

151 dst[pos] = (((a3 >> 4) & 0xFC0) | ((a3 >> 3) & 0x3F)) << shift;

152 pos++;

153 if (pos >= w) {

154 if (count == 8)

155 break;

156 dst += stride;

157 pos = 0;

158 }

159 dst[pos] = (((a3 >> 16) & 7) | ((a3 >> 17) & 0xFF8)) << shift;

160 pos++;

161 if (pos >= w) {

162 if (count == 9)

163 break;

164 dst += stride;

165 pos = 0;

166 }

167

168 count -= 9;

169 }

170 }

171

172 static int cri_decode_frame(AVCodecContext *avctx, void *data,

173 int *got_frame, AVPacket *avpkt)

174 {

175 CRIContext *s = avctx->priv_data;

176 GetByteContext *gb = &s->gb;

177 ThreadFrame frame = { .f = data };

178 int ret, bps, hflip = 0, vflip = 0;

179 AVFrameSideData *rotation;

180 int compressed = 0;

181 AVFrame *p = data;

182

183 s->data = NULL;

184 s->data_size = 0;

185

186 bytestream2_init(gb, avpkt->data, avpkt->size);

187

188 while (bytestream2_get_bytes_left(gb) > 8) {

189 char codec_name[1024];

190 uint32_t key, length;

191 float framerate;

192 int width, height;

193

194 key = bytestream2_get_le32(gb);

195 length = bytestream2_get_le32(gb);

196

197 switch (key) {

198 case 1:

199 if (length != 4)

200 return AVERROR_INVALIDDATA;

201

202 if (bytestream2_get_le32(gb) != MKTAG('D', 'V', 'C', 'C'))

203 return AVERROR_INVALIDDATA;

204 break;

205 case 100:

206 if (length < 16)

207 return AVERROR_INVALIDDATA;

208 width = bytestream2_get_le32(gb);

209 height = bytestream2_get_le32(gb);

210 s->color_model = bytestream2_get_le32(gb);

211 if (bytestream2_get_le32(gb) != 1)

212 return AVERROR_INVALIDDATA;

213 ret = ff_set_dimensions(avctx, width, height);

214 if (ret < 0)

215 return ret;

216 length -= 16;

217 goto skip;

218 case 101:

219 if (length != 4)

220 return AVERROR_INVALIDDATA;

221

222 if (bytestream2_get_le32(gb) != 0)

223 return AVERROR_INVALIDDATA;

224 break;

225 case 102:

226 bytestream2_get_buffer(gb, codec_name, FFMIN(length, sizeof(codec_name) - 1));

227 length -= FFMIN(length, sizeof(codec_name) - 1);

228 if (strncmp(codec_name, "cintel_craw", FFMIN(length, sizeof(codec_name) - 1)))

229 return AVERROR_INVALIDDATA;

230 compressed = 1;

231 goto skip;

232 case 103:

233 if (bytestream2_get_bytes_left(gb) < length)

234 return AVERROR_INVALIDDATA;

235 s->data = gb->buffer;

236 s->data_size = length;

237 goto skip;

238 case 105:

239 hflip = bytestream2_get_byte(gb) != 0;

240 length--;

241 goto skip;

242 case 106:

243 vflip = bytestream2_get_byte(gb) != 0;

244 length--;

245 goto skip;

246 case 107:

247 if (length != 4)

248 return AVERROR_INVALIDDATA;

249 framerate = av_int2float(bytestream2_get_le32(gb));

250 avctx->framerate.num = framerate * 1000;

251 avctx->framerate.den = 1000;

252 break;

253 case 119:

254 if (length != 32)

255 return AVERROR_INVALIDDATA;

256

257 for (int i = 0; i < 4; i++)

258 s->tile_size[i] = bytestream2_get_le64(gb);

259 break;

260 default:

261 av_log(avctx, AV_LOG_DEBUG, "skipping unknown key %u of length %u\n", key, length);

262 skip:

263 bytestream2_skip(gb, length);

264 }

265 }

266

267 switch (s->color_model) {

268 case 76:

269 case 88:

270 avctx->pix_fmt = AV_PIX_FMT_BAYER_BGGR16;

271 break;

272 case 77:

273 case 89:

274 avctx->pix_fmt = AV_PIX_FMT_BAYER_GBRG16;

275 break;

276 case 78:

277 case 90:

278 avctx->pix_fmt = AV_PIX_FMT_BAYER_RGGB16;

279 break;

280 case 45:

281 case 79:

282 case 91:

283 avctx->pix_fmt = AV_PIX_FMT_BAYER_GRBG16;

284 break;

285 }

286

287 switch (s->color_model) {

288 case 45:

289 bps = 10;

290 break;

291 case 76:

292 case 77:

293 case 78:

294 case 79:

295 bps = 12;

296 break;

297 case 88:

298 case 89:

299 case 90:

300 case 91:

301 bps = 16;

302 break;

303 default:

304 return AVERROR_INVALIDDATA;

305 }

306

307 if (compressed) {

308 for (int i = 0; i < 4; i++) {

309 if (s->tile_size[i] >= s->data_size)

310 return AVERROR_INVALIDDATA;

311 }

312

313 if (s->tile_size[0] + s->tile_size[1] + s->tile_size[2] + s->tile_size[3] !=

314 s->data_size)

315 return AVERROR_INVALIDDATA;

316 }

317

318 if (!s->data || !s->data_size)

319 return AVERROR_INVALIDDATA;

320

321 if ((ret = ff_thread_get_buffer(avctx, &frame, 0)) < 0)

322 return ret;

323

324 avctx->bits_per_raw_sample = bps;

325

326 if (!compressed && s->color_model == 45) {

327 uint16_t *dst = (uint16_t *)p->data[0];

328 GetByteContext gb;

329

330 bytestream2_init(&gb, s->data, s->data_size);

331 unpack_10bit(&gb, dst, 4, avctx->width, avctx->height, p->linesize[0] / 2);

332 } else if (!compressed) {

333 GetBitContext gbit;

334 const int shift = 16 - bps;

335

336 ret = init_get_bits8(&gbit, s->data, s->data_size);

337 if (ret < 0)

338 return ret;

339

340 for (int y = 0; y < avctx->height; y++) {

341 uint16_t *dst = (uint16_t *)(p->data[0] + y * p->linesize[0]);

342

343 if (get_bits_left(&gbit) < avctx->width * bps)

344 break;

345

346 for (int x = 0; x < avctx->width; x++)

347 dst[x] = get_bits(&gbit, bps) << shift;

348 }

349 } else {

350 unsigned offset = 0;

351

352 for (int tile = 0; tile < 4; tile++) {

353 av_packet_unref(s->jpkt);

354 s->jpkt->data = (uint8_t *)s->data + offset;

355 s->jpkt->size = s->tile_size[tile];

356

357 ret = avcodec_send_packet(s->jpeg_avctx, s->jpkt);

358 if (ret < 0) {

359 av_log(avctx, AV_LOG_ERROR, "Error submitting a packet for decoding\n");

360 return ret;

361 }

362

363 ret = avcodec_receive_frame(s->jpeg_avctx, s->jpgframe);

364 if (ret < 0 || s->jpgframe->format != AV_PIX_FMT_GRAY16 ||

365 s->jpeg_avctx->width * 2 != avctx->width ||

366 s->jpeg_avctx->height * 2 != avctx->height) {

367 if (ret < 0) {

368 av_log(avctx, AV_LOG_ERROR,

369 "JPEG decoding error (%d).\n", ret);

370 } else {

371 av_log(avctx, AV_LOG_ERROR,

372 "JPEG invalid format.\n");

373 ret = AVERROR_INVALIDDATA;

374 }

375

376 /* Normally skip, if error explode */

377 if (avctx->err_recognition & AV_EF_EXPLODE)

378 return ret;

379 else

380 return 0;

381 }

382

383 for (int y = 0; y < s->jpeg_avctx->height; y++) {

384 const int hw = s->jpgframe->width / 2;

385 uint16_t *dst = (uint16_t *)(p->data[0] + (y * 2) * p->linesize[0] + tile * hw * 2);

386 const uint16_t *src = (const uint16_t *)(s->jpgframe->data[0] + y * s->jpgframe->linesize[0]);

387

388 memcpy(dst, src, hw * 2);

389 src += hw;

390 dst += p->linesize[0] / 2;

391 memcpy(dst, src, hw * 2);

392 }

393

394 av_frame_unref(s->jpgframe);

395 offset += s->tile_size[tile];

396 }

397 }

398

399 if (hflip || vflip) {

400 rotation = av_frame_new_side_data(p, AV_FRAME_DATA_DISPLAYMATRIX,

401 sizeof(int32_t) * 9);

402 if (rotation) {

403 av_display_rotation_set((int32_t *)rotation->data, 0.f);

404 av_display_matrix_flip((int32_t *)rotation->data, hflip, vflip);

405 }

406 }

407

408 p->pict_type = AV_PICTURE_TYPE_I;

409 p->key_frame = 1;

410

411 *got_frame = 1;

412

413 return 0;

414 }

415

416 static av_cold int cri_decode_close(AVCodecContext *avctx)

417 {

418 CRIContext *s = avctx->priv_data;

419

420 av_frame_free(&s->jpgframe);

421 av_packet_free(&s->jpkt);

422 avcodec_free_context(&s->jpeg_avctx);

423

424 return 0;

425 }

426

427 const AVCodec ff_cri_decoder = {

428 .name = "cri",

429 .type = AVMEDIA_TYPE_VIDEO,

430 .id = AV_CODEC_ID_CRI,

431 .priv_data_size = sizeof(CRIContext),

432 .init = cri_decode_init,

433 .decode = cri_decode_frame,

434 .close = cri_decode_close,

435 .capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_FRAME_THREADS,

436 .caps_internal = FF_CODEC_CAP_INIT_THREADSAFE | FF_CODEC_CAP_INIT_CLEANUP,

437 .long_name = NULL_IF_CONFIG_SMALL("Cintel RAW"),

438 };

av_packet_unref

void av_packet_unref(AVPacket *pkt)

Wipe the packet.

Definition: avpacket.c:424

AVCodec

AVCodec.

Definition: codec.h:202

stride

int stride

Definition: mace.c:144

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

CRIContext::data

const uint8_t * data

Definition: cri.c:45

get_bits_left

static int get_bits_left(GetBitContext *gb)

Definition: get_bits.h:850

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

ff_cri_decoder

const AVCodec ff_cri_decoder

Definition: cri.c:427

av_frame_new_side_data

AVFrameSideData * av_frame_new_side_data(AVFrame *frame, enum AVFrameSideDataType type, size_t size)

Add a new side data to a frame.

Definition: frame.c:605

GetByteContext

Definition: bytestream.h:33

CRIContext

Definition: cri.c:38

unpack_10bit

static void unpack_10bit(GetByteContext *gb, uint16_t *dst, int shift, int w, int h, ptrdiff_t stride)

Definition: cri.c:81

AVCodecContext::err_recognition

int err_recognition

Error recognition; may misdetect some more or less valid parts as errors.

Definition: avcodec.h:1324

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

AVFrame

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

Definition: frame.h:317

uint8_t w

Definition: llviddspenc.c:38

av_display_matrix_flip

void av_display_matrix_flip(int32_t matrix[9], int hflip, int vflip)

Flip the input matrix horizontally and/or vertically.

Definition: display.c:65

internal.h

AVPacket::data

uint8_t * data

Definition: packet.h:373

data

const char data[16]

Definition: mxf.c:143

av_display_rotation_set

void av_display_rotation_set(int32_t matrix[9], double angle)

Initialize a transformation matrix describing a pure clockwise rotation by the specified angle (in de...

Definition: display.c:50

AV_FRAME_DATA_DISPLAYMATRIX

@ AV_FRAME_DATA_DISPLAYMATRIX

This side data contains a 3x3 transformation matrix describing an affine transformation that needs to...

Definition: frame.h:84

CRIContext::jpkt

AVPacket * jpkt

Definition: cri.c:40

intfloat.h

AV_PIX_FMT_BAYER_GRBG16

#define AV_PIX_FMT_BAYER_GRBG16

Definition: pixfmt.h:431

thread.h

av_packet_free

void av_packet_free(AVPacket **pkt)

Free the packet, if the packet is reference counted, it will be unreferenced first.

Definition: avpacket.c:75

AVFrame::data

uint8_t * data[AV_NUM_DATA_POINTERS]

pointer to the picture/channel planes.

Definition: frame.h:338

init

static int init

Definition: av_tx.c:47

AVCodecContext::framerate

AVRational framerate

Definition: avcodec.h:1710

framerate

int framerate

Definition: h264_levels.c:65

bytestream2_skip

static av_always_inline void bytestream2_skip(GetByteContext *g, unsigned int size)

Definition: bytestream.h:168

get_bits

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

Read 1-25 bits.

Definition: get_bits.h:380

av_int2float

static av_always_inline float av_int2float(uint32_t i)

Reinterpret a 32-bit integer as a float.

Definition: intfloat.h:40

GetBitContext

Definition: get_bits.h:62

ff_thread_get_buffer

the pkt_dts and pkt_pts fields in AVFrame will work as usual Restrictions on codec whose streams don t reset across will not work because their bitstreams cannot be decoded in parallel *The contents of buffers must not be read before as well as code calling up to before the decode process starts Call have so the codec calls ff_thread_report set FF_CODEC_CAP_ALLOCATE_PROGRESS in AVCodec caps_internal and use ff_thread_get_buffer() to allocate frames. The frames must then be freed with ff_thread_release_buffer(). Otherwise decode directly into the user-supplied frames. Call ff_thread_report_progress() after some part of the current picture has decoded. A good place to put this is where draw_horiz_band() is called - add this if it isn 't called anywhere

AVFrame::key_frame

int key_frame

1 -> keyframe, 0-> not

Definition: frame.h:409

AVCodecContext::flags

int flags

AV_CODEC_FLAG_*.

Definition: avcodec.h:463

AVCodecContext::dct_algo

int dct_algo

DCT algorithm, see FF_DCT_* below.

Definition: avcodec.h:1384

AV_PIX_FMT_GRAY16

#define AV_PIX_FMT_GRAY16

Definition: pixfmt.h:388

AVRational::num

int num

Numerator.

Definition: rational.h:59

av_frame_alloc

AVFrame * av_frame_alloc(void)

Allocate an AVFrame and set its fields to default values.

Definition: frame.c:97

#define a1

Definition: regdef.h:47

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

init_get_bits8

static int init_get_bits8(GetBitContext *s, const uint8_t *buffer, int byte_size)

Initialize GetBitContext.

Definition: get_bits.h:678

decode

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

Definition: decode_audio.c:71

avcodec_alloc_context3

AVCodecContext * avcodec_alloc_context3(const AVCodec *codec)

Allocate an AVCodecContext and set its fields to default values.

Definition: options.c:141

width

#define width

#define s(width, name)

Definition: cbs_vp9.c:257

GetByteContext::buffer

const uint8_t * buffer

Definition: bytestream.h:34

CRIContext::tile_size

uint64_t tile_size[4]

Definition: cri.c:47

avcodec_receive_frame

int avcodec_receive_frame(AVCodecContext *avctx, AVFrame *frame)

Return decoded output data from a decoder.

Definition: decode.c:642

cri_decode_init

static av_cold int cri_decode_init(AVCodecContext *avctx)

Definition: cri.c:50

AVCodecContext::bits_per_raw_sample

int bits_per_raw_sample

Bits per sample/pixel of internal libavcodec pixel/sample format.

Definition: avcodec.h:1425

AV_LOG_DEBUG

#define AV_LOG_DEBUG

Stuff which is only useful for libav* developers.

Definition: log.h:201

get_bits.h

key

const char * key

Definition: hwcontext_opencl.c:168

AV_PIX_FMT_BAYER_BGGR16

#define AV_PIX_FMT_BAYER_BGGR16

Definition: pixfmt.h:428

CRIContext::jpeg_avctx

AVCodecContext * jpeg_avctx

Definition: cri.c:39

AV_CODEC_CAP_FRAME_THREADS

#define AV_CODEC_CAP_FRAME_THREADS

Codec supports frame-level multithreading.

Definition: codec.h:113

NULL

#define NULL

Definition: coverity.c:32

avcodec_free_context

void avcodec_free_context(AVCodecContext **avctx)

Free the codec context and everything associated with it and write NULL to the provided pointer.

Definition: options.c:156

CRIContext::jpgframe

AVFrame * jpgframe

Definition: cri.c:41

AV_PICTURE_TYPE_I

@ AV_PICTURE_TYPE_I

Intra.

Definition: avutil.h:274

src

#define src

Definition: vp8dsp.c:255

AV_PIX_FMT_BAYER_GBRG16

#define AV_PIX_FMT_BAYER_GBRG16

Definition: pixfmt.h:430

bytestream2_get_buffer

static av_always_inline unsigned int bytestream2_get_buffer(GetByteContext *g, uint8_t *dst, unsigned int size)

Definition: bytestream.h:267

avcodec_open2

int attribute_align_arg avcodec_open2(AVCodecContext *avctx, const AVCodec *codec, AVDictionary **options)

Initialize the AVCodecContext to use the given AVCodec.

Definition: avcodec.c:137

AV_EF_EXPLODE

#define AV_EF_EXPLODE

abort decoding on minor error detection

Definition: avcodec.h:1335

cri_decode_frame

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

Definition: cri.c:172

bytestream2_get_bytes_left

static av_always_inline int bytestream2_get_bytes_left(GetByteContext *g)

Definition: bytestream.h:158

avcodec_find_decoder

const AVCodec * avcodec_find_decoder(enum AVCodecID id)

Find a registered decoder with a matching codec ID.

Definition: allcodecs.c:921

AVCodecContext::flags2

int flags2

AV_CODEC_FLAG2_*.

Definition: avcodec.h:470

AVFrame::pict_type

enum AVPictureType pict_type

Picture type of the frame.

Definition: frame.h:414

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

bps

unsigned bps

Definition: movenc.c:1597

AVFrameSideData::data

uint8_t * data

Definition: frame.h:225

height

#define height

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

av_packet_alloc

AVPacket * av_packet_alloc(void)

Allocate an AVPacket and set its fields to default values.

Definition: avpacket.c:64

#define a0

Definition: regdef.h:46

AV_CODEC_ID_MJPEG

@ AV_CODEC_ID_MJPEG

Definition: codec_id.h:57

avcodec_send_packet

int avcodec_send_packet(AVCodecContext *avctx, const AVPacket *avpkt)

Supply raw packet data as input to a decoder.

Definition: decode.c:579

AV_CODEC_ID_CRI

@ AV_CODEC_ID_CRI

Definition: codec_id.h:307

CRIContext::data_size

unsigned data_size

Definition: cri.c:46

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

Definition: cbs_h2645.c:271

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

display.h

#define a2

Definition: regdef.h:48

FFMIN

#define FFMIN(a, b)

Definition: macros.h:49

av_frame_unref

void av_frame_unref(AVFrame *frame)

Unreference all the buffers referenced by frame and reset the frame fields.

Definition: frame.c:435

AVCodecContext::idct_algo

int idct_algo

IDCT algorithm, see FF_IDCT_* below.

Definition: avcodec.h:1397

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

avcodec.h

ret

Definition: filter_design.txt:187

frame

these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several the filter must be ready for frames arriving randomly on any input any filter with several inputs will most likely require some kind of queuing mechanism It is perfectly acceptable to have a limited queue and to drop frames when the inputs are too unbalanced request_frame For filters that do not use the this method is called when a frame is wanted on an output For a it should directly call filter_frame on the corresponding output For a if there are queued frames already one of these frames should be pushed If the filter should request a frame on one of its repeatedly until at least one frame has been pushed Return or at least make progress towards producing a frame

Definition: filter_design.txt:264

pos

unsigned int pos

Definition: spdifenc.c:412

AVCodecContext

main external API structure.

Definition: avcodec.h:383

ThreadFrame

Definition: thread.h:34

AVRational::den

int den

Denominator.