← Back to branch summary

~ubuntu-branches/ubuntu/utopic/libav/utopic-proposed

« back to all changes in this revision

Viewing changes to libavcodec/dnxhdenc.c

  • Committer: Package Import Robot
  • Author(s): Reinhard Tartler, Reinhard Tartler, Rico Tzschichholz
  • Date: 2014-08-30 11:02:45 UTC
  • mfrom: (1.3.47 sid)
  • Revision ID: package-import@ubuntu.com-20140830110245-io3dg7q85wfr7125
Tags: 6:11~beta1-2
[ Reinhard Tartler ]
* Make libavcodec-dev depend on libavresample-dev

[ Rico Tzschichholz ]
* Some fixes and leftovers from soname bumps

Show diffs side-by-side

added added

removed removed

Lines of Context:
libavcodec/dnxhdenc.c
23
23
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
24
24
 */
25
25
 
26
 
#define RC_VARIANCE 1 // use variance or ssd for fast rc
27
 
 
28
26
#include "libavutil/attributes.h"
29
27
#include "libavutil/internal.h"
30
28
#include "libavutil/opt.h"
31
29
#include "libavutil/timer.h"
 
30
 
32
31
#include "avcodec.h"
33
 
#include "dsputil.h"
 
32
#include "blockdsp.h"
 
33
#include "fdctdsp.h"
34
34
#include "internal.h"
35
35
#include "mpegvideo.h"
 
36
#include "pixblockdsp.h"
36
37
#include "dnxhdenc.h"
37
38
 
 
39
// The largest value that will not lead to overflow for 10bit samples.
 
40
#define DNX10BIT_QMAT_SHIFT 18
 
41
#define RC_VARIANCE 1 // use variance or ssd for fast rc
 
42
#define LAMBDA_FRAC_BITS 10
 
43
 
38
44
#define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
39
 
#define DNX10BIT_QMAT_SHIFT 18 // The largest value that will not lead to overflow for 10bit samples.
40
 
 
41
 
static const AVOption options[]={
42
 
    {"nitris_compat", "encode with Avid Nitris compatibility", offsetof(DNXHDEncContext, nitris_compat), AV_OPT_TYPE_INT, {.i64 = 0}, 0, 1, VE},
43
 
{NULL}
44
 
};
45
 
static const AVClass class = { "dnxhd", av_default_item_name, options, LIBAVUTIL_VERSION_INT };
46
 
 
47
 
#define LAMBDA_FRAC_BITS 10
48
 
 
49
 
static void dnxhd_8bit_get_pixels_8x4_sym(int16_t *restrict block, const uint8_t *pixels, int line_size)
 
45
static const AVOption options[] = {
 
46
    { "nitris_compat", "encode with Avid Nitris compatibility",
 
47
        offsetof(DNXHDEncContext, nitris_compat), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 1, VE },
 
48
    { NULL }
 
49
};
 
50
 
 
51
static const AVClass class = {
 
52
    "dnxhd",
 
53
    av_default_item_name,
 
54
    options,
 
55
    LIBAVUTIL_VERSION_INT
 
56
};
 
57
 
 
58
static void dnxhd_8bit_get_pixels_8x4_sym(int16_t *restrict block,
 
59
                                          const uint8_t *pixels,
 
60
                                          ptrdiff_t line_size)
50
61
{
51
62
    int i;
52
63
    for (i = 0; i < 4; i++) {
53
 
        block[0] = pixels[0]; block[1] = pixels[1];
54
 
        block[2] = pixels[2]; block[3] = pixels[3];
55
 
        block[4] = pixels[4]; block[5] = pixels[5];
56
 
        block[6] = pixels[6]; block[7] = pixels[7];
57
 
        pixels += line_size;
58
 
        block += 8;
 
64
        block[0] = pixels[0];
 
65
        block[1] = pixels[1];
 
66
        block[2] = pixels[2];
 
67
        block[3] = pixels[3];
 
68
        block[4] = pixels[4];
 
69
        block[5] = pixels[5];
 
70
        block[6] = pixels[6];
 
71
        block[7] = pixels[7];
 
72
        pixels  += line_size;
 
73
        block   += 8;
59
74
    }
60
75
    memcpy(block,      block -  8, sizeof(*block) * 8);
61
76
    memcpy(block +  8, block - 16, sizeof(*block) * 8);
63
78
    memcpy(block + 24, block - 32, sizeof(*block) * 8);
64
79
}
65
80
 
66
 
static av_always_inline void dnxhd_10bit_get_pixels_8x4_sym(int16_t *restrict block, const uint8_t *pixels, int line_size)
 
81
static av_always_inline
 
82
void dnxhd_10bit_get_pixels_8x4_sym(int16_t *restrict block,
 
83
                                    const uint8_t *pixels,
 
84
                                    ptrdiff_t line_size)
67
85
{
68
86
    int i;
69
87
 
70
88
    block += 32;
71
89
 
72
90
    for (i = 0; i < 4; i++) {
73
 
        memcpy(block + i     * 8, pixels + i * line_size, 8 * sizeof(*block));
74
 
        memcpy(block - (i+1) * 8, pixels + i * line_size, 8 * sizeof(*block));
 
91
        memcpy(block + i * 8, pixels + i * line_size, 8 * sizeof(*block));
 
92
        memcpy(block - (i + 1) * 8, pixels + i * line_size, 8 * sizeof(*block));
75
93
    }
76
94
}
77
95
 
83
101
    int last_non_zero = 0;
84
102
    int i;
85
103
 
86
 
    ctx->dsp.fdct(block);
 
104
    ctx->fdsp.fdct(block);
87
105
 
88
106
    // Divide by 4 with rounding, to compensate scaling of DCT coefficients
89
107
    block[0] = (block[0] + 2) >> 2;
104
122
static av_cold int dnxhd_init_vlc(DNXHDEncContext *ctx)
105
123
{
106
124
    int i, j, level, run;
107
 
    int max_level = 1<<(ctx->cid_table->bit_depth+2);
108
 
 
109
 
    FF_ALLOCZ_OR_GOTO(ctx->m.avctx, ctx->vlc_codes, max_level*4*sizeof(*ctx->vlc_codes), fail);
110
 
    FF_ALLOCZ_OR_GOTO(ctx->m.avctx, ctx->vlc_bits,  max_level*4*sizeof(*ctx->vlc_bits) , fail);
111
 
    FF_ALLOCZ_OR_GOTO(ctx->m.avctx, ctx->run_codes, 63*2,                                fail);
112
 
    FF_ALLOCZ_OR_GOTO(ctx->m.avctx, ctx->run_bits,  63,                                  fail);
113
 
 
114
 
    ctx->vlc_codes += max_level*2;
115
 
    ctx->vlc_bits  += max_level*2;
 
125
    int max_level = 1 << (ctx->cid_table->bit_depth + 2);
 
126
 
 
127
    FF_ALLOCZ_OR_GOTO(ctx->m.avctx, ctx->vlc_codes,
 
128
                      max_level * 4 * sizeof(*ctx->vlc_codes), fail);
 
129
    FF_ALLOCZ_OR_GOTO(ctx->m.avctx, ctx->vlc_bits,
 
130
                      max_level * 4 * sizeof(*ctx->vlc_bits), fail);
 
131
    FF_ALLOCZ_OR_GOTO(ctx->m.avctx, ctx->run_codes,
 
132
                      63 * 2, fail);
 
133
    FF_ALLOCZ_OR_GOTO(ctx->m.avctx, ctx->run_bits,
 
134
                      63, fail);
 
135
 
 
136
    ctx->vlc_codes += max_level * 2;
 
137
    ctx->vlc_bits  += max_level * 2;
116
138
    for (level = -max_level; level < max_level; level++) {
117
139
        for (run = 0; run < 2; run++) {
118
 
            int index = (level<<1)|run;
 
140
            int index = (level << 1) | run;
119
141
            int sign, offset = 0, alevel = level;
120
142
 
121
143
            MASK_ABS(sign, alevel);
122
144
            if (alevel > 64) {
123
 
                offset = (alevel-1)>>6;
124
 
                alevel -= offset<<6;
 
145
                offset  = (alevel - 1) >> 6;
 
146
                alevel -= offset << 6;
125
147
            }
126
148
            for (j = 0; j < 257; j++) {
127
149
                if (ctx->cid_table->ac_level[j] == alevel &&
129
151
                    (!run    || (ctx->cid_table->ac_run_flag  [j] && run))) {
130
152
                    assert(!ctx->vlc_codes[index]);
131
153
                    if (alevel) {
132
 
                        ctx->vlc_codes[index] = (ctx->cid_table->ac_codes[j]<<1)|(sign&1);
133
 
                        ctx->vlc_bits [index] = ctx->cid_table->ac_bits[j]+1;
 
154
                        ctx->vlc_codes[index] =
 
155
                            (ctx->cid_table->ac_codes[j] << 1) | (sign & 1);
 
156
                        ctx->vlc_bits[index] = ctx->cid_table->ac_bits[j] + 1;
134
157
                    } else {
135
158
                        ctx->vlc_codes[index] = ctx->cid_table->ac_codes[j];
136
 
                        ctx->vlc_bits [index] = ctx->cid_table->ac_bits [j];
 
159
                        ctx->vlc_bits[index]  = ctx->cid_table->ac_bits[j];
137
160
                    }
138
161
                    break;
139
162
                }
140
163
            }
141
164
            assert(!alevel || j < 257);
142
165
            if (offset) {
143
 
                ctx->vlc_codes[index] = (ctx->vlc_codes[index]<<ctx->cid_table->index_bits)|offset;
144
 
                ctx->vlc_bits [index]+= ctx->cid_table->index_bits;
 
166
                ctx->vlc_codes[index] =
 
167
                    (ctx->vlc_codes[index] << ctx->cid_table->index_bits) | offset;
 
168
                ctx->vlc_bits[index] += ctx->cid_table->index_bits;
145
169
            }
146
170
        }
147
171
    }
149
173
        int run = ctx->cid_table->run[i];
150
174
        assert(run < 63);
151
175
        ctx->run_codes[run] = ctx->cid_table->run_codes[i];
152
 
        ctx->run_bits [run] = ctx->cid_table->run_bits[i];
 
176
        ctx->run_bits[run]  = ctx->cid_table->run_bits[i];
153
177
    }
