* Many thanks to Dan Dennedy <dan@dennedy.org> for providing wealth
* of DV technical info.
*
- * 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
*/
/**
- * @file libavcodec/dv.c
+ * @file
* DV codec.
*/
#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"
+#include "dv_tablegen.h"
//#undef NDEBUG
//#include <assert.h>
#define TEX_VLC_BITS 9
-#if CONFIG_SMALL
-#define DV_VLC_MAP_RUN_SIZE 15
-#define DV_VLC_MAP_LEV_SIZE 23
-#else
-#define DV_VLC_MAP_RUN_SIZE 64
-#define DV_VLC_MAP_LEV_SIZE 512 //FIXME sign was removed so this should be /2 but needs check
-#endif
-
/* XXX: also include quantization */
static RL_VLC_ELEM dv_rl_vlc[1184];
-/* VLC encoding lookup table */
-static struct dv_vlc_pair {
- uint32_t vlc;
- uint8_t size;
-} dv_vlc_map[DV_VLC_MAP_RUN_SIZE][DV_VLC_MAP_LEV_SIZE];
static inline int dv_work_pool_size(const DVprofile *d)
{
} else {
iweight1 = &dv_iweight_1080_y[0];
iweight2 = &dv_iweight_1080_c[0];
- }
+ }
if (DV_PROFILE_IS_HD(d)) {
for (c = 0; c < 4; c++) {
for (s = 0; s < 16; s++) {
for (; i < dv_quant_areas[c]; i++) {
*factor1 = iweight1[i] << (dv_quant_shifts[s][c] + 1);
*factor2++ = (*factor1++) << 1;
- }
- }
+ }
+ }
+ }
}
}
}
-}
return 0;
}
}
free_vlc(&dv_vlc);
- for (i = 0; i < NB_DV_VLC - 1; i++) {
- if (dv_vlc_run[i] >= DV_VLC_MAP_RUN_SIZE)
- continue;
-#if CONFIG_SMALL
- 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;
-
- dv_vlc_map[dv_vlc_run[i]][dv_vlc_level[i]].vlc =
- dv_vlc_bits[i] << (!!dv_vlc_level[i]);
- dv_vlc_map[dv_vlc_run[i]][dv_vlc_level[i]].size =
- dv_vlc_len[i] + (!!dv_vlc_level[i]);
- }
- for (i = 0; i < DV_VLC_MAP_RUN_SIZE; i++) {
-#if CONFIG_SMALL
- for (j = 1; j < DV_VLC_MAP_LEV_SIZE; j++) {
- if (dv_vlc_map[i][j].size == 0) {
- dv_vlc_map[i][j].vlc = dv_vlc_map[0][j].vlc |
- (dv_vlc_map[i-1][0].vlc << (dv_vlc_map[0][j].size));
- dv_vlc_map[i][j].size = dv_vlc_map[i-1][0].size +
- dv_vlc_map[0][j].size;
- }
- }
-#else
- for (j = 1; j < DV_VLC_MAP_LEV_SIZE/2; j++) {
- if (dv_vlc_map[i][j].size == 0) {
- dv_vlc_map[i][j].vlc = dv_vlc_map[0][j].vlc |
- (dv_vlc_map[i-1][0].vlc << (dv_vlc_map[0][j].size));
- dv_vlc_map[i][j].size = dv_vlc_map[i-1][0].size +
- dv_vlc_map[0][j].size;
- }
- dv_vlc_map[i][((uint16_t)(-j))&0x1ff].vlc =
- dv_vlc_map[i][j].vlc | 1;
- dv_vlc_map[i][((uint16_t)(-j))&0x1ff].size =
- dv_vlc_map[i][j].size;
- }
-#endif
- }
+ dv_vlc_map_tableinit();
}
/* Generic DSP setup */
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);
PutBitContext pb, vs_pb;
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 */
+ LOCAL_ALIGNED_16(DCTELEM, sblock, [5*DV_MAX_BPM], [64]);
+ LOCAL_ALIGNED_16(uint8_t, mb_bit_buffer, [80 + 4]); /* allow some slack */
+ LOCAL_ALIGNED_16(uint8_t, vs_bit_buffer, [5 * 80 + 4]); /* allow some slack */
const int log2_blocksize = 3-s->avctx->lowres;
int is_field_mode[5];
assert((((int)mb_bit_buffer) & 7) == 0);
assert((((int)vs_bit_buffer) & 7) == 0);
- memset(sblock, 0, sizeof(sblock));
+ memset(sblock, 0, 5*DV_MAX_BPM*sizeof(*sblock));
/* pass 1 : read DC and AC coefficients in blocks */
buf_ptr = &s->buf[work_chunk->buf_offset*80];
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++;
}
s->ildct_cmp(NULL, data + linesize, NULL, linesize<<1, 4);
return (ps > is);
}
- } else
- return 0;
+ }
+
+ return 0;
}
static av_always_inline int dv_init_enc_block(EncBlockInfo* bi, uint8_t *data, int linesize, DVVideoContext *s, int bias)
{
const int *weight;
const uint8_t* zigzag_scan;
- DECLARE_ALIGNED_16(DCTELEM, blk[64]);
+ LOCAL_ALIGNED_16(DCTELEM, blk, [64]);
int i, area;
/* We offer two different methods for class number assignment: the
method suggested in SMPTE 314M Table 22, and an improved
} else {
/* We rely on the fact that encoding all zeros leads to an immediate EOB,
which is precisely what the spec calls for in the "dummy" blocks. */
- memset(blk, 0, sizeof(blk));
+ memset(blk, 0, 64*sizeof(*blk));
bi->dct_mode = 0;
}
bi->mb[0] = blk[0];
int mb_x, mb_y, c_offset, linesize, y_stride;
uint8_t* y_ptr;
uint8_t* dif;
- uint8_t scratch[64];
+ LOCAL_ALIGNED_8(uint8_t, scratch, [64]);
EncBlockInfo enc_blks[5*DV_MAX_BPM];
PutBitContext pbs[5*DV_MAX_BPM];
PutBitContext* pb;
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;
+ const uint8_t* vsc_pack;
+ int apt, is16_9;
- 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);
*data_size = sizeof(AVFrame);
*(AVFrame*)data = s->picture;
+ /* Determine the codec's sample_aspect ratio from the packet */
+ vsc_pack = buf + 80*5 + 48 + 5;
+ if ( *vsc_pack == dv_video_control ) {
+ apt = buf[4] & 0x07;
+ is16_9 = (vsc_pack && ((vsc_pack[2] & 0x07) == 0x02 || (!apt && (vsc_pack[2] & 0x07) == 0x07)));
+ avctx->sample_aspect_ratio = s->sys->sar[is16_9];
+ }
+
return s->sys->frame_size;
}
#endif /* CONFIG_DVVIDEO_DECODER */
{
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;
#if CONFIG_DVVIDEO_ENCODER
-AVCodec dvvideo_encoder = {
+AVCodec ff_dvvideo_encoder = {
"dvvideo",
- CODEC_TYPE_VIDEO,
+ AVMEDIA_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
#if CONFIG_DVVIDEO_DECODER
-AVCodec dvvideo_decoder = {
+AVCodec ff_dvvideo_decoder = {
"dvvideo",
- CODEC_TYPE_VIDEO,
+ AVMEDIA_TYPE_VIDEO,
CODEC_ID_DVVIDEO,
sizeof(DVVideoContext),
dvvideo_init,
dvvideo_decode_frame,
CODEC_CAP_DR1,
NULL,
+ .max_lowres = 3,
.long_name = NULL_IF_CONFIG_SMALL("DV (Digital Video)"),
};
#endif