[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 chroma_height;
    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;
66	int chroma_height;
67	int upscale_v;
68	int rct; /* standard rct */
69	int pegasus_rct; /* pegasus reversible colorspace transform */
70	int bits; /* bits per component */
71	int colr;
72	int xfrm;
73	int adobe_transform;
74
75	int maxval;
76	int near; ///< near lossless bound (si 0 for lossless)
77	int t1,t2,t3;
78	int reset; ///< context halfing interval ?rename
79
80	int width, height;
81	int mb_width, mb_height;
82	int nb_components;
83	int block_stride[MAX_COMPONENTS];
84	int component_id[MAX_COMPONENTS];
85	int h_count[MAX_COMPONENTS]; /* horizontal and vertical count for each component */
86	int v_count[MAX_COMPONENTS];
87	int comp_index[MAX_COMPONENTS];
88	int dc_index[MAX_COMPONENTS];
89	int ac_index[MAX_COMPONENTS];
90	int nb_blocks[MAX_COMPONENTS];
91	int h_scount[MAX_COMPONENTS];
92	int v_scount[MAX_COMPONENTS];
93	int quant_sindex[MAX_COMPONENTS];
94	int h_max, v_max; /* maximum h and v counts */
95	int quant_index[4]; /* quant table index for each component */
96	int last_dc[MAX_COMPONENTS]; /* last DEQUANTIZED dc (XXX: am I right to do that ?) */
97	AVFrame picture; / picture structure */
98	AVFrame picture_ptr; / pointer to picture structure */
99	int got_picture; ///< we found a SOF and picture is valid, too.
100	int linesize[MAX_COMPONENTS]; ///< linesize << interlaced
101	int8_t *qscale_table;
102	DECLARE_ALIGNED(16, int16_t, block)[64];
103	int16_t (*blocks[MAX_COMPONENTS])[64]; ///< intermediate sums (progressive mode)
104	uint8_t *last_nnz[MAX_COMPONENTS];
105	uint64_t coefs_finished[MAX_COMPONENTS]; ///< bitmask of which coefs have been completely decoded (progressive mode)
106	int palette_index;
107	ScanTable scantable;
108	BlockDSPContext bdsp;
109	HpelDSPContext hdsp;
110	IDCTDSPContext idsp;
111
112	int restart_interval;
113	int restart_count;
114
115	int buggy_avid;
116	int cs_itu601;
117	int interlace_polarity;
118
119	int mjpb_skiptosod;
120
121	int cur_scan; /* current scan, used by JPEG-LS */
122	int flipped; /* true if picture is flipped */
123
124	uint16_t (*ljpeg_buffer)[4];
125	unsigned int ljpeg_buffer_size;
126
127	int extern_huff;
128	AVDictionary *exif_metadata;
129
130	AVStereo3D *stereo3d; ///!< stereoscopic information (cached, since it is read before frame allocation)
131
132	const AVPixFmtDescriptor *pix_desc;
133	} MJpegDecodeContext;
134
135	int ff_mjpeg_decode_init(AVCodecContext *avctx);
136	int ff_mjpeg_decode_end(AVCodecContext *avctx);
137	int ff_mjpeg_decode_frame(AVCodecContext *avctx,
138	void data, int got_frame,
139	AVPacket *avpkt);
140	int ff_mjpeg_decode_dqt(MJpegDecodeContext *s);
141	int ff_mjpeg_decode_dht(MJpegDecodeContext *s);
142	int ff_mjpeg_decode_sof(MJpegDecodeContext *s);
143	int ff_mjpeg_decode_sos(MJpegDecodeContext *s,
144	const uint8_t *mb_bitmask,int mb_bitmask_size,
145	const AVFrame *reference);
146	int ff_mjpeg_find_marker(MJpegDecodeContext *s,
147	const uint8_t *buf_ptr, const uint8_t buf_end,
148	const uint8_t *unescaped_buf_ptr, int unescaped_buf_size);
149
150	#endif /* AVCODEC_MJPEGDEC_H */