154
178
    return 0;
155
 
 fail:
156
 
    return -1;
 
179
fail:
 
180
    return AVERROR(ENOMEM);
157
181
}
158
182
 
159
183
static av_cold int dnxhd_init_qmat(DNXHDEncContext *ctx, int lbias, int cbias)
160
184
{
161
185
    // init first elem to 1 to avoid div by 0 in convert_matrix
162
 
    uint16_t weight_matrix[64] = {1,}; // convert_matrix needs uint16_t*
 
186
    uint16_t weight_matrix[64] = { 1, }; // convert_matrix needs uint16_t*
163
187
    int qscale, i;
164
188
    const uint8_t *luma_weight_table   = ctx->cid_table->luma_weight;
165
189
    const uint8_t *chroma_weight_table = ctx->cid_table->chroma_weight;
166
190
 
167
 
    FF_ALLOCZ_OR_GOTO(ctx->m.avctx, ctx->qmatrix_l,   (ctx->m.avctx->qmax+1) * 64 *     sizeof(int),      fail);
168
 
    FF_ALLOCZ_OR_GOTO(ctx->m.avctx, ctx->qmatrix_c,   (ctx->m.avctx->qmax+1) * 64 *     sizeof(int),      fail);
169
 
    FF_ALLOCZ_OR_GOTO(ctx->m.avctx, ctx->qmatrix_l16, (ctx->m.avctx->qmax+1) * 64 * 2 * sizeof(uint16_t), fail);
170
 
    FF_ALLOCZ_OR_GOTO(ctx->m.avctx, ctx->qmatrix_c16, (ctx->m.avctx->qmax+1) * 64 * 2 * sizeof(uint16_t), fail);
 
191
    FF_ALLOCZ_OR_GOTO(ctx->m.avctx, ctx->qmatrix_l,
 
192
                      (ctx->m.avctx->qmax + 1) * 64 * sizeof(int), fail);
 
193
    FF_ALLOCZ_OR_GOTO(ctx->m.avctx, ctx->qmatrix_c,
 
194
                      (ctx->m.avctx->qmax + 1) * 64 * sizeof(int), fail);
 
195
    FF_ALLOCZ_OR_GOTO(ctx->m.avctx, ctx->qmatrix_l16,
 
196
                      (ctx->m.avctx->qmax + 1) * 64 * 2 * sizeof(uint16_t),
 
197
                      fail);
 
198
    FF_ALLOCZ_OR_GOTO(ctx->m.avctx, ctx->qmatrix_c16,
 
199
                      (ctx->m.avctx->qmax + 1) * 64 * 2 * sizeof(uint16_t),
 
200
                      fail);
171
201
 
172
202
    if (ctx->cid_table->bit_depth == 8) {
173
203
        for (i = 1; i < 64; i++) {
174
 
            int j = ctx->m.dsp.idct_permutation[ff_zigzag_direct[i]];
 
204
            int j = ctx->m.idsp.idct_permutation[ff_zigzag_direct[i]];
175
205
            weight_matrix[j] = ctx->cid_table->luma_weight[i];
176
206
        }
177
 
        ff_convert_matrix(&ctx->m.dsp, ctx->qmatrix_l, ctx->qmatrix_l16, weight_matrix,
178
 
                          ctx->m.intra_quant_bias, 1, ctx->m.avctx->qmax, 1);
 
207
        ff_convert_matrix(&ctx->m, ctx->qmatrix_l, ctx->qmatrix_l16,
 
208
                          weight_matrix, ctx->m.intra_quant_bias, 1,
 
209
                          ctx->m.avctx->qmax, 1);
179
210
        for (i = 1; i < 64; i++) {
180
 
            int j = ctx->m.dsp.idct_permutation[ff_zigzag_direct[i]];
 
211
            int j = ctx->m.idsp.idct_permutation[ff_zigzag_direct[i]];
181
212
            weight_matrix[j] = ctx->cid_table->chroma_weight[i];
182
213
        }
183
 
        ff_convert_matrix(&ctx->m.dsp, ctx->qmatrix_c, ctx->qmatrix_c16, weight_matrix,
184
 
                          ctx->m.intra_quant_bias, 1, ctx->m.avctx->qmax, 1);
 
214
        ff_convert_matrix(&ctx->m, ctx->qmatrix_c, ctx->qmatrix_c16,
 
215
                          weight_matrix, ctx->m.intra_quant_bias, 1,
 
216
                          ctx->m.avctx->qmax, 1);
185
217
 
186
218
        for (qscale = 1; qscale <= ctx->m.avctx->qmax; qscale++) {
187
219
            for (i = 0; i < 64; i++) {
188
 
                ctx->qmatrix_l  [qscale]   [i] <<= 2; ctx->qmatrix_c  [qscale]   [i] <<= 2;
189
 
                ctx->qmatrix_l16[qscale][0][i] <<= 2; ctx->qmatrix_l16[qscale][1][i] <<= 2;
190
 
                ctx->qmatrix_c16[qscale][0][i] <<= 2; ctx->qmatrix_c16[qscale][1][i] <<= 2;
 
220
                ctx->qmatrix_l[qscale][i]      <<= 2;
 
221
                ctx->qmatrix_c[qscale][i]      <<= 2;
 
222
                ctx->qmatrix_l16[qscale][0][i] <<= 2;
 
223
                ctx->qmatrix_l16[qscale][1][i] <<= 2;
 
224
                ctx->qmatrix_c16[qscale][0][i] <<= 2;
 
225
                ctx->qmatrix_c16[qscale][1][i] <<= 2;
191
226
            }
192
227
        }
193
228
    } else {
194
229
        // 10-bit
195
230
        for (qscale = 1; qscale <= ctx->m.avctx->qmax; qscale++) {
196
231
            for (i = 1; i < 64; i++) {
197
 
                int j = ctx->m.dsp.idct_permutation[ff_zigzag_direct[i]];
 
232
                int j = ctx->m.idsp.idct_permutation[ff_zigzag_direct[i]];
198
233
 
199
 
                // The quantization formula from the VC-3 standard is:
200
 
                // quantized = sign(block[i]) * floor(abs(block[i]/s) * p / (qscale * weight_table[i]))
201
 
                // Where p is 32 for 8-bit samples and 8 for 10-bit ones.
202
 
                // The s factor compensates scaling of DCT coefficients done by the DCT routines,
203
 
                // and therefore is not present in standard.  It's 8 for 8-bit samples and 4 for 10-bit ones.
204
 
                // We want values of ctx->qtmatrix_l and ctx->qtmatrix_r to be:
205
 
                // ((1 << DNX10BIT_QMAT_SHIFT) * (p / s)) / (qscale * weight_table[i])
206
 
                // For 10-bit samples, p / s == 2
207
 
                ctx->qmatrix_l[qscale][j] = (1 << (DNX10BIT_QMAT_SHIFT + 1)) / (qscale * luma_weight_table[i]);
208
 
                ctx->qmatrix_c[qscale][j] = (1 << (DNX10BIT_QMAT_SHIFT + 1)) / (qscale * chroma_weight_table[i]);
 
234
                /* The quantization formula from the VC-3 standard is:
 
235
                 * quantized = sign(block[i]) * floor(abs(block[i]/s) * p /
 
236
                 *             (qscale * weight_table[i]))
 
237
                 * Where p is 32 for 8-bit samples and 8 for 10-bit ones.
 
238
                 * The s factor compensates scaling of DCT coefficients done by
 
239
                 * the DCT routines, and therefore is not present in standard.
 
240
                 * It's 8 for 8-bit samples and 4 for 10-bit ones.
 
241
                 * We want values of ctx->qtmatrix_l and ctx->qtmatrix_r to be:
 
242
                 *     ((1 << DNX10BIT_QMAT_SHIFT) * (p / s)) /
 
243
                 *     (qscale * weight_table[i])
 
244
                 * For 10-bit samples, p / s == 2 */
 
245
                ctx->qmatrix_l[qscale][j] = (1 << (DNX10BIT_QMAT_SHIFT + 1)) /
 
246
                                            (qscale * luma_weight_table[i]);
 
247
                ctx->qmatrix_c[qscale][j] = (1 << (DNX10BIT_QMAT_SHIFT + 1)) /
 
248
                                            (qscale * chroma_weight_table[i]);
209
249
            }
210
250
        }
211
251
    }
212
252
 
213
253
    return 0;
214
 
 fail:
215
 
    return -1;
 
254
fail:
 
255
    return AVERROR(ENOMEM);
216
256
}
217
257
 
