X-Git-Url: https://git.sesse.net/?a=blobdiff_plain;f=libavcodec%2Fljpegenc.c;h=b6d73a42be48bc88876c3ca54581f310af56535d;hb=5f74bd31a9bd1ac7655103b11743c12d38e0419f;hp=cbe1afc23a0c4b76bd2cfa3169bae9338df9b3fd;hpb=6140271f545698b7084bb5e02c0cac25e5304289;p=ffmpeg diff --git a/libavcodec/ljpegenc.c b/libavcodec/ljpegenc.c index cbe1afc23a0..b6d73a42be4 100644 --- a/libavcodec/ljpegenc.c +++ b/libavcodec/ljpegenc.c @@ -1,6 +1,6 @@ /* * lossless JPEG encoder - * Copyright (c) 2000, 2001 Fabrice Bellard. + * Copyright (c) 2000, 2001 Fabrice Bellard * Copyright (c) 2003 Alex Beregszaszi * Copyright (c) 2003-2004 Michael Niedermayer * @@ -8,191 +8,362 @@ * aspecting, new decode_frame mechanism and apple mjpeg-b support * by Alex Beregszaszi * - * This file is part of FFmpeg. + * This file is part of Libav. * - * FFmpeg is free software; you can redistribute it and/or + * 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 */ /** - * @file ljpegenc.c + * @file * lossless JPEG encoder. */ +#include "libavutil/frame.h" +#include "libavutil/mem.h" +#include "libavutil/pixdesc.h" + #include "avcodec.h" -#include "dsputil.h" -#include "mpegvideo.h" +#include "idctdsp.h" +#include "internal.h" +#include "jpegtables.h" +#include "mjpegenc_common.h" #include "mjpeg.h" #include "mjpegenc.h" +typedef struct LJpegEncContext { + AVClass *class; + IDCTDSPContext idsp; + ScanTable scantable; + uint16_t matrix[64]; + + int vsample[3]; + int hsample[3]; -static int encode_picture_lossless(AVCodecContext *avctx, unsigned char *buf, int buf_size, void *data){ - MpegEncContext * const s = avctx->priv_data; - MJpegContext * const m = s->mjpeg_ctx; - AVFrame *pict = data; - const int width= s->width; - const int height= s->height; - AVFrame * const p= (AVFrame*)&s->current_picture; - const int predictor= avctx->prediction_method+1; + uint16_t huff_code_dc_luminance[12]; + uint16_t huff_code_dc_chrominance[12]; + uint8_t huff_size_dc_luminance[12]; + uint8_t huff_size_dc_chrominance[12]; - init_put_bits(&s->pb, buf, buf_size); + uint16_t (*scratch)[4]; + int pred; +} LJpegEncContext; - *p = *pict; - p->pict_type= FF_I_TYPE; - p->key_frame= 1; +static int ljpeg_encode_bgr(AVCodecContext *avctx, PutBitContext *pb, + const AVFrame *frame) +{ + LJpegEncContext *s = avctx->priv_data; + const int width = frame->width; + const int height = frame->height; + const int linesize = frame->linesize[0]; + uint16_t (*buffer)[4] = s->scratch; + int left[3], top[3], topleft[3]; + int x, y, i; - ff_mjpeg_encode_picture_header(s); +#if FF_API_PRIVATE_OPT +FF_DISABLE_DEPRECATION_WARNINGS + if (avctx->prediction_method) + s->pred = avctx->prediction_method + 1; +FF_ENABLE_DEPRECATION_WARNINGS +#endif - s->header_bits= put_bits_count(&s->pb); + for (i = 0; i < 3; i++) + buffer[0][i] = 1 << (9 - 1); - if(avctx->pix_fmt == PIX_FMT_RGB32){ - int x, y, i; - const int linesize= p->linesize[0]; - uint16_t (*buffer)[4]= (void *) s->rd_scratchpad; - int left[3], top[3], topleft[3]; + for (y = 0; y < height; y++) { + const int modified_predictor = y ? s->pred : 1; + uint8_t *ptr = frame->data[0] + (linesize * y); - for(i=0; i<3; i++){ - buffer[0][i]= 1 << (9 - 1); + if (pb->buf_end - pb->buf - (put_bits_count(pb) >> 3) < width * 3 * 3) { + av_log(avctx, AV_LOG_ERROR, "encoded frame too large\n"); + return -1; } - for(y = 0; y < height; y++) { - const int modified_predictor= y ? predictor : 1; - uint8_t *ptr = p->data[0] + (linesize * y); + for (i = 0; i < 3; i++) + top[i]= left[i]= topleft[i]= buffer[0][i]; - if(s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb)>>3) < width*3*4){ - av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n"); - return -1; - } + for (x = 0; x < width; x++) { + buffer[x][1] = ptr[3 * x + 0] - ptr[3 * x + 1] + 0x100; + buffer[x][2] = ptr[3 * x + 2] - ptr[3 * x + 1] + 0x100; + buffer[x][0] = (ptr[3 * x + 0] + 2 * ptr[3 * x + 1] + ptr[3 * x + 2]) >> 2; + + for (i = 0; i < 3; i++) { + int pred, diff; + + PREDICT(pred, topleft[i], top[i], left[i], modified_predictor); + + topleft[i] = top[i]; + top[i] = buffer[x+1][i]; + + left[i] = buffer[x][i]; + + diff = ((left[i] - pred + 0x100) & 0x1FF) - 0x100; - for(i=0; i<3; i++){ - top[i]= left[i]= topleft[i]= buffer[0][i]; + if (i == 0) + ff_mjpeg_encode_dc(pb, diff, s->huff_size_dc_luminance, s->huff_code_dc_luminance); //FIXME ugly + else + ff_mjpeg_encode_dc(pb, diff, s->huff_size_dc_chrominance, s->huff_code_dc_chrominance); } - for(x = 0; x < width; x++) { - buffer[x][1] = ptr[4*x+0] - ptr[4*x+1] + 0x100; - buffer[x][2] = ptr[4*x+2] - ptr[4*x+1] + 0x100; - buffer[x][0] = (ptr[4*x+0] + 2*ptr[4*x+1] + ptr[4*x+2])>>2; + } + } - for(i=0;i<3;i++) { - int pred, diff; + return 0; +} - PREDICT(pred, topleft[i], top[i], left[i], modified_predictor); +static inline void ljpeg_encode_yuv_mb(LJpegEncContext *s, PutBitContext *pb, + const AVFrame *frame, int predictor, + int mb_x, int mb_y) +{ + int i; - topleft[i]= top[i]; - top[i]= buffer[x+1][i]; + if (mb_x == 0 || mb_y == 0) { + for (i = 0; i < 3; i++) { + uint8_t *ptr; + int x, y, h, v, linesize; + h = s->hsample[i]; + v = s->vsample[i]; + linesize = frame->linesize[i]; - left[i]= buffer[x][i]; + for (y = 0; y < v; y++) { + for (x = 0; x < h; x++) { + int pred; - diff= ((left[i] - pred + 0x100)&0x1FF) - 0x100; + ptr = frame->data[i] + (linesize * (v * mb_y + y)) + (h * mb_x + x); //FIXME optimize this crap + if (y == 0 && mb_y == 0) { + if (x == 0 && mb_x == 0) + pred = 128; + else + pred = ptr[-1]; + } else { + if (x == 0 && mb_x == 0) { + pred = ptr[-linesize]; + } else { + PREDICT(pred, ptr[-linesize - 1], ptr[-linesize], + ptr[-1], predictor); + } + } - if(i==0) - ff_mjpeg_encode_dc(s, diff, m->huff_size_dc_luminance, m->huff_code_dc_luminance); //FIXME ugly + if (i == 0) + ff_mjpeg_encode_dc(pb, *ptr - pred, s->huff_size_dc_luminance, s->huff_code_dc_luminance); //FIXME ugly else - ff_mjpeg_encode_dc(s, diff, m->huff_size_dc_chrominance, m->huff_code_dc_chrominance); + ff_mjpeg_encode_dc(pb, *ptr - pred, s->huff_size_dc_chrominance, s->huff_code_dc_chrominance); } } } - }else{ - int mb_x, mb_y, i; - const int mb_width = (width + s->mjpeg_hsample[0] - 1) / s->mjpeg_hsample[0]; - const int mb_height = (height + s->mjpeg_vsample[0] - 1) / s->mjpeg_vsample[0]; - - for(mb_y = 0; mb_y < mb_height; mb_y++) { - if(s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb)>>3) < mb_width * 4 * 3 * s->mjpeg_hsample[0] * s->mjpeg_vsample[0]){ - av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n"); - return -1; - } - for(mb_x = 0; mb_x < mb_width; mb_x++) { - if(mb_x==0 || mb_y==0){ - for(i=0;i<3;i++) { - uint8_t *ptr; - int x, y, h, v, linesize; - h = s->mjpeg_hsample[i]; - v = s->mjpeg_vsample[i]; - linesize= p->linesize[i]; - - for(y=0; ydata[i] + (linesize * (v * mb_y + y)) + (h * mb_x + x); //FIXME optimize this crap - if(y==0 && mb_y==0){ - if(x==0 && mb_x==0){ - pred= 128; - }else{ - pred= ptr[-1]; - } - }else{ - if(x==0 && mb_x==0){ - pred= ptr[-linesize]; - }else{ - PREDICT(pred, ptr[-linesize-1], ptr[-linesize], ptr[-1], predictor); - } - } - - if(i==0) - ff_mjpeg_encode_dc(s, (int8_t)(*ptr - pred), m->huff_size_dc_luminance, m->huff_code_dc_luminance); //FIXME ugly - else - ff_mjpeg_encode_dc(s, (int8_t)(*ptr - pred), m->huff_size_dc_chrominance, m->huff_code_dc_chrominance); - } - } - } - }else{ - for(i=0;i<3;i++) { - uint8_t *ptr; - int x, y, h, v, linesize; - h = s->mjpeg_hsample[i]; - v = s->mjpeg_vsample[i]; - linesize= p->linesize[i]; - - for(y=0; ydata[i] + (linesize * (v * mb_y + y)) + (h * mb_x + x); //FIXME optimize this crap -//printf("%d %d %d %d %8X\n", mb_x, mb_y, x, y, ptr); - PREDICT(pred, ptr[-linesize-1], ptr[-linesize], ptr[-1], predictor); - - if(i==0) - ff_mjpeg_encode_dc(s, (int8_t)(*ptr - pred), m->huff_size_dc_luminance, m->huff_code_dc_luminance); //FIXME ugly - else - ff_mjpeg_encode_dc(s, (int8_t)(*ptr - pred), m->huff_size_dc_chrominance, m->huff_code_dc_chrominance); - } - } - } + } else { + for (i = 0; i < 3; i++) { + uint8_t *ptr; + int x, y, h, v, linesize; + h = s->hsample[i]; + v = s->vsample[i]; + linesize = frame->linesize[i]; + + for (y = 0; y < v; y++) { + for (x = 0; x < h; x++) { + int pred; + + ptr = frame->data[i] + (linesize * (v * mb_y + y)) + (h * mb_x + x); //FIXME optimize this crap + PREDICT(pred, ptr[-linesize - 1], ptr[-linesize], ptr[-1], predictor); + + if (i == 0) + ff_mjpeg_encode_dc(pb, *ptr - pred, s->huff_size_dc_luminance, s->huff_code_dc_luminance); //FIXME ugly + else + ff_mjpeg_encode_dc(pb, *ptr - pred, s->huff_size_dc_chrominance, s->huff_code_dc_chrominance); } } } } +} + +static int ljpeg_encode_yuv(AVCodecContext *avctx, PutBitContext *pb, + const AVFrame *frame) +{ + LJpegEncContext *s = avctx->priv_data; + const int mb_width = (avctx->width + s->hsample[0] - 1) / s->hsample[0]; + const int mb_height = (avctx->height + s->vsample[0] - 1) / s->vsample[0]; + int mb_x, mb_y; + +#if FF_API_PRIVATE_OPT +FF_DISABLE_DEPRECATION_WARNINGS + if (avctx->prediction_method) + s->pred = avctx->prediction_method + 1; +FF_ENABLE_DEPRECATION_WARNINGS +#endif + + for (mb_y = 0; mb_y < mb_height; mb_y++) { + if (pb->buf_end - pb->buf - (put_bits_count(pb) >> 3) < + mb_width * 4 * 3 * s->hsample[0] * s->vsample[0]) { + av_log(avctx, AV_LOG_ERROR, "encoded frame too large\n"); + return -1; + } + + for (mb_x = 0; mb_x < mb_width; mb_x++) + ljpeg_encode_yuv_mb(s, pb, frame, s->pred, mb_x, mb_y); + } + + return 0; +} + +static int ljpeg_encode_frame(AVCodecContext *avctx, AVPacket *pkt, + const AVFrame *pict, int *got_packet) +{ + LJpegEncContext *s = avctx->priv_data; + PutBitContext pb; + const int width = avctx->width; + const int height = avctx->height; + const int mb_width = (width + s->hsample[0] - 1) / s->hsample[0]; + const int mb_height = (height + s->vsample[0] - 1) / s->vsample[0]; + int max_pkt_size = AV_INPUT_BUFFER_MIN_SIZE; + int ret, header_bits; + + if (avctx->pix_fmt == AV_PIX_FMT_BGR24) + max_pkt_size += width * height * 3 * 3; + else { + max_pkt_size += mb_width * mb_height * 3 * 4 + * s->hsample[0] * s->vsample[0]; + } + if ((ret = ff_alloc_packet(pkt, max_pkt_size)) < 0) { + av_log(avctx, AV_LOG_ERROR, "Error getting output packet of size %d.\n", max_pkt_size); + return ret; + } + + init_put_bits(&pb, pkt->data, pkt->size); + + ff_mjpeg_encode_picture_header(avctx, &pb, &s->scantable, + s->pred, s->matrix); + + header_bits = put_bits_count(&pb); + + if (avctx->pix_fmt == AV_PIX_FMT_BGR24) + ret = ljpeg_encode_bgr(avctx, &pb, pict); + else + ret = ljpeg_encode_yuv(avctx, &pb, pict); + if (ret < 0) + return ret; emms_c(); - ff_mjpeg_encode_picture_trailer(s); - s->picture_number++; + ff_mjpeg_encode_picture_trailer(&pb, header_bits); + + flush_put_bits(&pb); + pkt->size = put_bits_ptr(&pb) - pb.buf; + pkt->flags |= AV_PKT_FLAG_KEY; + *got_packet = 1; + + return 0; +} + +static av_cold int ljpeg_encode_close(AVCodecContext *avctx) +{ + LJpegEncContext *s = avctx->priv_data; + + av_freep(&s->scratch); + + return 0; +} + +static av_cold int ljpeg_encode_init(AVCodecContext *avctx) +{ + LJpegEncContext *s = avctx->priv_data; + int chroma_v_shift, chroma_h_shift; + + if ((avctx->pix_fmt == AV_PIX_FMT_YUV420P || + avctx->pix_fmt == AV_PIX_FMT_YUV422P || + avctx->pix_fmt == AV_PIX_FMT_YUV444P || + avctx->color_range == AVCOL_RANGE_MPEG) && + avctx->strict_std_compliance > FF_COMPLIANCE_UNOFFICIAL) { + av_log(avctx, AV_LOG_ERROR, + "Limited range YUV is non-standard, set strict_std_compliance to " + "at least unofficial to use it.\n"); + return AVERROR(EINVAL); + } + +#if FF_API_CODED_FRAME +FF_DISABLE_DEPRECATION_WARNINGS + avctx->coded_frame->pict_type = AV_PICTURE_TYPE_I; + avctx->coded_frame->key_frame = 1; +FF_ENABLE_DEPRECATION_WARNINGS +#endif + + s->scratch = av_malloc_array(avctx->width + 1, sizeof(*s->scratch)); + + ff_idctdsp_init(&s->idsp, avctx); + ff_init_scantable(s->idsp.idct_permutation, &s->scantable, + ff_zigzag_direct); + + av_pix_fmt_get_chroma_sub_sample(avctx->pix_fmt, &chroma_h_shift, + &chroma_v_shift); - flush_put_bits(&s->pb); - return pbBufPtr(&s->pb) - s->pb.buf; -// return (put_bits_count(&f->pb)+7)/8; + if (avctx->pix_fmt == AV_PIX_FMT_BGR24) { + s->vsample[0] = s->hsample[0] = + s->vsample[1] = s->hsample[1] = + s->vsample[2] = s->hsample[2] = 1; + } else { + s->vsample[0] = 2; + s->vsample[1] = 2 >> chroma_v_shift; + s->vsample[2] = 2 >> chroma_v_shift; + s->hsample[0] = 2; + s->hsample[1] = 2 >> chroma_h_shift; + s->hsample[2] = 2 >> chroma_h_shift; + } + + ff_mjpeg_build_huffman_codes(s->huff_size_dc_luminance, + s->huff_code_dc_luminance, + avpriv_mjpeg_bits_dc_luminance, + avpriv_mjpeg_val_dc); + ff_mjpeg_build_huffman_codes(s->huff_size_dc_chrominance, + s->huff_code_dc_chrominance, + avpriv_mjpeg_bits_dc_chrominance, + avpriv_mjpeg_val_dc); + + return 0; } +#define OFFSET(x) offsetof(LJpegEncContext, x) +#define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM +static const AVOption options[] = { +{ "pred", "Prediction method", OFFSET(pred), AV_OPT_TYPE_INT, { .i64 = 1 }, 1, 3, VE, "pred" }, + { "left", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = 1 }, INT_MIN, INT_MAX, VE, "pred" }, + { "plane", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = 2 }, INT_MIN, INT_MAX, VE, "pred" }, + { "median", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = 3 }, INT_MIN, INT_MAX, VE, "pred" }, + + { NULL}, +}; + +static const AVClass ljpeg_class = { + .class_name = "ljpeg", + .item_name = av_default_item_name, + .option = options, + .version = LIBAVUTIL_VERSION_INT, +}; -AVCodec ljpeg_encoder = { //FIXME avoid MPV_* lossless JPEG should not need them - "ljpeg", - CODEC_TYPE_VIDEO, - CODEC_ID_LJPEG, - sizeof(MpegEncContext), - MPV_encode_init, - encode_picture_lossless, - MPV_encode_end, - .long_name = "Lossless JPEG", +AVCodec ff_ljpeg_encoder = { + .name = "ljpeg", + .long_name = NULL_IF_CONFIG_SMALL("Lossless JPEG"), + .type = AVMEDIA_TYPE_VIDEO, + .id = AV_CODEC_ID_LJPEG, + .priv_data_size = sizeof(LJpegEncContext), + .priv_class = &ljpeg_class, + .init = ljpeg_encode_init, + .encode2 = ljpeg_encode_frame, + .close = ljpeg_encode_close, + .pix_fmts = (const enum AVPixelFormat[]){ AV_PIX_FMT_YUVJ420P, + AV_PIX_FMT_YUVJ422P, + AV_PIX_FMT_YUVJ444P, + AV_PIX_FMT_BGR24, + AV_PIX_FMT_YUV420P, + AV_PIX_FMT_YUV422P, + AV_PIX_FMT_YUV444P, + AV_PIX_FMT_NONE }, };