libmpcodecs/ve_x264.c

   1 /*****************************************************************************
   2  *
   3  * - H.264 encoder for mencoder using x264 -
   4  *
   5  * Copyright (C) 2004 LINUX4MEDIA GmbH
   6  * Copyright (C) 2004 Ark Linux
   7  *
   8  * Written by Bernhard Rosenkraenzer <bero@arklinux.org>
   9  *
  10  * This file is part of MPlayer.
  11  *
  12  * MPlayer is free software; you can redistribute it and/or modify
  13  * it under the terms of the GNU General Public License as published by
  14  * the Free Software Foundation; either version 2 of the License, or
  15  * (at your option) any later version.
  16  *
  17  * MPlayer is distributed in the hope that it will be useful,
  18  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  19  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  20  * GNU General Public License for more details.
  21  *
  22  * You should have received a copy of the GNU General Public License along
  23  * with MPlayer; if not, write to the Free Software Foundation, Inc.,
  24  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  25  *
  26  *****************************************************************************/
  27
  28 #include <stdio.h>
  29 #include <stdlib.h>
  30 #include <string.h>
  31 #include <errno.h>
  32
  33 #include "config.h"
  34 #include "mp_msg.h"
  35
  36 #include "m_option.h"
  37 #include "codec-cfg.h"
  38 #include "stream/stream.h"
  39 #include "libmpdemux/demuxer.h"
  40 #include "libmpdemux/stheader.h"
  41
  42 #include "stream/stream.h"
  43 #include "libmpdemux/muxer.h"
  44
  45 #include "img_format.h"
  46 #include "mp_image.h"
  47 #include "vf.h"
  48
  49 #include <x264.h>
  50
  51 typedef struct h264_module_t {
  52     muxer_stream_t *mux;
  53     x264_t *    x264;
  54     x264_picture_t  pic;
  55 } h264_module_t;
  56
  57 extern char* passtmpfile;
  58 static int turbo = 0;
  59 static x264_param_t param;
  60 static int parse_error = 0;
  61
  62 static int encode_nals(uint8_t *buf, int size, x264_nal_t *nals, int nnal){
  63     uint8_t *p = buf;
  64     int i;
  65
  66     for(i = 0; i < nnal; i++){
  67         int s = x264_nal_encode(p, &size, 1, nals + i);
  68         if(s < 0)
  69             return -1;
  70         p += s;
  71     }
  72
  73     return p - buf;
  74 }
  75
  76 static int put_image(struct vf_instance_s *vf, mp_image_t *mpi, double pts);
  77 static int encode_frame(struct vf_instance_s *vf, x264_picture_t *pic_in);
  78
  79 void x264enc_set_param(const m_option_t* opt, char* arg)
  80 {
  81     static int initted = 0;
  82     if(!initted) {
  83         x264_param_default(&param);
  84         x264_param_parse(&param, "psnr", "no");
  85         x264_param_parse(&param, "ssim", "no");
  86         initted = 1;
  87     }
  88
  89     if(!arg) {
  90         parse_error = 1;
  91         return;
  92     }
  93
  94     while(*arg) {
  95         char *name = arg;
  96         char *value;
  97         int ret;
  98
  99         arg += strcspn(arg, ":");
 100         if(*arg) {
 101             *arg = 0;
 102             arg++;
 103         }
 104
 105         value = strchr( name, '=' );
 106         if(value) {
 107             *value = 0;
 108             value++;
 109         }
 110
 111         if(!strcmp(name, "turbo")) {
 112             turbo = value ? atoi(value) : 1;
 113             continue;
 114         }
 115
 116         ret = x264_param_parse(&param, name, value);
 117         if(ret == X264_PARAM_BAD_NAME)
 118             mp_msg(MSGT_CFGPARSER, MSGL_ERR, "Option x264encopts: Unknown suboption %s\n", name);
 119         if(ret == X264_PARAM_BAD_VALUE)
 120             mp_msg(MSGT_CFGPARSER, MSGL_ERR, "Option x264encopts: Bad argument %s=%s\n", name, value ? value : "(null)");
 121
 122         /* mark this option as done, so it's not reparsed if there's another -x264encopts */
 123         *name = 0;
 124
 125         parse_error |= ret;
 126     }
 127
 128     if(param.rc.b_stat_write && !param.rc.b_stat_read) {
 129         /* Adjust or disable some flags to gain speed in the first pass */
 130         if(turbo == 1)
 131         {
 132             param.i_frame_reference = ( param.i_frame_reference + 1 ) >> 1;
 133             param.analyse.i_subpel_refine = FFMAX( FFMIN( 3, param.analyse.i_subpel_refine - 1 ), 1 );
 134             param.analyse.inter &= ( ~X264_ANALYSE_PSUB8x8 );
 135             param.analyse.inter &= ( ~X264_ANALYSE_BSUB16x16 );
 136             param.analyse.i_trellis = 0;
 137         }
 138         else if(turbo >= 2)
 139         {
 140             param.i_frame_reference = 1;
 141             param.analyse.i_subpel_refine = 1;
 142             param.analyse.i_me_method = X264_ME_DIA;
 143             param.analyse.inter = 0;
 144             param.analyse.b_transform_8x8 = 0;
 145             param.analyse.b_weighted_bipred = 0;
 146             param.analyse.i_trellis = 0;
 147         }
 148     }
 149 }
 150
 151 static int config(struct vf_instance_s* vf, int width, int height, int d_width, int d_height, unsigned int flags, unsigned int outfmt) {
 152     h264_module_t *mod=(h264_module_t*)vf->priv;
 153
 154     if(parse_error)
 155         return 0;
 156
 157     mod->mux->bih->biWidth = width;
 158     mod->mux->bih->biHeight = height;
 159     mod->mux->bih->biSizeImage = width * height * 3;
 160     mod->mux->aspect = (float)d_width/d_height;
 161
 162     // make sure param is initialized
 163     x264enc_set_param(NULL, "");
 164     param.i_width = width;
 165     param.i_height = height;
 166     param.i_fps_num = mod->mux->h.dwRate;
 167     param.i_fps_den = mod->mux->h.dwScale;
 168     param.vui.i_sar_width = d_width*height;
 169     param.vui.i_sar_height = d_height*width;
 170
 171     x264_param_parse(&param, "stats", passtmpfile);
 172
 173     switch(outfmt) {
 174     case IMGFMT_I420:
 175         param.i_csp = X264_CSP_I420;
 176         break;
 177     case IMGFMT_YV12:
 178         param.i_csp = X264_CSP_YV12;
 179         break;
 180     default:
 181         mp_msg(MSGT_MENCODER, MSGL_ERR, "Wrong colorspace.\n");
 182         return 0;
 183     }
 184
 185     mod->x264 = x264_encoder_open(&param);
 186     if(!mod->x264) {
 187         mp_msg(MSGT_MENCODER, MSGL_ERR, "x264_encoder_open failed.\n");
 188         return 0;
 189     }
 190
 191     if(!param.b_repeat_headers){
 192         uint8_t *extradata;
 193         x264_nal_t *nal;
 194         int extradata_size, nnal, i, s = 0;
 195
 196         x264_encoder_headers(mod->x264, &nal, &nnal);
 197
 198         /* 5 bytes NAL header + worst case escaping */
 199         for(i = 0; i < nnal; i++)
 200             s += 5 + nal[i].i_payload * 4 / 3;
 201
 202         extradata = malloc(s);
 203         extradata_size = encode_nals(extradata, s, nal, nnal);
 204
 205         mod->mux->bih= realloc(mod->mux->bih, sizeof(BITMAPINFOHEADER) + extradata_size);
 206         memcpy(mod->mux->bih + 1, extradata, extradata_size);
 207         mod->mux->bih->biSize= sizeof(BITMAPINFOHEADER) + extradata_size;
 208     }
 209
 210     if (param.i_bframe > 1 && param.b_bframe_pyramid)
 211         mod->mux->decoder_delay = 2;
 212     else
 213         mod->mux->decoder_delay = param.i_bframe ? 1 : 0;
 214
 215     return 1;
 216 }
 217
 218 static int control(struct vf_instance_s* vf, int request, void *data)
 219 {
 220     h264_module_t *mod=(h264_module_t*)vf->priv;
 221     switch(request){
 222         case VFCTRL_FLUSH_FRAMES:
 223             if(param.i_bframe)
 224                 while(encode_frame(vf, NULL) > 0);
 225             return CONTROL_TRUE;
 226         default:
 227             return CONTROL_UNKNOWN;
 228     }
 229 }
 230
 231 static int query_format(struct vf_instance_s* vf, unsigned int fmt)
 232 {
 233     switch(fmt) {
 234     case IMGFMT_I420:
 235         return VFCAP_CSP_SUPPORTED | VFCAP_CSP_SUPPORTED_BY_HW;
 236     case IMGFMT_YV12:
 237     case IMGFMT_422P:
 238     case IMGFMT_444P:
 239     case IMGFMT_YVYU:
 240     case IMGFMT_RGB:
 241     case IMGFMT_BGR:
 242     case IMGFMT_BGR32:
 243         /* These colorspaces are supported, but they'll just have
 244          * to be converted to I420 internally */
 245         return 0; /* VFCAP_CSP_SUPPORTED */
 246     }
 247     return 0;
 248 }
 249
 250 static int put_image(struct vf_instance_s *vf, mp_image_t *mpi, double pts)
 251 {
 252     h264_module_t *mod=(h264_module_t*)vf->priv;
 253     int i;
 254
 255     memset(&mod->pic, 0, sizeof(x264_picture_t));
 256     mod->pic.img.i_csp=param.i_csp;
 257     mod->pic.img.i_plane=3;
 258     for(i=0; i<4; i++) {
 259         mod->pic.img.plane[i] = mpi->planes[i];
 260         mod->pic.img.i_stride[i] = mpi->stride[i];
 261     }
 262
 263     mod->pic.i_type = X264_TYPE_AUTO;
 264
 265     return encode_frame(vf, &mod->pic) >= 0;
 266 }
 267
 268 static int encode_frame(struct vf_instance_s *vf, x264_picture_t *pic_in)
 269 {
 270     h264_module_t *mod=(h264_module_t*)vf->priv;
 271     x264_picture_t pic_out;
 272     x264_nal_t *nal;
 273     int i_nal;
 274     int i_size = 0;
 275     int i;
 276
 277     if(x264_encoder_encode(mod->x264, &nal, &i_nal, pic_in, &pic_out) < 0) {
 278         mp_msg(MSGT_MENCODER, MSGL_ERR, "x264_encoder_encode failed\n");
 279         return -1;
 280     }
 281
 282     for(i=0; i < i_nal; i++) {
 283         int i_data = mod->mux->buffer_size - i_size;
 284         i_size += x264_nal_encode(mod->mux->buffer + i_size, &i_data, 1, &nal[i]);
 285     }
 286     if(i_size>0) {
 287         int keyframe = (pic_out.i_type == X264_TYPE_IDR) ||
 288                        (pic_out.i_type == X264_TYPE_I
 289                         && param.i_frame_reference == 1
 290                         && !param.i_bframe);
 291         muxer_write_chunk(mod->mux, i_size, keyframe?0x10:0, MP_NOPTS_VALUE, MP_NOPTS_VALUE);
 292     }
 293     else
 294         ++mod->mux->encoder_delay;
 295
 296     return i_size;
 297 }
 298
 299 static void uninit(struct vf_instance_s *vf)
 300 {
 301     h264_module_t *mod=(h264_module_t*)vf->priv;
 302     if (mod->x264)
 303     x264_encoder_close(mod->x264);
 304 }
 305
 306 static int vf_open(vf_instance_t *vf, char *args) {
 307     h264_module_t *mod;
 308
 309     vf->config = config;
 310     vf->default_caps = VFCAP_CONSTANT;
 311     vf->control = control;
 312     vf->query_format = query_format;
 313     vf->put_image = put_image;
 314     vf->uninit = uninit;
 315     vf->priv = malloc(sizeof(h264_module_t));
 316
 317     mod=(h264_module_t*)vf->priv;
 318     mod->mux = (muxer_stream_t*)args;
 319     mod->mux->bih = malloc(sizeof(BITMAPINFOHEADER));
 320     memset(mod->mux->bih, 0, sizeof(BITMAPINFOHEADER));
 321     mod->mux->bih->biSize = sizeof(BITMAPINFOHEADER);
 322     mod->mux->bih->biPlanes = 1;
 323     mod->mux->bih->biBitCount = 24;
 324     mod->mux->bih->biCompression = mmioFOURCC('h', '2', '6', '4');
 325
 326     return 1;
 327 }
 328
 329 vf_info_t ve_info_x264 = {
 330     "H.264 encoder",
 331     "x264",
 332     "Bernhard Rosenkraenzer <bero@arklinux.org>",
 333     "(C) 2004 LINUX4MEDIA GmbH; (C) 2004 Ark Linux",
 334     vf_open
 335 };