/* * encode_lavc.c -- encode A/V frames using libavcodec. * (C) 2007-2010 Francesco Romani * * This file is part of transcode, a video stream processing tool. * * transcode is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * transcode is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see . */ #include "transcode.h" #include "framebuffer.h" #include "filter.h" #include "aclib/imgconvert.h" #include "libtc/optstr.h" #include "libtc/cfgfile.h" #include "libtc/ratiocodes.h" #include "libtc/tcframes.h" #include "libtc/tcmodule-plugin.h" #include "libtc/tcavcodec.h" #include #define MOD_NAME "encode_lavc.so" #define MOD_VERSION "v0.0.7 (2007-10-27)" #define MOD_CAP "libavcodec based encoder (" LIBAVCODEC_IDENT ")" #define MOD_FEATURES \ TC_MODULE_FEATURE_ENCODE|TC_MODULE_FEATURE_VIDEO #define MOD_FLAGS \ TC_MODULE_FLAG_RECONFIGURABLE #define LAVC_CONFIG_FILE "lavc.cfg" #define PSNR_LOG_FILE "psnr.log" static const char tc_lavc_help[] = "" "Overview:\n" " this module uses libavcodec to encode given raw frames in\n" " an huge variety of compressed formats, both audio and video.\n" "Options:\n" " help produce module overview and options explanations\n" " list log out a list of supported A/V codecs\n"; typedef struct tclavcconfigdata_ TCLavcConfigData; struct tclavcconfigdata_ { int thread_count; /* * following options can't be sect directly on AVCodeContext, * we need some buffering and translation. */ int vrate_tolerance; int rc_min_rate; int rc_max_rate; int rc_buffer_size; int lmin; int lmax; int me_method; /* same as above for flags */ struct { uint32_t mv0; uint32_t cbp; uint32_t qpel; uint32_t alt; uint32_t vdpart; uint32_t naq; uint32_t ilme; uint32_t ildct; uint32_t aic; uint32_t aiv; uint32_t umv; uint32_t psnr; uint32_t trell; uint32_t gray; uint32_t v4mv; uint32_t closedgop; } flags; /* * special flags: flags that triggers more than a setting * FIXME: not yet supported */ int turbo_setup; }; typedef struct tclavcprivatedata_ TCLavcPrivateData; /* this is to reduce if()s in out encode_video() */ typedef void (*PreEncodeVideoFn)(struct tclavcprivatedata_ *pd, vframe_list_t *vframe); struct tclavcprivatedata_ { int vcodec_id; TCCodecID tc_pix_fmt; AVFrame ff_venc_frame; AVCodecContext ff_vcontext; AVCodec *ff_vcodec; TCLavcConfigData confdata; struct { int active; int top_first; } interlacing; uint16_t inter_matrix[TC_MATRIX_SIZE]; uint16_t intra_matrix[TC_MATRIX_SIZE]; FILE *stats_file; FILE *psnr_file; vframe_list_t *vframe_buf; /* for colorspace conversions in prepare functions */ PreEncodeVideoFn pre_encode_video; int flush_flag; }; /*************************************************************************/ static const TCCodecID tc_lavc_codecs_in[] = { TC_CODEC_YUV420P, TC_CODEC_YUV422P, TC_CODEC_RGB, TC_CODEC_ERROR }; #define FF_VCODEC_ID(pd) (tc_lavc_internal_codecs[(pd)->vcodec_id]) #define TC_VCODEC_ID(pd) (tc_lavc_codecs_out[(pd)->vcodec_id]) /* WARNING: the two arrays below MUST BE KEPT SYNCHRONIZED! */ static const TCCodecID tc_lavc_codecs_out[] = { TC_CODEC_MPEG1VIDEO, TC_CODEC_MPEG2VIDEO, TC_CODEC_MPEG4VIDEO, TC_CODEC_H263I, TC_CODEC_H263P, TC_CODEC_H264, TC_CODEC_WMV1, TC_CODEC_WMV2, TC_CODEC_RV10, TC_CODEC_HUFFYUV, TC_CODEC_FFV1, TC_CODEC_DV, TC_CODEC_MJPEG, TC_CODEC_LJPEG, TC_CODEC_MP42, TC_CODEC_MP43, TC_CODEC_ERROR }; static const enum CodecID tc_lavc_internal_codecs[] = { CODEC_ID_MPEG1VIDEO, CODEC_ID_MPEG2VIDEO, CODEC_ID_MPEG4, CODEC_ID_H263I, CODEC_ID_H263P, CODEC_ID_H264, CODEC_ID_WMV1, CODEC_ID_WMV2, CODEC_ID_RV10, CODEC_ID_HUFFYUV, CODEC_ID_FFV1, CODEC_ID_DVVIDEO, CODEC_ID_MJPEG, CODEC_ID_LJPEG, CODEC_ID_MSMPEG4V2, CODEC_ID_MSMPEG4V3, CODEC_ID_NONE }; static const TCFormatID tc_lavc_formats[] = { TC_FORMAT_ERROR }; /*************************************************************************/ /* * following helper private functions adapt stuff and do proper * colorspace conversion, if needed, preparing data for * later real encoding */ /* * pre_encode_video_yuv420p: * pre_encode_video_yuv420p_huffyuv: * pre_encode_video_yuv422p: * pre_encode_video_yuv422p_huffyuv: * pre_encode_video_rgb24: * prepare internal structures for actual encoding, doing * colorspace conversion and/or any needed adaptation. * * Parameters: * pd: pointer to private module dataure * vframe: pointer to *SOURCE* video data frame * Return Value: * none * Preconditions: * module initialized and configured; * auxiliariy buffer space already allocated if needed * (pix fmt != yuv420p) * Postconditions: * video data ready to be encoded through lavc. */ static void pre_encode_video_yuv420p(TCLavcPrivateData *pd, vframe_list_t *vframe) { avpicture_fill((AVPicture *)&pd->ff_venc_frame, vframe->video_buf, PIX_FMT_YUV420P, pd->ff_vcontext.width, pd->ff_vcontext.height); } static void pre_encode_video_yuv420p_huffyuv(TCLavcPrivateData *pd, vframe_list_t *vframe) { uint8_t *src[3] = { NULL, NULL, NULL }; YUV_INIT_PLANES(src, vframe->video_buf, IMG_YUV_DEFAULT, pd->ff_vcontext.width, pd->ff_vcontext.height); avpicture_fill((AVPicture *)&pd->ff_venc_frame, pd->vframe_buf->video_buf, PIX_FMT_YUV422P, pd->ff_vcontext.width, pd->ff_vcontext.height); ac_imgconvert(src, IMG_YUV_DEFAULT, pd->ff_venc_frame.data, IMG_YUV422P, pd->ff_vcontext.width, pd->ff_vcontext.height); } static void pre_encode_video_yuv422p(TCLavcPrivateData *pd, vframe_list_t *vframe) { uint8_t *src[3] = { NULL, NULL, NULL }; YUV_INIT_PLANES(src, vframe->video_buf, IMG_YUV422P, pd->ff_vcontext.width, pd->ff_vcontext.height); avpicture_fill((AVPicture *)&pd->ff_venc_frame, pd->vframe_buf->video_buf, PIX_FMT_YUV420P, pd->ff_vcontext.width, pd->ff_vcontext.height); ac_imgconvert(src, IMG_YUV422P, pd->ff_venc_frame.data, IMG_YUV420P, pd->ff_vcontext.width, pd->ff_vcontext.height); } static void pre_encode_video_yuv422p_huffyuv(TCLavcPrivateData *pd, vframe_list_t *vframe) { avpicture_fill((AVPicture *)&pd->ff_venc_frame, vframe->video_buf, PIX_FMT_YUV422P, pd->ff_vcontext.width, pd->ff_vcontext.height); } static void pre_encode_video_rgb24(TCLavcPrivateData *pd, vframe_list_t *vframe) { avpicture_fill((AVPicture *)&pd->ff_venc_frame, pd->vframe_buf->video_buf, PIX_FMT_YUV420P, pd->ff_vcontext.width, pd->ff_vcontext.height); ac_imgconvert(&vframe->video_buf, IMG_RGB_DEFAULT, pd->ff_venc_frame.data, IMG_YUV420P, pd->ff_vcontext.width, pd->ff_vcontext.height); } /*************************************************************************/ /* more helpers */ /* * tc_codec_is_supported: * scan the module supported output codec looking for given one. * * Parameters: * codec: codec id to check against supported codec list. * Return Value: * >= 0: index of codec, if supported, in output list * TC_NULL_MATCH: given codec isn't supported. */ static int tc_codec_is_supported(TCCodecID codec) { int i = 0, ret = TC_NULL_MATCH; for (i = 0; tc_lavc_codecs_out[i] != TC_CODEC_ERROR; i++) { if (codec == tc_lavc_codecs_out[i]) { ret = i; break; } } return ret; } #if !defined(INFINITY) && defined(HUGE_VAL) #define INFINITY HUGE_VAL #endif /* * psnr: * compute the psnr value of given data. * * Parameters: * d: value to be computed * Return value: * psnr of `d' */ static double psnr(double d) { if (d == 0) { return INFINITY; } return -10.0 * log(d) / log(10); } /* * tc_lavc_list_codecs: * (NOT Thread safe. But do anybody cares since * transcode encoder(.c) is single-threaded today * and in any foreseable future?) * return a buffer listing all supported codecs with * respective name and short description. * * Parameters: * None * Return Value: * Read-only pointer to a char buffer holding the * description data. Buffer is guaranted valid * at least until next call of this function. * You NEVER need to tc_free() the pointer. */ static const char* tc_lavc_list_codecs(void) { /* XXX: I feel a bad taste */ static char buf[TC_BUF_MAX]; static int ready = TC_FALSE; if (!ready) { size_t used = 0; int i = 0; for (i = 0; tc_lavc_codecs_out[i] != TC_CODEC_ERROR; i++) { char sbuf[TC_BUF_MIN]; size_t slen = 0; tc_snprintf(sbuf, sizeof(sbuf), "%15s: %s\n", tc_codec_to_string(tc_lavc_codecs_out[i]), tc_codec_to_comment(tc_lavc_codecs_out[i])); slen = strlen(sbuf); if (used + slen <= sizeof(buf)) { strlcpy(buf + used, sbuf, sizeof(buf) - used); used += slen; /* chomp final '\0' except for first round */ } else { tc_log_error(MOD_NAME, "too much codecs! this should happen. " "Please file a bug report."); strlcpy(buf, "internal error", sizeof(buf)); } } ready = TC_TRUE; } return buf; } /* * tc_lavc_read_matrices: * read and fill internal (as in internal module data) * custom quantization matrices from data stored on * disk files, using given paths, then passes them * to libavcodec for usage in encoders if loading was * succesfull. * * Parameters: * pd: pointer to module private data to use. * intra_matrix_file: path of file containing intra matrix data. * inter_matrix_file: path of file containing inter matrix data. * Return Value: * None * Side Effects: * 0-2 files on disk are opend, read, closed */ static void tc_lavc_read_matrices(TCLavcPrivateData *pd, const char *intra_matrix_file, const char *inter_matrix_file) { if (intra_matrix_file != NULL && strlen(intra_matrix_file) > 0) { /* looks like we've got something... */ int ret = tc_read_matrix(intra_matrix_file, NULL, pd->inter_matrix); if (ret == 0) { /* ok, let's give this to lavc */ pd->ff_vcontext.intra_matrix = pd->inter_matrix; } else { tc_log_warn(MOD_NAME, "error while reading intra matrix from" " %s", intra_matrix_file); pd->ff_vcontext.intra_matrix = NULL; /* paranoia */ } } if (inter_matrix_file != NULL && strlen(inter_matrix_file) > 0) { /* looks like we've got something... */ int ret = tc_read_matrix(inter_matrix_file, NULL, pd->inter_matrix); if (ret == 0) { /* ok, let's give this to lavc */ pd->ff_vcontext.inter_matrix = pd->inter_matrix; } else { tc_log_warn(MOD_NAME, "error while reading inter matrix from" " %s", inter_matrix_file); pd->ff_vcontext.inter_matrix = NULL; /* paranoia */ } } } /* * tc_lavc_load_filters: * request to transcode core filters needed by given parameters. * * Parameters: * pd: pointer to module private data. * Return Value: * None. */ static void tc_lavc_load_filters(TCLavcPrivateData *pd) { if (TC_VCODEC_ID(pd) == TC_CODEC_MJPEG || TC_VCODEC_ID(pd) == TC_CODEC_LJPEG) { int handle; tc_log_info(MOD_NAME, "output is mjpeg or ljpeg, extending range from " "YUV420P to YUVJ420P (full range)"); handle = tc_filter_add("levels", "input=16-240"); if (!handle) { tc_log_warn(MOD_NAME, "cannot load levels filter"); } } } /*************************************************************************/ /* PSNR-log stuff */ #define PSNR_REQUESTED(PD) ((PD)->confdata.flags.psnr) /* * psnr_open: * open psnr log file and prepare internal data to write out * PSNR stats * * Parameters: * pd: pointer to private module data. * Return Value: * TC_OK: succesfull (log file open and avalaible and so on) * TC_ERROR: otherwise */ static int psnr_open(TCLavcPrivateData *pd) { pd->psnr_file = NULL; pd->psnr_file = fopen(PSNR_LOG_FILE, "w"); if (pd->psnr_file != NULL) { /* add a little reminder */ fprintf(pd->psnr_file, "# Num Qual Size Y U V Tot Type"); } else { tc_log_warn(MOD_NAME, "can't open psnr log file '%s'", PSNR_LOG_FILE); return TC_ERROR; } return TC_OK; } #define PFRAME(PD) ((PD)->ff_vcontext.coded_frame) /* * psnr_write: * fetch and write to log file, if avalaible, PSNR statistics * for last encoded frames. Format is human-readable. * If psnr log file isn't avalaible, silently doesn nothing. * * Parameters: * pd: pointer to private module data. * size: size (bytes) of last encoded frame. * Return Value: * None. */ static void psnr_write(TCLavcPrivateData *pd, int size) { if (pd->psnr_file != NULL) { const char pict_type[5] = { '?', 'I', 'P', 'B', 'S' }; double f = pd->ff_vcontext.width * pd->ff_vcontext.height * 255.0 * 255.0; double err[3] = { PFRAME(pd)->error[0], PFRAME(pd)->error[1], PFRAME(pd)->error[2] }; fprintf(pd->psnr_file, "%6d, %2d, %6d, %2.2f," " %2.2f, %2.2f, %2.2f %c\n", PFRAME(pd)->coded_picture_number, PFRAME(pd)->quality, size, psnr(err[0] / f), psnr(err[1] * 4 / f), /* FIXME */ psnr(err[2] * 4 / f), /* FIXME */ psnr((err[0] + err[1] + err[2]) / (f * 1.5)), pict_type[PFRAME(pd)->pict_type]); } } #undef PFRAME /* * psnr_close: * close psnr log file, free acquired resource. * It's safe to perform this call even if psnr_open() * was NOT called previously. * * Parameters: * pd: pointer to private module data. * Return Value: * TC_OK: succesfull (log file closed correctly) * TC_ERROR: otherwise */ static int psnr_close(TCLavcPrivateData *pd) { if (pd->psnr_file != NULL) { if (fclose(pd->psnr_file) != 0) { return TC_ERROR; } } return TC_OK; } /* * psnr_print: * tc_log out summary of *overall* PSNR stats. * * Parameters: * pd: pointer to private module data. * Return Value: * None. */ static void psnr_print(TCLavcPrivateData *pd) { double f = pd->ff_vcontext.width * pd->ff_vcontext.height * 255.0 * 255.0; f *= pd->ff_vcontext.coded_frame->coded_picture_number; #define ERROR pd->ff_vcontext.error tc_log_info(MOD_NAME, "PSNR: Y:%2.2f, Cb:%2.2f, Cr:%2.2f, All:%2.2f", psnr(ERROR[0] / f), /* FIXME: this is correct if pix_fmt != YUV420P */ psnr(ERROR[1] * 4 / f), psnr(ERROR[2] * 4 / f), psnr((ERROR[0] + ERROR[1] + ERROR[2]) / (f * 1.5))); #undef ERROR } /*************************************************************************/ /* * configure() helpers, libavcodec allow very detailed * configuration step */ /* * tc_lavc_set_pix_fmt: * choose the right pixel format and setup all internal module * fields depending on this value. * Please note that this function SHALL NOT allocate resources * (i.e.: buffers) that's job of other specific functions. * * Parameters: * pd: pointer to private module data. * vob: pointer to vob_t structure. * Return Value: * TC_OK: succesfull; * TC_ERROR: wrong/erroneous/unsupported pixel format. * * FIXME: move to TC_CODEC_* colorspaces */ static int tc_lavc_set_pix_fmt(TCLavcPrivateData *pd, const vob_t *vob) { switch (vob->im_v_codec) { case CODEC_YUV: if (TC_VCODEC_ID(pd) == TC_CODEC_HUFFYUV) { pd->tc_pix_fmt = TC_CODEC_YUV422P; pd->ff_vcontext.pix_fmt = PIX_FMT_YUV422P; pd->pre_encode_video = pre_encode_video_yuv420p_huffyuv; } else { pd->tc_pix_fmt = TC_CODEC_YUV420P; pd->ff_vcontext.pix_fmt = (TC_VCODEC_ID(pd) == TC_CODEC_MJPEG) ? PIX_FMT_YUVJ420P : PIX_FMT_YUV420P; pd->pre_encode_video = pre_encode_video_yuv420p; } break; case CODEC_YUV422: pd->tc_pix_fmt = TC_CODEC_YUV422P; pd->ff_vcontext.pix_fmt = (TC_VCODEC_ID(pd) == TC_CODEC_MJPEG) ? PIX_FMT_YUVJ422P : PIX_FMT_YUV422P; if (TC_VCODEC_ID(pd) == TC_CODEC_HUFFYUV) { pd->pre_encode_video = pre_encode_video_yuv422p_huffyuv; } else { pd->pre_encode_video = pre_encode_video_yuv422p; } break; case CODEC_RGB: pd->tc_pix_fmt = TC_CODEC_RGB; pd->ff_vcontext.pix_fmt = (TC_VCODEC_ID(pd) == TC_CODEC_HUFFYUV) ? PIX_FMT_YUV422P : (TC_VCODEC_ID(pd) == TC_CODEC_MJPEG) ? PIX_FMT_YUVJ420P : PIX_FMT_YUV420P; pd->pre_encode_video = pre_encode_video_rgb24; break; default: tc_log_warn(MOD_NAME, "Unknown pixel format %i", vob->im_v_codec); return TC_ERROR; } tc_log_info(MOD_NAME, "internal pixel format: %s", tc_codec_to_string(pd->tc_pix_fmt)); return TC_OK; } #define CAN_DO_MULTIPASS(FLAG) do { \ if (!(FLAG)) { \ tc_log_error(MOD_NAME, "This codec does not support multipass " \ "encoding."); \ return TC_ERROR; \ } \ } while (0) /* * tc_lavc_init_multipass: * setup internal (avcodec) parameters for multipass translating * values from vob_t structure, and handle multipass log file data, * reading it or creating it if needed. * * Parameters: * pd: pointer to private module data. * vob: pointer to vob_t structure. * Return Value: * TC_OK: succesfull * TC_ERROR: error (mostly I/O related; reason will tc_log*()'d out) * Side effects: * A file on disk will be open'd, and possibly read. * Seeks are possible as well. */ static int tc_lavc_init_multipass(TCLavcPrivateData *pd, const vob_t *vob) { int multipass_flag = tc_codec_is_multipass(TC_VCODEC_ID(pd)); pd->stats_file = NULL; size_t fsize = 0; switch (vob->divxmultipass) { case 1: CAN_DO_MULTIPASS(multipass_flag); pd->ff_vcontext.flags |= CODEC_FLAG_PASS1; pd->stats_file = fopen(vob->divxlogfile, "w"); if (pd->stats_file == NULL) { tc_log_error(MOD_NAME, "could not create 2pass log file" " \"%s\".", vob->divxlogfile); return TC_ERROR; } break; case 2: CAN_DO_MULTIPASS(multipass_flag); pd->ff_vcontext.flags |= CODEC_FLAG_PASS2; pd->stats_file = fopen(vob->divxlogfile, "r"); if (pd->stats_file == NULL){ tc_log_error(MOD_NAME, "could not open 2pass log file \"%s\"" " for reading.", vob->divxlogfile); return TC_ERROR; } /* FIXME: we're optimistic here, don't we? */ fseek(pd->stats_file, 0, SEEK_END); fsize = ftell(pd->stats_file); fseek(pd->stats_file, 0, SEEK_SET); pd->ff_vcontext.stats_in = tc_malloc(fsize + 1); if (pd->ff_vcontext.stats_in == NULL) { tc_log_error(MOD_NAME, "can't get memory for multipass log"); fclose(pd->stats_file); return TC_ERROR; } if (fread(pd->ff_vcontext.stats_in, fsize, 1, pd->stats_file) < 1) { tc_log_error(MOD_NAME, "Could not read the complete 2pass log" " file \"%s\".", vob->divxlogfile); return TC_ERROR; } pd->ff_vcontext.stats_in[fsize] = 0; /* paranoia */ fclose(pd->stats_file); break; case 3: /* fixed qscale :p */ pd->ff_vcontext.flags |= CODEC_FLAG_QSCALE; pd->ff_venc_frame.quality = vob->divxbitrate; break; } return TC_OK; } #undef CAN_DO_MULTIPASS /* * tc_lavc_fini_multipass: * release multipass resources, most notably but NOT exclusively * close log file open'd on disk. * * Parameters: * pd: pointer to private module data. * Return Value: * None. */ static void tc_lavc_fini_multipass(TCLavcPrivateData *pd) { if (pd->ff_vcontext.stats_in != NULL) { tc_free(pd->ff_vcontext.stats_in); pd->ff_vcontext.stats_in = NULL; } if (pd->stats_file != NULL) { fclose(pd->stats_file); /* XXX */ pd->stats_file = NULL; } } /* * tc_lavc_init_rc_override: * parse Rate Control override string given in format understood * by libavcodec and store result in internal avcodec context. * * Parameters: * pd: pointer to private module data. * str: RC override string to parse. * Return Value: * None. * Side Effects: * some memory will be allocated. */ static void tc_lavc_init_rc_override(TCLavcPrivateData *pd, const char *str) { int i = 0; if (str != NULL && strlen(str) > 0) { const char *p = str; for (i = 0; p != NULL; i++) { int start, end, q; int e = sscanf(p, "%i,%i,%i", &start, &end, &q); if (e != 3) { tc_log_warn(MOD_NAME, "Error parsing rc_override (ignored)"); return; } pd->ff_vcontext.rc_override = tc_realloc(pd->ff_vcontext.rc_override, sizeof(RcOverride) * (i + 1)); /* XXX */ pd->ff_vcontext.rc_override[i].start_frame = start; pd->ff_vcontext.rc_override[i].end_frame = end; if (q > 0) { pd->ff_vcontext.rc_override[i].qscale = q; pd->ff_vcontext.rc_override[i].quality_factor = 1.0; } else { pd->ff_vcontext.rc_override[i].qscale = 0; pd->ff_vcontext.rc_override[i].quality_factor = -q / 100.0; } p = strchr(p, '/'); if (p != NULL) { p++; } } } pd->ff_vcontext.rc_override_count = i; } /* * tc_lavc_fini_rc_override: * free Rate Control override resources acquired by * former call of tc_lavc_init_rc_override. * It's safe to call this function even if * tc_lavc_init_rc_override was NOT called previously. * * Parameters: * pd: pointer to private module data. * Return Value: * None. */ static void tc_lavc_fini_rc_override(TCLavcPrivateData *pd) { if (pd->ff_vcontext.rc_override != NULL) { tc_free(pd->ff_vcontext.rc_override); pd->ff_vcontext.rc_override = NULL; } } /* * tc_lavc_init_buf: * allocate internal colorspace conversion buffer, if needed * (depending by internal pixel format), * * Parameters: * pd: pointer to private module data. * vob: pointer to vob_t structure. * Return Value: * TC_OK: succesfull * TC_ERROR: error (can't allocate buffers) * Preconditions: * INTERNAL pixel format already determined using * tc_lavc_set_pix_fmt(). */ static int tc_lavc_init_buf(TCLavcPrivateData *pd, const vob_t *vob) { if (pd->tc_pix_fmt != TC_CODEC_YUV420P) { /*yuv420p it's our default */ pd->vframe_buf = tc_new_video_frame(vob->im_v_width, vob->im_v_height, pd->tc_pix_fmt, TC_TRUE); if (pd->vframe_buf == NULL) { tc_log_warn(MOD_NAME, "unable to allocate internal vframe buffer"); return TC_ERROR; } } return TC_OK; } /* release internal colorspace conversion buffers. */ #define tc_lavc_fini_buf(PD) do { \ if ((PD) != NULL && (PD)->vframe_buf != NULL) { \ tc_del_video_frame((PD)->vframe_buf); \ } \ } while (0) /* * tc_lavc_settings_from_vob: * translate vob settings and store them in module * private data and in avcodec context, in correct format. * * Parameters: * pd: pointer to private module data. * vob: pointer to vob_t structure. * Return Value: * TC_OK: succesfull * TC_ERROR: error (various reasons, all will be tc_log*()'d out) * Side Effects: * various helper subroutines will be called. */ static int tc_lavc_settings_from_vob(TCLavcPrivateData *pd, const vob_t *vob) { int ret = 0; pd->ff_vcontext.bit_rate = vob->divxbitrate * 1000; pd->ff_vcontext.width = vob->ex_v_width; pd->ff_vcontext.height = vob->ex_v_height; pd->ff_vcontext.qmin = vob->min_quantizer; pd->ff_vcontext.qmax = vob->max_quantizer; if (vob->export_attributes & TC_EXPORT_ATTRIBUTE_GOP) { pd->ff_vcontext.gop_size = vob->divxkeyframes; } else { if (TC_VCODEC_ID(pd) == TC_CODEC_MPEG1VIDEO || TC_VCODEC_ID(pd) == TC_CODEC_MPEG2VIDEO) { pd->ff_vcontext.gop_size = 15; /* conservative default for mpeg1/2 svcd/dvd */ } else { pd->ff_vcontext.gop_size = 250; /* reasonable default for mpeg4 (and others) */ } } ret = tc_find_best_aspect_ratio(vob, &pd->ff_vcontext.sample_aspect_ratio.num, &pd->ff_vcontext.sample_aspect_ratio.den, MOD_NAME); if (ret != TC_OK) { tc_log_error(MOD_NAME, "unable to find sane value for SAR"); return TC_ERROR; } ret = tc_frc_code_to_ratio(vob->ex_frc, &pd->ff_vcontext.time_base.den, &pd->ff_vcontext.time_base.num); /* watch out here */ if (ret == TC_NULL_MATCH) { /* legacy */ if ((vob->ex_fps > 29) && (vob->ex_fps < 30)) { pd->ff_vcontext.time_base.den = 30000; pd->ff_vcontext.time_base.num = 1001; } else { pd->ff_vcontext.time_base.den = (int)(vob->ex_fps * 1000.0); pd->ff_vcontext.time_base.num = 1000; } } switch(vob->encode_fields) { case TC_ENCODE_FIELDS_TOP_FIRST: pd->interlacing.active = 1; pd->interlacing.top_first = 1; break; case TC_ENCODE_FIELDS_BOTTOM_FIRST: pd->interlacing.active = 1; pd->interlacing.top_first = 0; break; default: /* progressive / unknown */ pd->interlacing.active = 0; pd->interlacing.top_first = 0; break; } ret = tc_lavc_set_pix_fmt(pd, vob); if (ret != TC_OK) { return ret; } return tc_lavc_init_multipass(pd, vob); } #define PCTX(field) &(pd->ff_vcontext.field) #define PAUX(field) &(pd->confdata.field) /* * tc_lavc_config_defaults: * setup sane values for auxiliary config, and setup *transcode's* * AVCodecContext default settings. * * Parameters: * pd: pointer to private module data. * Return Value: * None */ static void tc_lavc_config_defaults(TCLavcPrivateData *pd) { /* first of all reinitialize lavc data */ avcodec_get_context_defaults(&pd->ff_vcontext); pd->confdata.thread_count = 1; pd->confdata.vrate_tolerance = 8 * 1000; pd->confdata.rc_min_rate = 0; pd->confdata.rc_max_rate = 0; pd->confdata.rc_buffer_size = 0; pd->confdata.lmin = 2; pd->confdata.lmax = 31; pd->confdata.me_method = ME_EPZS; memset(&pd->confdata.flags, 0, sizeof(pd->confdata.flags)); pd->confdata.turbo_setup = 0; /* * context *transcode* (not libavcodec) defaults */ pd->ff_vcontext.mb_qmin = 2; pd->ff_vcontext.mb_qmax = 31; pd->ff_vcontext.max_qdiff = 3; pd->ff_vcontext.max_b_frames = 0; pd->ff_vcontext.me_range = 0; pd->ff_vcontext.mb_decision = 0; pd->ff_vcontext.scenechange_threshold = 0; pd->ff_vcontext.scenechange_factor = 1; pd->ff_vcontext.b_frame_strategy = 0; pd->ff_vcontext.b_sensitivity = 40; pd->ff_vcontext.brd_scale = 0; pd->ff_vcontext.bidir_refine = 0; pd->ff_vcontext.rc_strategy = 2; pd->ff_vcontext.b_quant_factor = 1.25; pd->ff_vcontext.i_quant_factor = 0.8; pd->ff_vcontext.b_quant_offset = 1.25; pd->ff_vcontext.i_quant_offset = 0.0; pd->ff_vcontext.qblur = 0.5; pd->ff_vcontext.qcompress = 0.5; pd->ff_vcontext.mpeg_quant = 0; pd->ff_vcontext.rc_initial_cplx = 0.0; pd->ff_vcontext.rc_qsquish = 1.0; pd->ff_vcontext.luma_elim_threshold = 0; pd->ff_vcontext.chroma_elim_threshold = 0; pd->ff_vcontext.strict_std_compliance = 0; pd->ff_vcontext.dct_algo = FF_DCT_AUTO; pd->ff_vcontext.idct_algo = FF_IDCT_AUTO; pd->ff_vcontext.lumi_masking = 0.0; pd->ff_vcontext.dark_masking = 0.0; pd->ff_vcontext.temporal_cplx_masking = 0.0; pd->ff_vcontext.spatial_cplx_masking = 0.0; pd->ff_vcontext.p_masking = 0.0; pd->ff_vcontext.border_masking = 0.0; pd->ff_vcontext.me_pre_cmp = 0; pd->ff_vcontext.me_cmp = 0; pd->ff_vcontext.me_sub_cmp = 0; pd->ff_vcontext.ildct_cmp = FF_CMP_SAD; pd->ff_vcontext.pre_dia_size = 0; pd->ff_vcontext.dia_size = 0; pd->ff_vcontext.mv0_threshold = 256; pd->ff_vcontext.last_predictor_count = 0; pd->ff_vcontext.pre_me = 1; pd->ff_vcontext.me_subpel_quality = 8; pd->ff_vcontext.refs = 1; pd->ff_vcontext.intra_quant_bias = FF_DEFAULT_QUANT_BIAS; pd->ff_vcontext.inter_quant_bias = FF_DEFAULT_QUANT_BIAS; pd->ff_vcontext.noise_reduction = 0; pd->ff_vcontext.quantizer_noise_shaping = 0; pd->ff_vcontext.flags = 0; } /* FIXME: it is too nasty? */ #define SET_FLAG(pd, field) (pd)->ff_vcontext.flags |= (pd)->confdata.flags.field /* * tc_lavc_dispatch_settings: * translate auxiliary configuration into context values; * also does some consistency verifications. * * Parameters: * pd: pointer to private module data. * vob: pointer to vob_t structure. * Return Value: * None. */ static void tc_lavc_dispatch_settings(TCLavcPrivateData *pd) { /* some translation... */ pd->ff_vcontext.bit_rate_tolerance = pd->confdata.vrate_tolerance * 1000; pd->ff_vcontext.rc_min_rate = pd->confdata.rc_min_rate * 1000; pd->ff_vcontext.rc_max_rate = pd->confdata.rc_max_rate * 1000; pd->ff_vcontext.rc_buffer_size = pd->confdata.rc_buffer_size * 1024; pd->ff_vcontext.lmin = (int)(FF_QP2LAMBDA * pd->confdata.lmin + 0.5); pd->ff_vcontext.lmax = (int)(FF_QP2LAMBDA * pd->confdata.lmax + 0.5); pd->ff_vcontext.me_method = ME_ZERO + pd->confdata.me_method; pd->ff_vcontext.flags = 0; SET_FLAG(pd, mv0); SET_FLAG(pd, cbp); SET_FLAG(pd, qpel); SET_FLAG(pd, alt); SET_FLAG(pd, vdpart); SET_FLAG(pd, naq); SET_FLAG(pd, ilme); SET_FLAG(pd, ildct); SET_FLAG(pd, aic); SET_FLAG(pd, aiv); SET_FLAG(pd, umv); SET_FLAG(pd, psnr); SET_FLAG(pd, trell); SET_FLAG(pd, gray); SET_FLAG(pd, v4mv); SET_FLAG(pd, closedgop); #if LIBAVCODEC_VERSION_INT < ((52<<16)+(0<<8)+0) /* FIXME: coherency check */ if (pd->ff_vcontext.rtp_payload_size > 0) { pd->ff_vcontext.rtp_mode = 1; } #endif if (pd->confdata.flags.closedgop) { pd->ff_vcontext.scenechange_threshold = 1000000; } if (pd->interlacing.active) { /* enforce interlacing */ pd->ff_vcontext.flags |= CODEC_FLAG_INTERLACED_DCT; pd->ff_vcontext.flags |= CODEC_FLAG_INTERLACED_ME; } } #undef SET_FLAG /* * tc_lavc_read_config: * read configuration values from * 1) configuration file (if found) * 2) command line (overrides configuration file in case * of conflicts). * Also read related informations like RC override string * and custom quantization matrices; translate all settings * in libavcodec-friendly values (if needed), then finally * perform some coherency checks and feed avcodec context * with gathered data. * * Parameters: * pd: pointer to private module data. * options: command line options of *THIS MODULE*. * Return Value: * TC_OK: succesfull * TC_ERROR: error. Mostly I/O related or badly broken * (meaningless) value. Exact reason will tc_log*()'d out. * Side Effects: * Quite a lot, since various (and quite complex) subroutines * are involved. Most notably, various files can be opened/read/closed * on disk, and some memory could be allocated. * * FIXME: I'm a bit worried about heavy stack usage of this function... */ static int tc_lavc_read_config(TCLavcPrivateData *pd, const char *options, const vob_t *vob) { char intra_matrix_file[PATH_MAX] = { '\0' }; char inter_matrix_file[PATH_MAX] = { '\0' }; char rc_override_buf[TC_BUF_MIN] = { '\0' }; /* XXX */ /* * Please note that option names are INTENTIONALLY identical/similar * to mplayer/mencoder ones */ TCConfigEntry lavc_conf[] = { { "threads", PAUX(thread_count), TCCONF_TYPE_INT, TCCONF_FLAG_RANGE, 1, 7 }, // need special handling // { "keyint", PCTX(gop_size), TCCONF_TYPE_INT, TCCONF_FLAG_RANGE, 1, 1000 }, // handled by transcode core // { "vbitrate", PCTX(bit_rate), TCCONF_TYPE_INT, TCCONF_FLAG_RANGE, 0, INT_MAX }, // handled by transcode core // { "vqmin", PCTX(qmin), TCCONF_TYPE_INT, TCCONF_FLAG_RANGE, 1, 60 }, // handled by transcode core // { "vqmax", PCTX(qmax), TCCONF_TYPE_INT, TCCONF_FLAG_RANGE, 1, 60 }, // handled by transcode core { "mbqmin", PCTX(mb_qmin), TCCONF_TYPE_INT, TCCONF_FLAG_RANGE, 1, 60 }, { "mbqmax", PCTX(mb_qmax), TCCONF_TYPE_INT, TCCONF_FLAG_RANGE, 1, 60 }, { "lmin", PAUX(lmin), TCCONF_TYPE_FLOAT, TCCONF_FLAG_RANGE, 0.01, 255.0 }, { "lmax", PAUX(lmax), TCCONF_TYPE_FLOAT, TCCONF_FLAG_RANGE, 0.01, 255.0 }, { "vqdiff", PCTX(max_qdiff), TCCONF_TYPE_INT, TCCONF_FLAG_RANGE, 1, 31 }, { "vmax_b_frames", PCTX(max_b_frames), TCCONF_TYPE_INT, TCCONF_FLAG_RANGE, 0, FF_MAX_B_FRAMES }, { "vme", PAUX(me_method), TCCONF_TYPE_INT, TCCONF_FLAG_RANGE, 0, 16, }, { "me_range", PCTX(me_range), TCCONF_TYPE_INT, TCCONF_FLAG_RANGE, 0, 16000 }, { "mbd", PCTX(mb_decision), TCCONF_TYPE_INT, TCCONF_FLAG_RANGE, 0, 3 }, { "sc_threshold", PCTX(scenechange_threshold), TCCONF_TYPE_INT, TCCONF_FLAG_RANGE, -1000000, 1000000 }, { "sc_factor", PCTX(scenechange_factor), TCCONF_TYPE_INT, TCCONF_FLAG_RANGE, 1, 16 }, { "vb_strategy", PCTX(b_frame_strategy), TCCONF_TYPE_INT, TCCONF_FLAG_RANGE, 0, 10 }, { "b_sensitivity", PCTX(b_sensitivity), TCCONF_TYPE_INT, TCCONF_FLAG_RANGE, 1, 100 }, { "brd_scale", PCTX(brd_scale), TCCONF_TYPE_INT, TCCONF_FLAG_RANGE, 0, 10 }, { "bidir_refine", PCTX(bidir_refine), TCCONF_TYPE_INT, TCCONF_FLAG_RANGE, 0, 4 }, // { "aspect", }, // handled by transcode core { "vratetol", PAUX(vrate_tolerance), TCCONF_TYPE_INT, TCCONF_FLAG_RANGE, 4, 24000000 }, { "vrc_maxrate", PAUX(rc_max_rate), TCCONF_TYPE_INT, TCCONF_FLAG_RANGE, 0, 24000000 }, { "vrc_minrate", PAUX(rc_min_rate), TCCONF_TYPE_INT, TCCONF_FLAG_RANGE, 0, 24000000 }, { "vrc_buf_size", PAUX(rc_buffer_size), TCCONF_TYPE_INT, TCCONF_FLAG_RANGE, 4, 24000000 }, { "vrc_strategy", PCTX(rc_strategy), TCCONF_TYPE_INT, TCCONF_FLAG_RANGE, 0, 2 }, { "vb_qfactor", PCTX(b_quant_factor), TCCONF_TYPE_FLOAT, TCCONF_FLAG_RANGE, -31.0, 31.0 }, { "vi_qfactor", PCTX(i_quant_factor), TCCONF_TYPE_FLOAT, TCCONF_FLAG_RANGE, -31.0, 31.0 }, { "vb_qoffset", PCTX(b_quant_offset), TCCONF_TYPE_FLOAT, TCCONF_FLAG_RANGE, 0.0, 31.0 }, { "vi_qoffset", PCTX(i_quant_offset), TCCONF_TYPE_FLOAT, TCCONF_FLAG_RANGE, 0.0, 31.0 }, { "vqblur", PCTX(qblur), TCCONF_TYPE_FLOAT, TCCONF_FLAG_RANGE, 0.0, 1.0 }, { "vqcomp", PCTX(qcompress), TCCONF_TYPE_FLOAT, TCCONF_FLAG_RANGE, 0.0, 1.0 }, { "mpeg_quant", PCTX(mpeg_quant), TCCONF_TYPE_FLAG, 0, 0, 1 }, // { "vrc_eq", }, // not yet supported { "vrc_override", rc_override_buf, TCCONF_TYPE_STRING, 0, 0, 0 }, { "vrc_init_cplx", PCTX(rc_initial_cplx), TCCONF_TYPE_FLOAT, TCCONF_FLAG_RANGE, 0.0, 9999999.0 }, // { "vrc_init_occupancy", }, // not yet supported { "vqsquish", PCTX(rc_qsquish), TCCONF_TYPE_FLOAT, TCCONF_FLAG_RANGE, 0.0, 99.0 }, { "vlelim", PCTX(luma_elim_threshold), TCCONF_TYPE_INT, TCCONF_FLAG_RANGE, -99, 99 }, { "vcelim", PCTX(chroma_elim_threshold), TCCONF_TYPE_INT, TCCONF_FLAG_RANGE, -99, 99 }, { "vstrict", PCTX(strict_std_compliance), TCCONF_TYPE_INT, TCCONF_FLAG_RANGE, -99, 99 }, { "vpsize", PCTX(rtp_payload_size), TCCONF_TYPE_INT, TCCONF_FLAG_RANGE, 0, 100000000 }, { "dct", PCTX(dct_algo), TCCONF_TYPE_INT, TCCONF_FLAG_RANGE, 0, 10 }, { "idct", PCTX(idct_algo), TCCONF_TYPE_INT, TCCONF_FLAG_RANGE, 0, 20 }, { "lumi_mask", PCTX(lumi_masking), TCCONF_TYPE_FLOAT, TCCONF_FLAG_RANGE, 0.0, 1.0 }, { "dark_mask", PCTX(dark_masking), TCCONF_TYPE_FLOAT, TCCONF_FLAG_RANGE, 0.0, 1.0 }, { "tcplx_mask", PCTX(temporal_cplx_masking), TCCONF_TYPE_FLOAT, TCCONF_FLAG_RANGE, 0.0, 1.0 }, { "scplx_mask", PCTX(spatial_cplx_masking), TCCONF_TYPE_FLOAT, TCCONF_FLAG_RANGE, 0.0, 1.0 }, { "p_mask", PCTX(p_masking), TCCONF_TYPE_FLOAT, TCCONF_FLAG_RANGE, 0.0, 1.0 }, { "border_mask", PCTX(border_masking), TCCONF_TYPE_FLOAT, TCCONF_FLAG_RANGE, 0.0, 1.0 }, { "pred", PCTX(prediction_method), TCCONF_TYPE_INT, TCCONF_FLAG_RANGE, 0, 4 }, { "precmp", PCTX(me_pre_cmp), TCCONF_TYPE_INT, TCCONF_FLAG_RANGE, 0, 2000 }, { "cmp", PCTX(me_cmp), TCCONF_TYPE_INT, TCCONF_FLAG_RANGE, 0, 2000 }, { "subcmp", PCTX(me_sub_cmp), TCCONF_TYPE_INT, TCCONF_FLAG_RANGE, 0, 2000 }, { "ildctcmp", PCTX(ildct_cmp), TCCONF_TYPE_INT, TCCONF_FLAG_RANGE, 0, 2000 }, { "predia", PCTX(pre_dia_size), TCCONF_TYPE_INT, TCCONF_FLAG_RANGE, -2000, 2000 }, { "dia", PCTX(dia_size), TCCONF_TYPE_INT, TCCONF_FLAG_RANGE, -2000, 2000 }, { "mv0_threshold", PCTX(mv0_threshold), TCCONF_TYPE_INT, TCCONF_FLAG_RANGE, 0, 1000 }, { "last_pred", PCTX(last_predictor_count), TCCONF_TYPE_INT, TCCONF_FLAG_RANGE, 0, 2000 }, { "pre_me", PCTX(pre_me), TCCONF_TYPE_INT, TCCONF_FLAG_RANGE, 0, 2000}, { "subq", PCTX(me_subpel_quality), TCCONF_TYPE_INT, TCCONF_FLAG_RANGE, 0, 8 }, { "refs", PCTX(refs), TCCONF_TYPE_INT, TCCONF_FLAG_RANGE, 1, 8 }, { "ibias", PCTX(intra_quant_bias), TCCONF_TYPE_INT, TCCONF_FLAG_RANGE, -512, 512 }, { "pbias", PCTX(inter_quant_bias), TCCONF_TYPE_INT, TCCONF_FLAG_RANGE, -512, 512 }, { "nr", PCTX(noise_reduction), TCCONF_TYPE_INT, TCCONF_FLAG_RANGE, 0, 1000000}, { "qns", PCTX(quantizer_noise_shaping), TCCONF_TYPE_INT, TCCONF_FLAG_RANGE, 0, 3 }, { "inter_matrix_file", inter_matrix_file, TCCONF_TYPE_STRING, 0, 0, 0 }, { "intra_matrix_file", intra_matrix_file, TCCONF_TYPE_STRING, 0, 0, 0 }, { "mv0", PAUX(flags.mv0), TCCONF_TYPE_FLAG, 0, 0, CODEC_FLAG_MV0 }, { "cbp", PAUX(flags.cbp), TCCONF_TYPE_FLAG, 0, 0, CODEC_FLAG_CBP_RD }, { "qpel", PAUX(flags.qpel), TCCONF_TYPE_FLAG, 0, 0, CODEC_FLAG_QPEL }, { "alt", PAUX(flags.alt), TCCONF_TYPE_FLAG, 0, 0, CODEC_FLAG_ALT_SCAN }, { "ilme", PAUX(flags.ilme), TCCONF_TYPE_FLAG, 0, 0, CODEC_FLAG_INTERLACED_ME }, { "ildct", PAUX(flags.ildct), TCCONF_TYPE_FLAG, 0, 0, CODEC_FLAG_INTERLACED_DCT }, { "naq", PAUX(flags.naq), TCCONF_TYPE_FLAG, 0, 0, CODEC_FLAG_NORMALIZE_AQP }, { "vdpart", PAUX(flags.vdpart), TCCONF_TYPE_FLAG, 0, 0, CODEC_FLAG_PART }, #if LIBAVCODEC_VERSION_INT < ((52<<16)+(0<<8)+0) { "aic", PAUX(flags.aic), TCCONF_TYPE_FLAG, 0, 0, CODEC_FLAG_H263P_AIC }, #else { "aic", PAUX(flags.aic), TCCONF_TYPE_FLAG, 0, 0, CODEC_FLAG_AC_PRED }, #endif { "aiv", PAUX(flags.aiv), TCCONF_TYPE_FLAG, 0, 0, CODEC_FLAG_H263P_AIV }, { "umv", PAUX(flags.umv), TCCONF_TYPE_FLAG, 0, 0, CODEC_FLAG_H263P_UMV }, { "psnr", PAUX(flags.psnr), TCCONF_TYPE_FLAG, 0, 0, CODEC_FLAG_PSNR }, #if LIBAVCODEC_VERSION_INT < ((52<<16)+(0<<8)+0) { "trell", PAUX(flags.trell), TCCONF_TYPE_FLAG, 0, 0, CODEC_FLAG_TRELLIS_QUANT }, #else { "trell", PCTX(trellis), TCCONF_TYPE_FLAG, 0, 0, 1 }, #endif { "gray", PAUX(flags.gray), TCCONF_TYPE_FLAG, 0, 0, CODEC_FLAG_GRAY }, { "v4mv", PAUX(flags.v4mv), TCCONF_TYPE_FLAG, 0, 0, CODEC_FLAG_4MV }, { "closedgop", PAUX(flags.closedgop), TCCONF_TYPE_FLAG, 0, 0, CODEC_FLAG_CLOSED_GOP }, // { "turbo", PAUX(turbo_setup), TCCONF_TYPE_FLAG, 0, 0, 1 }, // not yet supported /* End of the config file */ { NULL, 0, 0, 0, 0, 0 } }; module_read_config(LAVC_CONFIG_FILE, tc_codec_to_string(vob->ex_v_codec), lavc_conf, MOD_NAME); if (options && strlen(options) > 0) { size_t i = 0, n = 0; char **opts = tc_strsplit(options, ':', &n); if (opts == NULL) { tc_log_error(MOD_NAME, "can't split option string"); return TC_ERROR; } for (i = 0; i < n; i++) { if (!module_read_config_line(opts[i], lavc_conf, MOD_NAME)) { tc_log_error(MOD_NAME, "error parsing module options (%s)", opts[i]); tc_strfreev(opts); return TC_ERROR; } } tc_strfreev(opts); } /* gracefully go ahead if no matrices are given */ tc_lavc_read_matrices(pd, intra_matrix_file, inter_matrix_file); /* gracefully go ahead if no rc override is given */ tc_lavc_init_rc_override(pd, rc_override_buf); if (verbose >= TC_DEBUG) { module_print_config(lavc_conf, MOD_NAME); } /* only now we can do this safely */ tc_lavc_dispatch_settings(pd); return TC_OK; } #undef PCTX #undef PAUX /* * tc_lavc_write_logs: * write on disk file encoding logs. That means encoder * multipass log file, but that can also include PSNR * statistics, if requested. * * Parameters: * pd: pointer to private module data. * size: size of last encoded frame. * Return Value: * TC_OK: succesfull * TC_ERROR: I/O error. Exact reason will tc_log*()'d out. */ static int tc_lavc_write_logs(TCLavcPrivateData *pd, int size) { /* store stats if there are any */ if (pd->ff_vcontext.stats_out != NULL && pd->stats_file != NULL) { int ret = fprintf(pd->stats_file, "%s", pd->ff_vcontext.stats_out); if (ret < 0) { tc_log_warn(MOD_NAME, "error while writing multipass log file"); return TC_ERROR; } } if (PSNR_REQUESTED(pd)) { /* errors not fatal, they can be ignored */ psnr_write(pd, size); } return TC_OK; } /*************************************************************************/ /* see libtc/tcmodule-data.h for functions meaning and purposes */ static int tc_lavc_init(TCModuleInstance *self, uint32_t features) { TCLavcPrivateData *pd = NULL; TC_MODULE_SELF_CHECK(self, "init"); TC_MODULE_INIT_CHECK(self, MOD_FEATURES, features); pd = tc_malloc(sizeof(TCLavcPrivateData)); if (pd == NULL) { tc_log_error(MOD_NAME, "unable to allocate private data"); return TC_ERROR; } /* enforce NULL-ness of dangerous (segfault-friendly) stuff */ pd->psnr_file = NULL; pd->stats_file = NULL; if (verbose) { tc_log_info(MOD_NAME, "%s %s", MOD_VERSION, MOD_CAP); } self->userdata = pd; return TC_OK; } static int tc_lavc_fini(TCModuleInstance *self) { TC_MODULE_SELF_CHECK(self, "fini"); /* _stop() does the magic; FIXME: recall from here? */ tc_free(self->userdata); self->userdata = NULL; return TC_OK; } #define ABORT_IF_NOT_OK(RET) do { \ if ((RET) != TC_OK) { \ goto failed; \ } \ } while (0) static int tc_lavc_configure(TCModuleInstance *self, const char *options, vob_t *vob) { const char *vcodec_name = tc_codec_to_string(vob->ex_v_codec); TCLavcPrivateData *pd = NULL; int ret = TC_OK; TC_MODULE_SELF_CHECK(self, "configure"); TC_MODULE_SELF_CHECK(options, "configure"); /* paranoia */ pd = self->userdata; pd->flush_flag = vob->encoder_flush; /* FIXME: move into core? */ TC_INIT_LIBAVCODEC; avcodec_get_frame_defaults(&pd->ff_venc_frame); /* * auxiliary config data needs to be blanked too * before any other operation */ tc_lavc_config_defaults(pd); /* * we must do first since we NEED valid vcodec_name * ASAP to read right section of configuration file. */ pd->vcodec_id = tc_codec_is_supported(vob->ex_v_codec); if (pd->vcodec_id == TC_NULL_MATCH) { tc_log_error(MOD_NAME, "unsupported codec `%s'", vcodec_name); return TC_ERROR; } if (verbose) { tc_log_info(MOD_NAME, "using video codec '%s'", vcodec_name); } ret = tc_lavc_settings_from_vob(pd, vob); ABORT_IF_NOT_OK(ret); /* calling WARNING: order matters here */ ret = tc_lavc_init_buf(pd, vob); ABORT_IF_NOT_OK(ret); ret = tc_lavc_read_config(pd, options, vob); ABORT_IF_NOT_OK(ret); tc_lavc_load_filters(pd); if (verbose) { tc_log_info(MOD_NAME, "using %i thread%s", pd->confdata.thread_count, (pd->confdata.thread_count > 1) ?"s" :""); } avcodec_thread_init(&pd->ff_vcontext, pd->confdata.thread_count); pd->ff_vcodec = avcodec_find_encoder(FF_VCODEC_ID(pd)); if (pd->ff_vcodec == NULL) { tc_log_error(MOD_NAME, "unable to find a libavcodec encoder for `%s'", tc_codec_to_string(TC_VCODEC_ID(pd))); goto failed; } TC_LOCK_LIBAVCODEC; ret = avcodec_open(&pd->ff_vcontext, pd->ff_vcodec); TC_UNLOCK_LIBAVCODEC; if (ret < 0) { tc_log_error(MOD_NAME, "avcodec_open() failed"); goto failed; } /* finally, pass up the extradata, if any */ self->extradata = pd->ff_vcontext.extradata; self->extradata_size = pd->ff_vcontext.extradata_size; if (PSNR_REQUESTED(pd)) { /* errors already logged, and they can be ignored */ psnr_open(pd); pd->confdata.flags.psnr = 0; /* no longer requested :^) */ } return TC_OK; failed: tc_lavc_fini_buf(pd); return TC_ERROR; } #undef ABORT_IF_NOT_OK static int tc_lavc_inspect(TCModuleInstance *self, const char *param, const char **value) { TC_MODULE_SELF_CHECK(self, "inspect"); TC_MODULE_SELF_CHECK(value, "inspect"); if (optstr_lookup(param, "help")) { *value = tc_lavc_help; } if (optstr_lookup(param, "vcodec")) { *value = "must be selected by user\n"; } if (optstr_lookup(param, "list")) { *value = tc_lavc_list_codecs(); } return TC_OK; } static int tc_lavc_stop(TCModuleInstance *self) { TCLavcPrivateData *pd = NULL; TC_MODULE_SELF_CHECK(self, "stop"); pd = self->userdata; tc_lavc_fini_buf(pd); if (PSNR_REQUESTED(pd)) { psnr_print(pd); psnr_close(pd); } tc_lavc_fini_rc_override(pd); /* ok, now really start the real teardown */ tc_lavc_fini_multipass(pd); if (pd->ff_vcodec != NULL) { avcodec_close(&pd->ff_vcontext); pd->ff_vcodec = NULL; } return TC_OK; } static int tc_lavc_flush_video(TCModuleInstance *self, vframe_list_t *outframe) { outframe->video_len = 0; return TC_OK; } static int tc_lavc_encode_video(TCModuleInstance *self, vframe_list_t *inframe, vframe_list_t *outframe) { TCLavcPrivateData *pd = NULL; TC_MODULE_SELF_CHECK(self, "encode_video"); pd = self->userdata; if (inframe == NULL && pd->flush_flag) { return tc_lavc_flush_video(self, outframe); // FIXME } pd->ff_venc_frame.interlaced_frame = pd->interlacing.active; pd->ff_venc_frame.top_field_first = pd->interlacing.top_first; pd->pre_encode_video(pd, inframe); TC_LOCK_LIBAVCODEC; outframe->video_len = avcodec_encode_video(&pd->ff_vcontext, outframe->video_buf, inframe->video_size, &pd->ff_venc_frame); TC_UNLOCK_LIBAVCODEC; if (outframe->video_len < 0) { tc_log_warn(MOD_NAME, "encoder error: size (%i)", outframe->video_len); return TC_ERROR; } if (pd->ff_vcontext.coded_frame->key_frame) { outframe->attributes |= TC_FRAME_IS_KEYFRAME; } return tc_lavc_write_logs(pd, outframe->video_len); } /*************************************************************************/ TC_MODULE_CODEC_FORMATS(tc_lavc); TC_MODULE_INFO(tc_lavc); static const TCModuleClass tc_lavc_class = { TC_MODULE_CLASS_HEAD(tc_lavc), .init = tc_lavc_init, .fini = tc_lavc_fini, .configure = tc_lavc_configure, .stop = tc_lavc_stop, .inspect = tc_lavc_inspect, .encode_video = tc_lavc_encode_video, }; extern const TCModuleClass *tc_plugin_setup(void) { return &tc_lavc_class; } /*************************************************************************/ /* * Local variables: * c-file-style: "stroustrup" * c-file-offsets: ((case-label . *) (statement-case-intro . *)) * indent-tabs-mode: nil * End: * * vim: expandtab shiftwidth=4: */