2 * Interface to xvidcore for mpeg4 encoding
3 * Copyright (c) 2004 Adam Thayer <krevnik@comcast.net>
5 * This file is part of Libav.
7 * Libav is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
12 * Libav is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with Libav; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
24 * Interface to xvidcore for MPEG-4 compliant encoding.
25 * @author Adam Thayer (krevnik@comcast.net)
31 #include "libavutil/cpu.h"
32 #include "libavutil/intreadwrite.h"
33 #include "libavutil/mathematics.h"
35 #include "mpegvideo.h"
38 * Buffer management macros.
40 #define BUFFER_SIZE 1024
41 #define BUFFER_REMAINING(x) (BUFFER_SIZE - strlen(x))
42 #define BUFFER_CAT(x) (&((x)[strlen(x)]))
45 * Structure for the private Xvid context.
46 * This stores all the private context for the codec.
49 void *encoder_handle
; /**< Handle for Xvid encoder */
50 int xsize
; /**< Frame x size */
51 int ysize
; /**< Frame y size */
52 int vop_flags
; /**< VOP flags for Xvid encoder */
53 int vol_flags
; /**< VOL flags for Xvid encoder */
54 int me_flags
; /**< Motion Estimation flags */
55 int qscale
; /**< Do we use constant scale? */
56 int quicktime_format
; /**< Are we in a QT-based format? */
57 AVFrame encoded_picture
; /**< Encoded frame information */
58 char *twopassbuffer
; /**< Character buffer for two-pass */
59 char *old_twopassbuffer
; /**< Old character buffer (two-pass) */
60 char *twopassfile
; /**< second pass temp file name */
61 unsigned char *intra_matrix
; /**< P-Frame Quant Matrix */
62 unsigned char *inter_matrix
; /**< I-Frame Quant Matrix */
66 * Structure for the private first-pass plugin.
68 struct xvid_ff_pass1
{
69 int version
; /**< Xvid version */
70 struct xvid_context
*context
; /**< Pointer to private context */
74 * Xvid 2-Pass Kludge Section
76 * Xvid's default 2-pass doesn't allow us to create data as we need to, so
77 * this section spends time replacing the first pass plugin so we can write
78 * statistic information as libavcodec requests in. We have another kludge
79 * that allows us to pass data to the second pass in Xvid without a custom
80 * rate-control plugin.
84 * Initialize the two-pass plugin and context.
86 * @param param Input construction parameter structure
87 * @param handle Private context handle
88 * @return Returns XVID_ERR_xxxx on failure, or 0 on success.
90 static int xvid_ff_2pass_create(xvid_plg_create_t
* param
,
92 struct xvid_ff_pass1
*x
= (struct xvid_ff_pass1
*)param
->param
;
93 char *log
= x
->context
->twopassbuffer
;
95 /* Do a quick bounds check */
99 /* We use snprintf() */
100 /* This is because we can safely prevent a buffer overflow */
102 snprintf(log
, BUFFER_REMAINING(log
),
103 "# avconv 2-pass log file, using xvid codec\n");
104 snprintf(BUFFER_CAT(log
), BUFFER_REMAINING(log
),
105 "# Do not modify. libxvidcore version: %d.%d.%d\n\n",
106 XVID_VERSION_MAJOR(XVID_VERSION
),
107 XVID_VERSION_MINOR(XVID_VERSION
),
108 XVID_VERSION_PATCH(XVID_VERSION
));
110 *handle
= x
->context
;
115 * Destroy the two-pass plugin context.
117 * @param ref Context pointer for the plugin
118 * @param param Destrooy context
119 * @return Returns 0, success guaranteed
121 static int xvid_ff_2pass_destroy(struct xvid_context
*ref
,
122 xvid_plg_destroy_t
*param
) {
123 /* Currently cannot think of anything to do on destruction */
124 /* Still, the framework should be here for reference/use */
125 if( ref
->twopassbuffer
!= NULL
)
126 ref
->twopassbuffer
[0] = 0;
131 * Enable fast encode mode during the first pass.
133 * @param ref Context pointer for the plugin
134 * @param param Frame data
135 * @return Returns 0, success guaranteed
137 static int xvid_ff_2pass_before(struct xvid_context
*ref
,
138 xvid_plg_data_t
*param
) {
140 int motion_replacements
;
143 /* Nothing to do here, result is changed too much */
144 if( param
->zone
&& param
->zone
->mode
== XVID_ZONE_QUANT
)
147 /* We can implement a 'turbo' first pass mode here */
151 motion_remove
= ~XVID_ME_CHROMA_PVOP
&
152 ~XVID_ME_CHROMA_BVOP
&
153 ~XVID_ME_EXTSEARCH16
&
154 ~XVID_ME_ADVANCEDDIAMOND16
;
155 motion_replacements
= XVID_ME_FAST_MODEINTERPOLATE
|
156 XVID_ME_SKIP_DELTASEARCH
|
157 XVID_ME_FASTREFINE16
|
158 XVID_ME_BFRAME_EARLYSTOP
;
159 vop_remove
= ~XVID_VOP_MODEDECISION_RD
&
160 ~XVID_VOP_FAST_MODEDECISION_RD
&
161 ~XVID_VOP_TRELLISQUANT
&
165 param
->vol_flags
&= ~XVID_VOL_GMC
;
166 param
->vop_flags
&= vop_remove
;
167 param
->motion_flags
&= motion_remove
;
168 param
->motion_flags
|= motion_replacements
;
174 * Capture statistic data and write it during first pass.
176 * @param ref Context pointer for the plugin
177 * @param param Statistic data
178 * @return Returns XVID_ERR_xxxx on failure, or 0 on success
180 static int xvid_ff_2pass_after(struct xvid_context
*ref
,
181 xvid_plg_data_t
*param
) {
182 char *log
= ref
->twopassbuffer
;
183 const char *frame_types
= " ipbs";
186 /* Quick bounds check */
188 return XVID_ERR_FAIL
;
190 /* Convert the type given to us into a character */
191 if( param
->type
< 5 && param
->type
> 0 ) {
192 frame_type
= frame_types
[param
->type
];
194 return XVID_ERR_FAIL
;
197 snprintf(BUFFER_CAT(log
), BUFFER_REMAINING(log
),
198 "%c %d %d %d %d %d %d\n",
199 frame_type
, param
->stats
.quant
, param
->stats
.kblks
, param
->stats
.mblks
,
200 param
->stats
.ublks
, param
->stats
.length
, param
->stats
.hlength
);
206 * Dispatch function for our custom plugin.
207 * This handles the dispatch for the Xvid plugin. It passes data
208 * on to other functions for actual processing.
210 * @param ref Context pointer for the plugin
211 * @param cmd The task given for us to complete
212 * @param p1 First parameter (varies)
213 * @param p2 Second parameter (varies)
214 * @return Returns XVID_ERR_xxxx on failure, or 0 on success
216 static int xvid_ff_2pass(void *ref
, int cmd
, void *p1
, void *p2
)
223 case XVID_PLG_BEFORE
:
224 return xvid_ff_2pass_before(ref
, p1
);
226 case XVID_PLG_CREATE
:
227 return xvid_ff_2pass_create(p1
, p2
);
230 return xvid_ff_2pass_after(ref
, p1
);
232 case XVID_PLG_DESTROY
:
233 return xvid_ff_2pass_destroy(ref
, p1
);
236 return XVID_ERR_FAIL
;
241 * Routine to create a global VO/VOL header for MP4 container.
242 * What we do here is extract the header from the Xvid bitstream
243 * as it is encoded. We also strip the repeated headers from the
244 * bitstream when a global header is requested for MPEG-4 ISO
247 * @param avctx AVCodecContext pointer to context
248 * @param frame Pointer to encoded frame data
249 * @param header_len Length of header to search
250 * @param frame_len Length of encoded frame data
251 * @return Returns new length of frame data
253 static int xvid_strip_vol_header(AVCodecContext
*avctx
,
255 unsigned int header_len
,
256 unsigned int frame_len
) {
259 for( i
= 0; i
< header_len
- 3; i
++ ) {
260 if( pkt
->data
[i
] == 0x00 &&
261 pkt
->data
[i
+1] == 0x00 &&
262 pkt
->data
[i
+2] == 0x01 &&
263 pkt
->data
[i
+3] == 0xB6 ) {
270 /* We need to store the header, so extract it */
271 if( avctx
->extradata
== NULL
) {
272 avctx
->extradata
= av_malloc(vo_len
);
273 memcpy(avctx
->extradata
, pkt
->data
, vo_len
);
274 avctx
->extradata_size
= vo_len
;
276 /* Less dangerous now, memmove properly copies the two
277 chunks of overlapping data */
278 memmove(pkt
->data
, &pkt
->data
[vo_len
], frame_len
- vo_len
);
279 pkt
->size
= frame_len
- vo_len
;
285 * Routine to correct a possibly erroneous framerate being fed to us.
286 * Xvid currently chokes on framerates where the ticks per frame is
287 * extremely large. This function works to correct problems in this area
288 * by estimating a new framerate and taking the simpler fraction of
291 * @param avctx Context that contains the framerate to correct.
293 static void xvid_correct_framerate(AVCodecContext
*avctx
)
296 int est_frate
, est_fbase
;
300 frate
= avctx
->time_base
.den
;
301 fbase
= avctx
->time_base
.num
;
303 gcd
= av_gcd(frate
, fbase
);
309 if( frate
<= 65000 && fbase
<= 65000 ) {
310 avctx
->time_base
.den
= frate
;
311 avctx
->time_base
.num
= fbase
;
315 fps
= (float)frate
/ (float)fbase
;
316 est_fps
= roundf(fps
* 1000.0) / 1000.0;
318 est_frate
= (int)est_fps
;
319 if( est_fps
> (int)est_fps
) {
320 est_frate
= (est_frate
+ 1) * 1000;
321 est_fbase
= (int)roundf((float)est_frate
/ est_fps
);
325 gcd
= av_gcd(est_frate
, est_fbase
);
331 if( fbase
> est_fbase
) {
332 avctx
->time_base
.den
= est_frate
;
333 avctx
->time_base
.num
= est_fbase
;
334 av_log(avctx
, AV_LOG_DEBUG
,
335 "Xvid: framerate re-estimated: %.2f, %.3f%% correction\n",
336 est_fps
, (((est_fps
- fps
)/fps
) * 100.0));
338 avctx
->time_base
.den
= frate
;
339 avctx
->time_base
.num
= fbase
;
343 static av_cold
int xvid_encode_init(AVCodecContext
*avctx
) {
345 int xvid_flags
= avctx
->flags
;
346 struct xvid_context
*x
= avctx
->priv_data
;
347 uint16_t *intra
, *inter
;
350 xvid_plugin_single_t single
= { 0 };
351 struct xvid_ff_pass1 rc2pass1
= { 0 };
352 xvid_plugin_2pass2_t rc2pass2
= { 0 };
353 xvid_gbl_init_t xvid_gbl_init
= { 0 };
354 xvid_enc_create_t xvid_enc_create
= { 0 };
355 xvid_enc_plugin_t plugins
[7];
357 /* Bring in VOP flags from avconv command-line */
358 x
->vop_flags
= XVID_VOP_HALFPEL
; /* Bare minimum quality */
359 if( xvid_flags
& CODEC_FLAG_4MV
)
360 x
->vop_flags
|= XVID_VOP_INTER4V
; /* Level 3 */
363 x
->vop_flags
|= XVID_VOP_TRELLISQUANT
; /* Level 5 */
364 if( xvid_flags
& CODEC_FLAG_AC_PRED
)
365 x
->vop_flags
|= XVID_VOP_HQACPRED
; /* Level 6 */
366 if( xvid_flags
& CODEC_FLAG_GRAY
)
367 x
->vop_flags
|= XVID_VOP_GREYSCALE
;
369 /* Decide which ME quality setting to use */
371 switch( avctx
->me_method
) {
372 case ME_FULL
: /* Quality 6 */
373 x
->me_flags
|= XVID_ME_EXTSEARCH16
374 | XVID_ME_EXTSEARCH8
;
376 case ME_EPZS
: /* Quality 4 */
377 x
->me_flags
|= XVID_ME_ADVANCEDDIAMOND8
378 | XVID_ME_HALFPELREFINE8
379 | XVID_ME_CHROMA_PVOP
380 | XVID_ME_CHROMA_BVOP
;
382 case ME_LOG
: /* Quality 2 */
385 x
->me_flags
|= XVID_ME_ADVANCEDDIAMOND16
386 | XVID_ME_HALFPELREFINE16
;
388 case ME_ZERO
: /* Quality 0 */
393 /* Decide how we should decide blocks */
394 switch( avctx
->mb_decision
) {
396 x
->vop_flags
|= XVID_VOP_MODEDECISION_RD
;
397 x
->me_flags
|= XVID_ME_HALFPELREFINE8_RD
398 | XVID_ME_QUARTERPELREFINE8_RD
399 | XVID_ME_EXTSEARCH_RD
400 | XVID_ME_CHECKPREDICTION_RD
;
402 if( !(x
->vop_flags
& XVID_VOP_MODEDECISION_RD
) )
403 x
->vop_flags
|= XVID_VOP_FAST_MODEDECISION_RD
;
404 x
->me_flags
|= XVID_ME_HALFPELREFINE16_RD
405 | XVID_ME_QUARTERPELREFINE16_RD
;
411 /* Bring in VOL flags from avconv command-line */
413 if( xvid_flags
& CODEC_FLAG_GMC
) {
414 x
->vol_flags
|= XVID_VOL_GMC
;
415 x
->me_flags
|= XVID_ME_GME_REFINE
;
417 if( xvid_flags
& CODEC_FLAG_QPEL
) {
418 x
->vol_flags
|= XVID_VOL_QUARTERPEL
;
419 x
->me_flags
|= XVID_ME_QUARTERPELREFINE16
;
420 if( x
->vop_flags
& XVID_VOP_INTER4V
)
421 x
->me_flags
|= XVID_ME_QUARTERPELREFINE8
;
424 xvid_gbl_init
.version
= XVID_VERSION
;
425 xvid_gbl_init
.debug
= 0;
428 /* Xvid's PPC support is borked, use libavcodec to detect */
430 if (av_get_cpu_flags() & AV_CPU_FLAG_ALTIVEC
) {
431 xvid_gbl_init
.cpu_flags
= XVID_CPU_FORCE
| XVID_CPU_ALTIVEC
;
434 xvid_gbl_init
.cpu_flags
= XVID_CPU_FORCE
;
436 /* Xvid can detect on x86 */
437 xvid_gbl_init
.cpu_flags
= 0;
441 xvid_global(NULL
, XVID_GBL_INIT
, &xvid_gbl_init
, NULL
);
443 /* Create the encoder reference */
444 xvid_enc_create
.version
= XVID_VERSION
;
446 /* Store the desired frame size */
447 xvid_enc_create
.width
= x
->xsize
= avctx
->width
;
448 xvid_enc_create
.height
= x
->ysize
= avctx
->height
;
450 /* Xvid can determine the proper profile to use */
451 /* xvid_enc_create.profile = XVID_PROFILE_S_L3; */
453 /* We don't use zones */
454 xvid_enc_create
.zones
= NULL
;
455 xvid_enc_create
.num_zones
= 0;
457 xvid_enc_create
.num_threads
= avctx
->thread_count
;
459 xvid_enc_create
.plugins
= plugins
;
460 xvid_enc_create
.num_plugins
= 0;
462 /* Initialize Buffers */
463 x
->twopassbuffer
= NULL
;
464 x
->old_twopassbuffer
= NULL
;
465 x
->twopassfile
= NULL
;
467 if( xvid_flags
& CODEC_FLAG_PASS1
) {
468 rc2pass1
.version
= XVID_VERSION
;
469 rc2pass1
.context
= x
;
470 x
->twopassbuffer
= av_malloc(BUFFER_SIZE
);
471 x
->old_twopassbuffer
= av_malloc(BUFFER_SIZE
);
472 if( x
->twopassbuffer
== NULL
|| x
->old_twopassbuffer
== NULL
) {
473 av_log(avctx
, AV_LOG_ERROR
,
474 "Xvid: Cannot allocate 2-pass log buffers\n");
477 x
->twopassbuffer
[0] = x
->old_twopassbuffer
[0] = 0;
479 plugins
[xvid_enc_create
.num_plugins
].func
= xvid_ff_2pass
;
480 plugins
[xvid_enc_create
.num_plugins
].param
= &rc2pass1
;
481 xvid_enc_create
.num_plugins
++;
482 } else if( xvid_flags
& CODEC_FLAG_PASS2
) {
483 rc2pass2
.version
= XVID_VERSION
;
484 rc2pass2
.bitrate
= avctx
->bit_rate
;
486 fd
= ff_tempfile("xvidff.", &x
->twopassfile
);
488 av_log(avctx
, AV_LOG_ERROR
,
489 "Xvid: Cannot write 2-pass pipe\n");
493 if( avctx
->stats_in
== NULL
) {
494 av_log(avctx
, AV_LOG_ERROR
,
495 "Xvid: No 2-pass information loaded for second pass\n");
499 if( strlen(avctx
->stats_in
) >
500 write(fd
, avctx
->stats_in
, strlen(avctx
->stats_in
)) ) {
502 av_log(avctx
, AV_LOG_ERROR
,
503 "Xvid: Cannot write to 2-pass pipe\n");
508 rc2pass2
.filename
= x
->twopassfile
;
509 plugins
[xvid_enc_create
.num_plugins
].func
= xvid_plugin_2pass2
;
510 plugins
[xvid_enc_create
.num_plugins
].param
= &rc2pass2
;
511 xvid_enc_create
.num_plugins
++;
512 } else if( !(xvid_flags
& CODEC_FLAG_QSCALE
) ) {
513 /* Single Pass Bitrate Control! */
514 single
.version
= XVID_VERSION
;
515 single
.bitrate
= avctx
->bit_rate
;
517 plugins
[xvid_enc_create
.num_plugins
].func
= xvid_plugin_single
;
518 plugins
[xvid_enc_create
.num_plugins
].param
= &single
;
519 xvid_enc_create
.num_plugins
++;
522 /* Luminance Masking */
523 if( 0.0 != avctx
->lumi_masking
) {
524 plugins
[xvid_enc_create
.num_plugins
].func
= xvid_plugin_lumimasking
;
525 plugins
[xvid_enc_create
.num_plugins
].param
= NULL
;
526 xvid_enc_create
.num_plugins
++;
529 /* Frame Rate and Key Frames */
530 xvid_correct_framerate(avctx
);
531 xvid_enc_create
.fincr
= avctx
->time_base
.num
;
532 xvid_enc_create
.fbase
= avctx
->time_base
.den
;
533 if( avctx
->gop_size
> 0 )
534 xvid_enc_create
.max_key_interval
= avctx
->gop_size
;
536 xvid_enc_create
.max_key_interval
= 240; /* Xvid's best default */
539 if( xvid_flags
& CODEC_FLAG_QSCALE
) x
->qscale
= 1;
542 xvid_enc_create
.min_quant
[0] = avctx
->qmin
;
543 xvid_enc_create
.min_quant
[1] = avctx
->qmin
;
544 xvid_enc_create
.min_quant
[2] = avctx
->qmin
;
545 xvid_enc_create
.max_quant
[0] = avctx
->qmax
;
546 xvid_enc_create
.max_quant
[1] = avctx
->qmax
;
547 xvid_enc_create
.max_quant
[2] = avctx
->qmax
;
550 x
->intra_matrix
= x
->inter_matrix
= NULL
;
551 if( avctx
->mpeg_quant
)
552 x
->vol_flags
|= XVID_VOL_MPEGQUANT
;
553 if( (avctx
->intra_matrix
|| avctx
->inter_matrix
) ) {
554 x
->vol_flags
|= XVID_VOL_MPEGQUANT
;
556 if( avctx
->intra_matrix
) {
557 intra
= avctx
->intra_matrix
;
558 x
->intra_matrix
= av_malloc(sizeof(unsigned char) * 64);
561 if( avctx
->inter_matrix
) {
562 inter
= avctx
->inter_matrix
;
563 x
->inter_matrix
= av_malloc(sizeof(unsigned char) * 64);
567 for( i
= 0; i
< 64; i
++ ) {
569 x
->intra_matrix
[i
] = (unsigned char)intra
[i
];
571 x
->inter_matrix
[i
] = (unsigned char)inter
[i
];
576 xvid_enc_create
.frame_drop_ratio
= 0;
577 xvid_enc_create
.global
= 0;
578 if( xvid_flags
& CODEC_FLAG_CLOSED_GOP
)
579 xvid_enc_create
.global
|= XVID_GLOBAL_CLOSED_GOP
;
581 /* Determines which codec mode we are operating in */
582 avctx
->extradata
= NULL
;
583 avctx
->extradata_size
= 0;
584 if( xvid_flags
& CODEC_FLAG_GLOBAL_HEADER
) {
585 /* In this case, we are claiming to be MPEG4 */
586 x
->quicktime_format
= 1;
587 avctx
->codec_id
= AV_CODEC_ID_MPEG4
;
589 /* We are claiming to be Xvid */
590 x
->quicktime_format
= 0;
591 if(!avctx
->codec_tag
)
592 avctx
->codec_tag
= AV_RL32("xvid");
596 xvid_enc_create
.max_bframes
= avctx
->max_b_frames
;
597 xvid_enc_create
.bquant_offset
= 100 * avctx
->b_quant_offset
;
598 xvid_enc_create
.bquant_ratio
= 100 * avctx
->b_quant_factor
;
599 if( avctx
->max_b_frames
> 0 && !x
->quicktime_format
) xvid_enc_create
.global
|= XVID_GLOBAL_PACKED
;
601 /* Create encoder context */
602 xerr
= xvid_encore(NULL
, XVID_ENC_CREATE
, &xvid_enc_create
, NULL
);
604 av_log(avctx
, AV_LOG_ERROR
, "Xvid: Could not create encoder reference\n");
608 x
->encoder_handle
= xvid_enc_create
.handle
;
609 avctx
->coded_frame
= &x
->encoded_picture
;
614 static int xvid_encode_frame(AVCodecContext
*avctx
, AVPacket
*pkt
,
615 const AVFrame
*picture
, int *got_packet
)
617 int xerr
, i
, ret
, user_packet
= !!pkt
->data
;
619 struct xvid_context
*x
= avctx
->priv_data
;
620 AVFrame
*p
= &x
->encoded_picture
;
621 int mb_width
= (avctx
->width
+ 15) / 16;
622 int mb_height
= (avctx
->height
+ 15) / 16;
624 xvid_enc_frame_t xvid_enc_frame
= { 0 };
625 xvid_enc_stats_t xvid_enc_stats
= { 0 };
628 (ret
= av_new_packet(pkt
, mb_width
*mb_height
*MAX_MB_BYTES
+ FF_MIN_BUFFER_SIZE
)) < 0) {
629 av_log(avctx
, AV_LOG_ERROR
, "Error getting output packet.\n");
633 /* Start setting up the frame */
634 xvid_enc_frame
.version
= XVID_VERSION
;
635 xvid_enc_stats
.version
= XVID_VERSION
;
638 /* Let Xvid know where to put the frame. */
639 xvid_enc_frame
.bitstream
= pkt
->data
;
640 xvid_enc_frame
.length
= pkt
->size
;
642 /* Initialize input image fields */
643 if( avctx
->pix_fmt
!= AV_PIX_FMT_YUV420P
) {
644 av_log(avctx
, AV_LOG_ERROR
, "Xvid: Color spaces other than 420p not supported\n");
648 xvid_enc_frame
.input
.csp
= XVID_CSP_PLANAR
; /* YUV420P */
650 for( i
= 0; i
< 4; i
++ ) {
651 xvid_enc_frame
.input
.plane
[i
] = picture
->data
[i
];
652 xvid_enc_frame
.input
.stride
[i
] = picture
->linesize
[i
];
656 xvid_enc_frame
.vop_flags
= x
->vop_flags
;
657 xvid_enc_frame
.vol_flags
= x
->vol_flags
;
658 xvid_enc_frame
.motion
= x
->me_flags
;
659 xvid_enc_frame
.type
=
660 picture
->pict_type
== AV_PICTURE_TYPE_I
? XVID_TYPE_IVOP
:
661 picture
->pict_type
== AV_PICTURE_TYPE_P
? XVID_TYPE_PVOP
:
662 picture
->pict_type
== AV_PICTURE_TYPE_B
? XVID_TYPE_BVOP
:
665 /* Pixel aspect ratio setting */
666 if (avctx
->sample_aspect_ratio
.num
< 1 || avctx
->sample_aspect_ratio
.num
> 255 ||
667 avctx
->sample_aspect_ratio
.den
< 1 || avctx
->sample_aspect_ratio
.den
> 255) {
668 av_log(avctx
, AV_LOG_ERROR
, "Invalid pixel aspect ratio %i/%i\n",
669 avctx
->sample_aspect_ratio
.num
, avctx
->sample_aspect_ratio
.den
);
672 xvid_enc_frame
.par
= XVID_PAR_EXT
;
673 xvid_enc_frame
.par_width
= avctx
->sample_aspect_ratio
.num
;
674 xvid_enc_frame
.par_height
= avctx
->sample_aspect_ratio
.den
;
677 if( x
->qscale
) xvid_enc_frame
.quant
= picture
->quality
/ FF_QP2LAMBDA
;
678 else xvid_enc_frame
.quant
= 0;
681 xvid_enc_frame
.quant_intra_matrix
= x
->intra_matrix
;
682 xvid_enc_frame
.quant_inter_matrix
= x
->inter_matrix
;
685 xerr
= xvid_encore(x
->encoder_handle
, XVID_ENC_ENCODE
,
686 &xvid_enc_frame
, &xvid_enc_stats
);
688 /* Two-pass log buffer swapping */
689 avctx
->stats_out
= NULL
;
690 if( x
->twopassbuffer
) {
691 tmp
= x
->old_twopassbuffer
;
692 x
->old_twopassbuffer
= x
->twopassbuffer
;
693 x
->twopassbuffer
= tmp
;
694 x
->twopassbuffer
[0] = 0;
695 if( x
->old_twopassbuffer
[0] != 0 ) {
696 avctx
->stats_out
= x
->old_twopassbuffer
;
703 p
->quality
= xvid_enc_stats
.quant
* FF_QP2LAMBDA
;
704 if( xvid_enc_stats
.type
== XVID_TYPE_PVOP
)
705 p
->pict_type
= AV_PICTURE_TYPE_P
;
706 else if( xvid_enc_stats
.type
== XVID_TYPE_BVOP
)
707 p
->pict_type
= AV_PICTURE_TYPE_B
;
708 else if( xvid_enc_stats
.type
== XVID_TYPE_SVOP
)
709 p
->pict_type
= AV_PICTURE_TYPE_S
;
711 p
->pict_type
= AV_PICTURE_TYPE_I
;
712 if( xvid_enc_frame
.out_flags
& XVID_KEYFRAME
) {
714 pkt
->flags
|= AV_PKT_FLAG_KEY
;
715 if( x
->quicktime_format
)
716 return xvid_strip_vol_header(avctx
, pkt
,
717 xvid_enc_stats
.hlength
, xerr
);
729 av_log(avctx
, AV_LOG_ERROR
, "Xvid: Encoding Error Occurred: %i\n", xerr
);
734 static av_cold
int xvid_encode_close(AVCodecContext
*avctx
) {
735 struct xvid_context
*x
= avctx
->priv_data
;
737 xvid_encore(x
->encoder_handle
, XVID_ENC_DESTROY
, NULL
, NULL
);
739 av_freep(&avctx
->extradata
);
740 if( x
->twopassbuffer
!= NULL
) {
741 av_free(x
->twopassbuffer
);
742 av_free(x
->old_twopassbuffer
);
744 av_free(x
->twopassfile
);
745 av_free(x
->intra_matrix
);
746 av_free(x
->inter_matrix
);
751 AVCodec ff_libxvid_encoder
= {
753 .type
= AVMEDIA_TYPE_VIDEO
,
754 .id
= AV_CODEC_ID_MPEG4
,
755 .priv_data_size
= sizeof(struct xvid_context
),
756 .init
= xvid_encode_init
,
757 .encode2
= xvid_encode_frame
,
758 .close
= xvid_encode_close
,
759 .pix_fmts
= (const enum AVPixelFormat
[]){ AV_PIX_FMT_YUV420P
, AV_PIX_FMT_NONE
},
760 .long_name
= NULL_IF_CONFIG_SMALL("libxvidcore MPEG-4 part 2"),