ffmpeg2theora.c

/* -*- tab-width:4;c-file-style:"cc-mode"; -*- */
/*
 * ffmpeg2theora.c -- Convert ffmpeg supported a/v files to  Ogg Theora / Vorbis
 * Copyright (C) 2003-2009 <j@v2v.cc>
 *
 * This program 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 3 of the License, or
 * (at your option) any later version.
 *
 * This program 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 <http://www.gnu.org/licenses/>.
 */

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <getopt.h>
#include <math.h>
#include <errno.h>

#include "libavformat/avformat.h"
#include "libavdevice/avdevice.h"
#ifdef HAVE_FRAMEHOOK
#include "libavformat/framehook.h"
#endif
#include "libswscale/swscale.h"
#include "libpostproc/postprocess.h"

#include "theora/theoraenc.h"
#include "vorbis/codec.h"
#include "vorbis/vorbisenc.h"

#ifdef WIN32
#include "fcntl.h"
#endif

#include "theorautils.h"
#include "iso639.h"
#include "subtitles.h"
#include "ffmpeg2theora.h"
#include "avinfo.h"

#define LENGTH(x) (sizeof(x) / sizeof(*x))

enum {
    NULL_FLAG,
    DEINTERLACE_FLAG,
    SOFTTARGET_FLAG,
    TWOPASS_FLAG,
    FIRSTPASS_FLAG,
    SECONDPASS_FLAG,
    OPTIMIZE_FLAG,
    NOSYNC_FLAG,
    NOAUDIO_FLAG,
    NOVIDEO_FLAG,
    NOSUBTITLES_FLAG,
    NOMETADATA_FLAG,
    NOOSHASH_FLAG,
    NOUPSCALING_FLAG,
    CROPTOP_FLAG,
    CROPBOTTOM_FLAG,
    CROPRIGHT_FLAG,
    CROPLEFT_FLAG,
    ASPECT_FLAG,
    PIXEL_ASPECT_FLAG,
    MAXSIZE_FLAG,
    INPUTFPS_FLAG,
    AUDIOSTREAM_FLAG,
    VIDEOSTREAM_FLAG,
    SUBTITLES_FLAG,
    SUBTITLES_ENCODING_FLAG,
    SUBTITLES_LANGUAGE_FLAG,
    SUBTITLES_CATEGORY_FLAG,
    SUBTITLES_IGNORE_NON_UTF8_FLAG,
    VHOOK_FLAG,
    FRONTEND_FLAG,
    FRONTENDFILE_FLAG,
    SPEEDLEVEL_FLAG,
    PP_FLAG,
    NOSKELETON,
    SEEK_INDEX,
    INDEX_INTERVAL,
    THEORA_INDEX_RESERVE,
    VORBIS_INDEX_RESERVE,
    INFO_FLAG
} F2T_FLAGS;

enum {
    V2V_PRESET_NONE,
    V2V_PRESET_PRO,
    V2V_PRESET_PREVIEW,
    V2V_PRESET_VIDEOBIN,
    V2V_PRESET_PADMA,
    V2V_PRESET_PADMASTREAM,
} F2T_PRESETS;


#define PAL_HALF_WIDTH 384
#define PAL_HALF_HEIGHT 288
#define NTSC_HALF_WIDTH 320
#define NTSC_HALF_HEIGHT 240

#define PAL_FULL_WIDTH 720
#define PAL_FULL_HEIGHT 576
#define NTSC_FULL_WIDTH 720
#define NTSC_FULL_HEIGHT 480


oggmux_info info;

static int using_stdin = 0;

static int padcolor[3] = { 16, 128, 128 };


static int ilog(unsigned _v){
  int ret;
  for(ret=0;_v;ret++)_v>>=1;
  return ret;
}

/**
 * Allocate and initialise an AVFrame.
 */
static AVFrame *frame_alloc(int pix_fmt, int width, int height) {
    AVFrame *picture;
    uint8_t *picture_buf;
    int size;

    picture = avcodec_alloc_frame();
    if (!picture)
        return NULL;
    size = avpicture_get_size (pix_fmt, width, height);
    picture_buf = av_malloc (size);
    if (!picture_buf) {
        av_free (picture);
        return NULL;
    }
    avpicture_fill((AVPicture *) picture, picture_buf, pix_fmt, width, height);
    return picture;
}

/**
 * Frees an AVFrame.
 */
static void frame_dealloc(AVFrame *frame) {
    if (frame) {
        avpicture_free((AVPicture*)frame);
        av_free(frame);
    }
}

/**
 * initialize ff2theora with default values
 * @return ff2theora struct
 */
