2 * straightforward (to be) optimized JPEG encoder for the YUV422 format
3 * based on MJPEG code from FFmpeg
5 * For an excellent introduction to the JPEG format, see:
6 * http://www.ece.purdue.edu/~bouman/grad-labs/lab8/pdf/lab.pdf
8 * Copyright (c) 2002, Rik Snel
9 * parts from FFmpeg Copyright (c) 2000-2002 Fabrice Bellard
11 * This file is part of MPlayer.
13 * MPlayer is free software; you can redistribute it and/or modify
14 * it under the terms of the GNU General Public License as published by
15 * the Free Software Foundation; either version 2 of the License, or
16 * (at your option) any later version.
18 * MPlayer is distributed in the hope that it will be useful,
19 * but WITHOUT ANY WARRANTY; without even the implied warranty of
20 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
21 * GNU General Public License for more details.
23 * You should have received a copy of the GNU General Public License along
24 * with MPlayer; if not, write to the Free Software Foundation, Inc.,
25 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
30 #include <sys/types.h>
35 /* We need this #define because we need ../libavcodec/common.h to #define
36 * be2me_32, otherwise the linker will complain that it doesn't exist */
37 #define HAVE_AV_CONFIG_H
38 #include "libavcodec/avcodec.h"
39 #include "libavcodec/dsputil.h"
40 #include "libavcodec/mpegvideo.h"
41 #include "libavcodec/mjpegenc.h"
45 extern int avcodec_initialized
;
48 /* Begin excessive code duplication ************************************/
49 /* Code coming from mpegvideo.c and mjpeg.c in ../libavcodec ***********/
51 static const unsigned short aanscales
[64] = {
52 /* precomputed values scaled up by 14 bits */
53 16384, 22725, 21407, 19266, 16384, 12873, 8867, 4520,
54 22725, 31521, 29692, 26722, 22725, 17855, 12299, 6270,
55 21407, 29692, 27969, 25172, 21407, 16819, 11585, 5906,
56 19266, 26722, 25172, 22654, 19266, 15137, 10426, 5315,
57 16384, 22725, 21407, 19266, 16384, 12873, 8867, 4520,
58 12873, 17855, 16819, 15137, 12873, 10114, 6967, 3552,
59 8867, 12299, 11585, 10426, 8867, 6967, 4799, 2446,
60 4520, 6270, 5906, 5315, 4520, 3552, 2446, 1247
63 static void convert_matrix(MpegEncContext
*s
, int (*qmat
)[64],
64 uint16_t (*qmat16
)[2][64], const uint16_t *quant_matrix
,
65 int bias
, int qmin
, int qmax
)
69 for(qscale
=qmin
; qscale
<=qmax
; qscale
++){
71 if (s
->dsp
.fdct
== ff_jpeg_fdct_islow
) {
72 for (i
= 0; i
< 64; i
++) {
73 const int j
= s
->dsp
.idct_permutation
[i
];
74 /* 16 <= qscale * quant_matrix[i] <= 7905
75 * 19952 <= aanscales[i] * \
76 * qscale * quant_matrix[i] <= 205026
77 * (1<<36)/19952 >= (1<<36)/(aanscales[i] * \
78 * qscale * quant_matrix[i]) >= (1<<36)/249205025
79 * 3444240 >= (1<<36)/(aanscales[i] *
80 * qscale * quant_matrix[i]) >= 275 */
81 qmat
[qscale
][i
] = (int)((UINT64_C(1) << (QMAT_SHIFT
-3))/
82 (qscale
* quant_matrix
[j
]));
84 } else if (s
->dsp
.fdct
== fdct_ifast
) {
86 const int j
= s
->dsp
.idct_permutation
[i
];
87 /* 16 <= qscale * quant_matrix[i] <= 7905 */
88 /* 19952 <= aanscales[i] * qscale * quant_matrix[i] <= 249205026 */
89 /* (1<<36)/19952 >= (1<<36)/(aanscales[i] * qscale * quant_matrix[i]) >= (1<<36)/249205026 */
90 /* 3444240 >= (1<<36)/(aanscales[i] * qscale * quant_matrix[i]) >= 275 */
92 qmat
[qscale
][i
] = (int)((UINT64_C(1) << (QMAT_SHIFT
+ 11)) /
93 (aanscales
[i
] * qscale
* quant_matrix
[j
]));
97 const int j
= s
->dsp
.idct_permutation
[i
];
98 /* We can safely suppose that 16 <= quant_matrix[i] <= 255
99 So 16 <= qscale * quant_matrix[i] <= 7905
100 so (1<<19) / 16 >= (1<<19) / (qscale * quant_matrix[i]) >= (1<<19) / 7905
101 so 32768 >= (1<<19) / (qscale * quant_matrix[i]) >= 67
103 qmat
[qscale
][i
] = (int)((UINT64_C(1) << QMAT_SHIFT_MMX
) / (qscale
* quant_matrix
[j
]));
104 qmat16
[qscale
][0][i
] = (1 << QMAT_SHIFT_MMX
) / (qscale
* quant_matrix
[j
]);
106 if(qmat16
[qscale
][0][i
]==0 || qmat16
[qscale
][0][i
]==128*256) qmat16
[qscale
][0][i
]=128*256-1;
107 qmat16
[qscale
][1][i
]= ROUNDED_DIV(bias
<<(16-QUANT_BIAS_SHIFT
), qmat16
[qscale
][0][i
]);
113 static inline void encode_dc(MpegEncContext
*s
, int val
,
114 uint8_t *huff_size
, uint16_t *huff_code
)
119 put_bits(&s
->pb
, huff_size
[0], huff_code
[0]);
127 /* compute the log (XXX: optimize) */
134 put_bits(&s
->pb
, huff_size
[nbits
], huff_code
[nbits
]);
136 put_bits(&s
->pb
, nbits
, mant
& ((1 << nbits
) - 1));
140 static void encode_block(MpegEncContext
*s
, DCTELEM
*block
, int n
)
142 int mant
, nbits
, code
, i
, j
;
143 int component
, dc
, run
, last_index
, val
;
144 MJpegContext
*m
= s
->mjpeg_ctx
;
145 uint8_t *huff_size_ac
;
146 uint16_t *huff_code_ac
;
149 component
= (n
<= 3 ? 0 : n
- 4 + 1);
150 dc
= block
[0]; /* overflow is impossible */
151 val
= dc
- s
->last_dc
[component
];
153 encode_dc(s
, val
, m
->huff_size_dc_luminance
, m
->huff_code_dc_luminance
);
154 huff_size_ac
= m
->huff_size_ac_luminance
;
155 huff_code_ac
= m
->huff_code_ac_luminance
;
157 encode_dc(s
, val
, m
->huff_size_dc_chrominance
, m
->huff_code_dc_chrominance
);
158 huff_size_ac
= m
->huff_size_ac_chrominance
;
159 huff_code_ac
= m
->huff_code_ac_chrominance
;
161 s
->last_dc
[component
] = dc
;
166 last_index
= s
->block_last_index
[n
];
167 for(i
=1;i
<=last_index
;i
++) {
168 j
= s
->intra_scantable
.permutated
[i
];
174 put_bits(&s
->pb
, huff_size_ac
[0xf0], huff_code_ac
[0xf0]);
183 /* compute the log (XXX: optimize) */
189 code
= (run
<< 4) | nbits
;
191 put_bits(&s
->pb
, huff_size_ac
[code
], huff_code_ac
[code
]);
193 put_bits(&s
->pb
, nbits
, mant
& ((1 << nbits
) - 1));
198 /* output EOB only if not already 64 values */
199 if (last_index
< 63 || run
!= 0)
200 put_bits(&s
->pb
, huff_size_ac
[0], huff_code_ac
[0]);
203 static inline void clip_coeffs(MpegEncContext
*s
, DCTELEM
*block
, int last_index
)
206 const int maxlevel
= s
->max_qcoeff
;
207 const int minlevel
= s
->min_qcoeff
;
209 for(i
=0; i
<=last_index
; i
++){
210 const int j
= s
->intra_scantable
.permutated
[i
];
211 int level
= block
[j
];
213 if (level
>maxlevel
) level
=maxlevel
;
214 else if(level
<minlevel
) level
=minlevel
;
219 /* End excessive code duplication **************************************/
221 /* this function is a reproduction of the one in mjpeg, it includes two
222 * changes, it allows for black&white encoding (it skips the U and V
223 * macroblocks and it outputs the huffman code for 'no change' (dc) and
224 * 'all zero' (ac)) and it takes 4 macroblocks (422) instead of 6 (420) */
225 static void zr_mjpeg_encode_mb(jpeg_enc_t
*j
) {
227 MJpegContext
*m
= j
->s
->mjpeg_ctx
;
229 encode_block(j
->s
, j
->s
->block
[0], 0);
230 encode_block(j
->s
, j
->s
->block
[1], 1);
233 put_bits(&j
->s
->pb
, m
->huff_size_dc_chrominance
[0],
234 m
->huff_code_dc_chrominance
[0]);
235 put_bits(&j
->s
->pb
, m
->huff_size_ac_chrominance
[0],
236 m
->huff_code_ac_chrominance
[0]);
238 put_bits(&j
->s
->pb
, m
->huff_size_dc_chrominance
[0],
239 m
->huff_code_dc_chrominance
[0]);
240 put_bits(&j
->s
->pb
, m
->huff_size_ac_chrominance
[0],
241 m
->huff_code_ac_chrominance
[0]);
243 /* we trick encode_block here so that it uses
244 * chrominance huffman tables instead of luminance ones
245 * (see the effect of second argument of encode_block) */
246 encode_block(j
->s
, j
->s
->block
[2], 4);
247 encode_block(j
->s
, j
->s
->block
[3], 5);
251 /* this function can take all kinds of YUV colorspaces
252 * YV12, YVYU, UYVY. The necesary parameters must be set up by the caller
253 * y_ps means "y pixel size", y_rs means "y row size".
254 * For YUYV, for example, is u_buf = y_buf + 1, v_buf = y_buf + 3,
255 * y_ps = 2, u_ps = 4, v_ps = 4, y_rs = u_rs = v_rs.
257 * The actual buffers must be passed with mjpeg_encode_frame, this is
258 * to make it possible to call encode on the buffer provided by the
259 * codec in draw_frame.
261 * The data is straightened out at the moment it is put in DCT
262 * blocks, there are therefore no spurious memcopies involved */
263 /* Notice that w must be a multiple of 16 and h must be a multiple of 8 */
264 /* We produce YUV422 jpegs, the colors must be subsampled horizontally,
265 * if the colors are also subsampled vertically, then this function
266 * performs cheap upsampling (better solution will be: a DCT that is
267 * optimized in the case that every two rows are the same) */
268 /* cu = 0 means 'No cheap upsampling'
269 * cu = 1 means 'perform cheap upsampling' */
270 /* The encoder doesn't know anything about interlacing, the halve height
271 * needs to be passed and the double rowstride. Which field gets encoded
272 * is decided by what buffers are passed to mjpeg_encode_frame */
273 jpeg_enc_t
*jpeg_enc_init(int w
, int h
, int y_psize
, int y_rsize
,
274 int u_psize
, int u_rsize
, int v_psize
, int v_rsize
,
275 int cu
, int q
, int b
) {
278 mp_msg(MSGT_VO
, MSGL_V
, "JPEnc init: %dx%d %d %d %d %d %d %d\n",
279 w
, h
, y_psize
, y_rsize
, u_psize
,
280 u_rsize
, v_psize
, v_rsize
);
282 j
= av_malloc(sizeof(jpeg_enc_t
));
283 if (j
== NULL
) return NULL
;
285 j
->s
= av_malloc(sizeof(MpegEncContext
));
286 memset(j
->s
,0x00,sizeof(MpegEncContext
));
292 /* info on how to access the pixels */
304 j
->s
->out_format
= FMT_MJPEG
;
305 j
->s
->intra_only
= 1;
307 j
->s
->pict_type
= FF_I_TYPE
;
308 j
->s
->y_dc_scale
= 8;
309 j
->s
->c_dc_scale
= 8;
311 //FIXME j->s->mjpeg_write_tables = 1;
312 j
->s
->mjpeg_vsample
[0] = 1;
313 j
->s
->mjpeg_vsample
[1] = 1;
314 j
->s
->mjpeg_vsample
[2] = 1;
315 j
->s
->mjpeg_hsample
[0] = 2;
316 j
->s
->mjpeg_hsample
[1] = 1;
317 j
->s
->mjpeg_hsample
[2] = 1;
319 j
->cheap_upsample
= cu
;
322 /* if libavcodec is used by the decoder then we must not
323 * initialize again, but if it is not initialized then we must
324 * initialize it here. */
325 if (!avcodec_initialized
) {
326 /* we need to initialize libavcodec */
328 avcodec_register_all();
329 avcodec_initialized
=1;
332 if (ff_mjpeg_encode_init(j
->s
) < 0) {
338 /* alloc bogus avctx to keep MPV_common_init from segfaulting */
339 j
->s
->avctx
= calloc(sizeof(*j
->s
->avctx
), 1);
340 /* Set up to encode mjpeg */
341 j
->s
->avctx
->codec_id
= CODEC_ID_MJPEG
;
343 /* make MPV_common_init allocate important buffers, like s->block */
344 j
->s
->avctx
->thread_count
= 1;
346 if (MPV_common_init(j
->s
) < 0) {
352 /* correct the value for sc->mb_height */
353 j
->s
->mb_height
= j
->s
->height
/8;
356 j
->s
->intra_matrix
[0] = ff_mpeg1_default_intra_matrix
[0];
357 for (i
= 1; i
< 64; i
++)
358 j
->s
->intra_matrix
[i
] = av_clip_uint8(
359 (ff_mpeg1_default_intra_matrix
[i
]*j
->s
->qscale
) >> 3);
360 convert_matrix(j
->s
, j
->s
->q_intra_matrix
, j
->s
->q_intra_matrix16
,
361 j
->s
->intra_matrix
, j
->s
->intra_quant_bias
, 8, 8);
365 int jpeg_enc_frame(jpeg_enc_t
*j
, unsigned char *y_data
,
366 unsigned char *u_data
, unsigned char *v_data
, char *bufr
) {
367 int i
, k
, mb_x
, mb_y
, overflow
;
369 unsigned char *source
;
370 /* initialize the buffer */
372 init_put_bits(&j
->s
->pb
, bufr
, 1024*256);
374 ff_mjpeg_encode_picture_header(j
->s
);
376 j
->s
->header_bits
= put_bits_count(&j
->s
->pb
);
378 j
->s
->last_dc
[0] = 128;
379 j
->s
->last_dc
[1] = 128;
380 j
->s
->last_dc
[2] = 128;
382 for (mb_y
= 0; mb_y
< j
->s
->mb_height
; mb_y
++) {
383 for (mb_x
= 0; mb_x
< j
->s
->mb_width
; mb_x
++) {
384 /* conversion 8 to 16 bit and filling of blocks
385 * must be mmx optimized */
386 /* fill 2 Y macroblocks and one U and one V */
387 source
= mb_y
* 8 * j
->y_rs
+
388 16 * j
->y_ps
* mb_x
+ y_data
;
389 dest
= j
->s
->block
[0];
390 for (i
= 0; i
< 8; i
++) {
391 for (k
= 0; k
< 8; k
++) {
392 dest
[k
] = source
[k
*j
->y_ps
];
397 source
= mb_y
* 8 * j
->y_rs
+
398 (16*mb_x
+ 8)*j
->y_ps
+ y_data
;
399 dest
= j
->s
->block
[1];
400 for (i
= 0; i
< 8; i
++) {
401 for (k
= 0; k
< 8; k
++) {
402 dest
[k
] = source
[k
*j
->y_ps
];
407 if (!j
->bw
&& j
->cheap_upsample
) {
408 source
= mb_y
*4*j
->u_rs
+
409 8*mb_x
*j
->u_ps
+ u_data
;
410 dest
= j
->s
->block
[2];
411 for (i
= 0; i
< 4; i
++) {
412 for (k
= 0; k
< 8; k
++) {
413 dest
[k
] = source
[k
*j
->u_ps
];
414 dest
[k
+8] = source
[k
*j
->u_ps
];
419 source
= mb_y
*4*j
->v_rs
+
420 8*mb_x
*j
->v_ps
+ v_data
;
421 dest
= j
->s
->block
[3];
422 for (i
= 0; i
< 4; i
++) {
423 for (k
= 0; k
< 8; k
++) {
424 dest
[k
] = source
[k
*j
->v_ps
];
425 dest
[k
+8] = source
[k
*j
->v_ps
];
430 } else if (!j
->bw
&& !j
->cheap_upsample
) {
431 source
= mb_y
*8*j
->u_rs
+
432 8*mb_x
*j
->u_ps
+ u_data
;
433 dest
= j
->s
->block
[2];
434 for (i
= 0; i
< 8; i
++) {
435 for (k
= 0; k
< 8; k
++)
436 dest
[k
] = source
[k
*j
->u_ps
];
440 source
= mb_y
*8*j
->v_rs
+
441 8*mb_x
*j
->v_ps
+ v_data
;
442 dest
= j
->s
->block
[3];
443 for (i
= 0; i
< 8; i
++) {
444 for (k
= 0; k
< 8; k
++)
445 dest
[k
] = source
[k
*j
->v_ps
];
450 emms_c(); /* is this really needed? */
452 j
->s
->block_last_index
[0] =
453 j
->s
->dct_quantize(j
->s
, j
->s
->block
[0],
455 if (overflow
) clip_coeffs(j
->s
, j
->s
->block
[0],
456 j
->s
->block_last_index
[0]);
457 j
->s
->block_last_index
[1] =
458 j
->s
->dct_quantize(j
->s
, j
->s
->block
[1],
460 if (overflow
) clip_coeffs(j
->s
, j
->s
->block
[1],
461 j
->s
->block_last_index
[1]);
464 j
->s
->block_last_index
[4] =
465 j
->s
->dct_quantize(j
->s
, j
->s
->block
[2],
467 if (overflow
) clip_coeffs(j
->s
, j
->s
->block
[2],
468 j
->s
->block_last_index
[2]);
469 j
->s
->block_last_index
[5] =
470 j
->s
->dct_quantize(j
->s
, j
->s
->block
[3],
472 if (overflow
) clip_coeffs(j
->s
, j
->s
->block
[3],
473 j
->s
->block_last_index
[3]);
475 zr_mjpeg_encode_mb(j
);
479 ff_mjpeg_encode_picture_trailer(j
->s
);
480 flush_put_bits(&j
->s
->pb
);
483 //if (j->s->mjpeg_write_tables == 1)
484 // j->s->mjpeg_write_tables = 0;
486 return pbBufPtr(&(j
->s
->pb
)) - j
->s
->pb
.buf
;
489 void jpeg_enc_uninit(jpeg_enc_t
*j
) {
490 ff_mjpeg_encode_close(j
->s
);