/*
* MJPEG encoder
- * Copyright (c) 2000, 2001 Fabrice Bellard.
+ * Copyright (c) 2000, 2001 Fabrice Bellard
* Copyright (c) 2003 Alex Beregszaszi
* Copyright (c) 2003-2004 Michael Niedermayer
*
- * This file is part of FFmpeg.
+ * Support for external huffman table, various fixes (AVID workaround),
+ * aspecting, new decode_frame mechanism and apple mjpeg-b support
+ * by Alex Beregszaszi
*
- * FFmpeg is free software; you can redistribute it and/or
+ * This file is part of Libav.
+ *
+ * Libav is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
- * FFmpeg is distributed in the hope that it will be useful,
+ * Libav is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
- * License along with FFmpeg; if not, write to the Free Software
+ * License along with Libav; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
- *
- * Support for external huffman table, various fixes (AVID workaround),
- * aspecting, new decode_frame mechanism and apple mjpeg-b support
- * by Alex Beregszaszi
*/
/**
- * @file mjpegenc.c
+ * @file
* MJPEG encoder.
*/
#undef TWOMATRIXES
-int ff_mjpeg_encode_init(MpegEncContext *s)
+av_cold int ff_mjpeg_encode_init(MpegEncContext *s)
{
MJpegContext *m;
/* build all the huffman tables */
ff_mjpeg_build_huffman_codes(m->huff_size_dc_luminance,
m->huff_code_dc_luminance,
- ff_mjpeg_bits_dc_luminance,
- ff_mjpeg_val_dc_luminance);
+ avpriv_mjpeg_bits_dc_luminance,
+ avpriv_mjpeg_val_dc);
ff_mjpeg_build_huffman_codes(m->huff_size_dc_chrominance,
m->huff_code_dc_chrominance,
- ff_mjpeg_bits_dc_chrominance,
- ff_mjpeg_val_dc_chrominance);
+ avpriv_mjpeg_bits_dc_chrominance,
+ avpriv_mjpeg_val_dc);
ff_mjpeg_build_huffman_codes(m->huff_size_ac_luminance,
m->huff_code_ac_luminance,
- ff_mjpeg_bits_ac_luminance,
- ff_mjpeg_val_ac_luminance);
+ avpriv_mjpeg_bits_ac_luminance,
+ avpriv_mjpeg_val_ac_luminance);
ff_mjpeg_build_huffman_codes(m->huff_size_ac_chrominance,
m->huff_code_ac_chrominance,
- ff_mjpeg_bits_ac_chrominance,
- ff_mjpeg_val_ac_chrominance);
+ avpriv_mjpeg_bits_ac_chrominance,
+ avpriv_mjpeg_val_ac_chrominance);
s->mjpeg_ctx = m;
return 0;
/* huffman table */
put_marker(p, DHT);
flush_put_bits(p);
- ptr = pbBufPtr(p);
+ ptr = put_bits_ptr(p);
put_bits(p, 16, 0); /* patched later */
size = 2;
- size += put_huffman_table(s, 0, 0, ff_mjpeg_bits_dc_luminance,
- ff_mjpeg_val_dc_luminance);
- size += put_huffman_table(s, 0, 1, ff_mjpeg_bits_dc_chrominance,
- ff_mjpeg_val_dc_chrominance);
-
- size += put_huffman_table(s, 1, 0, ff_mjpeg_bits_ac_luminance,
- ff_mjpeg_val_ac_luminance);
- size += put_huffman_table(s, 1, 1, ff_mjpeg_bits_ac_chrominance,
- ff_mjpeg_val_ac_chrominance);
- ptr[0] = size >> 8;
- ptr[1] = size;
+ size += put_huffman_table(s, 0, 0, avpriv_mjpeg_bits_dc_luminance,
+ avpriv_mjpeg_val_dc);
+ size += put_huffman_table(s, 0, 1, avpriv_mjpeg_bits_dc_chrominance,
+ avpriv_mjpeg_val_dc);
+
+ size += put_huffman_table(s, 1, 0, avpriv_mjpeg_bits_ac_luminance,
+ avpriv_mjpeg_val_ac_luminance);
+ size += put_huffman_table(s, 1, 1, avpriv_mjpeg_bits_ac_chrominance,
+ avpriv_mjpeg_val_ac_chrominance);
+ AV_WB16(ptr, size);
}
static void jpeg_put_comments(MpegEncContext *s)
/* JFIF header */
put_marker(p, APP0);
put_bits(p, 16, 16);
- ff_put_string(p, "JFIF", 1); /* this puts the trailing zero-byte too */
+ avpriv_put_string(p, "JFIF", 1); /* this puts the trailing zero-byte too */
put_bits(p, 16, 0x0201); /* v 1.02 */
put_bits(p, 8, 0); /* units type: 0 - aspect ratio */
put_bits(p, 16, s->avctx->sample_aspect_ratio.num);
if(!(s->flags & CODEC_FLAG_BITEXACT)){
put_marker(p, COM);
flush_put_bits(p);
- ptr = pbBufPtr(p);
+ ptr = put_bits_ptr(p);
put_bits(p, 16, 0); /* patched later */
- ff_put_string(p, LIBAVCODEC_IDENT, 1);
+ avpriv_put_string(p, LIBAVCODEC_IDENT, 1);
size = strlen(LIBAVCODEC_IDENT)+3;
- ptr[0] = size >> 8;
- ptr[1] = size;
+ AV_WB16(ptr, size);
}
- if( s->avctx->pix_fmt == PIX_FMT_YUV420P
- ||s->avctx->pix_fmt == PIX_FMT_YUV422P
- ||s->avctx->pix_fmt == PIX_FMT_YUV444P){
+ if( s->avctx->pix_fmt == AV_PIX_FMT_YUV420P
+ ||s->avctx->pix_fmt == AV_PIX_FMT_YUV422P
+ ||s->avctx->pix_fmt == AV_PIX_FMT_YUV444P){
put_marker(p, COM);
flush_put_bits(p);
- ptr = pbBufPtr(p);
+ ptr = put_bits_ptr(p);
put_bits(p, 16, 0); /* patched later */
- ff_put_string(p, "CS=ITU601", 1);
+ avpriv_put_string(p, "CS=ITU601", 1);
size = strlen("CS=ITU601")+3;
- ptr[0] = size >> 8;
- ptr[1] = size;
+ AV_WB16(ptr, size);
}
}
void ff_mjpeg_encode_picture_header(MpegEncContext *s)
{
- const int lossless= s->avctx->codec_id != CODEC_ID_MJPEG;
+ const int lossless= s->avctx->codec_id != AV_CODEC_ID_MJPEG;
put_marker(&s->pb, SOI);
jpeg_table_header(s);
switch(s->avctx->codec_id){
- case CODEC_ID_MJPEG: put_marker(&s->pb, SOF0 ); break;
- case CODEC_ID_LJPEG: put_marker(&s->pb, SOF3 ); break;
+ case AV_CODEC_ID_MJPEG: put_marker(&s->pb, SOF0 ); break;
+ case AV_CODEC_ID_LJPEG: put_marker(&s->pb, SOF3 ); break;
default: assert(0);
}
put_bits(&s->pb, 16, 17);
- if(lossless && s->avctx->pix_fmt == PIX_FMT_RGB32)
+ if(lossless && s->avctx->pix_fmt == AV_PIX_FMT_BGRA)
put_bits(&s->pb, 8, 9); /* 9 bits/component RCT */
else
put_bits(&s->pb, 8, 8); /* 8 bits/component */
put_bits(&s->pb, 8, lossless ? s->avctx->prediction_method+1 : 0); /* Ss (not used) */
switch(s->avctx->codec_id){
- case CODEC_ID_MJPEG: put_bits(&s->pb, 8, 63); break; /* Se (not used) */
- case CODEC_ID_LJPEG: put_bits(&s->pb, 8, 0); break; /* not used */
+ case AV_CODEC_ID_MJPEG: put_bits(&s->pb, 8, 63); break; /* Se (not used) */
+ case AV_CODEC_ID_LJPEG: put_bits(&s->pb, 8, 0); break; /* not used */
default: assert(0);
}
if(ff_count==0) return;
- /* skip put bits */
- for(i=0; i<ff_count-3; i+=4)
- put_bits(&s->pb, 32, 0);
- put_bits(&s->pb, (ff_count-i)*8, 0);
flush_put_bits(&s->pb);
+ skip_put_bytes(&s->pb, ff_count);
for(i=size-1; ff_count; i--){
int v= buf[i];
if(v==0xFF){
-//printf("%d %d\n", i, ff_count);
buf[i+ff_count]= 0;
ff_count--;
}
put_bits(&s->pb, huff_size[nbits], huff_code[nbits]);
- put_bits(&s->pb, nbits, mant & ((1 << nbits) - 1));
+ put_sbits(&s->pb, nbits, mant);
}
}
-static void encode_block(MpegEncContext *s, DCTELEM *block, int n)
+static void encode_block(MpegEncContext *s, int16_t *block, int n)
{
int mant, nbits, code, i, j;
int component, dc, run, last_index, val;
put_bits(&s->pb, huff_size_ac[code], huff_code_ac[code]);
- put_bits(&s->pb, nbits, mant & ((1 << nbits) - 1));
+ put_sbits(&s->pb, nbits, mant);
run = 0;
}
}
put_bits(&s->pb, huff_size_ac[0], huff_code_ac[0]);
}
-void ff_mjpeg_encode_mb(MpegEncContext *s, DCTELEM block[6][64])
+void ff_mjpeg_encode_mb(MpegEncContext *s, int16_t block[6][64])
{
int i;
for(i=0;i<5;i++) {
encode_block(s, block[5], 5);
encode_block(s, block[7], 7);
}
+
+ s->i_tex_bits += get_bits_diff(s);
}
+
+AVCodec ff_mjpeg_encoder = {
+ .name = "mjpeg",
+ .type = AVMEDIA_TYPE_VIDEO,
+ .id = AV_CODEC_ID_MJPEG,
+ .priv_data_size = sizeof(MpegEncContext),
+ .init = ff_MPV_encode_init,
+ .encode2 = ff_MPV_encode_picture,
+ .close = ff_MPV_encode_end,
+ .pix_fmts = (const enum AVPixelFormat[]){
+ AV_PIX_FMT_YUVJ420P, AV_PIX_FMT_YUVJ422P, AV_PIX_FMT_NONE
+ },
+ .long_name = NULL_IF_CONFIG_SMALL("MJPEG (Motion JPEG)"),
+};
projects / ffmpeg / blobdiff