FFmpeg: libavcodec/eatgv.c Source File

FFmpeg

[フレーム]

libavcodec

eatgv.c

Go to the documentation of this file.

1 /*

2 * Electronic Arts TGV 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 St, Fifth Floor, Boston, MA 02110-1301 USA

20 */

22 /**

23 * @file

24 * Electronic Arts TGV Video Decoder

25 * by Peter Ross (pross@xvid.org)

26 *

27 * Technical details here:

28 * http://wiki.multimedia.cx/index.php?title=Electronic_Arts_TGV

29 */

31 #include "libavutil/mem.h"

33 #define BITSTREAM_READER_LE

34 #include "avcodec.h"

35 #include "get_bits.h"

36 #include "codec_internal.h"

37 #include "decode.h"

39 #define EA_PREAMBLE_SIZE 8

40 #define kVGT_TAG MKTAG('k', 'V', 'G', 'T')

42 typedef struct TgvContext {

43 AVCodecContext *avctx;

44 AVFrame *last_frame;

45 uint8_t *frame_buffer;

46 int width,height;

47 uint32_t palette[AVPALETTE_COUNT];

49 int (*mv_codebook)[2];

50 uint8_t (*block_codebook)[16];

51 int num_mvs; ///< current length of mv_codebook

52 int num_blocks_packed; ///< current length of block_codebook

53 } TgvContext;

55 static av_cold int tgv_decode_init(AVCodecContext *avctx)

56 {

57 TgvContext *s = avctx->priv_data;

58 s->avctx = avctx;

59 avctx->framerate = (AVRational){ 15, 1 };

60 avctx->pix_fmt = AV_PIX_FMT_PAL8;

62 s->last_frame = av_frame_alloc();

63 if (!s->last_frame)

64 return AVERROR(ENOMEM);

66 return 0;

67 }

69 /**

70 * Unpack buffer

71 * @return 0 on success, -1 on critical buffer underflow

72 */

73 static int unpack(const uint8_t *src, const uint8_t *src_end,

74 uint8_t *dst, int width, int height)

75 {

76 uint8_t *dst_end = dst + width*height;

77 int size, size1, size2, offset, run;

78 uint8_t *dst_start = dst;

80 if (src[0] & 0x01)

81 src += 5;

82 else

83 src += 2;

85 if (src_end - src < 3)

86 return AVERROR_INVALIDDATA;

87 size = AV_RB24(src);

88 src += 3;

90 while (size > 0 && src < src_end) {

92 /* determine size1 and size2 */

93 size1 = (src[0] & 3);

94 if (src[0] & 0x80) { // 1

95 if (src[0] & 0x40 ) { // 11

96 if (src[0] & 0x20) { // 111

97 if (src[0] < 0xFC) // !(111111)

98 size1 = (((src[0] & 31) + 1) << 2);

99 src++;

100 size2 = 0;

101 } else { // 110

102 offset = ((src[0] & 0x10) << 12) + AV_RB16(&src[1]) + 1;

103 size2 = ((src[0] & 0xC) << 6) + src[3] + 5;

104 src += 4;

105 }

106 } else { // 10

107 size1 = ((src[1] & 0xC0) >> 6);

108 offset = (AV_RB16(&src[1]) & 0x3FFF) + 1;

109 size2 = (src[0] & 0x3F) + 4;

110 src += 3;

111 }

112 } else { // 0

113 offset = ((src[0] & 0x60) << 3) + src[1] + 1;

114 size2 = ((src[0] & 0x1C) >> 2) + 3;

115 src += 2;

116 }

117

118

119 /* fetch strip from src */

120 if (size1 > src_end - src)

121 break;

122

123 if (size1 > 0) {

124 size -= size1;

125 run = FFMIN(size1, dst_end - dst);

126 memcpy(dst, src, run);

127 dst += run;

128 src += run;

129 }

130

131 if (size2 > 0) {

132 if (dst - dst_start < offset)

133 return 0;

134 size -= size2;

135 run = FFMIN(size2, dst_end - dst);

136 av_memcpy_backptr(dst, offset, run);

137 dst += run;

138 }

139 }

140

141 return 0;

142 }

143

144 /**

145 * Decode inter-frame

146 * @return 0 on success, -1 on critical buffer underflow

147 */