218
258
static av_cold int dnxhd_init_rc(DNXHDEncContext *ctx)
219
259
{
220
 
    FF_ALLOCZ_OR_GOTO(ctx->m.avctx, ctx->mb_rc, 8160*ctx->m.avctx->qmax*sizeof(RCEntry), fail);
 
260
    FF_ALLOCZ_OR_GOTO(ctx->m.avctx, ctx->mb_rc,
 
261
                      8160 * ctx->m.avctx->qmax * sizeof(RCEntry), fail);
221
262
    if (ctx->m.avctx->mb_decision != FF_MB_DECISION_RD)
222
 
        FF_ALLOCZ_OR_GOTO(ctx->m.avctx, ctx->mb_cmp, ctx->m.mb_num*sizeof(RCCMPEntry), fail);
 
263
        FF_ALLOCZ_OR_GOTO(ctx->m.avctx, ctx->mb_cmp,
 
264
                          ctx->m.mb_num * sizeof(RCCMPEntry), fail);
223
265
 
224
 
    ctx->frame_bits = (ctx->cid_table->coding_unit_size - 640 - 4 - ctx->min_padding) * 8;
 
266
    ctx->frame_bits = (ctx->cid_table->coding_unit_size -
 
267
                       640 - 4 - ctx->min_padding) * 8;
225
268
    ctx->qscale = 1;
226
 
    ctx->lambda = 2<<LAMBDA_FRAC_BITS; // qscale 2
 
269
    ctx->lambda = 2 << LAMBDA_FRAC_BITS; // qscale 2
227
270
    return 0;
228
 
 fail:
229
 
    return -1;
 
271
fail:
 
272
    return AVERROR(ENOMEM);
230
273
}
231
274
 
232
275
static av_cold int dnxhd_encode_init(AVCodecContext *avctx)
233
276
{
234
277
    DNXHDEncContext *ctx = avctx->priv_data;
235
 
    int i, index, bit_depth;
 
278
    int i, index, bit_depth, ret;
236
279
 
237
280
    switch (avctx->pix_fmt) {
238
281
    case AV_PIX_FMT_YUV422P:
242
285
        bit_depth = 10;
243
286
        break;
244
287
    default:
245
 
        av_log(avctx, AV_LOG_ERROR, "pixel format is incompatible with DNxHD\n");
246
 
        return -1;
 
288
        av_log(avctx, AV_LOG_ERROR,
 
289
               "pixel format is incompatible with DNxHD\n");
 
290
        return AVERROR(EINVAL);
247
291
    }
248
292
 
249
293
    ctx->cid = ff_dnxhd_find_cid(avctx, bit_depth);
250
294
    if (!ctx->cid) {
251
 
        av_log(avctx, AV_LOG_ERROR, "video parameters incompatible with DNxHD\n");
252
 
        return -1;
 
295
        av_log(avctx, AV_LOG_ERROR,
 
296
               "video parameters incompatible with DNxHD\n");
 
297
        return AVERROR(EINVAL);
253
298
    }
254
299
    av_log(avctx, AV_LOG_DEBUG, "cid %d\n", ctx->cid);
255
300
 
256
301
    index = ff_dnxhd_get_cid_table(ctx->cid);
257
302
    ctx->cid_table = &ff_dnxhd_cid_table[index];
258
303
 
259
 
    ctx->m.avctx = avctx;
 
304
    ctx->m.avctx    = avctx;
260
305
    ctx->m.mb_intra = 1;
261
306
    ctx->m.h263_aic = 1;
262
307
 
263
308
    avctx->bits_per_raw_sample = ctx->cid_table->bit_depth;
264
309
 
265
 
    ff_dsputil_init(&ctx->m.dsp, avctx);
266
 
    ff_dct_common_init(&ctx->m);
 
310
    ff_blockdsp_init(&ctx->bdsp, avctx);
 
311
    ff_fdctdsp_init(&ctx->m.fdsp, avctx);
 
312
    ff_mpv_idct_init(&ctx->m);
 
313
    ff_mpegvideoencdsp_init(&ctx->m.mpvencdsp, avctx);
 
314
    ff_pixblockdsp_init(&ctx->m.pdsp, avctx);
267
315
    if (!ctx->m.dct_quantize)
268
316
        ctx->m.dct_quantize = ff_dct_quantize_c;
269
317
 
270
318
    if (ctx->cid_table->bit_depth == 10) {
271
 
       ctx->m.dct_quantize = dnxhd_10bit_dct_quantize;
272
 
       ctx->get_pixels_8x4_sym = dnxhd_10bit_get_pixels_8x4_sym;
273
 
       ctx->block_width_l2 = 4;
 
319
        ctx->m.dct_quantize     = dnxhd_10bit_dct_quantize;
 
320
        ctx->get_pixels_8x4_sym = dnxhd_10bit_get_pixels_8x4_sym;
 
321
        ctx->block_width_l2     = 4;
274
322
    } else {
275
 
       ctx->get_pixels_8x4_sym = dnxhd_8bit_get_pixels_8x4_sym;
276
 
       ctx->block_width_l2 = 3;
 
323
        ctx->get_pixels_8x4_sym = dnxhd_8bit_get_pixels_8x4_sym;
 
324
        ctx->block_width_l2     = 3;
277
325
    }
278
326
 
279
327
    if (ARCH_X86)
283
331
    ctx->m.mb_width  = (avctx->width  + 15) / 16;
284
332
 
285
333
    if (avctx->flags & CODEC_FLAG_INTERLACED_DCT) {
286
 
        ctx->interlaced = 1;
 
334
        ctx->interlaced   = 1;
287
335
        ctx->m.mb_height /= 2;
288
336
    }
289
337
 
291
339
 
292
340
    if (avctx->intra_quant_bias != FF_DEFAULT_QUANT_BIAS)
293
341
        ctx->m.intra_quant_bias = avctx->intra_quant_bias;
294
 
    if (dnxhd_init_qmat(ctx, ctx->m.intra_quant_bias, 0) < 0) // XXX tune lbias/cbias
295
 
        return -1;
 
342
    // XXX tune lbias/cbias
 
343
    if ((ret = dnxhd_init_qmat(ctx, ctx->m.intra_quant_bias, 0)) < 0)
 
344
        return ret;
296
345
 
297
 
    // Avid Nitris hardware decoder requires a minimum amount of padding in the coding unit payload
 
346
    /* Avid Nitris hardware decoder requires a minimum amount of padding
 
347
     * in the coding unit payload */
298
348
    if (ctx->nitris_compat)
299
349
        ctx->min_padding = 1600;
300
350
 
301
 
    if (dnxhd_init_vlc(ctx) < 0)
302
 
        return -1;
303
 
    if (dnxhd_init_rc(ctx) < 0)
304
 
        return -1;
 
351
    if ((ret = dnxhd_init_vlc(ctx)) < 0)
 
352
        return ret;
 
353
    if ((ret = dnxhd_init_rc(ctx)) < 0)
 
354
        return ret;
305
355
 
306
 
    FF_ALLOCZ_OR_GOTO(ctx->m.avctx, ctx->slice_size, ctx->m.mb_height*sizeof(uint32_t), fail);
307
 
    FF_ALLOCZ_OR_GOTO(ctx->m.avctx, ctx->slice_offs, ctx->m.mb_height*sizeof(uint32_t), fail);
308
 
    FF_ALLOCZ_OR_GOTO(ctx->m.avctx, ctx->mb_bits,    ctx->m.mb_num   *sizeof(uint16_t), fail);
309
 
    FF_ALLOCZ_OR_GOTO(ctx->m.avctx, ctx->mb_qscale,  ctx->m.mb_num   *sizeof(uint8_t),  fail);
 
356
    FF_ALLOCZ_OR_GOTO(ctx->m.avctx, ctx->slice_size,
 
357
                      ctx->m.mb_height * sizeof(uint32_t), fail);
 
358
    FF_ALLOCZ_OR_GOTO(ctx->m.avctx, ctx->slice_offs,
 
359
                      ctx->m.mb_height * sizeof(uint32_t), fail);
 
360
    FF_ALLOCZ_OR_GOTO(ctx->m.avctx, ctx->mb_bits,
 
361
                      ctx->m.mb_num * sizeof(uint16_t), fail);
 
362
    FF_ALLOCZ_OR_GOTO(ctx->m.avctx, ctx->mb_qscale,
 
363
                      ctx->m.mb_num * sizeof(uint8_t), fail);
310
364
 
311
365
    avctx->coded_frame = av_frame_alloc();
312
366
    if (!avctx->coded_frame)
317
371
 
318
372
    if (avctx->thread_count > MAX_THREADS) {
319
373
        av_log(avctx, AV_LOG_ERROR, "too many threads\n");
320
 
        return -1;
 
374
        return AVERROR(EINVAL);
321
375
    }
322
376
 
323
377
    ctx->thread[0] = ctx;
324
378
    for (i = 1; i < avctx->thread_count; i++) {
325
 
        ctx->thread[i] =  av_malloc(sizeof(DNXHDEncContext));
 
379
        ctx->thread[i] = av_malloc(sizeof(DNXHDEncContext));
326
380
        memcpy(ctx->thread[i], ctx, sizeof(DNXHDEncContext));
327
381
    }
328
382
 
329
383
    return 0;
330
 
 fail: //for FF_ALLOCZ_OR_GOTO
331
 
    return -1;
 
384
fail:  // for FF_ALLOCZ_OR_GOTO
 
385
    return AVERROR(ENOMEM);
332
386
}
333
387
 
