FFmpeg  2.8.15
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Modules Pages
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/common.h"
27 #include "libavutil/pixdesc.h"
28 #include "libavutil/pixfmt.h"
29 
30 #include "avcodec.h"
31 #include "idctdsp.h"
32 #include "jpegtables.h"
33 #include "put_bits.h"
34 #include "mjpegenc.h"
35 #include "mjpegenc_common.h"
36 #include "mjpeg.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, i;
43 
44  put_bits(p, 4, table_class);
45  put_bits(p, 4, table_id);
46 
47  n = 0;
48  for(i=1;i<=16;i++) {
49  n += bits_table[i];
50  put_bits(p, 8, bits_table[i]);
51  }
52 
53  for(i=0;i<n;i++)
54  put_bits(p, 8, value_table[i]);
55 
56  return n + 17;
57 }
58 
60  ScanTable *intra_scantable,
61  uint16_t luma_intra_matrix[64],
62  uint16_t chroma_intra_matrix[64],
63  int hsample[3])
64 {
65  int i, j, size;
66  uint8_t *ptr;
67 
68  if (avctx->codec_id != AV_CODEC_ID_LJPEG) {
69  int matrix_count = 1 + !!memcmp(luma_intra_matrix,
70  chroma_intra_matrix,
71  sizeof(luma_intra_matrix[0]) * 64);
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(i=0;i<64;i++) {
78  j = intra_scantable->permutated[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(i=0;i<64;i++) {
86  j = intra_scantable->permutated[i];
87  put_bits(p, 8, chroma_intra_matrix[j]);
88  }
89  }
90  }
91 
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;
108 
113  AV_WB16(ptr, size);
114 }
115 
117 {
118  int size;
119  uint8_t *ptr;
120 
121  if (avctx->sample_aspect_ratio.num > 0 && avctx->sample_aspect_ratio.den > 0) {
122  AVRational sar = avctx->sample_aspect_ratio;
123 
124  if (sar.num > 65535 || sar.den > 65535) {
125  if (!av_reduce(&sar.num, &sar.den, avctx->sample_aspect_ratio.num, avctx->sample_aspect_ratio.den, 65535))
126  av_log(avctx, AV_LOG_WARNING,
127  "Cannot store exact aspect ratio %d:%d\n",
128  avctx->sample_aspect_ratio.num,
129  avctx->sample_aspect_ratio.den);
130  }
131 
132  /* JFIF header */
133  put_marker(p, APP0);
134  put_bits(p, 16, 16);
135  avpriv_put_string(p, "JFIF", 1); /* this puts the trailing zero-byte too */
136  /* The most significant byte is used for major revisions, the least
137  * significant byte for minor revisions. Version 1.02 is the current
138  * released revision. */
139  put_bits(p, 16, 0x0102);
140  put_bits(p, 8, 0); /* units type: 0 - aspect ratio */
141  put_bits(p, 16, sar.num);
142  put_bits(p, 16, sar.den);
143  put_bits(p, 8, 0); /* thumbnail width */
144  put_bits(p, 8, 0); /* thumbnail height */
145  }
146 
147  /* comment */
148  if (!(avctx->flags & AV_CODEC_FLAG_BITEXACT)) {
149  put_marker(p, COM);
150  flush_put_bits(p);
151  ptr = put_bits_ptr(p);
152  put_bits(p, 16, 0); /* patched later */
154  size = strlen(LIBAVCODEC_IDENT)+3;
155  AV_WB16(ptr, size);
156  }
157 
158  if (((avctx->pix_fmt == AV_PIX_FMT_YUV420P ||
159  avctx->pix_fmt == AV_PIX_FMT_YUV422P ||
160  avctx->pix_fmt == AV_PIX_FMT_YUV444P) && avctx->color_range != AVCOL_RANGE_JPEG)
161  || avctx->color_range == AVCOL_RANGE_MPEG) {
162  put_marker(p, COM);
163  flush_put_bits(p);
164  ptr = put_bits_ptr(p);
165  put_bits(p, 16, 0); /* patched later */
166  avpriv_put_string(p, "CS=ITU601", 1);
167  size = strlen("CS=ITU601")+3;
168  AV_WB16(ptr, size);
169  }
170 }
171 
172 void ff_mjpeg_init_hvsample(AVCodecContext *avctx, int hsample[3], int vsample[3])
173 {
174  int chroma_h_shift, chroma_v_shift;
175 
176  av_pix_fmt_get_chroma_sub_sample(avctx->pix_fmt, &chroma_h_shift,
177  &chroma_v_shift);
178  if (avctx->codec->id == AV_CODEC_ID_LJPEG &&
179  ( avctx->pix_fmt == AV_PIX_FMT_BGR0
180  || avctx->pix_fmt == AV_PIX_FMT_BGRA
181  || avctx->pix_fmt == AV_PIX_FMT_BGR24)) {
182  vsample[0] = hsample[0] =
183  vsample[1] = hsample[1] =
184  vsample[2] = hsample[2] = 1;
185  } else if (avctx->pix_fmt == AV_PIX_FMT_YUV444P || avctx->pix_fmt == AV_PIX_FMT_YUVJ444P) {
186  vsample[0] = vsample[1] = vsample[2] = 2;
187  hsample[0] = hsample[1] = hsample[2] = 1;
188  } else {
189  vsample[0] = 2;
190  vsample[1] = 2 >> chroma_v_shift;
191  vsample[2] = 2 >> chroma_v_shift;
192  hsample[0] = 2;
193  hsample[1] = 2 >> chroma_h_shift;
194  hsample[2] = 2 >> chroma_h_shift;
195  }
196 }
197 
199  ScanTable *intra_scantable,
200  uint16_t luma_intra_matrix[64],
201  uint16_t chroma_intra_matrix[64])
202 {
203  const int lossless = avctx->codec_id != AV_CODEC_ID_MJPEG && avctx->codec_id != AV_CODEC_ID_AMV;
204  int hsample[3], vsample[3];
205  int i;
206  int chroma_matrix = !!memcmp(luma_intra_matrix,
207  chroma_intra_matrix,
208  sizeof(luma_intra_matrix[0])*64);
209 
210  ff_mjpeg_init_hvsample(avctx, hsample, vsample);
211 
212  put_marker(pb, SOI);
213 
214  // hack for AMV mjpeg format
215  if(avctx->codec_id == AV_CODEC_ID_AMV) goto end;
216 
217  jpeg_put_comments(avctx, pb);
218 
219  jpeg_table_header(avctx, pb, intra_scantable, luma_intra_matrix, chroma_intra_matrix, hsample);
220 
221  switch (avctx->codec_id) {
222  case AV_CODEC_ID_MJPEG: put_marker(pb, SOF0 ); break;
223  case AV_CODEC_ID_LJPEG: put_marker(pb, SOF3 ); break;
224  default: av_assert0(0);
225  }
226 
227  put_bits(pb, 16, 17);
228  if (lossless && ( avctx->pix_fmt == AV_PIX_FMT_BGR0
229  || avctx->pix_fmt == AV_PIX_FMT_BGRA
230  || avctx->pix_fmt == AV_PIX_FMT_BGR24))
231  put_bits(pb, 8, 9); /* 9 bits/component RCT */
232  else
233  put_bits(pb, 8, 8); /* 8 bits/component */
234  put_bits(pb, 16, avctx->height);
235  put_bits(pb, 16, avctx->width);
236  put_bits(pb, 8, 3); /* 3 components */
237 
238  /* Y component */
239  put_bits(pb, 8, 1); /* component number */
240  put_bits(pb, 4, hsample[0]); /* H factor */
241  put_bits(pb, 4, vsample[0]); /* V factor */
242  put_bits(pb, 8, 0); /* select matrix */
243 
244  /* Cb component */
245  put_bits(pb, 8, 2); /* component number */
246  put_bits(pb, 4, hsample[1]); /* H factor */
247  put_bits(pb, 4, vsample[1]); /* V factor */
248  put_bits(pb, 8, lossless ? 0 : chroma_matrix); /* select matrix */
249 
250  /* Cr component */
251  put_bits(pb, 8, 3); /* component number */
252  put_bits(pb, 4, hsample[2]); /* H factor */
253  put_bits(pb, 4, vsample[2]); /* V factor */
254  put_bits(pb, 8, lossless ? 0 : chroma_matrix); /* select matrix */
255 
256  /* scan header */
257  put_marker(pb, SOS);
258  put_bits(pb, 16, 12); /* length */
259  put_bits(pb, 8, 3); /* 3 components */
260 
261  /* Y component */
262  put_bits(pb, 8, 1); /* index */
263  put_bits(pb, 4, 0); /* DC huffman table index */
264  put_bits(pb, 4, 0); /* AC huffman table index */
265 
266  /* Cb component */
267  put_bits(pb, 8, 2); /* index */
268  put_bits(pb, 4, 1); /* DC huffman table index */
269  put_bits(pb, 4, lossless ? 0 : 1); /* AC huffman table index */
270 
271  /* Cr component */
272  put_bits(pb, 8, 3); /* index */
273  put_bits(pb, 4, 1); /* DC huffman table index */
274  put_bits(pb, 4, lossless ? 0 : 1); /* AC huffman table index */
275 
276  put_bits(pb, 8, lossless ? avctx->prediction_method + 1 : 0); /* Ss (not used) */
277 
278  switch (avctx->codec_id) {
279  case AV_CODEC_ID_MJPEG: put_bits(pb, 8, 63); break; /* Se (not used) */
280  case AV_CODEC_ID_LJPEG: put_bits(pb, 8, 0); break; /* not used */
281  default: av_assert0(0);
282  }
283 
284  put_bits(pb, 8, 0); /* Ah/Al (not used) */
285 
286 end:
287  if (!lossless) {
288  MpegEncContext *s = avctx->priv_data;
289  av_assert0(avctx->codec->priv_data_size == sizeof(MpegEncContext));
290 
291  s->esc_pos = put_bits_count(pb) >> 3;
292  for(i=1; i<s->slice_context_count; i++)
293  s->thread_context[i]->esc_pos = 0;
294  }
295 }
296 
298 {
299  int size;
300  int i, ff_count;
301  uint8_t *buf = pb->buf + start;
302  int align= (-(size_t)(buf))&3;
303  int pad = (-put_bits_count(pb))&7;
304 
305  if (pad)
306  put_bits(pb, pad, (1<<pad)-1);
307 
308  flush_put_bits(pb);
309  size = put_bits_count(pb) - start * 8;
310 
311  av_assert1((size&7) == 0);
312  size >>= 3;
313 
314  ff_count=0;
315  for(i=0; i<size && i<align; i++){
316  if(buf[i]==0xFF) ff_count++;
317  }
318  for(; i<size-15; i+=16){
319  int acc, v;
320 
321  v= *(uint32_t*)(&buf[i]);
322  acc= (((v & (v>>4))&0x0F0F0F0F)+0x01010101)&0x10101010;
323  v= *(uint32_t*)(&buf[i+4]);
324  acc+=(((v & (v>>4))&0x0F0F0F0F)+0x01010101)&0x10101010;
325  v= *(uint32_t*)(&buf[i+8]);
326  acc+=(((v & (v>>4))&0x0F0F0F0F)+0x01010101)&0x10101010;
327  v= *(uint32_t*)(&buf[i+12]);
328  acc+=(((v & (v>>4))&0x0F0F0F0F)+0x01010101)&0x10101010;
329 
330  acc>>=4;
331  acc+= (acc>>16);
332  acc+= (acc>>8);
333  ff_count+= acc&0xFF;
334  }
335  for(; i<size; i++){
336  if(buf[i]==0xFF) ff_count++;
337  }
338 
339  if(ff_count==0) return;
340 
341  flush_put_bits(pb);
342  skip_put_bytes(pb, ff_count);
343 
344  for(i=size-1; ff_count; i--){
345  int v= buf[i];
346 
347  if(v==0xFF){
348  buf[i+ff_count]= 0;
349  ff_count--;
350  }
351 
352  buf[i+ff_count]= v;
353  }
354 }
355 
357 {
358  int i;
359  PutBitContext *pbc = &s->pb;
360  int mb_y = s->mb_y - !s->mb_x;
361 
362  int ret = ff_mpv_reallocate_putbitbuffer(s, put_bits_count(&s->pb) / 8 + 100,
363  put_bits_count(&s->pb) / 4 + 1000);
364  if (ret < 0) {
365  av_log(s->avctx, AV_LOG_ERROR, "Buffer reallocation failed\n");
366  goto fail;
367  }
368 
369  ff_mjpeg_escape_FF(pbc, s->esc_pos);
370 
371  if((s->avctx->active_thread_type & FF_THREAD_SLICE) && mb_y < s->mb_height)
372  put_marker(pbc, RST0 + (mb_y&7));
373  s->esc_pos = put_bits_count(pbc) >> 3;
374 fail:
375 
376  for(i=0; i<3; i++)
377  s->last_dc[i] = 128 << s->intra_dc_precision;
378 
379  return ret;
380 }
381 
383 {
384  av_assert1((header_bits & 7) == 0);
385 
386  put_marker(pb, EOI);
387 }
388 
390  uint8_t *huff_size, uint16_t *huff_code)
391 {
392  int mant, nbits;
393 
394  if (val == 0) {
395  put_bits(pb, huff_size[0], huff_code[0]);
396  } else {
397  mant = val;
398  if (val < 0) {
399  val = -val;
400  mant--;
401  }
402 
403  nbits= av_log2_16bit(val) + 1;
404 
405  put_bits(pb, huff_size[nbits], huff_code[nbits]);
406 
407  put_sbits(pb, nbits, mant);
408  }
409 }
const struct AVCodec * codec
Definition: avcodec.h:1521
const char const char void * val
Definition: avisynth_c.h:634
float v
const char * s
Definition: avisynth_c.h:631
Definition: mjpeg.h:71
Definition: mjpeg.h:111
Definition: mjpeg.h:73
static void put_sbits(PutBitContext *pb, int n, int32_t value)
Definition: put_bits.h:200
planar YUV 4:4:4, 24bpp, (1 Cr & Cb sample per 1x1 Y samples)
Definition: pixfmt.h:68
static void put_bits(Jpeg2000EncoderContext *s, int val, int n)
put n times val bit
Definition: j2kenc.c:205
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:182
Definition: mjpeg.h:42
int acc
Definition: yuv2rgb.c:532
MJPEG encoder.
enum AVColorRange color_range
MPEG vs JPEG YUV range.
Definition: avcodec.h:2247
Scantable.
Definition: idctdsp.h:29
int num
numerator
Definition: rational.h:44
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:1912
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:1732
Definition: mjpeg.h:75
uint8_t permutated[64]
Definition: idctdsp.h:31
void ff_mjpeg_encode_picture_header(AVCodecContext *avctx, PutBitContext *pb, ScanTable *intra_scantable, uint16_t luma_intra_matrix[64], uint16_t chroma_intra_matrix[64])
MJPEG encoder and decoder.
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
Definition: mjpeg.h:72
uint8_t
static av_cold int end(AVCodecContext *avctx)
Definition: avrndec.c:90
const uint8_t avpriv_mjpeg_bits_dc_luminance[17]
Definition: jpegtables.c:65
int intra_dc_precision
Definition: mpegvideo.h:465
ptrdiff_t size
Definition: opengl_enc.c:101
#define AV_WB16(p, v)
Definition: intreadwrite.h:405
#define av_log(a,...)
enum AVCodecID id
Definition: avcodec.h:3496
int slice_context_count
number of used thread_contexts
Definition: mpegvideo.h:163
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
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:227
int last_dc[3]
last DC values for MPEG1
Definition: mpegvideo.h:192
const uint8_t avpriv_mjpeg_bits_dc_chrominance[17]
Definition: jpegtables.c:70
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:2157
int active_thread_type
Which multithreading methods are in use by the codec.
Definition: avcodec.h:3062
packed BGRA 8:8:8:8, 32bpp, BGRABGRA...
Definition: pixfmt.h:97
int flags
AV_CODEC_FLAG_*.
Definition: avcodec.h:1607
uint8_t * buf
Definition: put_bits.h:38
void ff_mjpeg_encode_picture_trailer(PutBitContext *pb, int header_bits)
Libavcodec external API header.
#define fail()
Definition: checkasm.h:57
Definition: mjpeg.h:39
Definition: mjpeg.h:70
static int put_bits_count(PutBitContext *s)
Definition: put_bits.h:85
planar YUV 4:2:2, 16bpp, (1 Cr & Cb sample per 2x1 Y samples)
Definition: pixfmt.h:67
int ff_mpv_reallocate_putbitbuffer(MpegEncContext *s, size_t threshold, size_t size_increase)
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
Definition: mjpeg.h:79
static void put_marker(PutBitContext *p, enum JpegMarker code)
Definition: mjpegenc.h:54
Definition: mjpeg.h:56
static void skip_put_bytes(PutBitContext *s, int n)
Skip the given number of bytes.
Definition: put_bits.h:236
#define AV_CODEC_FLAG_BITEXACT
Use only bitexact stuff (except (I)DCT).
Definition: avcodec.h:788
#define av_assert1(cond)
assert() equivalent, that does not lie in speed critical code.
Definition: avassert.h:53
int width
picture width / height.
Definition: avcodec.h:1691
int priv_data_size
Definition: avcodec.h:3518
void ff_mjpeg_escape_FF(PutBitContext *pb, int start)
int n
Definition: avisynth_c.h:547
packed RGB 8:8:8, 24bpp, BGRBGR...
Definition: pixfmt.h:66
the normal 2^n-1 "JPEG" YUV ranges
Definition: pixfmt.h:540
const AVS_VideoInfo int align
Definition: avisynth_c.h:658
struct MpegEncContext * thread_context[MAX_THREADS]
Definition: mpegvideo.h:162
void ff_mjpeg_encode_dc(PutBitContext *pb, int val, uint8_t *huff_size, uint16_t *huff_code)
#define FF_THREAD_SLICE
Decode more than one part of a single frame at once.
Definition: avcodec.h:3055
enum AVCodecID codec_id
Definition: avcodec.h:1529
main external API structure.
Definition: avcodec.h:1512
void * buf
Definition: avisynth_c.h:553
static void jpeg_table_header(AVCodecContext *avctx, PutBitContext *p, ScanTable *intra_scantable, uint16_t luma_intra_matrix[64], uint16_t chroma_intra_matrix[64], int hsample[3])
const uint8_t avpriv_mjpeg_val_dc[12]
Definition: jpegtables.c:67
void ff_mjpeg_init_hvsample(AVCodecContext *avctx, int hsample[3], int vsample[3])
rational number numerator/denominator
Definition: rational.h:43
packed BGR 8:8:8, 32bpp, BGRXBGRX... X=unused/undefined
Definition: pixfmt.h:279
int ff_mjpeg_encode_stuffing(MpegEncContext *s)
const uint8_t avpriv_mjpeg_bits_ac_chrominance[17]
Definition: jpegtables.c:99
#define av_log2_16bit
Definition: intmath.h:101
const uint8_t avpriv_mjpeg_val_ac_chrominance[]
Definition: jpegtables.c:102
the normal 219*2^(n-8) "MPEG" YUV ranges
Definition: pixfmt.h:539
MpegEncContext.
Definition: mpegvideo.h:88
struct AVCodecContext * avctx
Definition: mpegvideo.h:105
PutBitContext pb
bit output
Definition: mpegvideo.h:158
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
Definition: pixfmt.h:63
static void flush_put_bits(PutBitContext *s)
Pad the end of the output stream with zeros.
Definition: put_bits.h:101
common internal and external API header
int prediction_method
prediction method (needed for huffyuv)
Definition: avcodec.h:1893
planar YUV 4:4:4, 24bpp, full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV444P and setting col...
Definition: pixfmt.h:77
int den
denominator
Definition: rational.h:45
const uint8_t avpriv_mjpeg_bits_ac_luminance[17]
Definition: jpegtables.c:73
void * priv_data
Definition: avcodec.h:1554
pixel format definitions
const uint8_t avpriv_mjpeg_val_ac_luminance[]
Definition: jpegtables.c:75
static int put_huffman_table(PutBitContext *p, int table_class, int table_id, const uint8_t *bits_table, const uint8_t *value_table)
#define LIBAVCODEC_IDENT
Definition: version.h:43
void avpriv_put_string(PutBitContext *pb, const char *string, int terminate_string)
Put the string string in the bitstream.
Definition: bitstream.c:53
void INT64 start
Definition: avisynth_c.h:553
static void jpeg_put_comments(AVCodecContext *avctx, PutBitContext *p)
Definition: mjpeg.h:61
bitstream writer API