← Back to branch summary

~medibuntu-maintainers/mplayer/medibuntu.precise

« back to all changes in this revision

Viewing changes to ffmpeg/libavcodec/libx264.c

  • Committer: Gauvain Pocentek
  • Date: 2012-03-06 11:59:12 UTC
  • mfrom: (66.1.15 precise)
  • Revision ID: gauvain@pocentek.net-20120306115912-h9d6kt9j0l532oo5
http://bugs.debian.org/442181
http://bugs.debian.org/481807
http://bugs.debian.org/496106
http://bugs.debian.org/533546
http://bugs.debian.org/568514
http://bugs.debian.org/637077
http://bugs.debian.org/638408
http://bugs.debian.org/643621
http://bugs.debian.org/650339
http://bugs.debian.org/653887
http://bugs.debian.org/654974
* Merge from Ubuntu:
  - put back faac support
  - recommends apport-hooks-medibuntu
  - change Maintainer, Uploaders & Vcs-* fields.
* New upstream snapshot
* upload to unstable
* Build against external libmpeg2
* drop 51_FTBFS_arm.patch again
* no longer build depend on libcdparanoia-dev on the Hurd
* Fix FTBFS on the hurd.
  Thanks to Samuel Thibault <sthibault@debian.org> (Closes: #654974)
* Fix FTBFS on arm
* New upstream snapshot, Closes: #650339, #643621, #481807
* Imported Upstream version 1.0~rc4+svn34492
* Bump standards version
* Bump dependency on libav >= 4:0.8~, Closes: #653887
* Fix build-indep
* Build mplayer-gui again, Closes: #568514
* Drop debian/all-lang-config-mak.sh, no longer needed
* include .dfsg1 in version number
* remove get-orig-source target
* no longer prune compiler flags from the environment
* No longer advertise nor build 3fdx, mga and dxr3 backends,
  Closes: #496106, #442181, #533546
* beautify mplayer version identification string
* Brown paperbag upload.
* Next try to fix build failure on sparce after recent binutils change.
* Brown paperbag upload.
* Really fix build failure on sparc after recent binutils change.
* Properly set Replaces/Conflicts on mplayer2{,-dbg} to avoid
  file overwrite errors.
* Adjust versioning of mplayer listed in the mplayer-dbg's Depends field.
* Fix build failure on sparc after recent binutils change.
* Urgency medium bumped because of RC-level bugfix
  and speeding up x264 transition.
* Update to my @debian.org email.
* Upload to unstable
* Enable joystick support on Linux only, Closes: #638408
* Rebuild fixes toolchain issue on arm, Closes: #637077
* New upstream snapshot
* following the discussion started by Diego Biurrun <diego@biurrun.de>
  in debian-devel, I have prepared a new packaging of 'mplayer'
  (with code that comes from CVS)
* the upstream tar.bz cannot be distributed by Debian, since it contains
   CSS code; so I am repackaging it 
* I have tried my best to address all known issues:
  - the package contains the detailed Copyright made by Diego Biurrun 
  - the package does not contain CSS code, or  AFAIK other code on which 
     there is active patent enforcement
  - there is a script  debian/cvs-changelog.sh  that shows all changes
     done to files included in this source.
    This should comply with GPLv2 sec 2.a  (in spirit if not in letter)
    For this reason, the source code contains CVS directories.
* needs   make (>= 3.80) for 'html-chunked-$(1)' in DOCS/xml/Makefile

* some corrections, as suggested Diego Biurrun
  - binary codecs should go into /usr/lib/codecs (upstream default)
  - better template 'mplayer/install_codecs'
  - an empty 'font=' in mplayer.conf breaks mplayer: postinst corrected
* correction in 'mplayer/cfgnote'
* better mplayer.postinst and mplayer.config

* New upstream release
* better debian/copyright file
* do not ship a skin
* New upstream release
* changed DEB_BUILD_OPTIONS to DEB_BUILD_CONFIGURE ,
  DEB_BUILD_OPTIONS is used as in debian policy
* use gcc-3.4
* changed xlibs-dev to a long list of dependencies, for Debian/etch
* try to adhere to  http://www.mplayerhq.hu/DOCS/tech/binary-packaging.txt
  (see README.Debian for details)
* removed dependency on xlibmesa-dev, disabled opengl
* New upstream release
* Simon McVittie <hacks@pseudorandom.co.uk> wonderful work:
- Work around Debian bug #267442 (glibc's sys/uio.h and gcc's altivec.h have
  conflicting uses for __vector) by re-ordering #includes
- Fix potential symlink attack in ./configure
- Disable support for binary codecs on platforms for which those codecs
  aren't available; also disable the corresponding Debconf note when it's
  inappropriate
- Changed Build-Depends: so it works in pbuilder
- Explicitly build-depend on libjpeg62-dev, libfontconfig1-dev,
  libungif4-dev 
- Tweak debian/rules to avoid certain errors being ignored
- Use --language=all
* provide a target  'debian/rules get-orig-source' 
  that recreates the orig.tar.gz ; then use the above orig.tar.gz