334
388
static int dnxhd_write_header(AVCodecContext *avctx, uint8_t *buf)
335
389
{
336
390
    DNXHDEncContext *ctx = avctx->priv_data;
337
 
    const uint8_t header_prefix[5] = { 0x00,0x00,0x02,0x80,0x01 };
 
391
    const uint8_t header_prefix[5] = { 0x00, 0x00, 0x02, 0x80, 0x01 };
338
392
 
339
393
    memset(buf, 0, 640);
340
394
 
341
395
    memcpy(buf, header_prefix, 5);
342
 
    buf[5] = ctx->interlaced ? ctx->cur_field+2 : 0x01;
 
396
    buf[5] = ctx->interlaced ? ctx->cur_field + 2 : 0x01;
343
397
    buf[6] = 0x80; // crc flag off
344
398
    buf[7] = 0xa0; // reserved
345
 
    AV_WB16(buf + 0x18, avctx->height>>ctx->interlaced); // ALPF
 
399
    AV_WB16(buf + 0x18, avctx->height >> ctx->interlaced); // ALPF
346
400
    AV_WB16(buf + 0x1a, avctx->width);  // SPL
347
 
    AV_WB16(buf + 0x1d, avctx->height>>ctx->interlaced); // NAL
 
401
    AV_WB16(buf + 0x1d, avctx->height >> ctx->interlaced); // NAL
348
402
 
349
403
    buf[0x21] = ctx->cid_table->bit_depth == 10 ? 0x58 : 0x38;
350
 
    buf[0x22] = 0x88 + (ctx->interlaced<<2);
 
404
    buf[0x22] = 0x88 + (ctx->interlaced << 2);
351
405
    AV_WB32(buf + 0x28, ctx->cid); // CID
352
406
    buf[0x2c] = ctx->interlaced ? 0 : 0x80;
353
407
 
366
420
{
367
421
    int nbits;
368
422
    if (diff < 0) {
369
 
        nbits = av_log2_16bit(-2*diff);
 
423
        nbits = av_log2_16bit(-2 * diff);
370
424
        diff--;
371
425
    } else {
372
 
        nbits = av_log2_16bit(2*diff);
 
426
        nbits = av_log2_16bit(2 * diff);
373
427
    }
374
428
    put_bits(&ctx->m.pb, ctx->cid_table->dc_bits[nbits] + nbits,
375
 
             (ctx->cid_table->dc_codes[nbits]<<nbits) + (diff & ((1 << nbits) - 1)));
 
429
             (ctx->cid_table->dc_codes[nbits] << nbits) +
 
430
             (diff & ((1 << nbits) - 1)));
376
431
}
377
432
 
378
 
static av_always_inline void dnxhd_encode_block(DNXHDEncContext *ctx, int16_t *block, int last_index, int n)
 
433
static av_always_inline
 
434
void dnxhd_encode_block(DNXHDEncContext *ctx, int16_t *block,
 
435
                        int last_index, int n)
379
436
{
380
437
    int last_non_zero = 0;
381
438
    int slevel, i, j;
388
445
        slevel = block[j];
389
446
        if (slevel) {
390
447
            int run_level = i - last_non_zero - 1;
391
 
            int rlevel = (slevel<<1)|!!run_level;
 
448
            int rlevel = (slevel << 1) | !!run_level;
392
449
            put_bits(&ctx->m.pb, ctx->vlc_bits[rlevel], ctx->vlc_codes[rlevel]);
393
450
            if (run_level)
394
 
                put_bits(&ctx->m.pb, ctx->run_bits[run_level], ctx->run_codes[run_level]);
 
451
                put_bits(&ctx->m.pb, ctx->run_bits[run_level],
 
452
                         ctx->run_codes[run_level]);
395
453
            last_non_zero = i;
396
454
        }
397
455
    }
398
456
    put_bits(&ctx->m.pb, ctx->vlc_bits[0], ctx->vlc_codes[0]); // EOB
399
457
}
400
458
 
401
 
static av_always_inline void dnxhd_unquantize_c(DNXHDEncContext *ctx, int16_t *block, int n, int qscale, int last_index)
 
459
static av_always_inline
 
460
void dnxhd_unquantize_c(DNXHDEncContext *ctx, int16_t *block, int n,
 
461
                        int qscale, int last_index)