148 static int tgv_decode_inter(TgvContext *s, AVFrame *frame,

149 const uint8_t *buf, const uint8_t *buf_end)

150 {

151 int num_mvs;

152 int num_blocks_raw;

153 int num_blocks_packed;

154 int vector_bits;

155 int i,j,x,y;

156 GetBitContext gb;

157 int mvbits;

158 const uint8_t *blocks_raw;

159

160 if(buf_end - buf < 12)

161 return AVERROR_INVALIDDATA;

162

163 num_mvs = AV_RL16(&buf[0]);

164 num_blocks_raw = AV_RL16(&buf[2]);

165 num_blocks_packed = AV_RL16(&buf[4]);

166 vector_bits = AV_RL16(&buf[6]);

167 buf += 12;

168

169 if (vector_bits > MIN_CACHE_BITS || !vector_bits) {

170 av_log(s->avctx, AV_LOG_ERROR,

171 "Invalid value for motion vector bits: %d\n", vector_bits);

172 return AVERROR_INVALIDDATA;

173 }

174

175 /* allocate codebook buffers as necessary */

176 if (num_mvs > s->num_mvs) {

177 int err = av_reallocp_array(&s->mv_codebook, num_mvs, sizeof(*s->mv_codebook));

178 if (err < 0) {

179 s->num_mvs = 0;

180 return err;

181 }

182 s->num_mvs = num_mvs;

183 }

184

185 if (num_blocks_packed > s->num_blocks_packed) {

186 int err;

187 if ((err = av_reallocp(&s->block_codebook, num_blocks_packed * 16)) < 0) {

188 s->num_blocks_packed = 0;

189 return err;

190 }

191 s->num_blocks_packed = num_blocks_packed;

192 }

193

194 /* read motion vectors */

195 mvbits = (num_mvs * 2 * 10 + 31) & ~31;

196

197 if (buf_end - buf < (mvbits>>3) + 16*num_blocks_raw + 8*num_blocks_packed)

198 return AVERROR_INVALIDDATA;

199

200 init_get_bits(&gb, buf, mvbits);

201 for (i = 0; i < num_mvs; i++) {

202 s->mv_codebook[i][0] = get_sbits(&gb, 10);

203 s->mv_codebook[i][1] = get_sbits(&gb, 10);

204 }

205 buf += mvbits >> 3;

206

207 /* note ptr to uncompressed blocks */

208 blocks_raw = buf;

209 buf += num_blocks_raw * 16;

210

211 /* read compressed blocks */

212 init_get_bits(&gb, buf, (buf_end - buf) << 3);

213 for (i = 0; i < num_blocks_packed; i++) {

214 int tmp[4];

215 for (j = 0; j < 4; j++)

216 tmp[j] = get_bits(&gb, 8);

217 for (j = 0; j < 16; j++)

218 s->block_codebook[i][15-j] = tmp[get_bits(&gb, 2)];

219 }

220

221 if (get_bits_left(&gb) < vector_bits *

222 (s->avctx->height / 4) * (s->avctx->width / 4))

223 return AVERROR_INVALIDDATA;

224

225 /* read vectors and build frame */

226 for (y = 0; y < s->avctx->height / 4; y++)

227 for (x = 0; x < s->avctx->width / 4; x++) {

228 unsigned int vector = get_bits(&gb, vector_bits);

229 const uint8_t *src;

230 ptrdiff_t src_stride;

231

232 if (vector < num_mvs) {

233 int mx = x * 4 + s->mv_codebook[vector][0];

234 int my = y * 4 + s->mv_codebook[vector][1];

235

236 if (mx < 0 || mx + 4 > s->avctx->width ||

237 my < 0 || my + 4 > s->avctx->height) {

238 av_log(s->avctx, AV_LOG_ERROR, "MV %d %d out of picture\n", mx, my);

239 continue;

240 }

241

242 src = s->last_frame->data[0] + mx + my * s->last_frame->linesize[0];

243 src_stride = s->last_frame->linesize[0];

244 } else {

245 int offset = vector - num_mvs;

246 if (offset < num_blocks_raw)

247 src = blocks_raw + 16*offset;

248 else if (offset - num_blocks_raw < num_blocks_packed)

249 src = s->block_codebook[offset - num_blocks_raw];

250 else

251 continue;

252 src_stride = 4;

253 }

254

255 for (j = 0; j < 4; j++)

256 for (i = 0; i < 4; i++)

257 frame->data[0][(y * 4 + j) * frame->linesize[0] + (x * 4 + i)] =

258 src[j * src_stride + i];

259 }

260

261 return 0;

262 }