* rewrote some parts of debian/rules
* don't clean and recompile docs if upstream ships them
* mplayer-doc was shipping too much stuff
* translated man pages where not installed properly
* compile with libdv4-dev
* correct README.Debian
* Forgot build-dep on libtheora
* Must not depend on libxvidcore
* New upstream release
* new release.
* rc1 to become 0.90
* new pre-release
* new pre-release
* gtk bug fixed.
* new release.
* version bumped
* 0.60 pre2 release
* 0.60 pre-release.

Show diffs side-by-side

added added

removed removed

Lines of Context:
ffmpeg/libavcodec/libx264.c
19
19
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20
20
 */
21
21
 
 
22
#include "libavutil/opt.h"
 
23
#include "libavutil/pixdesc.h"
22
24
#include "avcodec.h"
 
25
#include "internal.h"
23
26
#include <x264.h>
 
27
#include <float.h>
24
28
#include <math.h>
25
29
#include <stdio.h>
26
30
#include <stdlib.h>
27
31
#include <string.h>
28
32
 
29
33
typedef struct X264Context {
 
34
    AVClass        *class;
30
35
    x264_param_t    params;
31
36
    x264_t         *enc;
32
37
    x264_picture_t  pic;
33
38
    uint8_t        *sei;
34
39
    int             sei_size;
35
40
    AVFrame         out_pic;
 
41
    char *preset;
 
42
    char *tune;
 
43
    char *profile;
 
44
    int fastfirstpass;
 
45
    float crf;
 
46
    float crf_max;
 
47
    int cqp;
 
48
    int aq_mode;
 
49
    float aq_strength;
 
50
    char *psy_rd;
 
51
    int psy;
 
52
    int rc_lookahead;
 
53
    int weightp;
 
54
    int weightb;
 
55
    int ssim;
 
56
    int intra_refresh;
 
57
    int b_bias;
 
58
    int b_pyramid;
 
59
    int mixed_refs;
 
60
    int dct8x8;
 
61
    int fast_pskip;
 
62
    int aud;
 
63
    int mbtree;
 
64
    char *deblock;
 
65
    float cplxblur;
 
66
    char *partitions;
 
67
    int direct_pred;
 
68
    int slice_max_size;
36
69
} X264Context;
37
70
 
38
71
static void X264_log(void *p, int level, const char *fmt, va_list args)
90
123
    x264_picture_t pic_out;
91
124
 
92
125
    x264_picture_init( &x4->pic );
93
 
    x4->pic.img.i_csp   = X264_CSP_I420;
 
126
    x4->pic.img.i_csp   = x4->params.i_csp;
 
127
    if (x264_bit_depth > 8)
 
128
        x4->pic.img.i_csp |= X264_CSP_HIGH_DEPTH;
94
129
    x4->pic.img.i_plane = 3;
95
130
 
96
131
    if (frame) {
138
173
    }
139
174
 
140
175
    x4->out_pic.key_frame = pic_out.b_keyframe;
141
 
    x4->out_pic.quality   = (pic_out.i_qpplus1 - 1) * FF_QP2LAMBDA;
 
176
    if (bufsize)
 
177
        x4->out_pic.quality = (pic_out.i_qpplus1 - 1) * FF_QP2LAMBDA;
142
178
 
143
179
    return bufsize;
144
180
}
156
192
    return 0;
157
193
}
158
194
 
 
195
static int convert_pix_fmt(enum PixelFormat pix_fmt)
 
196
{
 
197
    switch (pix_fmt) {
 
198
    case PIX_FMT_YUV420P:
 
199
    case PIX_FMT_YUVJ420P:
 
200
    case PIX_FMT_YUV420P9:
 
201
    case PIX_FMT_YUV420P10: return X264_CSP_I420;
 
202
    case PIX_FMT_YUV422P:
 
203
    case PIX_FMT_YUV422P10: return X264_CSP_I422;
 
204
    case PIX_FMT_YUV444P:
 
205
    case PIX_FMT_YUV444P9:
 
206
    case PIX_FMT_YUV444P10: return X264_CSP_I444;
 
207
    };
 
208
    return 0;
 
209
}
 
210
 
 
211
#define PARSE_X264_OPT(name, var)\
 
212
    if (x4->var && x264_param_parse(&x4->params, name, x4->var) < 0) {\
 
213
        av_log(avctx, AV_LOG_ERROR, "Error parsing option '%s' with value '%s'.\n", name, x4->var);\
 
214
        return AVERROR(EINVAL);\
 
215
    }
 
216
 