static ff2theora ff2theora_init() {
    ff2theora this = calloc (1, sizeof (*this));
    if (this != NULL) {
        this->disable_audio=0;
        this->disable_video=0;
        this->disable_subtitles=0;
        this->disable_metadata=0;
        this->disable_oshash=0;
        this->no_upscaling=0;
        this->video_index = -1;
        this->audio_index = -1;
        this->start_time=0;
        this->end_time=0; /* 0 denotes no end time set */

        // audio
        this->sample_rate = -1;  // samplerate hmhmhm
        this->channels = -1;
        this->audio_quality = 1.00;// audio quality 1
        this->audio_bitrate=0;
        this->audiostream = -1;

        // video
        this->videostream = -1;
        this->picture_width=0;      // set to 0 to not resize the output
        this->picture_height=0;      // set to 0 to not resize the output
        this->video_quality=-1; // defaults set later
        this->video_bitrate=0;
        this->keyint=0;
        this->force_input_fps.num = -1;
        this->force_input_fps.den = 1;
        this->sync = 1;
        this->aspect_numerator=0;
        this->aspect_denominator=0;
        this->colorspace = TH_CS_UNSPECIFIED;
        this->frame_aspect.num=0;
        this->frame_aspect.den=1;
        this->pixel_aspect.num=0;
        this->pixel_aspect.den=0;
        this->max_x=-1;
        this->max_y=-1;
        this->deinterlace=0; // auto by default, if input is flaged as interlaced it will deinterlace.
        this->soft_target=0;
        this->buf_delay=-1;
        this->vhook=0;
        this->framerate_new.num = -1;
        this->framerate_new.den = 1;

        this->frame_topBand=0;
        this->frame_bottomBand=0;
        this->frame_leftBand=0;
        this->frame_rightBand=0;

        this->n_kate_streams=0;
        this->kate_streams=NULL;
        this->ignore_non_utf8 = 0;

        this->pix_fmt = PIX_FMT_YUV420P;

        // ffmpeg2theora --nosound -f dv -H 32000 -S 0 -v 8 -x 384 -y 288 -G 1.5 input.dv
        this->video_gamma  = 0.0;
        this->video_bright = 0.0;
        this->video_contr  = 0.0;
        this->video_satur  = 1.0;

        this->y_lut_used = 0;
        this->uv_lut_used = 0;
        this->sws_colorspace_ctx = NULL;
        this->sws_scale_ctx = NULL;
    }
    return this;
}

// gamma lookup table code

static void y_lut_init(ff2theora this) {
    int i;
    double v;

    double c = this->video_contr;
    double b = this->video_bright;
    double g = this->video_gamma;

    if ((g < 0.01) || (g > 100.0)) g = 1.0;
    if ((c < 0.01) || (c > 100.0)) c = 1.0;
    if ((b < -1.0) || (b > 1.0))   b = 0.0;

    if (g == 1.0 && c == 1.0 && b == 0.0) return;
    this->y_lut_used = 1;

    fprintf(stderr, "  Video correction: gamma=%g, contrast=%g, brightness=%g\n", g, c, b);

    g = 1.0 / g;    // larger values shall make brighter video.

    for (i = 0; i < 256; i++) {
        v = (double) i / 255.0;
        v = c * v + b * 0.1;
        if (v < 0.0) v = 0.0;
        v = pow(v, g) * 255.0;    // mplayer's vf_eq2.c multiplies with 256 here, strange...

        if (v >= 255)
            this->y_lut[i] = 255;
        else
            this->y_lut[i] = (unsigned char)(v+0.5);
    }
}


static void uv_lut_init(ff2theora this) {
    int i;
    double v, s;
    s = this->video_satur;

    if ((s < 0.0) || (s > 100.0)) s = 1.0;

    if (s == 1.0) return;
    this->uv_lut_used = 1;

    fprintf(stderr, "  Color correction: saturation=%g\n", s);

    for (i = 0; i < 256; i++) {
        v = 127.0 + (s * ((double)i - 127.0));
        if (v < 0.0) v = 0.0;

        if (v >= 255.0)
            this->uv_lut[i] = 255;
        else
            this->uv_lut[i] = (unsigned char)(v+0.5);
    }
}

static void lut_init(ff2theora this) {
    y_lut_init(this);
    uv_lut_init(this);
}

static void lut_apply(unsigned char *lut, unsigned char *src, unsigned char *dst, int width, int height, int stride) {
    int x, y;

    for (y = 0; y < height; y++) {
        for (x = 0; x < width; x++) {
            dst[x] = lut[src[x]];
        }
        src += stride;
        dst += stride;
    }
}