263

264 static int tgv_decode_frame(AVCodecContext *avctx, AVFrame *frame,

265 int *got_frame, AVPacket *avpkt)

266 {

267 const uint8_t *buf = avpkt->data;

268 int buf_size = avpkt->size;

269 TgvContext *s = avctx->priv_data;

270 const uint8_t *buf_end = buf + buf_size;

271 int chunk_type, ret;

272

273 if (buf_end - buf < EA_PREAMBLE_SIZE)

274 return AVERROR_INVALIDDATA;

275

276 chunk_type = AV_RL32(&buf[0]);

277 buf += EA_PREAMBLE_SIZE;

278

279 if (chunk_type == kVGT_TAG) {

280 int pal_count, i;

281 if(buf_end - buf < 12) {

282 av_log(avctx, AV_LOG_WARNING, "truncated header\n");

283 return AVERROR_INVALIDDATA;

284 }

285

286 s->width = AV_RL16(&buf[0]);

287 s->height = AV_RL16(&buf[2]);

288 if (s->avctx->width != s->width || s->avctx->height != s->height) {

289 av_freep(&s->frame_buffer);

290 av_frame_unref(s->last_frame);

291 if ((ret = ff_set_dimensions(s->avctx, s->width, s->height)) < 0)

292 return ret;

293 }

294

295 pal_count = AV_RL16(&buf[6]);

296 buf += 12;

297 for(i = 0; i < pal_count && i < AVPALETTE_COUNT && buf_end - buf >= 3; i++) {

298 s->palette[i] = 0xFFU << 24 | AV_RB24(buf);

299 buf += 3;

300 }

301 if (buf_end - buf < 5) {

302 return AVERROR_INVALIDDATA;

303 }

304 }

305

306 if ((ret = ff_get_buffer(avctx, frame, AV_GET_BUFFER_FLAG_REF)) < 0)

307 return ret;

308

309 memcpy(frame->data[1], s->palette, AVPALETTE_SIZE);

310

311 if (chunk_type == kVGT_TAG) {

312 int y;

313 frame->flags |= AV_FRAME_FLAG_KEY;

314 frame->pict_type = AV_PICTURE_TYPE_I;

315

316 if (!s->frame_buffer &&

317 !(s->frame_buffer = av_mallocz(s->width * s->height)))

318 return AVERROR(ENOMEM);

319

320 if (unpack(buf, buf_end, s->frame_buffer, s->avctx->width, s->avctx->height) < 0) {

321 av_log(avctx, AV_LOG_WARNING, "truncated intra frame\n");

322 return AVERROR_INVALIDDATA;

323 }

324 for (y = 0; y < s->height; y++)

325 memcpy(frame->data[0] + y * frame->linesize[0],

326 s->frame_buffer + y * s->width,

327 s->width);

328 } else {

329 if (!s->last_frame->data[0]) {

330 av_log(avctx, AV_LOG_WARNING, "inter frame without corresponding intra frame\n");

331 return buf_size;

332 }

333 frame->flags &= ~AV_FRAME_FLAG_KEY;

334 frame->pict_type = AV_PICTURE_TYPE_P;

335 if (tgv_decode_inter(s, frame, buf, buf_end) < 0) {

336 av_log(avctx, AV_LOG_WARNING, "truncated inter frame\n");

337 return AVERROR_INVALIDDATA;

338 }

339 }

340

341 if ((ret = av_frame_replace(s->last_frame, frame)) < 0)

342 return ret;

343

344 *got_frame = 1;

345

346 return buf_size;

347 }

348

349 static av_cold int tgv_decode_end(AVCodecContext *avctx)

350 {

351 TgvContext *s = avctx->priv_data;

352 av_frame_free(&s->last_frame);

353 av_freep(&s->frame_buffer);

354 av_freep(&s->mv_codebook);

355 av_freep(&s->block_codebook);

356 return 0;

357 }