159
217
static av_cold int X264_init(AVCodecContext *avctx)
160
218
{
161
219
    X264Context *x4 = avctx->priv_data;
162
220
 
163
 
    x4->sei_size = 0;
164
221
    x264_param_default(&x4->params);
165
222
 
 
223
    x4->params.b_deblocking_filter         = avctx->flags & CODEC_FLAG_LOOP_FILTER;
 
224
 
 
225
    if (x4->preset || x4->tune)
 
226
        if (x264_param_default_preset(&x4->params, x4->preset, x4->tune) < 0) {
 
227
            av_log(avctx, AV_LOG_ERROR, "Error setting preset/tune %s/%s.\n", x4->preset, x4->tune);
 
228
            return AVERROR(EINVAL);
 
229
        }
 
230
 
 
231
    if (avctx->level > 0)
 
232
        x4->params.i_level_idc = avctx->level;
 
233
 
166
234
    x4->params.pf_log               = X264_log;
167
235
    x4->params.p_log_private        = avctx;
 
236
    x4->params.i_log_level          = X264_LOG_DEBUG;
 
237
    x4->params.i_csp                = convert_pix_fmt(avctx->pix_fmt);
168
238
 
169
 
    x4->params.i_keyint_max         = avctx->gop_size;
170
 
    x4->params.b_intra_refresh      = avctx->flags2 & CODEC_FLAG2_INTRA_REFRESH;
171
 
    x4->params.rc.i_bitrate         = avctx->bit_rate       / 1000;
 
239
    if (avctx->bit_rate) {
 
240
        x4->params.rc.i_bitrate   = avctx->bit_rate / 1000;
 
241
        x4->params.rc.i_rc_method = X264_RC_ABR;
 
242
    }
172
243
    x4->params.rc.i_vbv_buffer_size = avctx->rc_buffer_size / 1000;
173
244
    x4->params.rc.i_vbv_max_bitrate = avctx->rc_max_rate    / 1000;
174
245
    x4->params.rc.b_stat_write      = avctx->flags & CODEC_FLAG_PASS1;
175
246
    if (avctx->flags & CODEC_FLAG_PASS2) {
176
247
        x4->params.rc.b_stat_read = 1;
177
248
    } else {
 
249
#if FF_API_X264_GLOBAL_OPTS
178
250
        if (avctx->crf) {
179
251
            x4->params.rc.i_rc_method   = X264_RC_CRF;
180
252
            x4->params.rc.f_rf_constant = avctx->crf;
183
255
            x4->params.rc.i_rc_method   = X264_RC_CQP;
184
256
            x4->params.rc.i_qp_constant = avctx->cqp;
185
257
        }
186
 
    }
187
 
 
188
 
    // if neither crf nor cqp modes are selected we have to enable the RC
189
 
    // we do it this way because we cannot check if the bitrate has been set
190
 
    if (!(avctx->crf || (avctx->cqp > -1)))
191
 
        x4->params.rc.i_rc_method = X264_RC_ABR;
192
 
 
193
 
    x4->params.i_bframe          = avctx->max_b_frames;
194
 
    x4->params.b_cabac           = avctx->coder_type == FF_CODER_TYPE_AC;
195
 
    x4->params.i_bframe_adaptive = avctx->b_frame_strategy;
196
 
    x4->params.i_bframe_bias     = avctx->bframebias;
197
 
    x4->params.i_bframe_pyramid  = avctx->flags2 & CODEC_FLAG2_BPYRAMID ? X264_B_PYRAMID_NORMAL : X264_B_PYRAMID_NONE;
198
 
    avctx->has_b_frames          = avctx->flags2 & CODEC_FLAG2_BPYRAMID ? 2 : !!avctx->max_b_frames;
199
 
 
200
 
    x4->params.i_keyint_min = avctx->keyint_min;
201
 
    if (x4->params.i_keyint_min > x4->params.i_keyint_max)
202
 
        x4->params.i_keyint_min = x4->params.i_keyint_max;
203
 
 
204
 
    x4->params.i_scenecut_threshold        = avctx->scenechange_threshold;
205
 
 
206
 
    x4->params.b_deblocking_filter         = avctx->flags & CODEC_FLAG_LOOP_FILTER;
207
 
    x4->params.i_deblocking_filter_alphac0 = avctx->deblockalpha;
208
 
    x4->params.i_deblocking_filter_beta    = avctx->deblockbeta;
209
 
 
210
 
    x4->params.rc.i_qp_min                 = avctx->qmin;
211
 
    x4->params.rc.i_qp_max                 = avctx->qmax;
212
 
    x4->params.rc.i_qp_step                = avctx->max_qdiff;
213
 
 
214
 
    x4->params.rc.f_qcompress       = avctx->qcompress; /* 0.0 => cbr, 1.0 => constant qp */
215
 
    x4->params.rc.f_qblur           = avctx->qblur;     /* temporally blur quants */
216
 
    x4->params.rc.f_complexity_blur = avctx->complexityblur;
217
 
 
218
 
    x4->params.i_frame_reference    = avctx->refs;
219
 
 
220
 
    x4->params.i_width              = avctx->width;
221
 
    x4->params.i_height             = avctx->height;
222
 
    x4->params.vui.i_sar_width      = avctx->sample_aspect_ratio.num;
223
 
    x4->params.vui.i_sar_height     = avctx->sample_aspect_ratio.den;
224
 
    x4->params.i_fps_num = x4->params.i_timebase_den = avctx->time_base.den;
225
 
    x4->params.i_fps_den = x4->params.i_timebase_num = avctx->time_base.num;
226
 
 
227
 
    x4->params.analyse.inter    = 0;
 
258
#endif
 
259
 
 
260
        if (x4->crf >= 0) {
 
261
            x4->params.rc.i_rc_method   = X264_RC_CRF;
 
262
            x4->params.rc.f_rf_constant = x4->crf;
 
263
        } else if (x4->cqp >= 0) {
 
264
            x4->params.rc.i_rc_method   = X264_RC_CQP;
 
265
            x4->params.rc.i_qp_constant = x4->cqp;
 
266
        }
 
267
 
 
268
        if (x4->crf_max >= 0)
 
269
            x4->params.rc.f_rf_constant_max = x4->crf_max;
 
270
    }
 