402
462
{
403
463
    const uint8_t *weight_matrix;
404
464
    int level;
405
465
    int i;
406
466
 
407
 
    weight_matrix = (n&2) ? ctx->cid_table->chroma_weight : ctx->cid_table->luma_weight;
 
467
    weight_matrix = (n & 2) ? ctx->cid_table->chroma_weight
 
468
                            : ctx->cid_table->luma_weight;
408
469
 
409
470
    for (i = 1; i <= last_index; i++) {
410
471
        int j = ctx->m.intra_scantable.permutated[i];
411
472
        level = block[j];
412
473
        if (level) {
413
474
            if (level < 0) {
414
 
                level = (1-2*level) * qscale * weight_matrix[i];
 
475
                level = (1 - 2 * level) * qscale * weight_matrix[i];
415
476
                if (ctx->cid_table->bit_depth == 10) {
416
477
                    if (weight_matrix[i] != 8)
417
478
                        level += 8;
423
484
                }
424
485
                level = -level;
425
486
            } else {
426
 
                level = (2*level+1) * qscale * weight_matrix[i];
 
487
                level = (2 * level + 1) * qscale * weight_matrix[i];
427
488
                if (ctx->cid_table->bit_depth == 10) {
428
489
                    if (weight_matrix[i] != 8)
429
490
                        level += 8;
448
509
    return score;
449
510
}
450
511
 
451
 
static av_always_inline int dnxhd_calc_ac_bits(DNXHDEncContext *ctx, int16_t *block, int last_index)
 
512
static av_always_inline
 
513
int dnxhd_calc_ac_bits(DNXHDEncContext *ctx, int16_t *block, int last_index)
452
514
{
453
515
    int last_non_zero = 0;
454
516
    int bits = 0;
458
520
        level = block[j];
459
521
        if (level) {
460
522
            int run_level = i - last_non_zero - 1;
461
 
            bits += ctx->vlc_bits[(level<<1)|!!run_level]+ctx->run_bits[run_level];
 
523
            bits += ctx->vlc_bits[(level << 1) |
 
524
                    !!run_level] + ctx->run_bits[run_level];
462
525
            last_non_zero = i;
463
526
        }
464
527
    }
465
528
    return bits;
466
529
}
467
530
 
468
 
static av_always_inline void dnxhd_get_blocks(DNXHDEncContext *ctx, int mb_x, int mb_y)
 
531
static av_always_inline
 
532
void dnxhd_get_blocks(DNXHDEncContext *ctx, int mb_x, int mb_y)
469
533
{
470
534
    const int bs = ctx->block_width_l2;
471
535
    const int bw = 1 << bs;
472
 
    const uint8_t *ptr_y = ctx->thread[0]->src[0] + ((mb_y << 4) * ctx->m.linesize)   + (mb_x << bs+1);
473
 
    const uint8_t *ptr_u = ctx->thread[0]->src[1] + ((mb_y << 4) * ctx->m.uvlinesize) + (mb_x << bs);
474
 
    const uint8_t *ptr_v = ctx->thread[0]->src[2] + ((mb_y << 4) * ctx->m.uvlinesize) + (mb_x << bs);
475
 
    DSPContext *dsp = &ctx->m.dsp;
476
 
 
477
 
    dsp->get_pixels(ctx->blocks[0], ptr_y,      ctx->m.linesize);
478
 
    dsp->get_pixels(ctx->blocks[1], ptr_y + bw, ctx->m.linesize);
479
 
    dsp->get_pixels(ctx->blocks[2], ptr_u,      ctx->m.uvlinesize);
480
 
    dsp->get_pixels(ctx->blocks[3], ptr_v,      ctx->m.uvlinesize);
481
 
 
482
 
    if (mb_y+1 == ctx->m.mb_height && ctx->m.avctx->height == 1080) {
 
536
    const uint8_t *ptr_y = ctx->thread[0]->src[0] +
 
537
                           ((mb_y << 4) * ctx->m.linesize) + (mb_x << bs + 1);
 
538
    const uint8_t *ptr_u = ctx->thread[0]->src[1] +
 
539
                           ((mb_y << 4) * ctx->m.uvlinesize) + (mb_x << bs);
 
540
    const uint8_t *ptr_v = ctx->thread[0]->src[2] +
 
541
                           ((mb_y << 4) * ctx->m.uvlinesize) + (mb_x << bs);
 
542
    PixblockDSPContext *pdsp = &ctx->m.pdsp;
 
543
 
 
544
    pdsp->get_pixels(ctx->blocks[0], ptr_y,      ctx->m.linesize);
 
545
    pdsp->get_pixels(ctx->blocks[1], ptr_y + bw, ctx->m.linesize);
 
546
    pdsp->get_pixels(ctx->blocks[2], ptr_u,      ctx->m.uvlinesize);
 
547
    pdsp->get_pixels(ctx->blocks[3], ptr_v,      ctx->m.uvlinesize);
 
548
 
 
549
    if (mb_y + 1 == ctx->m.mb_height && ctx->m.avctx->height == 1080) {
483
550
        if (ctx->interlaced) {
484
 
            ctx->get_pixels_8x4_sym(ctx->blocks[4], ptr_y + ctx->dct_y_offset,      ctx->m.linesize);
485
 
            ctx->get_pixels_8x4_sym(ctx->blocks[5], ptr_y + ctx->dct_y_offset + bw, ctx->m.linesize);
486
 
            ctx->get_pixels_8x4_sym(ctx->blocks[6], ptr_u + ctx->dct_uv_offset,     ctx->m.uvlinesize);
487
 
            ctx->get_pixels_8x4_sym(ctx->blocks[7], ptr_v + ctx->dct_uv_offset,     ctx->m.uvlinesize);
 
551
            ctx->get_pixels_8x4_sym(ctx->blocks[4],
 
552
                                    ptr_y + ctx->dct_y_offset,
 
553
                                    ctx->m.linesize);
 
554
            ctx->get_pixels_8x4_sym(ctx->blocks[5],
 
555
                                    ptr_y + ctx->dct_y_offset + bw,
 
556
                                    ctx->m.linesize);
 
557
            ctx->get_pixels_8x4_sym(ctx->blocks[6],
 
558
                                    ptr_u + ctx->dct_uv_offset,
 
559
                                    ctx->m.uvlinesize);
 
560
            ctx->get_pixels_8x4_sym(ctx->blocks[7],
 
561
                                    ptr_v + ctx->dct_uv_offset,
 
562
                                    ctx->m.uvlinesize);
488
563
        } else {
489
 
            dsp->clear_block(ctx->blocks[4]);
490
 
            dsp->clear_block(ctx->blocks[5]);
491
 
            dsp->clear_block(ctx->blocks[6]);
492
 
            dsp->clear_block(ctx->blocks[7]);
 
564
            ctx->bdsp.clear_block(ctx->blocks[4]);
 
565
            ctx->bdsp.clear_block(ctx->blocks[5]);
 
566
            ctx->bdsp.clear_block(ctx->blocks[6]);
 
567
            ctx->bdsp.clear_block(ctx->blocks[7]);
493
568
        }
494
569
    } else {
495
 
        dsp->get_pixels(ctx->blocks[4], ptr_y + ctx->dct_y_offset,      ctx->m.linesize);
496
 
        dsp->get_pixels(ctx->blocks[5], ptr_y + ctx->dct_y_offset + bw, ctx->m.linesize);
497
 
        dsp->get_pixels(ctx->blocks[6], ptr_u + ctx->dct_uv_offset,     ctx->m.uvlinesize);
498
 
        dsp->get_pixels(ctx->blocks[7], ptr_v + ctx->dct_uv_offset,     ctx->m.uvlinesize);
 
570
        pdsp->get_pixels(ctx->blocks[4],
 
571
                         ptr_y + ctx->dct_y_offset, ctx->m.linesize);
 
572
        pdsp->get_pixels(ctx->blocks[5],
 
573
                         ptr_y + ctx->dct_y_offset + bw, ctx->m.linesize);
 
574
        pdsp->get_pixels(ctx->blocks[6],
 
575
                         ptr_u + ctx->dct_uv_offset, ctx->m.uvlinesize);
 
576
        pdsp->get_pixels(ctx->blocks[7],
 
577
                         ptr_v + ctx->dct_uv_offset, ctx->m.uvlinesize);
499
578
    }
500
579
}
501
580
 
502
 
static av_always_inline int dnxhd_switch_matrix(DNXHDEncContext *ctx, int i)
 
581
static av_always_inline
 
582
int dnxhd_switch_matrix(DNXHDEncContext *ctx, int i)
503
583
{
504
 
    if (i&2) {
 
584
    if (i & 2) {
505
585
        ctx->m.q_intra_matrix16 = ctx->qmatrix_c16;
506
586
        ctx->m.q_intra_matrix   = ctx->qmatrix_c;
507
 
        return 1 + (i&1);
 
587
        return 1 + (i & 1);
508
588
    } else {
509
589
        ctx->m.q_intra_matrix16 = ctx->qmatrix_l16;
510
590
        ctx->m.q_intra_matrix   = ctx->qmatrix_l;
512
592
    }
513
593
}
514
594
 
515
 
static int dnxhd_calc_bits_thread(AVCodecContext *avctx, void *arg, int jobnr, int threadnr)
 
595
static int dnxhd_calc_bits_thread(AVCodecContext *avctx, void *arg,
 
596
                                  int jobnr, int threadnr)
516
597
{
517
598
    DNXHDEncContext *ctx = avctx->priv_data;
518
599
    int mb_y = jobnr, mb_x;
538
619
            int overflow, nbits, diff, last_index;
539
620
            int n = dnxhd_switch_matrix(ctx, i);
540
621
 
541
 
            memcpy(block, src_block, 64*sizeof(*block));
542
 
            last_index = ctx->m.dct_quantize(&ctx->m, block, i, qscale, &overflow);
543
 
            ac_bits += dnxhd_calc_ac_bits(ctx, block, last_index);
 
622
            memcpy(block, src_block, 64 * sizeof(*block));
 
623
            last_index = ctx->m.dct_quantize(&ctx->m, block, i,
 
624
                                             qscale, &overflow);
 
625
            ac_bits   += dnxhd_calc_ac_bits(ctx, block, last_index);
544
626
 
545
627
            diff = block[0] - ctx->m.last_dc[n];
546
 
            if (diff < 0) nbits = av_log2_16bit(-2*diff);
547
 
            else          nbits = av_log2_16bit( 2*diff);
 
628
            if (diff < 0)
 
629
                nbits = av_log2_16bit(-2 * diff);
 
630
            else
 
631
                nbits = av_log2_16bit(2 * diff);
548
632
 
549
633
            assert(nbits < ctx->cid_table->bit_depth + 4);
550
634
            dc_bits += ctx->cid_table->dc_bits[nbits] + nbits;
553
637
 
554
638
            if (avctx->mb_decision == FF_MB_DECISION_RD || !RC_VARIANCE) {
555
639
                dnxhd_unquantize_c(ctx, block, i, qscale, last_index);
556
 
                ctx->m.dsp.idct(block);
 
640
                ctx->m.idsp.idct(block);
557
641
                ssd += dnxhd_ssd_block(block, src_block);
558
642
            }
559
643
        }
560
 
        ctx->mb_rc[qscale][mb].ssd = ssd;
561
 
        ctx->mb_rc[qscale][mb].bits = ac_bits+dc_bits+12+8*ctx->vlc_bits[0];
 
644
        ctx->mb_rc[qscale][mb].ssd  = ssd;
 
645
        ctx->mb_rc[qscale][mb].bits = ac_bits + dc_bits + 12 +
 
646
                                      8 * ctx->vlc_bits[0];
562
647
    }
563
648
    return 0;
564
649
}
565
650
 
566
 
static int dnxhd_encode_thread(AVCodecContext *avctx, void *arg, int jobnr, int threadnr)
 
651
static int dnxhd_encode_thread(AVCodecContext *avctx, void *arg,
 
652
                               int jobnr, int threadnr)
567
653
{
568
654
    DNXHDEncContext *ctx = avctx->priv_data;
569
655
    int mb_y = jobnr, mb_x;
570
656
    ctx = ctx->thread[threadnr];
571
 
    init_put_bits(&ctx->m.pb, (uint8_t *)arg + 640 + ctx->slice_offs[jobnr], ctx->slice_size[jobnr]);
 
657
    init_put_bits(&ctx->m.pb, (uint8_t *)arg + 640 + ctx->slice_offs[jobnr],
 
658
                  ctx->slice_size[jobnr]);
572
659
 
573
660
    ctx->m.last_dc[0] =
574
661
    ctx->m.last_dc[1] =
578
665
        int qscale = ctx->mb_qscale[mb];
579
666
        int i;
580
667
 
581
 
        put_bits(&ctx->m.pb, 12, qscale<<1);
 
668
        put_bits(&ctx->m.pb, 12, qscale << 1);
582
669
 
583
670
        dnxhd_get_blocks(ctx, mb_x, mb_y);
584
671
 
587
674
            int overflow, n = dnxhd_switch_matrix(ctx, i);
588
675
            int last_index = ctx->m.dct_quantize(&ctx->m, block, i,
589
676
                                                 qscale, &overflow);
590
 
            //START_TIMER;
 
677
            // START_TIMER;
591
678
            dnxhd_encode_block(ctx, block, last_index, n);
592
 
            //STOP_TIMER("encode_block");
 
679
            // STOP_TIMER("encode_block");
593
680
        }
594
681
    }
595
 
    if (put_bits_count(&ctx->m.pb)&31)
596
 
        put_bits(&ctx->m.pb, 32-(put_bits_count(&ctx->m.pb)&31), 0);
 
682
    if (put_bits_count(&ctx->m.pb) & 31)
 
683
        put_bits(&ctx->m.pb, 32 - (put_bits_count(&ctx->m.pb) & 31), 0);
597
684
    flush_put_bits(&ctx->m.pb);
598
685
    return 0;
599
686
}
610
697
            unsigned mb = mb_y * ctx->m.mb_width + mb_x;
611
698
            ctx->slice_size[mb_y] += ctx->mb_bits[mb];
612
699
        }
