#define ALT_BITSTREAM_READER
#include "avcodec.h"
#include "dsputil.h"
-#include "bitstream.h"
+#include "get_bits.h"
+#include "put_bits.h"
#include "simple_idct.h"
#include "dvdata.h"
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);
+ me_cmp_func ildct_cmp;
} DVVideoContext;
#define TEX_VLC_BITS 9
static inline void dv_calc_mb_coordinates(const DVprofile *d, int chan, int seq, int slot,
uint16_t *tbl)
{
- const static uint8_t off[] = { 2, 6, 8, 0, 4 };
- const static uint8_t shuf1[] = { 36, 18, 54, 0, 72 };
- const static uint8_t shuf2[] = { 24, 12, 36, 0, 48 };
- const static uint8_t shuf3[] = { 18, 9, 27, 0, 36 };
+ static const uint8_t off[] = { 2, 6, 8, 0, 4 };
+ static const uint8_t shuf1[] = { 36, 18, 54, 0, 72 };
+ static const uint8_t shuf2[] = { 24, 12, 36, 0, 48 };
+ static const uint8_t shuf3[] = { 18, 9, 27, 0, 36 };
- const static uint8_t l_start[] = {0, 4, 9, 13, 18, 22, 27, 31, 36, 40};
- const static uint8_t l_start_shuffled[] = { 9, 4, 13, 0, 18 };
+ static const uint8_t l_start[] = {0, 4, 9, 13, 18, 22, 27, 31, 36, 40};
+ static const uint8_t l_start_shuffled[] = { 9, 4, 13, 0, 18 };
- const static uint8_t serpent1[] = {0, 1, 2, 2, 1, 0,
+ static const uint8_t serpent1[] = {0, 1, 2, 2, 1, 0,
0, 1, 2, 2, 1, 0,
0, 1, 2, 2, 1, 0,
0, 1, 2, 2, 1, 0,
0, 1, 2};
- const static uint8_t serpent2[] = {0, 1, 2, 3, 4, 5, 5, 4, 3, 2, 1, 0,
+ static const uint8_t serpent2[] = {0, 1, 2, 3, 4, 5, 5, 4, 3, 2, 1, 0,
0, 1, 2, 3, 4, 5, 5, 4, 3, 2, 1, 0,
0, 1, 2, 3, 4, 5};
- const static uint8_t remap[][2] = {{ 0, 0}, { 0, 0}, { 0, 0}, { 0, 0}, /* dummy */
+ static const uint8_t remap[][2] = {{ 0, 0}, { 0, 0}, { 0, 0}, { 0, 0}, /* dummy */
{ 0, 0}, { 0, 1}, { 0, 2}, { 0, 3}, {10, 0},
{10, 1}, {10, 2}, {10, 3}, {20, 0}, {20, 1},
{20, 2}, {20, 3}, {30, 0}, {30, 1}, {30, 2},
/* Generic DSP setup */
dsputil_init(&dsp, avctx);
+ ff_set_cmp(&dsp, dsp.ildct_cmp, avctx->ildct_cmp);
s->get_pixels = dsp.get_pixels;
+ s->ildct_cmp = dsp.ildct_cmp[5];
/* 88DCT setup */
s->fdct[0] = dsp.fdct;
avctx->coded_frame = &s->picture;
s->avctx = avctx;
+ avctx->chroma_sample_location = AVCHROMA_LOC_TOPLEFT;
return 0;
}
+static av_cold int dvvideo_init_encoder(AVCodecContext *avctx)
+{
+ if (!ff_dv_codec_profile(avctx)) {
+ av_log(avctx, AV_LOG_ERROR, "Found no DV profile for %ix%i %s video\n",
+ avctx->width, avctx->height, avcodec_get_pix_fmt_name(avctx->pix_fmt));
+ return -1;
+ }
+
+ return dvvideo_init(avctx);
+}
+
// #define VLC_DEBUG
// #define printf(...) av_log(NULL, AV_LOG_ERROR, __VA_ARGS__)
/* see dv_88_areas and dv_248_areas for details */
static const int mb_area_start[5] = { 1, 6, 21, 43, 64 };
-static inline int get_bits_left(GetBitContext *s)
-{
- return s->size_in_bits - get_bits_count(s);
-}
-
static inline int put_bits_left(PutBitContext* s)
{
return (s->buf_end - s->buf) * 8 - put_bits_count(s);
GetBitContext gb;
BlockInfo mb_data[5 * DV_MAX_BPM], *mb, *mb1;
DECLARE_ALIGNED_16(DCTELEM, sblock[5*DV_MAX_BPM][64]);
- DECLARE_ALIGNED_8(uint8_t, mb_bit_buffer[80 + 4]); /* allow some slack */
- DECLARE_ALIGNED_8(uint8_t, vs_bit_buffer[5 * 80 + 4]); /* allow some slack */
+ uint8_t mb_bit_buffer[80 + 4]; /* allow some slack */
+ uint8_t vs_bit_buffer[5 * 80 + 4]; /* allow some slack */
const int log2_blocksize = 3-s->avctx->lowres;
int is_field_mode[5];
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);
+ av_log(avctx, AV_LOG_ERROR, "AC EOB marker is absent pos=%d\n", mb->pos);
block += 64;
mb++;
}
return pb;
}
-//FIXME replace this by dsputil
-#define SC(x, y) ((s[x] - s[y]) ^ ((s[x] - s[y]) >> 7))
-static av_always_inline int dv_guess_dct_mode(DCTELEM *blk) {
- DCTELEM *s;
- int score88 = 0;
- int score248 = 0;
- int i;
-
- /* Compute 8-8 score (small values give a better chance for 8-8 DCT) */
- s = blk;
- for (i = 0; i < 7; i++) {
- score88 += SC(0, 8) + SC(1, 9) + SC(2, 10) + SC(3, 11) +
- SC(4, 12) + SC(5,13) + SC(6, 14) + SC(7, 15);
- s += 8;
- }
- /* Compute 2-4-8 score (small values give a better chance for 2-4-8 DCT) */
- s = blk;
- for (i = 0; i < 6; i++) {
- score248 += SC(0, 16) + SC(1,17) + SC(2, 18) + SC(3, 19) +
- SC(4, 20) + SC(5,21) + SC(6, 22) + SC(7, 23);
- s += 8;
+static av_always_inline int dv_guess_dct_mode(DVVideoContext *s, uint8_t *data, int linesize) {
+ if (s->avctx->flags & CODEC_FLAG_INTERLACED_DCT) {
+ int ps = s->ildct_cmp(NULL, data, NULL, linesize, 8) - 400;
+ if (ps > 0) {
+ int is = s->ildct_cmp(NULL, data , NULL, linesize<<1, 4) +
+ s->ildct_cmp(NULL, data + linesize, NULL, linesize<<1, 4);
+ return (ps > is);
+ }
}
- return (score88 - score248 > -10);
+ return 0;
}
static av_always_inline int dv_init_enc_block(EncBlockInfo* bi, uint8_t *data, int linesize, DVVideoContext *s, int bias)
bi->partial_bit_buffer = 0;
bi->cur_ac = 0;
if (data) {
+ bi->dct_mode = dv_guess_dct_mode(s, data, linesize);
s->get_pixels(blk, data, linesize);
- bi->dct_mode = (s->avctx->flags & CODEC_FLAG_INTERLACED_DCT) &&
- dv_guess_dct_mode(blk);
s->fdct[bi->dct_mode](blk);
} else {
/* We rely on the fact that encoding all zeros leads to an immediate EOB,
int sz = s->sys->block_sizes[i]>>3;
init_put_bits(&pbs[j], dif, sz);
- put_bits(&pbs[j], 9, (uint16_t)(((enc_blks[j].mb[0] >> 3) - 1024 + 2) >> 2));
+ put_sbits(&pbs[j], 9, ((enc_blks[j].mb[0] >> 3) - 1024 + 2) >> 2);
put_bits(&pbs[j], 1, enc_blks[j].dct_mode);
put_bits(&pbs[j], 2, enc_blks[j].cno);
if (enc_blks[j].partial_bit_count)
pb = dv_encode_ac(&enc_blks[j], pb, &pbs[s->sys->bpm*5]);
if (enc_blks[j].partial_bit_count)
- av_log(NULL, AV_LOG_ERROR, "ac bitstream overflow\n");
+ av_log(avctx, AV_LOG_ERROR, "ac bitstream overflow\n");
}
- for (j=0; j<5*s->sys->bpm; j++)
+ for (j=0; j<5*s->sys->bpm; j++) {
+ int pos;
+ int size = pbs[j].size_in_bits >> 3;
flush_put_bits(&pbs[j]);
+ pos = put_bits_count(&pbs[j]) >> 3;
+ if (pos > size) {
+ av_log(avctx, AV_LOG_ERROR, "bitstream written beyond buffer size\n");
+ return -1;
+ }
+ memset(pbs[j].buf + pos, 0xff, size - pos);
+ }
return 0;
}
144000 bytes for PAL - or twice those for 50Mbps) */
static int dvvideo_decode_frame(AVCodecContext *avctx,
void *data, int *data_size,
- const uint8_t *buf, int buf_size)
+ AVPacket *avpkt)
{
+ const uint8_t *buf = avpkt->data;
+ int buf_size = avpkt->size;
DVVideoContext *s = avctx->priv_data;
- s->sys = dv_frame_profile(buf);
- if (!s->sys || buf_size < s->sys->frame_size || dv_init_dynamic_tables(s->sys))
+ s->sys = ff_dv_frame_profile(s->sys, buf, buf_size);
+ if (!s->sys || buf_size < s->sys->frame_size || dv_init_dynamic_tables(s->sys)) {
+ av_log(avctx, AV_LOG_ERROR, "could not find dv frame profile\n");
return -1; /* NOTE: we only accept several full frames */
+ }
if (s->picture.data[0])
avctx->release_buffer(avctx, &s->picture);
* compression scheme (if any).
*/
int apt = (c->sys->pix_fmt == PIX_FMT_YUV420P ? 0 : 1);
- int stype = (c->sys->pix_fmt == PIX_FMT_YUV422P ? 4 : 0);
uint8_t aspect = 0;
if ((int)(av_q2d(c->avctx->sample_aspect_ratio) * c->avctx->width / c->avctx->height * 10) >= 17) /* 16:9 */
0xf; /* reserved -- always 1 */
buf[3] = (3 << 6) | /* reserved -- always 1 */
(c->sys->dsf << 5) | /* system: 60fields/50fields */
- stype; /* signal type video compression */
+ c->sys->video_stype; /* signal type video compression */
buf[4] = 0xff; /* VISC: 0xff -- no information */
break;
case dv_video_control:
{
DVVideoContext *s = c->priv_data;
- s->sys = dv_codec_profile(c);
+ s->sys = ff_dv_codec_profile(c);
if (!s->sys || buf_size < s->sys->frame_size || dv_init_dynamic_tables(s->sys))
return -1;
CODEC_TYPE_VIDEO,
CODEC_ID_DVVIDEO,
sizeof(DVVideoContext),
- dvvideo_init,
+ dvvideo_init_encoder,
dvvideo_encode_frame,
- .pix_fmts = (enum PixelFormat[]) {PIX_FMT_YUV411P, PIX_FMT_YUV422P, PIX_FMT_YUV420P, PIX_FMT_NONE},
+ .pix_fmts = (const enum PixelFormat[]) {PIX_FMT_YUV411P, PIX_FMT_YUV422P, PIX_FMT_YUV420P, PIX_FMT_NONE},
.long_name = NULL_IF_CONFIG_SMALL("DV (Digital Video)"),
};
#endif // CONFIG_DVVIDEO_ENCODER
projects / ffmpeg / blobdiff