271
 
 
272
    if (avctx->rc_buffer_size && avctx->rc_initial_buffer_occupancy &&
 
273
        (avctx->rc_initial_buffer_occupancy <= avctx->rc_buffer_size)) {
 
274
        x4->params.rc.f_vbv_buffer_init =
 
275
            (float)avctx->rc_initial_buffer_occupancy / avctx->rc_buffer_size;
 
276
    }
 
277
 
 
278
    x4->params.rc.f_ip_factor             = 1 / fabs(avctx->i_quant_factor);
 
279
    x4->params.rc.f_pb_factor             = avctx->b_quant_factor;
 
280
    x4->params.analyse.i_chroma_qp_offset = avctx->chromaoffset;
 
281
 
 
282
#if FF_API_X264_GLOBAL_OPTS
 
283
    if (avctx->aq_mode >= 0)
 
284
        x4->params.rc.i_aq_mode = avctx->aq_mode;
 
285
    if (avctx->aq_strength >= 0)
 
286
        x4->params.rc.f_aq_strength = avctx->aq_strength;
 
287
    if (avctx->psy_rd >= 0)
 
288
        x4->params.analyse.f_psy_rd           = avctx->psy_rd;
 
289
    if (avctx->psy_trellis >= 0)
 
290
        x4->params.analyse.f_psy_trellis      = avctx->psy_trellis;
 
291
    if (avctx->rc_lookahead >= 0)
 
292
        x4->params.rc.i_lookahead             = avctx->rc_lookahead;
 
293
    if (avctx->weighted_p_pred >= 0)
 
294
        x4->params.analyse.i_weighted_pred    = avctx->weighted_p_pred;
 
295
    if (avctx->bframebias)
 
296
        x4->params.i_bframe_bias              = avctx->bframebias;
 
297
    if (avctx->deblockalpha)
 
298
        x4->params.i_deblocking_filter_alphac0 = avctx->deblockalpha;
 
299
    if (avctx->deblockbeta)
 
300
        x4->params.i_deblocking_filter_beta    = avctx->deblockbeta;
 
301
    if (avctx->complexityblur >= 0)
 
302
        x4->params.rc.f_complexity_blur        = avctx->complexityblur;
 
303
    if (avctx->directpred >= 0)
 
304
        x4->params.analyse.i_direct_mv_pred    = avctx->directpred;
228
305
    if (avctx->partitions) {
229
306
        if (avctx->partitions & X264_PART_I4X4)
230
307
            x4->params.analyse.inter |= X264_ANALYSE_I4x4;
237
314
        if (avctx->partitions & X264_PART_B8X8)
238
315
            x4->params.analyse.inter |= X264_ANALYSE_BSUB16x16;
239
316
    }
240
 
 
241
 
    x4->params.analyse.i_direct_mv_pred  = avctx->directpred;
242
 
 
 
317
    x4->params.analyse.b_ssim = avctx->flags2 & CODEC_FLAG2_SSIM;
 
318
    x4->params.b_intra_refresh = avctx->flags2 & CODEC_FLAG2_INTRA_REFRESH;
 
319
    x4->params.i_bframe_pyramid = avctx->flags2 & CODEC_FLAG2_BPYRAMID ? X264_B_PYRAMID_NORMAL : X264_B_PYRAMID_NONE;
243
320
    x4->params.analyse.b_weighted_bipred = avctx->flags2 & CODEC_FLAG2_WPRED;
244
 
    x4->params.analyse.i_weighted_pred = avctx->weighted_p_pred;
 
321
    x4->params.analyse.b_mixed_references = avctx->flags2 & CODEC_FLAG2_MIXED_REFS;
 
322
    x4->params.analyse.b_transform_8x8    = avctx->flags2 & CODEC_FLAG2_8X8DCT;
 
323
    x4->params.analyse.b_fast_pskip       = avctx->flags2 & CODEC_FLAG2_FASTPSKIP;
 
324
    x4->params.b_aud                      = avctx->flags2 & CODEC_FLAG2_AUD;
 
325
    x4->params.analyse.b_psy              = avctx->flags2 & CODEC_FLAG2_PSY;
 
326
    x4->params.rc.b_mb_tree               = !!(avctx->flags2 & CODEC_FLAG2_MBTREE);
 
327
#endif
245
328
 
246
329
    if (avctx->me_method == ME_EPZS)
247
330
        x4->params.analyse.i_me_method = X264_ME_DIA;
253
336
        x4->params.analyse.i_me_method = X264_ME_ESA;
254
337
    else if (avctx->me_method == ME_TESA)
255
338
        x4->params.analyse.i_me_method = X264_ME_TESA;
256
 
    else x4->params.analyse.i_me_method = X264_ME_HEX;
257
 
 
258
 
    x4->params.rc.i_aq_mode               = avctx->aq_mode;
259
 
    x4->params.rc.f_aq_strength           = avctx->aq_strength;
260
 
    x4->params.rc.i_lookahead             = avctx->rc_lookahead;
261
 
 
262
 
    x4->params.analyse.b_psy              = avctx->flags2 & CODEC_FLAG2_PSY;
263
 
    x4->params.analyse.f_psy_rd           = avctx->psy_rd;
264
 
    x4->params.analyse.f_psy_trellis      = avctx->psy_trellis;
265
 
 
266
 
    x4->params.analyse.i_me_range         = avctx->me_range;
