FFmpeg
cbs_jpeg.c
Go to the documentation of this file.
1 /*
2  * This file is part of FFmpeg.
3  *
4  * FFmpeg is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU Lesser General Public
6  * License as published by the Free Software Foundation; either
7  * version 2.1 of the License, or (at your option) any later version.
8  *
9  * FFmpeg is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12  * Lesser General Public License for more details.
13  *
14  * You should have received a copy of the GNU Lesser General Public
15  * License along with FFmpeg; if not, write to the Free Software
16  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
17  */
18 
19 #include "cbs.h"
20 #include "cbs_internal.h"
21 #include "cbs_jpeg.h"
22 
23 
24 #define HEADER(name) do { \
25  ff_cbs_trace_header(ctx, name); \
26  } while (0)
27 
28 #define CHECK(call) do { \
29  err = (call); \
30  if (err < 0) \
31  return err; \
32  } while (0)
33 
34 #define SUBSCRIPTS(subs, ...) (subs > 0 ? ((int[subs + 1]){ subs, __VA_ARGS__ }) : NULL)
35 
36 #define u(width, name, range_min, range_max) \
37  xu(width, name, range_min, range_max, 0, )
38 #define us(width, name, sub, range_min, range_max) \
39  xu(width, name, range_min, range_max, 1, sub)
40 
41 
42 #define READ
43 #define READWRITE read
44 #define RWContext GetBitContext
45 #define FUNC(name) cbs_jpeg_read_ ## name
46 
47 #define xu(width, name, range_min, range_max, subs, ...) do { \
48  uint32_t value; \
49  CHECK(ff_cbs_read_unsigned(ctx, rw, width, #name, \
50  SUBSCRIPTS(subs, __VA_ARGS__), \
51  &value, range_min, range_max)); \
52  current->name = value; \
53  } while (0)
54 
56 
57 #undef READ
58 #undef READWRITE
59 #undef RWContext
60 #undef FUNC
61 #undef xu
62 
63 #define WRITE
64 #define READWRITE write
65 #define RWContext PutBitContext
66 #define FUNC(name) cbs_jpeg_write_ ## name
67 
68 #define xu(width, name, range_min, range_max, subs, ...) do { \
69  uint32_t value = current->name; \
70  CHECK(ff_cbs_write_unsigned(ctx, rw, width, #name, \
71  SUBSCRIPTS(subs, __VA_ARGS__), \
72  value, range_min, range_max)); \
73  } while (0)
74 
75 
77 
78 #undef WRITE
79 #undef READWRITE
80 #undef RWContext
81 #undef FUNC
82 #undef xu
83 
84 
85 static void cbs_jpeg_free_application_data(void *opaque, uint8_t *content)
86 {
88  av_buffer_unref(&ad->Ap_ref);
89  av_freep(&content);
90 }
91 
92 static void cbs_jpeg_free_comment(void *opaque, uint8_t *content)
93 {
95  av_buffer_unref(&comment->Cm_ref);
96  av_freep(&content);
97 }
98 
99 static void cbs_jpeg_free_scan(void *opaque, uint8_t *content)
100 {
101  JPEGRawScan *scan = (JPEGRawScan*)content;
102  av_buffer_unref(&scan->data_ref);
103  av_freep(&content);
104 }
105 
108  int header)
109 {
110  AVBufferRef *data_ref;
111  uint8_t *data;
112  size_t data_size;
113  int start, end, marker, next_start, next_marker;
114  int err, i, j, length;
115 
116  if (frag->data_size < 4) {
117  // Definitely too short to be meaningful.
118  return AVERROR_INVALIDDATA;
119  }
120 
121  for (i = 0; i + 1 < frag->data_size && frag->data[i] != 0xff; i++);
122  if (i > 0) {
123  av_log(ctx->log_ctx, AV_LOG_WARNING, "Discarding %d bytes at "
124  "beginning of image.\n", i);
125  }
126  for (++i; i + 1 < frag->data_size && frag->data[i] == 0xff; i++);
127  if (i + 1 >= frag->data_size && frag->data[i]) {
128  av_log(ctx->log_ctx, AV_LOG_ERROR, "Invalid JPEG image: "
129  "no SOI marker found.\n");
130  return AVERROR_INVALIDDATA;
131  }
132  marker = frag->data[i];
133  if (marker != JPEG_MARKER_SOI) {
134  av_log(ctx->log_ctx, AV_LOG_ERROR, "Invalid JPEG image: first "
135  "marker is %02x, should be SOI.\n", marker);
136  return AVERROR_INVALIDDATA;
137  }
138  for (++i; i + 1 < frag->data_size && frag->data[i] == 0xff; i++);
139  if (i + 1 >= frag->data_size) {
140  av_log(ctx->log_ctx, AV_LOG_ERROR, "Invalid JPEG image: "
141  "no image content found.\n");
142  return AVERROR_INVALIDDATA;
143  }
144  marker = frag->data[i];
145  start = i + 1;
146 
147  do {
148  if (marker == JPEG_MARKER_EOI) {
149  break;
150  } else if (marker == JPEG_MARKER_SOS) {
151  next_marker = -1;
152  end = start;
153  for (i = start; i + 1 < frag->data_size; i++) {
154  if (frag->data[i] != 0xff)
155  continue;
156  end = i;
157  for (++i; i + 1 < frag->data_size &&
158  frag->data[i] == 0xff; i++);
159  if (i + 1 < frag->data_size) {
160  if (frag->data[i] == 0x00)
161  continue;
162  next_marker = frag->data[i];
163  next_start = i + 1;
164  }
165  break;
166  }
167  } else {
168  i = start;
169  if (i + 2 > frag->data_size) {
170  av_log(ctx->log_ctx, AV_LOG_ERROR, "Invalid JPEG image: "
171  "truncated at %02x marker.\n", marker);
172  return AVERROR_INVALIDDATA;
173  }
174  length = AV_RB16(frag->data + i);
175  if (i + length > frag->data_size) {
176  av_log(ctx->log_ctx, AV_LOG_ERROR, "Invalid JPEG image: "
177  "truncated at %02x marker segment.\n", marker);
178  return AVERROR_INVALIDDATA;
179  }
180  end = start + length;
181 
182  i = end;
183  if (frag->data[i] != 0xff) {
184  next_marker = -1;
185  } else {
186  for (++i; i + 1 < frag->data_size &&
187  frag->data[i] == 0xff; i++);
188  if (i + 1 >= frag->data_size) {
189  next_marker = -1;
190  } else {
191  next_marker = frag->data[i];
192  next_start = i + 1;
193  }
194  }
195  }
196 
197  if (marker == JPEG_MARKER_SOS) {
198  length = AV_RB16(frag->data + start);
199 
200  if (length > end - start)
201  return AVERROR_INVALIDDATA;
202 
203  data_ref = NULL;
204  data = av_malloc(end - start +
206  if (!data)
207  return AVERROR(ENOMEM);
208 
209  memcpy(data, frag->data + start, length);
210  for (i = start + length, j = length; i < end; i++, j++) {
211  if (frag->data[i] == 0xff) {
212  while (frag->data[i] == 0xff)
213  ++i;
214  data[j] = 0xff;
215  } else {
216  data[j] = frag->data[i];
217  }
218  }
219  data_size = j;
220 
221  memset(data + data_size, 0, AV_INPUT_BUFFER_PADDING_SIZE);
222 
223  } else {
224  data = frag->data + start;
225  data_size = end - start;
226  data_ref = frag->data_ref;
227  }
228 
229  err = ff_cbs_append_unit_data(frag, marker,
230  data, data_size, data_ref);
231  if (err < 0)
232  return err;
233 
234  marker = next_marker;
235  start = next_start;
236  } while (next_marker != -1);
237 
238  return 0;
239 }
240 
242  CodedBitstreamUnit *unit)
243 {
244  GetBitContext gbc;
245  int err;
246 
247  err = init_get_bits(&gbc, unit->data, 8 * unit->data_size);
248  if (err < 0)
249  return err;
250 
251  if (unit->type >= JPEG_MARKER_SOF0 &&
252  unit->type <= JPEG_MARKER_SOF3) {
253  err = ff_cbs_alloc_unit_content(unit,
254  sizeof(JPEGRawFrameHeader),
255  NULL);
256  if (err < 0)
257  return err;
258 
259  err = cbs_jpeg_read_frame_header(ctx, &gbc, unit->content);
260  if (err < 0)
261  return err;
262 
263  } else if (unit->type >= JPEG_MARKER_APPN &&
264  unit->type <= JPEG_MARKER_APPN + 15) {
265  err = ff_cbs_alloc_unit_content(unit,
266  sizeof(JPEGRawApplicationData),
268  if (err < 0)
269  return err;
270 
271  err = cbs_jpeg_read_application_data(ctx, &gbc, unit->content);
272  if (err < 0)
273  return err;
274 
275  } else if (unit->type == JPEG_MARKER_SOS) {
276  JPEGRawScan *scan;
277  int pos;
278 
279  err = ff_cbs_alloc_unit_content(unit,
280  sizeof(JPEGRawScan),
282  if (err < 0)
283  return err;
284  scan = unit->content;
285 
286  err = cbs_jpeg_read_scan_header(ctx, &gbc, &scan->header);
287  if (err < 0)
288  return err;
289 
290  pos = get_bits_count(&gbc);
291  av_assert0(pos % 8 == 0);
292  if (pos > 0) {
293  scan->data_size = unit->data_size - pos / 8;
294  scan->data_ref = av_buffer_ref(unit->data_ref);
295  if (!scan->data_ref)
296  return AVERROR(ENOMEM);
297  scan->data = unit->data + pos / 8;
298  }
299 
300  } else {
301  switch (unit->type) {
302 #define SEGMENT(marker, type, func, free) \
303  case JPEG_MARKER_ ## marker: \
304  { \
305  err = ff_cbs_alloc_unit_content(unit, \
306  sizeof(type), free); \
307  if (err < 0) \
308  return err; \
309  err = cbs_jpeg_read_ ## func(ctx, &gbc, unit->content); \
310  if (err < 0) \
311  return err; \
312  } \
313  break
317 #undef SEGMENT
318  default:
319  return AVERROR(ENOSYS);
320  }
321  }
322 
323  return 0;
324 }
325 
327  CodedBitstreamUnit *unit,
328  PutBitContext *pbc)
329 {
330  JPEGRawScan *scan = unit->content;
331  int err;
332 
333  err = cbs_jpeg_write_scan_header(ctx, pbc, &scan->header);
334  if (err < 0)
335  return err;
336 
337  if (scan->data) {
338  if (scan->data_size * 8 > put_bits_left(pbc))
339  return AVERROR(ENOSPC);
340 
341  av_assert0(put_bits_count(pbc) % 8 == 0);
342 
343  flush_put_bits(pbc);
344 
345  memcpy(put_bits_ptr(pbc), scan->data, scan->data_size);
346  skip_put_bytes(pbc, scan->data_size);
347  }
348 
349  return 0;
350 }
351 
353  CodedBitstreamUnit *unit,
354  PutBitContext *pbc)
355 {
356  int err;
357 
358  if (unit->type >= JPEG_MARKER_SOF0 &&
359  unit->type <= JPEG_MARKER_SOF3) {
360  err = cbs_jpeg_write_frame_header(ctx, pbc, unit->content);
361  } else if (unit->type >= JPEG_MARKER_APPN &&
362  unit->type <= JPEG_MARKER_APPN + 15) {
363  err = cbs_jpeg_write_application_data(ctx, pbc, unit->content);
364  } else {
365  switch (unit->type) {
366 #define SEGMENT(marker, func) \
367  case JPEG_MARKER_ ## marker: \
368  err = cbs_jpeg_write_ ## func(ctx, pbc, unit->content); \
369  break;
370  SEGMENT(DQT, dqt);
371  SEGMENT(DHT, dht);
372  SEGMENT(COM, comment);
373  default:
374  return AVERROR_PATCHWELCOME;
375  }
376  }
377 
378  return err;
379 }
380 
382  CodedBitstreamUnit *unit,
383  PutBitContext *pbc)
384 {
385  if (unit->type == JPEG_MARKER_SOS)
386  return cbs_jpeg_write_scan (ctx, unit, pbc);
387  else
388  return cbs_jpeg_write_segment(ctx, unit, pbc);
389 }
390 
393 {
394  const CodedBitstreamUnit *unit;
395  uint8_t *data;
396  size_t size, dp, sp;
397  int i;
398 
399  size = 4; // SOI + EOI.
400  for (i = 0; i < frag->nb_units; i++) {
401  unit = &frag->units[i];
402  size += 2 + unit->data_size;
403  if (unit->type == JPEG_MARKER_SOS) {
404  for (sp = 0; sp < unit->data_size; sp++) {
405  if (unit->data[sp] == 0xff)
406  ++size;
407  }
408  }
409  }
410 
412  if (!frag->data_ref)
413  return AVERROR(ENOMEM);
414  data = frag->data_ref->data;
415 
416  dp = 0;
417 
418  data[dp++] = 0xff;
419  data[dp++] = JPEG_MARKER_SOI;
420 
421  for (i = 0; i < frag->nb_units; i++) {
422  unit = &frag->units[i];
423 
424  data[dp++] = 0xff;
425  data[dp++] = unit->type;
426 
427  if (unit->type != JPEG_MARKER_SOS) {
428  memcpy(data + dp, unit->data, unit->data_size);
429  dp += unit->data_size;
430  } else {
431  sp = AV_RB16(unit->data);
432  av_assert0(sp <= unit->data_size);
433  memcpy(data + dp, unit->data, sp);
434  dp += sp;
435 
436  for (; sp < unit->data_size; sp++) {
437  if (unit->data[sp] == 0xff) {
438  data[dp++] = 0xff;
439  data[dp++] = 0x00;
440  } else {
441  data[dp++] = unit->data[sp];
442  }
443  }
444  }
445  }
446 
447  data[dp++] = 0xff;
448  data[dp++] = JPEG_MARKER_EOI;
449 
450  av_assert0(dp == size);
451 
452  memset(data + size, 0, AV_INPUT_BUFFER_PADDING_SIZE);
453  frag->data = data;
454  frag->data_size = size;
455 
456  return 0;
457 }
458 
461 
462  .split_fragment = &cbs_jpeg_split_fragment,
463  .read_unit = &cbs_jpeg_read_unit,
464  .write_unit = &cbs_jpeg_write_unit,
465  .assemble_fragment = &cbs_jpeg_assemble_fragment,
466 };
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:186
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
cbs_jpeg.h
AVBufferRef::data
uint8_t * data
The data buffer.
Definition: buffer.h:90
CodedBitstreamUnit::content
void * content
Pointer to the decomposed form of this unit.
Definition: cbs.h:106
get_bits_count
static int get_bits_count(const GetBitContext *s)
Definition: get_bits.h:220
cbs_jpeg_syntax_template.c
JPEGRawScan::data_ref
AVBufferRef * data_ref
Definition: cbs_jpeg.h:83
CodedBitstreamContext
Context structure for coded bitstream operations.
Definition: cbs.h:173
data
const char data[16]
Definition: mxf.c:143
CodedBitstreamUnit::type
CodedBitstreamUnitType type
Codec-specific type of this unit.
Definition: cbs.h:73
cbs.h
JPEGRawScan::data
uint8_t * data
Definition: cbs_jpeg.h:82
av_buffer_ref
AVBufferRef * av_buffer_ref(const AVBufferRef *buf)
Create a new reference to an AVBuffer.
Definition: buffer.c:103
init_get_bits
static int init_get_bits(GetBitContext *s, const uint8_t *buffer, int bit_size)
Initialize GetBitContext.
Definition: get_bits.h:660
CodedBitstreamUnit
Coded bitstream unit structure.
Definition: cbs.h:69
av_malloc
#define av_malloc(s)
Definition: tableprint_vlc.h:30
cbs_jpeg_write_segment
static int cbs_jpeg_write_segment(CodedBitstreamContext *ctx, CodedBitstreamUnit *unit, PutBitContext *pbc)
Definition: cbs_jpeg.c:352
GetBitContext
Definition: get_bits.h:62
JPEGRawScan::data_size
size_t data_size
Definition: cbs_jpeg.h:84
put_bits_left
static int put_bits_left(PutBitContext *s)
Definition: put_bits.h:125
JPEGRawQuantisationTableSpecification
Definition: cbs_jpeg.h:93
CodedBitstreamUnit::data
uint8_t * data
Pointer to the directly-parsable bitstream form of this unit.
Definition: cbs.h:80
JPEGRawApplicationData::Ap_ref
AVBufferRef * Ap_ref
Definition: cbs_jpeg.h:113
CodedBitstreamFragment::units
CodedBitstreamUnit * units
Pointer to an array of units of length nb_units_allocated.
Definition: cbs.h:167
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:180
JPEG_MARKER_EOI
@ JPEG_MARKER_EOI
Definition: cbs_jpeg.h:36
COM
@ COM
Definition: mjpeg.h:111
CodedBitstreamFragment
Coded bitstream fragment structure, combining one or more units.
Definition: cbs.h:121
CodedBitstreamFragment::data_size
size_t data_size
The number of bytes in the bitstream.
Definition: cbs.h:134
JPEG_MARKER_SOI
@ JPEG_MARKER_SOI
Definition: cbs_jpeg.h:35
cbs_jpeg_assemble_fragment
static int cbs_jpeg_assemble_fragment(CodedBitstreamContext *ctx, CodedBitstreamFragment *frag)
Definition: cbs_jpeg.c:391
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
ctx
AVFormatContext * ctx
Definition: movenc.c:48
ff_cbs_append_unit_data
int ff_cbs_append_unit_data(CodedBitstreamFragment *frag, CodedBitstreamUnitType type, uint8_t *data, size_t data_size, AVBufferRef *data_buf)
Add a new unit to a fragment with the given data bitstream.
Definition: cbs.c:829
cbs_internal.h
ff_cbs_alloc_unit_content
int ff_cbs_alloc_unit_content(CodedBitstreamUnit *unit, size_t size, void(*free)(void *opaque, uint8_t *data))
Definition: cbs.c:698
CodedBitstreamType::codec_id
enum AVCodecID codec_id
Definition: cbs_internal.h:92
PutBitContext
Definition: put_bits.h:50
cbs_jpeg_write_scan
static int cbs_jpeg_write_scan(CodedBitstreamContext *ctx, CodedBitstreamUnit *unit, PutBitContext *pbc)
Definition: cbs_jpeg.c:326
JPEG_MARKER_SOS
@ JPEG_MARKER_SOS
Definition: cbs_jpeg.h:37
NULL
#define NULL
Definition: coverity.c:32
AVERROR_PATCHWELCOME
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Definition: error.h:64
av_buffer_unref
void av_buffer_unref(AVBufferRef **buf)
Free a given reference and automatically free the buffer if there are no more references to it.
Definition: buffer.c:139
CodedBitstreamUnit::data_size
size_t data_size
The number of bytes in the bitstream (including any padding bits in the final byte).
Definition: cbs.h:85
JPEG_MARKER_SOF3
@ JPEG_MARKER_SOF3
Definition: cbs_jpeg.h:32
cbs_jpeg_read_unit
static int cbs_jpeg_read_unit(CodedBitstreamContext *ctx, CodedBitstreamUnit *unit)
Definition: cbs_jpeg.c:241
JPEGRawHuffmanTableSpecification
Definition: cbs_jpeg.h:105
cbs_jpeg_free_scan
static void cbs_jpeg_free_scan(void *opaque, uint8_t *content)
Definition: cbs_jpeg.c:99
sp
#define sp
Definition: regdef.h:63
size
int size
Definition: twinvq_data.h:10344
CodedBitstreamFragment::data
uint8_t * data
Pointer to the bitstream form of this fragment.
Definition: cbs.h:127
ff_cbs_type_jpeg
const CodedBitstreamType ff_cbs_type_jpeg
Definition: cbs_jpeg.c:459
header
static const uint8_t header[24]
Definition: sdr2.c:67
CodedBitstreamType
Definition: cbs_internal.h:91
av_buffer_alloc
AVBufferRef * av_buffer_alloc(size_t size)
Allocate an AVBuffer of the given size using av_malloc().
Definition: buffer.c:77
DQT
@ DQT
Definition: mjpeg.h:73
AV_CODEC_ID_MJPEG
@ AV_CODEC_ID_MJPEG
Definition: codec_id.h:57
JPEGRawScan::header
JPEGRawScanHeader header
Definition: cbs_jpeg.h:81
CodedBitstreamUnit::data_ref
AVBufferRef * data_ref
A reference to the buffer containing data.
Definition: cbs.h:97
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:271
put_bits_count
static int put_bits_count(PutBitContext *s)
Definition: put_bits.h:80
DHT
@ DHT
Definition: mjpeg.h:56
JPEGRawApplicationData
Definition: cbs_jpeg.h:110
cbs_jpeg_split_fragment
static int cbs_jpeg_split_fragment(CodedBitstreamContext *ctx, CodedBitstreamFragment *frag, int header)
Definition: cbs_jpeg.c:106
SEGMENT
#define SEGMENT(marker, type, func, free)
JPEGRawScan
Definition: cbs_jpeg.h:80
comment
static int FUNC() comment(CodedBitstreamContext *ctx, RWContext *rw, JPEGRawComment *current)
Definition: cbs_jpeg_syntax_template.c:174
dht
static int FUNC() dht(CodedBitstreamContext *ctx, RWContext *rw, JPEGRawHuffmanTableSpecification *current)
Definition: cbs_jpeg_syntax_template.c:102
pos
unsigned int pos
Definition: spdifenc.c:412
AV_INPUT_BUFFER_PADDING_SIZE
#define AV_INPUT_BUFFER_PADDING_SIZE
Definition: defs.h:40
cbs_jpeg_write_unit
static int cbs_jpeg_write_unit(CodedBitstreamContext *ctx, CodedBitstreamUnit *unit, PutBitContext *pbc)
Definition: cbs_jpeg.c:381
put_bits_ptr
static uint8_t * put_bits_ptr(PutBitContext *s)
Return the pointer to the byte where the bitstream writer will put the next bit.
Definition: put_bits.h:370
skip_put_bytes
static void skip_put_bytes(PutBitContext *s, int n)
Skip the given number of bytes.
Definition: put_bits.h:379
JPEG_MARKER_SOF0
@ JPEG_MARKER_SOF0
Definition: cbs_jpeg.h:29
dqt
static int FUNC() dqt(CodedBitstreamContext *ctx, RWContext *rw, JPEGRawQuantisationTableSpecification *current)
Definition: cbs_jpeg_syntax_template.c:62
AVBufferRef
A reference to a data buffer.
Definition: buffer.h:82
flush_put_bits
static void flush_put_bits(PutBitContext *s)
Pad the end of the output stream with zeros.
Definition: put_bits.h:143
JPEGRawFrameHeader
Definition: cbs_jpeg.h:53
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:34
JPEGRawComment
Definition: cbs_jpeg.h:116
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
CodedBitstreamFragment::data_ref
AVBufferRef * data_ref
A reference to the buffer containing data.
Definition: cbs.h:144
cbs_jpeg_free_application_data
static void cbs_jpeg_free_application_data(void *opaque, uint8_t *content)
Definition: cbs_jpeg.c:85
cbs_jpeg_free_comment
static void cbs_jpeg_free_comment(void *opaque, uint8_t *content)
Definition: cbs_jpeg.c:92
JPEG_MARKER_APPN
@ JPEG_MARKER_APPN
Definition: cbs_jpeg.h:40
CodedBitstreamFragment::nb_units
int nb_units
Number of units in this fragment.
Definition: cbs.h:152
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