[deb_ffmpeg.git] / ffmpeg / libavcodec / mjpegdec.h

/*
 * MJPEG decoder
 * Copyright (c) 2000, 2001 Fabrice Bellard
 * Copyright (c) 2003 Alex Beregszaszi
 * Copyright (c) 2003-2004 Michael Niedermayer
 *
 * This file is part of FFmpeg.
 *
 * FFmpeg 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,
 * 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
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 */

/**
 * @file
 * MJPEG decoder.
 */

#ifndef AVCODEC_MJPEGDEC_H
#define AVCODEC_MJPEGDEC_H

#include "libavutil/log.h"
#include "libavutil/pixdesc.h"
#include "libavutil/stereo3d.h"

#include "avcodec.h"
#include "blockdsp.h"
#include "get_bits.h"
#include "hpeldsp.h"
#include "idctdsp.h"

#define MAX_COMPONENTS 4

typedef struct MJpegDecodeContext {
    AVClass *class;
    AVCodecContext *avctx;
    GetBitContext gb;

    int start_code; /* current start code */
    int buffer_size;
    uint8_t *buffer;

    int16_t quant_matrixes[4][64];
    VLC vlcs[3][4];
    int qscale[4];      ///< quantizer scale calculated from quant_matrixes

    int org_height;  /* size given at codec init */
    int first_picture;    /* true if decoding first picture */
    int interlaced;     /* true if interlaced */
    int bottom_field;   /* true if bottom field */
    int lossless;
    int ls;
    int progressive;
    int rgb;
    int upscale_h;
    int upscale_v;
    int rct;            /* standard rct */
    int pegasus_rct;    /* pegasus reversible colorspace transform */
    int bits;           /* bits per component */
    int colr;
    int xfrm;
    int adobe_transform;

    int maxval;
    int near;         ///< near lossless bound (si 0 for lossless)
    int t1,t2,t3;
    int reset;        ///< context halfing interval ?rename

    int width, height;
    int mb_width, mb_height;
    int nb_components;
    int block_stride[MAX_COMPONENTS];
    int component_id[MAX_COMPONENTS];
    int h_count[MAX_COMPONENTS]; /* horizontal and vertical count for each component */
    int v_count[MAX_COMPONENTS];
    int comp_index[MAX_COMPONENTS];
    int dc_index[MAX_COMPONENTS];
    int ac_index[MAX_COMPONENTS];
    int nb_blocks[MAX_COMPONENTS];
    int h_scount[MAX_COMPONENTS];
    int v_scount[MAX_COMPONENTS];
    int quant_sindex[MAX_COMPONENTS];
    int h_max, v_max; /* maximum h and v counts */
    int quant_index[4];   /* quant table index for each component */
    int last_dc[MAX_COMPONENTS]; /* last DEQUANTIZED dc (XXX: am I right to do that ?) */
    AVFrame *picture; /* picture structure */
    AVFrame *picture_ptr; /* pointer to picture structure */
    int got_picture;                                ///< we found a SOF and picture is valid, too.
    int linesize[MAX_COMPONENTS];                   ///< linesize << interlaced
    int8_t *qscale_table;
    DECLARE_ALIGNED(16, int16_t, block)[64];
    int16_t (*blocks[MAX_COMPONENTS])[64]; ///< intermediate sums (progressive mode)
    uint8_t *last_nnz[MAX_COMPONENTS];
    uint64_t coefs_finished[MAX_COMPONENTS]; ///< bitmask of which coefs have been completely decoded (progressive mode)
    int palette_index;
    ScanTable scantable;
    BlockDSPContext bdsp;
    HpelDSPContext hdsp;
    IDCTDSPContext idsp;

    int restart_interval;
    int restart_count;

    int buggy_avid;
    int cs_itu601;
    int interlace_polarity;

    int mjpb_skiptosod;

    int cur_scan; /* current scan, used by JPEG-LS */
    int flipped; /* true if picture is flipped */

    uint16_t (*ljpeg_buffer)[4];
    unsigned int ljpeg_buffer_size;

    int extern_huff;
    AVDictionary *exif_metadata;

    AVStereo3D *stereo3d; ///!< stereoscopic information (cached, since it is read before frame allocation)

    const AVPixFmtDescriptor *pix_desc;
} MJpegDecodeContext;

