mjpegdec: K&R formatting cosmetics
Signed-off-by: Diego Biurrun <diego@biurrun.de>
This commit is contained in:
Daniel Huang
Diego Biurrun
parent
999484c9fb
commit
8549cf073b
@ -42,8 +42,9 @@
|
||||
#include "jpeglsdec.h"
|
||||
|
||||
|
||||
static int build_vlc(VLC *vlc, const uint8_t *bits_table, const uint8_t *val_table,
|
||||
int nb_codes, int use_static, int is_ac)
|
||||
static int build_vlc(VLC *vlc, const uint8_t *bits_table,
|
||||
const uint8_t *val_table, int nb_codes,
|
||||
int use_static, int is_ac)
|
||||
{
|
||||
uint8_t huff_size[256];
|
||||
uint16_t huff_code[256];
|
||||
@ -58,12 +59,15 @@ static int build_vlc(VLC *vlc, const uint8_t *bits_table, const uint8_t *val_tab
|
||||
for (i = 0; i < 256; i++)
|
||||
huff_sym[i] = i + 16 * is_ac;
|
||||
|
||||
if(is_ac) huff_sym[0]= 16*256;
|
||||
if (is_ac)
|
||||
huff_sym[0] = 16 * 256;
|
||||
|
||||
return init_vlc_sparse(vlc, 9, nb_codes, huff_size, 1, 1, huff_code, 2, 2, huff_sym, 2, 2, use_static);
|
||||
return init_vlc_sparse(vlc, 9, nb_codes, huff_size, 1, 1,
|
||||
huff_code, 2, 2, huff_sym, 2, 2, use_static);
|
||||
}
|
||||
|
||||
static void build_basic_mjpeg_vlc(MJpegDecodeContext * s) {
|
||||
static void build_basic_mjpeg_vlc(MJpegDecodeContext *s)
|
||||
{
|
||||
build_vlc(&s->vlcs[0][0], ff_mjpeg_bits_dc_luminance,
|
||||
ff_mjpeg_val_dc, 12, 0, 0);
|
||||
build_vlc(&s->vlcs[0][1], ff_mjpeg_bits_dc_chrominance,
|
||||
@ -101,12 +105,12 @@ av_cold int ff_mjpeg_decode_init(AVCodecContext *avctx)
|
||||
if (avctx->flags & CODEC_FLAG_EXTERN_HUFF)
|
||||
s->extern_huff = 1;
|
||||
#endif
|
||||
if (s->extern_huff)
|
||||
{
|
||||
if (s->extern_huff) {
|
||||
av_log(avctx, AV_LOG_INFO, "mjpeg: using external huffman table\n");
|
||||
init_get_bits(&s->gb, avctx->extradata, avctx->extradata_size * 8);
|
||||
if (ff_mjpeg_decode_dht(s)) {
|
||||
av_log(avctx, AV_LOG_ERROR, "mjpeg: error using external huffman table\n");
|
||||
av_log(avctx, AV_LOG_ERROR,
|
||||
"mjpeg: error using external huffman table\n");
|
||||
return AVERROR_INVALIDDATA;
|
||||
}
|
||||
}
|
||||
@ -130,8 +134,7 @@ int ff_mjpeg_decode_dqt(MJpegDecodeContext *s)
|
||||
|
||||
while (len >= 65) {
|
||||
/* only 8 bit precision handled */
|
||||
if (get_bits(&s->gb, 4) != 0)
|
||||
{
|
||||
if (get_bits(&s->gb, 4) != 0) {
|
||||
av_log(s->avctx, AV_LOG_ERROR, "dqt: 16bit precision\n");
|
||||
return -1;
|
||||
}
|
||||
@ -146,13 +149,12 @@ int ff_mjpeg_decode_dqt(MJpegDecodeContext *s)
|
||||
}
|
||||
|
||||
// XXX FIXME finetune, and perhaps add dc too
|
||||
s->qscale[index]= FFMAX(
|
||||
s->quant_matrixes[index][s->scantable.permutated[1]],
|
||||
s->qscale[index] = FFMAX(s->quant_matrixes[index][s->scantable.permutated[1]],
|
||||
s->quant_matrixes[index][s->scantable.permutated[8]]) >> 1;
|
||||
av_log(s->avctx, AV_LOG_DEBUG, "qscale[%d]: %d\n", index, s->qscale[index]);
|
||||
av_log(s->avctx, AV_LOG_DEBUG, "qscale[%d]: %d\n",
|
||||
index, s->qscale[index]);
|
||||
len -= 65;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
@ -196,17 +198,17 @@ int ff_mjpeg_decode_dht(MJpegDecodeContext *s)
|
||||
free_vlc(&s->vlcs[class][index]);
|
||||
av_log(s->avctx, AV_LOG_DEBUG, "class=%d index=%d nb_codes=%d\n",
|
||||
class, index, code_max + 1);
|
||||
if(build_vlc(&s->vlcs[class][index], bits_table, val_table, code_max + 1, 0, class > 0) < 0){
|
||||
if (build_vlc(&s->vlcs[class][index], bits_table, val_table,
|
||||
code_max + 1, 0, class > 0) < 0)
|
||||
return -1;
|
||||
}
|
||||
|
||||
if (class > 0) {
|
||||
free_vlc(&s->vlcs[2][index]);
|
||||
if(build_vlc(&s->vlcs[2][index], bits_table, val_table, code_max + 1, 0, 0) < 0){
|
||||
if (build_vlc(&s->vlcs[2][index], bits_table, val_table,
|
||||
code_max + 1, 0, 0) < 0)
|
||||
return -1;
|
||||
}
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
@ -218,8 +220,10 @@ int ff_mjpeg_decode_sof(MJpegDecodeContext *s)
|
||||
len = get_bits(&s->gb, 16);
|
||||
s->bits = get_bits(&s->gb, 8);
|
||||
|
||||
if(s->pegasus_rct) s->bits=9;
|
||||
if(s->bits==9 && !s->pegasus_rct) s->rct=1; //FIXME ugly
|
||||
if (s->pegasus_rct)
|
||||
s->bits = 9;
|
||||
if (s->bits == 9 && !s->pegasus_rct)
|
||||
s->rct = 1; // FIXME ugly
|
||||
|
||||
if (s->bits != 8 && !s->lossless) {
|
||||
av_log(s->avctx, AV_LOG_ERROR, "only 8 bits/component accepted\n");
|
||||
@ -242,7 +246,8 @@ int ff_mjpeg_decode_sof(MJpegDecodeContext *s)
|
||||
nb_components > MAX_COMPONENTS)
|
||||
return -1;
|
||||
if (s->ls && !(s->bits <= 8 || nb_components == 1)) {
|
||||
av_log(s->avctx, AV_LOG_ERROR, "only <= 8 bits/component or 16-bit gray accepted for JPEG-LS\n");
|
||||
av_log(s->avctx, AV_LOG_ERROR,
|
||||
"only <= 8 bits/component or 16-bit gray accepted for JPEG-LS\n");
|
||||
return -1;
|
||||
}
|
||||
s->nb_components = nb_components;
|
||||
@ -261,16 +266,19 @@ int ff_mjpeg_decode_sof(MJpegDecodeContext *s)
|
||||
s->quant_index[i] = get_bits(&s->gb, 8);
|
||||
if (s->quant_index[i] >= 4)
|
||||
return -1;
|
||||
av_log(s->avctx, AV_LOG_DEBUG, "component %d %d:%d id: %d quant:%d\n", i, s->h_count[i],
|
||||
s->v_count[i], s->component_id[i], s->quant_index[i]);
|
||||
av_log(s->avctx, AV_LOG_DEBUG, "component %d %d:%d id: %d quant:%d\n",
|
||||
i, s->h_count[i], s->v_count[i],
|
||||
s->component_id[i], s->quant_index[i]);
|
||||
}
|
||||
|
||||
if (s->ls && (s->h_max > 1 || s->v_max > 1)) {
|
||||
av_log(s->avctx, AV_LOG_ERROR, "Subsampling in JPEG-LS is not supported.\n");
|
||||
av_log(s->avctx, AV_LOG_ERROR,
|
||||
"Subsampling in JPEG-LS is not supported.\n");
|
||||
return -1;
|
||||
}
|
||||
|
||||
if(s->v_max==1 && s->h_max==1 && s->lossless==1) s->rgb=1;
|
||||
if (s->v_max == 1 && s->h_max == 1 && s->lossless == 1)
|
||||
s->rgb = 1;
|
||||
|
||||
/* if different size, realloc/alloc picture */
|
||||
/* XXX: also check h_count and v_count */
|
||||
@ -295,7 +303,6 @@ int ff_mjpeg_decode_sof(MJpegDecodeContext *s)
|
||||
avcodec_set_dimensions(s->avctx, width, height);
|
||||
|
||||
s->qscale_table = av_mallocz((s->width + 15) / 16);
|
||||
|
||||
s->first_picture = 0;
|
||||
}
|
||||
|
||||
@ -308,7 +315,8 @@ int ff_mjpeg_decode_sof(MJpegDecodeContext *s)
|
||||
(s->h_count[2] << 12) | (s->v_count[2] << 8) |
|
||||
(s->h_count[3] << 4) | s->v_count[3];
|
||||
av_log(s->avctx, AV_LOG_DEBUG, "pix fmt id %x\n", pix_fmt_id);
|
||||
//NOTE we do not allocate pictures large enough for the possible padding of h/v_count being 4
|
||||
/* NOTE we do not allocate pictures large enough for the possible
|
||||
* padding of h/v_count being 4 */
|
||||
if (!(pix_fmt_id & 0xD0D0D0D0))
|
||||
pix_fmt_id -= (pix_fmt_id & 0xF0F0F0F0) >> 1;
|
||||
if (!(pix_fmt_id & 0x0D0D0D0D))
|
||||
@ -316,9 +324,9 @@ int ff_mjpeg_decode_sof(MJpegDecodeContext *s)
|
||||
|
||||
switch (pix_fmt_id) {
|
||||
case 0x11111100:
|
||||
if(s->rgb){
|
||||
if (s->rgb)
|
||||
s->avctx->pix_fmt = PIX_FMT_BGRA;
|
||||
}else
|
||||
else
|
||||
s->avctx->pix_fmt = s->cs_itu601 ? PIX_FMT_YUV444P : PIX_FMT_YUVJ444P;
|
||||
assert(s->nb_components == 3);
|
||||
break;
|
||||
@ -358,16 +366,15 @@ int ff_mjpeg_decode_sof(MJpegDecodeContext *s)
|
||||
s->picture_ptr->key_frame = 1;
|
||||
s->got_picture = 1;
|
||||
|
||||
for(i=0; i<3; i++){
|
||||
for (i = 0; i < 3; i++)
|
||||
s->linesize[i] = s->picture_ptr->linesize[i] << s->interlaced;
|
||||
}
|
||||
|
||||
// printf("%d %d %d %d %d %d\n", s->width, s->height, s->linesize[0], s->linesize[1], s->interlaced, s->avctx->height);
|
||||
// printf("%d %d %d %d %d %d\n",
|
||||
// s->width, s->height, s->linesize[0], s->linesize[1],
|
||||
// s->interlaced, s->avctx->height);
|
||||
|
||||
if (len != (8 + (3 * nb_components)))
|
||||
{
|
||||
av_log(s->avctx, AV_LOG_DEBUG, "decode_sof0: error, len(%d) mismatch\n", len);
|
||||
}
|
||||
|
||||
/* totally blank picture as progressive JPEG will only add details to it */
|
||||
if (s->progressive) {
|
||||
@ -390,10 +397,10 @@ static inline int mjpeg_decode_dc(MJpegDecodeContext *s, int dc_index)
|
||||
{
|
||||
int code;
|
||||
code = get_vlc2(&s->gb, s->vlcs[0][dc_index].table, 9, 2);
|
||||
if (code < 0)
|
||||
{
|
||||
av_log(s->avctx, AV_LOG_WARNING, "mjpeg_decode_dc: bad vlc: %d:%d (%p)\n", 0, dc_index,
|
||||
&s->vlcs[0][dc_index]);
|
||||
if (code < 0) {
|
||||
av_log(s->avctx, AV_LOG_WARNING,
|
||||
"mjpeg_decode_dc: bad vlc: %d:%d (%p)\n",
|
||||
0, dc_index, &s->vlcs[0][dc_index]);
|
||||
return 0xffff;
|
||||
}
|
||||
|
||||
@ -404,8 +411,8 @@ static inline int mjpeg_decode_dc(MJpegDecodeContext *s, int dc_index)
|
||||
}
|
||||
|
||||
/* decode block and dequantize */
|
||||
static int decode_block(MJpegDecodeContext *s, DCTELEM *block,
|
||||
int component, int dc_index, int ac_index, int16_t *quant_matrix)
|
||||
static int decode_block(MJpegDecodeContext *s, DCTELEM *block, int component,
|
||||
int dc_index, int ac_index, int16_t *quant_matrix)
|
||||
{
|
||||
int code, i, j, level, val;
|
||||
|
||||
@ -428,9 +435,9 @@ static int decode_block(MJpegDecodeContext *s, DCTELEM *block,
|
||||
i += ((unsigned)code) >> 4;
|
||||
code &= 0xf;
|
||||
if (code) {
|
||||
if(code > MIN_CACHE_BITS - 16){
|
||||
if (code > MIN_CACHE_BITS - 16)
|
||||
UPDATE_CACHE(re, &s->gb);
|
||||
}
|
||||
|
||||
{
|
||||
int cache = GET_CACHE(re, &s->gb);
|
||||
int sign = (~cache) >> 31;
|
||||
@ -452,8 +459,9 @@ static int decode_block(MJpegDecodeContext *s, DCTELEM *block,
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int decode_dc_progressive(MJpegDecodeContext *s, DCTELEM *block, int component,
|
||||
int dc_index, int16_t *quant_matrix, int Al)
|
||||
static int decode_dc_progressive(MJpegDecodeContext *s, DCTELEM *block,
|
||||
int component, int dc_index,
|
||||
int16_t *quant_matrix, int Al)
|
||||
{
|
||||
int val;
|
||||
s->dsp.clear_block(block);
|
||||
@ -469,8 +477,9 @@ static int decode_dc_progressive(MJpegDecodeContext *s, DCTELEM *block, int comp
|
||||
}
|
||||
|
||||
/* decode block and dequantize - progressive JPEG version */
|
||||
static int decode_block_progressive(MJpegDecodeContext *s, DCTELEM *block, uint8_t *last_nnz,
|
||||
int ac_index, int16_t *quant_matrix,
|
||||
static int decode_block_progressive(MJpegDecodeContext *s, DCTELEM *block,
|
||||
uint8_t *last_nnz, int ac_index,
|
||||
int16_t *quant_matrix,
|
||||
int ss, int se, int Al, int *EOBRUN)
|
||||
{
|
||||
int code, i, j, level, val, run;
|
||||
@ -479,7 +488,9 @@ static int decode_block_progressive(MJpegDecodeContext *s, DCTELEM *block, uint8
|
||||
(*EOBRUN)--;
|
||||
return 0;
|
||||
}
|
||||
{OPEN_READER(re, &s->gb);
|
||||
|
||||
{
|
||||
OPEN_READER(re, &s->gb);
|
||||
for (i = ss; ; i++) {
|
||||
UPDATE_CACHE(re, &s->gb);
|
||||
GET_VLC(code, re, &s->gb, s->vlcs[2][ac_index].table, 9, 2);
|
||||
@ -488,9 +499,9 @@ static int decode_block_progressive(MJpegDecodeContext *s, DCTELEM *block, uint8
|
||||
code &= 0xF;
|
||||
if (code) {
|
||||
i += run;
|
||||
if(code > MIN_CACHE_BITS - 16){
|
||||
if (code > MIN_CACHE_BITS - 16)
|
||||
UPDATE_CACHE(re, &s->gb);
|
||||
}
|
||||
|
||||
{
|
||||
int cache = GET_CACHE(re, &s->gb);
|
||||
int sign = (~cache) >> 31;
|
||||
@ -529,16 +540,20 @@ static int decode_block_progressive(MJpegDecodeContext *s, DCTELEM *block, uint8
|
||||
}
|
||||
}
|
||||
}
|
||||
CLOSE_READER(re, &s->gb);}
|
||||
CLOSE_READER(re, &s->gb);
|
||||
}
|
||||
|
||||
if (i > *last_nnz)
|
||||
*last_nnz = i;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
#define REFINE_BIT(j) { \
|
||||
UPDATE_CACHE(re, &s->gb); \
|
||||
sign = block[j] >> 15; \
|
||||
block[j] += SHOW_UBITS(re, &s->gb, 1) * ((quant_matrix[j]^sign)-sign) << Al;\
|
||||
block[j] += SHOW_UBITS(re, &s->gb, 1) * \
|
||||
((quant_matrix[j] ^ sign) - sign) << Al; \
|
||||
LAST_SKIP_BITS(re, &s->gb, 1); \
|
||||
}
|
||||
|
||||
@ -560,7 +575,8 @@ for(;;i++) {\
|
||||
}
|
||||
|
||||
/* decode block and dequantize - progressive JPEG refinement pass */
|
||||
static int decode_block_refinement(MJpegDecodeContext *s, DCTELEM *block, uint8_t *last_nnz,
|
||||
static int decode_block_refinement(MJpegDecodeContext *s, DCTELEM *block,
|
||||
uint8_t *last_nnz,
|
||||
int ac_index, int16_t *quant_matrix,
|
||||
int ss, int se, int Al, int *EOBRUN)
|
||||
{
|
||||
@ -568,9 +584,9 @@ static int decode_block_refinement(MJpegDecodeContext *s, DCTELEM *block, uint8_
|
||||
int last = FFMIN(se, *last_nnz);
|
||||
|
||||
OPEN_READER(re, &s->gb);
|
||||
if(*EOBRUN)
|
||||
if (*EOBRUN) {
|
||||
(*EOBRUN)--;
|
||||
else {
|
||||
} else {
|
||||
for (; ; i++) {
|
||||
UPDATE_CACHE(re, &s->gb);
|
||||
GET_VLC(code, re, &s->gb, s->vlcs[2][ac_index].table, 9, 2);
|
||||
@ -624,19 +640,22 @@ static int decode_block_refinement(MJpegDecodeContext *s, DCTELEM *block, uint8_
|
||||
#undef REFINE_BIT
|
||||
#undef ZERO_RUN
|
||||
|
||||
static int ljpeg_decode_rgb_scan(MJpegDecodeContext *s, int predictor, int point_transform){
|
||||
static int ljpeg_decode_rgb_scan(MJpegDecodeContext *s, int predictor,
|
||||
int point_transform)
|
||||
{
|
||||
int i, mb_x, mb_y;
|
||||
uint16_t (*buffer)[4];
|
||||
int left[3], top[3], topleft[3];
|
||||
const int linesize = s->linesize[0];
|
||||
const int mask = (1 << s->bits) - 1;
|
||||
|
||||
av_fast_malloc(&s->ljpeg_buffer, &s->ljpeg_buffer_size, (unsigned)s->mb_width * 4 * sizeof(s->ljpeg_buffer[0][0]));
|
||||
av_fast_malloc(&s->ljpeg_buffer, &s->ljpeg_buffer_size,
|
||||
(unsigned)s->mb_width * 4 * sizeof(s->ljpeg_buffer[0][0]));
|
||||
buffer = s->ljpeg_buffer;
|
||||
|
||||
for(i=0; i<3; i++){
|
||||
for (i = 0; i < 3; i++)
|
||||
buffer[0][i] = 1 << (s->bits + point_transform - 1);
|
||||
}
|
||||
|
||||
for (mb_y = 0; mb_y < s->mb_height; mb_y++) {
|
||||
const int modified_predictor = mb_y ? predictor : 1;
|
||||
uint8_t *ptr = s->picture_ptr->data[0] + (linesize * mb_y);
|
||||
@ -644,9 +663,9 @@ static int ljpeg_decode_rgb_scan(MJpegDecodeContext *s, int predictor, int point
|
||||
if (s->interlaced && s->bottom_field)
|
||||
ptr += linesize >> 1;
|
||||
|
||||
for(i=0; i<3; i++){
|
||||
for (i = 0; i < 3; i++)
|
||||
top[i] = left[i] = topleft[i] = buffer[0][i];
|
||||
}
|
||||
|
||||
for (mb_x = 0; mb_x < s->mb_width; mb_x++) {
|
||||
if (s->restart_interval && !s->restart_count)
|
||||
s->restart_count = s->restart_interval;
|
||||
@ -659,8 +678,8 @@ static int ljpeg_decode_rgb_scan(MJpegDecodeContext *s, int predictor, int point
|
||||
|
||||
PREDICT(pred, topleft[i], top[i], left[i], modified_predictor);
|
||||
|
||||
left[i]=
|
||||
buffer[mb_x][i]= mask & (pred + (mjpeg_decode_dc(s, s->dc_index[i]) << point_transform));
|
||||
left[i] = buffer[mb_x][i] =
|
||||
mask & (pred + (mjpeg_decode_dc(s, s->dc_index[i]) << point_transform));
|
||||
}
|
||||
|
||||
if (s->restart_interval && !--s->restart_count) {
|
||||
@ -692,7 +711,9 @@ static int ljpeg_decode_rgb_scan(MJpegDecodeContext *s, int predictor, int point
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int ljpeg_decode_yuv_scan(MJpegDecodeContext *s, int predictor, int point_transform){
|
||||
static int ljpeg_decode_yuv_scan(MJpegDecodeContext *s, int predictor,
|
||||
int point_transform)
|
||||
{
|
||||
int i, mb_x, mb_y;
|
||||
const int nb_components = 3;
|
||||
|
||||
@ -715,20 +736,21 @@ static int ljpeg_decode_yuv_scan(MJpegDecodeContext *s, int predictor, int point
|
||||
|
||||
for (j = 0; j < n; j++) {
|
||||
int pred;
|
||||
|
||||
ptr = s->picture_ptr->data[c] + (linesize * (v * mb_y + y)) + (h * mb_x + x); //FIXME optimize this crap
|
||||
// FIXME optimize this crap
|
||||
ptr = s->picture_ptr->data[c] +
|
||||
(linesize * (v * mb_y + y)) +
|
||||
(h * mb_x + x);
|
||||
if (y == 0 && mb_y == 0) {
|
||||
if(x==0 && mb_x==0){
|
||||
if (x == 0 && mb_x == 0)
|
||||
pred = 128 << point_transform;
|
||||
}else{
|
||||
else
|
||||
pred = ptr[-1];
|
||||
}
|
||||
} else {
|
||||
if(x==0 && mb_x==0){
|
||||
if (x == 0 && mb_x == 0)
|
||||
pred = ptr[-linesize];
|
||||
}else{
|
||||
PREDICT(pred, ptr[-linesize-1], ptr[-linesize], ptr[-1], predictor);
|
||||
}
|
||||
else
|
||||
PREDICT(pred, ptr[-linesize - 1],
|
||||
ptr[-linesize], ptr[-1], predictor);
|
||||
}
|
||||
|
||||
if (s->interlaced && s->bottom_field)
|
||||
@ -756,8 +778,12 @@ static int ljpeg_decode_yuv_scan(MJpegDecodeContext *s, int predictor, int point
|
||||
for (j = 0; j < n; j++) {
|
||||
int pred;
|
||||
|
||||
ptr = s->picture_ptr->data[c] + (linesize * (v * mb_y + y)) + (h * mb_x + x); //FIXME optimize this crap
|
||||
PREDICT(pred, ptr[-linesize-1], ptr[-linesize], ptr[-1], predictor);
|
||||
// FIXME optimize this crap
|
||||
ptr = s->picture_ptr->data[c] +
|
||||
(linesize * (v * mb_y + y)) +
|
||||
(h * mb_x + x);
|
||||
PREDICT(pred, ptr[-linesize - 1],
|
||||
ptr[-linesize], ptr[-1], predictor);
|
||||
*ptr = pred + (mjpeg_decode_dc(s, s->dc_index[i]) << point_transform);
|
||||
if (++x == h) {
|
||||
x = 0;
|
||||
@ -790,22 +816,25 @@ static av_always_inline void mjpeg_copy_block(uint8_t *dst, const uint8_t *src,
|
||||
}
|
||||
}
|
||||
|
||||
static int mjpeg_decode_scan(MJpegDecodeContext *s, int nb_components, int Ah, int Al,
|
||||
const uint8_t *mb_bitmask, const AVFrame *reference){
|
||||
static int mjpeg_decode_scan(MJpegDecodeContext *s, int nb_components, int Ah,
|
||||
int Al, const uint8_t *mb_bitmask,
|
||||
const AVFrame *reference)
|
||||
{
|
||||
int i, mb_x, mb_y;
|
||||
uint8_t *data[MAX_COMPONENTS];
|
||||
const uint8_t *reference_data[MAX_COMPONENTS];
|
||||
int linesize[MAX_COMPONENTS];
|
||||
GetBitContext mb_bitmask_gb;
|
||||
|
||||
if (mb_bitmask) {
|
||||
if (mb_bitmask)
|
||||
init_get_bits(&mb_bitmask_gb, mb_bitmask, s->mb_width * s->mb_height);
|
||||
}
|
||||
|
||||
if (s->flipped && s->avctx->flags & CODEC_FLAG_EMU_EDGE) {
|
||||
av_log(s->avctx, AV_LOG_ERROR, "Can not flip image with CODEC_FLAG_EMU_EDGE set!\n");
|
||||
av_log(s->avctx, AV_LOG_ERROR,
|
||||
"Can not flip image with CODEC_FLAG_EMU_EDGE set!\n");
|
||||
s->flipped = 0;
|
||||
}
|
||||
|
||||
for (i = 0; i < nb_components; i++) {
|
||||
int c = s->comp_index[i];
|
||||
data[c] = s->picture_ptr->data[c];
|
||||
@ -814,7 +843,8 @@ static int mjpeg_decode_scan(MJpegDecodeContext *s, int nb_components, int Ah, i
|
||||
s->coefs_finished[c] |= 1;
|
||||
if (s->flipped) {
|
||||
// picture should be flipped upside-down for this codec
|
||||
int offset = (linesize[c] * (s->v_scount[i] * (8 * s->mb_height -((s->height/s->v_max)&7)) - 1 ));
|
||||
int offset = (linesize[c] * (s->v_scount[i] *
|
||||
(8 * s->mb_height - ((s->height / s->v_max) & 7)) - 1));
|
||||
data[c] += offset;
|
||||
reference_data[c] += offset;
|
||||
linesize[c] *= -1;
|
||||
@ -829,7 +859,8 @@ static int mjpeg_decode_scan(MJpegDecodeContext *s, int nb_components, int Ah, i
|
||||
s->restart_count = s->restart_interval;
|
||||
|
||||
if (get_bits_count(&s->gb)>s->gb.size_in_bits) {
|
||||
av_log(s->avctx, AV_LOG_ERROR, "overread %d\n", get_bits_count(&s->gb) - s->gb.size_in_bits);
|
||||
av_log(s->avctx, AV_LOG_ERROR, "overread %d\n",
|
||||
get_bits_count(&s->gb) - s->gb.size_in_bits);
|
||||
return -1;
|
||||
}
|
||||
for (i = 0; i < nb_components; i++) {
|
||||
@ -850,30 +881,40 @@ static int mjpeg_decode_scan(MJpegDecodeContext *s, int nb_components, int Ah, i
|
||||
block_offset += linesize[c] >> 1;
|
||||
ptr = data[c] + block_offset;
|
||||
if (!s->progressive) {
|
||||
if (copy_mb) {
|
||||
mjpeg_copy_block(ptr, reference_data[c] + block_offset, linesize[c], s->avctx->lowres);
|
||||
} else {
|
||||
if (copy_mb)
|
||||
mjpeg_copy_block(ptr, reference_data[c] + block_offset,
|
||||
linesize[c], s->avctx->lowres);
|
||||
else {
|
||||
s->dsp.clear_block(s->block);
|
||||
if (decode_block(s, s->block, i,
|
||||
s->dc_index[i], s->ac_index[i],
|
||||
s->quant_matrixes[s->quant_index[c]]) < 0) {
|
||||
av_log(s->avctx, AV_LOG_ERROR, "error y=%d x=%d\n", mb_y, mb_x);
|
||||
av_log(s->avctx, AV_LOG_ERROR,
|
||||
"error y=%d x=%d\n", mb_y, mb_x);
|
||||
return -1;
|
||||
}
|
||||
s->dsp.idct_put(ptr, linesize[c], s->block);
|
||||
}
|
||||
} else {
|
||||
int block_idx = s->block_stride[c] * (v * mb_y + y) + (h * mb_x + x);
|
||||
int block_idx = s->block_stride[c] * (v * mb_y + y) +
|
||||
(h * mb_x + x);
|
||||
DCTELEM *block = s->blocks[c][block_idx];
|
||||
if (Ah)
|
||||
block[0] += get_bits1(&s->gb) * s->quant_matrixes[ s->quant_index[c] ][0] << Al;
|
||||
else if(decode_dc_progressive(s, block, i, s->dc_index[i], s->quant_matrixes[ s->quant_index[c] ], Al) < 0) {
|
||||
av_log(s->avctx, AV_LOG_ERROR, "error y=%d x=%d\n", mb_y, mb_x);
|
||||
block[0] += get_bits1(&s->gb) *
|
||||
s->quant_matrixes[s->quant_index[c]][0] << Al;
|
||||
else if (decode_dc_progressive(s, block, i, s->dc_index[i],
|
||||
s->quant_matrixes[s->quant_index[c]],
|
||||
Al) < 0) {
|
||||
av_log(s->avctx, AV_LOG_ERROR,
|
||||
"error y=%d x=%d\n", mb_y, mb_x);
|
||||
return -1;
|
||||
}
|
||||
}
|
||||
// av_log(s->avctx, AV_LOG_DEBUG, "mb: %d %d processed\n", mb_y, mb_x);
|
||||
//av_log(NULL, AV_LOG_DEBUG, "%d %d %d %d %d %d %d %d \n", mb_x, mb_y, x, y, c, s->bottom_field, (v * mb_y + y) * 8, (h * mb_x + x) * 8);
|
||||
// av_log(s->avctx, AV_LOG_DEBUG, "mb: %d %d processed\n",
|
||||
// mb_y, mb_x);
|
||||
// av_log(NULL, AV_LOG_DEBUG, "%d %d %d %d %d %d %d %d \n",
|
||||
// mb_x, mb_y, x, y, c, s->bottom_field,
|
||||
// (v * mb_y + y) * 8, (h * mb_x + x) * 8);
|
||||
if (++x == h) {
|
||||
x = 0;
|
||||
y++;
|
||||
@ -893,18 +934,20 @@ static int mjpeg_decode_scan(MJpegDecodeContext *s, int nb_components, int Ah, i
|
||||
if ((get_bits(&s->gb, 8) & 0xF8) == 0xD0) {
|
||||
for (i = 0; i < nb_components; i++) /* reset dc */
|
||||
s->last_dc[i] = 1024;
|
||||
} else {
|
||||
} else
|
||||
skip_bits_long(&s->gb, pos - get_bits_count(&s->gb));
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int mjpeg_decode_scan_progressive_ac(MJpegDecodeContext *s, int ss, int se, int Ah, int Al,
|
||||
const uint8_t *mb_bitmask, const AVFrame *reference){
|
||||
static int mjpeg_decode_scan_progressive_ac(MJpegDecodeContext *s, int ss,
|
||||
int se, int Ah, int Al,
|
||||
const uint8_t *mb_bitmask,
|
||||
const AVFrame *reference)
|
||||
{
|
||||
int mb_x, mb_y;
|
||||
int EOBRUN = 0;
|
||||
int c = s->comp_index[0];
|
||||
@ -915,9 +958,8 @@ static int mjpeg_decode_scan_progressive_ac(MJpegDecodeContext *s, int ss, int s
|
||||
int16_t *quant_matrix = s->quant_matrixes[s->quant_index[c]];
|
||||
GetBitContext mb_bitmask_gb;
|
||||
|
||||
if (mb_bitmask) {
|
||||
if (mb_bitmask)
|
||||
init_get_bits(&mb_bitmask_gb, mb_bitmask, s->mb_width * s->mb_height);
|
||||
}
|
||||
|
||||
if (!Al) {
|
||||
s->coefs_finished[c] |= (1LL << (se + 1)) - (1LL << ss);
|
||||
@ -948,14 +990,16 @@ static int mjpeg_decode_scan_progressive_ac(MJpegDecodeContext *s, int ss, int s
|
||||
ret = decode_block_progressive(s, *block, last_nnz, s->ac_index[0],
|
||||
quant_matrix, ss, se, Al, &EOBRUN);
|
||||
if (ret < 0) {
|
||||
av_log(s->avctx, AV_LOG_ERROR, "error y=%d x=%d\n", mb_y, mb_x);
|
||||
av_log(s->avctx, AV_LOG_ERROR,
|
||||
"error y=%d x=%d\n", mb_y, mb_x);
|
||||
return -1;
|
||||
}
|
||||
}
|
||||
|
||||
if (last_scan) {
|
||||
if (copy_mb) {
|
||||
mjpeg_copy_block(ptr, reference_data + block_offset, linesize, s->avctx->lowres);
|
||||
mjpeg_copy_block(ptr, reference_data + block_offset,
|
||||
linesize, s->avctx->lowres);
|
||||
} else {
|
||||
s->dsp.idct_put(ptr, linesize, *block);
|
||||
ptr += 8 >> s->avctx->lowres;
|
||||
@ -966,8 +1010,8 @@ static int mjpeg_decode_scan_progressive_ac(MJpegDecodeContext *s, int ss, int s
|
||||
return 0;
|
||||
}
|
||||
|
||||
int ff_mjpeg_decode_sos(MJpegDecodeContext *s,
|
||||
const uint8_t *mb_bitmask, const AVFrame *reference)
|
||||
int ff_mjpeg_decode_sos(MJpegDecodeContext *s, const uint8_t *mb_bitmask,
|
||||
const AVFrame *reference)
|
||||
{
|
||||
int len, nb_components, i, h, v, predictor, point_transform;
|
||||
int index, id;
|
||||
@ -978,11 +1022,11 @@ int ff_mjpeg_decode_sos(MJpegDecodeContext *s,
|
||||
len = get_bits(&s->gb, 16);
|
||||
nb_components = get_bits(&s->gb, 8);
|
||||
if (nb_components == 0 || nb_components > MAX_COMPONENTS) {
|
||||
av_log(s->avctx, AV_LOG_ERROR, "decode_sos: nb_components (%d) unsupported\n", nb_components);
|
||||
av_log(s->avctx, AV_LOG_ERROR,
|
||||
"decode_sos: nb_components (%d) unsupported\n", nb_components);
|
||||
return -1;
|
||||
}
|
||||
if (len != 6+2*nb_components)
|
||||
{
|
||||
if (len != 6 + 2 * nb_components) {
|
||||
av_log(s->avctx, AV_LOG_ERROR, "decode_sos: invalid len (%d)\n", len);
|
||||
return -1;
|
||||
}
|
||||
@ -993,9 +1037,9 @@ int ff_mjpeg_decode_sos(MJpegDecodeContext *s,
|
||||
for (index = 0; index < s->nb_components; index++)
|
||||
if (id == s->component_id[index])
|
||||
break;
|
||||
if (index == s->nb_components)
|
||||
{
|
||||
av_log(s->avctx, AV_LOG_ERROR, "decode_sos: index(%d) out of components\n", index);
|
||||
if (index == s->nb_components) {
|
||||
av_log(s->avctx, AV_LOG_ERROR,
|
||||
"decode_sos: index(%d) out of components\n", index);
|
||||
return -1;
|
||||
}
|
||||
/* Metasoft MJPEG codec has Cb and Cr swapped */
|
||||
@ -1015,7 +1059,8 @@ int ff_mjpeg_decode_sos(MJpegDecodeContext *s,
|
||||
if (s->dc_index[i] < 0 || s->ac_index[i] < 0 ||
|
||||
s->dc_index[i] >= 4 || s->ac_index[i] >= 4)
|
||||
goto out_of_range;
|
||||
if (!s->vlcs[0][s->dc_index[i]].table || !s->vlcs[1][s->ac_index[i]].table)
|
||||
if (!s->vlcs[0][s->dc_index[i]].table ||
|
||||
!s->vlcs[1][s->ac_index[i]].table)
|
||||
goto out_of_range;
|
||||
}
|
||||
|
||||
@ -1042,7 +1087,8 @@ int ff_mjpeg_decode_sos(MJpegDecodeContext *s,
|
||||
}
|
||||
|
||||
if (s->avctx->debug & FF_DEBUG_PICT_INFO)
|
||||
av_log(s->avctx, AV_LOG_DEBUG, "%s %s p:%d >>:%d ilv:%d bits:%d %s\n", s->lossless ? "lossless" : "sequential DCT", s->rgb ? "RGB" : "",
|
||||
av_log(s->avctx, AV_LOG_DEBUG, "%s %s p:%d >>:%d ilv:%d bits:%d %s\n",
|
||||
s->lossless ? "lossless" : "sequential DCT", s->rgb ? "RGB" : "",
|
||||
predictor, point_transform, ilv, s->bits,
|
||||
s->pegasus_rct ? "PRCT" : (s->rct ? "RCT" : ""));
|
||||
|
||||
@ -1069,7 +1115,8 @@ int ff_mjpeg_decode_sos(MJpegDecodeContext *s,
|
||||
}
|
||||
} else {
|
||||
if (s->progressive && predictor) {
|
||||
if(mjpeg_decode_scan_progressive_ac(s, predictor, ilv, prev_shift, point_transform,
|
||||
if (mjpeg_decode_scan_progressive_ac(s, predictor, ilv, prev_shift,
|
||||
point_transform,
|
||||
mb_bitmask, reference) < 0)
|
||||
return -1;
|
||||
} else {
|
||||
@ -1091,7 +1138,8 @@ static int mjpeg_decode_dri(MJpegDecodeContext *s)
|
||||
return -1;
|
||||
s->restart_interval = get_bits(&s->gb, 16);
|
||||
s->restart_count = 0;
|
||||
av_log(s->avctx, AV_LOG_DEBUG, "restart interval: %d\n", s->restart_interval);
|
||||
av_log(s->avctx, AV_LOG_DEBUG, "restart interval: %d\n",
|
||||
s->restart_interval);
|
||||
|
||||
return 0;
|
||||
}
|
||||
@ -1110,15 +1158,13 @@ static int mjpeg_decode_app(MJpegDecodeContext *s)
|
||||
id = av_be2ne32(id);
|
||||
len -= 6;
|
||||
|
||||
if(s->avctx->debug & FF_DEBUG_STARTCODE){
|
||||
if (s->avctx->debug & FF_DEBUG_STARTCODE)
|
||||
av_log(s->avctx, AV_LOG_DEBUG, "APPx %8X\n", id);
|
||||
}
|
||||
|
||||
/* Buggy AVID, it puts EOI only at every 10th frame. */
|
||||
/* Also, this fourcc is used by non-avid files too, it holds some
|
||||
information, but it's always present in AVID-created files. */
|
||||
if (id == AV_RL32("AVI1"))
|
||||
{
|
||||
if (id == AV_RL32("AVI1")) {
|
||||
/* structure:
|
||||
4bytes AVI1
|
||||
1bytes polarity
|
||||
@ -1130,8 +1176,10 @@ static int mjpeg_decode_app(MJpegDecodeContext *s)
|
||||
// if (s->first_picture)
|
||||
// printf("mjpeg: workarounding buggy AVID\n");
|
||||
i = get_bits(&s->gb, 8);
|
||||
if (i==2) s->bottom_field= 1;
|
||||
else if(i==1) s->bottom_field= 0;
|
||||
if (i == 2)
|
||||
s->bottom_field = 1;
|
||||
else if (i == 1)
|
||||
s->bottom_field = 0;
|
||||
#if 0
|
||||
skip_bits(&s->gb, 8);
|
||||
skip_bits(&s->gb, 32);
|
||||
@ -1145,8 +1193,7 @@ static int mjpeg_decode_app(MJpegDecodeContext *s)
|
||||
|
||||
// len -= 2;
|
||||
|
||||
if (id == AV_RL32("JFIF"))
|
||||
{
|
||||
if (id == AV_RL32("JFIF")) {
|
||||
int t_w, t_h, v1, v2;
|
||||
skip_bits(&s->gb, 8); /* the trailing zero-byte */
|
||||
v1 = get_bits(&s->gb, 8);
|
||||
@ -1157,16 +1204,15 @@ static int mjpeg_decode_app(MJpegDecodeContext *s)
|
||||
s->avctx->sample_aspect_ratio.den = get_bits(&s->gb, 16);
|
||||
|
||||
if (s->avctx->debug & FF_DEBUG_PICT_INFO)
|
||||
av_log(s->avctx, AV_LOG_INFO, "mjpeg: JFIF header found (version: %x.%x) SAR=%d/%d\n",
|
||||
av_log(s->avctx, AV_LOG_INFO,
|
||||
"mjpeg: JFIF header found (version: %x.%x) SAR=%d/%d\n",
|
||||
v1, v2,
|
||||
s->avctx->sample_aspect_ratio.num,
|
||||
s->avctx->sample_aspect_ratio.den
|
||||
);
|
||||
s->avctx->sample_aspect_ratio.den);
|
||||
|
||||
t_w = get_bits(&s->gb, 8);
|
||||
t_h = get_bits(&s->gb, 8);
|
||||
if (t_w && t_h)
|
||||
{
|
||||
if (t_w && t_h) {
|
||||
/* skip thumbnail */
|
||||
if (len -10 - (t_w * t_h * 3) > 0)
|
||||
len -= t_w * t_h * 3;
|
||||
@ -1175,8 +1221,7 @@ static int mjpeg_decode_app(MJpegDecodeContext *s)
|
||||
goto out;
|
||||
}
|
||||
|
||||
if (id == AV_RL32("Adob") && (get_bits(&s->gb, 8) == 'e'))
|
||||
{
|
||||
if (id == AV_RL32("Adob") && (get_bits(&s->gb, 8) == 'e')) {
|
||||
if (s->avctx->debug & FF_DEBUG_PICT_INFO)
|
||||
av_log(s->avctx, AV_LOG_INFO, "mjpeg: Adobe header found\n");
|
||||
skip_bits(&s->gb, 16); /* version */
|
||||
@ -1189,7 +1234,8 @@ static int mjpeg_decode_app(MJpegDecodeContext *s)
|
||||
|
||||
if (id == AV_RL32("LJIF")) {
|
||||
if (s->avctx->debug & FF_DEBUG_PICT_INFO)
|
||||
av_log(s->avctx, AV_LOG_INFO, "Pegasus lossless jpeg header found\n");
|
||||
av_log(s->avctx, AV_LOG_INFO,
|
||||
"Pegasus lossless jpeg header found\n");
|
||||
skip_bits(&s->gb, 16); /* version ? */
|
||||
skip_bits(&s->gb, 16); /* unknwon always 0? */
|
||||
skip_bits(&s->gb, 16); /* unknwon always 0? */
|
||||
@ -1211,13 +1257,12 @@ static int mjpeg_decode_app(MJpegDecodeContext *s)
|
||||
}
|
||||
|
||||
/* Apple MJPEG-A */
|
||||
if ((s->start_code == APP1) && (len > (0x28 - 8)))
|
||||
{
|
||||
if ((s->start_code == APP1) && (len > (0x28 - 8))) {
|
||||
id = get_bits_long(&s->gb, 32);
|
||||
id = av_be2ne32(id);
|
||||
len -= 4;
|
||||
if (id == AV_RL32("mjpg")) /* Apple MJPEG-A */
|
||||
{
|
||||
/* Apple MJPEG-A */
|
||||
if (id == AV_RL32("mjpg")) {
|
||||
#if 0
|
||||
skip_bits(&s->gb, 32); /* field size */
|
||||
skip_bits(&s->gb, 32); /* pad field size */
|
||||
@ -1236,7 +1281,8 @@ static int mjpeg_decode_app(MJpegDecodeContext *s)
|
||||
out:
|
||||
/* slow but needed for extreme adobe jpegs */
|
||||
if (len < 0)
|
||||
av_log(s->avctx, AV_LOG_ERROR, "mjpeg: error, decode_app parser read over the end\n");
|
||||
av_log(s->avctx, AV_LOG_ERROR,
|
||||
"mjpeg: error, decode_app parser read over the end\n");
|
||||
while (--len > 0)
|
||||
skip_bits(&s->gb, 8);
|
||||
|
||||
@ -1246,7 +1292,8 @@ out:
|
||||
static int mjpeg_decode_com(MJpegDecodeContext *s)
|
||||
{
|
||||
int len = get_bits(&s->gb, 16);
|
||||
if (len >= 2 && 8*len - 16 + get_bits_count(&s->gb) <= s->gb.size_in_bits) {
|
||||
if (len >= 2 &&
|
||||
8 * len - 16 + get_bits_count(&s->gb) <= s->gb.size_in_bits) {
|
||||
char *cbuf = av_malloc(len - 1);
|
||||
if (cbuf) {
|
||||
int i;
|
||||
@ -1261,19 +1308,15 @@ static int mjpeg_decode_com(MJpegDecodeContext *s)
|
||||
av_log(s->avctx, AV_LOG_INFO, "mjpeg comment: '%s'\n", cbuf);
|
||||
|
||||
/* buggy avid, it puts EOI only at every 10th frame */
|
||||
if (!strcmp(cbuf, "AVID"))
|
||||
{
|
||||
if (!strcmp(cbuf, "AVID")) {
|
||||
s->buggy_avid = 1;
|
||||
// if (s->first_picture)
|
||||
// printf("mjpeg: workarounding buggy AVID\n");
|
||||
}
|
||||
else if(!strcmp(cbuf, "CS=ITU601")){
|
||||
} else if (!strcmp(cbuf, "CS=ITU601"))
|
||||
s->cs_itu601 = 1;
|
||||
}
|
||||
else if ((len > 20 && !strncmp(cbuf, "Intel(R) JPEG Library", 21)) ||
|
||||
(len > 19 && !strncmp(cbuf, "Metasoft MJPEG Codec", 20))){
|
||||
(len > 19 && !strncmp(cbuf, "Metasoft MJPEG Codec", 20)))
|
||||
s->flipped = 1;
|
||||
}
|
||||
|
||||
av_free(cbuf);
|
||||
}
|
||||
@ -1314,33 +1357,30 @@ found:
|
||||
|
||||
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)
|
||||
const uint8_t **unescaped_buf_ptr,
|
||||
int *unescaped_buf_size)
|
||||
{
|
||||
int start_code;
|
||||
start_code = find_marker(buf_ptr, buf_end);
|
||||
|
||||
if ((buf_end - *buf_ptr) > s->buffer_size)
|
||||
{
|
||||
if ((buf_end - *buf_ptr) > s->buffer_size) {
|
||||
av_free(s->buffer);
|
||||
s->buffer_size = buf_end - *buf_ptr;
|
||||
s->buffer = av_malloc(s->buffer_size + FF_INPUT_BUFFER_PADDING_SIZE);
|
||||
av_log(s->avctx, AV_LOG_DEBUG, "buffer too small, expanding to %d bytes\n",
|
||||
s->buffer_size);
|
||||
av_log(s->avctx, AV_LOG_DEBUG,
|
||||
"buffer too small, expanding to %d bytes\n", s->buffer_size);
|
||||
}
|
||||
|
||||
/* unescape buffer of SOS, use special treatment for JPEG-LS */
|
||||
if (start_code == SOS && !s->ls)
|
||||
{
|
||||
if (start_code == SOS && !s->ls) {
|
||||
const uint8_t *src = *buf_ptr;
|
||||
uint8_t *dst = s->buffer;
|
||||
|
||||
while (src<buf_end)
|
||||
{
|
||||
while (src < buf_end) {
|
||||
uint8_t x = *(src++);
|
||||
|
||||
*(dst++) = x;
|
||||
if (s->avctx->codec_id != CODEC_ID_THP)
|
||||
{
|
||||
if (s->avctx->codec_id != CODEC_ID_THP) {
|
||||
if (x == 0xff) {
|
||||
while (src < buf_end && x == 0xff)
|
||||
x = *(src++);
|
||||
@ -1357,8 +1397,7 @@ int ff_mjpeg_find_marker(MJpegDecodeContext *s,
|
||||
|
||||
av_log(s->avctx, AV_LOG_DEBUG, "escaping removed %td bytes\n",
|
||||
(buf_end - *buf_ptr) - (dst - s->buffer));
|
||||
}
|
||||
else if(start_code == SOS && s->ls){
|
||||
} else if (start_code == SOS && s->ls) {
|
||||
const uint8_t *src = *buf_ptr;
|
||||
uint8_t *dst = s->buffer;
|
||||
int bit_count = 0;
|
||||
@ -1380,7 +1419,6 @@ int ff_mjpeg_find_marker(MJpegDecodeContext *s,
|
||||
}
|
||||
}
|
||||
bit_count = t * 8;
|
||||
|
||||
init_put_bits(&pb, dst, t);
|
||||
|
||||
/* unescape bitstream */
|
||||
@ -1397,9 +1435,7 @@ int ff_mjpeg_find_marker(MJpegDecodeContext *s,
|
||||
|
||||
*unescaped_buf_ptr = dst;
|
||||
*unescaped_buf_size = (bit_count + 7) >> 3;
|
||||
}
|
||||
else
|
||||
{
|
||||
} else {
|
||||
*unescaped_buf_ptr = *buf_ptr;
|
||||
*unescaped_buf_size = buf_end - *buf_ptr;
|
||||
}
|
||||
@ -1407,8 +1443,7 @@ int ff_mjpeg_find_marker(MJpegDecodeContext *s,
|
||||
return start_code;
|
||||
}
|
||||
|
||||
int ff_mjpeg_decode_frame(AVCodecContext *avctx,
|
||||
void *data, int *data_size,
|
||||
int ff_mjpeg_decode_frame(AVCodecContext *avctx, void *data, int *data_size,
|
||||
AVPacket *avpkt)
|
||||
{
|
||||
const uint8_t *buf = avpkt->data;
|
||||
@ -1426,36 +1461,35 @@ int ff_mjpeg_decode_frame(AVCodecContext *avctx,
|
||||
while (buf_ptr < buf_end) {
|
||||
/* find start next marker */
|
||||
start_code = ff_mjpeg_find_marker(s, &buf_ptr, buf_end,
|
||||
&unescaped_buf_ptr, &unescaped_buf_size);
|
||||
{
|
||||
&unescaped_buf_ptr,
|
||||
&unescaped_buf_size);
|
||||
/* EOF */
|
||||
if (start_code < 0) {
|
||||
goto the_end;
|
||||
} else {
|
||||
av_log(avctx, AV_LOG_DEBUG, "marker=%x avail_size_in_buf=%td\n", start_code, buf_end - buf_ptr);
|
||||
av_log(avctx, AV_LOG_DEBUG, "marker=%x avail_size_in_buf=%td\n",
|
||||
start_code, buf_end - buf_ptr);
|
||||
|
||||
init_get_bits(&s->gb, unescaped_buf_ptr, unescaped_buf_size * 8);
|
||||
|
||||
s->start_code = start_code;
|
||||
if(s->avctx->debug & FF_DEBUG_STARTCODE){
|
||||
if (s->avctx->debug & FF_DEBUG_STARTCODE)
|
||||
av_log(avctx, AV_LOG_DEBUG, "startcode: %X\n", start_code);
|
||||
}
|
||||
|
||||
/* process markers */
|
||||
if (start_code >= 0xd0 && start_code <= 0xd7) {
|
||||
av_log(avctx, AV_LOG_DEBUG, "restart marker: %d\n", start_code&0x0f);
|
||||
if (start_code >= 0xd0 && start_code <= 0xd7)
|
||||
av_log(avctx, AV_LOG_DEBUG,
|
||||
"restart marker: %d\n", start_code & 0x0f);
|
||||
/* APP fields */
|
||||
} else if (start_code >= APP0 && start_code <= APP15) {
|
||||
else if (start_code >= APP0 && start_code <= APP15)
|
||||
mjpeg_decode_app(s);
|
||||
/* Comment */
|
||||
} else if (start_code == COM){
|
||||
else if (start_code == COM)
|
||||
mjpeg_decode_com(s);
|
||||
}
|
||||
|
||||
switch (start_code) {
|
||||
case SOI:
|
||||
s->restart_interval = 0;
|
||||
|
||||
s->restart_count = 0;
|
||||
/* nothing to do on SOI */
|
||||
break;
|
||||
@ -1507,7 +1541,8 @@ int ff_mjpeg_decode_frame(AVCodecContext *avctx,
|
||||
break;
|
||||
eoi_parser:
|
||||
if (!s->got_picture) {
|
||||
av_log(avctx, AV_LOG_WARNING, "Found EOI before any SOF, ignoring\n");
|
||||
av_log(avctx, AV_LOG_WARNING,
|
||||
"Found EOI before any SOF, ignoring\n");
|
||||
break;
|
||||
}
|
||||
if (s->interlaced) {
|
||||
@ -1520,19 +1555,24 @@ eoi_parser:
|
||||
*data_size = sizeof(AVFrame);
|
||||
|
||||
if (!s->lossless) {
|
||||
picture->quality= FFMAX3(s->qscale[0], s->qscale[1], s->qscale[2]);
|
||||
picture->quality = FFMAX3(s->qscale[0],
|
||||
s->qscale[1],
|
||||
s->qscale[2]);
|
||||
picture->qstride = 0;
|
||||
picture->qscale_table = s->qscale_table;
|
||||
memset(picture->qscale_table, picture->quality, (s->width+15)/16);
|
||||
memset(picture->qscale_table, picture->quality,
|
||||
(s->width + 15) / 16);
|
||||
if (avctx->debug & FF_DEBUG_QP)
|
||||
av_log(avctx, AV_LOG_DEBUG, "QP: %d\n", picture->quality);
|
||||
av_log(avctx, AV_LOG_DEBUG,
|
||||
"QP: %d\n", picture->quality);
|
||||
picture->quality *= FF_QP2LAMBDA;
|
||||
}
|
||||
|
||||
goto the_end;
|
||||
case SOS:
|
||||
if (!s->got_picture) {
|
||||
av_log(avctx, AV_LOG_WARNING, "Can not process SOS before SOF, skipping\n");
|
||||
av_log(avctx, AV_LOG_WARNING,
|
||||
"Can not process SOS before SOF, skipping\n");
|
||||
break;
|
||||
}
|
||||
if (ff_mjpeg_decode_sos(s, NULL, NULL) < 0 &&
|
||||
@ -1556,7 +1596,8 @@ eoi_parser:
|
||||
case SOF14:
|
||||
case SOF15:
|
||||
case JPG:
|
||||
av_log(avctx, AV_LOG_ERROR, "mjpeg: unsupported coding type (%x)\n", start_code);
|
||||
av_log(avctx, AV_LOG_ERROR,
|
||||
"mjpeg: unsupported coding type (%x)\n", start_code);
|
||||
break;
|
||||
// default:
|
||||
// printf("mjpeg: unsupported marker (%x)\n", start_code);
|
||||
@ -1566,11 +1607,11 @@ eoi_parser:
|
||||
not_the_end:
|
||||
/* eof process start code */
|
||||
buf_ptr += (get_bits_count(&s->gb) + 7) / 8;
|
||||
av_log(avctx, AV_LOG_DEBUG, "marker parser used %d bytes (%d bits)\n",
|
||||
av_log(avctx, AV_LOG_DEBUG,
|
||||
"marker parser used %d bytes (%d bits)\n",
|
||||
(get_bits_count(&s->gb) + 7) / 8, get_bits_count(&s->gb));
|
||||
}
|
||||
}
|
||||
}
|
||||
if (s->got_picture) {
|
||||
av_log(avctx, AV_LOG_WARNING, "EOI missing, emulating\n");
|
||||
goto eoi_parser;
|
||||
@ -1578,7 +1619,8 @@ not_the_end:
|
||||
av_log(avctx, AV_LOG_FATAL, "No JPEG data found in image\n");
|
||||
return -1;
|
||||
the_end:
|
||||
av_log(avctx, AV_LOG_DEBUG, "mjpeg decode frame unused %td bytes\n", buf_end - buf_ptr);
|
||||
av_log(avctx, AV_LOG_DEBUG, "mjpeg decode frame unused %td bytes\n",
|
||||
buf_end - buf_ptr);
|
||||
// return buf_end - buf_ptr;
|
||||
return buf_ptr - buf;
|
||||
}
|
||||
@ -1610,7 +1652,8 @@ av_cold int ff_mjpeg_decode_end(AVCodecContext *avctx)
|
||||
#define OFFSET(x) offsetof(MJpegDecodeContext, x)
|
||||
#define VD AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM
|
||||
static const AVOption options[] = {
|
||||
{ "extern_huff", "Use external huffman table.", OFFSET(extern_huff), AV_OPT_TYPE_INT, { 0 }, 0, 1, VD },
|
||||
{ "extern_huff", "Use external huffman table.",
|
||||
OFFSET(extern_huff), AV_OPT_TYPE_INT, { 0 }, 0, 1, VD },
|
||||
{ NULL },
|
||||
};
|
||||
|
||||
|
||||
Loading…
Reference in New Issue
Block a user