FFmpeg
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
mjpegenc.c
Go to the documentation of this file.
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 "mjpegenc_common.h"
37 #include "mpegvideo.h"
38 #include "mjpeg.h"
39 #include "mjpegenc.h"
40 
42 {
43  MJpegContext *m;
44 
45  if (s->width > 65500 || s->height > 65500) {
46  av_log(s, AV_LOG_ERROR, "JPEG does not support resolutions above 65500x65500\n");
47  return AVERROR(EINVAL);
48  }
49 
50  m = av_malloc(sizeof(MJpegContext));
51  if (!m)
52  return AVERROR(ENOMEM);
53 
54  s->min_qcoeff=-1023;
55  s->max_qcoeff= 1023;
56 
57  /* build all the huffman tables */
74 
75  s->mjpeg_ctx = m;
76  return 0;
77 }
78 
80 {
81  av_free(s->mjpeg_ctx);
82 }
83 
84 static void encode_block(MpegEncContext *s, int16_t *block, int n)
85 {
86  int mant, nbits, code, i, j;
87  int component, dc, run, last_index, val;
88  MJpegContext *m = s->mjpeg_ctx;
89  uint8_t *huff_size_ac;
90  uint16_t *huff_code_ac;
91 
92  /* DC coef */
93  component = (n <= 3 ? 0 : (n&1) + 1);
94  dc = block[0]; /* overflow is impossible */
95  val = dc - s->last_dc[component];
96  if (n < 4) {
98  huff_size_ac = m->huff_size_ac_luminance;
99  huff_code_ac = m->huff_code_ac_luminance;
100  } else {
102  huff_size_ac = m->huff_size_ac_chrominance;
103  huff_code_ac = m->huff_code_ac_chrominance;
104  }
105  s->last_dc[component] = dc;
106 
107  /* AC coefs */
108 
109  run = 0;
110  last_index = s->block_last_index[n];
111  for(i=1;i<=last_index;i++) {
112  j = s->intra_scantable.permutated[i];
113  val = block[j];
114  if (val == 0) {
115  run++;
116  } else {
117  while (run >= 16) {
118  put_bits(&s->pb, huff_size_ac[0xf0], huff_code_ac[0xf0]);
119  run -= 16;
120  }
121  mant = val;
122  if (val < 0) {
123  val = -val;
124  mant--;
125  }
126 
127  nbits= av_log2_16bit(val) + 1;
128  code = (run << 4) | nbits;
129 
130  put_bits(&s->pb, huff_size_ac[code], huff_code_ac[code]);
131 
132  put_sbits(&s->pb, nbits, mant);
133  run = 0;
134  }
135  }
136 
137  /* output EOB only if not already 64 values */
138  if (last_index < 63 || run != 0)
139  put_bits(&s->pb, huff_size_ac[0], huff_code_ac[0]);
140 }
141 
142 void ff_mjpeg_encode_mb(MpegEncContext *s, int16_t block[12][64])
143 {
144  int i;
145  if (s->chroma_format == CHROMA_444) {
146  encode_block(s, block[0], 0);
147  encode_block(s, block[2], 2);
148  encode_block(s, block[4], 4);
149  encode_block(s, block[8], 8);
150  encode_block(s, block[5], 5);
151  encode_block(s, block[9], 9);
152 
153  if (16*s->mb_x+8 < s->width) {
154  encode_block(s, block[1], 1);
155  encode_block(s, block[3], 3);
156  encode_block(s, block[6], 6);
157  encode_block(s, block[10], 10);
158  encode_block(s, block[7], 7);
159  encode_block(s, block[11], 11);
160  }
161  } else {
162  for(i=0;i<5;i++) {
163  encode_block(s, block[i], i);
164  }
165  if (s->chroma_format == CHROMA_420) {
166  encode_block(s, block[5], 5);
167  } else {
168  encode_block(s, block[6], 6);
169  encode_block(s, block[5], 5);
170  encode_block(s, block[7], 7);
171  }
172  }
173 
174  s->i_tex_bits += get_bits_diff(s);
175 }
176 
177 // maximum over s->mjpeg_vsample[i]
178 #define V_MAX 2
180  const AVFrame *pic_arg, int *got_packet)
181 
182 {
183  MpegEncContext *s = avctx->priv_data;
184  AVFrame *pic;
185  int i, ret;
186  int chroma_h_shift, chroma_v_shift;
187 
188  av_pix_fmt_get_chroma_sub_sample(avctx->pix_fmt, &chroma_h_shift, &chroma_v_shift);
189 
190  //CODEC_FLAG_EMU_EDGE have to be cleared
192  return AVERROR(EINVAL);
193 
194  if ((avctx->height & 15) && avctx->strict_std_compliance > FF_COMPLIANCE_UNOFFICIAL) {
195  av_log(avctx, AV_LOG_ERROR,
196  "Heights which are not a multiple of 16 might fail with some decoders, "
197  "use vstrict=-1 / -strict -1 to use %d anyway.\n", avctx->height);
198  av_log(avctx, AV_LOG_WARNING, "If you have a device that plays AMV videos, please test if videos "
199  "with such heights work with it and report your findings to ffmpeg-devel@ffmpeg.org\n");
200  return AVERROR_EXPERIMENTAL;
201  }
202 
203  pic = av_frame_clone(pic_arg);
204  if (!pic)
205  return AVERROR(ENOMEM);
206  //picture should be flipped upside-down
207  for(i=0; i < 3; i++) {
208  int vsample = i ? 2 >> chroma_v_shift : 2;
209  pic->data[i] += pic->linesize[i] * (vsample * s->height / V_MAX - 1);
210  pic->linesize[i] *= -1;
211  }
212  ret = ff_mpv_encode_picture(avctx, pkt, pic, got_packet);
213  av_frame_free(&pic);
214  return ret;
215 }
216 
217 #if CONFIG_MJPEG_ENCODER
219 
220 AVCodec ff_mjpeg_encoder = {
221  .name = "mjpeg",
222  .long_name = NULL_IF_CONFIG_SMALL("MJPEG (Motion JPEG)"),
223  .type = AVMEDIA_TYPE_VIDEO,
224  .id = AV_CODEC_ID_MJPEG,
225  .priv_data_size = sizeof(MpegEncContext),
227  .encode2 = ff_mpv_encode_picture,
230  .pix_fmts = (const enum AVPixelFormat[]){
232  },
233  .priv_class = &mjpeg_class,
234 };
235 #endif
236 #if CONFIG_AMV_ENCODER
238 
239 AVCodec ff_amv_encoder = {
240  .name = "amv",
241  .long_name = NULL_IF_CONFIG_SMALL("AMV Video"),
242  .type = AVMEDIA_TYPE_VIDEO,
243  .id = AV_CODEC_ID_AMV,
244  .priv_data_size = sizeof(MpegEncContext),
246  .encode2 = amv_encode_picture,
248  .pix_fmts = (const enum AVPixelFormat[]){
250  },
251  .priv_class = &amv_class,
252 };
253 #endif