* 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
*/
//#define DEBUG
#include <assert.h>
-#include "libavcore/imgutils.h"
+#include "libavutil/imgutils.h"
#include "avcodec.h"
#include "dsputil.h"
#include "mjpeg.h"
{
MJpegDecodeContext *s = avctx->priv_data;
+ if (!s->picture_ptr)
+ s->picture_ptr = &s->picture;
+
s->avctx = avctx;
dsputil_init(&s->dsp, avctx);
ff_init_scantable(s->dsp.idct_permutation, &s->scantable, ff_zigzag_direct);
s->height < ((s->org_height * 3) / 4)) {
s->interlaced = 1;
s->bottom_field = s->interlace_polarity;
- s->picture.interlaced_frame = 1;
- s->picture.top_field_first = !s->interlace_polarity;
+ s->picture_ptr->interlaced_frame = 1;
+ s->picture_ptr->top_field_first = !s->interlace_polarity;
height *= 2;
}
s->avctx->pix_fmt = PIX_FMT_GRAY16;
}
- if(s->picture.data[0])
- s->avctx->release_buffer(s->avctx, &s->picture);
+ if(s->picture_ptr->data[0])
+ s->avctx->release_buffer(s->avctx, s->picture_ptr);
- s->picture.reference= 0;
- if(s->avctx->get_buffer(s->avctx, &s->picture) < 0){
+ if(s->avctx->get_buffer(s->avctx, s->picture_ptr) < 0){
av_log(s->avctx, AV_LOG_ERROR, "get_buffer() failed\n");
return -1;
}
- s->picture.pict_type= FF_I_TYPE;
- s->picture.key_frame= 1;
+ s->picture_ptr->pict_type= AV_PICTURE_TYPE_I;
+ s->picture_ptr->key_frame= 1;
s->got_picture = 1;
for(i=0; i<3; i++){
- s->linesize[i]= s->picture.linesize[i] << s->interlaced;
+ 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);
}
for(mb_y = 0; mb_y < s->mb_height; mb_y++) {
const int modified_predictor= mb_y ? predictor : 1;
- uint8_t *ptr = s->picture.data[0] + (linesize * mb_y);
+ uint8_t *ptr = s->picture_ptr->data[0] + (linesize * mb_y);
if (s->interlaced && s->bottom_field)
ptr += linesize >> 1;
for(j=0; j<n; j++) {
int pred;
- ptr = s->picture.data[c] + (linesize * (v * mb_y + y)) + (h * mb_x + x); //FIXME optimize this crap
+ ptr = s->picture_ptr->data[c] + (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 << point_transform;
for(j=0; j<n; j++) {
int pred;
- ptr = s->picture.data[c] + (linesize * (v * mb_y + y)) + (h * mb_x + x); //FIXME optimize this crap
+ 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);
*ptr= pred + (mjpeg_decode_dc(s, s->dc_index[i]) << point_transform);
if (++x == h) {
return 0;
}
-static int mjpeg_decode_scan(MJpegDecodeContext *s, int nb_components, int Ah, int Al){
+static av_always_inline void mjpeg_copy_block(uint8_t *dst, const uint8_t *src,
+ int linesize, int lowres)
+{
+ switch (lowres) {
+ case 0: copy_block8(dst, src, linesize, linesize, 8);
+ break;
+ case 1: copy_block4(dst, src, linesize, linesize, 4);
+ break;
+ case 2: copy_block2(dst, src, linesize, linesize, 2);
+ break;
+ case 3: *dst = *src;
+ break;
+ }
+}
+
+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) {
+ 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");
}
for(i=0; i < nb_components; i++) {
int c = s->comp_index[i];
- data[c] = s->picture.data[c];
+ data[c] = s->picture_ptr->data[c];
+ reference_data[c] = reference ? reference->data[c] : NULL;
linesize[c]=s->linesize[c];
s->coefs_finished[c] |= 1;
if(s->flipped) {
//picture should be flipped upside-down for this codec
- data[c] += (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;
}
}
for(mb_y = 0; mb_y < s->mb_height; mb_y++) {
for(mb_x = 0; mb_x < s->mb_width; mb_x++) {
+ const int copy_mb = mb_bitmask && !get_bits1(&mb_bitmask_gb);
+
if (s->restart_interval && !s->restart_count)
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);
+ return -1;
+ }
for(i=0;i<nb_components;i++) {
uint8_t *ptr;
int n, h, v, x, y, c, j;
+ int block_offset;
n = s->nb_blocks[i];
c = s->comp_index[i];
h = s->h_scount[i];
x = 0;
y = 0;
for(j=0;j<n;j++) {
- ptr = data[c] +
- (((linesize[c] * (v * mb_y + y) * 8) +
- (h * mb_x + x) * 8) >> s->avctx->lowres);
+ block_offset = (((linesize[c] * (v * mb_y + y) * 8) +
+ (h * mb_x + x) * 8) >> s->avctx->lowres);
+
if(s->interlaced && s->bottom_field)
- ptr += linesize[c] >> 1;
+ 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 {
s->dsp.clear_block(s->block);
if(decode_block(s, s->block, i,
s->dc_index[i], s->ac_index[i],
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);
DCTELEM *block = s->blocks[c][block_idx];
}
}
- if (s->restart_interval && !--s->restart_count) {
+ if (s->restart_interval && show_bits(&s->gb, 8) == 0xFF){ /* skip RSTn */
+ --s->restart_count;
align_get_bits(&s->gb);
- skip_bits(&s->gb, 16); /* skip RSTn */
+ while(show_bits(&s->gb, 8) == 0xFF)
+ skip_bits(&s->gb, 8);
+ skip_bits(&s->gb, 8);
for (i=0; i<nb_components; i++) /* reset dc */
s->last_dc[i] = 1024;
}
return 0;
}
-static int mjpeg_decode_scan_progressive_ac(MJpegDecodeContext *s, int ss, int se, int Ah, int Al){
+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];
- uint8_t* data = s->picture.data[c];
+ uint8_t* data = s->picture_ptr->data[c];
+ const uint8_t *reference_data = reference ? reference->data[c] : NULL;
int linesize = s->linesize[c];
int last_scan = 0;
int16_t *quant_matrix = s->quant_matrixes[ s->quant_index[c] ];
+ GetBitContext mb_bitmask_gb;
+
+ 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);
last_scan = !~s->coefs_finished[c];
}
- if(s->interlaced && s->bottom_field)
- data += linesize >> 1;
+ if(s->interlaced && s->bottom_field) {
+ int offset = linesize >> 1;
+ data += offset;
+ reference_data += offset;
+ }
for(mb_y = 0; mb_y < s->mb_height; mb_y++) {
- uint8_t *ptr = data + (mb_y*linesize*8 >> s->avctx->lowres);
+ int block_offset = (mb_y*linesize*8 >> s->avctx->lowres);
+ uint8_t *ptr = data + block_offset;
int block_idx = mb_y * s->block_stride[c];
DCTELEM (*block)[64] = &s->blocks[c][block_idx];
uint8_t *last_nnz = &s->last_nnz[c][block_idx];
for(mb_x = 0; mb_x < s->mb_width; mb_x++, block++, last_nnz++) {
+ const int copy_mb = mb_bitmask && !get_bits1(&mb_bitmask_gb);
+
+ if (!copy_mb) {
int ret;
if(Ah)
ret = decode_block_refinement(s, *block, last_nnz, s->ac_index[0],
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);
+ } else {
s->dsp.idct_put(ptr, linesize, *block);
ptr += 8 >> s->avctx->lowres;
+ }
}
}
}
return 0;
}
-int ff_mjpeg_decode_sos(MJpegDecodeContext *s)
+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;
}
}else{
if(s->progressive && predictor) {
- if(mjpeg_decode_scan_progressive_ac(s, predictor, ilv, prev_shift, point_transform) < 0)
+ if(mjpeg_decode_scan_progressive_ac(s, predictor, ilv, prev_shift, point_transform,
+ mb_bitmask, reference) < 0)
return -1;
} else {
- if(mjpeg_decode_scan(s, nb_components, prev_shift, point_transform) < 0)
+ if(mjpeg_decode_scan(s, nb_components, prev_shift, point_transform,
+ mb_bitmask, reference) < 0)
return -1;
}
}
return 0;
}
-#if 0
-static int valid_marker_list[] =
-{
- /* 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, a, b, c, d, e, f */
-/* 0 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-/* 1 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-/* 2 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-/* 3 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-/* 4 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-/* 5 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-/* 6 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-/* 7 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-/* 8 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-/* 9 */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-/* a */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-/* b */ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-/* c */ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
-/* d */ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
-/* e */ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
-/* f */ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0,
-}
-#endif
-
/* return the 8 bit start code value and update the search
state. Return -1 if no start code found */
static int find_marker(const uint8_t **pbuf_ptr, const uint8_t *buf_end)
return val;
}
-int ff_mjpeg_decode_frame(AVCodecContext *avctx,
- void *data, int *data_size,
- AVPacket *avpkt)
+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 *buf = avpkt->data;
- int buf_size = avpkt->size;
- MJpegDecodeContext *s = avctx->priv_data;
- const uint8_t *buf_end, *buf_ptr;
int start_code;
- AVFrame *picture = data;
-
- s->got_picture = 0; // picture from previous image can not be reused
- buf_ptr = buf;
- buf_end = buf + buf_size;
- while (buf_ptr < buf_end) {
- /* find start next marker */
- start_code = find_marker(&buf_ptr, buf_end);
- {
- /* 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);
+ 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_size = buf_end - *buf_ptr;
s->buffer = av_malloc(s->buffer_size + FF_INPUT_BUFFER_PADDING_SIZE);
- av_log(avctx, AV_LOG_DEBUG, "buffer too small, expanding to %d bytes\n",
+ 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)
{
- const uint8_t *src = buf_ptr;
+ const uint8_t *src = *buf_ptr;
uint8_t *dst = s->buffer;
while (src<buf_end)
uint8_t x = *(src++);
*(dst++) = x;
- if (avctx->codec_id != CODEC_ID_THP)
+ if (s->avctx->codec_id != CODEC_ID_THP)
{
if (x == 0xff) {
while (src < buf_end && x == 0xff)
}
}
}
- init_get_bits(&s->gb, s->buffer, (dst - s->buffer)*8);
+ *unescaped_buf_ptr = s->buffer;
+ *unescaped_buf_size = dst - s->buffer;
- av_log(avctx, AV_LOG_DEBUG, "escaping removed %td bytes\n",
- (buf_end - buf_ptr) - (dst - s->buffer));
+ 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){
- const uint8_t *src = buf_ptr;
+ const uint8_t *src = *buf_ptr;
uint8_t *dst = s->buffer;
int bit_count = 0;
int t = 0, b = 0;
}
flush_put_bits(&pb);
- init_get_bits(&s->gb, dst, bit_count);
+ *unescaped_buf_ptr = dst;
+ *unescaped_buf_size = (bit_count + 7) >> 3;
}
else
- init_get_bits(&s->gb, buf_ptr, (buf_end - buf_ptr)*8);
+ {
+ *unescaped_buf_ptr = *buf_ptr;
+ *unescaped_buf_size = buf_end - *buf_ptr;
+ }
+
+ return start_code;
+}
+
+int ff_mjpeg_decode_frame(AVCodecContext *avctx,
+ void *data, int *data_size,
+ AVPacket *avpkt)
+{
+ const uint8_t *buf = avpkt->data;
+ int buf_size = avpkt->size;
+ MJpegDecodeContext *s = avctx->priv_data;
+ const uint8_t *buf_end, *buf_ptr;
+ const uint8_t *unescaped_buf_ptr;
+ int unescaped_buf_size;
+ int start_code;
+ AVFrame *picture = data;
+
+ s->got_picture = 0; // picture from previous image can not be reused
+ buf_ptr = buf;
+ buf_end = buf + buf_size;
+ 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);
+ {
+ /* 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);
+
+ init_get_bits(&s->gb, unescaped_buf_ptr, unescaped_buf_size*8);
s->start_code = start_code;
if(s->avctx->debug & FF_DEBUG_STARTCODE){
av_log(avctx, AV_LOG_WARNING, "Found EOI before any SOF, ignoring\n");
break;
}
- {
- if (s->interlaced) {
- s->bottom_field ^= 1;
- /* if not bottom field, do not output image yet */
- if (s->bottom_field == !s->interlace_polarity)
- goto not_the_end;
- }
- *picture = s->picture;
- *data_size = sizeof(AVFrame);
-
- if(!s->lossless){
- 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);
- if(avctx->debug & FF_DEBUG_QP)
- av_log(avctx, AV_LOG_DEBUG, "QP: %d\n", picture->quality);
- picture->quality*= FF_QP2LAMBDA;
- }
-
- goto the_end;
+ if (s->interlaced) {
+ s->bottom_field ^= 1;
+ /* if not bottom field, do not output image yet */
+ if (s->bottom_field == !s->interlace_polarity)
+ goto not_the_end;
}
- break;
+ *picture = *s->picture_ptr;
+ *data_size = sizeof(AVFrame);
+
+ if(!s->lossless){
+ 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);
+ if(avctx->debug & FF_DEBUG_QP)
+ 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");
break;
}
- ff_mjpeg_decode_sos(s);
+ if (ff_mjpeg_decode_sos(s, NULL, NULL) < 0 &&
+ avctx->error_recognition >= FF_ER_EXPLODE)
+ return AVERROR_INVALIDDATA;
/* buggy avid puts EOI every 10-20th frame */
/* if restart period is over process EOI */
if ((s->buggy_avid && !s->interlaced) || s->restart_interval)
MJpegDecodeContext *s = avctx->priv_data;
int i, j;
- if (s->picture.data[0])
- avctx->release_buffer(avctx, &s->picture);
+ if (s->picture_ptr && s->picture_ptr->data[0])
+ avctx->release_buffer(avctx, s->picture_ptr);
av_free(s->buffer);
av_free(s->qscale_table);
}
AVCodec ff_mjpeg_decoder = {
- "mjpeg",
- AVMEDIA_TYPE_VIDEO,
- CODEC_ID_MJPEG,
- sizeof(MJpegDecodeContext),
- ff_mjpeg_decode_init,
- NULL,
- ff_mjpeg_decode_end,
- ff_mjpeg_decode_frame,
- CODEC_CAP_DR1,
- NULL,
- .max_lowres = 4,
+ .name = "mjpeg",
+ .type = AVMEDIA_TYPE_VIDEO,
+ .id = CODEC_ID_MJPEG,
+ .priv_data_size = sizeof(MJpegDecodeContext),
+ .init = ff_mjpeg_decode_init,
+ .close = ff_mjpeg_decode_end,
+ .decode = ff_mjpeg_decode_frame,
+ .capabilities = CODEC_CAP_DR1,
+ .max_lowres = 3,
.long_name = NULL_IF_CONFIG_SMALL("MJPEG (Motion JPEG)"),
};
AVCodec ff_thp_decoder = {
- "thp",
- AVMEDIA_TYPE_VIDEO,
- CODEC_ID_THP,
- sizeof(MJpegDecodeContext),
- ff_mjpeg_decode_init,
- NULL,
- ff_mjpeg_decode_end,
- ff_mjpeg_decode_frame,
- CODEC_CAP_DR1,
- NULL,
+ .name = "thp",
+ .type = AVMEDIA_TYPE_VIDEO,
+ .id = CODEC_ID_THP,
+ .priv_data_size = sizeof(MJpegDecodeContext),
+ .init = ff_mjpeg_decode_init,
+ .close = ff_mjpeg_decode_end,
+ .decode = ff_mjpeg_decode_frame,
+ .capabilities = CODEC_CAP_DR1,
.max_lowres = 3,
.long_name = NULL_IF_CONFIG_SMALL("Nintendo Gamecube THP video"),
};