static void prepare_ycbcr_buffer(ff2theora this, th_ycbcr_buffer ycbcr, AVFrame *frame) {
    /* pysical pages */
    ycbcr[0].width = this->frame_width;
    ycbcr[0].height = this->frame_height;
    ycbcr[0].stride = frame->linesize[0];
    ycbcr[0].data = frame->data[0];

    ycbcr[1].width = this->frame_width / 2;
    ycbcr[1].height = this->frame_height / 2;
    ycbcr[1].stride = frame->linesize[1];
    ycbcr[1].data = frame->data[1];

    ycbcr[2].width = this->frame_width / 2;
    ycbcr[2].height = this->frame_height / 2;
    ycbcr[2].stride = frame->linesize[1];
    ycbcr[2].data = frame->data[2];

    if (this->y_lut_used) {
        lut_apply(this->y_lut, ycbcr[0].data, ycbcr[0].data, ycbcr[0].width, ycbcr[0].height, ycbcr[0].stride);
    }
    if (this->uv_lut_used) {
        lut_apply(this->uv_lut, ycbcr[1].data, ycbcr[1].data, ycbcr[1].width, ycbcr[1].height, ycbcr[1].stride);
        lut_apply(this->uv_lut, ycbcr[2].data, ycbcr[2].data, ycbcr[2].width, ycbcr[2].height, ycbcr[2].stride);
    }
}

static int is_supported_subtitle_stream(ff2theora this, int idx)
{
  AVCodecContext *enc = this->context->streams[idx]->codec;
  if (enc->codec_type != CODEC_TYPE_SUBTITLE) return 0;
  switch (enc->codec_id) {
    case CODEC_ID_TEXT:
    case CODEC_ID_SSA:
    case CODEC_ID_MOV_TEXT:
      return 1;
    default:
      return 0;
  }
  return 0;
}

static char *get_raw_text_from_ssa(const char *ssa)
{
  int n,intag,inescape;
  char *multiblock = NULL, *realloced_mb;
  char *allocated;
  const char *dialogue, *ptr, *tag_start;

  if (!ssa) return NULL;

  /* turns out some SSA packets have several blocks, each on a single line, so loop */
  while (ssa) {
    dialogue=strstr(ssa, "Dialogue:");
    if (!dialogue) break;

    ptr = dialogue;
    for (n=0;n<9;++n) {
      ptr=strchr(ptr,',');
      if (!ptr) return NULL;
      ++ptr;
    }
    dialogue = ptr;
    allocated = strdup(dialogue);

    /* find all "{...}" tags - the following must work for UTF-8 */
    intag=inescape=0;
    n=0;
    for (ptr=dialogue; *ptr && *ptr!='\n'; ++ptr) {
      if (*ptr=='{') {
        if (intag==0) tag_start = ptr;
        ++intag;
      }
      else if (*ptr=='}') {
        --intag;
        if (intag == 0) {
          /* tag parsing - none for now */
        }
      }
      else if (!intag) {
        if (inescape) {
          if (*ptr == 'N' || *ptr == 'n')
            allocated[n++] = '\n';
          else if (*ptr == 'h')
            allocated[n++] = ' ';
          inescape=0;
        }
        else {
          if (*ptr=='\\') {
            inescape=1;
          }
          else {
            allocated[n++]=*ptr;
          }
        }
      }
    }
    allocated[n]=0;

    /* skip over what we read */
    ssa = ptr;

    /* remove any trailing newlines (also \r characters) */
    n = strlen(allocated);
    while (n>0 && (allocated[n-1]=='\n' || allocated[n-1]=='\r'))
      allocated[--n]=0;

    /* add this new block */
    realloced_mb = (char*)realloc(multiblock, (multiblock?strlen(multiblock):0) + strlen(allocated) + 2); /* \n + 0 */
    if (realloced_mb) {
      if (multiblock) strcat(realloced_mb, "\n"); else strcpy(realloced_mb, "");
      strcat(realloced_mb, allocated);
      multiblock = realloced_mb;
      free(allocated);
    }
  }

  return multiblock;
}

static const float get_ssa_time(const char *p)
{
    int hour, min, sec, hsec;

    if(sscanf(p, "%d:%d:%d%*c%d", &hour, &min, &sec, &hsec) != 4)
        return 0;

    min+= 60*hour;
    sec+= 60*min;
    return (float)(sec*100+hsec)/100;
}

static const float get_duration_from_ssa(const char *ssa)
{
  float d = 2.0f;
  double start, end;
  const char *ptr=ssa;

  ptr=strchr(ptr,',');
  if (!ptr) return d;
  ptr++;
  start = get_ssa_time(ptr);
  ptr=strchr(ptr,',');
  if (!ptr) return d;
  ptr++;
  end = get_ssa_time(ptr);

  return end-start;
}

