#include "diractab.h"
/* Quantizations above this usually zero coefficients and lower the quality */
-#define MAX_QUANT_INDEX 50
+#define MAX_QUANT_INDEX FF_ARRAY_ELEMS(ff_dirac_qscale_tab)
/* Total range is -COEF_LUT_TAB to +COEFF_LUT_TAB, but total tab size is half
* (COEF_LUT_TAB*MAX_QUANT_INDEX) since the sign is appended during encoding */
#define COEF_LUT_TAB 2048
-/* Per slice quantization bit cost cache */
-#define SLICE_CACHED_QUANTIZERS 30
+/* The limited size resolution of each slice forces us to do this */
+#define SSIZE_ROUND(b) (FFALIGN((b), s->size_scaler) + 4 + s->prefix_bytes)
/* Decides the cutoff point in # of slices to distribute the leftover bytes */
#define SLICE_REDIST_TOTAL 150
+typedef struct VC2BaseVideoFormat {
+ enum AVPixelFormat pix_fmt;
+ AVRational time_base;
+ int width, height, interlaced, level;
+ const char *name;
+} VC2BaseVideoFormat;
+
+static const VC2BaseVideoFormat base_video_fmts[] = {
+ { 0 }, /* Custom format, here just to make indexing equal to base_vf */
+ { AV_PIX_FMT_YUV420P, { 1001, 15000 }, 176, 120, 0, 1, "QSIF525" },
+ { AV_PIX_FMT_YUV420P, { 2, 25 }, 176, 144, 0, 1, "QCIF" },
+ { AV_PIX_FMT_YUV420P, { 1001, 15000 }, 352, 240, 0, 1, "SIF525" },
+ { AV_PIX_FMT_YUV420P, { 2, 25 }, 352, 288, 0, 1, "CIF" },
+ { AV_PIX_FMT_YUV420P, { 1001, 15000 }, 704, 480, 0, 1, "4SIF525" },
+ { AV_PIX_FMT_YUV420P, { 2, 25 }, 704, 576, 0, 1, "4CIF" },
+
+ { AV_PIX_FMT_YUV422P10, { 1001, 30000 }, 720, 480, 1, 2, "SD480I-60" },
+ { AV_PIX_FMT_YUV422P10, { 1, 25 }, 720, 576, 1, 2, "SD576I-50" },
+
+ { AV_PIX_FMT_YUV422P10, { 1001, 60000 }, 1280, 720, 0, 3, "HD720P-60" },
+ { AV_PIX_FMT_YUV422P10, { 1, 50 }, 1280, 720, 0, 3, "HD720P-50" },
+ { AV_PIX_FMT_YUV422P10, { 1001, 30000 }, 1920, 1080, 1, 3, "HD1080I-60" },
+ { AV_PIX_FMT_YUV422P10, { 1, 25 }, 1920, 1080, 1, 3, "HD1080I-50" },
+ { AV_PIX_FMT_YUV422P10, { 1001, 60000 }, 1920, 1080, 1, 3, "HD1080P-60" },
+ { AV_PIX_FMT_YUV422P10, { 1, 50 }, 1920, 1080, 1, 3, "HD1080P-50" },
+
+ { AV_PIX_FMT_YUV444P12, { 1, 24 }, 2048, 1080, 0, 4, "DC2K" },
+ { AV_PIX_FMT_YUV444P12, { 1, 24 }, 4096, 2160, 0, 5, "DC4K" },
+
+ { AV_PIX_FMT_YUV422P10, { 1001, 60000 }, 3840, 2160, 0, 6, "UHDTV 4K-60" },
+ { AV_PIX_FMT_YUV422P10, { 1, 50 }, 3840, 2160, 0, 6, "UHDTV 4K-50" },
+
+ { AV_PIX_FMT_YUV422P10, { 1001, 60000 }, 7680, 4320, 0, 7, "UHDTV 8K-60" },
+ { AV_PIX_FMT_YUV422P10, { 1, 50 }, 7680, 4320, 0, 7, "UHDTV 8K-50" },
+
+ { AV_PIX_FMT_YUV422P10, { 1001, 24000 }, 1920, 1080, 0, 3, "HD1080P-24" },
+ { AV_PIX_FMT_YUV422P10, { 1001, 30000 }, 720, 486, 1, 2, "SD Pro486" },
+};
+static const int base_video_fmts_len = FF_ARRAY_ELEMS(base_video_fmts);
+
enum VC2_QM {
VC2_QM_DEF = 0,
VC2_QM_COL,
ptrdiff_t coef_stride;
} Plane;
-typedef struct BitCostCache {
- int bits;
- int quantizer;
-} BitCostCache;
-
typedef struct SliceArgs {
PutBitContext pb;
- BitCostCache cache[SLICE_CACHED_QUANTIZERS];
- int cached_results;
+ int cache[MAX_QUANT_INDEX];
void *ctx;
int x;
int y;
int quant_idx;
int bits_ceil;
int bits_floor;
- int bytes_left;
int bytes;
} SliceArgs;
/* For conversion from unsigned pixel values to signed */
int diff_offset;
int bpp;
+ int bpp_idx;
/* Picture number */
uint32_t picture_number;
/* Quantization matrix */
uint8_t quant[MAX_DWT_LEVELS][4];
+ int custom_quant_matrix;
/* Coefficient LUT */
uint32_t *coef_lut_val;
enum DiracParseCodes last_parse_code;
} VC2EncContext;
-static av_always_inline void put_padding(PutBitContext *pb, int bytes)
-{
- int bits = bytes*8;
- if (!bits)
- return;
- while (bits > 31) {
- put_bits(pb, 31, 0);
- bits -= 31;
- }
- if (bits)
- put_bits(pb, bits, 0);
-}
-
static av_always_inline void put_vc2_ue_uint(PutBitContext *pb, uint32_t val)
{
int i;
/* VC-2 11.3.8 - signal_range() */
static void encode_signal_range(VC2EncContext *s)
{
- int idx;
- AVCodecContext *avctx = s->avctx;
- const AVPixFmtDescriptor *fmt = av_pix_fmt_desc_get(avctx->pix_fmt);
- const int depth = fmt->comp[0].depth;
- if (depth == 8 && avctx->color_range == AVCOL_RANGE_JPEG) {
- idx = 1;
- s->bpp = 1;
- s->diff_offset = 128;
- } else if (depth == 8 && (avctx->color_range == AVCOL_RANGE_MPEG ||
- avctx->color_range == AVCOL_RANGE_UNSPECIFIED)) {
- idx = 2;
- s->bpp = 1;
- s->diff_offset = 128;
- } else if (depth == 10) {
- idx = 3;
- s->bpp = 2;
- s->diff_offset = 512;
- } else {
- idx = 4;
- s->bpp = 2;
- s->diff_offset = 2048;
- }
put_bits(&s->pb, 1, !s->strict_compliance);
if (!s->strict_compliance)
- put_vc2_ue_uint(&s->pb, idx);
+ put_vc2_ue_uint(&s->pb, s->bpp_idx);
}
/* VC-2 11.3.9 - color_spec() */
{ 0, 0, 0, 0}
};
-static void init_custom_qm(VC2EncContext *s)
+static void init_quant_matrix(VC2EncContext *s)
{
int level, orientation;
+ if (s->wavelet_depth <= 4 && s->quant_matrix == VC2_QM_DEF) {
+ s->custom_quant_matrix = 0;
+ for (level = 0; level < s->wavelet_depth; level++) {
+ s->quant[level][0] = ff_dirac_default_qmat[s->wavelet_idx][level][0];
+ s->quant[level][1] = ff_dirac_default_qmat[s->wavelet_idx][level][1];
+ s->quant[level][2] = ff_dirac_default_qmat[s->wavelet_idx][level][2];
+ s->quant[level][3] = ff_dirac_default_qmat[s->wavelet_idx][level][3];
+ }
+ return;
+ }
+
+ s->custom_quant_matrix = 1;
+
if (s->quant_matrix == VC2_QM_DEF) {
for (level = 0; level < s->wavelet_depth; level++) {
for (orientation = 0; orientation < 4; orientation++) {
/* VC-2 12.3.4.2 - quant_matrix() */
static void encode_quant_matrix(VC2EncContext *s)
{
- int level, custom_quant_matrix = 0;
- if (s->wavelet_depth > 4 || s->quant_matrix != VC2_QM_DEF)
- custom_quant_matrix = 1;
- put_bits(&s->pb, 1, custom_quant_matrix);
- if (custom_quant_matrix) {
- init_custom_qm(s);
+ int level;
+ put_bits(&s->pb, 1, s->custom_quant_matrix);
+ if (s->custom_quant_matrix) {
put_vc2_ue_uint(&s->pb, s->quant[0][0]);
for (level = 0; level < s->wavelet_depth; level++) {
put_vc2_ue_uint(&s->pb, s->quant[level][1]);
put_vc2_ue_uint(&s->pb, s->quant[level][2]);
put_vc2_ue_uint(&s->pb, s->quant[level][3]);
}
- } else {
- for (level = 0; level < s->wavelet_depth; level++) {
- s->quant[level][0] = ff_dirac_default_qmat[s->wavelet_idx][level][0];
- s->quant[level][1] = ff_dirac_default_qmat[s->wavelet_idx][level][1];
- s->quant[level][2] = ff_dirac_default_qmat[s->wavelet_idx][level][2];
- s->quant[level][3] = ff_dirac_default_qmat[s->wavelet_idx][level][3];
- }
}
}
{
encode_transform_params(s);
avpriv_align_put_bits(&s->pb);
- /* Continued after DWT in encode_transform_data() */
}
/* VC-2 12 - picture_parse() */
const int neg = coeff[x] < 0;
uint32_t c_abs = FFABS(coeff[x]);
if (c_abs < COEF_LUT_TAB) {
- const uint8_t len = len_lut[c_abs];
- if (len == 1)
- put_bits(pb, 1, 1);
- else
- put_bits(pb, len + 1, (val_lut[c_abs] << 1) | neg);
+ put_bits(pb, len_lut[c_abs], val_lut[c_abs] | neg);
} else {
c_abs = QUANT(c_abs, qfactor);
put_vc2_ue_uint(pb, c_abs);
}
}
-static int count_hq_slice(VC2EncContext *s, BitCostCache *cache,
- int *cached_results, int slice_x, int slice_y,
- int quant_idx)
+static int count_hq_slice(SliceArgs *slice, int quant_idx)
{
- int i, x, y;
+ int x, y;
uint8_t quants[MAX_DWT_LEVELS][4];
int bits = 0, p, level, orientation;
+ VC2EncContext *s = slice->ctx;
- if (cache && *cached_results)
- for (i = 0; i < *cached_results; i++)
- if (cache[i].quantizer == quant_idx)
- return cache[i].bits;
+ if (slice->cache[quant_idx])
+ return slice->cache[quant_idx];
bits += 8*s->prefix_bytes;
bits += 8; /* quant_idx */
const uint8_t *len_lut = &s->coef_lut_len[q_idx*COEF_LUT_TAB];
const int qfactor = ff_dirac_qscale_tab[q_idx];
- const int left = b->width * slice_x / s->num_x;
- const int right = b->width *(slice_x+1) / s->num_x;
- const int top = b->height * slice_y / s->num_y;
- const int bottom = b->height *(slice_y+1) / s->num_y;
+ const int left = b->width * slice->x / s->num_x;
+ const int right = b->width *(slice->x+1) / s->num_x;
+ const int top = b->height * slice->y / s->num_y;
+ const int bottom = b->height *(slice->y+1) / s->num_y;
dwtcoef *buf = b->buf + top * b->stride;
for (x = left; x < right; x++) {
uint32_t c_abs = FFABS(buf[x]);
if (c_abs < COEF_LUT_TAB) {
- const int len = len_lut[c_abs];
- bits += len + (len != 1);
+ bits += len_lut[c_abs];
} else {
c_abs = QUANT(c_abs, qfactor);
bits += count_vc2_ue_uint(c_abs);
bits += pad_c*8;
}
- if (cache) {
- cache[*cached_results].quantizer = quant_idx;
- cache[*cached_results].bits = bits;
- *cached_results = FFMIN(*cached_results + 1, SLICE_CACHED_QUANTIZERS);
- }
+ slice->cache[quant_idx] = bits;
return bits;
}
{
SliceArgs *slice_dat = arg;
VC2EncContext *s = slice_dat->ctx;
- const int sx = slice_dat->x;
- const int sy = slice_dat->y;
- int bits_last = INT_MAX, quant_buf[2] = {-1, -1};
- int quant = slice_dat->quant_idx, range = quant/5;
const int top = slice_dat->bits_ceil;
const int bottom = slice_dat->bits_floor;
- int bits = count_hq_slice(s, slice_dat->cache, &slice_dat->cached_results,
- sx, sy, quant);
- range -= range & 1; /* Make it an even number */
+ int quant_buf[2] = {-1, -1};
+ int quant = slice_dat->quant_idx, step = 1;
+ int bits_last, bits = count_hq_slice(slice_dat, quant);
while ((bits > top) || (bits < bottom)) {
- range *= bits > top ? +1 : -1;
- quant = av_clip(quant + range, 0, s->q_ceil);
- bits = count_hq_slice(s, slice_dat->cache, &slice_dat->cached_results,
- sx, sy, quant);
- range = av_clip(range/2, 1, s->q_ceil);
+ const int signed_step = bits > top ? +step : -step;
+ quant = av_clip(quant + signed_step, 0, s->q_ceil-1);
+ bits = count_hq_slice(slice_dat, quant);
if (quant_buf[1] == quant) {
- quant = bits_last < bits ? quant_buf[0] : quant;
- bits = bits_last < bits ? bits_last : bits;
+ quant = FFMAX(quant_buf[0], quant);
+ bits = quant == quant_buf[0] ? bits_last : bits;
break;
}
+ step = av_clip(step/2, 1, (s->q_ceil-1)/2);
quant_buf[1] = quant_buf[0];
quant_buf[0] = quant;
- bits_last = bits;
+ bits_last = bits;
}
- slice_dat->quant_idx = av_clip(quant, 0, s->q_ceil);
- slice_dat->bytes = FFALIGN((bits >> 3), s->size_scaler) + 4 + s->prefix_bytes;
- slice_dat->bytes_left = s->slice_max_bytes - slice_dat->bytes;
-
+ slice_dat->quant_idx = av_clip(quant, 0, s->q_ceil-1);
+ slice_dat->bytes = SSIZE_ROUND(bits >> 3);
return 0;
}
-static void calc_slice_sizes(VC2EncContext *s)
+static int calc_slice_sizes(VC2EncContext *s)
{
- int slice_x, slice_y;
+ int i, j, slice_x, slice_y, bytes_left = 0;
+ int bytes_top[SLICE_REDIST_TOTAL] = {0};
+ int64_t total_bytes_needed = 0;
+ int slice_redist_range = FFMIN(SLICE_REDIST_TOTAL, s->num_x*s->num_y);
SliceArgs *enc_args = s->slice_args;
+ SliceArgs *top_loc[SLICE_REDIST_TOTAL] = {NULL};
+
+ init_quant_matrix(s);
for (slice_y = 0; slice_y < s->num_y; slice_y++) {
for (slice_x = 0; slice_x < s->num_x; slice_x++) {
SliceArgs *args = &enc_args[s->num_x*slice_y + slice_x];
args->ctx = s;
- args->x = slice_x;
- args->y = slice_y;
- args->cached_results = 0;
- args->bits_ceil = s->slice_max_bytes << 3;
+ args->x = slice_x;
+ args->y = slice_y;
+ args->bits_ceil = s->slice_max_bytes << 3;
args->bits_floor = s->slice_min_bytes << 3;
+ memset(args->cache, 0, s->q_ceil*sizeof(*args->cache));
}
}
- /* Determine quantization indices and bytes per slice */
+ /* First pass - determine baseline slice sizes w.r.t. max_slice_size */
s->avctx->execute(s->avctx, rate_control, enc_args, NULL, s->num_x*s->num_y,
sizeof(SliceArgs));
+
+ for (i = 0; i < s->num_x*s->num_y; i++) {
+ SliceArgs *args = &enc_args[i];
+ bytes_left += s->slice_max_bytes - args->bytes;
+ for (j = 0; j < slice_redist_range; j++) {
+ if (args->bytes > bytes_top[j]) {
+ bytes_top[j] = args->bytes;
+ top_loc[j] = args;
+ break;
+ }
+ }
+ }
+
+ /* Second pass - distribute leftover bytes */
+ while (1) {
+ int distributed = 0;
+ for (i = 0; i < slice_redist_range; i++) {
+ SliceArgs *args;
+ int bits, bytes, diff, prev_bytes, new_idx;
+ if (bytes_left <= 0)
+ break;
+ if (!top_loc[i] || !top_loc[i]->quant_idx)
+ break;
+ args = top_loc[i];
+ prev_bytes = args->bytes;
+ new_idx = FFMAX(args->quant_idx - 1, 0);
+ bits = count_hq_slice(args, new_idx);
+ bytes = SSIZE_ROUND(bits >> 3);
+ diff = bytes - prev_bytes;
+ if ((bytes_left - diff) > 0) {
+ args->quant_idx = new_idx;
+ args->bytes = bytes;
+ bytes_left -= diff;
+ distributed++;
+ }
+ }
+ if (!distributed)
+ break;
+ }
+
+ for (i = 0; i < s->num_x*s->num_y; i++) {
+ SliceArgs *args = &enc_args[i];
+ total_bytes_needed += args->bytes;
+ s->q_avg = (s->q_avg + args->quant_idx)/2;
+ }
+
+ return total_bytes_needed;
}
/* VC-2 13.5.3 - hq_slice */
uint8_t quants[MAX_DWT_LEVELS][4];
int p, level, orientation;
- avpriv_align_put_bits(pb);
- put_padding(pb, s->prefix_bytes);
+ skip_put_bytes(pb, s->prefix_bytes);
put_bits(pb, 8, quant_idx);
/* Slice quantization (slice_quantizers() in the specs) */
pad_c = (pad_s*s->size_scaler) - bytes_len;
}
pb->buf[bytes_start] = pad_s;
- put_padding(pb, pad_c);
+ flush_put_bits(pb);
+ skip_put_bytes(pb, pad_c);
}
return 0;
static int encode_slices(VC2EncContext *s)
{
uint8_t *buf;
- int i, slice_x, slice_y, skip = 0;
- int bytes_left = 0;
+ int slice_x, slice_y, skip = 0;
SliceArgs *enc_args = s->slice_args;
- int bytes_top[SLICE_REDIST_TOTAL] = {0};
- SliceArgs *top_loc[SLICE_REDIST_TOTAL] = {NULL};
-
avpriv_align_put_bits(&s->pb);
flush_put_bits(&s->pb);
buf = put_bits_ptr(&s->pb);
for (slice_y = 0; slice_y < s->num_y; slice_y++) {
for (slice_x = 0; slice_x < s->num_x; slice_x++) {
SliceArgs *args = &enc_args[s->num_x*slice_y + slice_x];
- bytes_left += args->bytes_left;
- for (i = 0; i < FFMIN(SLICE_REDIST_TOTAL, s->num_x*s->num_y); i++) {
- if (args->bytes > bytes_top[i]) {
- bytes_top[i] = args->bytes;
- top_loc[i] = args;
- break;
- }
- }
- }
- }
-
- while (1) {
- int distributed = 0;
- for (i = 0; i < FFMIN(SLICE_REDIST_TOTAL, s->num_x*s->num_y); i++) {
- SliceArgs *args;
- int bits, bytes, diff, prev_bytes, new_idx;
- if (bytes_left <= 0)
- break;
- if (!top_loc[i] || !top_loc[i]->quant_idx)
- break;
- args = top_loc[i];
- prev_bytes = args->bytes;
- new_idx = av_clip(args->quant_idx - 1, 0, s->q_ceil);
- bits = count_hq_slice(s, args->cache, &args->cached_results,
- args->x, args->y, new_idx);
- bytes = FFALIGN((bits >> 3), s->size_scaler) + 4 + s->prefix_bytes;
- diff = bytes - prev_bytes;
- if ((bytes_left - diff) >= 0) {
- args->quant_idx = new_idx;
- args->bytes = bytes;
- bytes_left -= diff;
- distributed++;
- }
- }
- if (!distributed)
- break;
- }
-
- for (slice_y = 0; slice_y < s->num_y; slice_y++) {
- for (slice_x = 0; slice_x < s->num_x; slice_x++) {
- SliceArgs *args = &enc_args[s->num_x*slice_y + slice_x];
- init_put_bits(&args->pb, buf + skip, args->bytes);
- s->q_avg = (s->q_avg + args->quant_idx)/2;
+ init_put_bits(&args->pb, buf + skip, args->bytes+s->prefix_bytes);
skip += args->bytes;
}
}
return 0;
}
-static void encode_frame(VC2EncContext *s, const AVFrame *frame,
- const char *aux_data, int field)
+static int encode_frame(VC2EncContext *s, AVPacket *avpkt, const AVFrame *frame,
+ const char *aux_data, const int header_size, int field)
{
- int i;
+ int i, ret;
+ int64_t max_frame_bytes;
+
+ /* Threaded DWT transform */
+ for (i = 0; i < 3; i++) {
+ s->transform_args[i].ctx = s;
+ s->transform_args[i].field = field;
+ s->transform_args[i].plane = &s->plane[i];
+ s->transform_args[i].idata = frame->data[i];
+ s->transform_args[i].istride = frame->linesize[i];
+ }
+ s->avctx->execute(s->avctx, dwt_plane, s->transform_args, NULL, 3,
+ sizeof(TransformArgs));
+
+ /* Calculate per-slice quantizers and sizes */
+ max_frame_bytes = header_size + calc_slice_sizes(s);
+
+ if (field < 2) {
+ ret = ff_alloc_packet2(s->avctx, avpkt,
+ max_frame_bytes << s->interlaced,
+ max_frame_bytes << s->interlaced);
+ if (ret) {
+ av_log(s->avctx, AV_LOG_ERROR, "Error getting output packet.\n");
+ return ret;
+ }
+ init_put_bits(&s->pb, avpkt->data, avpkt->size);
+ }
/* Sequence header */
encode_parse_info(s, DIRAC_PCODE_SEQ_HEADER);
encode_parse_info(s, DIRAC_PCODE_PICTURE_HQ);
encode_picture_start(s);
- for (i = 0; i < 3; i++) {
- s->transform_args[i].ctx = s;
- s->transform_args[i].field = field;
- s->transform_args[i].plane = &s->plane[i];
- s->transform_args[i].idata = frame->data[i];
- s->transform_args[i].istride = frame->linesize[i];
- }
-
- /* Do a DWT transform */
- s->avctx->execute(s->avctx, dwt_plane, s->transform_args, NULL, 3,
- sizeof(TransformArgs));
-
- /* Calculate per-slice quantizers and sizes */
- calc_slice_sizes(s);
-
- /* Init planes and encode slices */
+ /* Encode slices */
encode_slices(s);
/* End sequence */
encode_parse_info(s, DIRAC_PCODE_END_SEQ);
+
+ return 0;
}
static av_cold int vc2_encode_frame(AVCodecContext *avctx, AVPacket *avpkt,
- const AVFrame *frame, int *got_packet_ptr)
+ const AVFrame *frame, int *got_packet)
{
- int ret;
- int max_frame_bytes, sig_size = 256;
+ int ret = 0;
+ int sig_size = 256;
VC2EncContext *s = avctx->priv_data;
const char aux_data[] = LIBAVCODEC_IDENT;
const int aux_data_size = sizeof(aux_data);
const int header_size = 100 + aux_data_size;
- int64_t r_bitrate = avctx->bit_rate >> (s->interlaced);
+ int64_t max_frame_bytes, r_bitrate = avctx->bit_rate >> (s->interlaced);
s->avctx = avctx;
- s->size_scaler = 1;
+ s->size_scaler = 2;
s->prefix_bytes = 0;
s->last_parse_code = 0;
s->next_parse_offset = 0;
/* Rate control */
max_frame_bytes = (av_rescale(r_bitrate, s->avctx->time_base.num,
s->avctx->time_base.den) >> 3) - header_size;
+ s->slice_max_bytes = av_rescale(max_frame_bytes, 1, s->num_x*s->num_y);
/* Find an appropriate size scaler */
while (sig_size > 255) {
- s->slice_max_bytes = FFALIGN(av_rescale(max_frame_bytes, 1,
- s->num_x*s->num_y), s->size_scaler);
- s->slice_max_bytes += 4 + s->prefix_bytes;
- sig_size = s->slice_max_bytes/s->size_scaler; /* Signalled slize size */
+ int r_size = SSIZE_ROUND(s->slice_max_bytes);
+ sig_size = r_size/s->size_scaler; /* Signalled slize size */
s->size_scaler <<= 1;
}
+ s->slice_max_bytes = SSIZE_ROUND(s->slice_max_bytes);
s->slice_min_bytes = s->slice_max_bytes - s->slice_max_bytes*(s->tolerance/100.0f);
- ret = ff_alloc_packet2(avctx, avpkt, max_frame_bytes*2, 0);
- if (ret < 0) {
- av_log(avctx, AV_LOG_ERROR, "Error getting output packet.\n");
+ ret = encode_frame(s, avpkt, frame, aux_data, header_size, s->interlaced);
+ if (ret)
return ret;
- } else {
- init_put_bits(&s->pb, avpkt->data, avpkt->size);
+ if (s->interlaced) {
+ ret = encode_frame(s, avpkt, frame, aux_data, header_size, 2);
+ if (ret)
+ return ret;
}
- encode_frame(s, frame, aux_data, s->interlaced);
- if (s->interlaced)
- encode_frame(s, frame, NULL, 2);
-
flush_put_bits(&s->pb);
avpkt->size = put_bits_count(&s->pb) >> 3;
- *got_packet_ptr = 1;
+ *got_packet = 1;
return 0;
}
return 0;
}
-static int minimum_frame_bits(VC2EncContext *s)
-{
- int slice_x, slice_y, bits = 0;
- s->size_scaler = 64;
- for (slice_y = 0; slice_y < s->num_y; slice_y++) {
- for (slice_x = 0; slice_x < s->num_x; slice_x++) {
- bits += count_hq_slice(s, NULL, NULL, slice_x, slice_y, s->q_ceil);
- }
- }
- return bits;
-}
-
static av_cold int vc2_encode_init(AVCodecContext *avctx)
{
Plane *p;
SubBand *b;
int i, j, level, o, shift;
- int64_t bits_per_frame, min_bits_per_frame;
+ const AVPixFmtDescriptor *fmt = av_pix_fmt_desc_get(avctx->pix_fmt);
+ const int depth = fmt->comp[0].depth;
VC2EncContext *s = avctx->priv_data;
s->picture_number = 0;
s->interlaced = !((avctx->field_order == AV_FIELD_UNKNOWN) ||
(avctx->field_order == AV_FIELD_PROGRESSIVE));
- if (avctx->pix_fmt == AV_PIX_FMT_YUV422P10) {
- if (avctx->width == 1280 && avctx->height == 720) {
- s->level = 3;
- if (avctx->time_base.num == 1001 && avctx->time_base.den == 60000)
- s->base_vf = 9;
- if (avctx->time_base.num == 1 && avctx->time_base.den == 50)
- s->base_vf = 10;
- } else if (avctx->width == 1920 && avctx->height == 1080) {
- s->level = 3;
- if (s->interlaced) {
- if (avctx->time_base.num == 1001 && avctx->time_base.den == 30000)
- s->base_vf = 11;
- if (avctx->time_base.num == 1 && avctx->time_base.den == 50)
- s->base_vf = 12;
- } else {
- if (avctx->time_base.num == 1001 && avctx->time_base.den == 60000)
- s->base_vf = 13;
- if (avctx->time_base.num == 1 && avctx->time_base.den == 50)
- s->base_vf = 14;
- if (avctx->time_base.num == 1001 && avctx->time_base.den == 24000)
- s->base_vf = 21;
- }
- } else if (avctx->width == 3840 && avctx->height == 2160) {
- s->level = 6;
- if (avctx->time_base.num == 1001 && avctx->time_base.den == 60000)
- s->base_vf = 17;
- if (avctx->time_base.num == 1 && avctx->time_base.den == 50)
- s->base_vf = 18;
- }
- }
-
- if (s->interlaced && s->base_vf <= 0) {
- av_log(avctx, AV_LOG_ERROR, "Interlacing not supported with non standard formats!\n");
- return AVERROR_UNKNOWN;
+ for (i = 0; i < base_video_fmts_len; i++) {
+ const VC2BaseVideoFormat *fmt = &base_video_fmts[i];
+ if (avctx->pix_fmt != fmt->pix_fmt)
+ continue;
+ if (avctx->time_base.num != fmt->time_base.num)
+ continue;
+ if (avctx->time_base.den != fmt->time_base.den)
+ continue;
+ if (avctx->width != fmt->width)
+ continue;
+ if (avctx->height != fmt->height)
+ continue;
+ if (s->interlaced != fmt->interlaced)
+ continue;
+ s->base_vf = i;
+ s->level = base_video_fmts[i].level;
+ break;
}
if (s->interlaced)
return AVERROR_UNKNOWN;
}
} else {
- av_log(avctx, AV_LOG_INFO, "Selected base video format = %i\n", s->base_vf);
+ av_log(avctx, AV_LOG_INFO, "Selected base video format = %i (%s)\n",
+ s->base_vf, base_video_fmts[s->base_vf].name);
}
+ /* Chroma subsampling */
avcodec_get_chroma_sub_sample(avctx->pix_fmt, &s->chroma_x_shift, &s->chroma_y_shift);
+ /* Bit depth and color range index */
+ if (depth == 8 && avctx->color_range == AVCOL_RANGE_JPEG) {
+ s->bpp = 1;
+ s->bpp_idx = 1;
+ s->diff_offset = 128;
+ } else if (depth == 8 && (avctx->color_range == AVCOL_RANGE_MPEG ||
+ avctx->color_range == AVCOL_RANGE_UNSPECIFIED)) {
+ s->bpp = 1;
+ s->bpp_idx = 2;
+ s->diff_offset = 128;
+ } else if (depth == 10) {
+ s->bpp = 2;
+ s->bpp_idx = 3;
+ s->diff_offset = 512;
+ } else {
+ s->bpp = 2;
+ s->bpp_idx = 4;
+ s->diff_offset = 2048;
+ }
+
/* Planes initialization */
for (i = 0; i < 3; i++) {
int w, h;
s->num_x = s->plane[0].dwt_width/s->slice_width;
s->num_y = s->plane[0].dwt_height/s->slice_height;
- s->slice_args = av_malloc(s->num_x*s->num_y*sizeof(SliceArgs));
+ s->slice_args = av_calloc(s->num_x*s->num_y, sizeof(SliceArgs));
if (!s->slice_args)
goto alloc_fail;
/* Lookup tables */
- s->coef_lut_len = av_malloc(COEF_LUT_TAB*s->q_ceil*sizeof(*s->coef_lut_len));
+ s->coef_lut_len = av_malloc(COEF_LUT_TAB*(s->q_ceil+1)*sizeof(*s->coef_lut_len));
if (!s->coef_lut_len)
goto alloc_fail;
- s->coef_lut_val = av_malloc(COEF_LUT_TAB*s->q_ceil*sizeof(*s->coef_lut_val));
+ s->coef_lut_val = av_malloc(COEF_LUT_TAB*(s->q_ceil+1)*sizeof(*s->coef_lut_val));
if (!s->coef_lut_val)
goto alloc_fail;
for (i = 0; i < s->q_ceil; i++) {
+ uint8_t *len_lut = &s->coef_lut_len[i*COEF_LUT_TAB];
+ uint32_t *val_lut = &s->coef_lut_val[i*COEF_LUT_TAB];
for (j = 0; j < COEF_LUT_TAB; j++) {
- uint8_t *len_lut = &s->coef_lut_len[i*COEF_LUT_TAB];
- uint32_t *val_lut = &s->coef_lut_val[i*COEF_LUT_TAB];
get_vc2_ue_uint(QUANT(j, ff_dirac_qscale_tab[i]),
&len_lut[j], &val_lut[j]);
+ if (len_lut[j] != 1) {
+ len_lut[j] += 1;
+ val_lut[j] <<= 1;
+ } else {
+ val_lut[j] = 1;
+ }
}
}
- bits_per_frame = av_rescale(avctx->bit_rate, avctx->time_base.num,
- avctx->time_base.den);
- min_bits_per_frame = minimum_frame_bits(s) + 8*sizeof(LIBAVCODEC_IDENT) + 8*40 + 8*20000;
- if (bits_per_frame < min_bits_per_frame) {
- avctx->bit_rate = av_rescale(min_bits_per_frame, avctx->time_base.den,
- avctx->time_base.num);
- av_log(avctx, AV_LOG_WARNING,
- "Bitrate too low, clipping to minimum = %li Mbps!\n",
- avctx->bit_rate/1000000);
- }
-
return 0;
alloc_fail:
projects / ffmpeg / blobdiff