FFmpeg
mjpegenc_common.c
Go to the documentation of this file.
1 /*
2  * lossless JPEG shared bits
3  * Copyright (c) 2000, 2001 Fabrice Bellard
4  * Copyright (c) 2003 Alex Beregszaszi
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 #include <stdint.h>
24 #include <string.h>
25 
26 #include "libavutil/pixdesc.h"
27 #include "libavutil/pixfmt.h"
28 
29 #include "avcodec.h"
30 #include "idctdsp.h"
31 #include "jpegtables.h"
32 #include "put_bits.h"
33 #include "mjpegenc.h"
34 #include "mjpegenc_common.h"
35 #include "mjpeg.h"
36 #include "version.h"
37 
38 /* table_class: 0 = DC coef, 1 = AC coefs */
39 static int put_huffman_table(PutBitContext *p, int table_class, int table_id,
40  const uint8_t *bits_table, const uint8_t *value_table)
41 {
42  int n = 0;
43 
44  put_bits(p, 4, table_class);
45  put_bits(p, 4, table_id);
46 
47  for (int i = 1; i <= 16; i++) {
48  n += bits_table[i];
49  put_bits(p, 8, bits_table[i]);
50  }
51 
52  for (int i = 0; i < n; i++)
53  put_bits(p, 8, value_table[i]);
54 
55  return n + 17;
56 }
57 
59  MJpegContext *m,
60  const uint8_t intra_matrix_permutation[64],
61  uint16_t luma_intra_matrix[64],
62  uint16_t chroma_intra_matrix[64],
63  int hsample[3], int use_slices, int matrices_differ)
64 {
65  int size;
66  uint8_t *ptr;
67 
68  if (m) {
69  int matrix_count = 1 + matrices_differ;
71  matrix_count = 2;
72  /* quant matrixes */
73  put_marker(p, DQT);
74  put_bits(p, 16, 2 + matrix_count * (1 + 64));
75  put_bits(p, 4, 0); /* 8 bit precision */
76  put_bits(p, 4, 0); /* table 0 */
77  for (int i = 0; i < 64; i++) {
78  uint8_t j = intra_matrix_permutation[i];
79  put_bits(p, 8, luma_intra_matrix[j]);
80  }
81 
82  if (matrix_count > 1) {
83  put_bits(p, 4, 0); /* 8 bit precision */
84  put_bits(p, 4, 1); /* table 1 */
85  for (int i = 0; i < 64; i++) {
86  uint8_t j = intra_matrix_permutation[i];
87  put_bits(p, 8, chroma_intra_matrix[j]);
88  }
89  }
90  }
91 
92  if (use_slices) {
93  put_marker(p, DRI);
94  put_bits(p, 16, 4);
95  put_bits(p, 16, (avctx->width-1)/(8*hsample[0]) + 1);
96  }
97 
98  /* huffman table */
99  put_marker(p, DHT);
100  flush_put_bits(p);
101  ptr = put_bits_ptr(p);
102  put_bits(p, 16, 0); /* patched later */
103  size = 2;
104 
105  // Only MJPEG can have a variable Huffman variable. All other
106  // formats use the default Huffman table.
107  if (m && m->huffman == HUFFMAN_TABLE_OPTIMAL) {
109  m->val_dc_luminance);
111  m->val_dc_chrominance);
112 
114  m->val_ac_luminance);
116  m->val_ac_chrominance);
117  } else {
122 
127  }
128  AV_WB16(ptr, size);
129 }
130 
131 enum {
132  ICC_HDR_SIZE = 16, /* ICC_PROFILE\0 tag + 4 bytes */
133  ICC_CHUNK_SIZE = UINT16_MAX - ICC_HDR_SIZE,
134  ICC_MAX_CHUNKS = UINT8_MAX,
135 };
136 
138  size_t *max_pkt_size)
139 {
140  const AVFrameSideData *sd;
141  size_t new_pkt_size;
142  int nb_chunks;
144  if (!sd || !sd->size)
145  return 0;
146 
147  if (sd->size > ICC_MAX_CHUNKS * ICC_CHUNK_SIZE) {
148  av_log(avctx, AV_LOG_ERROR, "Cannot store %"SIZE_SPECIFIER" byte ICC "
149  "profile: too large for JPEG\n",
150  sd->size);
151  return AVERROR_INVALIDDATA;
152  }
153 
154  nb_chunks = (sd->size + ICC_CHUNK_SIZE - 1) / ICC_CHUNK_SIZE;
155  new_pkt_size = *max_pkt_size + nb_chunks * (UINT16_MAX + 2 /* APP2 marker */);
156  if (new_pkt_size < *max_pkt_size) /* overflow */
157  return AVERROR_INVALIDDATA;
158  *max_pkt_size = new_pkt_size;
159  return 0;
160 }
161 
163  const AVFrame *frame)
164 {
165  const AVFrameSideData *sd = NULL;
166  int size;
167  uint8_t *ptr;
168 
169  if (avctx->sample_aspect_ratio.num > 0 && avctx->sample_aspect_ratio.den > 0) {
170  AVRational sar = avctx->sample_aspect_ratio;
171 
172  if (sar.num > 65535 || sar.den > 65535) {
173  if (!av_reduce(&sar.num, &sar.den, avctx->sample_aspect_ratio.num, avctx->sample_aspect_ratio.den, 65535))
174  av_log(avctx, AV_LOG_WARNING,
175  "Cannot store exact aspect ratio %d:%d\n",
176  avctx->sample_aspect_ratio.num,
177  avctx->sample_aspect_ratio.den);
178  }
179 
180  /* JFIF header */
181  put_marker(p, APP0);
182  put_bits(p, 16, 16);
183  ff_put_string(p, "JFIF", 1); /* this puts the trailing zero-byte too */
184  /* The most significant byte is used for major revisions, the least
185  * significant byte for minor revisions. Version 1.02 is the current
186  * released revision. */
187  put_bits(p, 16, 0x0102);
188  put_bits(p, 8, 0); /* units type: 0 - aspect ratio */
189  put_bits(p, 16, sar.num);
190  put_bits(p, 16, sar.den);
191  put_bits(p, 8, 0); /* thumbnail width */
192  put_bits(p, 8, 0); /* thumbnail height */
193  }
194 
195  /* ICC profile */
197  if (sd && sd->size) {
198  const int nb_chunks = (sd->size + ICC_CHUNK_SIZE - 1) / ICC_CHUNK_SIZE;
199  const uint8_t *data = sd->data;
200  size_t remaining = sd->size;
201  /* must already be checked by the packat allocation code */
202  av_assert0(remaining <= ICC_MAX_CHUNKS * ICC_CHUNK_SIZE);
203  flush_put_bits(p);
204  for (int i = 0; i < nb_chunks; i++) {
205  size = FFMIN(remaining, ICC_CHUNK_SIZE);
206  av_assert1(size > 0);
207  ptr = put_bits_ptr(p);
208  ptr[0] = 0xff; /* chunk marker, not part of ICC_HDR_SIZE */
209  ptr[1] = APP2;
210  AV_WB16(ptr+2, size + ICC_HDR_SIZE);
211  AV_WL32(ptr+4, MKTAG('I','C','C','_'));
212  AV_WL32(ptr+8, MKTAG('P','R','O','F'));
213  AV_WL32(ptr+12, MKTAG('I','L','E','\0'));
214  ptr[16] = i+1;
215  ptr[17] = nb_chunks;
216  memcpy(&ptr[18], data, size);
217  skip_put_bytes(p, size + ICC_HDR_SIZE + 2);
218  remaining -= size;
219  data += size;
220  }
221  av_assert1(!remaining);
222  }
223 
224  /* comment */
225  if (!(avctx->flags & AV_CODEC_FLAG_BITEXACT)) {
226  put_marker(p, COM);
227  flush_put_bits(p);
228  ptr = put_bits_ptr(p);
229  put_bits(p, 16, 0); /* patched later */
231  size = strlen(LIBAVCODEC_IDENT)+3;
232  AV_WB16(ptr, size);
233  }
234 
235  if (((avctx->pix_fmt == AV_PIX_FMT_YUV420P ||
236  avctx->pix_fmt == AV_PIX_FMT_YUV422P ||
237  avctx->pix_fmt == AV_PIX_FMT_YUV444P) && avctx->color_range != AVCOL_RANGE_JPEG)
238  || avctx->color_range == AVCOL_RANGE_MPEG) {
239  put_marker(p, COM);
240  flush_put_bits(p);
241  ptr = put_bits_ptr(p);
242  put_bits(p, 16, 0); /* patched later */
243  ff_put_string(p, "CS=ITU601", 1);
244  size = strlen("CS=ITU601")+3;
245  AV_WB16(ptr, size);
246  }
247 }
248 
249 void ff_mjpeg_init_hvsample(AVCodecContext *avctx, int hsample[4], int vsample[4])
250 {
251  if (avctx->codec_id == AV_CODEC_ID_LJPEG &&
252  ( avctx->pix_fmt == AV_PIX_FMT_BGR0
253  || avctx->pix_fmt == AV_PIX_FMT_BGRA
254  || avctx->pix_fmt == AV_PIX_FMT_BGR24)) {
255  vsample[0] = hsample[0] =
256  vsample[1] = hsample[1] =
257  vsample[2] = hsample[2] =
258  vsample[3] = hsample[3] = 1;
259  } else if (avctx->pix_fmt == AV_PIX_FMT_YUV444P || avctx->pix_fmt == AV_PIX_FMT_YUVJ444P) {
260  vsample[0] = vsample[1] = vsample[2] = 2;
261  hsample[0] = hsample[1] = hsample[2] = 1;
262  } else {
263  int chroma_h_shift, chroma_v_shift;
264  av_pix_fmt_get_chroma_sub_sample(avctx->pix_fmt, &chroma_h_shift,
265  &chroma_v_shift);
266  vsample[0] = 2;
267  vsample[1] = 2 >> chroma_v_shift;
268  vsample[2] = 2 >> chroma_v_shift;
269  hsample[0] = 2;
270  hsample[1] = 2 >> chroma_h_shift;
271  hsample[2] = 2 >> chroma_h_shift;
272  }
273 }
274 
276  const AVFrame *frame, struct MJpegContext *m,
277  const uint8_t intra_matrix_permutation[64], int pred,
278  uint16_t luma_intra_matrix[64],
279  uint16_t chroma_intra_matrix[64],
280  int use_slices)
281 {
282  const int lossless = !m;
283  int hsample[4], vsample[4];
284  int components = 3 + (avctx->pix_fmt == AV_PIX_FMT_BGRA);
285  int chroma_matrix;
286 
287  ff_mjpeg_init_hvsample(avctx, hsample, vsample);
288 
289  put_marker(pb, SOI);
290 
291  // hack for AMV mjpeg format
292  if (avctx->codec_id == AV_CODEC_ID_AMV)
293  return;
294 
295  jpeg_put_comments(avctx, pb, frame);
296 
297  chroma_matrix = !lossless && !!memcmp(luma_intra_matrix,
298  chroma_intra_matrix,
299  sizeof(luma_intra_matrix[0]) * 64);
300  jpeg_table_header(avctx, pb, m, intra_matrix_permutation,
301  luma_intra_matrix, chroma_intra_matrix, hsample,
302  use_slices, chroma_matrix);
303 
304  switch (avctx->codec_id) {
305  case AV_CODEC_ID_MJPEG: put_marker(pb, SOF0 ); break;
306  case AV_CODEC_ID_LJPEG: put_marker(pb, SOF3 ); break;
307  default: av_assert0(0);
308  }
309 
310  put_bits(pb, 16, 8 + 3 * components);
311  if (lossless && ( avctx->pix_fmt == AV_PIX_FMT_BGR0
312  || avctx->pix_fmt == AV_PIX_FMT_BGRA
313  || avctx->pix_fmt == AV_PIX_FMT_BGR24))
314  put_bits(pb, 8, 9); /* 9 bits/component RCT */
315  else
316  put_bits(pb, 8, 8); /* 8 bits/component */
317  put_bits(pb, 16, avctx->height);
318  put_bits(pb, 16, avctx->width);
319  put_bits(pb, 8, components); /* 3 or 4 components */
320 
321  /* Y component */
322  put_bits(pb, 8, 1); /* component number */
323  put_bits(pb, 4, hsample[0]); /* H factor */
324  put_bits(pb, 4, vsample[0]); /* V factor */
325  put_bits(pb, 8, 0); /* select matrix */
326 
327  /* Cb component */
328  put_bits(pb, 8, 2); /* component number */
329  put_bits(pb, 4, hsample[1]); /* H factor */
330  put_bits(pb, 4, vsample[1]); /* V factor */
331  put_bits(pb, 8, lossless ? 0 : chroma_matrix); /* select matrix */
332 
333  /* Cr component */
334  put_bits(pb, 8, 3); /* component number */
335  put_bits(pb, 4, hsample[2]); /* H factor */
336  put_bits(pb, 4, vsample[2]); /* V factor */
337  put_bits(pb, 8, lossless ? 0 : chroma_matrix); /* select matrix */
338 
339  if (components == 4) {
340  put_bits(pb, 8, 4); /* component number */
341  put_bits(pb, 4, hsample[3]); /* H factor */
342  put_bits(pb, 4, vsample[3]); /* V factor */
343  put_bits(pb, 8, 0); /* select matrix */
344  }
345 
346  /* scan header */
347  put_marker(pb, SOS);
348  put_bits(pb, 16, 6 + 2*components); /* length */
349  put_bits(pb, 8, components); /* 3 components */
350 
351  /* Y component */
352  put_bits(pb, 8, 1); /* index */
353  put_bits(pb, 4, 0); /* DC huffman table index */
354  put_bits(pb, 4, 0); /* AC huffman table index */
355 
356  /* Cb component */
357  put_bits(pb, 8, 2); /* index */
358  put_bits(pb, 4, 1); /* DC huffman table index */
359  put_bits(pb, 4, lossless ? 0 : 1); /* AC huffman table index */
360 
361  /* Cr component */
362  put_bits(pb, 8, 3); /* index */
363  put_bits(pb, 4, 1); /* DC huffman table index */
364  put_bits(pb, 4, lossless ? 0 : 1); /* AC huffman table index */
365 
366  if (components == 4) {
367  /* Alpha component */
368  put_bits(pb, 8, 4); /* index */
369  put_bits(pb, 4, 0); /* DC huffman table index */
370  put_bits(pb, 4, 0); /* AC huffman table index */
371  }
372 
373  put_bits(pb, 8, pred); /* Ss (not used); pred only nonzero for LJPEG */
374 
375  switch (avctx->codec_id) {
376  case AV_CODEC_ID_MJPEG: put_bits(pb, 8, 63); break; /* Se (not used) */
377  case AV_CODEC_ID_LJPEG: put_bits(pb, 8, 0); break; /* not used */
378  default: av_assert0(0);
379  }
380 
381  put_bits(pb, 8, 0); /* Ah/Al (not used) */
382 }
383 
384 void ff_mjpeg_escape_FF(PutBitContext *pb, int start)
385 {
386  int size;
387  int i, ff_count;
388  uint8_t *buf = pb->buf + start;
389  int align= (-(size_t)(buf))&3;
390  int pad = (-put_bits_count(pb))&7;
391 
392  if (pad)
393  put_bits(pb, pad, (1<<pad)-1);
394 
395  flush_put_bits(pb);
396  size = put_bytes_output(pb) - start;
397 
398  ff_count=0;
399  for(i=0; i<size && i<align; i++){
400  if(buf[i]==0xFF) ff_count++;
401  }
402  for(; i<size-15; i+=16){
403  int acc, v;
404 
405  v= *(uint32_t*)(&buf[i]);
406  acc= (((v & (v>>4))&0x0F0F0F0F)+0x01010101)&0x10101010;
407  v= *(uint32_t*)(&buf[i+4]);
408  acc+=(((v & (v>>4))&0x0F0F0F0F)+0x01010101)&0x10101010;
409  v= *(uint32_t*)(&buf[i+8]);
410  acc+=(((v & (v>>4))&0x0F0F0F0F)+0x01010101)&0x10101010;
411  v= *(uint32_t*)(&buf[i+12]);
412  acc+=(((v & (v>>4))&0x0F0F0F0F)+0x01010101)&0x10101010;
413 
414  acc>>=4;
415  acc+= (acc>>16);
416  acc+= (acc>>8);
417  ff_count+= acc&0xFF;
418  }
419  for(; i<size; i++){
420  if(buf[i]==0xFF) ff_count++;
421  }
422 
423  if(ff_count==0) return;
424 
425  skip_put_bytes(pb, ff_count);
426 
427  for(i=size-1; ff_count; i--){
428  int v= buf[i];
429 
430  if(v==0xFF){
431  buf[i+ff_count]= 0;
432  ff_count--;
433  }
434 
435  buf[i+ff_count]= v;
436  }
437 }
438 
439 /* isn't this function nicer than the one in the libjpeg ? */
440 void ff_mjpeg_build_huffman_codes(uint8_t *huff_size, uint16_t *huff_code,
441  const uint8_t *bits_table,
442  const uint8_t *val_table)
443 {
444  int k, code;
445 
446  k = 0;
447  code = 0;
448  for (int i = 1; i <= 16; i++) {
449  int nb = bits_table[i];
450  for (int j = 0; j < nb; j++) {
451  int sym = val_table[k++];
452  huff_size[sym] = i;
453  huff_code[sym] = code;
454  code++;
455  }
456  code <<= 1;
457  }
458 }
459 
461 {
462  av_assert1((header_bits & 7) == 0);
463 
464  put_marker(pb, EOI);
465 }
466 
468  uint8_t *huff_size, uint16_t *huff_code)
469 {
470  int mant, nbits;
471 
472  if (val == 0) {
473  put_bits(pb, huff_size[0], huff_code[0]);
474  } else {
475  mant = val;
476  if (val < 0) {
477  val = -val;
478  mant--;
479  }
480 
481  nbits= av_log2_16bit(val) + 1;
482 
483  put_bits(pb, huff_size[nbits], huff_code[nbits]);
484 
485  put_sbits(pb, nbits, mant);
486  }
487 }
488 
490 {
492  avctx->color_range != AVCOL_RANGE_JPEG &&
493  (avctx->pix_fmt == AV_PIX_FMT_YUV420P ||
494  avctx->pix_fmt == AV_PIX_FMT_YUV422P ||
495  avctx->pix_fmt == AV_PIX_FMT_YUV444P ||
496  avctx->color_range == AVCOL_RANGE_MPEG)) {
497  av_log(avctx, AV_LOG_ERROR,
498  "Non full-range YUV is non-standard, set strict_std_compliance "
499  "to at most unofficial to use it.\n");
500  return AVERROR(EINVAL);
501  }
502  return 0;
503 }
ff_mjpeg_encode_dc
void ff_mjpeg_encode_dc(PutBitContext *pb, int val, uint8_t *huff_size, uint16_t *huff_code)
Definition: mjpegenc_common.c:467
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:215
jpegtables.h
mjpeg.h
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
LIBAVCODEC_IDENT
#define LIBAVCODEC_IDENT
Definition: version.h:43
AV_WL32
#define AV_WL32(p, v)
Definition: intreadwrite.h:422
jpeg_put_comments
static void jpeg_put_comments(AVCodecContext *avctx, PutBitContext *p, const AVFrame *frame)
Definition: mjpegenc_common.c:162
put_bytes_output
static int put_bytes_output(const PutBitContext *s)
Definition: put_bits.h:89
SOS
@ SOS
Definition: mjpeg.h:72
mjpegenc_common.h
av_frame_get_side_data
AVFrameSideData * av_frame_get_side_data(const AVFrame *frame, enum AVFrameSideDataType type)
Definition: frame.c:963
SOF0
@ SOF0
Definition: mjpeg.h:39
put_sbits
static void put_sbits(PutBitContext *pb, int n, int32_t value)
Definition: put_bits.h:281
av_log2_16bit
int av_log2_16bit(unsigned v)
Definition: intmath.c:31
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:389
MJpegContext::bits_ac_chrominance
uint8_t bits_ac_chrominance[17]
AC chrominance Huffman bits.
Definition: mjpegenc.h:88
put_bits
static void put_bits(Jpeg2000EncoderContext *s, int val, int n)
put n times val bit
Definition: j2kenc.c:223
pixdesc.h
AVCOL_RANGE_JPEG
@ AVCOL_RANGE_JPEG
Full range content.
Definition: pixfmt.h:717
data
const char data[16]
Definition: mxf.c:149
MJpegContext::val_dc_chrominance
uint8_t val_dc_chrominance[12]
DC chrominance Huffman values.
Definition: mjpegenc.h:83
MJpegContext::huffman
int huffman
Definition: mjpegenc.h:60
ff_mjpeg_val_dc
const uint8_t ff_mjpeg_val_dc[]
Definition: jpegtabs.h:34
version.h
AV_PIX_FMT_BGR24
@ AV_PIX_FMT_BGR24
packed RGB 8:8:8, 24bpp, BGRBGR...
Definition: pixfmt.h:76
AV_PIX_FMT_BGRA
@ AV_PIX_FMT_BGRA
packed BGRA 8:8:8:8, 32bpp, BGRABGRA...
Definition: pixfmt.h:102
put_huffman_table
static int put_huffman_table(PutBitContext *p, int table_class, int table_id, const uint8_t *bits_table, const uint8_t *value_table)
Definition: mjpegenc_common.c:39
MJpegContext::force_duplicated_matrix
int force_duplicated_matrix
Definition: mjpegenc.h:62
ff_mjpeg_bits_ac_chrominance
const uint8_t ff_mjpeg_bits_ac_chrominance[]
Definition: jpegtabs.h:66
ICC_HDR_SIZE
@ ICC_HDR_SIZE
Definition: mjpegenc_common.c:132
ICC_CHUNK_SIZE
@ ICC_CHUNK_SIZE
Definition: mjpegenc_common.c:133
SOF3
@ SOF3
Definition: mjpeg.h:42
AVCodecContext::flags
int flags
AV_CODEC_FLAG_*.
Definition: avcodec.h:508
val
static double val(void *priv, double ch)
Definition: aeval.c:77
av_pix_fmt_get_chroma_sub_sample
int av_pix_fmt_get_chroma_sub_sample(enum AVPixelFormat pix_fmt, int *h_shift, int *v_shift)
Utility function to access log2_chroma_w log2_chroma_h from the pixel format AVPixFmtDescriptor.
Definition: pixdesc.c:3198
av_reduce
int av_reduce(int *dst_num, int *dst_den, int64_t num, int64_t den, int64_t max)
Reduce a fraction.
Definition: rational.c:35
AVRational::num
int num
Numerator.
Definition: rational.h:59
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:209
AVFrameSideData::size
size_t size
Definition: frame.h:268
MJpegContext::bits_dc_luminance
uint8_t bits_dc_luminance[17]
DC luminance Huffman bits.
Definition: mjpegenc.h:80
COM
@ COM
Definition: mjpeg.h:111
MJpegContext::val_dc_luminance
uint8_t val_dc_luminance[12]
DC luminance Huffman values.
Definition: mjpegenc.h:81
HUFFMAN_TABLE_OPTIMAL
@ HUFFMAN_TABLE_OPTIMAL
Compute and use optimal Huffman tables.
Definition: mjpegenc.h:100
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:40
MJpegContext::val_ac_chrominance
uint8_t val_ac_chrominance[256]
AC chrominance Huffman values.
Definition: mjpegenc.h:89
ff_put_string
void ff_put_string(PutBitContext *pb, const char *string, int terminate_string)
Put the string string in the bitstream.
Definition: bitstream.c:39
AV_PIX_FMT_YUV420P
@ AV_PIX_FMT_YUV420P
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
Definition: pixfmt.h:73
PutBitContext
Definition: put_bits.h:50
AV_PIX_FMT_YUVJ444P
@ AV_PIX_FMT_YUVJ444P
planar YUV 4:4:4, 24bpp, full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV444P and setting col...
Definition: pixfmt.h:87
AVCodecContext::codec_id
enum AVCodecID codec_id
Definition: avcodec.h:461
ICC_MAX_CHUNKS
@ ICC_MAX_CHUNKS
Definition: mjpegenc_common.c:134
ff_mjpeg_encode_picture_header
void ff_mjpeg_encode_picture_header(AVCodecContext *avctx, PutBitContext *pb, const AVFrame *frame, struct MJpegContext *m, const uint8_t intra_matrix_permutation[64], int pred, uint16_t luma_intra_matrix[64], uint16_t chroma_intra_matrix[64], int use_slices)
Definition: mjpegenc_common.c:275
PutBitContext::buf
uint8_t * buf
Definition: put_bits.h:53
NULL
#define NULL
Definition: coverity.c:32
AVCodecContext::color_range
enum AVColorRange color_range
MPEG vs JPEG YUV range.
Definition: avcodec.h:701
AV_WB16
#define AV_WB16(p, v)
Definition: intreadwrite.h:401
AVRational
Rational number (pair of numerator and denominator).
Definition: rational.h:58
AV_FRAME_DATA_ICC_PROFILE
@ AV_FRAME_DATA_ICC_PROFILE
The data contains an ICC profile as an opaque octet buffer following the format described by ISO 1507...
Definition: frame.h:144
AV_PIX_FMT_BGR0
@ AV_PIX_FMT_BGR0
packed BGR 8:8:8, 32bpp, BGRXBGRX... X=unused/undefined
Definition: pixfmt.h:265
ff_mjpeg_val_ac_chrominance
const uint8_t ff_mjpeg_val_ac_chrominance[]
Definition: jpegtabs.h:69
DRI
@ DRI
Definition: mjpeg.h:75
ff_mjpeg_val_ac_luminance
const uint8_t ff_mjpeg_val_ac_luminance[]
Definition: jpegtabs.h:42
jpeg_table_header
static void jpeg_table_header(AVCodecContext *avctx, PutBitContext *p, MJpegContext *m, const uint8_t intra_matrix_permutation[64], uint16_t luma_intra_matrix[64], uint16_t chroma_intra_matrix[64], int hsample[3], int use_slices, int matrices_differ)
Definition: mjpegenc_common.c:58
ff_mjpeg_bits_ac_luminance
const uint8_t ff_mjpeg_bits_ac_luminance[]
Definition: jpegtabs.h:40
size
int size
Definition: twinvq_data.h:10344
AVFrameSideData::data
uint8_t * data
Definition: frame.h:267
align
static const uint8_t *BS_FUNC() align(BSCTX *bc)
Skip bits to a byte boundary.
Definition: bitstream_template.h:411
FF_COMPLIANCE_UNOFFICIAL
#define FF_COMPLIANCE_UNOFFICIAL
Allow unofficial extensions.
Definition: defs.h:61
DQT
@ DQT
Definition: mjpeg.h:73
ff_mjpeg_add_icc_profile_size
int ff_mjpeg_add_icc_profile_size(AVCodecContext *avctx, const AVFrame *frame, size_t *max_pkt_size)
Definition: mjpegenc_common.c:137
ff_mjpeg_build_huffman_codes
void ff_mjpeg_build_huffman_codes(uint8_t *huff_size, uint16_t *huff_code, const uint8_t *bits_table, const uint8_t *val_table)
Definition: mjpegenc_common.c:440
AV_CODEC_ID_MJPEG
@ AV_CODEC_ID_MJPEG
Definition: codec_id.h:59
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:256
code
and forward the test the status of outputs and forward it to the corresponding return FFERROR_NOT_READY If the filters stores internally one or a few frame for some it can consider them to be part of the FIFO and delay acknowledging a status change accordingly Example code
Definition: filter_design.txt:178
put_bits_count
static int put_bits_count(PutBitContext *s)
Definition: put_bits.h:80
EOI
@ EOI
Definition: mjpeg.h:71
av_assert1
#define av_assert1(cond)
assert() equivalent, that does not lie in speed critical code.
Definition: avassert.h:56
FFMIN
#define FFMIN(a, b)
Definition: macros.h:49
ff_mjpeg_encode_check_pix_fmt
int ff_mjpeg_encode_check_pix_fmt(AVCodecContext *avctx)
Definition: mjpegenc_common.c:489
DHT
@ DHT
Definition: mjpeg.h:56
AVCodecContext::height
int height
Definition: avcodec.h:624
AVCodecContext::pix_fmt
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:663
AVCOL_RANGE_MPEG
@ AVCOL_RANGE_MPEG
Narrow or limited range content.
Definition: pixfmt.h:700
idctdsp.h
avcodec.h
MJpegContext::bits_dc_chrominance
uint8_t bits_dc_chrominance[17]
DC chrominance Huffman bits.
Definition: mjpegenc.h:82
pred
static const float pred[4]
Definition: siprdata.h:259
pixfmt.h
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
AVCodecContext::strict_std_compliance
int strict_std_compliance
strictly follow the standard (MPEG-4, ...).
Definition: avcodec.h:1389
SIZE_SPECIFIER
#define SIZE_SPECIFIER
Definition: internal.h:129
AV_CODEC_ID_AMV
@ AV_CODEC_ID_AMV
Definition: codec_id.h:159
AVCodecContext
main external API structure.
Definition: avcodec.h:451
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:377
AVRational::den
int den
Denominator.
Definition: rational.h:60
APP2
@ APP2
Definition: mjpeg.h:81
ff_mjpeg_escape_FF
void ff_mjpeg_escape_FF(PutBitContext *pb, int start)
Definition: mjpegenc_common.c:384
skip_put_bytes
static void skip_put_bytes(PutBitContext *s, int n)
Skip the given number of bytes.
Definition: put_bits.h:386
MJpegContext
Holds JPEG frame data and Huffman table data.
Definition: mjpegenc.h:59
put_marker
static void put_marker(PutBitContext *p, enum JpegMarker code)
Definition: mjpegenc.h:104
AV_PIX_FMT_YUV444P
@ AV_PIX_FMT_YUV444P
planar YUV 4:4:4, 24bpp, (1 Cr & Cb sample per 1x1 Y samples)
Definition: pixfmt.h:78
ff_mjpeg_bits_dc_chrominance
const uint8_t ff_mjpeg_bits_dc_chrominance[]
Definition: jpegtabs.h:37
APP0
@ APP0
Definition: mjpeg.h:79
AV_PIX_FMT_YUV422P
@ AV_PIX_FMT_YUV422P
planar YUV 4:2:2, 16bpp, (1 Cr & Cb sample per 2x1 Y samples)
Definition: pixfmt.h:77
AV_CODEC_FLAG_BITEXACT
#define AV_CODEC_FLAG_BITEXACT
Use only bitexact stuff (except (I)DCT).
Definition: avcodec.h:342
SOI
@ SOI
Definition: mjpeg.h:70
ff_mjpeg_init_hvsample
void ff_mjpeg_init_hvsample(AVCodecContext *avctx, int hsample[4], int vsample[4])
Definition: mjpegenc_common.c:249
AVFrameSideData
Structure to hold side data for an AVFrame.
Definition: frame.h:265
flush_put_bits
static void flush_put_bits(PutBitContext *s)
Pad the end of the output stream with zeros.
Definition: put_bits.h:143
ff_mjpeg_bits_dc_luminance
const FF_VISIBILITY_PUSH_HIDDEN uint8_t ff_mjpeg_bits_dc_luminance[]
Definition: jpegtabs.h:32
AVCodecContext::width
int width
picture width / height.
Definition: avcodec.h:624
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
ff_mjpeg_encode_picture_trailer
void ff_mjpeg_encode_picture_trailer(PutBitContext *pb, int header_bits)
Definition: mjpegenc_common.c:460
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
MJpegContext::bits_ac_luminance
uint8_t bits_ac_luminance[17]
AC luminance Huffman bits.
Definition: mjpegenc.h:86
MJpegContext::val_ac_luminance
uint8_t val_ac_luminance[256]
AC luminance Huffman values.
Definition: mjpegenc.h:87
put_bits.h
mjpegenc.h
AV_CODEC_ID_LJPEG
@ AV_CODEC_ID_LJPEG
Definition: codec_id.h:61
AVCodecContext::sample_aspect_ratio
AVRational sample_aspect_ratio
sample aspect ratio (0 if unknown) That is the width of a pixel divided by the height of the pixel.
Definition: avcodec.h:648