613
 
        ctx->slice_size[mb_y] = (ctx->slice_size[mb_y]+31)&~31;
 
700
        ctx->slice_size[mb_y]   = (ctx->slice_size[mb_y] + 31) & ~31;
614
701
        ctx->slice_size[mb_y] >>= 3;
615
702
        thread_size = ctx->slice_size[mb_y];
616
703
        offset += thread_size;
617
704
    }
618
705
}
619
706
 
620
 
static int dnxhd_mb_var_thread(AVCodecContext *avctx, void *arg, int jobnr, int threadnr)
 
707
static int dnxhd_mb_var_thread(AVCodecContext *avctx, void *arg,
 
708
                               int jobnr, int threadnr)
621
709
{
622
710
    DNXHDEncContext *ctx = avctx->priv_data;
623
711
    int mb_y = jobnr, mb_x, x, y;
626
714
 
627
715
    ctx = ctx->thread[threadnr];
628
716
    if (ctx->cid_table->bit_depth == 8) {
629
 
        uint8_t *pix = ctx->thread[0]->src[0] + ((mb_y<<4) * ctx->m.linesize);
 
717
        uint8_t *pix = ctx->thread[0]->src[0] + ((mb_y << 4) * ctx->m.linesize);
630
718
        for (mb_x = 0; mb_x < ctx->m.mb_width; ++mb_x, pix += 16) {
631
 
            unsigned mb  = mb_y * ctx->m.mb_width + mb_x;
 
719
            unsigned mb = mb_y * ctx->m.mb_width + mb_x;
632
720
            int sum;
633
721
            int varc;
634
722
 
635
723
            if (!partial_last_row && mb_x * 16 <= avctx->width - 16) {
636
 
                sum  = ctx->m.dsp.pix_sum(pix, ctx->m.linesize);
637
 
                varc = ctx->m.dsp.pix_norm1(pix, ctx->m.linesize);
 
724
                sum  = ctx->m.mpvencdsp.pix_sum(pix, ctx->m.linesize);
 
725
                varc = ctx->m.mpvencdsp.pix_norm1(pix, ctx->m.linesize);
638
726
            } else {
639
727
                int bw = FFMIN(avctx->width - 16 * mb_x, 16);
640
728
                int bh = FFMIN((avctx->height >> ctx->interlaced) - 16 * mb_y, 16);
647
735
                    }
648
736
                }
649
737
            }
650
 
            varc = (varc - (((unsigned)sum * sum) >> 8) + 128) >> 8;
 
738
            varc = (varc - (((unsigned) sum * sum) >> 8) + 128) >> 8;
651
739
 
652
740
            ctx->mb_cmp[mb].value = varc;
653
 
            ctx->mb_cmp[mb].mb = mb;
 
741
            ctx->mb_cmp[mb].mb    = mb;
654
742
        }