static const char *find_language_for_subtitle_stream(const AVStream *s)
{
  const char *lang=find_iso639_1(s->language);
  if (!lang) {
    fprintf(stderr,"WARNING - unrecognized ISO 639-2 language code: %s\n",s->language);
  }
  return lang;
}

void ff2theora_output(ff2theora this) {
    unsigned int i;
    AVCodecContext *aenc = NULL;
    AVCodecContext *venc = NULL;
    int venc_pix_fmt;
    AVStream *astream = NULL;
    AVStream *vstream = NULL;
    AVCodec *acodec = NULL;
    AVCodec *vcodec = NULL;
    pp_mode_t *ppMode = NULL;
    pp_context_t *ppContext = NULL;
    int sws_flags;
    float frame_aspect = 0;
    double fps = 0.0;
    AVRational vstream_fps;
    int display_width, display_height;
    char *subtitles_enabled = (char*)alloca(this->context->nb_streams);
    char *subtitles_opened = (char*)alloca(this->context->nb_streams);
    int synced = this->start_time == 0.0;
    AVRational display_aspect_ratio, sample_aspect_ratio;

    if (this->audiostream >= 0 && this->context->nb_streams > this->audiostream) {
        AVCodecContext *enc = this->context->streams[this->audiostream]->codec;
        if (enc->codec_type == CODEC_TYPE_AUDIO) {
            this->audio_index = this->audiostream;
            fprintf(stderr, "  Using stream #0.%d as audio input\n",this->audio_index);
        }
        else {
            fprintf(stderr, "  The selected stream is not audio, falling back to automatic selection\n");
        }
    }
    if (this->videostream >= 0 && this->context->nb_streams > this->videostream) {
        AVCodecContext *enc = this->context->streams[this->videostream]->codec;
        if (enc->codec_type == CODEC_TYPE_VIDEO) {
            this->video_index = this->videostream;
            fprintf(stderr, "  Using stream #0.%d as video input\n",this->video_index);
        }
        else {
            fprintf(stderr, "  The selected stream is not video, falling back to automatic selection\n");
        }
    }

    for (i = 0; i < this->context->nb_streams; i++) {
        AVCodecContext *enc = this->context->streams[i]->codec;
        switch (enc->codec_type) {
            case CODEC_TYPE_VIDEO:
                if (this->video_index < 0 && !this->disable_video)
                    this->video_index = i;
                break;
            case CODEC_TYPE_AUDIO:
                if (this->audio_index < 0 && !this->disable_audio)
                    this->audio_index = i;
                break;
            default:
                break;
        }
    }

    if (this->video_index >= 0) {
        vstream = this->context->streams[this->video_index];
        venc = vstream->codec;
        vcodec = avcodec_find_decoder (venc->codec_id);
        display_width = venc->width;
        display_height = venc->height;
        venc_pix_fmt =  venc->pix_fmt;

        if (this->force_input_fps.num > 0)
            vstream_fps = this->force_input_fps;
        else if (vstream->time_base.den && vstream->time_base.num
                                  && av_q2d(vstream->time_base) > 0.001) {
            vstream_fps.num = vstream->time_base.den;
            vstream_fps.den = vstream->time_base.num;
        } else {
            vstream_fps.num = venc->time_base.den;
            vstream_fps.den = venc->time_base.num * venc->ticks_per_frame;
        }
        if (av_q2d(vstream->r_frame_rate) < av_q2d(vstream_fps)) {
            vstream_fps = vstream->r_frame_rate;
        }
        this->fps = fps = av_q2d(vstream_fps);
            
        if (vcodec == NULL || avcodec_open (venc, vcodec) < 0) {
            this->video_index = -1;
        }
        this->fps = fps;
#if DEBUG
        fprintf(stderr, "FPS1(stream): %f\n", 1/av_q2d(vstream->time_base));
        fprintf(stderr, "FPS2(stream.r_frame_rate): %f\n", av_q2d(vstream->r_frame_rate));
        fprintf(stderr, "FPS3(codec): %f\n", 1/av_q2d(venc->time_base));
        fprintf(stderr, "ticks per frame: %i\n", venc->ticks_per_frame);
        fprintf(stderr, "FPS used: %f\n", fps);
#endif
        if (this->picture_width && !this->picture_height) {
            this->picture_height = this->picture_width / ((double)display_width/display_height);
            this->picture_height = this->picture_height - this->picture_height%2;
        }
        if (this->picture_height && !this->picture_width) {
            this->picture_width = this->picture_height * ((double)display_width/display_height);
            this->picture_width = this->picture_width - this->picture_width%2;
        }


        if (this->picture_height==0 &&
            (this->frame_leftBand || this->frame_rightBand || this->frame_topBand || this->frame_bottomBand) ) {
            this->picture_height=display_height-
                    this->frame_topBand-this->frame_bottomBand;
        }
        if (this->picture_width==0 &&
            (this->frame_leftBand || this->frame_rightBand || this->frame_topBand || this->frame_bottomBand) ) {
            this->picture_width=display_width-
                    this->frame_leftBand-this->frame_rightBand;
        }

        //set display_aspect_ratio from source
        av_reduce(&display_aspect_ratio.num, &display_aspect_ratio.den,
                  venc->width*vstream->sample_aspect_ratio.num,
                  venc->height*vstream->sample_aspect_ratio.den,
                  1024*1024);

        if (vstream->sample_aspect_ratio.num && // default
            av_cmp_q(vstream->sample_aspect_ratio, venc->sample_aspect_ratio)) {
            sample_aspect_ratio = vstream->sample_aspect_ratio;
        } else {
            sample_aspect_ratio = venc->sample_aspect_ratio;
        }
        if (venc->sample_aspect_ratio.num) {
            av_reduce(&display_aspect_ratio.num, &display_aspect_ratio.den,
                      venc->width*venc->sample_aspect_ratio.num,
                      venc->height*venc->sample_aspect_ratio.den,
                      1024*1024);
        }

        if (this->preset == V2V_PRESET_PREVIEW) {
            if (abs(this->fps-30)<1 && (display_width!=NTSC_HALF_WIDTH || display_height!=NTSC_HALF_HEIGHT) ) {
                this->picture_width=NTSC_HALF_WIDTH;
                this->picture_height=NTSC_HALF_HEIGHT;
            }
            else {
                this->picture_width=PAL_HALF_WIDTH;
                this->picture_height=PAL_HALF_HEIGHT;
            }
        }
        else if (this->preset == V2V_PRESET_PRO) {
            if (abs(this->fps-30)<1 && (display_width!=NTSC_FULL_WIDTH || display_height!=NTSC_FULL_HEIGHT) ) {
                this->picture_width=NTSC_FULL_WIDTH;
                this->picture_height=NTSC_FULL_HEIGHT;
            }
            else {
                this->picture_width=PAL_FULL_WIDTH;
                this->picture_height=PAL_FULL_HEIGHT;
            }
        }
        else if (this->preset == V2V_PRESET_PADMA) {
            int width=display_width-this->frame_leftBand-this->frame_rightBand;
            int height=display_height-this->frame_topBand-this->frame_bottomBand;
            if (sample_aspect_ratio.den!=0 && sample_aspect_ratio.num!=0) {
                height=((float)sample_aspect_ratio.den/sample_aspect_ratio.num) * height;
                sample_aspect_ratio.den = 1;
                sample_aspect_ratio.num = 1;
            }
            if (this->frame_aspect.num == 0) {
                this->frame_aspect.num = width;
                this->frame_aspect.den = height;
            }
            if (av_q2d(this->frame_aspect) <= 1.5) {
                if (width > 640 || height > 480) {
                    //4:3 640 x 480
                    this->picture_width=640;
                    this->picture_height=480;
                }
                else {
                    this->picture_width=width;
                    this->picture_height=height;
                }
            }
            else {
                if (width > 640 || height > 360) {
                    //16:9 640 x 360
                    this->picture_width=640;
                    this->picture_height=360;
                }
                else {
                    this->picture_width=width;
                    this->picture_height=height;
                }
            }
            this->frame_aspect.num = this->picture_width;
            this->frame_aspect.den = this->picture_height;
        }
        else if (this->preset == V2V_PRESET_PADMASTREAM) {
            int width=display_width-this->frame_leftBand-this->frame_rightBand;
            int height=display_height-this->frame_topBand-this->frame_bottomBand;
            if (sample_aspect_ratio.den!=0 && sample_aspect_ratio.num!=0) {
                height=((float)sample_aspect_ratio.den/sample_aspect_ratio.num) * height;
                sample_aspect_ratio.den = 1;
                sample_aspect_ratio.num = 1;
            }
            if (this->frame_aspect.num == 0) {
                this->frame_aspect.num = width;
                this->frame_aspect.den = height;
            }
            if (av_q2d(this->frame_aspect) <= 1.5) {
                this->picture_width=128;
                this->picture_height=96;
            }
            else {
                this->picture_width=128;
                this->picture_height=72;
            }
            this->frame_aspect.num = this->picture_width;
            this->frame_aspect.den = this->picture_height;
        }
        else if (this->preset == V2V_PRESET_VIDEOBIN) {
            int width=display_width-this->frame_leftBand-this->frame_rightBand;
            int height=display_height-this->frame_topBand-this->frame_bottomBand;
            if (sample_aspect_ratio.den!=0 && sample_aspect_ratio.num!=0) {
                height=((float)sample_aspect_ratio.den/sample_aspect_ratio.num) * height;
                sample_aspect_ratio.den = 1;
                sample_aspect_ratio.num = 1;
            }
            if ( ((float)width /height) <= 1.5) {
                if (width > 448) {
                    //4:3 448 x 336
                    this->picture_width=448;
                    this->picture_height=336;
                }
                else {
                    this->picture_width=width;
                    this->picture_height=height;
                }
            }
            else {
                if (width > 512) {
                    //16:9 512 x 288
                    this->picture_width=512;
                    this->picture_height=288;
                }
                else {
                    this->picture_width=width;
                    this->picture_height=height;
                }
            }
            this->frame_aspect.num = this->picture_width;
            this->frame_aspect.den = this->picture_height;
        }
        //so frame_aspect is set on the commandline

        if (this->frame_aspect.num != 0) {
            if (this->picture_height) {
                this->aspect_numerator = this->frame_aspect.num*this->picture_height;
                this->aspect_denominator = this->frame_aspect.den*this->picture_width;
            }
            else{
                this->aspect_numerator = this->frame_aspect.num*display_height;
                this->aspect_denominator = this->frame_aspect.den*display_width;
            }
            av_reduce(&this->aspect_numerator,&this->aspect_denominator,
                       this->aspect_numerator,this->aspect_denominator,
                       1024*1024);
            frame_aspect=av_q2d(this->frame_aspect);
        }

        if (this->max_x > 0) {
            int width = display_width-this->frame_leftBand-this->frame_rightBand;
            int height = display_height-this->frame_topBand-this->frame_bottomBand;
            if (sample_aspect_ratio.den!=0 && sample_aspect_ratio.num!=0) {
                height=((float)sample_aspect_ratio.den/sample_aspect_ratio.num) * height;
                sample_aspect_ratio.den = 1;
                sample_aspect_ratio.num = 1;
            }
            if (this->frame_aspect.num == 0) {
                this->frame_aspect.num = width;
                this->frame_aspect.den = height;
            }
            if (width > height &&
                this->max_x/av_q2d(this->frame_aspect) <= this->max_y) {
                this->picture_width = this->max_x;
                this->picture_height = this->max_x / av_q2d(this->frame_aspect);
                this->picture_height = this->picture_height + this->picture_height%2;
            } else {
                this->picture_height = this->max_y;
                this->picture_width = this->max_y * av_q2d(this->frame_aspect);
                this->picture_width = this->picture_width + this->picture_width%2;
            }
        }

        if (this->no_upscaling) {
            if (this->picture_height && this->picture_height > display_height) {
                this->picture_width = display_height * display_aspect_ratio.num / display_aspect_ratio.den;
                this->picture_height = display_height;
            }
            else if (this->picture_width && this->picture_width > display_width) {
                this->picture_width = display_width;
                this->picture_height = display_width * display_aspect_ratio.den / display_aspect_ratio.num;
            }
            if (this->fps < av_q2d(this->framerate_new))
                this->framerate_new = vstream_fps;
        }

        if (sample_aspect_ratio.num!=0 && this->frame_aspect.num==0) {

            // just use the ratio from the input
            this->aspect_numerator=sample_aspect_ratio.num;
            this->aspect_denominator=sample_aspect_ratio.den;
            // or we use ratio for the output
            if (this->picture_height) {
                int width=display_width-this->frame_leftBand-this->frame_rightBand;
                int height=display_height-this->frame_topBand-this->frame_bottomBand;
                av_reduce(&this->aspect_numerator,&this->aspect_denominator,
                vstream->sample_aspect_ratio.num*width*this->picture_height,
                vstream->sample_aspect_ratio.den*height*this->picture_width,10000);
                frame_aspect=(float)(this->aspect_numerator*this->picture_width)/
                                (this->aspect_denominator*this->picture_height);
            }
            else{
                frame_aspect=(float)(this->aspect_numerator*display_width)/
                                (this->aspect_denominator*display_height);
            }
        }

        //pixel aspect ratio set, use that
        if (this->pixel_aspect.num>0) {
            this->aspect_numerator = this->pixel_aspect.num;
            this->aspect_denominator = this->pixel_aspect.den;
            if (this->picture_height) {
                frame_aspect=(float)(this->aspect_numerator*this->picture_width)/
                                (this->aspect_denominator*this->picture_height);
            }
            else{
                frame_aspect=(float)(this->aspect_numerator*display_width)/
                                (this->aspect_denominator*display_height);
            }
        }
        if (!(info.twopass==3 && info.passno==2) && !info.frontend && this->aspect_denominator && frame_aspect) {
            fprintf(stderr, "  Pixel Aspect Ratio: %.2f/1 ",(float)this->aspect_numerator/this->aspect_denominator);
            fprintf(stderr, "  Frame Aspect Ratio: %.2f/1\n", frame_aspect);
        }

        if (!(info.twopass==3 && info.passno==2) && !info.frontend && this->deinterlace==1)
            fprintf(stderr, "  Deinterlace: on\n");

        if (strcmp(this->pp_mode, "")) {
            ppContext = pp_get_context(display_width, display_height, PP_FORMAT_420);
            ppMode = pp_get_mode_by_name_and_quality(this->pp_mode, PP_QUALITY_MAX);
            if(!(info.twopass==3 && info.passno==2) && !info.frontend)
                fprintf(stderr, "  Postprocessing: %s\n", this->pp_mode);
        }

        if (venc->color_primaries == AVCOL_PRI_BT470M)
            this->colorspace = TH_CS_ITU_REC_470M;
        else if (venc->color_primaries == AVCOL_PRI_BT470BG)
            this->colorspace = TH_CS_ITU_REC_470BG;

        if (!this->picture_width)
            this->picture_width = display_width;
        if (!this->picture_height)
            this->picture_height = display_height;

        /* Theora has a divisible-by-sixteen restriction for the encoded video size */
        /* scale the frame size up to the nearest /16 and calculate offsets */
        this->frame_width = ((this->picture_width + 15) >>4)<<4;
        this->frame_height = ((this->picture_height + 15) >>4)<<4;

        /*Force the offsets to be even so that chroma samples line up like we
           expect.*/
        this->frame_x_offset = this->frame_width-this->picture_width>>1&~1;
        this->frame_y_offset = this->frame_height-this->picture_height>>1&~1;

        //Bicubic  (best for upscaling),
        if(display_width - (this->frame_leftBand + this->frame_rightBand) < this->picture_width |
           display_height - (this->frame_topBand + this->frame_bottomBand) < this->picture_height) {
           sws_flags = SWS_BICUBIC;
        } else {        //Bilinear (best for downscaling),
           sws_flags = SWS_BILINEAR;
        }

        if (this->frame_width > 0 || this->frame_height > 0) {
            this->sws_colorspace_ctx = sws_getContext(
                            display_width, display_height, venc_pix_fmt,
                            display_width, display_height, this->pix_fmt,
                            sws_flags, NULL, NULL, NULL
            );
            this->sws_scale_ctx = sws_getContext(
                        display_width - (this->frame_leftBand + this->frame_rightBand),
                        display_height - (this->frame_topBand + this->frame_bottomBand),
                        this->pix_fmt,
                        this->picture_width, this->picture_height, this->pix_fmt,
                        sws_flags, NULL, NULL, NULL
            );
            if (!info.frontend && !(info.twopass==3 && info.passno==2)) {
                if (this->frame_topBand || this->frame_bottomBand ||
                    this->frame_leftBand || this->frame_rightBand ||
                    this->picture_width != (display_width-this->frame_leftBand - this->frame_rightBand) ||
                    this->picture_height != (display_height-this->frame_topBand-this->frame_bottomBand))
                    fprintf(stderr, "  Resize: %dx%d", display_width, display_height);
                if (this->frame_topBand || this->frame_bottomBand ||
                    this->frame_leftBand || this->frame_rightBand) {
                    fprintf(stderr, " => %dx%d",
                        display_width-this->frame_leftBand-this->frame_rightBand,
                        display_height-this->frame_topBand-this->frame_bottomBand);
                }
                if (this->picture_width != (display_width-this->frame_leftBand - this->frame_rightBand)
                    || this->picture_height != (display_height-this->frame_topBand-this->frame_bottomBand))
                    fprintf(stderr, " => %dx%d",this->picture_width, this->picture_height);
                fprintf(stderr, "\n");
            }
        }

        lut_init(this);
    }
    if (!(info.twopass==3 && info.passno==2) && !info.frontend && this->framerate_new.num > 0 && av_cmp_q(vstream_fps, this->framerate_new)) {
        fprintf(stderr, "  Resample Framerate: %0.3f => %0.3f\n",
                        this->fps, av_q2d(this->framerate_new));
    }
    if (this->audio_index >= 0) {
        astream = this->context->streams[this->audio_index];
        aenc = this->context->streams[this->audio_index]->codec;
        acodec = avcodec_find_decoder (aenc->codec_id);
        if (this->channels < 1) {
            this->channels = aenc->channels;
        }
        if (this->sample_rate==-1) {
            this->sample_rate = aenc->sample_rate;
        }

        if (this->no_upscaling) {
            if (this->sample_rate > aenc->sample_rate)
                this->sample_rate = aenc->sample_rate;
            if (this->channels > aenc->channels)
                this->channels = aenc->channels;
        }

        if (acodec != NULL && avcodec_open (aenc, acodec) >= 0) {
            if (this->sample_rate != aenc->sample_rate
                || this->channels != aenc->channels
                || aenc->sample_fmt != SAMPLE_FMT_S16) {
                // values take from libavcodec/resample.c
                this->audio_resample_ctx = av_audio_resample_init(this->channels,    aenc->channels,
                                                                  this->sample_rate, aenc->sample_rate,
                                                                  SAMPLE_FMT_S16,    aenc->sample_fmt,
                                                                  16, 10, 0, 0.8);
                if (!this->audio_resample_ctx) {
                    this->channels = aenc->channels;
                }
                if (!info.frontend && this->sample_rate!=aenc->sample_rate)
                    fprintf(stderr, "  Resample: %dHz => %dHz\n",aenc->sample_rate,this->sample_rate);
                if (!info.frontend && this->channels!=aenc->channels)
                    fprintf(stderr, "  Channels: %d => %d\n",aenc->channels,this->channels);
            }
            else{
                this->audio_resample_ctx=NULL;
            }
        }
        else{
            this->audio_index = -1;
        }
    }

    if (info.passno != 1) {
      for (i = 0; i < this->context->nb_streams; i++) {
        subtitles_enabled[i] = 0;
        subtitles_opened[i] = 0;
#ifdef HAVE_KATE
        if (!this->disable_subtitles) {
          AVStream *stream = this->context->streams[i];
          AVCodecContext *enc = stream->codec;
          if (enc->codec_type == CODEC_TYPE_SUBTITLE) {
            AVCodec *codec = avcodec_find_decoder (enc->codec_id);
            if (codec && avcodec_open (enc, codec) >= 0) {
              subtitles_opened[i] = 1;
            }
            if (is_supported_subtitle_stream(this, i)) {
              subtitles_enabled[i] = 1;
              add_subtitles_stream(this, i, find_language_for_subtitle_stream(stream), NULL);
            }
            else if(!info.frontend) {
              fprintf(stderr,"Subtitle stream %d codec not supported, ignored\n", i);
            }
          }
        }
#endif
      }
    }

#ifdef HAVE_KATE
    if (info.passno != 1) {
      for (i=0; i<this->n_kate_streams; ++i) {
        ff2theora_kate_stream *ks=this->kate_streams+i;
        if (ks->stream_index >= 0) {
#ifdef DEBUG
            printf("Muxing Kate stream %d from input stream %d\n",
                i,ks->stream_index);
#endif
            if (!this->disable_subtitles) {
              info.with_kate=1;
            }
        }
        else if (load_subtitles(ks,this->ignore_non_utf8,info.frontend)>0) {
#ifdef DEBUG
            printf("Muxing Kate stream %d from %s as %s %s\n",
                i,ks->filename,
                ks->subtitles_language[0]?ks->subtitles_language:"<unknown language>",
                ks->subtitles_category[0]?ks->subtitles_category:"SUB");
#endif
        }
        else {
            if (i!=this->n_kate_streams) {
            memmove(this->kate_streams+i,this->kate_streams+i+1,(this->n_kate_streams-i-1)*sizeof(ff2theora_kate_stream));
            --this->n_kate_streams;
            --i;
          }
        }
      }
    }
#endif

    if (info.passno != 1) {
      oggmux_setup_kate_streams(&info, this->n_kate_streams);
    }

    if (this->video_index >= 0 || this->audio_index >= 0) {
        AVFrame *frame=NULL;
        AVFrame *frame_p=NULL;
        AVFrame *output=NULL;
        AVFrame *output_p=NULL;
        AVFrame *output_tmp_p=NULL;
        AVFrame *output_tmp=NULL;
        AVFrame *output_resized_p=NULL;
        AVFrame *output_resized=NULL;
        AVFrame *output_buffered_p=NULL;
        AVFrame *output_buffered=NULL;
        AVFrame *output_cropped_p=NULL;
        AVFrame *output_cropped=NULL;
        AVFrame *output_padded_p=NULL;
        AVFrame *output_padded=NULL;

        AVPacket pkt;
        AVPacket avpkt;
        int len1;
        int got_picture;
        int first = 1;
        int audio_eos = 0, video_eos = 0, audio_done = 0, video_done = 0;
        int ret;
        int16_t *audio_buf=av_malloc(4*AVCODEC_MAX_AUDIO_FRAME_SIZE);
        int16_t *resampled=av_malloc(4*AVCODEC_MAX_AUDIO_FRAME_SIZE);
        int16_t *audio_p=NULL;
        int no_frames;