cap_ogg.c

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