655
743
    } else { // 10-bit
656
744
        int const linesize = ctx->m.linesize >> 1;
657
745
        for (mb_x = 0; mb_x < ctx->m.mb_width; ++mb_x) {
658
 
            uint16_t *pix = (uint16_t*)ctx->thread[0]->src[0] + ((mb_y << 4) * linesize) + (mb_x << 4);
 
746
            uint16_t *pix = (uint16_t *)ctx->thread[0]->src[0] +
 
747
                            ((mb_y << 4) * linesize) + (mb_x << 4);
659
748
            unsigned mb  = mb_y * ctx->m.mb_width + mb_x;
660
749
            int sum = 0;
661
750
            int sqsum = 0;
665
754
            for (i = 0; i < 16; ++i) {
666
755
                for (j = 0; j < 16; ++j) {
667
756
                    // Turn 16-bit pixels into 10-bit ones.
668
 
                    int const sample = (unsigned)pix[j] >> 6;
669
 
                    sum += sample;
 
757
                    int const sample = (unsigned) pix[j] >> 6;
 
758
                    sum   += sample;
670
759
                    sqsum += sample * sample;
671
760
                    // 2^10 * 2^10 * 16 * 16 = 2^28, which is less than INT_MAX
672
761
                }
675
764
            mean = sum >> 8; // 16*16 == 2^8
676
765
            sqmean = sqsum >> 8;
677
766
            ctx->mb_cmp[mb].value = sqmean - mean * mean;
678
 
            ctx->mb_cmp[mb].mb = mb;
 
767
            ctx->mb_cmp[mb].mb    = mb;
679
768
        }
680
769
    }
681
770
    return 0;
689
778
 
690
779
    for (q = 1; q < avctx->qmax; q++) {
691
780
        ctx->qscale = q;
692
 
        avctx->execute2(avctx, dnxhd_calc_bits_thread, NULL, NULL, ctx->m.mb_height);
 
781
        avctx->execute2(avctx, dnxhd_calc_bits_thread,
 
782
                        NULL, NULL, ctx->m.mb_height);
693
783
    }
694
 
    up_step = down_step = 2<<LAMBDA_FRAC_BITS;
695
 
    lambda = ctx->lambda;
 
784
    up_step = down_step = 2 << LAMBDA_FRAC_BITS;
 
785
    lambda  = ctx->lambda;
696
786
 
697
787
    for (;;) {
698
788
        int bits = 0;
699
 
        int end = 0;
 
789
        int end  = 0;
700
790
        if (lambda == last_higher) {
701
791
            lambda++;
702
792
            end = 1; // need to set final qscales/bits
705
795
            for (x = 0; x < ctx->m.mb_width; x++) {
706
796
                unsigned min = UINT_MAX;
707
797
                int qscale = 1;
708
 
                int mb = y*ctx->m.mb_width+x;
 
798
                int mb     = y * ctx->m.mb_width + x;
709
799
                for (q = 1; q < avctx->qmax; q++) {
710
 
                    unsigned score = ctx->mb_rc[q][mb].bits*lambda+
711
 
                        ((unsigned)ctx->mb_rc[q][mb].ssd<<LAMBDA_FRAC_BITS);
 
800
                    unsigned score = ctx->mb_rc[q][mb].bits * lambda +
 
801
                                     ((unsigned) ctx->mb_rc[q][mb].ssd << LAMBDA_FRAC_BITS);
712
802
                    if (score < min) {
713
 
                        min = score;
 
803
                        min    = score;
714
804
                        qscale = q;
715
805
                    }
716
806
                }
717
807
                bits += ctx->mb_rc[qscale][mb].bits;
718
808
                ctx->mb_qscale[mb] = qscale;
719
 
                ctx->mb_bits[mb] = ctx->mb_rc[qscale][mb].bits;
 
809
                ctx->mb_bits[mb]   = ctx->mb_rc[qscale][mb].bits;
720
810
            }
721
 
            bits = (bits+31)&~31; // padding
 
811
            bits = (bits + 31) & ~31; // padding
722
812
            if (bits > ctx->frame_bits)
723
813
                break;
724
814
        }
725
 
        //av_dlog(ctx->m.avctx, "lambda %d, up %u, down %u, bits %d, frame %d\n",
726
 
        //        lambda, last_higher, last_lower, bits, ctx->frame_bits);
 
815
        // av_dlog(ctx->m.avctx,
 
816
        //         "lambda %d, up %u, down %u, bits %d, frame %d\n",
 
817
        //         lambda, last_higher, last_lower, bits, ctx->frame_bits);
727
818
        if (end) {
728
819
            if (bits > ctx->frame_bits)
729
 
                return -1;
 
820
                return AVERROR(EINVAL);
730
821
            break;
731
822
        }
732
823
        if (bits < ctx->frame_bits) {
745
836
            if (last_lower != INT_MAX)
746
837
                lambda = (lambda+last_lower)>>1;
747
838
            else if ((int64_t)lambda + up_step > INT_MAX)
748
 
                return -1;
 
839
                return AVERROR(EINVAL);
749
840
            else
750
841
                lambda += up_step;
751
842
            up_step = FFMIN((int64_t)up_step*5, INT_MAX);
772
863
        bits = 0;
773
864
        ctx->qscale = qscale;
774
865
        // XXX avoid recalculating bits
775
 
        ctx->m.avctx->execute2(ctx->m.avctx, dnxhd_calc_bits_thread, NULL, NULL, ctx->m.mb_height);
 
866
        ctx->m.avctx->execute2(ctx->m.avctx, dnxhd_calc_bits_thread,
 
867
                               NULL, NULL, ctx->m.mb_height);
776
868
        for (y = 0; y < ctx->m.mb_height; y++) {
777
869
            for (x = 0; x < ctx->m.mb_width; x++)
778
870
                bits += ctx->mb_rc[qscale][y*ctx->m.mb_width+x].bits;
780
872
            if (bits > ctx->frame_bits)
781
873
                break;
782
874
        }
783
 
        //av_dlog(ctx->m.avctx, "%d, qscale %d, bits %d, frame %d, higher %d, lower %d\n",
784
 
        //        ctx->m.avctx->frame_number, qscale, bits, ctx->frame_bits, last_higher, last_lower);
 
875
        // av_dlog(ctx->m.avctx,
 
876
        //         "%d, qscale %d, bits %d, frame %d, higher %d, lower %d\n",
 
877
        //         ctx->m.avctx->frame_number, qscale, bits, ctx->frame_bits,
 
878
        //         last_higher, last_lower);
785
879
        if (bits < ctx->frame_bits) {
786
880
            if (qscale == 1)
787
881
                return 1;
791
885
            }
792
886
            last_lower = FFMIN(qscale, last_lower);
793
887
            if (last_higher != 0)
794
 
                qscale = (qscale+last_higher)>>1;
 
888
                qscale = (qscale + last_higher) >> 1;
795
889
            else
796
890
                qscale -= down_step++;
797
891
            if (qscale < 1)
802
896
                break;
803
897
            last_higher = FFMAX(qscale, last_higher);
804
898
            if (last_lower != INT_MAX)
805
 
                qscale = (qscale+last_lower)>>1;
 
899
                qscale = (qscale + last_lower) >> 1;
806
900
            else
807
901
                qscale += up_step++;
808
902
            down_step = 1;
809
903
            if (qscale >= ctx->m.avctx->qmax)
810
 
                return -1;
 
904
                return AVERROR(EINVAL);
811
905
        }
812
906
    }
813
907
    //av_dlog(ctx->m.avctx, "out qscale %d\n", qscale);
822
916
static inline int get_bucket(int value, int shift)
823
917
{
824
918
    value >>= shift;
825
 
    value &= NBUCKETS - 1;
 
919
    value  &= NBUCKETS - 1;
826
920
    return NBUCKETS - 1 - value;
827
921
}
828
922
 
829
 
static void radix_count(const RCCMPEntry *data, int size, int buckets[RADIX_PASSES][NBUCKETS])
 
923
static void radix_count(const RCCMPEntry *data, int size,
 
924
                        int buckets[RADIX_PASSES][NBUCKETS])
830
925
{
831
926
    int i, j;
832
927
    memset(buckets, 0, sizeof(buckets[0][0]) * RADIX_PASSES * NBUCKETS);
846
941
    }
847
942
}
848
943
 
