avcodec/mjpegenc: Remove non functional huffman reallocation and error handling
[ffmpeg.git] / libavcodec / mjpegenc.c
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 "libavutil/pixdesc.h"
34
35 #include "avcodec.h"
36 #include "jpegtables.h"
37 #include "mjpegenc_common.h"
38 #include "mpegvideo.h"
39 #include "mjpeg.h"
40 #include "mjpegenc.h"
41
42 // Don't know, but let's guess 16 bits per code
43 #define MJPEG_HUFFMAN_EST_BITS_PER_CODE 16
44
45 static int alloc_huffman(MpegEncContext *s)
46 {
47     MJpegContext *m = s->mjpeg_ctx;
48     size_t num_mbs, num_blocks, num_codes;
49     int blocks_per_mb;
50
51     // We need to init this here as the mjpeg init is called before the common init,
52     s->mb_width  = (s->width  + 15) / 16;
53     s->mb_height = (s->height + 15) / 16;
54
55     switch (s->chroma_format) {
56     case CHROMA_420: blocks_per_mb =  6; break;
57     case CHROMA_422: blocks_per_mb =  8; break;
58     case CHROMA_444: blocks_per_mb = 12; break;
59     default: av_assert0(0);
60     };
61
62     // Make sure we have enough space to hold this frame.
63     num_mbs = s->mb_width * s->mb_height;
64     num_blocks = num_mbs * blocks_per_mb;
65     num_codes = num_blocks * 64;
66
67     m->huff_buffer = av_malloc_array(num_codes, sizeof(MJpegHuffmanCode));
68     if (!m->huff_buffer)
69         return AVERROR(ENOMEM);
70     return 0;
71 }
72
73 av_cold int ff_mjpeg_encode_init(MpegEncContext *s)
74 {
75     MJpegContext *m;
76
77     av_assert0(s->slice_context_count == 1);
78
79     if (s->width > 65500 || s->height > 65500) {
80         av_log(s, AV_LOG_ERROR, "JPEG does not support resolutions above 65500x65500\n");
81         return AVERROR(EINVAL);
82     }
83
84     m = av_malloc(sizeof(MJpegContext));
85     if (!m)
86         return AVERROR(ENOMEM);
87
88     s->min_qcoeff=-1023;
89     s->max_qcoeff= 1023;
90
91     // Build default Huffman tables.
92     // These may be overwritten later with more optimal Huffman tables, but
93     // they are needed at least right now for some processes like trellis.
94     ff_mjpeg_build_huffman_codes(m->huff_size_dc_luminance,
95                                  m->huff_code_dc_luminance,
96                                  avpriv_mjpeg_bits_dc_luminance,
97                                  avpriv_mjpeg_val_dc);
98     ff_mjpeg_build_huffman_codes(m->huff_size_dc_chrominance,
99                                  m->huff_code_dc_chrominance,
100                                  avpriv_mjpeg_bits_dc_chrominance,
101                                  avpriv_mjpeg_val_dc);
102     ff_mjpeg_build_huffman_codes(m->huff_size_ac_luminance,
103                                  m->huff_code_ac_luminance,
104                                  avpriv_mjpeg_bits_ac_luminance,
105                                  avpriv_mjpeg_val_ac_luminance);
106     ff_mjpeg_build_huffman_codes(m->huff_size_ac_chrominance,
107                                  m->huff_code_ac_chrominance,
108                                  avpriv_mjpeg_bits_ac_chrominance,
109                                  avpriv_mjpeg_val_ac_chrominance);
110
111     ff_init_uni_ac_vlc(m->huff_size_ac_luminance,   m->uni_ac_vlc_len);
112     ff_init_uni_ac_vlc(m->huff_size_ac_chrominance, m->uni_chroma_ac_vlc_len);
113     s->intra_ac_vlc_length      =
114     s->intra_ac_vlc_last_length = m->uni_ac_vlc_len;
115     s->intra_chroma_ac_vlc_length      =
116     s->intra_chroma_ac_vlc_last_length = m->uni_chroma_ac_vlc_len;
117
118     // Buffers start out empty.
119     m->huff_ncode = 0;
120     s->mjpeg_ctx = m;
121
122     return alloc_huffman(s);
123 }
124
125 av_cold void ff_mjpeg_encode_close(MpegEncContext *s)
126 {
127     av_freep(&s->mjpeg_ctx->huff_buffer);
128     av_freep(&s->mjpeg_ctx);
129 }
130
131 /**
132  * Encodes and outputs the entire frame in the JPEG format.
133  *
134  * @param s The MpegEncContext.
135  */
136 void ff_mjpeg_encode_picture_frame(MpegEncContext *s)
137 {
138     int i, nbits, code, table_id;
139     MJpegContext *m = s->mjpeg_ctx;
140     uint8_t *huff_size[4] = {m->huff_size_dc_luminance,
141                              m->huff_size_dc_chrominance,
142                              m->huff_size_ac_luminance,
143                              m->huff_size_ac_chrominance};
144     uint16_t *huff_code[4] = {m->huff_code_dc_luminance,
145                               m->huff_code_dc_chrominance,
146                               m->huff_code_ac_luminance,
147                               m->huff_code_ac_chrominance};
148     size_t total_bits = 0;
149     size_t bytes_needed;
150
151     // Estimate the total size first
152     for (i = 0; i < m->huff_ncode; i++) {
153         table_id = m->huff_buffer[i].table_id;
154         code = m->huff_buffer[i].code;
155         nbits = code & 0xf;
156
157         total_bits += huff_size[table_id][code] + nbits;
158     }
159
160     bytes_needed = (total_bits + 7) / 8;
161     ff_mpv_reallocate_putbitbuffer(s, bytes_needed, bytes_needed);
162
163     for (i = 0; i < m->huff_ncode; i++) {
164         table_id = m->huff_buffer[i].table_id;
165         code = m->huff_buffer[i].code;
166         nbits = code & 0xf;
167
168         put_bits(&s->pb, huff_size[table_id][code], huff_code[table_id][code]);
169         if (nbits != 0) {
170             put_sbits(&s->pb, nbits, m->huff_buffer[i].mant);
171         }
172     }
173
174     m->huff_ncode = 0;
175 }
176
177 /**
178  * Add code and table_id to the JPEG buffer.
179  *
180  * @param s The MJpegContext which contains the JPEG buffer.
181  * @param table_id Which Huffman table the code belongs to.
182  * @param code The encoded exponent of the coefficients and the run-bits.
183  */
184 static inline void ff_mjpeg_encode_code(MJpegContext *s, uint8_t table_id, int code)
185 {
186     MJpegHuffmanCode *c = &s->huff_buffer[s->huff_ncode++];
187     c->table_id = table_id;
188     c->code = code;
189 }
190
191 /**
192  * Add the coefficient's data to the JPEG buffer.
193  *
194  * @param s The MJpegContext which contains the JPEG buffer.
195  * @param table_id Which Huffman table the code belongs to.
196  * @param val The coefficient.
197  * @param run The run-bits.
198  */
199 static void ff_mjpeg_encode_coef(MJpegContext *s, uint8_t table_id, int val, int run)
200 {
201     int mant, code;
202
203     if (val == 0) {
204         av_assert0(run == 0);
205         ff_mjpeg_encode_code(s, table_id, 0);
206     } else {
207         mant = val;
208         if (val < 0) {
209             val = -val;
210             mant--;
211         }
212
213         code = (run << 4) | (av_log2_16bit(val) + 1);
214
215         s->huff_buffer[s->huff_ncode].mant = mant;
216         ff_mjpeg_encode_code(s, table_id, code);
217     }
218 }
219
220 /**
221  * Add the block's data into the JPEG buffer.
222  *
223  * @param s The MJpegEncContext that contains the JPEG buffer.
224  * @param block The block.
225  * @param n The block's index or number.
226  */
227 static void encode_block(MpegEncContext *s, int16_t *block, int n)
228 {
229     int i, j, table_id;
230     int component, dc, last_index, val, run;
231     MJpegContext *m = s->mjpeg_ctx;
232
233     /* DC coef */
234     component = (n <= 3 ? 0 : (n&1) + 1);
235     table_id = (n <= 3 ? 0 : 1);
236     dc = block[0]; /* overflow is impossible */
237     val = dc - s->last_dc[component];
238
239     ff_mjpeg_encode_coef(m, table_id, val, 0);
240
241     s->last_dc[component] = dc;
242
243     /* AC coefs */
244
245     run = 0;
246     last_index = s->block_last_index[n];
247     table_id |= 2;
248
249     for(i=1;i<=last_index;i++) {
250         j = s->intra_scantable.permutated[i];
251         val = block[j];
252
253         if (val == 0) {
254             run++;
255         } else {
256             while (run >= 16) {
257                 ff_mjpeg_encode_code(m, table_id, 0xf0);
258                 run -= 16;
259             }
260             ff_mjpeg_encode_coef(m, table_id, val, run);
261             run = 0;
262         }
263     }
264
265     /* output EOB only if not already 64 values */
266     if (last_index < 63 || run != 0)
267         ff_mjpeg_encode_code(m, table_id, 0);
268 }
269
270 int ff_mjpeg_encode_mb(MpegEncContext *s, int16_t block[12][64])
271 {
272     int i, is_chroma_420;
273
274     // Number of bits used depends on future data.
275     // So, nothing that relies on encoding many times and taking the
276     // one with the fewest bits will work properly here.
277     if (s->i_tex_bits != MJPEG_HUFFMAN_EST_BITS_PER_CODE *
278         s->mjpeg_ctx->huff_ncode) {
279         av_log(s->avctx, AV_LOG_ERROR, "Unsupported encoding method\n");
280         return AVERROR(EINVAL);
281     }
282
283     if (s->chroma_format == CHROMA_444) {
284         encode_block(s, block[0], 0);
285         encode_block(s, block[2], 2);
286         encode_block(s, block[4], 4);
287         encode_block(s, block[8], 8);
288         encode_block(s, block[5], 5);
289         encode_block(s, block[9], 9);
290
291         if (16*s->mb_x+8 < s->width) {
292             encode_block(s, block[1], 1);
293             encode_block(s, block[3], 3);
294             encode_block(s, block[6], 6);
295             encode_block(s, block[10], 10);
296             encode_block(s, block[7], 7);
297             encode_block(s, block[11], 11);
298         }
299     } else {
300         is_chroma_420 = (s->chroma_format == CHROMA_420);
301         for(i=0;i<5;i++) {
302             encode_block(s, block[i], i);
303         }
304         if (is_chroma_420) {
305             encode_block(s, block[5], 5);
306         } else {
307             encode_block(s, block[6], 6);
308             encode_block(s, block[5], 5);
309             encode_block(s, block[7], 7);
310         }
311     }
312
313     s->i_tex_bits = MJPEG_HUFFMAN_EST_BITS_PER_CODE * s->mjpeg_ctx->huff_ncode;
314     return 0;
315 }
316
317 // maximum over s->mjpeg_vsample[i]
318 #define V_MAX 2
319 static int amv_encode_picture(AVCodecContext *avctx, AVPacket *pkt,
320                               const AVFrame *pic_arg, int *got_packet)
321
322 {
323     MpegEncContext *s = avctx->priv_data;
324     AVFrame *pic;
325     int i, ret;
326     int chroma_h_shift, chroma_v_shift;
327
328     av_pix_fmt_get_chroma_sub_sample(avctx->pix_fmt, &chroma_h_shift, &chroma_v_shift);
329
330 #if FF_API_EMU_EDGE
331     //CODEC_FLAG_EMU_EDGE have to be cleared
332     if(s->avctx->flags & CODEC_FLAG_EMU_EDGE)
333         return AVERROR(EINVAL);
334 #endif
335
336     if ((avctx->height & 15) && avctx->strict_std_compliance > FF_COMPLIANCE_UNOFFICIAL) {
337         av_log(avctx, AV_LOG_ERROR,
338                "Heights which are not a multiple of 16 might fail with some decoders, "
339                "use vstrict=-1 / -strict -1 to use %d anyway.\n", avctx->height);
340         av_log(avctx, AV_LOG_WARNING, "If you have a device that plays AMV videos, please test if videos "
341                "with such heights work with it and report your findings to ffmpeg-devel@ffmpeg.org\n");
342         return AVERROR_EXPERIMENTAL;
343     }
344
345     pic = av_frame_clone(pic_arg);
346     if (!pic)
347         return AVERROR(ENOMEM);
348     //picture should be flipped upside-down
349     for(i=0; i < 3; i++) {
350         int vsample = i ? 2 >> chroma_v_shift : 2;
351         pic->data[i] += pic->linesize[i] * (vsample * s->height / V_MAX - 1);
352         pic->linesize[i] *= -1;
353     }
354     ret = ff_mpv_encode_picture(avctx, pkt, pic, got_packet);
355     av_frame_free(&pic);
356     return ret;
357 }
358
359 #define OFFSET(x) offsetof(MpegEncContext, x)
360 #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
361 static const AVOption options[] = {
362 FF_MPV_COMMON_OPTS
363 { "pred", "Prediction method", OFFSET(pred), AV_OPT_TYPE_INT, { .i64 = 1 }, 1, 3, VE, "pred" },
364     { "left",   NULL, 0, AV_OPT_TYPE_CONST, { .i64 = 1 }, INT_MIN, INT_MAX, VE, "pred" },
365     { "plane",  NULL, 0, AV_OPT_TYPE_CONST, { .i64 = 2 }, INT_MIN, INT_MAX, VE, "pred" },
366     { "median", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = 3 }, INT_MIN, INT_MAX, VE, "pred" },
367 { "huffman", "Huffman table strategy", OFFSET(huffman), AV_OPT_TYPE_INT, { .i64 = HUFFMAN_TABLE_DEFAULT }, 0, NB_HUFFMAN_TABLE_OPTION - 1, VE, "huffman" },
368     { "default", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = HUFFMAN_TABLE_DEFAULT }, INT_MIN, INT_MAX, VE, "huffman" },
369     { "optimal", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = HUFFMAN_TABLE_OPTIMAL }, INT_MIN, INT_MAX, VE, "huffman" },
370 { NULL},
371 };
372
373 #if CONFIG_MJPEG_ENCODER
374
375 static const AVClass mjpeg_class = {
376     .class_name = "mjpeg encoder",
377     .item_name  = av_default_item_name,
378     .option     = options,
379     .version    = LIBAVUTIL_VERSION_INT,
380 };
381
382 AVCodec ff_mjpeg_encoder = {
383     .name           = "mjpeg",
384     .long_name      = NULL_IF_CONFIG_SMALL("MJPEG (Motion JPEG)"),
385     .type           = AVMEDIA_TYPE_VIDEO,
386     .id             = AV_CODEC_ID_MJPEG,
387     .priv_data_size = sizeof(MpegEncContext),
388     .init           = ff_mpv_encode_init,
389     .encode2        = ff_mpv_encode_picture,
390     .close          = ff_mpv_encode_end,
391     .capabilities   = AV_CODEC_CAP_SLICE_THREADS | AV_CODEC_CAP_FRAME_THREADS | AV_CODEC_CAP_INTRA_ONLY,
392     .pix_fmts       = (const enum AVPixelFormat[]){
393         AV_PIX_FMT_YUVJ420P, AV_PIX_FMT_YUVJ422P, AV_PIX_FMT_YUVJ444P, AV_PIX_FMT_NONE
394     },
395     .priv_class     = &mjpeg_class,
396 };
397 #endif
398 #if CONFIG_AMV_ENCODER
399 static const AVClass amv_class = {
400     .class_name = "amv encoder",
401     .item_name  = av_default_item_name,
402     .option     = options,
403     .version    = LIBAVUTIL_VERSION_INT,
404 };
405
406 AVCodec ff_amv_encoder = {
407     .name           = "amv",
408     .long_name      = NULL_IF_CONFIG_SMALL("AMV Video"),
409     .type           = AVMEDIA_TYPE_VIDEO,
410     .id             = AV_CODEC_ID_AMV,
411     .priv_data_size = sizeof(MpegEncContext),
412     .init           = ff_mpv_encode_init,
413     .encode2        = amv_encode_picture,
414     .close          = ff_mpv_encode_end,
415     .pix_fmts       = (const enum AVPixelFormat[]){
416         AV_PIX_FMT_YUVJ420P, AV_PIX_FMT_NONE
417     },
418     .priv_class     = &amv_class,
419 };
420 #endif