#include "avcodec.h"
#include "blockdsp.h"
#include "copy_block.h"
+#include "hwaccel.h"
#include "idctdsp.h"
#include "internal.h"
#include "jpegtables.h"
#include "mjpeg.h"
#include "mjpegdec.h"
#include "jpeglsdec.h"
+#include "profiles.h"
#include "put_bits.h"
#include "tiff.h"
#include "exif.h"
huff_code, 2, 2, huff_sym, 2, 2, use_static);
}
-static int build_basic_mjpeg_vlc(MJpegDecodeContext *s)
+static int init_default_huffman_tables(MJpegDecodeContext *s)
{
- int ret;
-
- if ((ret = build_vlc(&s->vlcs[0][0], avpriv_mjpeg_bits_dc_luminance,
- avpriv_mjpeg_val_dc, 12, 0, 0)) < 0)
- return ret;
-
- if ((ret = build_vlc(&s->vlcs[0][1], avpriv_mjpeg_bits_dc_chrominance,
- avpriv_mjpeg_val_dc, 12, 0, 0)) < 0)
- return ret;
-
- if ((ret = build_vlc(&s->vlcs[1][0], avpriv_mjpeg_bits_ac_luminance,
- avpriv_mjpeg_val_ac_luminance, 251, 0, 1)) < 0)
- return ret;
-
- if ((ret = build_vlc(&s->vlcs[1][1], avpriv_mjpeg_bits_ac_chrominance,
- avpriv_mjpeg_val_ac_chrominance, 251, 0, 1)) < 0)
- return ret;
-
- if ((ret = build_vlc(&s->vlcs[2][0], avpriv_mjpeg_bits_ac_luminance,
- avpriv_mjpeg_val_ac_luminance, 251, 0, 0)) < 0)
- return ret;
-
- if ((ret = build_vlc(&s->vlcs[2][1], avpriv_mjpeg_bits_ac_chrominance,
- avpriv_mjpeg_val_ac_chrominance, 251, 0, 0)) < 0)
- return ret;
+ static const struct {
+ int class;
+ int index;
+ const uint8_t *bits;
+ const uint8_t *values;
+ int codes;
+ int length;
+ } ht[] = {
+ { 0, 0, avpriv_mjpeg_bits_dc_luminance,
+ avpriv_mjpeg_val_dc, 12, 12 },
+ { 0, 1, avpriv_mjpeg_bits_dc_chrominance,
+ avpriv_mjpeg_val_dc, 12, 12 },
+ { 1, 0, avpriv_mjpeg_bits_ac_luminance,
+ avpriv_mjpeg_val_ac_luminance, 251, 162 },
+ { 1, 1, avpriv_mjpeg_bits_ac_chrominance,
+ avpriv_mjpeg_val_ac_chrominance, 251, 162 },
+ { 2, 0, avpriv_mjpeg_bits_ac_luminance,
+ avpriv_mjpeg_val_ac_luminance, 251, 162 },
+ { 2, 1, avpriv_mjpeg_bits_ac_chrominance,
+ avpriv_mjpeg_val_ac_chrominance, 251, 162 },
+ };
+ int i, ret;
+
+ for (i = 0; i < FF_ARRAY_ELEMS(ht); i++) {
+ ret = build_vlc(&s->vlcs[ht[i].class][ht[i].index],
+ ht[i].bits, ht[i].values, ht[i].codes,
+ 0, ht[i].class == 1);
+ if (ret < 0)
+ return ret;
+ if (ht[i].class < 2) {
+ memcpy(s->raw_huffman_lengths[ht[i].class][ht[i].index],
+ ht[i].bits + 1, 16);
+ memcpy(s->raw_huffman_values[ht[i].class][ht[i].index],
+ ht[i].values, ht[i].length);
+ }
+ }
return 0;
}
s->org_height = avctx->coded_height;
avctx->chroma_sample_location = AVCHROMA_LOC_CENTER;
avctx->colorspace = AVCOL_SPC_BT470BG;
+ s->hwaccel_pix_fmt = s->hwaccel_sw_pix_fmt = AV_PIX_FMT_NONE;
- if ((ret = build_basic_mjpeg_vlc(s)) < 0)
+ if ((ret = init_default_huffman_tables(s)) < 0)
return ret;
if (s->extern_huff) {
if (ff_mjpeg_decode_dht(s)) {
av_log(avctx, AV_LOG_ERROR,
"error using external huffman table, switching back to internal\n");
- build_basic_mjpeg_vlc(s);
+ init_default_huffman_tables(s);
}
}
if (avctx->field_order == AV_FIELD_BB) { /* quicktime icefloe 019 */
code_max + 1, 0, 0)) < 0)
return ret;
}
+
+ for (i = 0; i < 16; i++)
+ s->raw_huffman_lengths[class][index][i] = bits_table[i + 1];
+ for (i = 0; i < 256; i++)
+ s->raw_huffman_values[class][index][i] = val_table[i];
}
return 0;
}
int ff_mjpeg_decode_sof(MJpegDecodeContext *s)
{
- int len, nb_components, i, width, height, bits, ret;
+ int len, nb_components, i, width, height, bits, ret, size_change;
unsigned pix_fmt_id;
int h_count[MAX_COMPONENTS] = { 0 };
int v_count[MAX_COMPONENTS] = { 0 };
memset(s->upscale_h, 0, sizeof(s->upscale_h));
memset(s->upscale_v, 0, sizeof(s->upscale_v));
- /* XXX: verify len field validity */
len = get_bits(&s->gb, 16);
bits = get_bits(&s->gb, 8);
av_log(s->avctx, AV_LOG_DEBUG, "sof0: picture: %dx%d\n", width, height);
if (av_image_check_size(width, height, 0, s->avctx) < 0)
return AVERROR_INVALIDDATA;
+ if (s->buf_size && (width + 7) / 8 * ((height + 7) / 8) > s->buf_size * 4LL)
+ return AVERROR_INVALIDDATA;
nb_components = get_bits(&s->gb, 8);
if (nb_components <= 0 ||
"bits/component or 16-bit gray");
return AVERROR_PATCHWELCOME;
}
+ if (len != 8 + 3 * nb_components) {
+ av_log(s->avctx, AV_LOG_ERROR, "decode_sof0: error, len(%d) mismatch %d components\n", len, nb_components);
+ return AVERROR_INVALIDDATA;
+ }
+
s->nb_components = nb_components;
s->h_max = 1;
s->v_max = 1;
if (width != s->width || height != s->height || bits != s->bits ||
memcmp(s->h_count, h_count, sizeof(h_count)) ||
memcmp(s->v_count, v_count, sizeof(v_count))) {
+ size_change = 1;
s->width = width;
s->height = height;
return ret;
s->first_picture = 0;
+ } else {
+ size_change = 0;
}
if (s->got_picture && s->interlaced && (s->bottom_field == !s->interlace_polarity)) {
if (s->rgb)
s->avctx->pix_fmt = s->bits <= 9 ? AV_PIX_FMT_BGR24 : AV_PIX_FMT_BGR48;
else {
- if (s->component_id[0] == 'Q' && s->component_id[1] == 'F' && s->component_id[2] == 'A') {
+ if ( s->adobe_transform == 0
+ || s->component_id[0] == 'R' - 1 && s->component_id[1] == 'G' - 1 && s->component_id[2] == 'B' - 1) {
s->avctx->pix_fmt = s->bits <= 8 ? AV_PIX_FMT_GBRP : AV_PIX_FMT_GBRP16;
} else {
if (s->bits <= 8) s->avctx->pix_fmt = s->cs_itu601 ? AV_PIX_FMT_YUV444P : AV_PIX_FMT_YUVJ444P;
s->avctx->color_range = s->cs_itu601 ? AVCOL_RANGE_MPEG : AVCOL_RANGE_JPEG;
break;
case 0x22111100:
+ case 0x23111100:
case 0x42111100:
case 0x24111100:
if (s->bits <= 8) s->avctx->pix_fmt = s->cs_itu601 ? AV_PIX_FMT_YUV420P : AV_PIX_FMT_YUVJ420P;
if (s->bits > 8)
goto unk_pixfmt;
s->upscale_v[1] = s->upscale_v[2] = 1;
+ } else if (pix_fmt_id == 0x23111100) {
+ if (s->bits > 8)
+ goto unk_pixfmt;
+ s->upscale_v[1] = s->upscale_v[2] = 2;
}
break;
case 0x41111100:
avpriv_report_missing_feature(s->avctx, "Lowres for weird subsampling");
return AVERROR_PATCHWELCOME;
}
+ if ((AV_RB32(s->upscale_h) || AV_RB32(s->upscale_v)) && s->progressive && s->avctx->pix_fmt == AV_PIX_FMT_GBRP) {
+ avpriv_report_missing_feature(s->avctx, "progressive for weird subsampling");
+ return AVERROR_PATCHWELCOME;
+ }
if (s->ls) {
memset(s->upscale_h, 0, sizeof(s->upscale_h));
memset(s->upscale_v, 0, sizeof(s->upscale_v));
return AVERROR_BUG;
}
+ if (s->avctx->pix_fmt == s->hwaccel_sw_pix_fmt && !size_change) {
+ s->avctx->pix_fmt = s->hwaccel_pix_fmt;
+ } else {
+ enum AVPixelFormat pix_fmts[] = {
+#if CONFIG_MJPEG_NVDEC_HWACCEL
+ AV_PIX_FMT_CUDA,
+#endif
+#if CONFIG_MJPEG_VAAPI_HWACCEL
+ AV_PIX_FMT_VAAPI,
+#endif
+ s->avctx->pix_fmt,
+ AV_PIX_FMT_NONE,
+ };
+ s->hwaccel_pix_fmt = ff_get_format(s->avctx, pix_fmts);
+ if (s->hwaccel_pix_fmt < 0)
+ return AVERROR(EINVAL);
+
+ s->hwaccel_sw_pix_fmt = s->avctx->pix_fmt;
+ s->avctx->pix_fmt = s->hwaccel_pix_fmt;
+ }
+
if (s->avctx->skip_frame == AVDISCARD_ALL) {
s->picture_ptr->pict_type = AV_PICTURE_TYPE_I;
s->picture_ptr->key_frame = 1;
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);
}
if ((s->rgb && !s->lossless && !s->ls) ||
}
memset(s->coefs_finished, 0, sizeof(s->coefs_finished));
}
+
+ if (s->avctx->hwaccel) {
+ s->hwaccel_picture_private =
+ av_mallocz(s->avctx->hwaccel->frame_priv_data_size);
+ if (!s->hwaccel_picture_private)
+ return AVERROR(ENOMEM);
+
+ ret = s->avctx->hwaccel->start_frame(s->avctx, s->raw_image_buffer,
+ s->raw_image_buffer_size);
+ if (ret < 0)
+ return ret;
+ }
+
return 0;
}
av_log(s->avctx, AV_LOG_ERROR, "error dc\n");
return AVERROR_INVALIDDATA;
}
- val = val * quant_matrix[0] + s->last_dc[component];
+ val = val * (unsigned)quant_matrix[0] + s->last_dc[component];
val = av_clip_int16(val);
s->last_dc[component] = val;
block[0] = val;
for (mb_x = 0; mb_x < s->mb_width; mb_x++) {
int modified_predictor = predictor;
+ if (get_bits_left(&s->gb) < 1) {
+ av_log(s->avctx, AV_LOG_ERROR, "bitstream end in rgb_scan\n");
+ return AVERROR_INVALIDDATA;
+ }
+
if (s->restart_interval && !s->restart_count){
s->restart_count = s->restart_interval;
resync_mb_x = mb_x;
return -1;
left[i] = buffer[mb_x][i] =
- mask & (pred + (dc * (1 << point_transform)));
+ mask & (pred + (unsigned)(dc * (1 << point_transform)));
}
if (s->restart_interval && !--s->restart_count) {
|| v * mb_y + y >= s->height) {
// Nothing to do
} else if (bits<=8) {
- ptr = s->picture_ptr->data[c] + (linesize * (v * mb_y + y)) + (h * mb_x + x); //FIXME optimize this crap
- if(y==0 && toprow){
- if(x==0 && leftcol){
- pred= 1 << (bits - 1);
- }else{
- pred= ptr[-1];
- }
- }else{
- if(x==0 && leftcol){
- pred= ptr[-linesize];
+ ptr = s->picture_ptr->data[c] + (linesize * (v * mb_y + y)) + (h * mb_x + x); //FIXME optimize this crap
+ if(y==0 && toprow){
+ if(x==0 && leftcol){
+ pred= 1 << (bits - 1);
+ }else{
+ pred= ptr[-1];
+ }
}else{
- PREDICT(pred, ptr[-linesize-1], ptr[-linesize], ptr[-1], predictor);
+ if(x==0 && leftcol){
+ pred= ptr[-linesize];
+ }else{
+ PREDICT(pred, ptr[-linesize-1], ptr[-linesize], ptr[-1], predictor);
+ }
}
- }
- if (s->interlaced && s->bottom_field)
- ptr += linesize >> 1;
- pred &= mask;
- *ptr= pred + ((unsigned)dc << point_transform);
+ if (s->interlaced && s->bottom_field)
+ ptr += linesize >> 1;
+ pred &= mask;
+ *ptr= pred + ((unsigned)dc << point_transform);
}else{
ptr16 = (uint16_t*)(s->picture_ptr->data[c] + 2*(linesize * (v * mb_y + y)) + 2*(h * mb_x + x)); //FIXME optimize this crap
if(y==0 && toprow){
}
}
- av_assert0(s->picture_ptr->data[0]);
/* XXX: verify len field validity */
len = get_bits(&s->gb, 16);
nb_components = get_bits(&s->gb, 8);
s->h_scount[i] = s->h_count[index];
s->v_scount[i] = s->v_count[index];
- if(nb_components == 3 && s->nb_components == 3 && s->avctx->pix_fmt == AV_PIX_FMT_GBR24P)
- index = (i+2)%3;
- if(nb_components == 1 && s->nb_components == 3 && s->avctx->pix_fmt == AV_PIX_FMT_GBR24P)
+ if((nb_components == 1 || nb_components == 3) && s->nb_components == 3 && s->avctx->pix_fmt == AV_PIX_FMT_GBR24P)
index = (index+2)%3;
s->comp_index[i] = index;
for (i = 0; i < nb_components; i++)
s->last_dc[i] = (4 << s->bits);
- if (s->lossless) {
+ if (s->avctx->hwaccel) {
+ int bytes_to_start = get_bits_count(&s->gb) / 8;
+ av_assert0(bytes_to_start >= 0 &&
+ s->raw_scan_buffer_size >= bytes_to_start);
+
+ ret = s->avctx->hwaccel->decode_slice(s->avctx,
+ s->raw_scan_buffer + bytes_to_start,
+ s->raw_scan_buffer_size - bytes_to_start);
+ if (ret < 0)
+ return ret;
+
+ } else if (s->lossless) {
av_assert0(s->picture_ptr == s->picture);
if (CONFIG_JPEGLS_DECODER && s->ls) {
// for () {
int ret = 0;
int is16bit;
+ s->buf_size = buf_size;
+
av_dict_free(&s->exif_metadata);
av_freep(&s->stereo3d);
s->adobe_transform = -1;
case SOI:
s->restart_interval = 0;
s->restart_count = 0;
+ s->raw_image_buffer = buf_ptr;
+ s->raw_image_buffer_size = buf_end - buf_ptr;
/* nothing to do on SOI */
break;
case DHT:
break;
case SOF0:
case SOF1:
+ if (start_code == SOF0)
+ s->avctx->profile = FF_PROFILE_MJPEG_HUFFMAN_BASELINE_DCT;
+ else
+ s->avctx->profile = FF_PROFILE_MJPEG_HUFFMAN_EXTENDED_SEQUENTIAL_DCT;
s->lossless = 0;
s->ls = 0;
s->progressive = 0;
goto fail;
break;
case SOF2:
+ s->avctx->profile = FF_PROFILE_MJPEG_HUFFMAN_PROGRESSIVE_DCT;
s->lossless = 0;
s->ls = 0;
s->progressive = 1;
goto fail;
break;
case SOF3:
+ s->avctx->profile = FF_PROFILE_MJPEG_HUFFMAN_LOSSLESS;
s->avctx->properties |= FF_CODEC_PROPERTY_LOSSLESS;
s->lossless = 1;
s->ls = 0;
goto fail;
break;
case SOF48:
+ s->avctx->profile = FF_PROFILE_MJPEG_JPEG_LS;
s->avctx->properties |= FF_CODEC_PROPERTY_LOSSLESS;
s->lossless = 1;
s->ls = 1;
break;
case EOI:
eoi_parser:
- if (avctx->skip_frame != AVDISCARD_ALL && s->progressive && s->cur_scan && s->got_picture)
+ if (!avctx->hwaccel && avctx->skip_frame != AVDISCARD_ALL &&
+ s->progressive && s->cur_scan && s->got_picture)
mjpeg_idct_scan_progressive_ac(s);
s->cur_scan = 0;
if (!s->got_picture) {
s->got_picture = 0;
goto the_end_no_picture;
}
+ if (s->avctx->hwaccel) {
+ ret = s->avctx->hwaccel->end_frame(s->avctx);
+ if (ret < 0)
+ return ret;
+
+ av_freep(&s->hwaccel_picture_private);
+ }
if ((ret = av_frame_ref(frame, s->picture_ptr)) < 0)
return ret;
*got_frame = 1;
goto the_end;
case SOS:
+ s->raw_scan_buffer = buf_ptr;
+ s->raw_scan_buffer_size = buf_end - buf_ptr;
+
s->cur_scan++;
if (avctx->skip_frame == AVDISCARD_ALL) {
skip_bits(&s->gb, get_bits_left(&s->gb));
w = AV_CEIL_RSHIFT(w, hshift);
h = AV_CEIL_RSHIFT(h, vshift);
}
- if (s->upscale_v[p])
+ if (s->upscale_v[p] == 1)
h = (h+1)>>1;
av_assert0(w > 0);
for (i = 0; i < h; i++) {
}
dst = &((uint8_t *)s->picture_ptr->data[p])[(h - 1) * s->linesize[p]];
for (i = h - 1; i; i--) {
- uint8_t *src1 = &((uint8_t *)s->picture_ptr->data[p])[i / 2 * s->linesize[p]];
- uint8_t *src2 = &((uint8_t *)s->picture_ptr->data[p])[(i + 1) / 2 * s->linesize[p]];
- if (src1 == src2 || i == h - 1) {
+ uint8_t *src1 = &((uint8_t *)s->picture_ptr->data[p])[i * s->upscale_v[p] / (s->upscale_v[p] + 1) * s->linesize[p]];
+ uint8_t *src2 = &((uint8_t *)s->picture_ptr->data[p])[(i + 1) * s->upscale_v[p] / (s->upscale_v[p] + 1) * s->linesize[p]];
+ if (s->upscale_v[p] != 2 && (src1 == src2 || i == h - 1)) {
memcpy(dst, src1, w);
} else {
for (index = 0; index < w; index++)
reset_icc_profile(s);
+ av_freep(&s->hwaccel_picture_private);
+
return 0;
}
.capabilities = AV_CODEC_CAP_DR1,
.max_lowres = 3,
.priv_class = &mjpegdec_class,
+ .profiles = NULL_IF_CONFIG_SMALL(ff_mjpeg_profiles),
.caps_internal = FF_CODEC_CAP_INIT_THREADSAFE |
FF_CODEC_CAP_SKIP_FRAME_FILL_PARAM,
+ .hw_configs = (const AVCodecHWConfigInternal*[]) {
+#if CONFIG_MJPEG_NVDEC_HWACCEL
+ HWACCEL_NVDEC(mjpeg),
+#endif
+#if CONFIG_MJPEG_VAAPI_HWACCEL
+ HWACCEL_VAAPI(mjpeg),
+#endif
+ NULL
+ },
};
#endif
#if CONFIG_THP_DECODER