Chiebot-Mirror
/
FFmpeg
8
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

* DV decoding/encoding now supports MultiThreading for up to 324 CPUs ;-)

Browse Source 
Originally committed as revision 2893 to svn://svn.ffmpeg.org/ffmpeg/trunk
pull/126/head
Roman Shaposhnik 21 years ago
parent 380fd6b1b4
commit 6faa4645c5
3 changed files with 105 additions and 92 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 1
      libavcodec/allcodecs.c
  2. 1
      libavcodec/avcodec.h
  3. 195
      libavcodec/dv.c

1
libavcodec/allcodecs.c
Unescape View File

@ -74,6 +74,7 @@ void avcodec_register_all(void)
register_avcodec(&asv2_encoder);
register_avcodec(&ffv1_encoder);
register_avcodec(&zlib_encoder);
register_avcodec(&dvvideo_encoder);
#endif /* CONFIG_ENCODERS */
register_avcodec(&rawvideo_encoder);
register_avcodec(&rawvideo_decoder);

1
libavcodec/avcodec.h
Unescape View File

@ -1669,6 +1669,7 @@ extern AVCodec h263p_encoder;
extern AVCodec flv_encoder;
extern AVCodec rv10_encoder;
extern AVCodec rv20_encoder;
extern AVCodec dvvideo_encoder;
extern AVCodec mjpeg_encoder;
extern AVCodec ljpeg_encoder;
extern AVCodec mpeg4_encoder;

195
libavcodec/dv.c
Unescape View File

