/*
* Copyright (C) 2005 Ole André Vadla Ravnås <oleavr@gmail.com>
- * Copyright (C) 2008 Ramiro Polla <ramiro@lisha.ufsc.br>
+ * Copyright (C) 2008 Ramiro Polla
*
- * 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
*/
#include <stdint.h>
#include "avcodec.h"
-#include "bitstream.h"
+#include "get_bits.h"
+#include "bytestream.h"
#include "dsputil.h"
+#include "thread.h"
#define MIMIC_HEADER_SIZE 20
int num_vblocks[3];
int num_hblocks[3];
- uint8_t *swap_buf;
+ void *swap_buf;
int swap_buf_size;
int cur_index;
AVFrame buf_ptrs [16];
AVPicture flipped_ptrs[16];
- DECLARE_ALIGNED_16(DCTELEM, dct_block[64]);
+ DECLARE_ALIGNED(16, DCTELEM, dct_block)[64];
GetBitContext gb;
ScanTable scantable;
DSPContext dsp;
VLC vlc;
+
+ /* Kept in the context so multithreading can have a constant to read from */
+ int next_cur_index;
+ int next_prev_index;
} MimicContext;
static const uint32_t huffcodes[] = {
ctx->prev_index = 0;
ctx->cur_index = 15;
- if(init_vlc(&ctx->vlc, 8, sizeof(huffbits)/sizeof(huffbits[0]),
+ if(init_vlc(&ctx->vlc, 11, FF_ARRAY_ELEMS(huffbits),
huffbits, 1, 1, huffcodes, 4, 4, 0)) {
av_log(avctx, AV_LOG_ERROR, "error initializing vlc table\n");
return -1;
return 0;
}
-const static int8_t vlcdec_lookup[9][64] = {
+static int mimic_decode_update_thread_context(AVCodecContext *avctx, const AVCodecContext *avctx_from)
+{
+ MimicContext *dst = avctx->priv_data, *src = avctx_from->priv_data;
+
+ if (avctx == avctx_from) return 0;
+
+ dst->cur_index = src->next_cur_index;
+ dst->prev_index = src->next_prev_index;
+
+ memcpy(dst->buf_ptrs, src->buf_ptrs, sizeof(src->buf_ptrs));
+ memcpy(dst->flipped_ptrs, src->flipped_ptrs, sizeof(src->flipped_ptrs));
+
+ memset(&dst->buf_ptrs[dst->cur_index], 0, sizeof(AVFrame));
+
+ return 0;
+}
+
+static const int8_t vlcdec_lookup[9][64] = {
{ 0, },
{ -1, 1, },
{ -3, 3, -2, 2, },
DCTELEM *block = ctx->dct_block;
unsigned int pos;
- memset(block, 0, 64 * sizeof(DCTELEM));
+ ctx->dsp.clear_block(block);
block[0] = get_bits(&ctx->gb, 8) << 3;
int value;
int coeff;
- vlc = get_vlc2(&ctx->gb, ctx->vlc.table, ctx->vlc.bits, 4);
+ vlc = get_vlc2(&ctx->gb, ctx->vlc.table, ctx->vlc.bits, 3);
if(!vlc) /* end-of-block code */
return 1;
if(vlc == -1)
value = get_bits(&ctx->gb, num_bits);
- /* FFmpeg's IDCT behaves somewhat different from the original code, so
+ /* Libav's IDCT behaves somewhat different from the original code, so
* a factor of 4 was added to the input */
coeff = vlcdec_lookup[num_bits][value];
static int decode(MimicContext *ctx, int quality, int num_coeffs,
int is_iframe)
{
- int y, x, plane;
+ int y, x, plane, cur_row = 0;
for(plane = 0; plane < 3; plane++) {
const int is_chroma = !!plane;
int index = (ctx->cur_index+backref)&15;
uint8_t *p = ctx->flipped_ptrs[index].data[0];
+ ff_thread_await_progress(&ctx->buf_ptrs[index], cur_row, 0);
if(p) {
p += src -
ctx->flipped_ptrs[ctx->prev_index].data[plane];
}
}
} else {
+ ff_thread_await_progress(&ctx->buf_ptrs[ctx->prev_index], cur_row, 0);
ctx->dsp.put_pixels_tab[1][0](dst, src, stride, 8);
}
src += 8;
}
src += (stride - ctx->num_hblocks[plane])<<3;
dst += (stride - ctx->num_hblocks[plane])<<3;
+
+ ff_thread_report_progress(&ctx->buf_ptrs[ctx->cur_index], cur_row++, 0);
}
}
}
static int mimic_decode_frame(AVCodecContext *avctx, void *data,
- int *data_size, const uint8_t *buf, int buf_size)
+ int *data_size, AVPacket *avpkt)
{
+ const uint8_t *buf = avpkt->data;
+ int buf_size = avpkt->size;
MimicContext *ctx = avctx->priv_data;
int is_pframe;
int width, height;
int quality, num_coeffs;
int swap_buf_size = buf_size - MIMIC_HEADER_SIZE;
- /*
- * Header structure:
- * uint16_t I_dont_remember;
- * uint16_t quality;
- * uint16_t width;
- * uint16_t height;
- * uint32_t some_constant;
- * uint32_t is_pframe;
- * uint32_t num_coeffs;
- */
-
if(buf_size < MIMIC_HEADER_SIZE) {
av_log(avctx, AV_LOG_ERROR, "insufficient data\n");
return -1;
}
- width = AV_RL16(buf + 4);
- height = AV_RL16(buf + 6);
+ buf += 2; /* some constant (always 256) */
+ quality = bytestream_get_le16(&buf);
+ width = bytestream_get_le16(&buf);
+ height = bytestream_get_le16(&buf);
+ buf += 4; /* some constant */
+ is_pframe = bytestream_get_le32(&buf);
+ num_coeffs = bytestream_get_byte(&buf);
+ buf += 3; /* some constant */
if(!ctx->avctx) {
int i;
return -1;
}
- quality = AV_RL16(buf + 2);
- is_pframe = AV_RL32(buf + 12);
- num_coeffs = buf[16];
-
if(is_pframe && !ctx->buf_ptrs[ctx->prev_index].data[0]) {
av_log(avctx, AV_LOG_ERROR, "decoding must start with keyframe\n");
return -1;
}
ctx->buf_ptrs[ctx->cur_index].reference = 1;
- if(avctx->get_buffer(avctx, &ctx->buf_ptrs[ctx->cur_index])) {
+ ctx->buf_ptrs[ctx->cur_index].pict_type = is_pframe ? AV_PICTURE_TYPE_P:AV_PICTURE_TYPE_I;
+ if(ff_thread_get_buffer(avctx, &ctx->buf_ptrs[ctx->cur_index])) {
av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
return -1;
}
+ ctx->next_prev_index = ctx->cur_index;
+ ctx->next_cur_index = (ctx->cur_index - 1) & 15;
+
prepare_avpic(ctx, &ctx->flipped_ptrs[ctx->cur_index],
(AVPicture*) &ctx->buf_ptrs[ctx->cur_index]);
- ctx->swap_buf = av_fast_realloc(ctx->swap_buf, &ctx->swap_buf_size,
+ ff_thread_finish_setup(avctx);
+
+ av_fast_malloc(&ctx->swap_buf, &ctx->swap_buf_size,
swap_buf_size + FF_INPUT_BUFFER_PADDING_SIZE);
if(!ctx->swap_buf)
- return AVERROR_NOMEM;
+ return AVERROR(ENOMEM);
- ctx->dsp.bswap_buf((uint32_t*)ctx->swap_buf,
- (const uint32_t*) (buf + MIMIC_HEADER_SIZE),
+ ctx->dsp.bswap_buf(ctx->swap_buf,
+ (const uint32_t*) buf,
swap_buf_size>>2);
init_get_bits(&ctx->gb, ctx->swap_buf, swap_buf_size << 3);
if(!decode(ctx, quality, num_coeffs, !is_pframe)) {
- avctx->release_buffer(avctx, &ctx->buf_ptrs[ctx->cur_index]);
- return -1;
+ if (avctx->active_thread_type&FF_THREAD_FRAME)
+ ff_thread_report_progress(&ctx->buf_ptrs[ctx->cur_index], INT_MAX, 0);
+ else {
+ ff_thread_release_buffer(avctx, &ctx->buf_ptrs[ctx->cur_index]);
+ return -1;
+ }
}
- ctx->buf_ptrs[ctx->cur_index].pict_type = is_pframe ? FF_P_TYPE:FF_I_TYPE;
*(AVFrame*)data = ctx->buf_ptrs[ctx->cur_index];
*data_size = sizeof(AVFrame);
- ctx->prev_index = ctx->cur_index;
- ctx->cur_index--;
- ctx->cur_index &= 15;
+ ctx->prev_index = ctx->next_prev_index;
+ ctx->cur_index = ctx->next_cur_index;
/* Only release frames that aren't used for backreferences anymore */
if(ctx->buf_ptrs[ctx->cur_index].data[0])
- avctx->release_buffer(avctx, &ctx->buf_ptrs[ctx->cur_index]);
+ ff_thread_release_buffer(avctx, &ctx->buf_ptrs[ctx->cur_index]);
return buf_size;
}
int i;
av_free(ctx->swap_buf);
+
+ if(avctx->is_copy) return 0;
+
for(i = 0; i < 16; i++)
if(ctx->buf_ptrs[i].data[0])
- avctx->release_buffer(avctx, &ctx->buf_ptrs[i]);
+ ff_thread_release_buffer(avctx, &ctx->buf_ptrs[i]);
free_vlc(&ctx->vlc);
return 0;
}
-AVCodec mimic_decoder = {
+AVCodec ff_mimic_decoder = {
"mimic",
- CODEC_TYPE_VIDEO,
+ AVMEDIA_TYPE_VIDEO,
CODEC_ID_MIMIC,
sizeof(MimicContext),
mimic_decode_init,
NULL,
mimic_decode_end,
mimic_decode_frame,
- CODEC_CAP_DR1,
+ CODEC_CAP_DR1 | CODEC_CAP_FRAME_THREADS,
+ .long_name = NULL_IF_CONFIG_SMALL("Mimic"),
+ .update_thread_context = ONLY_IF_THREADS_ENABLED(mimic_decode_update_thread_context)
};