1 #ifndef AVIF_H
2 #define AVIF_H
3 
4 #include <cstdarg>
5 #include <cstddef>
6 #include <cstdint>
7 #include <cstdlib>
8 #include <ostream>
9 #include <new>
10 
11 template <typename T>
12 using Box = T*;
13 namespace crabbyavif {
14 struct avifImage;
15 struct avifIO;
16 }
17 
18 
19 namespace crabbyavif {
20 
21 constexpr static const uint32_t CRABBY_AVIF_DEFAULT_IMAGE_SIZE_LIMIT = (16384 * 16384);
22 
23 constexpr static const uint32_t CRABBY_AVIF_DEFAULT_IMAGE_DIMENSION_LIMIT = 32768;
24 
25 constexpr static const uint32_t CRABBY_AVIF_DEFAULT_IMAGE_COUNT_LIMIT = ((12 * 3600) * 60);
26 
27 constexpr static const size_t CRABBY_AVIF_MAX_AV1_LAYER_COUNT = 4;
28 
29 constexpr static const int CRABBY_AVIF_TRUE = 1;
30 
31 constexpr static const int CRABBY_AVIF_FALSE = 0;
32 
33 constexpr static const uint32_t AVIF_STRICT_DISABLED = 0;
34 
35 constexpr static const uint32_t AVIF_STRICT_PIXI_REQUIRED = (1 << 0);
36 
37 constexpr static const uint32_t AVIF_STRICT_CLAP_VALID = (1 << 1);
38 
39 constexpr static const uint32_t AVIF_STRICT_ALPHA_ISPE_REQUIRED = (1 << 2);
40 
41 constexpr static const uint32_t AVIF_STRICT_ENABLED = ((AVIF_STRICT_PIXI_REQUIRED | AVIF_STRICT_CLAP_VALID) | AVIF_STRICT_ALPHA_ISPE_REQUIRED);
42 
43 constexpr static const uint32_t AVIF_IMAGE_CONTENT_NONE = 0;
44 
45 constexpr static const uint32_t AVIF_IMAGE_CONTENT_COLOR_AND_ALPHA = ((1 << 0) | (1 << 1));
46 
47 constexpr static const uint32_t AVIF_IMAGE_CONTENT_GAIN_MAP = (1 << 2);
48 
49 constexpr static const uint32_t AVIF_IMAGE_CONTENT_ALL = (AVIF_IMAGE_CONTENT_COLOR_AND_ALPHA | AVIF_IMAGE_CONTENT_GAIN_MAP);
50 
51 constexpr static const size_t CRABBY_AVIF_DIAGNOSTICS_ERROR_BUFFER_SIZE = 256;
52 
53 constexpr static const size_t CRABBY_AVIF_PLANE_COUNT_YUV = 3;
54 
55 constexpr static const int32_t CRABBY_AVIF_REPETITION_COUNT_INFINITE = -1;
56 
57 constexpr static const int32_t CRABBY_AVIF_REPETITION_COUNT_UNKNOWN = -2;
58 
59 constexpr static const uint32_t AVIF_TRANSFORM_NONE = 0;
60 
61 constexpr static const uint32_t AVIF_TRANSFORM_PASP = (1 << 0);
62 
63 constexpr static const uint32_t AVIF_TRANSFORM_CLAP = (1 << 1);
64 
65 constexpr static const uint32_t AVIF_TRANSFORM_IROT = (1 << 2);
66 
67 constexpr static const uint32_t AVIF_TRANSFORM_IMIR = (1 << 3);
68 
69 constexpr static const uint32_t AVIF_COLOR_PRIMARIES_BT709 = 1;
70 
71 constexpr static const uint32_t AVIF_COLOR_PRIMARIES_IEC61966_2_4 = 1;
72 
73 constexpr static const uint32_t AVIF_COLOR_PRIMARIES_BT2100 = 9;
74 
75 constexpr static const uint32_t AVIF_COLOR_PRIMARIES_DCI_P3 = 12;
76 
77 constexpr static const uint32_t AVIF_TRANSFER_CHARACTERISTICS_SMPTE2084 = 16;
78 
79 enum AndroidMediaCodecOutputColorFormat : int32_t {
80     ANDROID_MEDIA_CODEC_OUTPUT_COLOR_FORMAT_YUV420_FLEXIBLE = 2135033992,
81     ANDROID_MEDIA_CODEC_OUTPUT_COLOR_FORMAT_P010 = 54,
82 };
83 
84 enum avifChromaDownsampling {
85     AVIF_CHROMA_DOWNSAMPLING_AUTOMATIC,
86     AVIF_CHROMA_DOWNSAMPLING_FASTEST,
87     AVIF_CHROMA_DOWNSAMPLING_BEST_QUALITY,
88     AVIF_CHROMA_DOWNSAMPLING_AVERAGE,
89     AVIF_CHROMA_DOWNSAMPLING_SHARP_YUV,
90 };
91 
92 enum avifChromaSamplePosition {
93     AVIF_CHROMA_SAMPLE_POSITION_UNKNOWN = 0,
94     AVIF_CHROMA_SAMPLE_POSITION_VERTICAL = 1,
95     AVIF_CHROMA_SAMPLE_POSITION_COLOCATED = 2,
96     AVIF_CHROMA_SAMPLE_POSITION_RESERVED = 3,
97 };
98 
99 enum avifChromaUpsampling {
100     AVIF_CHROMA_UPSAMPLING_AUTOMATIC,
101     AVIF_CHROMA_UPSAMPLING_FASTEST,
102     AVIF_CHROMA_UPSAMPLING_BEST_QUALITY,
103     AVIF_CHROMA_UPSAMPLING_NEAREST,
104     AVIF_CHROMA_UPSAMPLING_BILINEAR,
105 };
106 
107 enum avifColorPrimaries : uint16_t {
108     AVIF_COLOR_PRIMARIES_UNKNOWN = 0,
109     AVIF_COLOR_PRIMARIES_SRGB = 1,
110     AVIF_COLOR_PRIMARIES_UNSPECIFIED = 2,
111     AVIF_COLOR_PRIMARIES_BT470M = 4,
112     AVIF_COLOR_PRIMARIES_BT470BG = 5,
113     AVIF_COLOR_PRIMARIES_BT601 = 6,
114     AVIF_COLOR_PRIMARIES_SMPTE240 = 7,
115     AVIF_COLOR_PRIMARIES_GENERIC_FILM = 8,
116     AVIF_COLOR_PRIMARIES_BT2020 = 9,
117     AVIF_COLOR_PRIMARIES_XYZ = 10,
118     AVIF_COLOR_PRIMARIES_SMPTE431 = 11,
119     AVIF_COLOR_PRIMARIES_SMPTE432 = 12,
120     AVIF_COLOR_PRIMARIES_EBU3213 = 22,
121 };
122 
123 enum CompressionFormat {
124     COMPRESSION_FORMAT_AVIF = 0,
125     COMPRESSION_FORMAT_HEIC = 1,
126 };
127 
128 enum avifRGBFormat {
129     AVIF_RGB_FORMAT_RGB,
130     AVIF_RGB_FORMAT_RGBA,
131     AVIF_RGB_FORMAT_ARGB,
132     AVIF_RGB_FORMAT_BGR,
133     AVIF_RGB_FORMAT_BGRA,
134     AVIF_RGB_FORMAT_ABGR,
135     AVIF_RGB_FORMAT_RGB565,
136     AVIF_RGB_FORMAT_RGBA1010102,
137 };
138 
139 enum avifMatrixCoefficients : uint16_t {
140     AVIF_MATRIX_COEFFICIENTS_IDENTITY = 0,
141     AVIF_MATRIX_COEFFICIENTS_BT709 = 1,
142     AVIF_MATRIX_COEFFICIENTS_UNSPECIFIED = 2,
143     AVIF_MATRIX_COEFFICIENTS_RESERVED = 3,
144     AVIF_MATRIX_COEFFICIENTS_FCC = 4,
145     AVIF_MATRIX_COEFFICIENTS_BT470BG = 5,
146     AVIF_MATRIX_COEFFICIENTS_BT601 = 6,
147     AVIF_MATRIX_COEFFICIENTS_SMPTE240 = 7,
148     AVIF_MATRIX_COEFFICIENTS_YCGCO = 8,
149     AVIF_MATRIX_COEFFICIENTS_BT2020_NCL = 9,
150     AVIF_MATRIX_COEFFICIENTS_BT2020_CL = 10,
151     AVIF_MATRIX_COEFFICIENTS_SMPTE2085 = 11,
152     AVIF_MATRIX_COEFFICIENTS_CHROMA_DERIVED_NCL = 12,
153     AVIF_MATRIX_COEFFICIENTS_CHROMA_DERIVED_CL = 13,
154     AVIF_MATRIX_COEFFICIENTS_ICTCP = 14,
155     AVIF_MATRIX_COEFFICIENTS_YCGCO_RE = 16,
156     AVIF_MATRIX_COEFFICIENTS_YCGCO_RO = 17,
157 };
158 
159 enum avifPixelFormat {
160     AVIF_PIXEL_FORMAT_NONE = 0,
161     AVIF_PIXEL_FORMAT_YUV444 = 1,
162     AVIF_PIXEL_FORMAT_YUV422 = 2,
163     AVIF_PIXEL_FORMAT_YUV420 = 3,
164     AVIF_PIXEL_FORMAT_YUV400 = 4,
165     AVIF_PIXEL_FORMAT_ANDROID_P010 = 5,
166     AVIF_PIXEL_FORMAT_ANDROID_NV12 = 6,
167     AVIF_PIXEL_FORMAT_ANDROID_NV21 = 7,
168     AVIF_PIXEL_FORMAT_COUNT,
169 };
170 
171 enum avifProgressiveState {
172     AVIF_PROGRESSIVE_STATE_UNAVAILABLE = 0,
173     AVIF_PROGRESSIVE_STATE_AVAILABLE = 1,
174     AVIF_PROGRESSIVE_STATE_ACTIVE = 2,
175 };
176 
177 enum avifDecoderSource {
178     AVIF_DECODER_SOURCE_AUTO = 0,
179     AVIF_DECODER_SOURCE_PRIMARY_ITEM = 1,
180     AVIF_DECODER_SOURCE_TRACKS = 2,
181 };
182 
183 enum avifTransferCharacteristics : uint16_t {
184     AVIF_TRANSFER_CHARACTERISTICS_UNKNOWN = 0,
185     AVIF_TRANSFER_CHARACTERISTICS_BT709 = 1,
186     AVIF_TRANSFER_CHARACTERISTICS_UNSPECIFIED = 2,
187     AVIF_TRANSFER_CHARACTERISTICS_RESERVED = 3,
188     AVIF_TRANSFER_CHARACTERISTICS_BT470M = 4,
189     AVIF_TRANSFER_CHARACTERISTICS_BT470BG = 5,
190     AVIF_TRANSFER_CHARACTERISTICS_BT601 = 6,
191     AVIF_TRANSFER_CHARACTERISTICS_SMPTE240 = 7,
192     AVIF_TRANSFER_CHARACTERISTICS_LINEAR = 8,
193     AVIF_TRANSFER_CHARACTERISTICS_LOG100 = 9,
194     AVIF_TRANSFER_CHARACTERISTICS_LOG100_SQRT10 = 10,
195     AVIF_TRANSFER_CHARACTERISTICS_IEC61966 = 11,
196     AVIF_TRANSFER_CHARACTERISTICS_BT1361 = 12,
197     AVIF_TRANSFER_CHARACTERISTICS_SRGB = 13,
198     AVIF_TRANSFER_CHARACTERISTICS_BT2020_10BIT = 14,
199     AVIF_TRANSFER_CHARACTERISTICS_BT2020_12BIT = 15,
200     AVIF_TRANSFER_CHARACTERISTICS_PQ = 16,
201     AVIF_TRANSFER_CHARACTERISTICS_SMPTE428 = 17,
202     AVIF_TRANSFER_CHARACTERISTICS_HLG = 18,
203 };
204 
205 enum avifRange {
206     AVIF_RANGE_LIMITED = 0,
207     AVIF_RANGE_FULL = 1,
208 };
209 
210 enum avifChannelIndex {
211     AVIF_CHAN_Y = 0,
212     AVIF_CHAN_U = 1,
213     AVIF_CHAN_V = 2,
214     AVIF_CHAN_A = 3,
215 };
216 
217 enum avifCodecChoice {
218     AVIF_CODEC_CHOICE_AUTO = 0,
219     AVIF_CODEC_CHOICE_AOM = 1,
220     AVIF_CODEC_CHOICE_DAV1D = 2,
221     AVIF_CODEC_CHOICE_LIBGAV1 = 3,
222     AVIF_CODEC_CHOICE_RAV1E = 4,
223     AVIF_CODEC_CHOICE_SVT = 5,
224     AVIF_CODEC_CHOICE_AVM = 6,
225 };
226 
227 enum avifCodecFlag {
228     AVIF_CODEC_FLAG_CAN_DECODE = (1 << 0),
229     AVIF_CODEC_FLAG_CAN_ENCODE = (1 << 1),
230 };
231 
232 enum avifHeaderFormat {
233     AVIF_HEADER_FULL,
234     AVIF_HEADER_REDUCED,
235 };
236 
237 enum avifPlanesFlag {
238     AVIF_PLANES_YUV = (1 << 0),
239     AVIF_PLANES_A = (1 << 1),
240     AVIF_PLANES_ALL = 255,
241 };
242 
243 enum avifResult {
244     AVIF_RESULT_OK = 0,
245     AVIF_RESULT_UNKNOWN_ERROR = 1,
246     AVIF_RESULT_INVALID_FTYP = 2,
247     AVIF_RESULT_NO_CONTENT = 3,
248     AVIF_RESULT_NO_YUV_FORMAT_SELECTED = 4,
249     AVIF_RESULT_REFORMAT_FAILED = 5,
250     AVIF_RESULT_UNSUPPORTED_DEPTH = 6,
251     AVIF_RESULT_ENCODE_COLOR_FAILED = 7,
252     AVIF_RESULT_ENCODE_ALPHA_FAILED = 8,
253     AVIF_RESULT_BMFF_PARSE_FAILED = 9,
254     AVIF_RESULT_MISSING_IMAGE_ITEM = 10,
255     AVIF_RESULT_DECODE_COLOR_FAILED = 11,
256     AVIF_RESULT_DECODE_ALPHA_FAILED = 12,
257     AVIF_RESULT_COLOR_ALPHA_SIZE_MISMATCH = 13,
258     AVIF_RESULT_ISPE_SIZE_MISMATCH = 14,
259     AVIF_RESULT_NO_CODEC_AVAILABLE = 15,
260     AVIF_RESULT_NO_IMAGES_REMAINING = 16,
261     AVIF_RESULT_INVALID_EXIF_PAYLOAD = 17,
262     AVIF_RESULT_INVALID_IMAGE_GRID = 18,
263     AVIF_RESULT_INVALID_CODEC_SPECIFIC_OPTION = 19,
264     AVIF_RESULT_TRUNCATED_DATA = 20,
265     AVIF_RESULT_IO_NOT_SET = 21,
266     AVIF_RESULT_IO_ERROR = 22,
267     AVIF_RESULT_WAITING_ON_IO = 23,
268     AVIF_RESULT_INVALID_ARGUMENT = 24,
269     AVIF_RESULT_NOT_IMPLEMENTED = 25,
270     AVIF_RESULT_OUT_OF_MEMORY = 26,
271     AVIF_RESULT_CANNOT_CHANGE_SETTING = 27,
272     AVIF_RESULT_INCOMPATIBLE_IMAGE = 28,
273     AVIF_RESULT_ENCODE_GAIN_MAP_FAILED = 29,
274     AVIF_RESULT_DECODE_GAIN_MAP_FAILED = 30,
275     AVIF_RESULT_INVALID_TONE_MAPPED_IMAGE = 31,
276 };
277 
278 struct Decoder;
279 
280 using avifBool = int;
281 
282 using avifStrictFlags = uint32_t;
283 
284 struct avifRWData {
285     uint8_t *data;
286     size_t size;
287 };
288 
289 struct ContentLightLevelInformation {
290     uint16_t maxCLL;
291     uint16_t maxPALL;
292 };
293 
294 using avifContentLightLevelInformationBox = ContentLightLevelInformation;
295 
296 using avifTransformFlags = uint32_t;
297 
298 struct PixelAspectRatio {
299     uint32_t hSpacing;
300     uint32_t vSpacing;
301 };
302 
303 using avifPixelAspectRatioBox = PixelAspectRatio;
304 
305 struct avifCleanApertureBox {
306     uint32_t widthN;
307     uint32_t widthD;
308     uint32_t heightN;
309     uint32_t heightD;
310     uint32_t horizOffN;
311     uint32_t horizOffD;
312     uint32_t vertOffN;
313     uint32_t vertOffD;
314 };
315 
316 struct avifImageRotation {
317     uint8_t angle;
318 };
319 
320 struct avifImageMirror {
321     uint8_t axis;
322 };
323 
324 struct Fraction {
325     int32_t n;
326     uint32_t d;
327 };
328 
329 using avifSignedFraction = Fraction;
330 
331 struct UFraction {
332     uint32_t n;
333     uint32_t d;
334 };
335 
336 using avifUnsignedFraction = UFraction;
337 
338 struct avifGainMap {
339     avifImage *image;
340     avifSignedFraction gainMapMin[3];
341     avifSignedFraction gainMapMax[3];
342     avifUnsignedFraction gainMapGamma[3];
343     avifSignedFraction baseOffset[3];
344     avifSignedFraction alternateOffset[3];
345     avifUnsignedFraction baseHdrHeadroom;
346     avifUnsignedFraction alternateHdrHeadroom;
347     avifBool useBaseColorSpace;
348     avifRWData altICC;
349     avifColorPrimaries altColorPrimaries;
350     avifTransferCharacteristics altTransferCharacteristics;
351     avifMatrixCoefficients altMatrixCoefficients;
352     avifRange altYUVRange;
353     uint32_t altDepth;
354     uint32_t altPlaneCount;
355     avifContentLightLevelInformationBox altCLLI;
356 };
357 
358 struct avifImage {
359     uint32_t width;
360     uint32_t height;
361     uint32_t depth;
362     avifPixelFormat yuvFormat;
363     avifRange yuvRange;
364     avifChromaSamplePosition yuvChromaSamplePosition;
365     uint8_t *yuvPlanes[CRABBY_AVIF_PLANE_COUNT_YUV];
366     uint32_t yuvRowBytes[CRABBY_AVIF_PLANE_COUNT_YUV];
367     avifBool imageOwnsYUVPlanes;
368     uint8_t *alphaPlane;
369     uint32_t alphaRowBytes;
370     avifBool imageOwnsAlphaPlane;
371     avifBool alphaPremultiplied;
372     avifRWData icc;
373     avifColorPrimaries colorPrimaries;
374     avifTransferCharacteristics transferCharacteristics;
375     avifMatrixCoefficients matrixCoefficients;
376     avifContentLightLevelInformationBox clli;
377     avifTransformFlags transformFlags;
378     avifPixelAspectRatioBox pasp;
379     avifCleanApertureBox clap;
380     avifImageRotation irot;
381     avifImageMirror imir;
382     avifRWData exif;
383     avifRWData xmp;
384     avifGainMap *gainMap;
385 };
386 
387 struct avifImageTiming {
388     uint64_t timescale;
389     double pts;
390     uint64_t ptsInTimescales;
391     double duration;
392     uint64_t durationInTimescales;
393 };
394 
395 struct avifIOStats {
396     size_t colorOBUSize;
397     size_t alphaOBUSize;
398 };
399 
400 struct avifDiagnostics {
401     char error[CRABBY_AVIF_DIAGNOSTICS_ERROR_BUFFER_SIZE];
402 };
403 
404 struct avifDecoderData {
405 
406 };
407 
408 using avifImageContentTypeFlags = uint32_t;
409 
410 struct avifDecoder {
411     avifCodecChoice codecChoice;
412     int32_t maxThreads;
413     avifDecoderSource requestedSource;
414     avifBool allowProgressive;
415     avifBool allowIncremental;
416     avifBool ignoreExif;
417     avifBool ignoreXMP;
418     uint32_t imageSizeLimit;
419     uint32_t imageDimensionLimit;
420     uint32_t imageCountLimit;
421     avifStrictFlags strictFlags;
422     avifImage *image;
423     int32_t imageIndex;
424     int32_t imageCount;
425     avifProgressiveState progressiveState;
426     avifImageTiming imageTiming;
427     uint64_t timescale;
428     double duration;
429     uint64_t durationInTimescales;
430     int32_t repetitionCount;
431     avifBool alphaPresent;
432     avifIOStats ioStats;
433     avifDiagnostics diag;
434     avifDecoderData *data;
435     avifImageContentTypeFlags imageContentToDecode;
436     avifBool imageSequenceTrackPresent;
437     AndroidMediaCodecOutputColorFormat androidMediaCodecOutputColorFormat;
438     CompressionFormat compressionFormat;
439     Box<Decoder> rust_decoder;
440     avifImage image_object;
441     avifGainMap gainmap_object;
442     avifImage gainmap_image_object;
443 };
444 
445 using avifIODestroyFunc = void(*)(avifIO *io);
446 
447 struct avifROData {
448     const uint8_t *data;
449     size_t size;
450 };
451 
452 using avifIOReadFunc = avifResult(*)(avifIO *io,
453                                      uint32_t readFlags,
454                                      uint64_t offset,
455                                      size_t size,
456                                      avifROData *out);
457 
458 using avifIOWriteFunc = avifResult(*)(avifIO *io,
459                                       uint32_t writeFlags,
460                                       uint64_t offset,
461                                       const uint8_t *data,
462                                       size_t size);
463 
464 struct avifIO {
465     avifIODestroyFunc destroy;
466     avifIOReadFunc read;
467     avifIOWriteFunc write;
468     uint64_t sizeHint;
469     avifBool persistent;
470     void *data;
471 };
472 
473 struct Extent {
474     uint64_t offset;
475     size_t size;
476 };
477 
478 using avifExtent = Extent;
479 
480 using avifPlanesFlags = uint32_t;
481 
482 struct CropRect {
483     uint32_t x;
484     uint32_t y;
485     uint32_t width;
486     uint32_t height;
487 };
488 
489 using avifCropRect = CropRect;
490 
491 struct avifRGBImage {
492     uint32_t width;
493     uint32_t height;
494     uint32_t depth;
495     avifRGBFormat format;
496     avifChromaUpsampling chromaUpsampling;
497     avifChromaDownsampling chromaDownsampling;
498     bool ignoreAlpha;
499     bool alphaPremultiplied;
500     bool isFloat;
501     int32_t maxThreads;
502     uint8_t *pixels;
503     uint32_t rowBytes;
504 };
505 
506 struct avifPixelFormatInfo {
507     avifBool monochrome;
508     int chromaShiftX;
509     int chromaShiftY;
510 };
511 
512 using avifCodecFlags = uint32_t;
513 
514 
515 
516 
517 
518 
519 
520 
521 
522 
523 
524 extern "C" {
525 
526 avifDecoder *crabby_avifDecoderCreate();
527 
528 void crabby_avifDecoderSetIO(avifDecoder *decoder, avifIO *io);
529 
530 avifResult crabby_avifDecoderSetIOFile(avifDecoder *decoder, const char *filename);
531 
532 avifResult crabby_avifDecoderSetIOMemory(avifDecoder *decoder, const uint8_t *data, size_t size);
533 
534 avifResult crabby_avifDecoderSetSource(avifDecoder *decoder, avifDecoderSource source);
535 
536 avifResult crabby_avifDecoderParse(avifDecoder *decoder);
537 
538 avifResult crabby_avifDecoderNextImage(avifDecoder *decoder);
539 
540 avifResult crabby_avifDecoderNthImage(avifDecoder *decoder, uint32_t frameIndex);
541 
542 avifResult crabby_avifDecoderNthImageTiming(const avifDecoder *decoder,
543                                             uint32_t frameIndex,
544                                             avifImageTiming *outTiming);
545 
546 void crabby_avifDecoderDestroy(avifDecoder *decoder);
547 
548 avifResult crabby_avifDecoderRead(avifDecoder *decoder, avifImage *image);
549 
550 avifResult crabby_avifDecoderReadMemory(avifDecoder *decoder,
551                                         avifImage *image,
552                                         const uint8_t *data,
553                                         size_t size);
554 
555 avifResult crabby_avifDecoderReadFile(avifDecoder *decoder, avifImage *image, const char *filename);
556 
557 avifBool crabby_avifDecoderIsKeyframe(const avifDecoder *decoder, uint32_t frameIndex);
558 
559 uint32_t crabby_avifDecoderNearestKeyframe(const avifDecoder *decoder, uint32_t frameIndex);
560 
561 uint32_t crabby_avifDecoderDecodedRowCount(const avifDecoder *decoder);
562 
563 avifResult crabby_avifDecoderNthImageMaxExtent(const avifDecoder *decoder,
564                                                uint32_t frameIndex,
565                                                avifExtent *outExtent);
566 
567 avifBool crabby_avifPeekCompatibleFileType(const avifROData *input);
568 
569 avifImage *crabby_avifImageCreateEmpty();
570 
571 avifImage *crabby_avifImageCreate(uint32_t width,
572                                   uint32_t height,
573                                   uint32_t depth,
574                                   avifPixelFormat yuvFormat);
575 
576 avifResult crabby_avifImageCopy(avifImage *dstImage,
577                                 const avifImage *srcImage,
578                                 avifPlanesFlags planes);
579 
580 avifResult crabby_avifImageAllocatePlanes(avifImage *image, avifPlanesFlags planes);
581 
582 void crabby_avifImageFreePlanes(avifImage *image, avifPlanesFlags planes);
583 
584 void crabby_avifImageDestroy(avifImage *image);
585 
586 avifBool crabby_avifImageUsesU16(const avifImage *image);
587 
588 avifBool crabby_avifImageIsOpaque(const avifImage *image);
589 
590 uint8_t *crabby_avifImagePlane(const avifImage *image, int channel);
591 
592 uint32_t crabby_avifImagePlaneRowBytes(const avifImage *image, int channel);
593 
594 uint32_t crabby_avifImagePlaneWidth(const avifImage *image, int channel);
595 
596 uint32_t crabby_avifImagePlaneHeight(const avifImage *image, int channel);
597 
598 avifResult crabby_avifImageSetViewRect(avifImage *dstImage,
599                                        const avifImage *srcImage,
600                                        const avifCropRect *rect);
601 
602 avifResult crabby_avifRWDataRealloc(avifRWData *raw, size_t newSize);
603 
604 avifResult crabby_avifRWDataSet(avifRWData *raw, const uint8_t *data, size_t size);
605 
606 void crabby_avifRWDataFree(avifRWData *raw);
607 
608 void cioDestroy(avifIO *_io);
609 
610 avifResult cioRead(avifIO *io, uint32_t _readFlags, uint64_t offset, size_t size, avifROData *out);
611 
612 avifResult cioWrite(avifIO *_io,
613                     uint32_t _writeFlags,
614                     uint64_t _offset,
615                     const uint8_t *_data,
616                     size_t _size);
617 
618 avifIO *crabby_avifIOCreateMemoryReader(const uint8_t *data, size_t size);
619 
620 avifIO *crabby_avifIOCreateFileReader(const char *filename);
621 
622 void crabby_avifIODestroy(avifIO *io);
623 
624 void crabby_avifRGBImageSetDefaults(avifRGBImage *rgb, const avifImage *image);
625 
626 avifResult crabby_avifImageYUVToRGB(const avifImage *image, avifRGBImage *rgb);
627 
628 avifResult crabby_avifImageScale(avifImage *image,
629                                  uint32_t dstWidth,
630                                  uint32_t dstHeight,
631                                  avifDiagnostics *_diag);
632 
633 const char *crabby_avifResultToString(avifResult res);
634 
635 avifBool crabby_avifCropRectConvertCleanApertureBox(avifCropRect *cropRect,
636                                                     const avifCleanApertureBox *clap,
637                                                     uint32_t imageW,
638                                                     uint32_t imageH,
639                                                     avifPixelFormat yuvFormat,
640                                                     avifDiagnostics *_diag);
641 
642 void crabby_avifGetPixelFormatInfo(avifPixelFormat format, avifPixelFormatInfo *info);
643 
644 void crabby_avifDiagnosticsClearError(avifDiagnostics *diag);
645 
646 void *crabby_avifAlloc(size_t size);
647 
648 void crabby_avifFree(void *p);
649 
650 } // extern "C"
651 
652 } // namespace crabbyavif
653 
654 #endif // AVIF_H
655