FFmpeg
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
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 = range_min; \
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 READ
79 #undef READWRITE
80 #undef RWContext
81 #undef FUNC
82 #undef xu
83 
84 
85 static void cbs_jpeg_free_application_data(void *unit, 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 *unit, 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 *unit, 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:101
static int FUNC() dqt(CodedBitstreamContext *ctx, RWContext *rw, JPEGRawQuantisationTableSpecification *current)
Definition: mjpeg.h:111
Definition: mjpeg.h:73
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:506
static void cbs_jpeg_free_application_data(void *unit, uint8_t *content)
Definition: cbs_jpeg.c:85
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:527
Coded bitstream unit structure.
Definition: cbs.h:64
AVBufferRef * Ap_ref
Definition: cbs_jpeg.h:113
ptrdiff_t size
Definition: opengl_enc.c:101
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.
Definition: cbs.h:153
#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:607
#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 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
#define AVERROR(e)
Definition: error.h:43
JPEGRawScanHeader header
Definition: cbs_jpeg.h:81
GLsizei GLsizei * length
Definition: opengl_enc.c:115
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:164
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
static void cbs_jpeg_free_scan(void *unit, uint8_t *content)
Definition: cbs_jpeg.c:99
Context structure for coded bitstream operations.
Definition: cbs.h:159
static int cbs_jpeg_assemble_fragment(CodedBitstreamContext *ctx, CodedBitstreamFragment *frag)
Definition: cbs_jpeg.c:434
static int init_get_bits(GetBitContext *s, const uint8_t *buffer, int bit_size)
Initialize GetBitContext.
Definition: get_bits.h:615
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:180
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:782
static void cbs_jpeg_free_comment(void *unit, uint8_t *content)
Definition: cbs_jpeg.c:92
uint8_t * data
Definition: cbs_jpeg.h:82
#define av_freep(p)
void INT64 start
Definition: avisynth_c.h:690
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 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