267
 
    x4->params.analyse.i_subpel_refine    = avctx->me_subpel_quality;
268
 
 
269
 
    x4->params.analyse.b_mixed_references = avctx->flags2 & CODEC_FLAG2_MIXED_REFS;
270
 
    x4->params.analyse.b_chroma_me        = avctx->me_cmp & FF_CMP_CHROMA;
271
 
    x4->params.analyse.b_transform_8x8    = avctx->flags2 & CODEC_FLAG2_8X8DCT;
272
 
    x4->params.analyse.b_fast_pskip       = avctx->flags2 & CODEC_FLAG2_FASTPSKIP;
273
 
 
274
 
    x4->params.analyse.i_trellis          = avctx->trellis;
275
 
    x4->params.analyse.i_noise_reduction  = avctx->noise_reduction;
276
 
 
277
 
    if (avctx->level > 0)
278
 
        x4->params.i_level_idc = avctx->level;
279
 
 
280
 
    if (avctx->rc_buffer_size && avctx->rc_initial_buffer_occupancy &&
281
 
        (avctx->rc_initial_buffer_occupancy <= avctx->rc_buffer_size)) {
282
 
        x4->params.rc.f_vbv_buffer_init =
283
 
            (float)avctx->rc_initial_buffer_occupancy / avctx->rc_buffer_size;
284
 
    }
285
 
 
286
 
    x4->params.rc.b_mb_tree               = !!(avctx->flags2 & CODEC_FLAG2_MBTREE);
287
 
    x4->params.rc.f_ip_factor             = 1 / fabs(avctx->i_quant_factor);
288
 
    x4->params.rc.f_pb_factor             = avctx->b_quant_factor;
289
 
    x4->params.analyse.i_chroma_qp_offset = avctx->chromaoffset;
 
339
 
 
340
    if (avctx->gop_size >= 0)
 
341
        x4->params.i_keyint_max         = avctx->gop_size;
 
342
    if (avctx->max_b_frames >= 0)
 
343
        x4->params.i_bframe             = avctx->max_b_frames;
 
344
    if (avctx->scenechange_threshold >= 0)
 
345
        x4->params.i_scenecut_threshold = avctx->scenechange_threshold;
 
346
    if (avctx->qmin >= 0)
 
347
        x4->params.rc.i_qp_min          = avctx->qmin;
 
348
    if (avctx->qmax >= 0)
 
349
        x4->params.rc.i_qp_max          = avctx->qmax;
 
350
    if (avctx->max_qdiff >= 0)
 
351
        x4->params.rc.i_qp_step         = avctx->max_qdiff;
 
352
    if (avctx->qblur >= 0)
 
353
        x4->params.rc.f_qblur           = avctx->qblur;     /* temporally blur quants */
 
354
    if (avctx->qcompress >= 0)
 
355
        x4->params.rc.f_qcompress       = avctx->qcompress; /* 0.0 => cbr, 1.0 => constant qp */
 
356
    if (avctx->refs >= 0)
 
357
        x4->params.i_frame_reference    = avctx->refs;
 
358
    if (avctx->trellis >= 0)
 
359
        x4->params.analyse.i_trellis    = avctx->trellis;
 
360
    if (avctx->me_range >= 0)
 
361
        x4->params.analyse.i_me_range   = avctx->me_range;
 
362
    if (avctx->noise_reduction >= 0)
 
363
        x4->params.analyse.i_noise_reduction = avctx->noise_reduction;
 
364
    if (avctx->me_subpel_quality >= 0)
 
365
        x4->params.analyse.i_subpel_refine   = avctx->me_subpel_quality;
 
366
    if (avctx->b_frame_strategy >= 0)
 
367
        x4->params.i_bframe_adaptive = avctx->b_frame_strategy;
 
368
    if (avctx->keyint_min >= 0)
 
369
        x4->params.i_keyint_min = avctx->keyint_min;
 
370
    if (avctx->coder_type >= 0)
 
371
        x4->params.b_cabac = avctx->coder_type == FF_CODER_TYPE_AC;
 
372
    if (avctx->me_cmp >= 0)
 
373
        x4->params.analyse.b_chroma_me = avctx->me_cmp & FF_CMP_CHROMA;
 
374
 
 
375
    if (x4->aq_mode >= 0)
 
376
        x4->params.rc.i_aq_mode = x4->aq_mode;
 
377
    if (x4->aq_strength >= 0)
 
378
        x4->params.rc.f_aq_strength = x4->aq_strength;
 
379
    PARSE_X264_OPT("psy-rd", psy_rd);
 
380
    PARSE_X264_OPT("deblock", deblock);
 
381
    PARSE_X264_OPT("partitions", partitions);
 
382
    if (x4->psy >= 0)
 
383
        x4->params.analyse.b_psy  = x4->psy;
 
384
    if (x4->rc_lookahead >= 0)
 
385
        x4->params.rc.i_lookahead = x4->rc_lookahead;
 
386
    if (x4->weightp >= 0)
 
387
        x4->params.analyse.i_weighted_pred = x4->weightp;
 
388
    if (x4->weightb >= 0)
 
389
        x4->params.analyse.b_weighted_bipred = x4->weightb;
 
390
    if (x4->cplxblur >= 0)
 
391
        x4->params.rc.f_complexity_blur = x4->cplxblur;
 
