FFmpeg
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups 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  /* JFIF header */
123  put_marker(p, APP0);
124  put_bits(p, 16, 16);
125  avpriv_put_string(p, "JFIF", 1); /* this puts the trailing zero-byte too */
126  /* The most significant byte is used for major revisions, the least
127  * significant byte for minor revisions. Version 1.02 is the current
128  * released revision. */
129  put_bits(p, 16, 0x0102);
130  put_bits(p, 8, 0); /* units type: 0 - aspect ratio */
131  put_bits(p, 16, avctx->sample_aspect_ratio.num);
132  put_bits(p, 16, avctx->sample_aspect_ratio.den);
133  put_bits(p, 8, 0); /* thumbnail width */
134  put_bits(p, 8, 0); /* thumbnail height */
135  }
136 
137  /* comment */
138  if (!(avctx->flags & CODEC_FLAG_BITEXACT)) {
139  put_marker(p, COM);
140  flush_put_bits(p);
141  ptr = put_bits_ptr(p);
142  put_bits(p, 16, 0); /* patched later */
144  size = strlen(LIBAVCODEC_IDENT)+3;
145  AV_WB16(ptr, size);
146  }
147 
148  if (avctx->pix_fmt == AV_PIX_FMT_YUV420P ||
149  avctx->pix_fmt == AV_PIX_FMT_YUV422P ||
150  avctx->pix_fmt == AV_PIX_FMT_YUV444P) {
151  put_marker(p, COM);
152  flush_put_bits(p);
153  ptr = put_bits_ptr(p);
154  put_bits(p, 16, 0); /* patched later */
155  avpriv_put_string(p, "CS=ITU601", 1);
156  size = strlen("CS=ITU601")+3;
157  AV_WB16(ptr, size);
158  }
159 }
160 
161 void ff_mjpeg_init_hvsample(AVCodecContext *avctx, int hsample[3], int vsample[3])
162 {
163  int chroma_h_shift, chroma_v_shift;
164 
165  av_pix_fmt_get_chroma_sub_sample(avctx->pix_fmt, &chroma_h_shift,
166  &chroma_v_shift);
167  if (avctx->codec->id == AV_CODEC_ID_LJPEG &&
168  ( avctx->pix_fmt == AV_PIX_FMT_BGR0
169  || avctx->pix_fmt == AV_PIX_FMT_BGRA
170  || avctx->pix_fmt == AV_PIX_FMT_BGR24)) {
171  vsample[0] = hsample[0] =
172  vsample[1] = hsample[1] =
173  vsample[2] = hsample[2] = 1;
174  } else if (avctx->pix_fmt == AV_PIX_FMT_YUV444P || avctx->pix_fmt == AV_PIX_FMT_YUVJ444P) {
175  vsample[0] = vsample[1] = vsample[2] = 2;
176  hsample[0] = hsample[1] = hsample[2] = 1;
177  } else {
178  vsample[0] = 2;
179  vsample[1] = 2 >> chroma_v_shift;
180  vsample[2] = 2 >> chroma_v_shift;
181  hsample[0] = 2;
182  hsample[1] = 2 >> chroma_h_shift;
183  hsample[2] = 2 >> chroma_h_shift;
184  }
185 }
186 
188  ScanTable *intra_scantable,
189  uint16_t luma_intra_matrix[64],
190  uint16_t chroma_intra_matrix[64])
191 {
192  const int lossless = avctx->codec_id != AV_CODEC_ID_MJPEG && avctx->codec_id != AV_CODEC_ID_AMV;
193  int hsample[3], vsample[3];
194  int i;
195  int chroma_matrix = !!memcmp(luma_intra_matrix,
196  chroma_intra_matrix,
197  sizeof(luma_intra_matrix[0])*64);
198 
199  ff_mjpeg_init_hvsample(avctx, hsample, vsample);
200 
201  put_marker(pb, SOI);
202 
203  // hack for AMV mjpeg format
204  if(avctx->codec_id == AV_CODEC_ID_AMV) goto end;
205 
206  jpeg_put_comments(avctx, pb);
207 
208  jpeg_table_header(avctx, pb, intra_scantable, luma_intra_matrix, chroma_intra_matrix, hsample);
209 
210  switch (avctx->codec_id) {
211  case AV_CODEC_ID_MJPEG: put_marker(pb, SOF0 ); break;
212  case AV_CODEC_ID_LJPEG: put_marker(pb, SOF3 ); break;
213  default: av_assert0(0);
214  }
215 
216  put_bits(pb, 16, 17);
217  if (lossless && ( avctx->pix_fmt == AV_PIX_FMT_BGR0
218  || avctx->pix_fmt == AV_PIX_FMT_BGRA
219  || avctx->pix_fmt == AV_PIX_FMT_BGR24))
220  put_bits(pb, 8, 9); /* 9 bits/component RCT */
221  else
222  put_bits(pb, 8, 8); /* 8 bits/component */
223  put_bits(pb, 16, avctx->height);
224  put_bits(pb, 16, avctx->width);
225  put_bits(pb, 8, 3); /* 3 components */
226 
227  /* Y component */
228  put_bits(pb, 8, 1); /* component number */
229  put_bits(pb, 4, hsample[0]); /* H factor */
230  put_bits(pb, 4, vsample[0]); /* V factor */
231  put_bits(pb, 8, 0); /* select matrix */
232 
233  /* Cb component */
234  put_bits(pb, 8, 2); /* component number */
235  put_bits(pb, 4, hsample[1]); /* H factor */
236  put_bits(pb, 4, vsample[1]); /* V factor */
237  put_bits(pb, 8, lossless ? 0 : chroma_matrix); /* select matrix */
238 
239  /* Cr component */
240  put_bits(pb, 8, 3); /* component number */
241  put_bits(pb, 4, hsample[2]); /* H factor */
242  put_bits(pb, 4, vsample[2]); /* V factor */
243  put_bits(pb, 8, lossless ? 0 : chroma_matrix); /* select matrix */
244 
245  /* scan header */
246  put_marker(pb, SOS);
247  put_bits(pb, 16, 12); /* length */
248  put_bits(pb, 8, 3); /* 3 components */
249 
250  /* Y component */
251  put_bits(pb, 8, 1); /* index */
252  put_bits(pb, 4, 0); /* DC huffman table index */
253  put_bits(pb, 4, 0); /* AC huffman table index */
254 
255  /* Cb component */
256  put_bits(pb, 8, 2); /* index */
257  put_bits(pb, 4, 1); /* DC huffman table index */
258  put_bits(pb, 4, lossless ? 0 : 1); /* AC huffman table index */
259 
260  /* Cr component */
261  put_bits(pb, 8, 3); /* index */
262  put_bits(pb, 4, 1); /* DC huffman table index */
263  put_bits(pb, 4, lossless ? 0 : 1); /* AC huffman table index */
264 
265  put_bits(pb, 8, lossless ? avctx->prediction_method + 1 : 0); /* Ss (not used) */
266 
267  switch (avctx->codec_id) {
268  case AV_CODEC_ID_MJPEG: put_bits(pb, 8, 63); break; /* Se (not used) */
269  case AV_CODEC_ID_LJPEG: put_bits(pb, 8, 0); break; /* not used */
270  default: av_assert0(0);
271  }
272 
273  put_bits(pb, 8, 0); /* Ah/Al (not used) */
274 
275 end:
276  if (!lossless) {
277  MpegEncContext *s = avctx->priv_data;
278  av_assert0(avctx->codec->priv_data_size == sizeof(MpegEncContext));
279 
280  s->esc_pos = put_bits_count(pb) >> 3;
281  for(i=1; i<s->slice_context_count; i++)
282  s->thread_context[i]->esc_pos = 0;
283  }
284 }
285 
287 {
288  int size;
289  int i, ff_count;
290  uint8_t *buf = pb->buf + start;
291  int align= (-(size_t)(buf))&3;
292  int pad = (-put_bits_count(pb))&7;
293 
294  if (pad)
295  put_bits(pb, pad, (1<<pad)-1);
296 
297  flush_put_bits(pb);
298  size = put_bits_count(pb) - start * 8;
299 
300  av_assert1((size&7) == 0);
301  size >>= 3;
302 
303  ff_count=0;
304  for(i=0; i<size && i<align; i++){
305  if(buf[i]==0xFF) ff_count++;
306  }
307  for(; i<size-15; i+=16){
308  int acc, v;
309 
310  v= *(uint32_t*)(&buf[i]);
311  acc= (((v & (v>>4))&0x0F0F0F0F)+0x01010101)&0x10101010;
312  v= *(uint32_t*)(&buf[i+4]);
313  acc+=(((v & (v>>4))&0x0F0F0F0F)+0x01010101)&0x10101010;
314  v= *(uint32_t*)(&buf[i+8]);
315  acc+=(((v & (v>>4))&0x0F0F0F0F)+0x01010101)&0x10101010;
316  v= *(uint32_t*)(&buf[i+12]);
317  acc+=(((v & (v>>4))&0x0F0F0F0F)+0x01010101)&0x10101010;
318 
319  acc>>=4;
320  acc+= (acc>>16);
321  acc+= (acc>>8);
322  ff_count+= acc&0xFF;
323  }
324  for(; i<size; i++){
325  if(buf[i]==0xFF) ff_count++;
326  }
327 
328  if(ff_count==0) return;
329 
330  flush_put_bits(pb);
331  skip_put_bytes(pb, ff_count);
332 
333  for(i=size-1; ff_count; i--){
334  int v= buf[i];
335 
336  if(v==0xFF){
337  buf[i+ff_count]= 0;
338  ff_count--;
339  }
340 
341  buf[i+ff_count]= v;
342  }
343 }
344 
346 {
347  int i;
348  PutBitContext *pbc = &s->pb;
349  int mb_y = s->mb_y - !s->mb_x;
350 
351  int ret = ff_mpv_reallocate_putbitbuffer(s, put_bits_count(&s->pb) / 8 + 100,
352  put_bits_count(&s->pb) / 4 + 1000);
353  if (ret < 0) {
354  av_log(s->avctx, AV_LOG_ERROR, "Buffer reallocation failed\n");
355  goto fail;
356  }
357 
358  ff_mjpeg_escape_FF(pbc, s->esc_pos);
359 
360  if((s->avctx->active_thread_type & FF_THREAD_SLICE) && mb_y < s->mb_height)
361  put_marker(pbc, RST0 + (mb_y&7));
362  s->esc_pos = put_bits_count(pbc) >> 3;
363 fail:
364 
365  for(i=0; i<3; i++)
366  s->last_dc[i] = 128 << s->intra_dc_precision;
367 
368  return ret;
369 }
370 
372 {
373  av_assert1((header_bits & 7) == 0);
374 
375  put_marker(pb, EOI);
376 }
377 
379  uint8_t *huff_size, uint16_t *huff_code)
380 {
381  int mant, nbits;
382 
383  if (val == 0) {
384  put_bits(pb, huff_size[0], huff_code[0]);
385  } else {
386  mant = val;
387  if (val < 0) {
388  val = -val;
389  mant--;
390  }
391 
392  nbits= av_log2_16bit(val) + 1;
393 
394  put_bits(pb, huff_size[nbits], huff_code[nbits]);
395 
396  put_sbits(pb, nbits, mant);
397  }
398 }
const struct AVCodec * codec
Definition: avcodec.h:1250
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:192
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:160
Definition: mjpeg.h:42
int acc
Definition: yuv2rgb.c:532
MJPEG encoder.
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:1623
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:1444
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])
int av_log2_16bit(unsigned v)
Definition: intmath.c:31
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:67
const uint8_t avpriv_mjpeg_bits_dc_luminance[17]
Definition: jpegtables.c:65
int intra_dc_precision
Definition: mpegvideo.h:523
#define CODEC_FLAG_BITEXACT
Use only bitexact stuff (except (I)DCT).
Definition: avcodec.h:759
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:3195
int slice_context_count
number of used thread_contexts
Definition: mpegvideo.h:225
#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:219
int last_dc[3]
last DC values for MPEG1
Definition: mpegvideo.h:254
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:2118
int active_thread_type
Which multithreading methods are in use by the codec.
Definition: avcodec.h:2772
packed BGRA 8:8:8:8, 32bpp, BGRABGRA...
Definition: pixfmt.h:97
int flags
CODEC_FLAG_*.
Definition: avcodec.h:1335
uint8_t * buf
Definition: put_bits.h:38
void ff_mjpeg_encode_picture_trailer(PutBitContext *pb, int header_bits)
Libavcodec external API header.
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)
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:228
#define av_assert1(cond)
assert() equivalent, that does not lie in speed critical code.
Definition: avassert.h:53
ret
Definition: avfilter.c:974
int width
picture width / height.
Definition: avcodec.h:1414
int priv_data_size
Definition: avcodec.h:3219
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
const AVS_VideoInfo int align
Definition: avisynth_c.h:658
struct MpegEncContext * thread_context[MAX_THREADS]
Definition: mpegvideo.h:224
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:2765
enum AVCodecID codec_id
Definition: avcodec.h:1258
main external API structure.
Definition: avcodec.h:1241
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])
packed BGR 8:8:8, 32bpp, BGRXBGRX... X=unused/undefined
Definition: pixfmt.h:267
int ff_mjpeg_encode_stuffing(MpegEncContext *s)
const uint8_t avpriv_mjpeg_bits_ac_chrominance[17]
Definition: jpegtables.c:99
const uint8_t avpriv_mjpeg_val_ac_chrominance[]
Definition: jpegtables.c:102
MpegEncContext.
Definition: mpegvideo.h:150
struct AVCodecContext * avctx
Definition: mpegvideo.h:167
PutBitContext pb
bit output
Definition: mpegvideo.h:220
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:1604
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:1283
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