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 unit, 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  for (unit = 0;; unit++) {
148  if (marker == JPEG_MARKER_EOI) {
149  break;
150  } else if (marker == JPEG_MARKER_SOS) {
151  for (i = start; i + 1 < frag->data_size; i++) {
152  if (frag->data[i] != 0xff)
153  continue;
154  end = i;
155  for (++i; i + 1 < frag->data_size &&
156  frag->data[i] == 0xff; i++);
157  if (i + 1 >= frag->data_size) {
158  next_marker = -1;
159  } else {
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  data_ref = NULL;
201  data = av_malloc(end - start +
203  if (!data)
204  return AVERROR(ENOMEM);
205 
206  memcpy(data, frag->data + start, length);
207  for (i = start + length, j = length; i < end; i++, j++) {
208  if (frag->data[i] == 0xff) {
209  while (frag->data[i] == 0xff)
210  ++i;
211  data[j] = 0xff;
212  } else {
213  data[j] = frag->data[i];
214  }
215  }
216  data_size = j;
217 
218  memset(data + data_size, 0, AV_INPUT_BUFFER_PADDING_SIZE);
219 
220  } else {
221  data = frag->data + start;
222  data_size = end - start;
223  data_ref = frag->data_ref;
224  }
225 
226  err = ff_cbs_insert_unit_data(ctx, frag, unit, marker,
227  data, data_size, data_ref);
228  if (err < 0) {
229  if (!data_ref)
230  av_freep(&data);
231  return err;
232  }
233 
234  if (next_marker == -1)
235  break;
236  marker = next_marker;
237  start = next_start;
238  }
239 
240  return 0;
241 }
242 
244  CodedBitstreamUnit *unit)
245 {
246  GetBitContext gbc;
247  int err;
248 
249  err = init_get_bits(&gbc, unit->data, 8 * unit->data_size);
250  if (err < 0)
251  return err;
252 
253  if (unit->type >= JPEG_MARKER_SOF0 &&
254  unit->type <= JPEG_MARKER_SOF3) {
255  err = ff_cbs_alloc_unit_content(ctx, unit,
256  sizeof(JPEGRawFrameHeader),
257  NULL);
258  if (err < 0)
259  return err;
260 
261  err = cbs_jpeg_read_frame_header(ctx, &gbc, unit->content);
262  if (err < 0)
263  return err;
264 
265  } else if (unit->type >= JPEG_MARKER_APPN &&
266  unit->type <= JPEG_MARKER_APPN + 15) {
267  err = ff_cbs_alloc_unit_content(ctx, unit,
268  sizeof(JPEGRawApplicationData),
270  if (err < 0)
271  return err;
272 
273  err = cbs_jpeg_read_application_data(ctx, &gbc, unit->content);
274  if (err < 0)
275  return err;
276 
277  } else if (unit->type == JPEG_MARKER_SOS) {
278  JPEGRawScan *scan;
279  int pos;
280 
281  err = ff_cbs_alloc_unit_content(ctx, unit,
282  sizeof(JPEGRawScan),
284  if (err < 0)
285  return err;
286  scan = unit->content;
287 
288  err = cbs_jpeg_read_scan_header(ctx, &gbc, &scan->header);
289  if (err < 0)
290  return err;
291 
292  pos = get_bits_count(&gbc);
293  av_assert0(pos % 8 == 0);
294  if (pos > 0) {
295  scan->data_size = unit->data_size - pos / 8;
296  scan->data_ref = av_buffer_ref(unit->data_ref);
297  if (!scan->data_ref)
298  return AVERROR(ENOMEM);
299  scan->data = unit->data + pos / 8;
300  }
301 
302  } else {
303  switch (unit->type) {
304 #define SEGMENT(marker, type, func, free) \
305  case JPEG_MARKER_ ## marker: \
306  { \
307  err = ff_cbs_alloc_unit_content(ctx, unit, \
308  sizeof(type), free); \
309  if (err < 0) \
310  return err; \
311  err = cbs_jpeg_read_ ## func(ctx, &gbc, unit->content); \
312  if (err < 0) \
313  return err; \
314  } \
315  break
319 #undef SEGMENT
320  default:
321  return AVERROR(ENOSYS);
322  }
323  }
324 
325  return 0;
326 }
327 
329  CodedBitstreamUnit *unit,
330  PutBitContext *pbc)
331 {
332  JPEGRawScan *scan = unit->content;
333  int i, err;
334 
335  err = cbs_jpeg_write_scan_header(ctx, pbc, &scan->header);
336  if (err < 0)
337  return err;
338 
339  if (scan->data) {
340  if (scan->data_size * 8 > put_bits_left(pbc))
341  return AVERROR(ENOSPC);
342 
343  for (i = 0; i < scan->data_size; i++)
344  put_bits(pbc, 8, scan->data[i]);
345  }
346 
347  return 0;
348 }
349 
351  CodedBitstreamUnit *unit,
352  PutBitContext *pbc)
353 {
354  int err;
355 
356  if (unit->type >= JPEG_MARKER_SOF0 &&
357  unit->type <= JPEG_MARKER_SOF3) {
358  err = cbs_jpeg_write_frame_header(ctx, pbc, unit->content);
359  } else if (unit->type >= JPEG_MARKER_APPN &&
360  unit->type <= JPEG_MARKER_APPN + 15) {
361  err = cbs_jpeg_write_application_data(ctx, pbc, unit->content);
362  } else {
363  switch (unit->type) {
364 #define SEGMENT(marker, func) \
365  case JPEG_MARKER_ ## marker: \
366  err = cbs_jpeg_write_ ## func(ctx, pbc, unit->content); \
367  break;
368  SEGMENT(DQT, dqt);
369  SEGMENT(DHT, dht);
370  SEGMENT(COM, comment);
371  default:
372  return AVERROR_PATCHWELCOME;
373  }
374  }
375 
376  return err;
377 }
378 
380  CodedBitstreamUnit *unit)
381 {
383  PutBitContext pbc;
384  int err;
385 
386  if (!priv->write_buffer) {
387  // Initial write buffer size is 1MB.
388  priv->write_buffer_size = 1024 * 1024;
389 
390  reallocate_and_try_again:
391  err = av_reallocp(&priv->write_buffer, priv->write_buffer_size);
392  if (err < 0) {
393  av_log(ctx->log_ctx, AV_LOG_ERROR, "Unable to allocate a "
394  "sufficiently large write buffer (last attempt "
395  "%"SIZE_SPECIFIER" bytes).\n", priv->write_buffer_size);
396  return err;
397  }
398  }
399 
400  init_put_bits(&pbc, priv->write_buffer, priv->write_buffer_size);
401 
402  if (unit->type == JPEG_MARKER_SOS)
403  err = cbs_jpeg_write_scan(ctx, unit, &pbc);
404  else
405  err = cbs_jpeg_write_segment(ctx, unit, &pbc);
406 
407  if (err == AVERROR(ENOSPC)) {
408  // Overflow.
409  priv->write_buffer_size *= 2;
410  goto reallocate_and_try_again;
411  }
412  if (err < 0) {
413  // Write failed for some other reason.
414  return err;
415  }
416 
417  if (put_bits_count(&pbc) % 8)
418  unit->data_bit_padding = 8 - put_bits_count(&pbc) % 8;
419  else
420  unit->data_bit_padding = 0;
421 
422  unit->data_size = (put_bits_count(&pbc) + 7) / 8;
423  flush_put_bits(&pbc);
424 
425  err = ff_cbs_alloc_unit_data(ctx, unit, unit->data_size);
426  if (err < 0)
427  return err;
428 
429  memcpy(unit->data, priv->write_buffer, unit->data_size);
430 
431  return 0;
432 }
433 
436 {
437  const CodedBitstreamUnit *unit;
438  uint8_t *data;
439  size_t size, dp, sp;
440  int i;
441 
442  size = 4; // SOI + EOI.
443  for (i = 0; i < frag->nb_units; i++) {
444  unit = &frag->units[i];
445  size += 2 + unit->data_size;
446  if (unit->type == JPEG_MARKER_SOS) {
447  for (sp = 0; sp < unit->data_size; sp++) {
448  if (unit->data[sp] == 0xff)
449  ++size;
450  }
451  }
452  }
453 
455  if (!frag->data_ref)
456  return AVERROR(ENOMEM);
457  data = frag->data_ref->data;
458 
459  dp = 0;
460 
461  data[dp++] = 0xff;
462  data[dp++] = JPEG_MARKER_SOI;
463 
464  for (i = 0; i < frag->nb_units; i++) {
465  unit = &frag->units[i];
466 
467  data[dp++] = 0xff;
468  data[dp++] = unit->type;
469 
470  if (unit->type != JPEG_MARKER_SOS) {
471  memcpy(data + dp, unit->data, unit->data_size);
472  dp += unit->data_size;
473  } else {
474  sp = AV_RB16(unit->data);
475  av_assert0(sp <= unit->data_size);
476  memcpy(data + dp, unit->data, sp);
477  dp += sp;
478 
479  for (; sp < unit->data_size; sp++) {
480  if (unit->data[sp] == 0xff) {
481  data[dp++] = 0xff;
482  data[dp++] = 0x00;
483  } else {
484  data[dp++] = unit->data[sp];
485  }
486  }
487  }
488  }
489 
490  data[dp++] = 0xff;
491  data[dp++] = JPEG_MARKER_EOI;
492 
493  av_assert0(dp == size);
494 
495  memset(data + size, 0, AV_INPUT_BUFFER_PADDING_SIZE);
496  frag->data = data;
497  frag->data_size = size;
498 
499  return 0;
500 }
501 
503 {
505 
506  av_freep(&priv->write_buffer);
507 }
508 
511 
512  .priv_data_size = sizeof(CodedBitstreamJPEGContext),
513 
514  .split_fragment = &cbs_jpeg_split_fragment,
515  .read_unit = &cbs_jpeg_read_unit,
516  .write_unit = &cbs_jpeg_write_unit,
517  .assemble_fragment = &cbs_jpeg_assemble_fragment,
518 
519  .close = &cbs_jpeg_close,
520 };
#define NULL
Definition: coverity.c:32
int nb_units
Number of units in this fragment.
Definition: cbs.h:147
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
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:125
ptrdiff_t const GLvoid * data
Definition: opengl_enc.c:100
static int FUNC() dqt(CodedBitstreamContext *ctx, RWContext *rw, JPEGRawQuantisationTableSpecification *current)
Definition: mjpeg.h:111
Definition: mjpeg.h:73
static void cbs_jpeg_free_scan(void *opaque, uint8_t *content)
Definition: cbs_jpeg.c:99
static void put_bits(Jpeg2000EncoderContext *s, int val, int n)
put n times val bit
Definition: j2kenc.c:208
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:182
CodedBitstreamUnitType type
Codec-specific type of this unit.
Definition: cbs.h:68
int ff_cbs_alloc_unit_content(CodedBitstreamContext *ctx, CodedBitstreamUnit *unit, size_t size, void(*free)(void *opaque, uint8_t *data))
Definition: cbs.c:588
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:87
AVBufferRef * data_ref
Definition: cbs_jpeg.h:84
static int cbs_jpeg_read_unit(CodedBitstreamContext *ctx, CodedBitstreamUnit *unit)
Definition: cbs_jpeg.c:243
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
size_t data_size
Definition: cbs_jpeg.h:83
uint8_t
#define av_malloc(s)
static void cbs_jpeg_close(CodedBitstreamContext *ctx)
Definition: cbs_jpeg.c:502
static av_cold int end(AVCodecContext *avctx)
Definition: avrndec.c:90
const CodedBitstreamType ff_cbs_type_jpeg
Definition: cbs_jpeg.c:509
size_t data_bit_padding
The number of bits which should be ignored in the final byte.
Definition: cbs.h:86
static int get_bits_count(const GetBitContext *s)
Definition: get_bits.h:219
#define sp
Definition: regdef.h:63
static int FUNC() dht(CodedBitstreamContext *ctx, RWContext *rw, JPEGRawHuffmanTableSpecification *current)
int ff_cbs_alloc_unit_data(CodedBitstreamContext *ctx, CodedBitstreamUnit *unit, size_t size)
Allocate a new internal data buffer of the given size in the unit.
Definition: cbs.c:609
Coded bitstream unit structure.
Definition: cbs.h:64
AVBufferRef * Ap_ref
Definition: cbs_jpeg.h:113
ptrdiff_t size
Definition: opengl_enc.c:100
void * content
Pointer to the decomposed form of this unit.
Definition: cbs.h:101
static const uint8_t header[24]
Definition: sdr2.c:67
CodedBitstreamUnit * units
Pointer to an array of units of length nb_units_allocated.
Definition: cbs.h:162
#define SEGMENT(marker, type, func, free)
uint8_t * data
Pointer to the directly-parsable bitstream form of this unit.
Definition: cbs.h:75
int ff_cbs_insert_unit_data(CodedBitstreamContext *ctx, CodedBitstreamFragment *frag, int position, CodedBitstreamUnitType type, uint8_t *data, size_t data_size, AVBufferRef *data_buf)
Insert a new unit into a fragment with the given data bitstream.
Definition: cbs.c:703
#define av_log(a,...)
static int FUNC() comment(CodedBitstreamContext *ctx, RWContext *rw, JPEGRawComment *current)
size_t data_size
The number of bytes in the bitstream.
Definition: cbs.h:129
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:259
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
static int put_bits_left(PutBitContext *s)
Definition: put_bits.h:93
JPEGRawScanHeader header
Definition: cbs_jpeg.h:81
GLsizei GLsizei * length
Definition: opengl_enc.c:114
static int put_bits_count(PutBitContext *s)
Definition: put_bits.h:85
void * log_ctx
Logging context to be passed to all av_log() calls associated with this context.
Definition: cbs.h:173
Definition: mjpeg.h:56
AVFormatContext * ctx
Definition: movenc.c:48
uint8_t * data
Pointer to the bitstream form of this fragment.
Definition: cbs.h:122
static int cbs_jpeg_write_unit(CodedBitstreamContext *ctx, CodedBitstreamUnit *unit)
Definition: cbs_jpeg.c:379
static int cbs_jpeg_write_segment(CodedBitstreamContext *ctx, CodedBitstreamUnit *unit, PutBitContext *pbc)
Definition: cbs_jpeg.c:350
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Definition: error.h:62
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:163
AVBufferRef * av_buffer_alloc(int size)
Allocate an AVBuffer of the given size using av_malloc().
Definition: buffer.c:67
Coded bitstream fragment structure, combining one or more units.
Definition: cbs.h:116
uint8_t * data
The data buffer.
Definition: buffer.h:89
Context structure for coded bitstream operations.
Definition: cbs.h:168
static int cbs_jpeg_assemble_fragment(CodedBitstreamContext *ctx, CodedBitstreamFragment *frag)
Definition: cbs_jpeg.c:434
static void cbs_jpeg_free_application_data(void *opaque, uint8_t *content)
Definition: cbs_jpeg.c:85
static int init_get_bits(GetBitContext *s, const uint8_t *buffer, int bit_size)
Initialize GetBitContext.
Definition: get_bits.h:659
enum AVCodecID codec_id
Definition: cbs_internal.h:29
#define SIZE_SPECIFIER
Definition: internal.h:262
void * priv_data
Internal codec-specific data.
Definition: cbs.h:189
A reference to a data buffer.
Definition: buffer.h:81
static void flush_put_bits(PutBitContext *s)
Pad the end of the output stream with zeros.
Definition: put_bits.h:101
AVBufferRef * data_ref
A reference to the buffer containing data.
Definition: cbs.h:92
AVBufferRef * av_buffer_ref(AVBufferRef *buf)
Create a new reference to an AVBuffer.
Definition: buffer.c:93
static void init_put_bits(PutBitContext *s, uint8_t *buffer, int buffer_size)
Initialize the PutBitContext s.
Definition: put_bits.h:48
#define AV_INPUT_BUFFER_PADDING_SIZE
Required number of additionally allocated bytes at the end of the input bitstream for decoding...
Definition: avcodec.h:793
uint8_t * data
Definition: cbs_jpeg.h:82
#define av_freep(p)
void INT64 start
Definition: avisynth_c.h:766
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
AVBufferRef * data_ref
A reference to the buffer containing data.
Definition: cbs.h:139
static int cbs_jpeg_split_fragment(CodedBitstreamContext *ctx, CodedBitstreamFragment *frag, int header)
Definition: cbs_jpeg.c:106
AVBufferRef * Cm_ref
Definition: cbs_jpeg.h:119
static void cbs_jpeg_free_comment(void *opaque, uint8_t *content)
Definition: cbs_jpeg.c:92
static int cbs_jpeg_write_scan(CodedBitstreamContext *ctx, CodedBitstreamUnit *unit, PutBitContext *pbc)
Definition: cbs_jpeg.c:328
size_t data_size
The number of bytes in the bitstream (including any padding bits in the final byte).
Definition: cbs.h:80