/*
* DV decoder
* Copyright (c) 2002 Fabrice Bellard.
+ * Copyright (c) 2004 Roman Shaposhnik.
*
* DV encoder
* Copyright (c) 2003 Roman Shaposhnik.
#include "simple_idct.h"
#include "dvdata.h"
-typedef struct DVVideoDecodeContext {
+typedef struct DVVideoContext {
const DVprofile* sys;
AVFrame picture;
+ uint8_t *buf;
uint8_t dv_zigzag[2][64];
- uint8_t dv_idct_shift[2][22][64];
+ uint8_t dv_idct_shift[2][2][22][64];
void (*get_pixels)(DCTELEM *block, const uint8_t *pixels, int line_size);
void (*fdct[2])(DCTELEM *block);
void (*idct_put[2])(uint8_t *dest, int line_size, DCTELEM *block);
-
- GetBitContext gb;
- DCTELEM block[5*6][64] __align8;
-} DVVideoDecodeContext;
+} DVVideoContext;
#define TEX_VLC_BITS 9
#define DV_VLC_MAP_LEV_SIZE 512
#endif
+/* MultiThreading */
+static uint8_t** dv_anchor;
+
/* XXX: also include quantization */
-static RL_VLC_ELEM *dv_rl_vlc[1];
+static RL_VLC_ELEM *dv_rl_vlc;
/* VLC encoding lookup table */
static struct dv_vlc_pair {
uint32_t vlc;
uint8_t size;
} (*dv_vlc_map)[DV_VLC_MAP_LEV_SIZE] = NULL;
-static void dv_build_unquantize_tables(DVVideoDecodeContext *s, uint8_t* perm)
+static void dv_build_unquantize_tables(DVVideoContext *s, uint8_t* perm)
{
int i, q, j;
for(i = 1; i < 64; i++) {
/* 88 table */
j = perm[i];
- s->dv_idct_shift[0][q][j] =
+ s->dv_idct_shift[0][0][q][j] =
dv_quant_shifts[q][dv_88_areas[i]] + 1;
+ s->dv_idct_shift[1][0][q][j] = s->dv_idct_shift[0][0][q][j] + 1;
}
/* 248DCT */
for(i = 1; i < 64; i++) {
/* 248 table */
- s->dv_idct_shift[1][q][i] =
+ s->dv_idct_shift[0][1][q][i] =
dv_quant_shifts[q][dv_248_areas[i]] + 1;
+ s->dv_idct_shift[1][1][q][i] = s->dv_idct_shift[0][1][q][i] + 1;
}
}
}
static int dvvideo_init(AVCodecContext *avctx)
{
- DVVideoDecodeContext *s = avctx->priv_data;
+ DVVideoContext *s = avctx->priv_data;
DSPContext dsp;
static int done=0;
int i, j;
if (!done) {
- int i;
VLC dv_vlc;
+ uint16_t new_dv_vlc_bits[NB_DV_VLC*2];
+ uint8_t new_dv_vlc_len[NB_DV_VLC*2];
+ uint8_t new_dv_vlc_run[NB_DV_VLC*2];
+ int16_t new_dv_vlc_level[NB_DV_VLC*2];
done = 1;
if (!dv_vlc_map)
return -ENOMEM;
+ /* dv_anchor lets each thread know its Id */
+ dv_anchor = av_malloc(12*27*sizeof(void*));
+ if (!dv_anchor) {
+ av_free(dv_vlc_map);
+ return -ENOMEM;
+ }
+ for (i=0; i<12*27; i++)
+ dv_anchor[i] = (void*)(size_t)i;
+
+ /* it's faster to include sign bit in a generic VLC parsing scheme */
+ for (i=0, j=0; i<NB_DV_VLC; i++, j++) {
+ new_dv_vlc_bits[j] = dv_vlc_bits[i];
+ new_dv_vlc_len[j] = dv_vlc_len[i];
+ new_dv_vlc_run[j] = dv_vlc_run[i];
+ new_dv_vlc_level[j] = dv_vlc_level[i];
+
+ if (dv_vlc_level[i]) {
+ new_dv_vlc_bits[j] <<= 1;
+ new_dv_vlc_len[j]++;
+
+ j++;
+ new_dv_vlc_bits[j] = (dv_vlc_bits[i] << 1) | 1;
+ new_dv_vlc_len[j] = dv_vlc_len[i] + 1;
+ new_dv_vlc_run[j] = dv_vlc_run[i];
+ new_dv_vlc_level[j] = -dv_vlc_level[i];
+ }
+ }
+
/* NOTE: as a trick, we use the fact the no codes are unused
to accelerate the parsing of partial codes */
- init_vlc(&dv_vlc, TEX_VLC_BITS, NB_DV_VLC,
- dv_vlc_len, 1, 1, dv_vlc_bits, 2, 2);
+ init_vlc(&dv_vlc, TEX_VLC_BITS, j,
+ new_dv_vlc_len, 1, 1, new_dv_vlc_bits, 2, 2, 0);
- dv_rl_vlc[0] = av_malloc(dv_vlc.table_size * sizeof(RL_VLC_ELEM));
- if (!dv_rl_vlc[0]) {
+ dv_rl_vlc = av_malloc(dv_vlc.table_size * sizeof(RL_VLC_ELEM));
+ if (!dv_rl_vlc) {
+ av_free(dv_anchor);
av_free(dv_vlc_map);
return -ENOMEM;
}
if(len<0){ //more bits needed
run= 0;
level= code;
- } else if (code == (NB_DV_VLC - 1)) {
- /* EOB */
- run = 0;
- level = 256;
} else {
- run= dv_vlc_run[code] + 1;
- level= dv_vlc_level[code];
+ run= new_dv_vlc_run[code] + 1;
+ level= new_dv_vlc_level[code];
}
- dv_rl_vlc[0][i].len = len;
- dv_rl_vlc[0][i].level = level;
- dv_rl_vlc[0][i].run = run;
+ dv_rl_vlc[i].len = len;
+ dv_rl_vlc[i].level = level;
+ dv_rl_vlc[i].run = run;
}
+ free_vlc(&dv_vlc);
for (i = 0; i < NB_DV_VLC - 1; i++) {
- if (dv_vlc_run[i] >= DV_VLC_MAP_RUN_SIZE || dv_vlc_level[i] >= DV_VLC_MAP_LEV_SIZE)
+ if (dv_vlc_run[i] >= DV_VLC_MAP_RUN_SIZE)
+ continue;
+#ifdef DV_CODEC_TINY_TARGET
+ if (dv_vlc_level[i] >= DV_VLC_MAP_LEV_SIZE)
continue;
+#endif
if (dv_vlc_map[dv_vlc_run[i]][dv_vlc_level[i]].size != 0)
continue;
}
// #define VLC_DEBUG
+// #define printf(...) av_log(NULL, AV_LOG_ERROR, __VA_ARGS__)
typedef struct BlockInfo {
const uint8_t *shift_table;
const uint8_t *scan_table;
uint8_t pos; /* position in block */
- uint8_t eob_reached; /* true if EOB has been reached */
uint8_t dct_mode;
uint8_t partial_bit_count;
uint16_t partial_bit_buffer;
#ifndef ALT_BITSTREAM_READER
#warning only works with ALT_BITSTREAM_READER
+static int re_index; //Hack to make it compile
#endif
+static inline int get_bits_left(GetBitContext *s)
+{
+ return s->size_in_bits - get_bits_count(s);
+}
+
+static inline int get_bits_size(GetBitContext *s)
+{
+ return s->size_in_bits;
+}
+
+static inline int put_bits_left(PutBitContext* s)
+{
+ return (s->buf_end - s->buf) * 8 - put_bits_count(s);
+}
+
/* decode ac coefs */
-static void dv_decode_ac(DVVideoDecodeContext *s,
- BlockInfo *mb, DCTELEM *block, int last_index)
+static void dv_decode_ac(GetBitContext *gb, BlockInfo *mb, DCTELEM *block)
{
- int last_re_index;
- int shift_offset = mb->shift_offset;
+ int last_index = get_bits_size(gb);
const uint8_t *scan_table = mb->scan_table;
const uint8_t *shift_table = mb->shift_table;
int pos = mb->pos;
- int level, pos1, sign, run;
- int partial_bit_count;
-#ifndef ALT_BITSTREAM_READER //FIXME
- int re_index=0;
- int re1_index=0;
-#endif
- OPEN_READER(re, &s->gb);
+ int partial_bit_count = mb->partial_bit_count;
+ int level, pos1, run, vlc_len, index;
+
+ OPEN_READER(re, gb);
+ UPDATE_CACHE(re, gb);
-#ifdef VLC_DEBUG
- printf("start\n");
-#endif
-
/* if we must parse a partial vlc, we do it here */
- partial_bit_count = mb->partial_bit_count;
if (partial_bit_count > 0) {
- uint8_t buf[4];
- uint32_t v;
- int l, l1;
- GetBitContext gb1;
-
- /* build the dummy bit buffer */
- l = 16 - partial_bit_count;
- UPDATE_CACHE(re, &s->gb);
-#ifdef VLC_DEBUG
- printf("show=%04x\n", SHOW_UBITS(re, &s->gb, 16));
-#endif
- v = (mb->partial_bit_buffer << l) | SHOW_UBITS(re, &s->gb, l);
- buf[0] = v >> 8;
- buf[1] = v;
-#ifdef VLC_DEBUG
- printf("v=%04x cnt=%d %04x\n",
- v, partial_bit_count, (mb->partial_bit_buffer << l));
-#endif
- /* try to read the codeword */
- init_get_bits(&gb1, buf, 4*8);
- {
- OPEN_READER(re1, &gb1);
- UPDATE_CACHE(re1, &gb1);
- GET_RL_VLC(level, run, re1, &gb1, dv_rl_vlc[0],
- TEX_VLC_BITS, 2);
- l = re1_index;
- CLOSE_READER(re1, &gb1);
- }
-#ifdef VLC_DEBUG
- printf("****run=%d level=%d size=%d\n", run, level, l);
-#endif
- /* compute codeword length */
- l1 = (level != 256 && level != 0);
- /* if too long, we cannot parse */
- l -= partial_bit_count;
- if ((re_index + l + l1) > last_index)
- return;
- /* skip read bits */
- last_re_index = 0; /* avoid warning */
- re_index += l;
- /* by definition, if we can read the vlc, all partial bits
- will be read (otherwise we could have read the vlc before) */
- mb->partial_bit_count = 0;
- UPDATE_CACHE(re, &s->gb);
- goto handle_vlc;
+ re_cache = ((unsigned)re_cache >> partial_bit_count) |
+ (mb->partial_bit_buffer << (sizeof(re_cache)*8 - partial_bit_count));
+ re_index -= partial_bit_count;
+ mb->partial_bit_count = 0;
}
/* get the AC coefficients until last_index is reached */
for(;;) {
- UPDATE_CACHE(re, &s->gb);
#ifdef VLC_DEBUG
- printf("%2d: bits=%04x index=%d\n",
- pos, SHOW_UBITS(re, &s->gb, 16), re_index);
+ printf("%2d: bits=%04x index=%d\n", pos, SHOW_UBITS(re, gb, 16), re_index);
#endif
- last_re_index = re_index;
- GET_RL_VLC(level, run, re, &s->gb, dv_rl_vlc[0],
- TEX_VLC_BITS, 2);
- handle_vlc:
+ /* our own optimized GET_RL_VLC */
+ index = NEG_USR32(re_cache, TEX_VLC_BITS);
+ vlc_len = dv_rl_vlc[index].len;
+ if (vlc_len < 0) {
+ index = NEG_USR32((unsigned)re_cache << TEX_VLC_BITS, -vlc_len) + dv_rl_vlc[index].level;
+ vlc_len = TEX_VLC_BITS - vlc_len;
+ }
+ level = dv_rl_vlc[index].level;
+ run = dv_rl_vlc[index].run;
+
+ /* gotta check if we're still within gb boundaries */
+ if (re_index + vlc_len > last_index) {
+ /* should be < 16 bits otherwise a codeword could have been parsed */
+ mb->partial_bit_count = last_index - re_index;
+ mb->partial_bit_buffer = NEG_USR32(re_cache, mb->partial_bit_count);
+ re_index = last_index;
+ break;
+ }
+ re_index += vlc_len;
+
#ifdef VLC_DEBUG
- printf("run=%d level=%d\n", run, level);
+ printf("run=%d level=%d\n", run, level);
#endif
- if (level == 256) {
- if (re_index > last_index) {
- cannot_read:
- /* put position before read code */
- re_index = last_re_index;
- mb->eob_reached = 0;
- break;
- }
- /* EOB */
- mb->eob_reached = 1;
- break;
- } else if (level != 0) {
- if ((re_index + 1) > last_index)
- goto cannot_read;
- sign = SHOW_SBITS(re, &s->gb, 1);
- level = (level ^ sign) - sign;
- LAST_SKIP_BITS(re, &s->gb, 1);
- pos += run;
- /* error */
- if (pos >= 64) {
- goto read_error;
- }
+ pos += run;
+ if (pos >= 64)
+ break;
+
+ if (level) {
pos1 = scan_table[pos];
- level = level << (shift_table[pos1] + shift_offset);
- block[pos1] = level;
- // printf("run=%d level=%d shift=%d\n", run, level, shift_table[pos1]);
- } else {
- if (re_index > last_index)
- goto cannot_read;
- /* level is zero: means run without coding. No
- sign is coded */
- pos += run;
- /* error */
- if (pos >= 64) {
- read_error:
-#if defined(VLC_DEBUG) || 1
- av_log(NULL, AV_LOG_ERROR, "error pos=%d\n", pos);
-#endif
- /* for errors, we consider the eob is reached */
- mb->eob_reached = 1;
- break;
- }
- }
+ block[pos1] = level << shift_table[pos1];
+ }
+
+ UPDATE_CACHE(re, gb);
}
- CLOSE_READER(re, &s->gb);
+ CLOSE_READER(re, gb);
mb->pos = pos;
}
-static inline void bit_copy(PutBitContext *pb, GetBitContext *gb, int bits_left)
+static inline void bit_copy(PutBitContext *pb, GetBitContext *gb)
{
+ int bits_left = get_bits_left(gb);
while (bits_left >= 16) {
put_bits(pb, 16, get_bits(gb, 16));
bits_left -= 16;
}
/* mb_x and mb_y are in units of 8 pixels */
-static inline void dv_decode_video_segment(DVVideoDecodeContext *s,
+static inline void dv_decode_video_segment(DVVideoContext *s,
uint8_t *buf_ptr1,
const uint16_t *mb_pos_ptr)
{
int quant, dc, dct_mode, class1, j;
int mb_index, mb_x, mb_y, v, last_index;
DCTELEM *block, *block1;
- int c_offset, bits_left;
+ int c_offset;
uint8_t *y_ptr;
- BlockInfo mb_data[5 * 6], *mb, *mb1;
void (*idct_put)(uint8_t *dest, int line_size, DCTELEM *block);
uint8_t *buf_ptr;
PutBitContext pb, vs_pb;
+ GetBitContext gb;
+ BlockInfo mb_data[5 * 6], *mb, *mb1;
+ DCTELEM sblock[5*6][64] __align8;
uint8_t mb_bit_buffer[80 + 4]; /* allow some slack */
- int mb_bit_count;
uint8_t vs_bit_buffer[5 * 80 + 4]; /* allow some slack */
- int vs_bit_count;
-
- memset(s->block, 0, sizeof(s->block));
+
+ memset(sblock, 0, sizeof(sblock));
/* pass 1 : read DC and AC coefficients in blocks */
buf_ptr = buf_ptr1;
- block1 = &s->block[0][0];
+ block1 = &sblock[0][0];
mb1 = mb_data;
init_put_bits(&vs_pb, vs_bit_buffer, 5 * 80);
- vs_bit_count = 0;
- for(mb_index = 0; mb_index < 5; mb_index++) {
+ for(mb_index = 0; mb_index < 5; mb_index++, mb1 += 6, block1 += 6 * 64) {
/* skip header */
quant = buf_ptr[3] & 0x0f;
buf_ptr += 4;
init_put_bits(&pb, mb_bit_buffer, 80);
- mb_bit_count = 0;
mb = mb1;
block = block1;
for(j = 0;j < 6; j++) {
- /* NOTE: size is not important here */
- init_get_bits(&s->gb, buf_ptr, 14*8);
+ last_index = block_sizes[j];
+ init_get_bits(&gb, buf_ptr, last_index);
/* get the dc */
- dc = get_bits(&s->gb, 9);
- dc = (dc << (32 - 9)) >> (32 - 9);
- dct_mode = get_bits1(&s->gb);
+ dc = get_sbits(&gb, 9);
+ dct_mode = get_bits1(&gb);
mb->dct_mode = dct_mode;
mb->scan_table = s->dv_zigzag[dct_mode];
- class1 = get_bits(&s->gb, 2);
- mb->shift_offset = (class1 == 3);
- mb->shift_table = s->dv_idct_shift[dct_mode]
+ class1 = get_bits(&gb, 2);
+ mb->shift_table = s->dv_idct_shift[class1 == 3][dct_mode]
[quant + dv_quant_offset[class1]];
dc = dc << 2;
/* convert to unsigned because 128 is not added in the
standard IDCT */
dc += 1024;
block[0] = dc;
- last_index = block_sizes[j];
buf_ptr += last_index >> 3;
mb->pos = 0;
mb->partial_bit_count = 0;
#ifdef VLC_DEBUG
printf("MB block: %d, %d ", mb_index, j);
#endif
- dv_decode_ac(s, mb, block, last_index);
+ dv_decode_ac(&gb, mb, block);
/* write the remaining bits in a new buffer only if the
block is finished */
- bits_left = last_index - get_bits_count(&s->gb);
- if (mb->eob_reached) {
- mb->partial_bit_count = 0;
- mb_bit_count += bits_left;
- bit_copy(&pb, &s->gb, bits_left);
- } else {
- /* should be < 16 bits otherwise a codeword could have
- been parsed */
- mb->partial_bit_count = bits_left;
- mb->partial_bit_buffer = get_bits(&s->gb, bits_left);
- }
+ if (mb->pos >= 64)
+ bit_copy(&pb, &gb);
+
block += 64;
mb++;
}
- flush_put_bits(&pb);
-
/* pass 2 : we can do it just after */
#ifdef VLC_DEBUG
- printf("***pass 2 size=%d MB#=%d\n", mb_bit_count, mb_index);
+ printf("***pass 2 size=%d MB#=%d\n", put_bits_count(&pb), mb_index);
#endif
block = block1;
mb = mb1;
- init_get_bits(&s->gb, mb_bit_buffer, 80*8);
- for(j = 0;j < 6; j++) {
- if (!mb->eob_reached && get_bits_count(&s->gb) < mb_bit_count) {
- dv_decode_ac(s, mb, block, mb_bit_count);
+ init_get_bits(&gb, mb_bit_buffer, put_bits_count(&pb));
+ flush_put_bits(&pb);
+ for(j = 0;j < 6; j++, block += 64, mb++) {
+ if (mb->pos < 64 && get_bits_left(&gb) > 0) {
+ dv_decode_ac(&gb, mb, block);
/* if still not finished, no need to parse other blocks */
- if (!mb->eob_reached) {
- /* we could not parse the current AC coefficient,
- so we add the remaining bytes */
- bits_left = mb_bit_count - get_bits_count(&s->gb);
- if (bits_left > 0) {
- mb->partial_bit_count += bits_left;
- mb->partial_bit_buffer =
- (mb->partial_bit_buffer << bits_left) |
- get_bits(&s->gb, bits_left);
- }
- goto next_mb;
- }
+ if (mb->pos < 64)
+ break;
}
- block += 64;
- mb++;
}
/* all blocks are finished, so the extra bytes can be used at
the video segment level */
- bits_left = mb_bit_count - get_bits_count(&s->gb);
- vs_bit_count += bits_left;
- bit_copy(&vs_pb, &s->gb, bits_left);
- next_mb:
- mb1 += 6;
- block1 += 6 * 64;
+ if (j >= 6)
+ bit_copy(&vs_pb, &gb);
}
/* we need a pass other the whole video segment */
- flush_put_bits(&vs_pb);
-
#ifdef VLC_DEBUG
- printf("***pass 3 size=%d\n", vs_bit_count);
+ printf("***pass 3 size=%d\n", put_bits_count(&vs_pb));
#endif
- block = &s->block[0][0];
+ block = &sblock[0][0];
mb = mb_data;
- init_get_bits(&s->gb, vs_bit_buffer, 5 * 80*8);
+ init_get_bits(&gb, vs_bit_buffer, put_bits_count(&vs_pb));
+ flush_put_bits(&vs_pb);
for(mb_index = 0; mb_index < 5; mb_index++) {
for(j = 0;j < 6; j++) {
- if (!mb->eob_reached) {
+ if (mb->pos < 64) {
#ifdef VLC_DEBUG
printf("start %d:%d\n", mb_index, j);
#endif
- dv_decode_ac(s, mb, block, vs_bit_count);
+ dv_decode_ac(&gb, mb, block);
}
+ if (mb->pos >= 64 && mb->pos < 127)
+ av_log(NULL, AV_LOG_ERROR, "AC EOB marker is absent pos=%d\n", mb->pos);
block += 64;
mb++;
}
}
/* compute idct and place blocks */
- block = &s->block[0][0];
+ block = &sblock[0][0];
mb = mb_data;
for(mb_index = 0; mb_index < 5; mb_index++) {
v = *mb_pos_ptr++;
uint32_t partial_bit_buffer; /* we can't use uint16_t here */
} EncBlockInfo;
-static always_inline int dv_bits_left(PutBitContext* s)
-{
- return (s->buf_end - s->buf) * 8 -
- ((s->buf_ptr - s->buf) * 8 + 32 - (int64_t)s->bit_left);
-}
-
static always_inline void dv_encode_ac(EncBlockInfo* bi, PutBitContext* pb_pool,
int pb_size)
{
bi->partial_bit_count = bi->partial_bit_buffer = 0;
vlc_loop:
/* Find suitable storage space */
- for (; size > (bits_left = dv_bits_left(pb)); pb++) {
+ for (; size > (bits_left = put_bits_left(pb)); pb++) {
if (bits_left) {
size -= bits_left;
put_bits(pb, bits_left, vlc >> size);
* horrible and the weighting is missing. But it's missing from the
* decoding step also -- so at least we're on the same page with decoder ;-)
*/
-static inline void dv_encode_video_segment(DVVideoDecodeContext *s,
+static inline void dv_encode_video_segment(DVVideoContext *s,
uint8_t *dif,
const uint16_t *mb_pos_ptr)
{
uint8_t* ptr;
int do_edge_wrap;
DCTELEM block[64] __align8;
+ DCTELEM sblock[5*6][64] __align8;
EncBlockInfo enc_blks[5*6];
PutBitContext pbs[5*6];
PutBitContext* pb;
}
enc_blk->dct_mode = dv_guess_dct_mode(block);
- enc_blk->mb = &s->block[mb_index*6+j][0];
+ enc_blk->mb = &sblock[mb_index*6+j][0];
enc_blk->area_q[0] = enc_blk->area_q[1] = enc_blk->area_q[2] = enc_blk->area_q[3] = 0;
enc_blk->partial_bit_count = 0;
enc_blk->partial_bit_buffer = 0;
flush_put_bits(&pbs[j]);
}
+static int dv_decode_mt(AVCodecContext *avctx, void* sl)
+{
+ DVVideoContext *s = avctx->priv_data;
+ int slice = (size_t)sl;
+ dv_decode_video_segment(s, &s->buf[((slice/27)*6+(slice/3)+slice*5+7)*80],
+ &s->sys->video_place[slice*5]);
+ return 0;
+}
+
+static int dv_encode_mt(AVCodecContext *avctx, void* sl)
+{
+ DVVideoContext *s = avctx->priv_data;
+ int slice = (size_t)sl;
+ dv_encode_video_segment(s, &s->buf[((slice/27)*6+(slice/3)+slice*5+7)*80],
+ &s->sys->video_place[slice*5]);
+ return 0;
+}
+
/* NOTE: exactly one frame must be given (120000 bytes for NTSC,
144000 bytes for PAL) */
static int dvvideo_decode_frame(AVCodecContext *avctx,
void *data, int *data_size,
uint8_t *buf, int buf_size)
{
- DVVideoDecodeContext *s = avctx->priv_data;
- int ds, vs;
- const uint16_t *mb_pos_ptr;
-
+ DVVideoContext *s = avctx->priv_data;
+
s->sys = dv_frame_profile(buf);
if (!s->sys || buf_size < s->sys->frame_size)
return -1; /* NOTE: we only accept several full frames */
-
if(s->picture.data[0])
avctx->release_buffer(avctx, &s->picture);
s->picture.interlaced_frame = 1;
s->picture.top_field_first = 0;
- /* for each DIF segment */
- mb_pos_ptr = s->sys->video_place;
- for (ds = 0; ds < s->sys->difseg_size; ds++) {
- buf += 6 * 80; /* skip DIF segment header */
-
- for(vs = 0; vs < 27; vs++) {
- if ((vs % 3) == 0)
- buf += 80; /* skip audio block */
-
-#ifdef VLC_DEBUG
- printf("********************* %d, %d **********************\n", ds, vs);
-#endif
- dv_decode_video_segment(s, buf, mb_pos_ptr);
- buf += 5 * 80;
- mb_pos_ptr += 5;
- }
- }
-
+ s->buf = buf;
+ avctx->execute(avctx, dv_decode_mt, (void**)&dv_anchor[0], NULL,
+ s->sys->difseg_size * 27);
+
emms_c();
/* return image */
static int dvvideo_encode_frame(AVCodecContext *c, uint8_t *buf, int buf_size,
void *data)
{
- DVVideoDecodeContext *s = c->priv_data;
- const uint16_t *mb_pos_ptr;
- int ds, vs;
+ DVVideoContext *s = c->priv_data;
s->sys = dv_codec_profile(c);
if (!s->sys)
return -1;
-
+ if(buf_size < s->sys->frame_size)
+ return -1;
+
c->pix_fmt = s->sys->pix_fmt;
s->picture = *((AVFrame *)data);
- /* for each DIF segment */
- mb_pos_ptr = s->sys->video_place;
- for (ds = 0; ds < s->sys->difseg_size; ds++) {
- buf += 6 * 80; /* skip DIF segment header */
-
- for(vs = 0; vs < 27; vs++) {
- if ((vs % 3) == 0)
- buf += 80; /* skip audio block */
-
-#ifdef VLC_DEBUG
- printf("********************* %d, %d **********************\n", ds, vs);
-#endif
- dv_encode_video_segment(s, buf, mb_pos_ptr);
- buf += 5 * 80;
- mb_pos_ptr += 5;
- }
- }
+ s->buf = buf;
+ c->execute(c, dv_encode_mt, (void**)&dv_anchor[0], NULL,
+ s->sys->difseg_size * 27);
emms_c();
return s->sys->frame_size;
}
-static int dvvideo_end(AVCodecContext *avctx)
-{
- avcodec_default_free_buffers(avctx);
- return 0;
-}
+#ifdef CONFIG_DVVIDEO_ENCODER
+AVCodec dvvideo_encoder = {
+ "dvvideo",
+ CODEC_TYPE_VIDEO,
+ CODEC_ID_DVVIDEO,
+ sizeof(DVVideoContext),
+ dvvideo_init,
+ dvvideo_encode_frame,
+ NULL,
+ NULL,
+ CODEC_CAP_DR1,
+ NULL
+};
+#endif // CONFIG_DVVIDEO_ENCODER
AVCodec dvvideo_decoder = {
"dvvideo",
CODEC_TYPE_VIDEO,
CODEC_ID_DVVIDEO,
- sizeof(DVVideoDecodeContext),
+ sizeof(DVVideoContext),
dvvideo_init,
- dvvideo_encode_frame,
- dvvideo_end,
+ NULL,
+ NULL,
dvvideo_decode_frame,
CODEC_CAP_DR1,
NULL
projects / ffmpeg / blobdiff