392
 
 
393
    if (x4->ssim >= 0)
 
394
        x4->params.analyse.b_ssim = x4->ssim;
 
395
    if (x4->intra_refresh >= 0)
 
396
        x4->params.b_intra_refresh = x4->intra_refresh;
 
397
    if (x4->b_bias != INT_MIN)
 
398
        x4->params.i_bframe_bias              = x4->b_bias;
 
399
    if (x4->b_pyramid >= 0)
 
400
        x4->params.i_bframe_pyramid = x4->b_pyramid;
 
401
    if (x4->mixed_refs >= 0)
 
402
        x4->params.analyse.b_mixed_references = x4->mixed_refs;
 
403
    if (x4->dct8x8 >= 0)
 
404
        x4->params.analyse.b_transform_8x8    = x4->dct8x8;
 
405
    if (x4->fast_pskip >= 0)
 
406
        x4->params.analyse.b_fast_pskip       = x4->fast_pskip;
 
407
    if (x4->aud >= 0)
 
408
        x4->params.b_aud                      = x4->aud;
 
409
    if (x4->mbtree >= 0)
 
410
        x4->params.rc.b_mb_tree               = x4->mbtree;
 
411
    if (x4->direct_pred >= 0)
 
412
        x4->params.analyse.i_direct_mv_pred   = x4->direct_pred;
 
413
 
 
414
    if (x4->slice_max_size >= 0)
 
415
        x4->params.i_slice_max_size =  x4->slice_max_size;
 
416
 
 
417
    if (x4->fastfirstpass)
 
418
        x264_param_apply_fastfirstpass(&x4->params);
 
419
 
 
420
    if (x4->profile)
 
421
        if (x264_param_apply_profile(&x4->params, x4->profile) < 0) {
 
422
            av_log(avctx, AV_LOG_ERROR, "Error setting profile %s.\n", x4->profile);
 
423
            return AVERROR(EINVAL);
 
424
        }
 
425
 
 
426
    x4->params.i_width          = avctx->width;
 
427
    x4->params.i_height         = avctx->height;
 
428
    x4->params.vui.i_sar_width  = avctx->sample_aspect_ratio.num;
 
429
    x4->params.vui.i_sar_height = avctx->sample_aspect_ratio.den;
 
430
    x4->params.i_fps_num = x4->params.i_timebase_den = avctx->time_base.den;
 
431
    x4->params.i_fps_den = x4->params.i_timebase_num = avctx->time_base.num;
290
432
 
291
433
    x4->params.analyse.b_psnr = avctx->flags & CODEC_FLAG_PSNR;
292
 
    x4->params.analyse.b_ssim = avctx->flags2 & CODEC_FLAG2_SSIM;
293
 
    x4->params.i_log_level    = X264_LOG_DEBUG;
294
 
 
295
 
    x4->params.b_aud          = avctx->flags2 & CODEC_FLAG2_AUD;
296
434
 
297
435
    x4->params.i_threads      = avctx->thread_count;
298
436
 
307
445
    if (avctx->flags & CODEC_FLAG_GLOBAL_HEADER)
308
446
        x4->params.b_repeat_headers = 0;
309
447
 
 
448
    // update AVCodecContext with x264 parameters
 
449
    avctx->has_b_frames = x4->params.i_bframe ?
 
450
        x4->params.i_bframe_pyramid ? 2 : 1 : 0;
 
451
    avctx->bit_rate = x4->params.rc.i_bitrate*1000;
 
452
#if FF_API_X264_GLOBAL_OPTS
 
453
    avctx->crf = x4->params.rc.f_rf_constant;
 
454
#endif
 
455
 
310
456
    x4->enc = x264_encoder_open(&x4->params);
311
457
    if (!x4->enc)
312
458
        return -1;
330
476
    return 0;
331
477
}
332
478
 
 
479
static const enum PixelFormat pix_fmts_8bit[] = {
 
480
    PIX_FMT_YUV420P,
 
481
    PIX_FMT_YUVJ420P,
 
482
    PIX_FMT_YUV422P,
 
483
    PIX_FMT_YUV444P,
 
484
    PIX_FMT_NONE
 
485
};
 
486
static const enum PixelFormat pix_fmts_9bit[] = {
 
487
    PIX_FMT_YUV420P9,
 
488
    PIX_FMT_YUV444P9,
 
489
    PIX_FMT_NONE
 
490
};
 
491
static const enum PixelFormat pix_fmts_10bit[] = {
 
492
    PIX_FMT_YUV420P10,
 
493
    PIX_FMT_YUV422P10,
 
494
    PIX_FMT_YUV444P10,
 
495
    PIX_FMT_NONE
 
496
};
 
497
 
 
498
static av_cold void X264_init_static(AVCodec *codec)
 
499
{
 
500
    if (x264_bit_depth == 8)
 
501
        codec->pix_fmts = pix_fmts_8bit;
 
502
    else if (x264_bit_depth == 9)
 
503
        codec->pix_fmts = pix_fmts_9bit;
 
504
    else if (x264_bit_depth == 10)
 
505
        codec->pix_fmts = pix_fmts_10bit;
 
506
}
 
507
 
 
508
#define OFFSET(x) offsetof(X264Context, x)
 
509
#define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
 