358

359 const FFCodec ff_eatgv_decoder = {

360 .p.name = "eatgv",

361 CODEC_LONG_NAME("Electronic Arts TGV video"),

362 .p.type = AVMEDIA_TYPE_VIDEO,

363 .p.id = AV_CODEC_ID_TGV,

364 .priv_data_size = sizeof(TgvContext),

365 .init = tgv_decode_init,

366 .close = tgv_decode_end,

367 FF_CODEC_DECODE_CB(tgv_decode_frame),

368 .p.capabilities = AV_CODEC_CAP_DR1,

369 };

AV_LOG_WARNING

#define AV_LOG_WARNING

Something somehow does not look correct.

Definition: log.h:216

tgv_decode_init

static av_cold int tgv_decode_init(AVCodecContext *avctx)

Definition: eatgv.c:55

get_bits_left

static int get_bits_left(GetBitContext *gb)

Definition: get_bits.h:689

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

num_mvs

static const int num_mvs[RV34_MB_TYPES]

number of motion vectors in each macroblock type

Definition: rv34.c:865

TgvContext::height

int height

Definition: eatgv.c:46

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

AVFrame

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

Definition: frame.h:427

AVPacket::data

uint8_t * data

Definition: packet.h:558

FFCodec

Definition: codec_internal.h:127

TgvContext::num_blocks_packed

int num_blocks_packed

current length of block_codebook

Definition: eatgv.c:52

ff_eatgv_decoder

const FFCodec ff_eatgv_decoder

Definition: eatgv.c:359

ff_set_dimensions

int ff_set_dimensions(AVCodecContext *s, int width, int height)

Check that the provided frame dimensions are valid and set them on the codec context.

Definition: utils.c:91

init_get_bits

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

Initialize GetBitContext.

Definition: get_bits.h:512

TgvContext::avctx

AVCodecContext * avctx

Definition: eatgv.c:43

AVCodecContext::framerate

AVRational framerate

Definition: avcodec.h:551

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

uint8_t ptrdiff_t const uint8_t ptrdiff_t int intptr_t mx

Definition: dsp.h:57

TgvContext::last_frame

AVFrame * last_frame

Definition: eatgv.c:44

FFCodec::p

AVCodec p

The public AVCodec.

Definition: codec_internal.h:131

GetBitContext

Definition: get_bits.h:109

tgv_decode_frame

static int tgv_decode_frame(AVCodecContext *avctx, AVFrame *frame, int *got_frame, AVPacket *avpkt)

Definition: eatgv.c:264

TgvContext::width

int width

Definition: eatgv.c:46

av_frame_alloc

AVFrame * av_frame_alloc(void)

Allocate an AVFrame and set its fields to default values.

Definition: frame.c:52

TgvContext::num_mvs

int num_mvs

current length of mv_codebook

Definition: eatgv.c:51

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

AV_FRAME_FLAG_KEY

#define AV_FRAME_FLAG_KEY

A flag to mark frames that are keyframes.

Definition: frame.h:642

av_memcpy_backptr

void av_memcpy_backptr(uint8_t *dst, int back, int cnt)

Overlapping memcpy() implementation.

Definition: mem.c:447

FF_CODEC_DECODE_CB

#define FF_CODEC_DECODE_CB(func)

Definition: codec_internal.h:346

#define s(width, name)

Definition: cbs_vp9.c:198

AV_GET_BUFFER_FLAG_REF

#define AV_GET_BUFFER_FLAG_REF

The decoder will keep a reference to the frame and may reuse it later.

Definition: avcodec.h:411

tgv_decode_inter

static int tgv_decode_inter(TgvContext *s, AVFrame *frame, const uint8_t *buf, const uint8_t *buf_end)

Decode inter-frame.

Definition: eatgv.c:148

get_sbits

static int get_sbits(GetBitContext *s, int n)

Definition: get_bits.h:318

decode.h

get_bits.h

AV_RL16

uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_RL16

Definition: bytestream.h:94

CODEC_LONG_NAME

#define CODEC_LONG_NAME(str)

Definition: codec_internal.h:331

tmp

static uint8_t tmp[40]

Definition: aes_ctr.c:52

