Line | Branch | Exec | Source |
---|---|---|---|
1 | /* | ||
2 | * MJPEG encoder | ||
3 | * Copyright (c) 2000, 2001 Fabrice Bellard | ||
4 | * Copyright (c) 2003 Alex Beregszaszi | ||
5 | * Copyright (c) 2003-2004 Michael Niedermayer | ||
6 | * | ||
7 | * Support for external huffman table, various fixes (AVID workaround), | ||
8 | * aspecting, new decode_frame mechanism and apple mjpeg-b support | ||
9 | * by Alex Beregszaszi | ||
10 | * | ||
11 | * This file is part of FFmpeg. | ||
12 | * | ||
13 | * FFmpeg is free software; you can redistribute it and/or | ||
14 | * modify it under the terms of the GNU Lesser General Public | ||
15 | * License as published by the Free Software Foundation; either | ||
16 | * version 2.1 of the License, or (at your option) any later version. | ||
17 | * | ||
18 | * FFmpeg 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 GNU | ||
21 | * Lesser General Public License for more details. | ||
22 | * | ||
23 | * You should have received a copy of the GNU Lesser General Public | ||
24 | * License along with FFmpeg; if not, write to the Free Software | ||
25 | * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA | ||
26 | */ | ||
27 | |||
28 | /** | ||
29 | * @file | ||
30 | * MJPEG encoder. | ||
31 | */ | ||
32 | |||
33 | #include "config_components.h" | ||
34 | |||
35 | #include "libavutil/mem.h" | ||
36 | |||
37 | #include "avcodec.h" | ||
38 | #include "codec_internal.h" | ||
39 | #include "jpegtables.h" | ||
40 | #include "mjpegenc_common.h" | ||
41 | #include "mjpegenc_huffman.h" | ||
42 | #include "mpegvideo.h" | ||
43 | #include "mjpeg.h" | ||
44 | #include "mjpegenc.h" | ||
45 | #include "mpegvideoenc.h" | ||
46 | #include "profiles.h" | ||
47 | |||
48 | /* The following is the private context of MJPEG/AMV decoder. | ||
49 | * Note that when using slice threading only the main thread's | ||
50 | * MpegEncContext is followed by a MjpegContext; the other threads | ||
51 | * can access this shared context via MpegEncContext.mjpeg. */ | ||
52 | typedef struct MJPEGEncContext { | ||
53 | MpegEncContext mpeg; | ||
54 | MJpegContext mjpeg; | ||
55 | } MJPEGEncContext; | ||
56 | |||
57 | 2540 | static av_cold void init_uni_ac_vlc(const uint8_t huff_size_ac[256], | |
58 | uint8_t *uni_ac_vlc_len) | ||
59 | { | ||
60 |
2/2✓ Branch 0 taken 325120 times.
✓ Branch 1 taken 2540 times.
|
327660 | for (int i = 0; i < 128; i++) { |
61 | 325120 | int level = i - 64; | |
62 |
2/2✓ Branch 0 taken 2540 times.
✓ Branch 1 taken 322580 times.
|
325120 | if (!level) |
63 | 2540 | continue; | |
64 |
2/2✓ Branch 0 taken 20645120 times.
✓ Branch 1 taken 322580 times.
|
20967700 | for (int run = 0; run < 64; run++) { |
65 | int len, code, nbits; | ||
66 | 20645120 | int alevel = FFABS(level); | |
67 | |||
68 | 20645120 | len = (run >> 4) * huff_size_ac[0xf0]; | |
69 | |||
70 | 20645120 | nbits= av_log2_16bit(alevel) + 1; | |
71 | 20645120 | code = ((15&run) << 4) | nbits; | |
72 | |||
73 | 20645120 | len += huff_size_ac[code] + nbits; | |
74 | |||
75 | 20645120 | uni_ac_vlc_len[UNI_AC_ENC_INDEX(run, i)] = len; | |
76 | // We ignore EOB as its just a constant which does not change generally | ||
77 | } | ||
78 | } | ||
79 | 2540 | } | |
80 | |||
81 | 1439 | static void mjpeg_encode_picture_header(MpegEncContext *s) | |
82 | { | ||
83 | 1439 | ff_mjpeg_encode_picture_header(s->avctx, &s->pb, s->cur_pic.ptr->f, s->mjpeg_ctx, | |
84 | 1439 | s->intra_scantable.permutated, 0, | |
85 | 1439 | s->intra_matrix, s->chroma_intra_matrix, | |
86 | 1439 | s->slice_context_count > 1); | |
87 | |||
88 | 1439 | s->esc_pos = put_bytes_count(&s->pb, 0); | |
89 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 1439 times.
|
1439 | for (int i = 1; i < s->slice_context_count; i++) |
90 | ✗ | s->thread_context[i]->esc_pos = 0; | |
91 | 1439 | } | |
92 | |||
93 | 1439 | void ff_mjpeg_amv_encode_picture_header(MpegEncContext *s) | |
94 | { | ||
95 | 1439 | MJPEGEncContext *const m = (MJPEGEncContext*)s; | |
96 | av_assert2(s->mjpeg_ctx == &m->mjpeg); | ||
97 | /* s->huffman == HUFFMAN_TABLE_OPTIMAL can only be true for MJPEG. */ | ||
98 |
2/2✓ Branch 0 taken 200 times.
✓ Branch 1 taken 1239 times.
|
1439 | if (!CONFIG_MJPEG_ENCODER || m->mjpeg.huffman != HUFFMAN_TABLE_OPTIMAL) |
99 | 200 | mjpeg_encode_picture_header(s); | |
100 | 1439 | } | |
101 | |||
102 | #if CONFIG_MJPEG_ENCODER | ||
103 | /** | ||
104 | * Encodes and outputs the entire frame in the JPEG format. | ||
105 | * | ||
106 | * @param s The MpegEncContext. | ||
107 | */ | ||
108 | 1239 | static void mjpeg_encode_picture_frame(MpegEncContext *s) | |
109 | { | ||
110 | int nbits, code, table_id; | ||
111 | 1239 | MJpegContext *m = s->mjpeg_ctx; | |
112 | 1239 | uint8_t *huff_size[4] = { m->huff_size_dc_luminance, | |
113 | 1239 | m->huff_size_dc_chrominance, | |
114 | 1239 | m->huff_size_ac_luminance, | |
115 | 1239 | m->huff_size_ac_chrominance }; | |
116 | 1239 | uint16_t *huff_code[4] = { m->huff_code_dc_luminance, | |
117 | 1239 | m->huff_code_dc_chrominance, | |
118 | 1239 | m->huff_code_ac_luminance, | |
119 | 1239 | m->huff_code_ac_chrominance }; | |
120 | 1239 | size_t total_bits = 0; | |
121 | size_t bytes_needed; | ||
122 | |||
123 | 1239 | s->header_bits = get_bits_diff(s); | |
124 | // Estimate the total size first | ||
125 |
2/2✓ Branch 0 taken 28822754 times.
✓ Branch 1 taken 1239 times.
|
28823993 | for (int i = 0; i < m->huff_ncode; i++) { |
126 | 28822754 | table_id = m->huff_buffer[i].table_id; | |
127 | 28822754 | code = m->huff_buffer[i].code; | |
128 | 28822754 | nbits = code & 0xf; | |
129 | |||
130 | 28822754 | total_bits += huff_size[table_id][code] + nbits; | |
131 | } | ||
132 | |||
133 | 1239 | bytes_needed = (total_bits + 7) / 8; | |
134 | 1239 | ff_mpv_reallocate_putbitbuffer(s, bytes_needed, bytes_needed); | |
135 | |||
136 |
2/2✓ Branch 0 taken 28822754 times.
✓ Branch 1 taken 1239 times.
|
28823993 | for (int i = 0; i < m->huff_ncode; i++) { |
137 | 28822754 | table_id = m->huff_buffer[i].table_id; | |
138 | 28822754 | code = m->huff_buffer[i].code; | |
139 | 28822754 | nbits = code & 0xf; | |
140 | |||
141 | 28822754 | put_bits(&s->pb, huff_size[table_id][code], huff_code[table_id][code]); | |
142 |
2/2✓ Branch 0 taken 26018465 times.
✓ Branch 1 taken 2804289 times.
|
28822754 | if (nbits != 0) { |
143 | 26018465 | put_sbits(&s->pb, nbits, m->huff_buffer[i].mant); | |
144 | } | ||
145 | } | ||
146 | |||
147 | 1239 | m->huff_ncode = 0; | |
148 | 1239 | s->i_tex_bits = get_bits_diff(s); | |
149 | 1239 | } | |
150 | |||
151 | /** | ||
152 | * Builds all 4 optimal Huffman tables. | ||
153 | * | ||
154 | * Uses the data stored in the JPEG buffer to compute the tables. | ||
155 | * Stores the Huffman tables in the bits_* and val_* arrays in the MJpegContext. | ||
156 | * | ||
157 | * @param m MJpegContext containing the JPEG buffer. | ||
158 | */ | ||
159 | 1239 | static void mjpeg_build_optimal_huffman(MJpegContext *m) | |
160 | { | ||
161 | MJpegEncHuffmanContext dc_luminance_ctx; | ||
162 | MJpegEncHuffmanContext dc_chrominance_ctx; | ||
163 | MJpegEncHuffmanContext ac_luminance_ctx; | ||
164 | MJpegEncHuffmanContext ac_chrominance_ctx; | ||
165 | 1239 | MJpegEncHuffmanContext *ctx[4] = { &dc_luminance_ctx, | |
166 | &dc_chrominance_ctx, | ||
167 | &ac_luminance_ctx, | ||
168 | &ac_chrominance_ctx }; | ||
169 |
2/2✓ Branch 0 taken 4956 times.
✓ Branch 1 taken 1239 times.
|
6195 | for (int i = 0; i < 4; i++) |
170 | 4956 | ff_mjpeg_encode_huffman_init(ctx[i]); | |
171 | |||
172 |
2/2✓ Branch 0 taken 28822754 times.
✓ Branch 1 taken 1239 times.
|
28823993 | for (int i = 0; i < m->huff_ncode; i++) { |
173 | 28822754 | int table_id = m->huff_buffer[i].table_id; | |
174 | 28822754 | int code = m->huff_buffer[i].code; | |
175 | |||
176 | 28822754 | ff_mjpeg_encode_huffman_increment(ctx[table_id], code); | |
177 | } | ||
178 | |||
179 | 1239 | ff_mjpeg_encode_huffman_close(&dc_luminance_ctx, | |
180 | 1239 | m->bits_dc_luminance, | |
181 | 1239 | m->val_dc_luminance, 12); | |
182 | 1239 | ff_mjpeg_encode_huffman_close(&dc_chrominance_ctx, | |
183 | 1239 | m->bits_dc_chrominance, | |
184 | 1239 | m->val_dc_chrominance, 12); | |
185 | 1239 | ff_mjpeg_encode_huffman_close(&ac_luminance_ctx, | |
186 | 1239 | m->bits_ac_luminance, | |
187 | 1239 | m->val_ac_luminance, 256); | |
188 | 1239 | ff_mjpeg_encode_huffman_close(&ac_chrominance_ctx, | |
189 | 1239 | m->bits_ac_chrominance, | |
190 | 1239 | m->val_ac_chrominance, 256); | |
191 | |||
192 | 1239 | ff_mjpeg_build_huffman_codes(m->huff_size_dc_luminance, | |
193 | 1239 | m->huff_code_dc_luminance, | |
194 | 1239 | m->bits_dc_luminance, | |
195 | 1239 | m->val_dc_luminance); | |
196 | 1239 | ff_mjpeg_build_huffman_codes(m->huff_size_dc_chrominance, | |
197 | 1239 | m->huff_code_dc_chrominance, | |
198 | 1239 | m->bits_dc_chrominance, | |
199 | 1239 | m->val_dc_chrominance); | |
200 | 1239 | ff_mjpeg_build_huffman_codes(m->huff_size_ac_luminance, | |
201 | 1239 | m->huff_code_ac_luminance, | |
202 | 1239 | m->bits_ac_luminance, | |
203 | 1239 | m->val_ac_luminance); | |
204 | 1239 | ff_mjpeg_build_huffman_codes(m->huff_size_ac_chrominance, | |
205 | 1239 | m->huff_code_ac_chrominance, | |
206 | 1239 | m->bits_ac_chrominance, | |
207 | 1239 | m->val_ac_chrominance); | |
208 | 1239 | } | |
209 | #endif | ||
210 | |||
211 | /** | ||
212 | * Writes the complete JPEG frame when optimal huffman tables are enabled, | ||
213 | * otherwise writes the stuffing. | ||
214 | * | ||
215 | * Header + values + stuffing. | ||
216 | * | ||
217 | * @param s The MpegEncContext. | ||
218 | * @return int Error code, 0 if successful. | ||
219 | */ | ||
220 | 1439 | int ff_mjpeg_encode_stuffing(MpegEncContext *s) | |
221 | { | ||
222 | 1439 | MJpegContext *const m = s->mjpeg_ctx; | |
223 | 1439 | PutBitContext *pbc = &s->pb; | |
224 | 1439 | int mb_y = s->mb_y - !s->mb_x; | |
225 | int ret; | ||
226 | |||
227 | #if CONFIG_MJPEG_ENCODER | ||
228 |
2/2✓ Branch 0 taken 1239 times.
✓ Branch 1 taken 200 times.
|
1439 | if (m->huffman == HUFFMAN_TABLE_OPTIMAL) { |
229 | |||
230 | 1239 | mjpeg_build_optimal_huffman(m); | |
231 | |||
232 | // Replace the VLCs with the optimal ones. | ||
233 | // The default ones may be used for trellis during quantization. | ||
234 | 1239 | init_uni_ac_vlc(m->huff_size_ac_luminance, m->uni_ac_vlc_len); | |
235 | 1239 | init_uni_ac_vlc(m->huff_size_ac_chrominance, m->uni_chroma_ac_vlc_len); | |
236 | 1239 | s->intra_ac_vlc_length = | |
237 | 1239 | s->intra_ac_vlc_last_length = m->uni_ac_vlc_len; | |
238 | 1239 | s->intra_chroma_ac_vlc_length = | |
239 | 1239 | s->intra_chroma_ac_vlc_last_length = m->uni_chroma_ac_vlc_len; | |
240 | |||
241 | 1239 | mjpeg_encode_picture_header(s); | |
242 | 1239 | mjpeg_encode_picture_frame(s); | |
243 | } | ||
244 | #endif | ||
245 | |||
246 | 1439 | ret = ff_mpv_reallocate_putbitbuffer(s, put_bits_count(&s->pb) / 8 + 100, | |
247 | 1439 | put_bits_count(&s->pb) / 4 + 1000); | |
248 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 1439 times.
|
1439 | if (ret < 0) { |
249 | ✗ | av_log(s->avctx, AV_LOG_ERROR, "Buffer reallocation failed\n"); | |
250 | ✗ | goto fail; | |
251 | } | ||
252 | |||
253 | 1439 | ff_mjpeg_escape_FF(pbc, s->esc_pos); | |
254 | |||
255 |
1/4✗ Branch 0 not taken.
✓ Branch 1 taken 1439 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
|
1439 | if (s->slice_context_count > 1 && mb_y < s->mb_height - 1) |
256 | ✗ | put_marker(pbc, RST0 + (mb_y&7)); | |
257 | 1439 | s->esc_pos = put_bytes_count(pbc, 0); | |
258 | |||
259 | 1439 | fail: | |
260 |
2/2✓ Branch 0 taken 4317 times.
✓ Branch 1 taken 1439 times.
|
5756 | for (int i = 0; i < 3; i++) |
261 | 4317 | s->last_dc[i] = 128 << s->intra_dc_precision; | |
262 | |||
263 | 1439 | return ret; | |
264 | } | ||
265 | |||
266 | 27 | static int alloc_huffman(MpegEncContext *s) | |
267 | { | ||
268 | 27 | MJpegContext *m = s->mjpeg_ctx; | |
269 | size_t num_mbs, num_blocks, num_codes; | ||
270 | int blocks_per_mb; | ||
271 | |||
272 | // We need to init this here as the mjpeg init is called before the common init, | ||
273 | 27 | s->mb_width = (s->width + 15) / 16; | |
274 | 27 | s->mb_height = (s->height + 15) / 16; | |
275 | |||
276 |
3/4✓ Branch 0 taken 18 times.
✓ Branch 1 taken 4 times.
✓ Branch 2 taken 5 times.
✗ Branch 3 not taken.
|
27 | switch (s->chroma_format) { |
277 | 18 | case CHROMA_420: blocks_per_mb = 6; break; | |
278 | 4 | case CHROMA_422: blocks_per_mb = 8; break; | |
279 | 5 | case CHROMA_444: blocks_per_mb = 12; break; | |
280 | ✗ | default: av_assert0(0); | |
281 | }; | ||
282 | |||
283 | // Make sure we have enough space to hold this frame. | ||
284 | 27 | num_mbs = s->mb_width * s->mb_height; | |
285 | 27 | num_blocks = num_mbs * blocks_per_mb; | |
286 | 27 | num_codes = num_blocks * 64; | |
287 | |||
288 | 27 | m->huff_buffer = av_malloc_array(num_codes, sizeof(MJpegHuffmanCode)); | |
289 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 27 times.
|
27 | if (!m->huff_buffer) |
290 | ✗ | return AVERROR(ENOMEM); | |
291 | 27 | return 0; | |
292 | } | ||
293 | |||
294 | 31 | av_cold int ff_mjpeg_encode_init(MpegEncContext *s) | |
295 | { | ||
296 | 31 | MJpegContext *const m = &((MJPEGEncContext*)s)->mjpeg; | |
297 | int ret, use_slices; | ||
298 | |||
299 | 31 | s->mjpeg_ctx = m; | |
300 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 31 times.
|
62 | use_slices = s->avctx->slices > 0 ? s->avctx->slices > 1 : |
301 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 31 times.
|
31 | (s->avctx->active_thread_type & FF_THREAD_SLICE) && |
302 | ✗ | s->avctx->thread_count > 1; | |
303 | |||
304 |
3/4✓ Branch 0 taken 27 times.
✓ Branch 1 taken 4 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 27 times.
|
31 | if (s->codec_id == AV_CODEC_ID_AMV || use_slices) |
305 | 4 | m->huffman = HUFFMAN_TABLE_DEFAULT; | |
306 | |||
307 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 31 times.
|
31 | if (s->mpv_flags & FF_MPV_FLAG_QP_RD) { |
308 | // Used to produce garbage with MJPEG. | ||
309 | ✗ | av_log(s->avctx, AV_LOG_ERROR, | |
310 | "QP RD is no longer compatible with MJPEG or AMV\n"); | ||
311 | ✗ | return AVERROR(EINVAL); | |
312 | } | ||
313 | |||
314 | /* The following check is automatically true for AMV, | ||
315 | * but it doesn't hurt either. */ | ||
316 | 31 | ret = ff_mjpeg_encode_check_pix_fmt(s->avctx); | |
317 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 31 times.
|
31 | if (ret < 0) |
318 | ✗ | return ret; | |
319 | |||
320 |
2/4✓ Branch 0 taken 31 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 31 times.
|
31 | if (s->width > 65500 || s->height > 65500) { |
321 | ✗ | av_log(s, AV_LOG_ERROR, "JPEG does not support resolutions above 65500x65500\n"); | |
322 | ✗ | return AVERROR(EINVAL); | |
323 | } | ||
324 | |||
325 | 31 | s->min_qcoeff=-1023; | |
326 | 31 | s->max_qcoeff= 1023; | |
327 | |||
328 | // Build default Huffman tables. | ||
329 | // These may be overwritten later with more optimal Huffman tables, but | ||
330 | // they are needed at least right now for some processes like trellis. | ||
331 | 31 | ff_mjpeg_build_huffman_codes(m->huff_size_dc_luminance, | |
332 | 31 | m->huff_code_dc_luminance, | |
333 | ff_mjpeg_bits_dc_luminance, | ||
334 | ff_mjpeg_val_dc); | ||
335 | 31 | ff_mjpeg_build_huffman_codes(m->huff_size_dc_chrominance, | |
336 | 31 | m->huff_code_dc_chrominance, | |
337 | ff_mjpeg_bits_dc_chrominance, | ||
338 | ff_mjpeg_val_dc); | ||
339 | 31 | ff_mjpeg_build_huffman_codes(m->huff_size_ac_luminance, | |
340 | 31 | m->huff_code_ac_luminance, | |
341 | ff_mjpeg_bits_ac_luminance, | ||
342 | ff_mjpeg_val_ac_luminance); | ||
343 | 31 | ff_mjpeg_build_huffman_codes(m->huff_size_ac_chrominance, | |
344 | 31 | m->huff_code_ac_chrominance, | |
345 | ff_mjpeg_bits_ac_chrominance, | ||
346 | ff_mjpeg_val_ac_chrominance); | ||
347 | |||
348 | 31 | init_uni_ac_vlc(m->huff_size_ac_luminance, m->uni_ac_vlc_len); | |
349 | 31 | init_uni_ac_vlc(m->huff_size_ac_chrominance, m->uni_chroma_ac_vlc_len); | |
350 | 31 | s->intra_ac_vlc_length = | |
351 | 31 | s->intra_ac_vlc_last_length = m->uni_ac_vlc_len; | |
352 | 31 | s->intra_chroma_ac_vlc_length = | |
353 | 31 | s->intra_chroma_ac_vlc_last_length = m->uni_chroma_ac_vlc_len; | |
354 | |||
355 | // Buffers start out empty. | ||
356 | 31 | m->huff_ncode = 0; | |
357 | |||
358 |
2/2✓ Branch 0 taken 27 times.
✓ Branch 1 taken 4 times.
|
31 | if (m->huffman == HUFFMAN_TABLE_OPTIMAL) |
359 | 27 | return alloc_huffman(s); | |
360 | |||
361 | 4 | return 0; | |
362 | } | ||
363 | |||
364 | 31 | static av_cold int mjpeg_encode_close(AVCodecContext *avctx) | |
365 | { | ||
366 | 31 | MJPEGEncContext *const mjpeg = avctx->priv_data; | |
367 | 31 | av_freep(&mjpeg->mjpeg.huff_buffer); | |
368 | 31 | ff_mpv_encode_end(avctx); | |
369 | 31 | return 0; | |
370 | } | ||
371 | |||
372 | /** | ||
373 | * Add code and table_id to the JPEG buffer. | ||
374 | * | ||
375 | * @param s The MJpegContext which contains the JPEG buffer. | ||
376 | * @param table_id Which Huffman table the code belongs to. | ||
377 | * @param code The encoded exponent of the coefficients and the run-bits. | ||
378 | */ | ||
379 | 28822754 | static inline void ff_mjpeg_encode_code(MJpegContext *s, uint8_t table_id, int code) | |
380 | { | ||
381 | 28822754 | MJpegHuffmanCode *c = &s->huff_buffer[s->huff_ncode++]; | |
382 | 28822754 | c->table_id = table_id; | |
383 | 28822754 | c->code = code; | |
384 | 28822754 | } | |
385 | |||
386 | /** | ||
387 | * Add the coefficient's data to the JPEG buffer. | ||
388 | * | ||
389 | * @param s The MJpegContext which contains the JPEG buffer. | ||
390 | * @param table_id Which Huffman table the code belongs to. | ||
391 | * @param val The coefficient. | ||
392 | * @param run The run-bits. | ||
393 | */ | ||
394 | 26122335 | static void ff_mjpeg_encode_coef(MJpegContext *s, uint8_t table_id, int val, int run) | |
395 | { | ||
396 | int mant, code; | ||
397 | |||
398 |
2/2✓ Branch 0 taken 103870 times.
✓ Branch 1 taken 26018465 times.
|
26122335 | if (val == 0) { |
399 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 103870 times.
|
103870 | av_assert0(run == 0); |
400 | 103870 | ff_mjpeg_encode_code(s, table_id, 0); | |
401 | } else { | ||
402 | 26018465 | mant = val; | |
403 |
2/2✓ Branch 0 taken 12989723 times.
✓ Branch 1 taken 13028742 times.
|
26018465 | if (val < 0) { |
404 | 12989723 | val = -val; | |
405 | 12989723 | mant--; | |
406 | } | ||
407 | |||
408 | 26018465 | code = (run << 4) | (av_log2_16bit(val) + 1); | |
409 | |||
410 | 26018465 | s->huff_buffer[s->huff_ncode].mant = mant; | |
411 | 26018465 | ff_mjpeg_encode_code(s, table_id, code); | |
412 | } | ||
413 | 26122335 | } | |
414 | |||
415 | /** | ||
416 | * Add the block's data into the JPEG buffer. | ||
417 | * | ||
418 | * @param s The MpegEncContext that contains the JPEG buffer. | ||
419 | * @param block The block. | ||
420 | * @param n The block's index or number. | ||
421 | */ | ||
422 | 2723556 | static void record_block(MpegEncContext *s, int16_t *block, int n) | |
423 | { | ||
424 | int i, j, table_id; | ||
425 | int component, dc, last_index, val, run; | ||
426 | 2723556 | MJpegContext *m = s->mjpeg_ctx; | |
427 | |||
428 | /* DC coef */ | ||
429 |
2/2✓ Branch 0 taken 1227008 times.
✓ Branch 1 taken 1496548 times.
|
2723556 | component = (n <= 3 ? 0 : (n&1) + 1); |
430 | 2723556 | table_id = (n <= 3 ? 0 : 1); | |
431 | 2723556 | dc = block[0]; /* overflow is impossible */ | |
432 | 2723556 | val = dc - s->last_dc[component]; | |
433 | |||
434 | 2723556 | ff_mjpeg_encode_coef(m, table_id, val, 0); | |
435 | |||
436 | 2723556 | s->last_dc[component] = dc; | |
437 | |||
438 | /* AC coefs */ | ||
439 | |||
440 | 2723556 | run = 0; | |
441 | 2723556 | last_index = s->block_last_index[n]; | |
442 | 2723556 | table_id |= 2; | |
443 | |||
444 |
2/2✓ Branch 0 taken 50046156 times.
✓ Branch 1 taken 2723556 times.
|
52769712 | for(i=1;i<=last_index;i++) { |
445 | 50046156 | j = s->intra_scantable.permutated[i]; | |
446 | 50046156 | val = block[j]; | |
447 | |||
448 |
2/2✓ Branch 0 taken 26647377 times.
✓ Branch 1 taken 23398779 times.
|
50046156 | if (val == 0) { |
449 | 26647377 | run++; | |
450 | } else { | ||
451 |
2/2✓ Branch 0 taken 56662 times.
✓ Branch 1 taken 23398779 times.
|
23455441 | while (run >= 16) { |
452 | 56662 | ff_mjpeg_encode_code(m, table_id, 0xf0); | |
453 | 56662 | run -= 16; | |
454 | } | ||
455 | 23398779 | ff_mjpeg_encode_coef(m, table_id, val, run); | |
456 | 23398779 | run = 0; | |
457 | } | ||
458 | } | ||
459 | |||
460 | /* output EOB only if not already 64 values */ | ||
461 |
3/4✓ Branch 0 taken 79799 times.
✓ Branch 1 taken 2643757 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 79799 times.
|
2723556 | if (last_index < 63 || run != 0) |
462 | 2643757 | ff_mjpeg_encode_code(m, table_id, 0); | |
463 | 2723556 | } | |
464 | |||
465 | 359100 | static void encode_block(MpegEncContext *s, int16_t *block, int n) | |
466 | { | ||
467 | int mant, nbits, code, i, j; | ||
468 | int component, dc, run, last_index, val; | ||
469 | 359100 | MJpegContext *m = s->mjpeg_ctx; | |
470 | uint8_t *huff_size_ac; | ||
471 | uint16_t *huff_code_ac; | ||
472 | |||
473 | /* DC coef */ | ||
474 |
2/2✓ Branch 0 taken 119700 times.
✓ Branch 1 taken 239400 times.
|
359100 | component = (n <= 3 ? 0 : (n&1) + 1); |
475 | 359100 | dc = block[0]; /* overflow is impossible */ | |
476 | 359100 | val = dc - s->last_dc[component]; | |
477 |
2/2✓ Branch 0 taken 239400 times.
✓ Branch 1 taken 119700 times.
|
359100 | if (n < 4) { |
478 | 239400 | ff_mjpeg_encode_dc(&s->pb, val, m->huff_size_dc_luminance, m->huff_code_dc_luminance); | |
479 | 239400 | huff_size_ac = m->huff_size_ac_luminance; | |
480 | 239400 | huff_code_ac = m->huff_code_ac_luminance; | |
481 | } else { | ||
482 | 119700 | ff_mjpeg_encode_dc(&s->pb, val, m->huff_size_dc_chrominance, m->huff_code_dc_chrominance); | |
483 | 119700 | huff_size_ac = m->huff_size_ac_chrominance; | |
484 | 119700 | huff_code_ac = m->huff_code_ac_chrominance; | |
485 | } | ||
486 | 359100 | s->last_dc[component] = dc; | |
487 | |||
488 | /* AC coefs */ | ||
489 | |||
490 | 359100 | run = 0; | |
491 | 359100 | last_index = s->block_last_index[n]; | |
492 |
2/2✓ Branch 0 taken 6520168 times.
✓ Branch 1 taken 359100 times.
|
6879268 | for(i=1;i<=last_index;i++) { |
493 | 6520168 | j = s->intra_scantable.permutated[i]; | |
494 | 6520168 | val = block[j]; | |
495 |
2/2✓ Branch 0 taken 3000879 times.
✓ Branch 1 taken 3519289 times.
|
6520168 | if (val == 0) { |
496 | 3000879 | run++; | |
497 | } else { | ||
498 |
2/2✓ Branch 0 taken 3018 times.
✓ Branch 1 taken 3519289 times.
|
3522307 | while (run >= 16) { |
499 | 3018 | put_bits(&s->pb, huff_size_ac[0xf0], huff_code_ac[0xf0]); | |
500 | 3018 | run -= 16; | |
501 | } | ||
502 | 3519289 | mant = val; | |
503 |
2/2✓ Branch 0 taken 1776140 times.
✓ Branch 1 taken 1743149 times.
|
3519289 | if (val < 0) { |
504 | 1776140 | val = -val; | |
505 | 1776140 | mant--; | |
506 | } | ||
507 | |||
508 | 3519289 | nbits= av_log2_16bit(val) + 1; | |
509 | 3519289 | code = (run << 4) | nbits; | |
510 | |||
511 | 3519289 | put_bits(&s->pb, huff_size_ac[code], huff_code_ac[code]); | |
512 | |||
513 | 3519289 | put_sbits(&s->pb, nbits, mant); | |
514 | 3519289 | run = 0; | |
515 | } | ||
516 | } | ||
517 | |||
518 | /* output EOB only if not already 64 values */ | ||
519 |
3/4✓ Branch 0 taken 14683 times.
✓ Branch 1 taken 344417 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 14683 times.
|
359100 | if (last_index < 63 || run != 0) |
520 | 344417 | put_bits(&s->pb, huff_size_ac[0], huff_code_ac[0]); | |
521 | 359100 | } | |
522 | |||
523 | 434062 | void ff_mjpeg_encode_mb(MpegEncContext *s, int16_t block[12][64]) | |
524 | { | ||
525 | int i; | ||
526 |
2/2✓ Branch 0 taken 374212 times.
✓ Branch 1 taken 59850 times.
|
434062 | if (s->mjpeg_ctx->huffman == HUFFMAN_TABLE_OPTIMAL) { |
527 |
2/2✓ Branch 0 taken 59914 times.
✓ Branch 1 taken 314298 times.
|
374212 | if (s->chroma_format == CHROMA_444) { |
528 | 59914 | record_block(s, block[0], 0); | |
529 | 59914 | record_block(s, block[2], 2); | |
530 | 59914 | record_block(s, block[4], 4); | |
531 | 59914 | record_block(s, block[8], 8); | |
532 | 59914 | record_block(s, block[5], 5); | |
533 | 59914 | record_block(s, block[9], 9); | |
534 | |||
535 |
2/2✓ Branch 0 taken 59764 times.
✓ Branch 1 taken 150 times.
|
59914 | if (16*s->mb_x+8 < s->width) { |
536 | 59764 | record_block(s, block[1], 1); | |
537 | 59764 | record_block(s, block[3], 3); | |
538 | 59764 | record_block(s, block[6], 6); | |
539 | 59764 | record_block(s, block[10], 10); | |
540 | 59764 | record_block(s, block[7], 7); | |
541 | 59764 | record_block(s, block[11], 11); | |
542 | } | ||
543 | } else { | ||
544 |
2/2✓ Branch 0 taken 1571490 times.
✓ Branch 1 taken 314298 times.
|
1885788 | for(i=0;i<5;i++) { |
545 | 1571490 | record_block(s, block[i], i); | |
546 | } | ||
547 |
2/2✓ Branch 0 taken 254448 times.
✓ Branch 1 taken 59850 times.
|
314298 | if (s->chroma_format == CHROMA_420) { |
548 | 254448 | record_block(s, block[5], 5); | |
549 | } else { | ||
550 | 59850 | record_block(s, block[6], 6); | |
551 | 59850 | record_block(s, block[5], 5); | |
552 | 59850 | record_block(s, block[7], 7); | |
553 | } | ||
554 | } | ||
555 | } else { | ||
556 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 59850 times.
|
59850 | if (s->chroma_format == CHROMA_444) { |
557 | ✗ | encode_block(s, block[0], 0); | |
558 | ✗ | encode_block(s, block[2], 2); | |
559 | ✗ | encode_block(s, block[4], 4); | |
560 | ✗ | encode_block(s, block[8], 8); | |
561 | ✗ | encode_block(s, block[5], 5); | |
562 | ✗ | encode_block(s, block[9], 9); | |
563 | |||
564 | ✗ | if (16*s->mb_x+8 < s->width) { | |
565 | ✗ | encode_block(s, block[1], 1); | |
566 | ✗ | encode_block(s, block[3], 3); | |
567 | ✗ | encode_block(s, block[6], 6); | |
568 | ✗ | encode_block(s, block[10], 10); | |
569 | ✗ | encode_block(s, block[7], 7); | |
570 | ✗ | encode_block(s, block[11], 11); | |
571 | } | ||
572 | } else { | ||
573 |
2/2✓ Branch 0 taken 299250 times.
✓ Branch 1 taken 59850 times.
|
359100 | for(i=0;i<5;i++) { |
574 | 299250 | encode_block(s, block[i], i); | |
575 | } | ||
576 |
1/2✓ Branch 0 taken 59850 times.
✗ Branch 1 not taken.
|
59850 | if (s->chroma_format == CHROMA_420) { |
577 | 59850 | encode_block(s, block[5], 5); | |
578 | } else { | ||
579 | ✗ | encode_block(s, block[6], 6); | |
580 | ✗ | encode_block(s, block[5], 5); | |
581 | ✗ | encode_block(s, block[7], 7); | |
582 | } | ||
583 | } | ||
584 | |||
585 | 59850 | s->i_tex_bits += get_bits_diff(s); | |
586 | } | ||
587 | 434062 | } | |
588 | |||
589 | #if CONFIG_AMV_ENCODER | ||
590 | // maximum over s->mjpeg_vsample[i] | ||
591 | #define V_MAX 2 | ||
592 | 200 | static int amv_encode_picture(AVCodecContext *avctx, AVPacket *pkt, | |
593 | const AVFrame *pic_arg, int *got_packet) | ||
594 | { | ||
595 | 200 | MpegEncContext *s = avctx->priv_data; | |
596 | AVFrame *pic; | ||
597 | int i, ret; | ||
598 | 200 | int chroma_v_shift = 1; /* AMV is 420-only */ | |
599 | |||
600 |
3/4✓ Branch 0 taken 50 times.
✓ Branch 1 taken 150 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 50 times.
|
200 | if ((avctx->height & 15) && avctx->strict_std_compliance > FF_COMPLIANCE_UNOFFICIAL) { |
601 | ✗ | av_log(avctx, AV_LOG_ERROR, | |
602 | "Heights which are not a multiple of 16 might fail with some decoders, " | ||
603 | "use vstrict=-1 / -strict -1 to use %d anyway.\n", avctx->height); | ||
604 | ✗ | av_log(avctx, AV_LOG_WARNING, "If you have a device that plays AMV videos, please test if videos " | |
605 | "with such heights work with it and report your findings to ffmpeg-devel@ffmpeg.org\n"); | ||
606 | ✗ | return AVERROR_EXPERIMENTAL; | |
607 | } | ||
608 | |||
609 | 200 | pic = av_frame_clone(pic_arg); | |
610 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 200 times.
|
200 | if (!pic) |
611 | ✗ | return AVERROR(ENOMEM); | |
612 | //picture should be flipped upside-down | ||
613 |
2/2✓ Branch 0 taken 600 times.
✓ Branch 1 taken 200 times.
|
800 | for(i=0; i < 3; i++) { |
614 |
2/2✓ Branch 0 taken 400 times.
✓ Branch 1 taken 200 times.
|
600 | int vsample = i ? 2 >> chroma_v_shift : 2; |
615 | 600 | pic->data[i] += pic->linesize[i] * (vsample * s->height / V_MAX - 1); | |
616 | 600 | pic->linesize[i] *= -1; | |
617 | } | ||
618 | 200 | ret = ff_mpv_encode_picture(avctx, pkt, pic, got_packet); | |
619 | 200 | av_frame_free(&pic); | |
620 | 200 | return ret; | |
621 | } | ||
622 | #endif | ||
623 | |||
624 | #define OFFSET(x) offsetof(MJPEGEncContext, mjpeg.x) | ||
625 | #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM | ||
626 | static const AVOption options[] = { | ||
627 | FF_MPV_COMMON_OPTS | ||
628 | { "huffman", "Huffman table strategy", OFFSET(huffman), AV_OPT_TYPE_INT, { .i64 = HUFFMAN_TABLE_OPTIMAL }, 0, NB_HUFFMAN_TABLE_OPTION - 1, VE, .unit = "huffman" }, | ||
629 | { "default", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = HUFFMAN_TABLE_DEFAULT }, INT_MIN, INT_MAX, VE, .unit = "huffman" }, | ||
630 | { "optimal", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = HUFFMAN_TABLE_OPTIMAL }, INT_MIN, INT_MAX, VE, .unit = "huffman" }, | ||
631 | { "force_duplicated_matrix", "Always write luma and chroma matrix for mjpeg, useful for rtp streaming.", OFFSET(force_duplicated_matrix), AV_OPT_TYPE_BOOL, {.i64 = 0 }, 0, 1, VE }, | ||
632 | { NULL}, | ||
633 | }; | ||
634 | |||
635 | #if CONFIG_MJPEG_ENCODER | ||
636 | static const AVClass mjpeg_class = { | ||
637 | .class_name = "mjpeg encoder", | ||
638 | .item_name = av_default_item_name, | ||
639 | .option = options, | ||
640 | .version = LIBAVUTIL_VERSION_INT, | ||
641 | }; | ||
642 | |||
643 | 14366 | static int mjpeg_get_supported_config(const AVCodecContext *avctx, | |
644 | const AVCodec *codec, | ||
645 | enum AVCodecConfig config, | ||
646 | unsigned flags, const void **out, | ||
647 | int *out_num) | ||
648 | { | ||
649 |
2/2✓ Branch 0 taken 27 times.
✓ Branch 1 taken 14339 times.
|
14366 | if (config == AV_CODEC_CONFIG_COLOR_RANGE) { |
650 | static const enum AVColorRange mjpeg_ranges[] = { | ||
651 | AVCOL_RANGE_MPEG, AVCOL_RANGE_JPEG, AVCOL_RANGE_UNSPECIFIED, | ||
652 | }; | ||
653 |
1/2✓ Branch 0 taken 27 times.
✗ Branch 1 not taken.
|
27 | int strict = avctx ? avctx->strict_std_compliance : 0; |
654 | 27 | int index = strict > FF_COMPLIANCE_UNOFFICIAL ? 1 : 0; | |
655 | 27 | *out = &mjpeg_ranges[index]; | |
656 | 27 | *out_num = FF_ARRAY_ELEMS(mjpeg_ranges) - index - 1; | |
657 | 27 | return 0; | |
658 | } | ||
659 | |||
660 | 14339 | return ff_default_get_supported_config(avctx, codec, config, flags, out, out_num); | |
661 | } | ||
662 | |||
663 | FFCodec ff_mjpeg_encoder = { | ||
664 | .p.name = "mjpeg", | ||
665 | CODEC_LONG_NAME("MJPEG (Motion JPEG)"), | ||
666 | .p.type = AVMEDIA_TYPE_VIDEO, | ||
667 | .p.id = AV_CODEC_ID_MJPEG, | ||
668 | .priv_data_size = sizeof(MJPEGEncContext), | ||
669 | .init = ff_mpv_encode_init, | ||
670 | FF_CODEC_ENCODE_CB(ff_mpv_encode_picture), | ||
671 | .close = mjpeg_encode_close, | ||
672 | .p.capabilities = AV_CODEC_CAP_SLICE_THREADS | AV_CODEC_CAP_FRAME_THREADS | | ||
673 | AV_CODEC_CAP_ENCODER_REORDERED_OPAQUE, | ||
674 | .caps_internal = FF_CODEC_CAP_INIT_CLEANUP | FF_CODEC_CAP_ICC_PROFILES, | ||
675 | .p.pix_fmts = (const enum AVPixelFormat[]) { | ||
676 | AV_PIX_FMT_YUVJ420P, AV_PIX_FMT_YUVJ422P, AV_PIX_FMT_YUVJ444P, | ||
677 | AV_PIX_FMT_YUV420P, AV_PIX_FMT_YUV422P, AV_PIX_FMT_YUV444P, | ||
678 | AV_PIX_FMT_NONE | ||
679 | }, | ||
680 | .p.priv_class = &mjpeg_class, | ||
681 | .p.profiles = NULL_IF_CONFIG_SMALL(ff_mjpeg_profiles), | ||
682 | .get_supported_config = mjpeg_get_supported_config, | ||
683 | }; | ||
684 | #endif | ||
685 | |||
686 | #if CONFIG_AMV_ENCODER | ||
687 | static const AVClass amv_class = { | ||
688 | .class_name = "amv encoder", | ||
689 | .item_name = av_default_item_name, | ||
690 | .option = options, | ||
691 | .version = LIBAVUTIL_VERSION_INT, | ||
692 | }; | ||
693 | |||
694 | const FFCodec ff_amv_encoder = { | ||
695 | .p.name = "amv", | ||
696 | CODEC_LONG_NAME("AMV Video"), | ||
697 | .p.type = AVMEDIA_TYPE_VIDEO, | ||
698 | .p.id = AV_CODEC_ID_AMV, | ||
699 | .priv_data_size = sizeof(MJPEGEncContext), | ||
700 | .init = ff_mpv_encode_init, | ||
701 | FF_CODEC_ENCODE_CB(amv_encode_picture), | ||
702 | .close = mjpeg_encode_close, | ||
703 | .caps_internal = FF_CODEC_CAP_INIT_CLEANUP, | ||
704 | .p.pix_fmts = (const enum AVPixelFormat[]) { | ||
705 | AV_PIX_FMT_YUVJ420P, AV_PIX_FMT_NONE | ||
706 | }, | ||
707 | .color_ranges = AVCOL_RANGE_JPEG, | ||
708 | .p.priv_class = &amv_class, | ||
709 | .p.capabilities = AV_CODEC_CAP_ENCODER_REORDERED_OPAQUE, | ||
710 | }; | ||
711 | #endif | ||
712 |