510
static const AVOption options[] = {
 
511
    { "preset",        "Set the encoding preset (cf. x264 --fullhelp)",   OFFSET(preset),        AV_OPT_TYPE_STRING, { .str = "medium" }, 0, 0, VE},
 
512
    { "tune",          "Tune the encoding params (cf. x264 --fullhelp)",  OFFSET(tune),          AV_OPT_TYPE_STRING, { 0 }, 0, 0, VE},
 
513
    { "profile",       "Set profile restrictions (cf. x264 --fullhelp) ", OFFSET(profile),       AV_OPT_TYPE_STRING, { 0 }, 0, 0, VE},
 
514
    { "fastfirstpass", "Use fast settings when encoding first pass",      OFFSET(fastfirstpass), AV_OPT_TYPE_INT,    { 1 }, 0, 1, VE},
 
515
    { "crf",           "Select the quality for constant quality mode",    OFFSET(crf),           AV_OPT_TYPE_FLOAT,  {-1 }, -1, FLT_MAX, VE },
 
516
    { "crf_max",       "In CRF mode, prevents VBV from lowering quality beyond this point.",OFFSET(crf_max), AV_OPT_TYPE_FLOAT, {-1 }, -1, FLT_MAX, VE },
 
517
    { "qp",            "Constant quantization parameter rate control method",OFFSET(cqp),        AV_OPT_TYPE_INT,    {-1 }, -1, INT_MAX, VE },
 
518
    { "aq-mode",       "AQ method",                                       OFFSET(aq_mode),       AV_OPT_TYPE_INT,    {-1 }, -1, INT_MAX, VE, "aq_mode"},
 
519
    { "none",          NULL,                              0, AV_OPT_TYPE_CONST, {X264_AQ_NONE},         INT_MIN, INT_MAX, VE, "aq_mode" },
 
520
    { "variance",      "Variance AQ (complexity mask)",   0, AV_OPT_TYPE_CONST, {X264_AQ_VARIANCE},     INT_MIN, INT_MAX, VE, "aq_mode" },
 
521
    { "autovariance",  "Auto-variance AQ (experimental)", 0, AV_OPT_TYPE_CONST, {X264_AQ_AUTOVARIANCE}, INT_MIN, INT_MAX, VE, "aq_mode" },
 
522
    { "aq-strength",   "AQ strength. Reduces blocking and blurring in flat and textured areas.", OFFSET(aq_strength), AV_OPT_TYPE_FLOAT, {-1}, -1, FLT_MAX, VE},
 
523
    { "psy",           "Use psychovisual optimizations.",                 OFFSET(psy),           AV_OPT_TYPE_INT,    {-1 }, -1, 1, VE },
 
524
    { "psy-rd",        "Strength of psychovisual optimization, in <psy-rd>:<psy-trellis> format.", OFFSET(psy_rd), AV_OPT_TYPE_STRING,  {0 }, 0, 0, VE},
 
525
    { "rc-lookahead",  "Number of frames to look ahead for frametype and ratecontrol", OFFSET(rc_lookahead), AV_OPT_TYPE_INT, {-1 }, -1, INT_MAX, VE },
 
526
    { "weightb",       "Weighted prediction for B-frames.",               OFFSET(weightb),       AV_OPT_TYPE_INT,    {-1 }, -1, 1, VE },
 
527
    { "weightp",       "Weighted prediction analysis method.",            OFFSET(weightp),       AV_OPT_TYPE_INT,    {-1 }, -1, INT_MAX, VE, "weightp" },
 
528
    { "none",          NULL, 0, AV_OPT_TYPE_CONST, {X264_WEIGHTP_NONE},   INT_MIN, INT_MAX, VE, "weightp" },
 
529
    { "simple",        NULL, 0, AV_OPT_TYPE_CONST, {X264_WEIGHTP_SIMPLE}, INT_MIN, INT_MAX, VE, "weightp" },
 
530
    { "smart",         NULL, 0, AV_OPT_TYPE_CONST, {X264_WEIGHTP_SMART},  INT_MIN, INT_MAX, VE, "weightp" },
 
531
    { "ssim",          "Calculate and print SSIM stats.",                 OFFSET(ssim),          AV_OPT_TYPE_INT,    {-1 }, -1, 1, VE },
 
532
    { "intra-refresh", "Use Periodic Intra Refresh instead of IDR frames.",OFFSET(intra_refresh),AV_OPT_TYPE_INT,    {-1 }, -1, 1, VE },
 
533
    { "b-bias",        "Influences how often B-frames are used",          OFFSET(b_bias),        AV_OPT_TYPE_INT,    {INT_MIN}, INT_MIN, INT_MAX, VE },
 
534
    { "b-pyramid",     "Keep some B-frames as references.",               OFFSET(b_pyramid),     AV_OPT_TYPE_INT,    {-1 }, -1, INT_MAX, VE, "b_pyramid" },
 
535
    { "none",          NULL,                                  0, AV_OPT_TYPE_CONST, {X264_B_PYRAMID_NONE},   INT_MIN, INT_MAX, VE, "b_pyramid" },
 
536
    { "strict",        "Strictly hierarchical pyramid",       0, AV_OPT_TYPE_CONST, {X264_B_PYRAMID_STRICT}, INT_MIN, INT_MAX, VE, "b_pyramid" },
 
537
    { "normal",        "Non-strict (not Blu-ray compatible)", 0, AV_OPT_TYPE_CONST, {X264_B_PYRAMID_NORMAL}, INT_MIN, INT_MAX, VE, "b_pyramid" },
 
538
    { "mixed-refs",    "One reference per partition, as opposed to one reference per macroblock", OFFSET(mixed_refs), AV_OPT_TYPE_INT, {-1}, -1, 1, VE },
 
539
    { "8x8dct",        "High profile 8x8 transform.",                     OFFSET(dct8x8),        AV_OPT_TYPE_INT,    {-1 }, -1, 1, VE},
 
540
    { "fast-pskip",    NULL,                                              OFFSET(fast_pskip),    AV_OPT_TYPE_INT,    {-1 }, -1, 1, VE},
 
541
    { "aud",           "Use access unit delimiters.",                     OFFSET(aud),           AV_OPT_TYPE_INT,    {-1 }, -1, 1, VE},
 
542
    { "mbtree",        "Use macroblock tree ratecontrol.",                OFFSET(mbtree),        AV_OPT_TYPE_INT,    {-1 }, -1, 1, VE},
 
543
    { "deblock",       "Loop filter parameters, in <alpha:beta> form.",   OFFSET(deblock),       AV_OPT_TYPE_STRING, { 0 },  0, 0, VE},
 
544
    { "cplxblur",      "Reduce fluctuations in QP (before curve compression)", OFFSET(cplxblur), AV_OPT_TYPE_FLOAT,  {-1 }, -1, FLT_MAX, VE},
 
545
    { "partitions",    "A comma-separated list of partitions to consider. "
 
546
                       "Possible values: p8x8, p4x4, b8x8, i8x8, i4x4, none, all", OFFSET(partitions), AV_OPT_TYPE_STRING, { 0 }, 0, 0, VE},
 
547
    { "direct-pred",   "Direct MV prediction mode",                       OFFSET(direct_pred),   AV_OPT_TYPE_INT,    {-1 }, -1, INT_MAX, VE, "direct-pred" },
 
548
    { "none",          NULL,      0,    AV_OPT_TYPE_CONST, { X264_DIRECT_PRED_NONE },     0, 0, VE, "direct-pred" },
 
549
    { "spatial",       NULL,      0,    AV_OPT_TYPE_CONST, { X264_DIRECT_PRED_SPATIAL },  0, 0, VE, "direct-pred" },
 
550
    { "temporal",      NULL,      0,    AV_OPT_TYPE_CONST, { X264_DIRECT_PRED_TEMPORAL }, 0, 0, VE, "direct-pred" },
 
551
    { "auto",          NULL,      0,    AV_OPT_TYPE_CONST, { X264_DIRECT_PRED_AUTO },     0, 0, VE, "direct-pred" },
 
552
    { "slice-max-size","Constant quantization parameter rate control method",OFFSET(slice_max_size),        AV_OPT_TYPE_INT,    {-1 }, -1, INT_MAX, VE },
 
553
    { NULL },
 
554
};
 