849
 
static void radix_sort_pass(RCCMPEntry *dst, const RCCMPEntry *data, int size, int buckets[NBUCKETS], int pass)
 
944
static void radix_sort_pass(RCCMPEntry *dst, const RCCMPEntry *data,
 
945
                            int size, int buckets[NBUCKETS], int pass)
850
946
{
851
947
    int shift = pass * BUCKET_BITS;
852
948
    int i;
853
949
    for (i = 0; i < size; i++) {
854
 
        int v = get_bucket(data[i].value, shift);
 
950
        int v   = get_bucket(data[i].value, shift);
855
951
        int pos = buckets[v]++;
856
952
        dst[pos] = data[i];
857
953
    }
876
972
    int max_bits = 0;
877
973
    int ret, x, y;
878
974
    if ((ret = dnxhd_find_qscale(ctx)) < 0)
879
 
        return -1;
 
975
        return ret;
880
976
    for (y = 0; y < ctx->m.mb_height; y++) {
881
977
        for (x = 0; x < ctx->m.mb_width; x++) {
882
 
            int mb = y*ctx->m.mb_width+x;
 
978
            int mb = y * ctx->m.mb_width + x;
883
979
            int delta_bits;
884
980
            ctx->mb_qscale[mb] = ctx->qscale;
885
981
            ctx->mb_bits[mb] = ctx->mb_rc[ctx->qscale][mb].bits;
886
982
            max_bits += ctx->mb_rc[ctx->qscale][mb].bits;
887
983
            if (!RC_VARIANCE) {
888
 
                delta_bits = ctx->mb_rc[ctx->qscale][mb].bits-ctx->mb_rc[ctx->qscale+1][mb].bits;
 
984
                delta_bits = ctx->mb_rc[ctx->qscale][mb].bits -
 
985
                             ctx->mb_rc[ctx->qscale + 1][mb].bits;
889
986
                ctx->mb_cmp[mb].mb = mb;
890
 
                ctx->mb_cmp[mb].value = delta_bits ?
891
 
                    ((ctx->mb_rc[ctx->qscale][mb].ssd-ctx->mb_rc[ctx->qscale+1][mb].ssd)*100)/delta_bits
892
 
                    : INT_MIN; //avoid increasing qscale
 
987
                ctx->mb_cmp[mb].value =
 
988
                    delta_bits ? ((ctx->mb_rc[ctx->qscale][mb].ssd -
 
989
                                   ctx->mb_rc[ctx->qscale + 1][mb].ssd) * 100) /
 
990
                                  delta_bits
 
991
                               : INT_MIN; // avoid increasing qscale
893
992
            }
894
993
        }
895
 
        max_bits += 31; //worst padding
 
994
        max_bits += 31; // worst padding
896
995
    }
897
996
    if (!ret) {
898
997
        if (RC_VARIANCE)
899
 
            avctx->execute2(avctx, dnxhd_mb_var_thread, NULL, NULL, ctx->m.mb_height);
 
998
            avctx->execute2(avctx, dnxhd_mb_var_thread,
 
999
                            NULL, NULL, ctx->m.mb_height);
900
1000
        radix_sort(ctx->mb_cmp, ctx->m.mb_num);
901
1001
        for (x = 0; x < ctx->m.mb_num && max_bits > ctx->frame_bits; x++) {
902
1002
            int mb = ctx->mb_cmp[x].mb;
903
 
            max_bits -= ctx->mb_rc[ctx->qscale][mb].bits - ctx->mb_rc[ctx->qscale+1][mb].bits;
904
 
            ctx->mb_qscale[mb] = ctx->qscale+1;
905
 
            ctx->mb_bits[mb] = ctx->mb_rc[ctx->qscale+1][mb].bits;
 
1003
            max_bits -= ctx->mb_rc[ctx->qscale][mb].bits -
 
1004
                        ctx->mb_rc[ctx->qscale + 1][mb].bits;
 
1005
            ctx->mb_qscale[mb] = ctx->qscale + 1;
 
1006
            ctx->mb_bits[mb]   = ctx->mb_rc[ctx->qscale + 1][mb].bits;
906
1007
        }
907
1008
    }
908
1009
    return 0;
932
1033
    uint8_t *buf;
933
1034
 
934
1035
    if ((ret = ff_alloc_packet(pkt, ctx->cid_table->frame_size)) < 0) {
935
 
        av_log(avctx, AV_LOG_ERROR, "output buffer is too small to compress picture\n");
 
1036
        av_log(avctx, AV_LOG_ERROR,
 
1037
               "output buffer is too small to compress picture\n");
936
1038
        return ret;
937
1039
    }
938
1040
    buf = pkt->data;
939
1041
 
940
1042
    dnxhd_load_picture(ctx, frame);
941
1043
 
942
 
 encode_coding_unit:
 
1044
encode_coding_unit:
943
1045
    for (i = 0; i < 3; i++) {
944
1046
        ctx->src[i] = frame->data[i];
945
1047
        if (ctx->interlaced && ctx->cur_field)
955
1057
    if (ret < 0) {
956
1058
        av_log(avctx, AV_LOG_ERROR,
957
1059
               "picture could not fit ratecontrol constraints, increase qmax\n");
958
 
        return -1;
 
1060
        return ret;
959
1061
    }
960
1062
 
961
1063
    dnxhd_setup_threads_slices(ctx);
970
1072
    avctx->execute2(avctx, dnxhd_encode_thread, buf, NULL, ctx->m.mb_height);
971
1073
 
972
1074
    assert(640 + offset + 4 <= ctx->cid_table->coding_unit_size);
973
 
    memset(buf + 640 + offset, 0, ctx->cid_table->coding_unit_size - 4 - offset - 640);
 
1075
    memset(buf + 640 + offset, 0,
 
1076
           ctx->cid_table->coding_unit_size - 4 - offset - 640);
974
1077
 
975
1078
    AV_WB32(buf + ctx->cid_table->coding_unit_size - 4, 0x600DC0DE); // EOF
976
1079
 
977
1080
    if (ctx->interlaced && first_field) {
978
1081
        first_field     = 0;
979
1082
        ctx->cur_field ^= 1;
980
 
        buf      += ctx->cid_table->coding_unit_size;
 
1083
        buf            += ctx->cid_table->coding_unit_size;
981
1084
        goto encode_coding_unit;
982
1085
    }
983
1086
 
991
1094
static av_cold int dnxhd_encode_end(AVCodecContext *avctx)
992
1095
{
993
1096
    DNXHDEncContext *ctx = avctx->priv_data;
994
 
    int max_level = 1<<(ctx->cid_table->bit_depth+2);
 
1097
    int max_level        = 1 << (ctx->cid_table->bit_depth + 2);
995
1098
    int i;
996
1099
 
997
 
    av_free(ctx->vlc_codes-max_level*2);
998
 
    av_free(ctx->vlc_bits -max_level*2);
 
1100
    av_free(ctx->vlc_codes - max_level * 2);
 
1101
    av_free(ctx->vlc_bits - max_level * 2);
999
1102
    av_freep(&ctx->run_codes);
1000
1103
    av_freep(&ctx->run_bits);
1001
1104
 
1029
1132
    .encode2        = dnxhd_encode_picture,
1030
1133
    .close          = dnxhd_encode_end,
1031
1134
    .capabilities   = CODEC_CAP_SLICE_THREADS,
1032
 
    .pix_fmts       = (const enum AVPixelFormat[]){ AV_PIX_FMT_YUV422P,
1033
 
                                                  AV_PIX_FMT_YUV422P10,
1034
 
                                                  AV_PIX_FMT_NONE },
 
1135
    .pix_fmts       = (const enum AVPixelFormat[]) {
 
1136
        AV_PIX_FMT_YUV422P,
 
1137
        AV_PIX_FMT_YUV422P10,
 
1138
        AV_PIX_FMT_NONE
 
1139
    },
1035
1140
    .priv_class     = &class,
1036
1141
};