int ff_mjpeg_decode_init(AVCodecContext *avctx);
int ff_mjpeg_decode_end(AVCodecContext *avctx);
int ff_mjpeg_decode_frame(AVCodecContext *avctx,
                          void *data, int *got_frame,
                          AVPacket *avpkt);
int ff_mjpeg_decode_dqt(MJpegDecodeContext *s);
int ff_mjpeg_decode_dht(MJpegDecodeContext *s);
int ff_mjpeg_decode_sof(MJpegDecodeContext *s);
int ff_mjpeg_decode_sos(MJpegDecodeContext *s,
                        const uint8_t *mb_bitmask,int mb_bitmask_size,
                        const AVFrame *reference);
int ff_mjpeg_find_marker(MJpegDecodeContext *s,
                         const uint8_t **buf_ptr, const uint8_t *buf_end,
                         const uint8_t **unescaped_buf_ptr, int *unescaped_buf_size);

#endif /* AVCODEC_MJPEGDEC_H */
Commit	Line	Data
2ba45a60 DM	1	/*
	2	* MJPEG decoder
	3	* Copyright (c) 2000, 2001 Fabrice Bellard
	4	* Copyright (c) 2003 Alex Beregszaszi
	5	* Copyright (c) 2003-2004 Michael Niedermayer
	6	*
	7	* This file is part of FFmpeg.
	8	*
	9	* FFmpeg is free software; you can redistribute it and/or
	10	* modify it under the terms of the GNU Lesser General Public
	11	* License as published by the Free Software Foundation; either
	12	* version 2.1 of the License, or (at your option) any later version.
	13	*
	14	* FFmpeg is distributed in the hope that it will be useful,
	15	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	16	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	17	* Lesser General Public License for more details.
	18	*
	19	* You should have received a copy of the GNU Lesser General Public
	20	* License along with FFmpeg; if not, write to the Free Software
	21	* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
	22	*/
	23
	24	/**
	25	* @file
	26	* MJPEG decoder.
	27	*/
	28
	29	#ifndef AVCODEC_MJPEGDEC_H
	30	#define AVCODEC_MJPEGDEC_H
	31
	32	#include "libavutil/log.h"
	33	#include "libavutil/pixdesc.h"
	34	#include "libavutil/stereo3d.h"
	35
	36	#include "avcodec.h"
	37	#include "blockdsp.h"
	38	#include "get_bits.h"
	39	#include "hpeldsp.h"
	40	#include "idctdsp.h"
	41
	42	#define MAX_COMPONENTS 4
	43
	44	typedef struct MJpegDecodeContext {
	45	AVClass *class;
	46	AVCodecContext *avctx;
	47	GetBitContext gb;
	48
	49	int start_code; /* current start code */
	50	int buffer_size;
	51	uint8_t *buffer;
	52
	53	int16_t quant_matrixes[4][64];
	54	VLC vlcs[3][4];
	55	int qscale[4]; ///< quantizer scale calculated from quant_matrixes
	56
	57	int org_height; /* size given at codec init */
	58	int first_picture; /* true if decoding first picture */
	59	int interlaced; /* true if interlaced */
	60	int bottom_field; /* true if bottom field */
	61	int lossless;
	62	int ls;
	63	int progressive;
	64	int rgb;
65	int upscale_h;
2ba45a60 DM	66	int upscale_v;
	67	int rct; /* standard rct */
	68	int pegasus_rct; /* pegasus reversible colorspace transform */
	69	int bits; /* bits per component */
	70	int colr;
	71	int xfrm;
	72	int adobe_transform;
	73
	74	int maxval;
	75	int near; ///< near lossless bound (si 0 for lossless)
	76	int t1,t2,t3;
	77	int reset; ///< context halfing interval ?rename
	78
	79	int width, height;
	80	int mb_width, mb_height;
	81	int nb_components;
	82	int block_stride[MAX_COMPONENTS];
	83	int component_id[MAX_COMPONENTS];
	84	int h_count[MAX_COMPONENTS]; /* horizontal and vertical count for each component */
	85	int v_count[MAX_COMPONENTS];
	86	int comp_index[MAX_COMPONENTS];
	87	int dc_index[MAX_COMPONENTS];
	88	int ac_index[MAX_COMPONENTS];
	89	int nb_blocks[MAX_COMPONENTS];
	90	int h_scount[MAX_COMPONENTS];
	91	int v_scount[MAX_COMPONENTS];
	92	int quant_sindex[MAX_COMPONENTS];
	93	int h_max, v_max; /* maximum h and v counts */
	94	int quant_index[4]; /* quant table index for each component */
	95	int last_dc[MAX_COMPONENTS]; /* last DEQUANTIZED dc (XXX: am I right to do that ?) */
	96	AVFrame picture; / picture structure */
	97	AVFrame picture_ptr; / pointer to picture structure */
	98	int got_picture; ///< we found a SOF and picture is valid, too.
	99	int linesize[MAX_COMPONENTS]; ///< linesize << interlaced
	100	int8_t *qscale_table;
	101	DECLARE_ALIGNED(16, int16_t, block)[64];
	102	int16_t (*blocks[MAX_COMPONENTS])[64]; ///< intermediate sums (progressive mode)
	103	uint8_t *last_nnz[MAX_COMPONENTS];
	104	uint64_t coefs_finished[MAX_COMPONENTS]; ///< bitmask of which coefs have been completely decoded (progressive mode)
	105	int palette_index;
	106	ScanTable scantable;
	107	BlockDSPContext bdsp;
	108	HpelDSPContext hdsp;
	109	IDCTDSPContext idsp;
	110
	111	int restart_interval;
	112	int restart_count;
	113
	114	int buggy_avid;
	115	int cs_itu601;
	116	int interlace_polarity;
	117
	118	int mjpb_skiptosod;
	119
	120	int cur_scan; /* current scan, used by JPEG-LS */
	121	int flipped; /* true if picture is flipped */
	122
	123	uint16_t (*ljpeg_buffer)[4];
	124	unsigned int ljpeg_buffer_size;
	125
	126	int extern_huff;
	127	AVDictionary *exif_metadata;
	128
	129	AVStereo3D *stereo3d; ///!< stereoscopic information (cached, since it is read before frame allocation)
130
131	const AVPixFmtDescriptor *pix_desc;
132	} MJpegDecodeContext;
133
134	int ff_mjpeg_decode_init(AVCodecContext *avctx);
135	int ff_mjpeg_decode_end(AVCodecContext *avctx);
136	int ff_mjpeg_decode_frame(AVCodecContext *avctx,
137	void data, int got_frame,
138	AVPacket *avpkt);
139	int ff_mjpeg_decode_dqt(MJpegDecodeContext *s);
140	int ff_mjpeg_decode_dht(MJpegDecodeContext *s);
141	int ff_mjpeg_decode_sof(MJpegDecodeContext *s);
142	int ff_mjpeg_decode_sos(MJpegDecodeContext *s,
143	const uint8_t *mb_bitmask,int mb_bitmask_size,
144	const AVFrame *reference);
145	int ff_mjpeg_find_marker(MJpegDecodeContext *s,
146	const uint8_t *buf_ptr, const uint8_t buf_end,
147	const uint8_t *unescaped_buf_ptr, int unescaped_buf_size);
148
149	#endif /* AVCODEC_MJPEGDEC_H */