555
 
 
556
static const AVClass class = {
 
557
    .class_name = "libx264",
 
558
    .item_name  = av_default_item_name,
 
559
    .option     = options,
 
560
    .version    = LIBAVUTIL_VERSION_INT,
 
561
};
 
562
 
 
563
static const AVCodecDefault x264_defaults[] = {
 
564
    { "b",                "0" },
 
565
    { "bf",               "-1" },
 
566
    { "g",                "-1" },
 
567
    { "qmin",             "-1" },
 
568
    { "qmax",             "-1" },
 
569
    { "qdiff",            "-1" },
 
570
    { "qblur",            "-1" },
 
571
    { "qcomp",            "-1" },
 
572
    { "refs",             "-1" },
 
573
    { "sc_threshold",     "-1" },
 
574
    { "trellis",          "-1" },
 
575
    { "nr",               "-1" },
 
576
    { "me_range",         "-1" },
 
577
    { "me_method",        "-1" },
 
578
    { "subq",             "-1" },
 
579
    { "b_strategy",       "-1" },
 
580
    { "keyint_min",       "-1" },
 
581
    { "coder",            "-1" },
 
582
    { "cmp",              "-1" },
 
583
    { "threads",          AV_STRINGIFY(X264_THREADS_AUTO) },
 
584
    { NULL },
 
585
};
 
586
 
333
587
AVCodec ff_libx264_encoder = {
334
588
    .name           = "libx264",
335
589
    .type           = AVMEDIA_TYPE_VIDEO,
338
592
    .init           = X264_init,
339
593
    .encode         = X264_frame,
340
594
    .close          = X264_close,
341
 
    .capabilities   = CODEC_CAP_DELAY,
342
 
    .pix_fmts       = (const enum PixelFormat[]) { PIX_FMT_YUV420P, PIX_FMT_YUVJ420P, PIX_FMT_NONE },
 
595
    .capabilities   = CODEC_CAP_DELAY | CODEC_CAP_AUTO_THREADS,
343
596
    .long_name      = NULL_IF_CONFIG_SMALL("libx264 H.264 / AVC / MPEG-4 AVC / MPEG-4 part 10"),
 
597
    .priv_class     = &class,
 
598
    .defaults       = x264_defaults,
 
599
    .init_static_data = X264_init_static,
344
600
};