Hello!
I tried magicyuv encoding in CinGG, it works with attached option file, and can
be viewed in mplayer
(compiled with latest ffmpeg git) after I modified .mplayer/codecs.conf
cat magicyuv.qt
mov magicyuv
pix_fmt=yuv444p
threads=2
(for some reason first pixel format in encoder's options in CinGG list still
not what i tried to set as pix_fmt, so
just for being extra safe I set it manually)
add this into mplayer's codecs.conf:
videocodec ffmagicyuv
info "FFmpeg Magicyuv"
status working
fourcc M8Y4
;format 0x3459384D
driver ffmpeg
dll "magicyuv"
out YV12,422P,444P,422P10,444P10
After this, mplayer plays this file (24Mb/s for just 1440x900x24bpp_30 fps!)
mplayer /dev/shm/magicyuv.ff -vo x11
MPlayer SVN-r38152-5.5.0 (C) 2000-2019 MPlayer Team
224 audio & 466 video codecs
Playing /dev/shm/magicyuv.ff.
libavformat version 58.33.100 (internal)
libavformat file format detected.
[mov,mp4,m4a,3gp,3g2,mj2 @ 0x575f59e0]Protocol name not provided, cannot
determine if input is local or a network protocol, buffers and access patterns
cannot be configured optimally without knowing the protocol
[lavf] stream 0: video (magicyuv), -vid 0
[lavf] stream 1: audio (pcm_s16le), -aid 0, -alang rus
VIDEO: [M8Y4] 1440x900 24bpp 30.000 fps 197394.6 kbps (24096.0 kbyte/s)
==========================================================================
Opening video decoder: [ffmpeg] FFmpeg's libavcodec codec family
libavcodec version 58.59.102 (internal)
Selected video codec: [ffmagicyuv] vfm: ffmpeg (FFmpeg Magicyuv)
==========================================================================
Clip info:
major_brand: qt
minor_version: 512
compatible_brands: qt
encoder: Lavf58.29.100
Load subtitles in /dev/shm/
==========================================================================
Forced audio codec: mad
Opening audio decoder: [pcm] Uncompressed PCM audio decoder
AUDIO: 48000 Hz, 2 ch, s16le, 1536.0 kbit/100.00% (ratio: 192000->192000)
Selected audio codec: [pcm] afm: pcm (Uncompressed PCM)
==========================================================================
AO: [alsa] 48000Hz 2ch s16le (2 bytes per sample)
Starting playback...
Could not find matching colorspace - retrying with -vf scale...
Opening video filter: [scale]
Movie-Aspect is undefined - no prescaling applied.
[swscaler @ 0x57889140]bicubic scaler, from yuv444p to bgra using MMXEXT
VO: [x11] 1440x900 => 1440x900 BGRA
[VD_FFMPEG] DRI failure.
Movie-Aspect is undefined - no prescaling applied.
VO: [x11] 1440x900 => 1440x900 BGRA
A: 0.2 V: 0.0 A-V: 0.171 ct: 0.000 0/ 0 ??% ??% ??,?% 1 0
[VD_FFMPEG] DRI failure.
A: 30.0 V: 30.0 A-V: 0.027 ct: 0.110 0/ 0 3% 70% 2.2% 15 0
I also tried dvcpro100 encoding, but it probably requires interlaced project
(and patches, of course)....
Just in case you want to play with them, also attached (from ffmpeg mail list
see http://ffmpeg.org/pipermail/ffmpeg-devel/2019-September/249795.html )
mov magicyuv
pix_fmt=yuv444p
threads=2
mov dvvideo
vcodec=dvvideo
pixel_format=yuv422p
flags=+ildct+ilme
b=100000000
aspect=16:9
#threads=3
---
libavcodec/dv.h | 2 ++
libavcodec/dvdec.c | 90 +++++++++++++++++++++++++++++++++++-----------
2 files changed, 72 insertions(+), 20 deletions(-)
diff --git a/libavcodec/dv.h b/libavcodec/dv.h
index 0e97bb200e..7ef5b7c552 100644
--- a/libavcodec/dv.h
+++ b/libavcodec/dv.h
@@ -31,6 +31,7 @@
#include "dv_profile.h"
#include "me_cmp.h"
#include "vlc.h"
+#include "idctdsp.h"
typedef struct DVwork_chunk {
uint16_t buf_offset;
@@ -52,6 +53,7 @@ typedef struct DVVideoContext {
me_cmp_func ildct_cmp;
DVwork_chunk work_chunks[4 * 12 * 27];
uint32_t idct_factor[2 * 4 * 16 * 64];
+ IDCTDSPContext idsp;
int quant_deadzone;
} DVVideoContext;
diff --git a/libavcodec/dvdec.c b/libavcodec/dvdec.c
index 89864f2edc..4345cd9e29 100644
--- a/libavcodec/dvdec.c
+++ b/libavcodec/dvdec.c
@@ -45,7 +45,6 @@
#include "dv_profile_internal.h"
#include "dvdata.h"
#include "get_bits.h"
-#include "idctdsp.h"
#include "internal.h"
#include "put_bits.h"
#include "simple_idct.h"
@@ -177,24 +176,22 @@ static void dv_init_weight_tables(DVVideoContext *ctx, const AVDVProfile *d)
static av_cold int dvvideo_decode_init(AVCodecContext *avctx)
{
DVVideoContext *s = avctx->priv_data;
- IDCTDSPContext idsp;
int i;
- memset(&idsp,0, sizeof(idsp));
- ff_idctdsp_init(&idsp, avctx);
+ ff_idctdsp_init(&s->idsp, avctx);
for (i = 0; i < 64; i++)
- s->dv_zigzag[0][i] = idsp.idct_permutation[ff_zigzag_direct[i]];
+ s->dv_zigzag[0][i] = s->idsp.idct_permutation[ff_zigzag_direct[i]];
if (avctx->lowres){
for (i = 0; i < 64; i++){
int j = ff_dv_zigzag248_direct[i];
- s->dv_zigzag[1][i] = idsp.idct_permutation[(j & 7) + (j & 8) * 4 + (j & 48) / 2];
+ s->dv_zigzag[1][i] = s->idsp.idct_permutation[(j & 7) + (j & 8) * 4 + (j & 48) / 2];
}
}else
memcpy(s->dv_zigzag[1], ff_dv_zigzag248_direct, sizeof(s->dv_zigzag[1]));
- s->idct_put[0] = idsp.idct_put;
+ s->idct_put[0] = s->idsp.idct_put;
s->idct_put[1] = ff_simple_idct248_put;
return ff_dvvideo_init(avctx);
@@ -272,6 +269,49 @@ static inline void bit_copy(PutBitContext *pb, GetBitContext *gb)
put_bits(pb, bits_left, get_bits(gb, bits_left));
}
+static av_always_inline void put_block_8x4(int16_t *block, uint8_t *restrict p, int stride)
+{
+ int i, j;
+ const uint8_t *cm = ff_crop_tab + MAX_NEG_CROP;
+
+ for (i = 0; i < 4; i++) {
+ for (j = 0; j < 8; j++)
+ p[j] = cm[block[j]];
+ block += 8;
+ p += stride;
+ }
+}
+
+static void dv100_idct_put_last_row_field_chroma(DVVideoContext *s, uint8_t *data,
+ int stride, int16_t *blocks)
+{
+ s->idsp.idct(blocks + 0*64);
+ s->idsp.idct(blocks + 1*64);
+
+ put_block_8x4(blocks+0*64, data, stride<<1);
+ put_block_8x4(blocks+0*64 + 4*8, data + 8, stride<<1);
+ put_block_8x4(blocks+1*64, data + stride, stride<<1);
+ put_block_8x4(blocks+1*64 + 4*8, data + 8 + stride, stride<<1);
+}
+
+static void dv100_idct_put_last_row_field_luma(DVVideoContext *s, uint8_t *data,
+ int stride, int16_t *blocks)
+{
+ s->idsp.idct(blocks + 0*64);
+ s->idsp.idct(blocks + 1*64);
+ s->idsp.idct(blocks + 2*64);
+ s->idsp.idct(blocks + 3*64);
+
+ put_block_8x4(blocks+0*64, data, stride<<1);
+ put_block_8x4(blocks+0*64 + 4*8, data + 16, stride<<1);
+ put_block_8x4(blocks+1*64, data + 8, stride<<1);
+ put_block_8x4(blocks+1*64 + 4*8, data + 24, stride<<1);
+ put_block_8x4(blocks+2*64, data + stride, stride<<1);
+ put_block_8x4(blocks+2*64 + 4*8, data + 16 + stride, stride<<1);
+ put_block_8x4(blocks+3*64, data + 8 + stride, stride<<1);
+ put_block_8x4(blocks+3*64 + 4*8, data + 24 + stride, stride<<1);
+}
+
/* mb_x and mb_y are in units of 8 pixels */
static int dv_decode_video_segment(AVCodecContext *avctx, void *arg)
{
@@ -443,14 +483,18 @@ retry:
}
y_ptr = s->frame->data[0] +
((mb_y * s->frame->linesize[0] + mb_x) << log2_blocksize);
- linesize = s->frame->linesize[0] << is_field_mode[mb_index];
- mb[0].idct_put(y_ptr, linesize, block + 0 * 64);
- if (s->sys->video_stype == 4) { /* SD 422 */
- mb[2].idct_put(y_ptr + (1 << log2_blocksize), linesize, block + 2 * 64);
+ if (mb_y == 134 && is_field_mode[mb_index]) {
+ dv100_idct_put_last_row_field_luma(s, y_ptr, s->frame->linesize[0], block);
} else {
- mb[1].idct_put(y_ptr + (1 << log2_blocksize), linesize, block + 1 * 64);
- mb[2].idct_put(y_ptr + y_stride, linesize, block + 2 * 64);
- mb[3].idct_put(y_ptr + (1 << log2_blocksize) + y_stride, linesize, block + 3 * 64);
+ linesize = s->frame->linesize[0] << is_field_mode[mb_index];
+ mb[0].idct_put(y_ptr, linesize, block + 0 * 64);
+ if (s->sys->video_stype == 4) { /* SD 422 */
+ mb[2].idct_put(y_ptr + (1 << log2_blocksize), linesize, block + 2 * 64);
+ } else {
+ mb[1].idct_put(y_ptr + (1 << log2_blocksize), linesize, block + 1 * 64);
+ mb[2].idct_put(y_ptr + y_stride, linesize, block + 2 * 64);
+ mb[3].idct_put(y_ptr + (1 << log2_blocksize) + y_stride, linesize, block + 3 * 64);
+ }
}
mb += 4;
block += 4 * 64;
@@ -478,13 +522,19 @@ retry:
mb++;
} else {
y_stride = (mb_y == 134) ? (1 << log2_blocksize) :
- s->frame->linesize[j] << ((!is_field_mode[mb_index]) * log2_blocksize);
- linesize = s->frame->linesize[j] << is_field_mode[mb_index];
- (mb++)->idct_put(c_ptr, linesize, block);
- block += 64;
- if (s->sys->bpm == 8) {
- (mb++)->idct_put(c_ptr + y_stride, linesize, block);
+ s->frame->linesize[j] << ((!is_field_mode[mb_index]) * log2_blocksize);
+ if (mb_y == 134 && is_field_mode[mb_index]) {
+ dv100_idct_put_last_row_field_chroma(s, c_ptr, s->frame->linesize[j], block);
+ mb += 2;
+ block += 2*64;
+ } else {
+ linesize = s->frame->linesize[j] << is_field_mode[mb_index];
+ (mb++)->idct_put(c_ptr, linesize, block);
block += 64;
+ if (s->sys->bpm == 8) {
+ (mb++)->idct_put(c_ptr + y_stride, linesize, block);
+ block += 64;
+ }
}
}
}
--
2.20.1 (Apple Git-117)---
libavcodec/dvdec.c | 13 ++++++++++---
1 file changed, 10 insertions(+), 3 deletions(-)
diff --git a/libavcodec/dvdec.c b/libavcodec/dvdec.c
index 4345cd9e29..cfa0fb9905 100644
--- a/libavcodec/dvdec.c
+++ b/libavcodec/dvdec.c
@@ -592,12 +592,19 @@ static int dvvideo_decode_frame(AVCodecContext *avctx, void *data,
if ((ret = ff_thread_get_buffer(avctx, &frame, 0)) < 0)
return ret;
- frame.f->interlaced_frame = 1;
- frame.f->top_field_first = 0;
/* Determine the codec's field order from the packet */
if ( *vsc_pack == dv_video_control ) {
- frame.f->top_field_first = !(vsc_pack[3] & 0x40);
+ if (avctx->height == 720) {
+ frame.f->interlaced_frame = 0;
+ frame.f->top_field_first = 0;
+ } else if (avctx->height == 1080) {
+ frame.f->interlaced_frame = 1;
+ frame.f->top_field_first = (vsc_pack[3] & 0x40) == 0x40;
+ } else {
+ frame.f->interlaced_frame = (vsc_pack[3] & 0x10) == 0x10;
+ frame.f->top_field_first = !(vsc_pack[3] & 0x40);
+ }
}
s->buf = buf;
--
2.20.1 (Apple Git-117)---
libavcodec/dv.h | 1 +
libavcodec/dvenc.c | 576 ++++++++++++++++++++++++++++++++++++++++-----
2 files changed, 522 insertions(+), 55 deletions(-)
diff --git a/libavcodec/dv.h b/libavcodec/dv.h
index 7ef5b7c552..0205d72347 100644
--- a/libavcodec/dv.h
+++ b/libavcodec/dv.h
@@ -83,6 +83,7 @@ enum dv_pack_type {
#define DV_PROFILE_IS_HD(p) ((p)->video_stype & 0x10)
#define DV_PROFILE_IS_1080i50(p) (((p)->video_stype == 0x14) && ((p)->dsf == 1))
+#define DV_PROFILE_IS_1080i60(p) (((p)->video_stype == 0x14) && ((p)->dsf == 0))
#define DV_PROFILE_IS_720p50(p) (((p)->video_stype == 0x18) && ((p)->dsf == 1))
/**
diff --git a/libavcodec/dvenc.c b/libavcodec/dvenc.c
index ce2fc75daa..b7a771fa18 100644
--- a/libavcodec/dvenc.c
+++ b/libavcodec/dvenc.c
@@ -60,10 +60,7 @@ static av_cold int dvvideo_encode_init(AVCodecContext *avctx)
ff_dv_print_profiles(avctx, AV_LOG_ERROR);
return AVERROR(EINVAL);
}
- if (avctx->height > 576) {
- av_log(avctx, AV_LOG_ERROR, "DVCPRO HD encoding is not supported.\n");
- return AVERROR_PATCHWELCOME;
- }
+
ret = ff_dv_init_dynamic_tables(s, s->sys);
if (ret < 0) {
av_log(avctx, AV_LOG_ERROR, "Error initializing work tables.\n");
@@ -90,6 +87,7 @@ static av_cold int dvvideo_encode_init(AVCodecContext *avctx)
}
/* bit budget for AC only in 5 MBs */
+static const int vs_total_ac_bits_hd = (68 * 6 + 52*2) * 5;
static const int vs_total_ac_bits = (100 * 4 + 68 * 2) * 5;
static const int mb_area_start[5] = { 1, 6, 21, 43, 64 };
@@ -158,6 +156,11 @@ typedef struct EncBlockInfo {
uint8_t sign[64];
uint8_t partial_bit_count;
uint32_t partial_bit_buffer; /* we can't use uint16_t here */
+ /* used by DV100 only: a copy of the weighted and classified but
+ not-yet-quantized AC coefficients. This is necessary for
+ re-quantizing at different steps. */
+ int16_t save[64];
+ int min_qlevel; /* DV100 only: minimum qlevel (for AC coefficients >255) */
} EncBlockInfo;
static av_always_inline PutBitContext *dv_encode_ac(EncBlockInfo *bi,
@@ -243,13 +246,135 @@ static const int dv_weight_248[64] = {
170627, 170627, 153560, 153560, 165371, 165371, 144651, 144651,
};
-static av_always_inline int dv_init_enc_block(EncBlockInfo *bi, uint8_t *data,
- ptrdiff_t linesize,
- DVVideoContext *s, int bias)
+/* setting this to 1 results in a faster codec but
+ * somewhat lower image quality */
+#define DV100_SACRIFICE_QUALITY_FOR_SPEED 1
+#define DV100_ENABLE_FINER 1
+
+/* pack combination of QNO and CNO into a single 8-bit value */
+#define DV100_MAKE_QLEVEL(qno,cno) ((qno<<2) | (cno))
+#define DV100_QLEVEL_QNO(qlevel) (qlevel>>2)
+#define DV100_QLEVEL_CNO(qlevel) (qlevel&0x3)
+
+#define DV100_NUM_QLEVELS 31
+
+/* The quantization step is determined by a combination of QNO and
+ CNO. We refer to these combinations as "qlevels" (this term is our
+ own, it's not mentioned in the spec). We use CNO, a multiplier on
+ the quantization step, to "fill in the gaps" between quantization
+ steps associated with successive values of QNO. e.g. there is no
+ QNO for a quantization step of 10, but we can use QNO=5 CNO=1 to
+ get the same result. The table below encodes combinations of QNO
+ and CNO in order of increasing quantization coarseness. */
+static const uint8_t dv100_qlevels[DV100_NUM_QLEVELS] = {
+ DV100_MAKE_QLEVEL( 1,0), // 1*1= 1
+ DV100_MAKE_QLEVEL( 1,0), // 1*1= 1
+ DV100_MAKE_QLEVEL( 2,0), // 2*1= 2
+ DV100_MAKE_QLEVEL( 3,0), // 3*1= 3
+ DV100_MAKE_QLEVEL( 4,0), // 4*1= 4
+ DV100_MAKE_QLEVEL( 5,0), // 5*1= 5
+ DV100_MAKE_QLEVEL( 6,0), // 6*1= 6
+ DV100_MAKE_QLEVEL( 7,0), // 7*1= 7
+ DV100_MAKE_QLEVEL( 8,0), // 8*1= 8
+ DV100_MAKE_QLEVEL( 5,1), // 5*2=10
+ DV100_MAKE_QLEVEL( 6,1), // 6*2=12
+ DV100_MAKE_QLEVEL( 7,1), // 7*2=14
+ DV100_MAKE_QLEVEL( 9,0), // 16*1=16
+ DV100_MAKE_QLEVEL(10,0), // 18*1=18
+ DV100_MAKE_QLEVEL(11,0), // 20*1=20
+ DV100_MAKE_QLEVEL(12,0), // 22*1=22
+ DV100_MAKE_QLEVEL(13,0), // 24*1=24
+ DV100_MAKE_QLEVEL(14,0), // 28*1=28
+ DV100_MAKE_QLEVEL( 9,1), // 16*2=32
+ DV100_MAKE_QLEVEL(10,1), // 18*2=36
+ DV100_MAKE_QLEVEL(11,1), // 20*2=40
+ DV100_MAKE_QLEVEL(12,1), // 22*2=44
+ DV100_MAKE_QLEVEL(13,1), // 24*2=48
+ DV100_MAKE_QLEVEL(15,0), // 52*1=52
+ DV100_MAKE_QLEVEL(14,1), // 28*2=56
+ DV100_MAKE_QLEVEL( 9,2), // 16*4=64
+ DV100_MAKE_QLEVEL(10,2), // 18*4=72
+ DV100_MAKE_QLEVEL(11,2), // 20*4=80
+ DV100_MAKE_QLEVEL(12,2), // 22*4=88
+ DV100_MAKE_QLEVEL(13,2), // 24*4=96
+ // ...
+ DV100_MAKE_QLEVEL(15,3), // 52*8=416
+};
+
+/* how much to increase qlevel when we need to compress more coarsely */
+/* this is a tradeoff between encoding speed and space efficiency */
+/* the highest-quality, lowest-speed option it to use 1 for all qlevels. */
+static const uint8_t dv100_qstep_delta[16] = {
+#if DV100_SACRIFICE_QUALITY_FOR_SPEED
+ 0, 2, 0, 5, 0, 0, 0, 0, 1, 6, 0, 0, 0, 0, 0, 0,
+#else
+ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+#endif
+};
+
+static const int dv100_min_bias = 0;
+static const int dv100_chroma_bias = 0;
+static const int dv100_starting_qno = 1;
+static const int dv100_min_qno = 1;
+
+#if DV100_SACRIFICE_QUALITY_FOR_SPEED
+static const int dv100_qlevel_inc = 4;
+#else
+static const int dv100_qlevel_inc = 1;
+#endif
+
+// 1/qstep, shifted up by 16 bits
+static const int dv100_qstep_bits = 16;
+static const int dv100_qstep_inv[16] = {
+ 65536, 65536, 32768, 21845, 16384, 13107, 10923, 9362, 8192, 4096, 3641, 3277, 2979, 2731, 2341, 1260,
+};
+
+/* DV100 weights are pre-zigzagged, inverted and multiplied by 2^(dv100_weight_shift)
+ (in DV100 the AC components are divided by the spec weights) */
+static const int dv100_weight_shift = 16;
+static const int dv_weight_1080[2][64] = {
+ { 8192, 65536, 65536, 61681, 61681, 61681, 58254, 58254,
+ 58254, 58254, 58254, 58254, 55188, 58254, 58254, 55188,
+ 55188, 55188, 55188, 55188, 55188, 24966, 27594, 26214,
+ 26214, 26214, 27594, 24966, 23831, 24385, 25575, 25575,
+ 25575, 25575, 24385, 23831, 23302, 23302, 24966, 24966,
+ 24966, 23302, 23302, 21845, 22795, 24385, 24385, 22795,
+ 21845, 21400, 21845, 23831, 21845, 21400, 10382, 10700,
+ 10700, 10382, 10082, 9620, 10082, 9039, 9039, 8525, },
+ { 8192, 65536, 65536, 61681, 61681, 61681, 41943, 41943,
+ 41943, 41943, 40330, 41943, 40330, 41943, 40330, 40330,
+ 40330, 38836, 38836, 40330, 40330, 24966, 27594, 26214,
+ 26214, 26214, 27594, 24966, 23831, 24385, 25575, 25575,
+ 25575, 25575, 24385, 23831, 11523, 11523, 12483, 12483,
+ 12483, 11523, 11523, 10923, 11275, 12193, 12193, 11275,
+ 10923, 5323, 5490, 5924, 5490, 5323, 5165, 5323,
+ 5323, 5165, 5017, 4788, 5017, 4520, 4520, 4263, }
+};
+
+static const int dv_weight_720[2][64] = {
+ { 8192, 65536, 65536, 61681, 61681, 61681, 58254, 58254,
+ 58254, 58254, 58254, 58254, 55188, 58254, 58254, 55188,
+ 55188, 55188, 55188, 55188, 55188, 24966, 27594, 26214,
+ 26214, 26214, 27594, 24966, 23831, 24385, 25575, 25575,
+ 25575, 25575, 24385, 23831, 15420, 15420, 16644, 16644,
+ 16644, 15420, 15420, 10923, 11398, 12193, 12193, 11398,
+ 10923, 10700, 10923, 11916, 10923, 10700, 5191, 5350,
+ 5350, 5191, 5041, 4810, 5041, 4520, 4520, 4263, },
+ { 8192, 43691, 43691, 40330, 40330, 40330, 29127, 29127,
+ 29127, 29127, 29127, 29127, 27594, 29127, 29127, 27594,
+ 27594, 27594, 27594, 27594, 27594, 12483, 13797, 13107,
+ 13107, 13107, 13797, 12483, 11916, 12193, 12788, 12788,
+ 12788, 12788, 12193, 11916, 5761, 5761, 6242, 6242,
+ 6242, 5761, 5761, 5461, 5638, 5461, 6096, 5638,
+ 5461, 2661, 2745, 2962, 2745, 2661, 2583, 2661,
+ 2661, 2583, 2509, 2394, 2509, 2260, 2260, 2131, }
+};
+
+static av_always_inline int dv_set_class_number_sd(DVVideoContext *s,
+ int16_t *blk, EncBlockInfo *bi,
+ const uint8_t *zigzag_scan,
+ const int *weight, int bias)
{
- const int *weight;
- const uint8_t *zigzag_scan;
- LOCAL_ALIGNED_16(int16_t, 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
@@ -271,31 +396,8 @@ static av_always_inline int dv_init_enc_block(EncBlockInfo *bi, uint8_t *data,
const unsigned deadzone = s->quant_deadzone;
const unsigned threshold = 2 * deadzone;
- av_assert2((((int) blk) & 15) == 0);
-
- bi->area_q[0] =
- bi->area_q[1] =
- bi->area_q[2] =
- bi->area_q[3] = 0;
- bi->partial_bit_count = 0;
- 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);
- s->fdct[bi->dct_mode](blk);
- } 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, 64 * sizeof(*blk));
- bi->dct_mode = 0;
- }
bi->mb[0] = blk[0];
- zigzag_scan = bi->dct_mode ? ff_dv_zigzag248_direct : ff_zigzag_direct;
- weight = bi->dct_mode ? dv_weight_248 : dv_weight_88;
-
for (area = 0; area < 4; area++) {
bi->prev[area] = prev;
bi->bit_size[area] = 1; // 4 areas 4 bits for EOB :)
@@ -350,6 +452,318 @@ static av_always_inline int dv_init_enc_block(EncBlockInfo *bi, uint8_t *data,
bi->bit_size[2] + bi->bit_size[3];
}
+/* this function just copies the DCT coefficients and performs
+ the initial (non-)quantization. */
+static inline void dv_set_class_number_hd(DVVideoContext *s,
+ int16_t *blk, EncBlockInfo *bi,
+ const uint8_t *zigzag_scan,
+ const int *weight, int bias)
+{
+ int i, max = 0;
+
+ /* the first quantization (none at all) */
+ bi->area_q[0] = 1;
+
+ /* LOOP1: weigh AC components and store to save[] */
+ /* (i=0 is the DC component; we only include it to make the
+ number of loop iterations even, for future possible SIMD optimization) */
+ for (i = 0; i < 64; i += 2) {
+ int level0, level1;
+
+ /* get the AC component (in zig-zag order) */
+ level0 = blk[zigzag_scan[i+0]];
+ level1 = blk[zigzag_scan[i+1]];
+
+ /* extract sign and make it the lowest bit */
+ bi->sign[i+0] = (level0>>31)&1;
+ bi->sign[i+1] = (level1>>31)&1;
+
+ /* take absolute value of the level */
+ level0 = FFABS(level0);
+ level1 = FFABS(level1);
+
+ /* weigh it */
+ level0 = (level0*weight[i+0] + 4096 + (1<<17)) >> 18;
+ level1 = (level1*weight[i+1] + 4096 + (1<<17)) >> 18;
+
+ /* save unquantized value */
+ bi->save[i+0] = level0;
+ bi->save[i+1] = level1;
+ }
+
+ /* find max component */
+ for (i = 0; i < 64; i++) {
+ int ac = bi->save[i];
+ if (ac > max)
+ max = ac;
+ }
+
+ /* copy DC component */
+ bi->mb[0] = blk[0];
+
+ /* the EOB code is 4 bits */
+ bi->bit_size[0] = 4;
+ bi->bit_size[1] = bi->bit_size[2] = bi->bit_size[3] = 0;
+
+ /* ensure that no AC coefficients are cut off */
+ bi->min_qlevel = ((max+256) >> 8);
+
+ bi->area_q[0] = 25; /* set to an "impossible" value */
+ bi->cno = 0;
+}
+
+static av_always_inline int dv_init_enc_block(EncBlockInfo* bi, uint8_t *data, int linesize,
+ DVVideoContext *s, int chroma)
+{
+ LOCAL_ALIGNED_16(int16_t, blk, [64]);
+
+ bi->area_q[0] = bi->area_q[1] = bi->area_q[2] = bi->area_q[3] = 0;
+ bi->partial_bit_count = 0;
+ bi->partial_bit_buffer = 0;
+ bi->cur_ac = 0;
+
+ if (data) {
+ if (DV_PROFILE_IS_HD(s->sys)) {
+ s->get_pixels(blk, data, linesize << bi->dct_mode);
+ s->fdct[0](blk);
+ } else {
+ bi->dct_mode = dv_guess_dct_mode(s, data, linesize);
+ s->get_pixels(blk, data, linesize);
+ s->fdct[bi->dct_mode](blk);
+ }
+ } 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, 64*sizeof(*blk));
+ bi->dct_mode = 0;
+ }
+
+ if (DV_PROFILE_IS_HD(s->sys)) {
+ const int *weights;
+ if (s->sys->height == 1080) {
+ weights = dv_weight_1080[chroma];
+ } else { /* 720p */
+ weights = dv_weight_720[chroma];
+ }
+ dv_set_class_number_hd(s, blk, bi,
+ ff_zigzag_direct,
+ weights,
+ dv100_min_bias+chroma*dv100_chroma_bias);
+ } else {
+ dv_set_class_number_sd(s, blk, bi,
+ bi->dct_mode ? ff_dv_zigzag248_direct : ff_zigzag_direct,
+ bi->dct_mode ? dv_weight_248 : dv_weight_88,
+ chroma);
+ }
+
+ return bi->bit_size[0] + bi->bit_size[1] + bi->bit_size[2] + bi->bit_size[3];
+}
+
+/* DV100 quantize
+ Perform quantization by divinding the AC component by the qstep.
+ As an optimization we use a fixed-point integer multiply instead
+ of a divide. */
+static av_always_inline int dv100_quantize(int level, int qsinv)
+{
+ /* this code is equivalent to */
+ /* return (level + qs/2) / qs; */
+
+ return (level * qsinv + 1024 + (1<<(dv100_qstep_bits-1))) >> dv100_qstep_bits;
+
+ /* the extra +1024 is needed to make the rounding come out right. */
+
+ /* I (DJM) have verified that the results are exactly the same as
+ division for level 0-2048 at all QNOs. */
+}
+
+static int dv100_actual_quantize(EncBlockInfo *b, int qlevel)
+{
+ int prev, k, qsinv;
+
+ int qno = DV100_QLEVEL_QNO(dv100_qlevels[qlevel]);
+ int cno = DV100_QLEVEL_CNO(dv100_qlevels[qlevel]);
+
+ if (b->area_q[0] == qno && b->cno == cno)
+ return b->bit_size[0];
+
+ qsinv = dv100_qstep_inv[qno];
+
+ /* record the new qstep */
+ b->area_q[0] = qno;
+ b->cno = cno;
+
+ /* reset encoded size (EOB = 4 bits) */
+ b->bit_size[0] = 4;
+
+ /* visit nonzero components and quantize */
+ prev = 0;
+ for (k = 1; k < 64; k++) {
+ /* quantize */
+ int ac = dv100_quantize(b->save[k], qsinv) >> cno;
+ if (ac) {
+ if (ac > 255)
+ ac = 255;
+ b->mb[k] = ac;
+ b->bit_size[0] += dv_rl2vlc_size(k - prev - 1, ac);
+ b->next[prev] = k;
+ prev = k;
+ }
+ }
+ b->next[prev] = k;
+
+ return b->bit_size[0];
+}
+
+static inline void dv_guess_qnos_hd(EncBlockInfo *blks, int *qnos)
+{
+ EncBlockInfo *b;
+ int min_qlevel[5];
+ int qlevels[5];
+ int size[5];
+ int i, j;
+ /* cache block sizes at hypothetical qlevels */
+ uint16_t size_cache[5*8][DV100_NUM_QLEVELS] = {{0}};
+
+ /* get minimum qlevels */
+ for (i = 0; i < 5; i++) {
+ min_qlevel[i] = 1;
+ for (j = 0; j < 8; j++) {
+ if (blks[8*i+j].min_qlevel > min_qlevel[i])
+ min_qlevel[i] = blks[8*i+j].min_qlevel;
+ }
+ }
+
+ /* initialize sizes */
+ for (i = 0; i < 5; i++) {
+ qlevels[i] = dv100_starting_qno;
+ if (qlevels[i] < min_qlevel[i])
+ qlevels[i] = min_qlevel[i];
+
+ qnos[i] = DV100_QLEVEL_QNO(dv100_qlevels[qlevels[i]]);
+ size[i] = 0;
+ for (j = 0; j < 8; j++) {
+ size_cache[8*i+j][qlevels[i]] = dv100_actual_quantize(&blks[8*i+j], qlevels[i]);
+ size[i] += size_cache[8*i+j][qlevels[i]];
+ }
+ }
+
+ /* must we go coarser? */
+ if (size[0]+size[1]+size[2]+size[3]+size[4] > vs_total_ac_bits_hd) {
+ int largest = size[0] % 5; /* 'random' number */
+
+ do {
+ /* find the macroblock with the lowest qlevel */
+ for (i = 0; i < 5; i++) {
+ if (qlevels[i] < DV100_NUM_QLEVELS-1 &&
+ qlevels[i] < qlevels[largest])
+ largest = i;
+ }
+
+ i = largest;
+ /* ensure that we don't enter infinite loop */
+ largest = (largest+1) % 5;
+
+ if (qlevels[i] >= DV100_NUM_QLEVELS-1) {
+ /* can't quantize any more */
+ continue;
+ }
+
+ /* quantize a little bit more */
+ qlevels[i] += dv100_qlevel_inc;
+ if (qlevels[i] > DV100_NUM_QLEVELS-1)
+ qlevels[i] = DV100_NUM_QLEVELS-1;
+
+ qnos[i] = DV100_QLEVEL_QNO(dv100_qlevels[qlevels[i]]);
+ size[i] = 0;
+
+ /* for each block */
+ b = &blks[8*i];
+ for (j = 0; j < 8; j++, b++) {
+ /* accumulate block size into macroblock */
+ if(size_cache[8*i+j][qlevels[i]] == 0) {
+ /* it is safe to use actual_quantize() here because we only go from finer to coarser,
+ and it saves the final actual_quantize() down below */
+ size_cache[8*i+j][qlevels[i]] = dv100_actual_quantize(b, qlevels[i]);
+ }
+ size[i] += size_cache[8*i+j][qlevels[i]];
+ } /* for each block */
+
+ } while (vs_total_ac_bits_hd < size[0] + size[1] + size[2] + size[3] + size[4] &&
+ (qlevels[0] < DV100_NUM_QLEVELS-1 ||
+ qlevels[1] < DV100_NUM_QLEVELS-1 ||
+ qlevels[2] < DV100_NUM_QLEVELS-1 ||
+ qlevels[3] < DV100_NUM_QLEVELS-1 ||
+ qlevels[4] < DV100_NUM_QLEVELS-1));
+
+ // can we go finer?
+ } else if (DV100_ENABLE_FINER &&
+ size[0]+size[1]+size[2]+size[3]+size[4] < vs_total_ac_bits_hd) {
+ int save_qlevel;
+ int largest = size[0] % 5; /* 'random' number */
+
+ while (qlevels[0] > min_qlevel[0] ||
+ qlevels[1] > min_qlevel[1] ||
+ qlevels[2] > min_qlevel[2] ||
+ qlevels[3] > min_qlevel[3] ||
+ qlevels[4] > min_qlevel[4]) {
+
+ /* find the macroblock with the highest qlevel */
+ for (i = 0; i < 5; i++) {
+ if (qlevels[i] > min_qlevel[i] && qlevels[i] > qlevels[largest])
+ largest = i;
+ }
+
+ i = largest;
+
+ /* ensure that we don't enter infinite loop */
+ largest = (largest+1) % 5;
+
+ if (qlevels[i] <= min_qlevel[i]) {
+ /* can't unquantize any more */
+ continue;
+ }
+ /* quantize a little bit less */
+ save_qlevel = qlevels[i];
+ qlevels[i] -= dv100_qlevel_inc;
+ if (qlevels[i] < min_qlevel[i])
+ qlevels[i] = min_qlevel[i];
+
+ qnos[i] = DV100_QLEVEL_QNO(dv100_qlevels[qlevels[i]]);
+
+ size[i] = 0;
+
+ /* for each block */
+ b = &blks[8*i];
+ for (j = 0; j < 8; j++, b++) {
+ /* accumulate block size into macroblock */
+ if(size_cache[8*i+j][qlevels[i]] == 0) {
+ size_cache[8*i+j][qlevels[i]] = dv100_actual_quantize(b, qlevels[i]);
+ }
+ size[i] += size_cache[8*i+j][qlevels[i]];
+ } /* for each block */
+
+ /* did we bust the limit? */
+ if (vs_total_ac_bits_hd < size[0] + size[1] + size[2] + size[3] + size[4]) {
+ /* go back down and exit */
+ qlevels[i] = save_qlevel;
+ qnos[i] = DV100_QLEVEL_QNO(dv100_qlevels[qlevels[i]]);
+ break;
+ }
+ }
+ }
+
+ /* now do the actual quantization */
+ for (i = 0; i < 5; i++) {
+ /* for each block */
+ b = &blks[8*i];
+ size[i] = 0;
+ for (j = 0; j < 8; j++, b++) {
+ /* accumulate block size into macroblock */
+ size[i] += dv100_actual_quantize(b, qlevels[i]);
+ } /* for each block */
+ }
+}
+
static inline void dv_guess_qnos(EncBlockInfo *blks, int *qnos)
{
int size[5];
@@ -422,6 +836,26 @@ static inline void dv_guess_qnos(EncBlockInfo *blks, int *qnos)
}
}
+/* update all cno values into the blocks, over-writing the old values without
+ touching anything else. (only used for DV100) */
+static inline void dv_revise_cnos(uint8_t *dif, EncBlockInfo *blk, const AVDVProfile *profile)
+{
+ uint8_t *data;
+ int mb_index, i;
+
+ for (mb_index = 0; mb_index < 5; mb_index++) {
+ data = dif + mb_index*80 + 4;
+ for (i = 0; i < profile->bpm; i++) {
+ /* zero out the class number */
+ data[1] &= 0xCF;
+ /* add the new one */
+ data[1] |= blk[profile->bpm*mb_index+i].cno << 4;
+
+ data += profile->block_sizes[i] >> 3;
+ }
+ }
+}
+
static int dv_encode_video_segment(AVCodecContext *avctx, void *arg)
{
DVVideoContext *s = avctx->priv_data;
@@ -430,26 +864,38 @@ static int dv_encode_video_segment(AVCodecContext *avctx, void *arg)
int mb_x, mb_y, c_offset;
ptrdiff_t linesize, y_stride;
uint8_t *y_ptr;
- uint8_t *dif;
+ uint8_t *dif, *p;
LOCAL_ALIGNED_8(uint8_t, scratch, [128]);
EncBlockInfo enc_blks[5 * DV_MAX_BPM];
PutBitContext pbs[5 * DV_MAX_BPM];
PutBitContext *pb;
EncBlockInfo *enc_blk;
int vs_bit_size = 0;
- int qnos[5] = { 15, 15, 15, 15, 15 }; /* No quantization */
+ int qnos[5];
int *qnosp = &qnos[0];
- dif = &s->buf[work_chunk->buf_offset * 80];
+ p = dif = &s->buf[work_chunk->buf_offset * 80];
enc_blk = &enc_blks[0];
for (mb_index = 0; mb_index < 5; mb_index++) {
dv_calculate_mb_xy(s, work_chunk, mb_index, &mb_x, &mb_y);
+ qnos[mb_index] = DV_PROFILE_IS_HD(s->sys) ? 1 : 15;
+
+ y_ptr = s->frame->data[0] + ((mb_y * s->frame->linesize[0] + mb_x) << 3);
+ linesize = s->frame->linesize[0];
+
+ if (s->sys->height == 1080 && mb_y < 134)
+ enc_blk->dct_mode = dv_guess_dct_mode(s, y_ptr, linesize);
+ else
+ enc_blk->dct_mode = 0;
+ for (i = 1; i < 8; i++)
+ enc_blk[i].dct_mode = enc_blk->dct_mode;
+
/* initializing luminance blocks */
if ((s->sys->pix_fmt == AV_PIX_FMT_YUV420P) ||
(s->sys->pix_fmt == AV_PIX_FMT_YUV411P && mb_x >= (704 / 8)) ||
(s->sys->height >= 720 && mb_y != 134)) {
- y_stride = s->frame->linesize[0] << 3;
+ y_stride = s->frame->linesize[0] << (3*!enc_blk->dct_mode);
} else {
y_stride = 16;
}
@@ -478,7 +924,7 @@ static int dv_encode_video_segment(AVCodecContext *avctx, void *arg)
for (j = 2; j; j--) {
uint8_t *c_ptr = s->frame->data[j] + c_offset;
linesize = s->frame->linesize[j];
- y_stride = (mb_y == 134) ? 8 : (s->frame->linesize[j] << 3);
+ y_stride = (mb_y == 134) ? 8 : (s->frame->linesize[j] << (3*!enc_blk->dct_mode));
if (s->sys->pix_fmt == AV_PIX_FMT_YUV411P && mb_x >= (704 / 8)) {
uint8_t *d;
uint8_t *b = scratch;
@@ -506,27 +952,31 @@ static int dv_encode_video_segment(AVCodecContext *avctx, void *arg)
}
}
- if (vs_total_ac_bits < vs_bit_size)
+ if (DV_PROFILE_IS_HD(s->sys)) {
+ /* unconditional */
+ dv_guess_qnos_hd(&enc_blks[0], qnosp);
+ } else if (vs_total_ac_bits < vs_bit_size) {
dv_guess_qnos(&enc_blks[0], qnosp);
+ }
/* DIF encoding process */
for (j = 0; j < 5 * s->sys->bpm;) {
int start_mb = j;
- dif[3] = *qnosp++;
- dif += 4;
+ p[3] = *qnosp++;
+ p += 4;
/* First pass over individual cells only */
for (i = 0; i < s->sys->bpm; i++, j++) {
int sz = s->sys->block_sizes[i] >> 3;
- init_put_bits(&pbs[j], dif, sz);
+ init_put_bits(&pbs[j], p, sz);
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], 1, DV_PROFILE_IS_HD(s->sys) && i ? 1 : enc_blks[j].dct_mode);
put_bits(&pbs[j], 2, enc_blks[j].cno);
dv_encode_ac(&enc_blks[j], &pbs[j], &pbs[j + 1]);
- dif += sz;
+ p += sz;
}
/* Second pass over each MB space */
@@ -559,6 +1009,9 @@ static int dv_encode_video_segment(AVCodecContext *avctx, void *arg)
memset(pbs[j].buf + pos, 0xff, size - pos);
}
+ if (DV_PROFILE_IS_HD(s->sys))
+ dv_revise_cnos(dif, enc_blks, s->sys);
+
return 0;
}
@@ -583,12 +1036,19 @@ static inline int dv_write_pack(enum dv_pack_type pack_id, DVVideoContext *c,
* 2. It is not at all clear what STYPE is used for 4:2:0 PAL
* compression scheme (if any).
*/
+ uint8_t aspect = 0;
int apt = (c->sys->pix_fmt == AV_PIX_FMT_YUV420P ? 0 : 1);
- int fs = c->frame->top_field_first ? 0x00 : 0x40;
+ int fs;
- uint8_t aspect = 0;
- if ((int) (av_q2d(c->avctx->sample_aspect_ratio) *
- c->avctx->width / c->avctx->height * 10) >= 17) /* 16:9 */
+ if (c->avctx->height >= 720)
+ fs = c->avctx->height == 720 || c->frame->top_field_first ? 0x40 : 0x00;
+ else
+ fs = c->frame->top_field_first ? 0x00 : 0x40;
+
+ if (DV_PROFILE_IS_HD(c->sys) ||
+ (int)(av_q2d(c->avctx->sample_aspect_ratio) *
+ c->avctx->width / c->avctx->height * 10) >= 17)
+ /* HD formats are always 16:9 */
aspect = 0x02;
buf[0] = (uint8_t) pack_id;
@@ -643,10 +1103,14 @@ static inline int dv_write_dif_id(enum dv_section_type t, uint8_t chan_num,
uint8_t seq_num, uint8_t dif_num,
uint8_t *buf)
{
+ int fsc = chan_num & 1;
+ int fsp = 1 - (chan_num >> 1);
+
buf[0] = (uint8_t) t; /* Section type */
buf[1] = (seq_num << 4) | /* DIF seq number 0-9 for 525/60; 0-11 for 625/50 */
- (chan_num << 3) | /* FSC: for 50Mb/s 0 - first channel; 1 - second */
- 7; /* reserved -- always 1 */
+ (fsc << 3) | /* FSC: for 50 and 100Mb/s 0 - first channel; 1 - second */
+ (fsp << 2) | /* FSP: for 100Mb/s 1 - channels 0-1; 0 - channels 2-3 */
+ 3; /* reserved -- always 1 */
buf[2] = dif_num; /* DIF block number Video: 0-134, Audio: 0-8 */
return 3;
}
@@ -674,20 +1138,22 @@ static inline int dv_write_ssyb_id(uint8_t syb_num, uint8_t fr, uint8_t *buf)
static void dv_format_frame(DVVideoContext *c, uint8_t *buf)
{
int chan, i, j, k;
+ /* We work with 720p frames split in half. The odd half-frame is chan 2,3 */
+ int chan_offset = 2*(c->sys->height == 720 && c->avctx->frame_number & 1);
for (chan = 0; chan < c->sys->n_difchan; chan++) {
for (i = 0; i < c->sys->difseg_size; i++) {
memset(buf, 0xff, 80 * 6); /* first 6 DIF blocks are for control data */
/* DV header: 1DIF */
- buf += dv_write_dif_id(dv_sect_header, chan, i, 0, buf);
+ buf += dv_write_dif_id(dv_sect_header, chan+chan_offset, i, 0, buf);
buf += dv_write_pack((c->sys->dsf ? dv_header625 : dv_header525),
c, buf);
buf += 72; /* unused bytes */
/* DV subcode: 2DIFs */
for (j = 0; j < 2; j++) {
- buf += dv_write_dif_id(dv_sect_subcode, chan, i, j, buf);
+ buf += dv_write_dif_id(dv_sect_subcode, chan+chan_offset, i, j, buf);
for (k = 0; k < 6; k++)
buf += dv_write_ssyb_id(k, (i < c->sys->difseg_size / 2), buf) + 5;
buf += 29; /* unused bytes */
@@ -695,7 +1161,7 @@ static void dv_format_frame(DVVideoContext *c, uint8_t *buf)
/* DV VAUX: 3DIFS */
for (j = 0; j < 3; j++) {
- buf += dv_write_dif_id(dv_sect_vaux, chan, i, j, buf);
+ buf += dv_write_dif_id(dv_sect_vaux, chan+chan_offset, i, j, buf);
buf += dv_write_pack(dv_video_source, c, buf);
buf += dv_write_pack(dv_video_control, c, buf);
buf += 7 * 5;
@@ -708,10 +1174,10 @@ static void dv_format_frame(DVVideoContext *c, uint8_t *buf)
for (j = 0; j < 135; j++) {
if (j % 15 == 0) {
memset(buf, 0xff, 80);
- buf += dv_write_dif_id(dv_sect_audio, chan, i, j / 15, buf);
+ buf += dv_write_dif_id(dv_sect_audio, chan+chan_offset, i, j/15, buf);
buf += 77; /* audio control & shuffled PCM audio */
}
- buf += dv_write_dif_id(dv_sect_video, chan, i, j, buf);
+ buf += dv_write_dif_id(dv_sect_video, chan+chan_offset, i, j, buf);
buf += 77; /* 1 video macroblock: 1 bytes control
* 4 * 14 bytes Y 8x8 data
* 10 bytes Cr 8x8 data
--
2.20.1 (Apple Git-117)--
Cin mailing list
[email protected]
https://lists.cinelerra-gg.org/mailman/listinfo/cin