uint8_t ptrdiff_t const uint8_t ptrdiff_t int intptr_t intptr_t my

Definition: dsp.h:57

TgvContext::block_codebook

uint8_t(* block_codebook)[16]

Definition: eatgv.c:50

run

uint8_t run

Definition: svq3.c:207

AVRational

Rational number (pair of numerator and denominator).

Definition: rational.h:58

AVPALETTE_SIZE

#define AVPALETTE_SIZE

Definition: pixfmt.h:32

AV_PICTURE_TYPE_I

@ AV_PICTURE_TYPE_I

Intra.

Definition: avutil.h:278

AVPALETTE_COUNT

#define AVPALETTE_COUNT

Definition: pixfmt.h:33

kVGT_TAG

#define kVGT_TAG

Definition: eatgv.c:40

ff_get_buffer

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

Get a buffer for a frame.

Definition: decode.c:1720

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

height

#define height

Definition: dsp.h:89

codec_internal.h

dst

uint8_t ptrdiff_t const uint8_t ptrdiff_t int intptr_t intptr_t int int16_t * dst

Definition: dsp.h:87

size

int size

Definition: twinvq_data.h:10344

av_reallocp

int av_reallocp(void *ptr, size_t size)

Allocate, reallocate, or free a block of memory through a pointer to a pointer.

Definition: mem.c:188

TgvContext::palette

uint32_t palette[AVPALETTE_COUNT]

Definition: eatgv.c:47

EA_PREAMBLE_SIZE

#define EA_PREAMBLE_SIZE

Definition: eatgv.c:39

av_reallocp_array

int av_reallocp_array(void *ptr, size_t nmemb, size_t size)

Allocate, reallocate an array through a pointer to a pointer.

Definition: mem.c:225

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

TgvContext::frame_buffer

uint8_t * frame_buffer

Definition: eatgv.c:45

AV_CODEC_ID_TGV

@ AV_CODEC_ID_TGV

Definition: codec_id.h:172

unpack

static int unpack(const uint8_t *src, const uint8_t *src_end, uint8_t *dst, int width, int height)

Unpack buffer.

Definition: eatgv.c:73

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

Definition: cbs_h2645.c:256

MIN_CACHE_BITS

#define MIN_CACHE_BITS

Definition: get_bits.h:167

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

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

AVCodec::name

const char * name

Name of the codec implementation.

Definition: codec.h:179

AVCodecContext::pix_fmt

enum AVPixelFormat pix_fmt

Pixel format, see AV_PIX_FMT_xxx.

Definition: avcodec.h:631

avcodec.h

AV_PIX_FMT_PAL8

@ AV_PIX_FMT_PAL8

8 bits with AV_PIX_FMT_RGB32 palette

Definition: pixfmt.h:84

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

AV_RL32

uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_RL32

Definition: bytestream.h:92

#define U(x)

Definition: vpx_arith.h:37

av_frame_replace

int av_frame_replace(AVFrame *dst, const AVFrame *src)

Ensure the destination frame refers to the same data described by the source frame,...

Definition: frame.c:376

AVCodecContext

main external API structure.

Definition: avcodec.h:431

tgv_decode_end

static av_cold int tgv_decode_end(AVCodecContext *avctx)

Definition: eatgv.c:349

AV_PICTURE_TYPE_P

@ AV_PICTURE_TYPE_P

Predicted.

Definition: avutil.h:279

AVMEDIA_TYPE_VIDEO

@ AVMEDIA_TYPE_VIDEO

Definition: avutil.h:200

mem.h

TgvContext::mv_codebook

int(* mv_codebook)[2]

Definition: eatgv.c:49

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

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

width

#define width

Definition: dsp.h:89

AV_RB24

uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_WL16 uint64_t_TMPL AV_WB64 unsigned int_TMPL AV_WB32 unsigned int_TMPL AV_RB24

Definition: bytestream.h:97

src

#define src

Definition: vp8dsp.c:248

TgvContext

Definition: eatgv.c:42

AV_RB16

uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_WL16 uint64_t_TMPL AV_WB64 unsigned int_TMPL AV_WB32 unsigned int_TMPL AV_WB24 unsigned int_TMPL AV_RB16

Definition: bytestream.h:98

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