@ -33,9 +33,10 @@
#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];
@ -43,10 +44,7 @@ typedef struct DVVideoDecodeContext {
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
@ -58,6 +56,9 @@ typedef struct DVVideoDecodeContext {
#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;
/* VLC encoding lookup table */
@ -66,7 +67,7 @@ static struct dv_vlc_pair {
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;
@ -91,7 +92,7 @@ static void dv_build_unquantize_tables(DVVideoDecodeContext *s, uint8_t* perm)
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;
@ -106,6 +107,14 @@ static int dvvideo_init(AVCodecContext *avctx)
if (!dv_vlc_map)
return -ENOMEM;
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++)
(int)dv_anchor[i] = 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,
@ -113,6 +122,7 @@ static int dvvideo_init(AVCodecContext *avctx)
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;
}
@ -199,6 +209,12 @@ static int dvvideo_init(AVCodecContext *avctx)
return 0;
}
static int dvvideo_end(AVCodecContext *avctx)
{
avcodec_default_free_buffers(avctx);
return 0;
}
// #define VLC_DEBUG
typedef struct BlockInfo {
@ -225,9 +241,9 @@ static const int mb_area_start[5] = { 1, 6, 21, 43, 64 };
#endif
/* decode ac coefs */
static void dv_decode_ac(DVVideoDecodeContext *s, BlockInfo *mb, DCTELEM *block)
static void dv_decode_ac(GetBitContext *gb, BlockInfo *mb, DCTELEM *block)
{
int last_index = get_bits_size(&s->gb);
int last_index = get_bits_size(gb);
int last_re_index;
int shift_offset = mb->shift_offset;
const uint8_t *scan_table = mb->scan_table;
@ -240,7 +256,7 @@ static void dv_decode_ac(DVVideoDecodeContext *s, BlockInfo *mb, DCTELEM *block)
int re_index=0;
int re1_index=0;
#endif
OPEN_READER(re, &s->gb);
OPEN_READER(re, gb);
#ifdef VLC_DEBUG
printf("start\n");
@ -256,11 +272,11 @@ static void dv_decode_ac(DVVideoDecodeContext *s, BlockInfo *mb, DCTELEM *block)
/* build the dummy bit buffer */
l = 16 - partial_bit_count;
UPDATE_CACHE(re, &s->gb);
UPDATE_CACHE(re, gb);
#ifdef VLC_DEBUG
printf("show=%04x\n", SHOW_UBITS(re, &s->gb, 16));
printf("show=%04x\n", SHOW_UBITS(re, gb, 16));
#endif
v = (mb->partial_bit_buffer << l) | SHOW_UBITS(re, &s->gb, l);
v = (mb->partial_bit_buffer << l) | SHOW_UBITS(re, gb, l);
buf[0] = v >> 8;
buf[1] = v;
#ifdef VLC_DEBUG
@ -294,34 +310,34 @@ static void dv_decode_ac(DVVideoDecodeContext *s, BlockInfo *mb, DCTELEM *block)
/* 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);
UPDATE_CACHE(re, gb);
goto handle_vlc;
}
/* get the AC coefficients until last_index is reached */
for(;;) {
UPDATE_CACHE(re, &s->gb);
UPDATE_CACHE(re, gb);
#ifdef VLC_DEBUG
printf("%2d: bits=%04x index=%d\n",
pos, SHOW_UBITS(re, &s->gb, 16), re_index);
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,
GET_RL_VLC(level, run, re, gb, dv_rl_vlc,
TEX_VLC_BITS, 2);
handle_vlc:
#ifdef VLC_DEBUG
printf("run=%d level=%d\n", run, level);
#endif
if (level) {
sign = SHOW_SBITS(re, &s->gb, 1);
LAST_SKIP_BITS(re, &s->gb, 1);
sign = SHOW_SBITS(re, gb, 1);
LAST_SKIP_BITS(re, gb, 1);
}
if (re_index > last_index) {
/* should be < 16 bits otherwise a codeword could have been parsed */
re_index = last_re_index;
UPDATE_CACHE(re, &s->gb);
UPDATE_CACHE(re, gb);
mb->partial_bit_count = last_index - re_index;
mb->partial_bit_buffer = SHOW_UBITS(re, &s->gb, mb->partial_bit_count);
mb->partial_bit_buffer = SHOW_UBITS(re, gb, mb->partial_bit_count);
re_index = last_index;
break;
}
@ -338,7 +354,7 @@ static void dv_decode_ac(DVVideoDecodeContext *s, BlockInfo *mb, DCTELEM *block)
// printf("run=%d level=%d shift=%d\n", run, level, shift_table[pos1]);
}
}
CLOSE_READER(re, &s->gb);
CLOSE_READER(re, gb);
mb->pos = pos;
}
@ -355,7 +371,7 @@ static inline void bit_copy(PutBitContext *pb, GetBitContext *gb)
}
/* 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)
{
@ -364,18 +380,20 @@ static inline void dv_decode_video_segment(DVVideoDecodeContext *s,
DCTELEM *block, *block1;
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 */
uint8_t vs_bit_buffer[5 * 80 + 4]; /* allow some slack */
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);
for(mb_index = 0; mb_index < 5; mb_index++, mb1 += 6, block1 += 6 * 64) {
@ -387,15 +405,15 @@ static inline void dv_decode_video_segment(DVVideoDecodeContext *s,
block = block1;
for(j = 0;j < 6; j++) {
last_index = block_sizes[j];
init_get_bits(&s->gb, buf_ptr, last_index);
init_get_bits(&gb, buf_ptr, last_index);
/* get the dc */
dc = get_bits(&s->gb, 9);
dc = get_bits(&gb, 9);
dc = (dc << (32 - 9)) >> (32 - 9);
dct_mode = get_bits1(&s->gb);
dct_mode = get_bits1(&gb);
mb->dct_mode = dct_mode;
mb->scan_table = s->dv_zigzag[dct_mode];
class1 = get_bits(&s->gb, 2);
class1 = get_bits(&gb, 2);
mb->shift_offset = (class1 == 3);
mb->shift_table = s->dv_idct_shift[dct_mode]
[quant + dv_quant_offset[class1]];
@ -411,12 +429,12 @@ static inline void dv_decode_video_segment(DVVideoDecodeContext *s,
#ifdef VLC_DEBUG
printf("MB block: %d, %d ", mb_index, j);
#endif
dv_decode_ac(s, mb, block);
dv_decode_ac(&gb, mb, block);
/* write the remaining bits in a new buffer only if the
block is finished */
if (mb->pos >= 64)
bit_copy(&pb, &s->gb);
bit_copy(&pb, &gb);
block += 64;
mb++;
@ -428,11 +446,11 @@ static inline void dv_decode_video_segment(DVVideoDecodeContext *s,
#endif
block = block1;
mb = mb1;
init_get_bits(&s->gb, mb_bit_buffer, put_bits_count(&pb));
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(&s->gb) > 0) {
dv_decode_ac(s, mb, block);
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->pos < 64)
break;
@ -441,16 +459,16 @@ static inline void dv_decode_video_segment(DVVideoDecodeContext *s,
/* all blocks are finished, so the extra bytes can be used at
the video segment level */
if (j >= 6)
bit_copy(&vs_pb, &s->gb);
bit_copy(&vs_pb, &gb);
}
/* we need a pass other the whole video segment */
#ifdef VLC_DEBUG
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, put_bits_count(&vs_pb));
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++) {
@ -458,7 +476,7 @@ static inline void dv_decode_video_segment(DVVideoDecodeContext *s,
#ifdef VLC_DEBUG
printf("start %d:%d\n", mb_index, j);
#endif
dv_decode_ac(s, mb, block);
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);
@ -468,7 +486,7 @@ static inline void dv_decode_video_segment(DVVideoDecodeContext *s,
}
/* 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++;
@ -743,7 +761,7 @@ static inline void dv_guess_qnos(EncBlockInfo* blks, int* qnos)
* 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)
{
@ -754,6 +772,7 @@ static inline void dv_encode_video_segment(DVVideoDecodeContext *s,
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;
@ -807,7 +826,7 @@ static inline void dv_encode_video_segment(DVVideoDecodeContext *s,
}
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;
@ -859,15 +878,31 @@ static inline void dv_encode_video_segment(DVVideoDecodeContext *s,
flush_put_bits(&pbs[j]);
}
static int dv_decode_mt(AVCodecContext *avctx, void* sl)
{
DVVideoContext *s = avctx->priv_data;
int slice = (int)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 = (int)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;
*data_size=0;
/* special case for last picture */
@ -878,7 +913,6 @@ static int dvvideo_decode_frame(AVCodecContext *avctx,
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);
@ -893,24 +927,10 @@ static int dvvideo_decode_frame(AVCodecContext *avctx,
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 */
@ -923,9 +943,7 @@ static int dvvideo_decode_frame(AVCodecContext *avctx,
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)
@ -934,41 +952,34 @@ static int dvvideo_encode_frame(AVCodecContext *c, uint8_t *buf, int buf_size,
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;
}
AVCodec dvvideo_encoder = {
"dvvideo",
CODEC_TYPE_VIDEO,
CODEC_ID_DVVIDEO,
sizeof(DVVideoContext),
dvvideo_init,
dvvideo_encode_frame,
dvvideo_end,
NULL,
CODEC_CAP_DR1,
NULL
};
AVCodec dvvideo_decoder = {
"dvvideo",
CODEC_TYPE_VIDEO,
CODEC_ID_DVVIDEO,
sizeof(DVVideoDecodeContext),
sizeof(DVVideoContext),
dvvideo_init,
dvvideo_encode_frame,
NULL,
dvvideo_end,
dvvideo_decode_frame,
CODEC_CAP_DR1,

Write Preview
Loading…
Cancel
Save