FFmpeg
hapenc.c
Go to the documentation of this file.
1 /*
2  * Vidvox Hap encoder
3  * Copyright (C) 2015 Vittorio Giovara <vittorio.giovara@gmail.com>
4  * Copyright (C) 2015 Tom Butterworth <bangnoise@gmail.com>
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  */
22 
23 /**
24  * @file
25  * Hap encoder
26  *
27  * Fourcc: Hap1, Hap5, HapY
28  *
29  * https://github.com/Vidvox/hap/blob/master/documentation/HapVideoDRAFT.md
30  */
31 
32 #include <stdint.h>
33 #include "snappy-c.h"
34 
35 #include "libavutil/frame.h"
36 #include "libavutil/imgutils.h"
37 #include "libavutil/intreadwrite.h"
38 #include "libavutil/opt.h"
39 
40 #include "avcodec.h"
41 #include "bytestream.h"
42 #include "codec_internal.h"
43 #include "encode.h"
44 #include "hap.h"
45 #include "texturedsp.h"
46 
47 #define HAP_MAX_CHUNKS 64
48 
50  /* Short header: four bytes with a 24 bit size value */
52  /* Long header: eight bytes with a 32 bit size value */
54 };
55 
56 static int compress_texture(AVCodecContext *avctx, uint8_t *out, int out_length, const AVFrame *f)
57 {
58  HapContext *ctx = avctx->priv_data;
59 
60  if (ctx->tex_size > out_length)
62 
63  ctx->enc.tex_data.out = out;
64  ctx->enc.frame_data.in = f->data[0];
65  ctx->enc.stride = f->linesize[0];
66  avctx->execute2(avctx, ff_texturedsp_compress_thread, &ctx->enc, NULL, ctx->enc.slice_count);
67 
68  return 0;
69 }
70 
71 /* section_length does not include the header */
73  enum HapHeaderLength header_length,
74  int section_length,
75  enum HapSectionType section_type)
76 {
77  /* The first three bytes are the length of the section (not including the
78  * header) or zero if using an eight-byte header.
79  * For an eight-byte header, the length is in the last four bytes.
80  * The fourth byte stores the section type. */
81  bytestream2_put_le24(pbc, header_length == HAP_HDR_LONG ? 0 : section_length);
82  bytestream2_put_byte(pbc, section_type);
83 
84  if (header_length == HAP_HDR_LONG) {
85  bytestream2_put_le32(pbc, section_length);
86  }
87 }
88 
89 static int hap_compress_frame(AVCodecContext *avctx, uint8_t *dst)
90 {
91  HapContext *ctx = avctx->priv_data;
92  int i, final_size = 0;
93 
94  for (i = 0; i < ctx->chunk_count; i++) {
95  HapChunk *chunk = &ctx->chunks[i];
96  uint8_t *chunk_src, *chunk_dst;
97  int ret;
98 
99  if (i == 0) {
100  chunk->compressed_offset = 0;
101  } else {
102  chunk->compressed_offset = ctx->chunks[i-1].compressed_offset
103  + ctx->chunks[i-1].compressed_size;
104  }
105  chunk->uncompressed_size = ctx->tex_size / ctx->chunk_count;
106  chunk->uncompressed_offset = i * chunk->uncompressed_size;
107  chunk->compressed_size = ctx->max_snappy;
108  chunk_src = ctx->tex_buf + chunk->uncompressed_offset;
109  chunk_dst = dst + chunk->compressed_offset;
110 
111  /* Compress with snappy too, write directly on packet buffer. */
112  ret = snappy_compress(chunk_src, chunk->uncompressed_size,
113  chunk_dst, &chunk->compressed_size);
114  if (ret != SNAPPY_OK) {
115  av_log(avctx, AV_LOG_ERROR, "Snappy compress error.\n");
116  return AVERROR_BUG;
117  }
118 
119  /* If there is no gain from snappy, just use the raw texture. */
120  if (chunk->compressed_size >= chunk->uncompressed_size) {
121  av_log(avctx, AV_LOG_VERBOSE,
122  "Snappy buffer bigger than uncompressed (%"SIZE_SPECIFIER" >= %"SIZE_SPECIFIER" bytes).\n",
123  chunk->compressed_size, chunk->uncompressed_size);
124  memcpy(chunk_dst, chunk_src, chunk->uncompressed_size);
125  chunk->compressor = HAP_COMP_NONE;
126  chunk->compressed_size = chunk->uncompressed_size;
127  } else {
128  chunk->compressor = HAP_COMP_SNAPPY;
129  }
130 
131  final_size += chunk->compressed_size;
132  }
133 
134  return final_size;
135 }
136 
138 {
139  /* Second-Stage Compressor Table (one byte per entry)
140  * + Chunk Size Table (four bytes per entry)
141  * + headers for both sections (short versions)
142  * = chunk_count + (4 * chunk_count) + 4 + 4 */
143  return (5 * ctx->chunk_count) + 8;
144 }
145 
147 {
148  /* Top section header (long version) */
149  int length = HAP_HDR_LONG;
150 
151  if (ctx->chunk_count > 1) {
152  /* Decode Instructions header (short) + Decode Instructions Container */
154  }
155 
156  return length;
157 }
158 
159 static void hap_write_frame_header(HapContext *ctx, uint8_t *dst, int frame_length)
160 {
161  PutByteContext pbc;
162  int i;
163 
164  bytestream2_init_writer(&pbc, dst, frame_length);
165  if (ctx->chunk_count == 1) {
166  /* Write a simple header */
167  hap_write_section_header(&pbc, HAP_HDR_LONG, frame_length - 8,
168  ctx->chunks[0].compressor | ctx->opt_tex_fmt);
169  } else {
170  /* Write a complex header with Decode Instructions Container */
171  hap_write_section_header(&pbc, HAP_HDR_LONG, frame_length - 8,
172  HAP_COMP_COMPLEX | ctx->opt_tex_fmt);
175  hap_write_section_header(&pbc, HAP_HDR_SHORT, ctx->chunk_count,
177 
178  for (i = 0; i < ctx->chunk_count; i++) {
179  bytestream2_put_byte(&pbc, ctx->chunks[i].compressor >> 4);
180  }
181 
182  hap_write_section_header(&pbc, HAP_HDR_SHORT, ctx->chunk_count * 4,
184 
185  for (i = 0; i < ctx->chunk_count; i++) {
186  bytestream2_put_le32(&pbc, ctx->chunks[i].compressed_size);
187  }
188  }
189 }
190 
191 static int hap_encode(AVCodecContext *avctx, AVPacket *pkt,
192  const AVFrame *frame, int *got_packet)
193 {
194  HapContext *ctx = avctx->priv_data;
195  int header_length = hap_header_length(ctx);
196  int final_data_size, ret;
197  int pktsize = FFMAX(ctx->tex_size, ctx->max_snappy * ctx->chunk_count) + header_length;
198 
199  /* Allocate maximum size packet, shrink later. */
200  ret = ff_alloc_packet(avctx, pkt, pktsize);
201  if (ret < 0)
202  return ret;
203 
204  if (ctx->opt_compressor == HAP_COMP_NONE) {
205  /* DXTC compression directly to the packet buffer. */
206  ret = compress_texture(avctx, pkt->data + header_length, pkt->size - header_length, frame);
207  if (ret < 0)
208  return ret;
209 
210  ctx->chunks[0].compressor = HAP_COMP_NONE;
211  final_data_size = ctx->tex_size;
212  } else {
213  /* DXTC compression. */
214  ret = compress_texture(avctx, ctx->tex_buf, ctx->tex_size, frame);
215  if (ret < 0)
216  return ret;
217 
218  /* Compress (using Snappy) the frame */
219  final_data_size = hap_compress_frame(avctx, pkt->data + header_length);
220  if (final_data_size < 0)
221  return final_data_size;
222  }
223 
224  /* Write header at the start. */
225  hap_write_frame_header(ctx, pkt->data, final_data_size + header_length);
226 
227  av_shrink_packet(pkt, final_data_size + header_length);
228  *got_packet = 1;
229  return 0;
230 }
231 
232 static av_cold int hap_init(AVCodecContext *avctx)
233 {
234  HapContext *ctx = avctx->priv_data;
235  int corrected_chunk_count;
236  int ret = av_image_check_size(avctx->width, avctx->height, 0, avctx);
237 
238  if (ret < 0) {
239  av_log(avctx, AV_LOG_ERROR, "Invalid video size %dx%d.\n",
240  avctx->width, avctx->height);
241  return ret;
242  }
243 
244  if (avctx->width % 4 || avctx->height % 4) {
245  av_log(avctx, AV_LOG_ERROR, "Video size %dx%d is not multiple of 4.\n",
246  avctx->width, avctx->height);
247  return AVERROR_INVALIDDATA;
248  }
249 
250  ff_texturedspenc_init(&ctx->dxtc);
251 
252  switch (ctx->opt_tex_fmt) {
253  case HAP_FMT_RGBDXT1:
254  ctx->enc.tex_ratio = 8;
255  avctx->codec_tag = MKTAG('H', 'a', 'p', '1');
256  avctx->bits_per_coded_sample = 24;
257  ctx->enc.tex_funct = ctx->dxtc.dxt1_block;
258  break;
259  case HAP_FMT_RGBADXT5:
260  ctx->enc.tex_ratio = 16;
261  avctx->codec_tag = MKTAG('H', 'a', 'p', '5');
262  avctx->bits_per_coded_sample = 32;
263  ctx->enc.tex_funct = ctx->dxtc.dxt5_block;
264  break;
265  case HAP_FMT_YCOCGDXT5:
266  ctx->enc.tex_ratio = 16;
267  avctx->codec_tag = MKTAG('H', 'a', 'p', 'Y');
268  avctx->bits_per_coded_sample = 24;
269  ctx->enc.tex_funct = ctx->dxtc.dxt5ys_block;
270  break;
271  default:
272  av_log(avctx, AV_LOG_ERROR, "Invalid format %02X\n", ctx->opt_tex_fmt);
273  return AVERROR_INVALIDDATA;
274  }
275  ctx->enc.raw_ratio = 16;
276  ctx->enc.slice_count = av_clip(avctx->thread_count, 1, avctx->height / TEXTURE_BLOCK_H);
277 
278  /* Texture compression ratio is constant, so can we computer
279  * beforehand the final size of the uncompressed buffer. */
280  ctx->tex_size = avctx->width / TEXTURE_BLOCK_W *
281  avctx->height / TEXTURE_BLOCK_H * ctx->enc.tex_ratio;
282 
283  switch (ctx->opt_compressor) {
284  case HAP_COMP_NONE:
285  /* No benefit chunking uncompressed data */
286  corrected_chunk_count = 1;
287 
288  ctx->max_snappy = ctx->tex_size;
289  ctx->tex_buf = NULL;
290  break;
291  case HAP_COMP_SNAPPY:
292  /* Round the chunk count to divide evenly on DXT block edges */
293  corrected_chunk_count = av_clip(ctx->opt_chunk_count, 1, HAP_MAX_CHUNKS);
294  while ((ctx->tex_size / ctx->enc.tex_ratio) % corrected_chunk_count != 0) {
295  corrected_chunk_count--;
296  }
297 
298  ctx->max_snappy = snappy_max_compressed_length(ctx->tex_size / corrected_chunk_count);
299  ctx->tex_buf = av_malloc(ctx->tex_size);
300  if (!ctx->tex_buf) {
301  return AVERROR(ENOMEM);
302  }
303  break;
304  default:
305  av_log(avctx, AV_LOG_ERROR, "Invalid compresor %02X\n", ctx->opt_compressor);
306  return AVERROR_INVALIDDATA;
307  }
308  if (corrected_chunk_count != ctx->opt_chunk_count) {
309  av_log(avctx, AV_LOG_INFO, "%d chunks requested but %d used.\n",
310  ctx->opt_chunk_count, corrected_chunk_count);
311  }
312  ret = ff_hap_set_chunk_count(ctx, corrected_chunk_count, 1);
313  if (ret != 0)
314  return ret;
315 
316  return 0;
317 }
318 
319 static av_cold int hap_close(AVCodecContext *avctx)
320 {
321  HapContext *ctx = avctx->priv_data;
322 
324 
325  return 0;
326 }
327 
328 #define OFFSET(x) offsetof(HapContext, x)
329 #define FLAGS AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
330 static const AVOption options[] = {
331  { "format", NULL, OFFSET(opt_tex_fmt), AV_OPT_TYPE_INT, { .i64 = HAP_FMT_RGBDXT1 }, HAP_FMT_RGBDXT1, HAP_FMT_YCOCGDXT5, FLAGS, "format" },
332  { "hap", "Hap 1 (DXT1 textures)", 0, AV_OPT_TYPE_CONST, { .i64 = HAP_FMT_RGBDXT1 }, 0, 0, FLAGS, "format" },
333  { "hap_alpha", "Hap Alpha (DXT5 textures)", 0, AV_OPT_TYPE_CONST, { .i64 = HAP_FMT_RGBADXT5 }, 0, 0, FLAGS, "format" },
334  { "hap_q", "Hap Q (DXT5-YCoCg textures)", 0, AV_OPT_TYPE_CONST, { .i64 = HAP_FMT_YCOCGDXT5 }, 0, 0, FLAGS, "format" },
335  { "chunks", "chunk count", OFFSET(opt_chunk_count), AV_OPT_TYPE_INT, {.i64 = 1 }, 1, HAP_MAX_CHUNKS, FLAGS, },
336  { "compressor", "second-stage compressor", OFFSET(opt_compressor), AV_OPT_TYPE_INT, { .i64 = HAP_COMP_SNAPPY }, HAP_COMP_NONE, HAP_COMP_SNAPPY, FLAGS, "compressor" },
337  { "none", "None", 0, AV_OPT_TYPE_CONST, { .i64 = HAP_COMP_NONE }, 0, 0, FLAGS, "compressor" },
338  { "snappy", "Snappy", 0, AV_OPT_TYPE_CONST, { .i64 = HAP_COMP_SNAPPY }, 0, 0, FLAGS, "compressor" },
339  { NULL },
340 };
341 
342 static const AVClass hapenc_class = {
343  .class_name = "Hap encoder",
344  .item_name = av_default_item_name,
345  .option = options,
346  .version = LIBAVUTIL_VERSION_INT,
347 };
348 
350  .p.name = "hap",
351  CODEC_LONG_NAME("Vidvox Hap"),
352  .p.type = AVMEDIA_TYPE_VIDEO,
353  .p.id = AV_CODEC_ID_HAP,
354  .p.capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_SLICE_THREADS,
355  .priv_data_size = sizeof(HapContext),
356  .p.priv_class = &hapenc_class,
357  .init = hap_init,
359  .close = hap_close,
360  .p.pix_fmts = (const enum AVPixelFormat[]) {
362  },
363  .caps_internal = FF_CODEC_CAP_INIT_CLEANUP,
364 };
AVPixelFormat
AVPixelFormat
Pixel format.
Definition: pixfmt.h:64
HAP_FMT_YCOCGDXT5
@ HAP_FMT_YCOCGDXT5
Definition: hap.h:36
av_clip
#define av_clip
Definition: common.h:95
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
opt.h
TEXTURE_BLOCK_H
#define TEXTURE_BLOCK_H
Definition: texturedsp.h:45
out
FILE * out
Definition: movenc.c:54
OFFSET
#define OFFSET(x)
Definition: hapenc.c:328
HapChunk::compressed_size
size_t compressed_size
Definition: hap.h:56
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:325
AVPacket::data
uint8_t * data
Definition: packet.h:374
AVOption
AVOption.
Definition: opt.h:251
encode.h
FFCodec
Definition: codec_internal.h:119
AV_LOG_VERBOSE
#define AV_LOG_VERBOSE
Detailed information.
Definition: log.h:196
FFMAX
#define FFMAX(a, b)
Definition: macros.h:47
hap_compress_frame
static int hap_compress_frame(AVCodecContext *avctx, uint8_t *dst)
Definition: hapenc.c:89
HapContext
Definition: hap.h:61
hapenc_class
static const AVClass hapenc_class
Definition: hapenc.c:342
av_malloc
#define av_malloc(s)
Definition: tableprint_vlc.h:30
HapHeaderLength
HapHeaderLength
Definition: hapenc.c:49
ff_texturedsp_compress_thread
int ff_texturedsp_compress_thread(AVCodecContext *avctx, void *arg, int slice, int thread_nb)
hap_init
static av_cold int hap_init(AVCodecContext *avctx)
Definition: hapenc.c:232
texturedsp.h
FFCodec::p
AVCodec p
The public AVCodec.
Definition: codec_internal.h:123
AVCodecContext::thread_count
int thread_count
thread count is used to decide how many independent tasks should be passed to execute()
Definition: avcodec.h:1466
hap.h
av_shrink_packet
void av_shrink_packet(AVPacket *pkt, int size)
Reduce packet size, correctly zeroing padding.
Definition: avpacket.c:112
AVERROR_BUFFER_TOO_SMALL
#define AVERROR_BUFFER_TOO_SMALL
Buffer too small.
Definition: error.h:53
hap_close
static av_cold int hap_close(AVCodecContext *avctx)
Definition: hapenc.c:319
FF_CODEC_ENCODE_CB
#define FF_CODEC_ENCODE_CB(func)
Definition: codec_internal.h:288
HAP_FMT_RGBADXT5
@ HAP_FMT_RGBADXT5
Definition: hap.h:35
HAP_COMP_SNAPPY
@ HAP_COMP_SNAPPY
Definition: hap.h:42
HAP_COMP_NONE
@ HAP_COMP_NONE
Definition: hap.h:41
pkt
AVPacket * pkt
Definition: movenc.c:59
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
hap_write_section_header
static void hap_write_section_header(PutByteContext *pbc, enum HapHeaderLength header_length, int section_length, enum HapSectionType section_type)
Definition: hapenc.c:72
bytestream2_init_writer
static av_always_inline void bytestream2_init_writer(PutByteContext *p, uint8_t *buf, int buf_size)
Definition: bytestream.h:147
intreadwrite.h
ff_hap_free_context
av_cold void ff_hap_free_context(HapContext *ctx)
Definition: hap.c:50
HAP_ST_SIZE_TABLE
@ HAP_ST_SIZE_TABLE
Definition: hap.h:49
ctx
AVFormatContext * ctx
Definition: movenc.c:48
ff_hap_encoder
const FFCodec ff_hap_encoder
Definition: hapenc.c:349
ff_texturedspenc_init
void ff_texturedspenc_init(TextureDSPContext *c)
Definition: texturedspenc.c:666
CODEC_LONG_NAME
#define CODEC_LONG_NAME(str)
Definition: codec_internal.h:264
AV_PIX_FMT_RGBA
@ AV_PIX_FMT_RGBA
packed RGBA 8:8:8:8, 32bpp, RGBARGBA...
Definition: pixfmt.h:93
HAP_HDR_SHORT
@ HAP_HDR_SHORT
Definition: hapenc.c:51
LIBAVUTIL_VERSION_INT
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:66
NULL
#define NULL
Definition: coverity.c:32
av_default_item_name
const char * av_default_item_name(void *ptr)
Return the context name.
Definition: log.c:237
HAP_ST_DECODE_INSTRUCTIONS
@ HAP_ST_DECODE_INSTRUCTIONS
Definition: hap.h:47
options
static const AVOption options[]
Definition: hapenc.c:330
HAP_COMP_COMPLEX
@ HAP_COMP_COMPLEX
Definition: hap.h:43
ff_hap_set_chunk_count
int ff_hap_set_chunk_count(HapContext *ctx, int count, int first_in_frame)
Definition: hap.c:28
HapChunk::uncompressed_size
size_t uncompressed_size
Definition: hap.h:58
PutByteContext
Definition: bytestream.h:37
HapSectionType
HapSectionType
Definition: hap.h:46
f
f
Definition: af_crystalizer.c:122
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:375
codec_internal.h
HapChunk::compressor
enum HapCompressor compressor
Definition: hap.h:54
hap_write_frame_header
static void hap_write_frame_header(HapContext *ctx, uint8_t *dst, int frame_length)
Definition: hapenc.c:159
frame.h
AV_CODEC_CAP_SLICE_THREADS
#define AV_CODEC_CAP_SLICE_THREADS
Codec supports slice-based (or partition-based) multithreading.
Definition: codec.h:117
FLAGS
#define FLAGS
Definition: hapenc.c:329
AV_LOG_INFO
#define AV_LOG_INFO
Standard information.
Definition: log.h:191
AVCodecContext::bits_per_coded_sample
int bits_per_coded_sample
bits per sample/pixel from the demuxer (needed for huffyuv).
Definition: avcodec.h:1444
HAP_ST_COMPRESSOR_TABLE
@ HAP_ST_COMPRESSOR_TABLE
Definition: hap.h:48
HapChunk
Definition: hap.h:53
HapChunk::uncompressed_offset
int uncompressed_offset
Definition: hap.h:57
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:269
TEXTURE_BLOCK_W
#define TEXTURE_BLOCK_W
Definition: texturedsp.h:44
AVCodec::name
const char * name
Name of the codec implementation.
Definition: codec.h:211
AVCodecContext::height
int height
Definition: avcodec.h:571
avcodec.h
ret
ret
Definition: filter_design.txt:187
AVClass::class_name
const char * class_name
The name of the class; usually it is the same name as the context structure type to which the AVClass...
Definition: log.h:71
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
hap_encode
static int hap_encode(AVCodecContext *avctx, AVPacket *pkt, const AVFrame *frame, int *got_packet)
Definition: hapenc.c:191
HAP_MAX_CHUNKS
#define HAP_MAX_CHUNKS
Definition: hapenc.c:47
SIZE_SPECIFIER
#define SIZE_SPECIFIER
Definition: internal.h:150
AVCodecContext
main external API structure.
Definition: avcodec.h:398
AV_CODEC_ID_HAP
@ AV_CODEC_ID_HAP
Definition: codec_id.h:241
hap_decode_instructions_length
static int hap_decode_instructions_length(HapContext *ctx)
Definition: hapenc.c:137
HAP_FMT_RGBDXT1
@ HAP_FMT_RGBDXT1
Definition: hap.h:34
AV_PIX_FMT_NONE
@ AV_PIX_FMT_NONE
Definition: pixfmt.h:65
AV_OPT_TYPE_INT
@ AV_OPT_TYPE_INT
Definition: opt.h:225
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
HAP_HDR_LONG
@ HAP_HDR_LONG
Definition: hapenc.c:53
AVCodecContext::codec_tag
unsigned int codec_tag
fourcc (LSB first, so "ABCD" -> ('D'<<24) + ('C'<<16) + ('B'<<8) + 'A').
Definition: avcodec.h:423
AVPacket
This structure stores compressed data.
Definition: packet.h:351
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:425
HapChunk::compressed_offset
uint32_t compressed_offset
Definition: hap.h:55
hap_header_length
static int hap_header_length(HapContext *ctx)
Definition: hapenc.c:146
AVCodecContext::width
int width
picture width / height.
Definition: avcodec.h:571
bytestream.h
imgutils.h
AVERROR_BUG
#define AVERROR_BUG
Internal bug, also see AVERROR_BUG2.
Definition: error.h:52
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
MKTAG
#define MKTAG(a, b, c, d)
Definition: macros.h:55
av_image_check_size
int av_image_check_size(unsigned int w, unsigned int h, int log_offset, void *log_ctx)
Check if the given dimension of an image is valid, meaning that all bytes of the image can be address...
Definition: imgutils.c:318
AV_OPT_TYPE_CONST
@ AV_OPT_TYPE_CONST
Definition: opt.h:234
AVCodecContext::execute2
int(* execute2)(struct AVCodecContext *c, int(*func)(struct AVCodecContext *c2, void *arg, int jobnr, int threadnr), void *arg2, int *ret, int count)
The codec may call this to execute several independent things.
Definition: avcodec.h:1536
ff_alloc_packet
int ff_alloc_packet(AVCodecContext *avctx, AVPacket *avpkt, int64_t size)
Check AVPacket size and allocate data.
Definition: encode.c:35
compress_texture
static int compress_texture(AVCodecContext *avctx, uint8_t *out, int out_length, const AVFrame *f)
Definition: hapenc.c:56