cap_ogg.c

   1 #ifndef _MSC_VER
   2 #include <stdint.h>
   3 #endif
   4 #include <sys/types.h>
   5
   6 #include "quakedef.h"
   7 #include "client.h"
   8 #include "cap_ogg.h"
   9
  10 // video capture cvars
  11 static cvar_t cl_capturevideo_ogg_theora_quality = {CVAR_SAVE, "cl_capturevideo_ogg_theora_quality", "32", "video quality factor (0 to 63), or -1 to use bitrate only; higher is better"};
  12 static cvar_t cl_capturevideo_ogg_theora_bitrate = {CVAR_SAVE, "cl_capturevideo_ogg_theora_bitrate", "-1", "video bitrate (45 to 2000 kbps), or -1 to use quality only; higher is better"};
  13 static cvar_t cl_capturevideo_ogg_theora_keyframe_bitrate_multiplier = {CVAR_SAVE, "cl_capturevideo_ogg_theora_keyframe_bitrate_multiplier", "1.5", "how much more bit rate to use for keyframes, specified as a factor of at least 1"};
  14 static cvar_t cl_capturevideo_ogg_theora_keyframe_frequency = {CVAR_SAVE, "cl_capturevideo_ogg_theora_keyframe_frequency", "64", "maximum number of frames between two key frames (1 to 1000)"};
  15 static cvar_t cl_capturevideo_ogg_theora_keyframe_mindistance = {CVAR_SAVE, "cl_capturevideo_ogg_theora_keyframe_mindistance", "8", "minimum number of frames between two key frames (1 to 1000)"};
  16 static cvar_t cl_capturevideo_ogg_theora_keyframe_auto_threshold = {CVAR_SAVE, "cl_capturevideo_ogg_theora_keyframe_auto_threshold", "80", "threshold for key frame decision (0 to 100)"};
  17 static cvar_t cl_capturevideo_ogg_theora_noise_sensitivity = {CVAR_SAVE, "cl_capturevideo_ogg_theora_noise_sensitivity", "1", "video noise sensitivity (0 to 6); lower is better"};
  18 static cvar_t cl_capturevideo_ogg_theora_sharpness = {CVAR_SAVE, "cl_capturevideo_ogg_theora_sharpness", "0", "sharpness (0 to 2); lower is sharper"};
  19 static cvar_t cl_capturevideo_ogg_vorbis_quality = {CVAR_SAVE, "cl_capturevideo_ogg_vorbis_quality", "1", "audio quality (-1 to 10); higher is better"};
  20
  21 // ogg.h stuff
  22 #ifdef _MSC_VER
  23 typedef __int16 ogg_int16_t;
  24 typedef unsigned __int16 ogg_uint16_t;
  25 typedef __int32 ogg_int32_t;
  26 typedef unsigned __int32 ogg_uint32_t;
  27 typedef __int64 ogg_int64_t;
  28 #else
  29 typedef int16_t ogg_int16_t;
  30 typedef uint16_t ogg_uint16_t;
  31 typedef int32_t ogg_int32_t;
  32 typedef uint32_t ogg_uint32_t;
  33 typedef int64_t ogg_int64_t;
  34 #endif
  35
  36 typedef struct {
  37   long endbyte;
  38   int  endbit;
  39
  40   unsigned char *buffer;
  41   unsigned char *ptr;
  42   long storage;
  43 } oggpack_buffer;
  44
  45 /* ogg_page is used to encapsulate the data in one Ogg bitstream page *****/
  46
  47 typedef struct {
  48   unsigned char *header;
  49   long header_len;
  50   unsigned char *body;
  51   long body_len;
  52 } ogg_page;
  53
  54 /* ogg_stream_state contains the current encode/decode state of a logical
  55    Ogg bitstream **********************************************************/
  56
  57 typedef struct {
  58   unsigned char   *body_data;    /* bytes from packet bodies */
  59   long    body_storage;          /* storage elements allocated */
  60   long    body_fill;             /* elements stored; fill mark */
  61   long    body_returned;         /* elements of fill returned */
  62
  63
  64   int     *lacing_vals;      /* The values that will go to the segment table */
  65   ogg_int64_t *granule_vals; /* granulepos values for headers. Not compact
  66                                 this way, but it is simple coupled to the
  67                                 lacing fifo */
  68   long    lacing_storage;
  69   long    lacing_fill;
  70   long    lacing_packet;
  71   long    lacing_returned;
  72
  73   unsigned char    header[282];      /* working space for header encode */
  74   int              header_fill;
  75
  76   int     e_o_s;          /* set when we have buffered the last packet in the
  77                              logical bitstream */
  78   int     b_o_s;          /* set after we've written the initial page
  79                              of a logical bitstream */
  80   long    serialno;
  81   long    pageno;
  82   ogg_int64_t  packetno;      /* sequence number for decode; the framing
  83                              knows where there's a hole in the data,
  84                              but we need coupling so that the codec
  85                              (which is in a seperate abstraction
  86                              layer) also knows about the gap */
  87   ogg_int64_t   granulepos;
  88
  89 } ogg_stream_state;
  90
  91 /* ogg_packet is used to encapsulate the data and metadata belonging
  92    to a single raw Ogg/Vorbis packet *************************************/
  93
  94 typedef struct {
  95   unsigned char *packet;
  96   long  bytes;
  97   long  b_o_s;
  98   long  e_o_s;
  99
 100   ogg_int64_t  granulepos;
 101
 102   ogg_int64_t  packetno;     /* sequence number for decode; the framing
 103                                 knows where there's a hole in the data,
 104                                 but we need coupling so that the codec
 105                                 (which is in a seperate abstraction
 106                                 layer) also knows about the gap */
 107 } ogg_packet;
 108
 109 typedef struct {
 110   unsigned char *data;
 111   int storage;
 112   int fill;
 113   int returned;
 114
 115   int unsynced;
 116   int headerbytes;
 117   int bodybytes;
 118 } ogg_sync_state;
 119
 120 /* Ogg BITSTREAM PRIMITIVES: encoding **************************/
 121
 122 static int      (*qogg_stream_packetin) (ogg_stream_state *os, ogg_packet *op);
 123 static int      (*qogg_stream_pageout) (ogg_stream_state *os, ogg_page *og);
 124 static int      (*qogg_stream_flush) (ogg_stream_state *os, ogg_page *og);
 125
 126 /* Ogg BITSTREAM PRIMITIVES: general ***************************/
 127
 128 static int      (*qogg_stream_init) (ogg_stream_state *os,int serialno);
 129 static int      (*qogg_stream_clear) (ogg_stream_state *os);
 130 static ogg_int64_t  (*qogg_page_granulepos) (ogg_page *og);
 131
 132 // end of ogg.h stuff
 133
 134 // vorbis/codec.h stuff
 135 typedef struct vorbis_info{
 136   int version;
 137   int channels;
 138   long rate;
 139
 140   /* The below bitrate declarations are *hints*.
 141      Combinations of the three values carry the following implications:
 142
 143      all three set to the same value:
 144        implies a fixed rate bitstream
 145      only nominal set:
 146        implies a VBR stream that averages the nominal bitrate.  No hard
 147        upper/lower limit
 148      upper and or lower set:
 149        implies a VBR bitstream that obeys the bitrate limits. nominal
 150        may also be set to give a nominal rate.
 151      none set:
 152        the coder does not care to speculate.
 153   */
 154
 155   long bitrate_upper;
 156   long bitrate_nominal;
 157   long bitrate_lower;
 158   long bitrate_window;
 159
 160   void *codec_setup;
 161 } vorbis_info;
 162
 163 /* vorbis_dsp_state buffers the current vorbis audio
 164    analysis/synthesis state.  The DSP state belongs to a specific
 165    logical bitstream ****************************************************/
 166 typedef struct vorbis_dsp_state{
 167   int analysisp;
 168   vorbis_info *vi;
 169
 170   float **pcm;
 171   float **pcmret;
 172   int      pcm_storage;
 173   int      pcm_current;
 174   int      pcm_returned;
 175
 176   int  preextrapolate;
 177   int  eofflag;
 178
 179   long lW;
 180   long W;
 181   long nW;
 182   long centerW;
 183
 184   ogg_int64_t granulepos;
 185   ogg_int64_t sequence;
 186
 187   ogg_int64_t glue_bits;
 188   ogg_int64_t time_bits;
 189   ogg_int64_t floor_bits;
 190   ogg_int64_t res_bits;
 191
 192   void       *backend_state;
 193 } vorbis_dsp_state;
 194
 195 typedef struct vorbis_block{
 196   /* necessary stream state for linking to the framing abstraction */
 197   float  **pcm;       /* this is a pointer into local storage */
 198   oggpack_buffer opb;
 199
 200   long  lW;
 201   long  W;
 202   long  nW;
 203   int   pcmend;
 204   int   mode;
 205
 206   int         eofflag;
 207   ogg_int64_t granulepos;
 208   ogg_int64_t sequence;
 209   vorbis_dsp_state *vd; /* For read-only access of configuration */
 210
 211   /* local storage to avoid remallocing; it's up to the mapping to
 212      structure it */
 213   void               *localstore;
 214   long                localtop;
 215   long                localalloc;
 216   long                totaluse;
 217   struct alloc_chain *reap;
 218
 219   /* bitmetrics for the frame */
 220   long glue_bits;
 221   long time_bits;
 222   long floor_bits;
 223   long res_bits;
 224
 225   void *internal;
 226
 227 } vorbis_block;
 228
 229 /* vorbis_block is a single block of data to be processed as part of
 230 the analysis/synthesis stream; it belongs to a specific logical
 231 bitstream, but is independant from other vorbis_blocks belonging to
 232 that logical bitstream. *************************************************/
 233
 234 struct alloc_chain{
 235   void *ptr;
 236   struct alloc_chain *next;
 237 };
 238
 239 /* vorbis_info contains all the setup information specific to the
 240    specific compression/decompression mode in progress (eg,
 241    psychoacoustic settings, channel setup, options, codebook
 242    etc). vorbis_info and substructures are in backends.h.
 243 *********************************************************************/
 244
 245 /* the comments are not part of vorbis_info so that vorbis_info can be
 246    static storage */
 247 typedef struct vorbis_comment{
 248   /* unlimited user comment fields.  libvorbis writes 'libvorbis'
 249      whatever vendor is set to in encode */
 250   char **user_comments;
 251   int   *comment_lengths;
 252   int    comments;
 253   char  *vendor;
 254
 255 } vorbis_comment;
 256
 257
 258 /* libvorbis encodes in two abstraction layers; first we perform DSP
 259    and produce a packet (see docs/analysis.txt).  The packet is then
 260    coded into a framed OggSquish bitstream by the second layer (see
 261    docs/framing.txt).  Decode is the reverse process; we sync/frame
 262    the bitstream and extract individual packets, then decode the
 263    packet back into PCM audio.
 264
 265    The extra framing/packetizing is used in streaming formats, such as
 266    files.  Over the net (such as with UDP), the framing and
 267    packetization aren't necessary as they're provided by the transport
 268    and the streaming layer is not used */
 269
 270 /* Vorbis PRIMITIVES: general ***************************************/
 271
 272 static void     (*qvorbis_info_init) (vorbis_info *vi);
 273 static void     (*qvorbis_info_clear) (vorbis_info *vi);
 274 static void     (*qvorbis_comment_init) (vorbis_comment *vc);
 275 static void     (*qvorbis_comment_clear) (vorbis_comment *vc);
 276
 277 static int      (*qvorbis_block_init) (vorbis_dsp_state *v, vorbis_block *vb);
 278 static int      (*qvorbis_block_clear) (vorbis_block *vb);
 279 static void     (*qvorbis_dsp_clear) (vorbis_dsp_state *v);
 280 static double   (*qvorbis_granule_time) (vorbis_dsp_state *v,
 281                                     ogg_int64_t granulepos);
 282
 283 /* Vorbis PRIMITIVES: analysis/DSP layer ****************************/
 284
 285 static int      (*qvorbis_analysis_init) (vorbis_dsp_state *v,vorbis_info *vi);
 286 static int      (*qvorbis_commentheader_out) (vorbis_comment *vc, ogg_packet *op);
 287 static int      (*qvorbis_analysis_headerout) (vorbis_dsp_state *v,
 288                                           vorbis_comment *vc,
 289                                           ogg_packet *op,
 290                                           ogg_packet *op_comm,
 291                                           ogg_packet *op_code);
 292 static float ** (*qvorbis_analysis_buffer) (vorbis_dsp_state *v,int vals);
 293 static int      (*qvorbis_analysis_wrote) (vorbis_dsp_state *v,int vals);
 294 static int      (*qvorbis_analysis_blockout) (vorbis_dsp_state *v,vorbis_block *vb);
 295 static int      (*qvorbis_analysis) (vorbis_block *vb,ogg_packet *op);
 296
 297 static int      (*qvorbis_bitrate_addblock) (vorbis_block *vb);
 298 static int      (*qvorbis_bitrate_flushpacket) (vorbis_dsp_state *vd,
 299                                            ogg_packet *op);
 300
 301 // end of vorbis/codec.h stuff
 302
 303 // vorbisenc.h stuff
 304 static int (*qvorbis_encode_init_vbr) (vorbis_info *vi,
 305                                   long channels,
 306                                   long rate,
 307
 308                                   float base_quality /* quality level from 0. (lo) to 1. (hi) */
 309                                   );
 310 // end of vorbisenc.h stuff
 311
 312 // theora.h stuff
 313 typedef struct {
 314     int   y_width;      /**< Width of the Y' luminance plane */
 315     int   y_height;     /**< Height of the luminance plane */
 316     int   y_stride;     /**< Offset in bytes between successive rows */
 317
 318     int   uv_width;     /**< Width of the Cb and Cr chroma planes */
 319     int   uv_height;    /**< Height of the chroma planes */
 320     int   uv_stride;    /**< Offset between successive chroma rows */
 321     unsigned char *y;   /**< Pointer to start of luminance data */
 322     unsigned char *u;   /**< Pointer to start of Cb data */
 323     unsigned char *v;   /**< Pointer to start of Cr data */
 324
 325 } yuv_buffer;
 326
 327 /**
 328  * A Colorspace.
 329  */
 330 typedef enum {
 331   OC_CS_UNSPECIFIED,    /**< The colorspace is unknown or unspecified */
 332   OC_CS_ITU_REC_470M,   /**< This is the best option for 'NTSC' content */
 333   OC_CS_ITU_REC_470BG,  /**< This is the best option for 'PAL' content */
 334   OC_CS_NSPACES         /**< This marks the end of the defined colorspaces */
 335 } theora_colorspace;
 336
 337 /**
 338  * A Chroma subsampling
 339  *
 340  * These enumerate the available chroma subsampling options supported
 341  * by the theora format. See Section 4.4 of the specification for
 342  * exact definitions.
 343  */
 344 typedef enum {
 345   OC_PF_420,    /**< Chroma subsampling by 2 in each direction (4:2:0) */
 346   OC_PF_RSVD,   /**< Reserved value */
 347   OC_PF_422,    /**< Horizonatal chroma subsampling by 2 (4:2:2) */
 348   OC_PF_444,    /**< No chroma subsampling at all (4:4:4) */
 349 } theora_pixelformat;
 350 /**
 351  * Theora bitstream info.
 352  * Contains the basic playback parameters for a stream,
 353  * corresponding to the initial 'info' header packet.
 354  *
 355  * Encoded theora frames must be a multiple of 16 in width and height.
 356  * To handle other frame sizes, a crop rectangle is specified in
 357  * frame_height and frame_width, offset_x and * offset_y. The offset
 358  * and size should still be a multiple of 2 to avoid chroma sampling
 359  * shifts. Offset values in this structure are measured from the
 360  * upper left of the image.
 361  *
 362  * Frame rate, in frames per second, is stored as a rational
 363  * fraction. Aspect ratio is also stored as a rational fraction, and
 364  * refers to the aspect ratio of the frame pixels, not of the
 365  * overall frame itself.
 366  *
 367  * See <a href="http://svn.xiph.org/trunk/theora/examples/encoder_example.c">
 368  * examples/encoder_example.c</a> for usage examples of the
 369  * other paramters and good default settings for the encoder parameters.
 370  */
 371 typedef struct {
 372   ogg_uint32_t  width;      /**< encoded frame width  */
 373   ogg_uint32_t  height;     /**< encoded frame height */
 374   ogg_uint32_t  frame_width;    /**< display frame width  */
 375   ogg_uint32_t  frame_height;   /**< display frame height */
 376   ogg_uint32_t  offset_x;   /**< horizontal offset of the displayed frame */
 377   ogg_uint32_t  offset_y;   /**< vertical offset of the displayed frame */
 378   ogg_uint32_t  fps_numerator;      /**< frame rate numerator **/
 379   ogg_uint32_t  fps_denominator;    /**< frame rate denominator **/
 380   ogg_uint32_t  aspect_numerator;   /**< pixel aspect ratio numerator */
 381   ogg_uint32_t  aspect_denominator; /**< pixel aspect ratio denominator */
 382   theora_colorspace colorspace;     /**< colorspace */
 383   int           target_bitrate;     /**< nominal bitrate in bits per second */
 384   int           quality;  /**< Nominal quality setting, 0-63 */
 385   int           quick_p;  /**< Quick encode/decode */
 386
 387   /* decode only */
 388   unsigned char version_major;
 389   unsigned char version_minor;
 390   unsigned char version_subminor;
 391
 392   void *codec_setup;
 393
 394   /* encode only */
 395   int           dropframes_p;
 396   int           keyframe_auto_p;
 397   ogg_uint32_t  keyframe_frequency;
 398   ogg_uint32_t  keyframe_frequency_force;  /* also used for decode init to
 399                                               get granpos shift correct */
 400   ogg_uint32_t  keyframe_data_target_bitrate;
 401   ogg_int32_t   keyframe_auto_threshold;
 402   ogg_uint32_t  keyframe_mindistance;
 403   ogg_int32_t   noise_sensitivity;
 404   ogg_int32_t   sharpness;
 405
 406   theora_pixelformat pixelformat;   /**< chroma subsampling mode to expect */
 407
 408 } theora_info;
 409
 410 /** Codec internal state and context.
 411  */
 412 typedef struct{
 413   theora_info *i;
 414   ogg_int64_t granulepos;
 415
 416   void *internal_encode;
 417   void *internal_decode;
 418
 419 } theora_state;
 420
 421 /**
 422  * Comment header metadata.
 423  *
 424  * This structure holds the in-stream metadata corresponding to
 425  * the 'comment' header packet.
 426  *
 427  * Meta data is stored as a series of (tag, value) pairs, in
 428  * length-encoded string vectors. The first occurence of the
 429  * '=' character delimits the tag and value. A particular tag
 430  * may occur more than once. The character set encoding for
 431  * the strings is always UTF-8, but the tag names are limited
 432  * to case-insensitive ASCII. See the spec for details.
 433  *
 434  * In filling in this structure, qtheora_decode_header() will
 435  * null-terminate the user_comment strings for safety. However,
 436  * the bitstream format itself treats them as 8-bit clean,
 437  * and so the length array should be treated as authoritative
 438  * for their length.
 439  */
 440 typedef struct theora_comment{
 441   char **user_comments;         /**< An array of comment string vectors */
 442   int   *comment_lengths;       /**< An array of corresponding string vector lengths in bytes */
 443   int    comments;              /**< The total number of comment string vectors */
 444   char  *vendor;                /**< The vendor string identifying the encoder, null terminated */
 445
 446 } theora_comment;
 447 static int (*qtheora_encode_init) (theora_state *th, theora_info *ti);
 448 static int (*qtheora_encode_YUVin) (theora_state *t, yuv_buffer *yuv);
 449 static int (*qtheora_encode_packetout) ( theora_state *t, int last_p,
 450                                     ogg_packet *op);
 451 static int (*qtheora_encode_header) (theora_state *t, ogg_packet *op);
 452 static int (*qtheora_encode_comment) (theora_comment *tc, ogg_packet *op);
 453 static int (*qtheora_encode_tables) (theora_state *t, ogg_packet *op);
 454 static void (*qtheora_info_init) (theora_info *c);
 455 static void (*qtheora_info_clear) (theora_info *c);
 456 static void (*qtheora_clear) (theora_state *t);
 457 static void (*qtheora_comment_init) (theora_comment *tc);
 458 static void  (*qtheora_comment_clear) (theora_comment *tc);
 459 static double (*qtheora_granule_time) (theora_state *th,ogg_int64_t granulepos);
 460 // end of theora.h stuff
 461
 462 static dllfunction_t oggfuncs[] =
 463 {
 464         {"ogg_stream_packetin", (void **) &qogg_stream_packetin},
 465         {"ogg_stream_pageout", (void **) &qogg_stream_pageout},
 466         {"ogg_stream_flush", (void **) &qogg_stream_flush},
 467         {"ogg_stream_init", (void **) &qogg_stream_init},
 468         {"ogg_stream_clear", (void **) &qogg_stream_clear},
 469         {"ogg_page_granulepos", (void **) &qogg_page_granulepos},
 470         {NULL, NULL}
 471 };
 472
 473 static dllfunction_t vorbisencfuncs[] =
 474 {
 475         {"vorbis_encode_init_vbr", (void **) &qvorbis_encode_init_vbr},
 476         {NULL, NULL}
 477 };
 478
 479 static dllfunction_t vorbisfuncs[] =
 480 {
 481         {"vorbis_info_init", (void **) &qvorbis_info_init},
 482         {"vorbis_info_clear", (void **) &qvorbis_info_clear},
 483         {"vorbis_comment_init", (void **) &qvorbis_comment_init},
 484         {"vorbis_comment_clear", (void **) &qvorbis_comment_clear},
 485         {"vorbis_block_init", (void **) &qvorbis_block_init},
 486         {"vorbis_block_clear", (void **) &qvorbis_block_clear},
 487         {"vorbis_dsp_clear", (void **) &qvorbis_dsp_clear},
 488         {"vorbis_analysis_init", (void **) &qvorbis_analysis_init},
 489         {"vorbis_commentheader_out", (void **) &qvorbis_commentheader_out},
 490         {"vorbis_analysis_headerout", (void **) &qvorbis_analysis_headerout},
 491         {"vorbis_analysis_buffer", (void **) &qvorbis_analysis_buffer},
 492         {"vorbis_analysis_wrote", (void **) &qvorbis_analysis_wrote},
 493         {"vorbis_analysis_blockout", (void **) &qvorbis_analysis_blockout},
 494         {"vorbis_analysis", (void **) &qvorbis_analysis},
 495         {"vorbis_bitrate_addblock", (void **) &qvorbis_bitrate_addblock},
 496         {"vorbis_bitrate_flushpacket", (void **) &qvorbis_bitrate_flushpacket},
 497         {"vorbis_granule_time", (void **) &qvorbis_granule_time},
 498         {NULL, NULL}
 499 };
 500
 501 static dllfunction_t theorafuncs[] =
 502 {
 503         {"theora_info_init", (void **) &qtheora_info_init},
 504         {"theora_info_clear", (void **) &qtheora_info_clear},
 505         {"theora_comment_init", (void **) &qtheora_comment_init},
 506         {"theora_comment_clear", (void **) &qtheora_comment_clear},
 507         {"theora_encode_init", (void **) &qtheora_encode_init},
 508         {"theora_encode_YUVin", (void **) &qtheora_encode_YUVin},
 509         {"theora_encode_packetout", (void **) &qtheora_encode_packetout},
 510         {"theora_encode_header", (void **) &qtheora_encode_header},
 511         {"theora_encode_comment", (void **) &qtheora_encode_comment},
 512         {"theora_encode_tables", (void **) &qtheora_encode_tables},
 513         {"theora_clear", (void **) &qtheora_clear},
 514         {"theora_granule_time", (void **) &qtheora_granule_time},
 515         {NULL, NULL}
 516 };
 517
 518 static dllhandle_t og_dll = NULL, vo_dll = NULL, ve_dll = NULL, th_dll = NULL;
 519
 520 qboolean SCR_CaptureVideo_Ogg_OpenLibrary()
 521 {
 522         const char* dllnames_og [] =
 523         {
 524 #if defined(WIN64)
 525                 "libogg64.dll",
 526 #elif defined(WIN32)
 527                 "libogg.dll",
 528                 "ogg.dll",
 529 #elif defined(MACOSX)
 530                 "libogg.dylib",
 531 #else
 532                 "libogg.so.0",
 533                 "libogg.so",
 534 #endif
 535                 NULL
 536         };
 537         const char* dllnames_vo [] =
 538         {
 539 #if defined(WIN64)
 540                 "libvorbis64.dll",
 541 #elif defined(WIN32)
 542                 "libvorbis.dll",
 543                 "vorbis.dll",
 544 #elif defined(MACOSX)
 545                 "libvorbis.dylib",
 546 #else
 547                 "libvorbis.so.0",
 548                 "libvorbis.so",
 549 #endif
 550                 NULL
 551         };
 552         const char* dllnames_ve [] =
 553         {
 554 #if defined(WIN64)
 555                 "libvorbisenc64.dll",
 556 #elif defined(WIN32)
 557                 "libvorbisenc.dll",
 558                 "vorbisenc.dll",
 559 #elif defined(MACOSX)
 560                 "libvorbisenc.dylib",
 561 #else
 562                 "libvorbisenc.so.2",
 563                 "libvorbisenc.so",
 564 #endif
 565                 NULL
 566         };
 567         const char* dllnames_th [] =
 568         {
 569 #if defined(WIN64)
 570                 "libtheora64.dll",
 571 #elif defined(WIN32)
 572                 "libtheora.dll",
 573                 "theora.dll",
 574 #elif defined(MACOSX)
 575                 "libtheora.dylib",
 576 #else
 577                 "libtheora.so.0",
 578                 "libtheora.so",
 579 #endif
 580                 NULL
 581         };
 582
 583         return
 584                 Sys_LoadLibrary (dllnames_og, &og_dll, oggfuncs)
 585                 &&
 586                 Sys_LoadLibrary (dllnames_th, &th_dll, theorafuncs)
 587                 &&
 588                 Sys_LoadLibrary (dllnames_vo, &vo_dll, vorbisfuncs)
 589                 &&
 590                 Sys_LoadLibrary (dllnames_ve, &ve_dll, vorbisencfuncs);
 591 }
 592
 593 void SCR_CaptureVideo_Ogg_Init()
 594 {
 595         SCR_CaptureVideo_Ogg_OpenLibrary();
 596
 597         Cvar_RegisterVariable(&cl_capturevideo_ogg_theora_quality);
 598         Cvar_RegisterVariable(&cl_capturevideo_ogg_theora_bitrate);
 599         Cvar_RegisterVariable(&cl_capturevideo_ogg_theora_keyframe_bitrate_multiplier);
 600         Cvar_RegisterVariable(&cl_capturevideo_ogg_theora_keyframe_frequency);
 601         Cvar_RegisterVariable(&cl_capturevideo_ogg_theora_keyframe_mindistance);
 602         Cvar_RegisterVariable(&cl_capturevideo_ogg_theora_keyframe_auto_threshold);
 603         Cvar_RegisterVariable(&cl_capturevideo_ogg_theora_noise_sensitivity);
 604         Cvar_RegisterVariable(&cl_capturevideo_ogg_vorbis_quality);
 605 }
 606
 607 qboolean SCR_CaptureVideo_Ogg_Available()
 608 {
 609         return og_dll && th_dll && vo_dll && ve_dll;
 610 }
 611
 612 void SCR_CaptureVideo_Ogg_CloseDLL()
 613 {
 614         Sys_UnloadLibrary (&ve_dll);
 615         Sys_UnloadLibrary (&vo_dll);
 616         Sys_UnloadLibrary (&th_dll);
 617         Sys_UnloadLibrary (&og_dll);
 618 }
 619
 620 typedef struct capturevideostate_ogg_formatspecific_s
 621 {
 622         ogg_stream_state to, vo;
 623         int serial1, serial2;
 624         theora_state ts;
 625         vorbis_dsp_state vd;
 626         vorbis_block vb;
 627         vorbis_info vi;
 628         yuv_buffer yuv[2];
 629         int yuvi;
 630         int lastnum;
 631         int channels;
 632
 633         // for interleaving
 634         ogg_page videopage;
 635         ogg_page audiopage;
 636         qboolean have_videopage;
 637         qboolean have_audiopage;
 638 }
 639 capturevideostate_ogg_formatspecific_t;
 640 #define LOAD_FORMATSPECIFIC_OGG() capturevideostate_ogg_formatspecific_t *format = (capturevideostate_ogg_formatspecific_t *) cls.capturevideo.formatspecific
 641
 642 #define INTERLEAVING_NOT_WORKING
 643 static void SCR_CaptureVideo_Ogg_Interleave()
 644 {
 645         LOAD_FORMATSPECIFIC_OGG();
 646
 647         //fprintf(stderr, "<");
 648
 649         if(!cls.capturevideo.soundrate)
 650         {
 651                 for(;;)
 652                 {
 653                         // first: make sure we have a page of both types
 654                         if(!format->have_videopage)
 655                                 if(qogg_stream_pageout(&format->to, &format->videopage) > 0)
 656                                         format->have_videopage = true;
 657                         if(format->have_videopage)
 658                         {
 659                                 FS_Write(cls.capturevideo.videofile, format->videopage.header, format->videopage.header_len);
 660                                 FS_Write(cls.capturevideo.videofile, format->videopage.body, format->videopage.body_len);
 661                                 format->have_videopage = false;
 662                         }
 663                         else
 664                                 break;
 665                 }
 666                 return;
 667         }
 668
 669         for(;;)
 670         {
 671                 // first: make sure we have a page of both types
 672                 if(!format->have_videopage)
 673                         if(qogg_stream_pageout(&format->to, &format->videopage) > 0)
 674                         {
 675                                 //fprintf(stderr, "V");
 676                                 format->have_videopage = true;
 677
 678 #ifdef INTERLEAVING_NOT_WORKING
 679                                 // why do I have to do this? the code should work without the
 680                                 // following three lines, which turn this attempt at correct
 681                                 // interleaving back into the old stupid one that oggz-validate
 682                                 // hates
 683                                 FS_Write(cls.capturevideo.videofile, format->videopage.header, format->videopage.header_len);
 684                                 FS_Write(cls.capturevideo.videofile, format->videopage.body, format->videopage.body_len);
 685                                 format->have_videopage = false;
 686                                 continue;
 687 #endif
 688                         }
 689                 if(!format->have_audiopage)
 690                         if(qogg_stream_pageout(&format->vo, &format->audiopage) > 0)
 691                         {
 692                                 //fprintf(stderr, "A");
 693                                 format->have_audiopage = true;
 694
 695 #ifdef INTERLEAVING_NOT_WORKING
 696                                 // why do I have to do this? the code should work without the
 697                                 // following three lines, which turn this attempt at correct
 698                                 // interleaving back into the old stupid one that oggz-validate
 699                                 // hates
 700                                 FS_Write(cls.capturevideo.videofile, format->audiopage.header, format->audiopage.header_len);
 701                                 FS_Write(cls.capturevideo.videofile, format->audiopage.body, format->audiopage.body_len);
 702                                 format->have_audiopage = false;
 703                                 continue;
 704 #endif
 705                         }
 706
 707                 if(format->have_videopage && format->have_audiopage)
 708                 {
 709                         // output the page that ends first
 710                         double audiotime = qvorbis_granule_time(&format->vd, qogg_page_granulepos(&format->audiopage));
 711                         double videotime = qtheora_granule_time(&format->ts, qogg_page_granulepos(&format->videopage));
 712                         //fprintf(stderr, "(A=%f V=%f)\n", audiotime, videotime);
 713                         if(audiotime < videotime)
 714                         {
 715                                 FS_Write(cls.capturevideo.videofile, format->audiopage.header, format->audiopage.header_len);
 716                                 FS_Write(cls.capturevideo.videofile, format->audiopage.body, format->audiopage.body_len);
 717                                 format->have_audiopage = false;
 718
 719                                 //fprintf(stderr, "a");
 720                         }
 721                         else
 722                         {
 723                                 FS_Write(cls.capturevideo.videofile, format->videopage.header, format->videopage.header_len);
 724                                 FS_Write(cls.capturevideo.videofile, format->videopage.body, format->videopage.body_len);
 725                                 format->have_videopage = false;
 726
 727                                 //fprintf(stderr, "v");
 728                         }
 729                 }
 730                 else
 731                         break;
 732         }
 733
 734         //fprintf(stderr, ">");
 735 }
 736
 737 static void SCR_CaptureVideo_Ogg_FlushInterleaving()
 738 {
 739         LOAD_FORMATSPECIFIC_OGG();
 740
 741         if(cls.capturevideo.soundrate)
 742         if(format->have_audiopage)
 743         {
 744                 FS_Write(cls.capturevideo.videofile, format->audiopage.header, format->audiopage.header_len);
 745                 FS_Write(cls.capturevideo.videofile, format->audiopage.body, format->audiopage.body_len);
 746                 format->have_audiopage = false;
 747         }
 748
 749         if(format->have_videopage)
 750         {
 751                 FS_Write(cls.capturevideo.videofile, format->videopage.header, format->videopage.header_len);
 752                 FS_Write(cls.capturevideo.videofile, format->videopage.body, format->videopage.body_len);
 753                 format->have_videopage = false;
 754         }
 755 }
 756
 757 static void SCR_CaptureVideo_Ogg_EndVideo()
 758 {
 759         LOAD_FORMATSPECIFIC_OGG();
 760         ogg_page pg;
 761         ogg_packet pt;
 762
 763         if(format->yuvi >= 0)
 764         {
 765                 // send the previous (and last) frame
 766                 while(format->lastnum > 0)
 767                 {
 768                         qtheora_encode_YUVin(&format->ts, &format->yuv[format->yuvi]);
 769
 770                         while(qtheora_encode_packetout(&format->ts, !format->lastnum, &pt))
 771                                 qogg_stream_packetin(&format->to, &pt);
 772
 773                         SCR_CaptureVideo_Ogg_Interleave();
 774                 }
 775         }
 776
 777         if(cls.capturevideo.soundrate)
 778         {
 779                 qvorbis_analysis_wrote(&format->vd, 0);
 780                 while(qvorbis_analysis_blockout(&format->vd, &format->vb) == 1)
 781                 {
 782                         qvorbis_analysis(&format->vb, NULL);
 783                         qvorbis_bitrate_addblock(&format->vb);
 784                         while(qvorbis_bitrate_flushpacket(&format->vd, &pt))
 785                                 qogg_stream_packetin(&format->vo, &pt);
 786                         SCR_CaptureVideo_Ogg_Interleave();
 787                 }
 788         }
 789
 790         SCR_CaptureVideo_Ogg_FlushInterleaving();
 791
 792         while(qogg_stream_pageout(&format->to, &pg) > 0)
 793         {
 794                 FS_Write(cls.capturevideo.videofile, pg.header, pg.header_len);
 795                 FS_Write(cls.capturevideo.videofile, pg.body, pg.body_len);
 796         }
 797
 798         if(cls.capturevideo.soundrate)
 799         {
 800                 while(qogg_stream_pageout(&format->vo, &pg) > 0)
 801                 {
 802                         FS_Write(cls.capturevideo.videofile, pg.header, pg.header_len);
 803                         FS_Write(cls.capturevideo.videofile, pg.body, pg.body_len);
 804                 }
 805         }
 806
 807         while (1) {
 808                 int result = qogg_stream_flush (&format->to, &pg);
 809                 if (result < 0)
 810                         fprintf (stderr, "Internal Ogg library error.\n"); // TODO Host_Error
 811                 if (result <= 0)
 812                         break;
 813                 FS_Write(cls.capturevideo.videofile, pg.header, pg.header_len);
 814                 FS_Write(cls.capturevideo.videofile, pg.body, pg.body_len);
 815         }
 816
 817         if(cls.capturevideo.soundrate)
 818         {
 819                 while (1) {
 820                         int result = qogg_stream_flush (&format->vo, &pg);
 821                         if (result < 0)
 822                                 fprintf (stderr, "Internal Ogg library error.\n"); // TODO Host_Error
 823                         if (result <= 0)
 824                                 break;
 825                         FS_Write(cls.capturevideo.videofile, pg.header, pg.header_len);
 826                         FS_Write(cls.capturevideo.videofile, pg.body, pg.body_len);
 827                 }
 828
 829                 qogg_stream_clear(&format->vo);
 830                 qvorbis_block_clear(&format->vb);
 831                 qvorbis_dsp_clear(&format->vd);
 832         }
 833
 834         qogg_stream_clear(&format->to);
 835         qtheora_clear(&format->ts);
 836         qvorbis_info_clear(&format->vi);
 837
 838         Mem_Free(format->yuv[0].y);
 839         Mem_Free(format->yuv[0].u);
 840         Mem_Free(format->yuv[0].v);
 841         Mem_Free(format->yuv[1].y);
 842         Mem_Free(format->yuv[1].u);
 843         Mem_Free(format->yuv[1].v);
 844         Mem_Free(format);
 845
 846         FS_Close(cls.capturevideo.videofile);
 847         cls.capturevideo.videofile = NULL;
 848 }
 849
 850 static void SCR_CaptureVideo_Ogg_ConvertFrame_BGRA_to_YUV()
 851 {
 852         LOAD_FORMATSPECIFIC_OGG();
 853         yuv_buffer *yuv;
 854         int x, y;
 855         int blockr, blockg, blockb;
 856         unsigned char *b = cls.capturevideo.outbuffer;
 857         int w = cls.capturevideo.width;
 858         int h = cls.capturevideo.height;
 859         int inpitch = w*4;
 860
 861         yuv = &format->yuv[format->yuvi];
 862
 863         for(y = 0; y < h; ++y)
 864         {
 865                 for(b = cls.capturevideo.outbuffer + (h-1-y)*w*4, x = 0; x < w; ++x)
 866                 {
 867                         blockr = b[2];
 868                         blockg = b[1];
 869                         blockb = b[0];
 870                         yuv->y[x + yuv->y_stride * y] =
 871                                 cls.capturevideo.yuvnormalizetable[0][cls.capturevideo.rgbtoyuvscaletable[0][0][blockr] + cls.capturevideo.rgbtoyuvscaletable[0][1][blockg] + cls.capturevideo.rgbtoyuvscaletable[0][2][blockb]];
 872                         b += 4;
 873                 }
 874
 875                 if((y & 1) == 0)
 876                 {
 877                         for(b = cls.capturevideo.outbuffer + (h-2-y)*w*4, x = 0; x < w/2; ++x)
 878                         {
 879                                 blockr = (b[2] + b[6] + b[inpitch+2] + b[inpitch+6]) >> 2;
 880                                 blockg = (b[1] + b[5] + b[inpitch+1] + b[inpitch+5]) >> 2;
 881                                 blockb = (b[0] + b[4] + b[inpitch+0] + b[inpitch+4]) >> 2;
 882                                 yuv->u[x + yuv->uv_stride * (y/2)] =
 883                                         cls.capturevideo.yuvnormalizetable[1][cls.capturevideo.rgbtoyuvscaletable[1][0][blockr] + cls.capturevideo.rgbtoyuvscaletable[1][1][blockg] + cls.capturevideo.rgbtoyuvscaletable[1][2][blockb] + 128];
 884                                 yuv->v[x + yuv->uv_stride * (y/2)] =
 885                                         cls.capturevideo.yuvnormalizetable[2][cls.capturevideo.rgbtoyuvscaletable[2][0][blockr] + cls.capturevideo.rgbtoyuvscaletable[2][1][blockg] + cls.capturevideo.rgbtoyuvscaletable[2][2][blockb] + 128];
 886                                 b += 8;
 887                         }
 888                 }
 889         }
 890 }
 891
 892 static void SCR_CaptureVideo_Ogg_VideoFrames(int num)
 893 {
 894         LOAD_FORMATSPECIFIC_OGG();
 895         ogg_packet pt;
 896
 897         // data is in cls.capturevideo.outbuffer as BGRA and has size width*height
 898
 899         if(format->yuvi >= 0)
 900         {
 901                 // send the previous frame
 902                 while(format->lastnum-- > 0)
 903                 {
 904                         qtheora_encode_YUVin(&format->ts, &format->yuv[format->yuvi]);
 905
 906                         while(qtheora_encode_packetout(&format->ts, false, &pt))
 907                                 qogg_stream_packetin(&format->to, &pt);
 908
 909                         SCR_CaptureVideo_Ogg_Interleave();
 910                 }
 911         }
 912
 913         format->yuvi = (format->yuvi + 1) % 2;
 914         SCR_CaptureVideo_Ogg_ConvertFrame_BGRA_to_YUV();
 915         format->lastnum = num;
 916
 917         // TODO maybe send num-1 frames from here already
 918 }
 919
 920 static void SCR_CaptureVideo_Ogg_SoundFrame(const portable_sampleframe_t *paintbuffer, size_t length)
 921 {
 922         LOAD_FORMATSPECIFIC_OGG();
 923         float **vorbis_buffer;
 924         size_t i;
 925         int j;
 926         ogg_packet pt;
 927
 928         vorbis_buffer = qvorbis_analysis_buffer(&format->vd, length);
 929         for(i = 0; i < length; ++i)
 930         {
 931                 for(j = 0; j < cls.capturevideo.soundchannels; ++j)
 932                         vorbis_buffer[j][i] = paintbuffer[i].sample[j] / 32768.0f;
 933         }
 934         qvorbis_analysis_wrote(&format->vd, length);
 935
 936         while(qvorbis_analysis_blockout(&format->vd, &format->vb) == 1)
 937         {
 938                 qvorbis_analysis(&format->vb, NULL);
 939                 qvorbis_bitrate_addblock(&format->vb);
 940
 941                 while(qvorbis_bitrate_flushpacket(&format->vd, &pt))
 942                         qogg_stream_packetin(&format->vo, &pt);
 943         }
 944
 945         SCR_CaptureVideo_Ogg_Interleave();
 946 }
 947
 948 void SCR_CaptureVideo_Ogg_BeginVideo()
 949 {
 950         cls.capturevideo.format = CAPTUREVIDEOFORMAT_OGG_VORBIS_THEORA;
 951         cls.capturevideo.videofile = FS_OpenRealFile(va("%s.ogv", cls.capturevideo.basename), "wb", false);
 952         cls.capturevideo.endvideo = SCR_CaptureVideo_Ogg_EndVideo;
 953         cls.capturevideo.videoframes = SCR_CaptureVideo_Ogg_VideoFrames;
 954         cls.capturevideo.soundframe = SCR_CaptureVideo_Ogg_SoundFrame;
 955         cls.capturevideo.formatspecific = Mem_Alloc(tempmempool, sizeof(capturevideostate_ogg_formatspecific_t));
 956         {
 957                 LOAD_FORMATSPECIFIC_OGG();
 958                 int num, denom, i;
 959                 ogg_page pg;
 960                 ogg_packet pt, pt2, pt3;
 961                 theora_comment tc;
 962                 vorbis_comment vc;
 963                 theora_info ti;
 964
 965                 format->serial1 = rand();
 966                 qogg_stream_init(&format->to, format->serial1);
 967
 968                 if(cls.capturevideo.soundrate)
 969                 {
 970                         do
 971                         {
 972                                 format->serial2 = rand();
 973                         }
 974                         while(format->serial1 == format->serial2);
 975                         qogg_stream_init(&format->vo, format->serial2);
 976                 }
 977
 978                 format->have_videopage = format->have_audiopage = false;
 979
 980                 qtheora_info_init(&ti);
 981                 ti.frame_width = cls.capturevideo.width;
 982                 ti.frame_height = cls.capturevideo.height;
 983                 ti.width = (ti.frame_width + 15) & ~15;
 984                 ti.height = (ti.frame_height + 15) & ~15;
 985                 //ti.offset_x = ((ti.width - ti.frame_width) / 2) & ~1;
 986                 //ti.offset_y = ((ti.height - ti.frame_height) / 2) & ~1;
 987
 988                 for(i = 0; i < 2; ++i)
 989                 {
 990                         format->yuv[i].y_width = ti.width;
 991                         format->yuv[i].y_height = ti.height;
 992                         format->yuv[i].y_stride = ti.width;
 993                         format->yuv[i].uv_width = ti.width / 2;
 994                         format->yuv[i].uv_height = ti.height / 2;
 995                         format->yuv[i].uv_stride = ti.width / 2;
 996                         format->yuv[i].y = Mem_Alloc(tempmempool, format->yuv[i].y_stride * format->yuv[i].y_height);
 997                         format->yuv[i].u = Mem_Alloc(tempmempool, format->yuv[i].uv_stride * format->yuv[i].uv_height);
 998                         format->yuv[i].v = Mem_Alloc(tempmempool, format->yuv[i].uv_stride * format->yuv[i].uv_height);
 999                 }
1000                 format->yuvi = -1; // -1: no frame valid yet, write into 0
1001
1002                 FindFraction(cls.capturevideo.framerate, &num, &denom, 1001);
1003                 ti.fps_numerator = num;
1004                 ti.fps_denominator = denom;
1005
1006                 FindFraction(1 / vid_pixelheight.value, &num, &denom, 1000);
1007                 ti.aspect_numerator = num;
1008                 ti.aspect_denominator = denom;
1009
1010                 ti.colorspace = OC_CS_UNSPECIFIED;
1011                 ti.pixelformat = OC_PF_420;
1012
1013                 ti.quick_p = true; // http://mlblog.osdir.com/multimedia.ogg.theora.general/2004-07/index.shtml
1014                 ti.dropframes_p = false;
1015
1016                 ti.target_bitrate = cl_capturevideo_ogg_theora_bitrate.integer * 1000;
1017                 ti.quality = cl_capturevideo_ogg_theora_quality.integer;
1018
1019                 if(ti.target_bitrate <= 0)
1020                 {
1021                         if(ti.quality < 0)
1022                         {
1023                                 ti.target_bitrate = -1;
1024                                 ti.keyframe_data_target_bitrate = -1;
1025                                 ti.quality = 63;
1026                         }
1027                         else
1028                         {
1029                                 ti.target_bitrate = -1;
1030                                 ti.keyframe_data_target_bitrate = -1;
1031                                 ti.quality = bound(0, ti.quality, 63);
1032                         }
1033                 }
1034                 else
1035                 {
1036                         if(ti.quality < 0)
1037                         {
1038                                 ti.target_bitrate = bound(45000, ti.target_bitrate, 2000000);
1039                                 ti.keyframe_data_target_bitrate = ti.target_bitrate * max(1, cl_capturevideo_ogg_theora_keyframe_bitrate_multiplier.value);
1040                                 ti.quality = -1;
1041                         }
1042                         else
1043                         {
1044                                 ti.target_bitrate = bound(45000, ti.target_bitrate, 2000000);
1045                                 ti.keyframe_data_target_bitrate = ti.target_bitrate * max(1, cl_capturevideo_ogg_theora_keyframe_bitrate_multiplier.value);
1046                                 ti.quality = -1;
1047                         }
1048                 }
1049
1050                 ti.keyframe_frequency = bound(1, cl_capturevideo_ogg_theora_keyframe_frequency.integer, 1000);
1051                 ti.keyframe_mindistance = bound(1, cl_capturevideo_ogg_theora_keyframe_mindistance.integer, (int) ti.keyframe_frequency);
1052                 ti.noise_sensitivity = bound(0, cl_capturevideo_ogg_theora_noise_sensitivity.integer, 6);
1053                 ti.sharpness = bound(0, cl_capturevideo_ogg_theora_sharpness.integer, 2);
1054                 ti.keyframe_auto_threshold = bound(0, cl_capturevideo_ogg_theora_keyframe_auto_threshold.integer, 100);
1055
1056                 ti.keyframe_frequency_force = ti.keyframe_frequency;
1057                 ti.keyframe_auto_p = (ti.keyframe_frequency != ti.keyframe_mindistance);
1058
1059                 qtheora_encode_init(&format->ts, &ti);
1060                 qtheora_info_clear(&ti);
1061
1062                 // vorbis?
1063                 if(cls.capturevideo.soundrate)
1064                 {
1065                         qvorbis_info_init(&format->vi);
1066                         qvorbis_encode_init_vbr(&format->vi, cls.capturevideo.soundchannels, cls.capturevideo.soundrate, bound(-1, cl_capturevideo_ogg_vorbis_quality.value, 10) * 0.099);
1067                         qvorbis_comment_init(&vc);
1068                         qvorbis_analysis_init(&format->vd, &format->vi);
1069                         qvorbis_block_init(&format->vd, &format->vb);
1070                 }
1071
1072                 qtheora_comment_init(&tc);
1073
1074                 /* create the remaining theora headers */
1075                 qtheora_encode_header(&format->ts, &pt);
1076                 qogg_stream_packetin(&format->to, &pt);
1077                 if (qogg_stream_pageout (&format->to, &pg) != 1)
1078                         fprintf (stderr, "Internal Ogg library error.\n");
1079                 FS_Write(cls.capturevideo.videofile, pg.header, pg.header_len);
1080                 FS_Write(cls.capturevideo.videofile, pg.body, pg.body_len);
1081
1082                 qtheora_encode_comment(&tc, &pt);
1083                 qogg_stream_packetin(&format->to, &pt);
1084                 qtheora_encode_tables(&format->ts, &pt);
1085                 qogg_stream_packetin (&format->to, &pt);
1086
1087                 qtheora_comment_clear(&tc);
1088
1089                 if(cls.capturevideo.soundrate)
1090                 {
1091                         qvorbis_analysis_headerout(&format->vd, &vc, &pt, &pt2, &pt3);
1092                         qogg_stream_packetin(&format->vo, &pt);
1093                         if (qogg_stream_pageout (&format->vo, &pg) != 1)
1094                                 fprintf (stderr, "Internal Ogg library error.\n");
1095                         FS_Write(cls.capturevideo.videofile, pg.header, pg.header_len);
1096                         FS_Write(cls.capturevideo.videofile, pg.body, pg.body_len);
1097
1098                         qogg_stream_packetin(&format->vo, &pt2);
1099                         qogg_stream_packetin(&format->vo, &pt3);
1100
1101                         qvorbis_comment_clear(&vc);
1102                 }
1103
1104                 for(;;)
1105                 {
1106                         int result = qogg_stream_flush (&format->to, &pg);
1107                         if (result < 0)
1108                                 fprintf (stderr, "Internal Ogg library error.\n"); // TODO Host_Error
1109                         if (result <= 0)
1110                                 break;
1111                         FS_Write(cls.capturevideo.videofile, pg.header, pg.header_len);
1112                         FS_Write(cls.capturevideo.videofile, pg.body, pg.body_len);
1113                 }
1114
1115                 if(cls.capturevideo.soundrate)
1116                 for(;;)
1117                 {
1118                         int result = qogg_stream_flush (&format->vo, &pg);
1119                         if (result < 0)
1120                                 fprintf (stderr, "Internal Ogg library error.\n"); // TODO Host_Error
1121                         if (result <= 0)
1122                                 break;
1123                         FS_Write(cls.capturevideo.videofile, pg.header, pg.header_len);
1124                         FS_Write(cls.capturevideo.videofile, pg.body, pg.body_len);
1125                 }
1126         }
1127 }