text: /********************************************************************
   *                                                                  *
   * THIS FILE IS PART OF THE OggTheora SOFTWARE CODEC SOURCE CODE.   *
   * USE, DISTRIBUTION AND REPRODUCTION OF THIS LIBRARY SOURCE IS     *
   * GOVERNED BY A BSD-STYLE SOURCE LICENSE INCLUDED WITH THIS SOURCE *
   * IN 'COPYING'. PLEASE READ THESE TERMS BEFORE DISTRIBUTING.       *
   *                                                                  *
   * THE Theora SOURCE CODE IS COPYRIGHT (C) 2002-2009                *
   * by the Xiph.Org Foundation http://www.xiph.org/                  *
   *                                                                  *
   ********************************************************************
  
    function:
    last mod: $Id$
  
   ********************************************************************/
  #include <stdlib.h>
  #include <string.h>
  #include "encint.h"
  #if defined(OC_X86_ASM)
  # include "x86/x86enc.h"
  #endif
  
  
  
  /*The default quantization parameters used by VP3.1.*/
  static const int OC_VP31_RANGE_SIZES[1]={63};
  static const th_quant_base OC_VP31_BASES_INTRA_Y[2]={
    {
       16, 11, 10, 16, 24, 40, 51, 61,
       12, 12, 14, 19, 26, 58, 60, 55,
       14, 13, 16, 24, 40, 57, 69, 56,
       14, 17, 22, 29, 51, 87, 80, 62,
       18, 22, 37, 58, 68,109,103, 77,
       24, 35, 55, 64, 81,104,113, 92,
       49, 64, 78, 87,103,121,120,101,
       72, 92, 95, 98,112,100,103, 99
    },
    {
       16, 11, 10, 16, 24, 40, 51, 61,
       12, 12, 14, 19, 26, 58, 60, 55,
       14, 13, 16, 24, 40, 57, 69, 56,
       14, 17, 22, 29, 51, 87, 80, 62,
       18, 22, 37, 58, 68,109,103, 77,
       24, 35, 55, 64, 81,104,113, 92,
       49, 64, 78, 87,103,121,120,101,
       72, 92, 95, 98,112,100,103, 99
    }
  };
  static const th_quant_base OC_VP31_BASES_INTRA_C[2]={
    {
       17, 18, 24, 47, 99, 99, 99, 99,
       18, 21, 26, 66, 99, 99, 99, 99,
       24, 26, 56, 99, 99, 99, 99, 99,
       47, 66, 99, 99, 99, 99, 99, 99,
       99, 99, 99, 99, 99, 99, 99, 99,
       99, 99, 99, 99, 99, 99, 99, 99,
       99, 99, 99, 99, 99, 99, 99, 99,
       99, 99, 99, 99, 99, 99, 99, 99
    },
    {
       17, 18, 24, 47, 99, 99, 99, 99,
       18, 21, 26, 66, 99, 99, 99, 99,
       24, 26, 56, 99, 99, 99, 99, 99,
       47, 66, 99, 99, 99, 99, 99, 99,
       99, 99, 99, 99, 99, 99, 99, 99,
       99, 99, 99, 99, 99, 99, 99, 99,
       99, 99, 99, 99, 99, 99, 99, 99,
       99, 99, 99, 99, 99, 99, 99, 99
    }
  };
  static const th_quant_base OC_VP31_BASES_INTER[2]={
    {
       16, 16, 16, 20, 24, 28, 32, 40,
       16, 16, 20, 24, 28, 32, 40, 48,
       16, 20, 24, 28, 32, 40, 48, 64,
       20, 24, 28, 32, 40, 48, 64, 64,
       24, 28, 32, 40, 48, 64, 64, 64,
       28, 32, 40, 48, 64, 64, 64, 96,
       32, 40, 48, 64, 64, 64, 96,128,
       40, 48, 64, 64, 64, 96,128,128
    },
    {
       16, 16, 16, 20, 24, 28, 32, 40,
       16, 16, 20, 24, 28, 32, 40, 48,
       16, 20, 24, 28, 32, 40, 48, 64,
       20, 24, 28, 32, 40, 48, 64, 64,
       24, 28, 32, 40, 48, 64, 64, 64,
       28, 32, 40, 48, 64, 64, 64, 96,
       32, 40, 48, 64, 64, 64, 96,128,
       40, 48, 64, 64, 64, 96,128,128
    }
  };
  
  const th_quant_info TH_VP31_QUANT_INFO={
    {
      220,200,190,180,170,170,160,160,
      150,150,140,140,130,130,120,120,
      110,110,100,100, 90, 90, 90, 80,
       80, 80, 70, 70, 70, 60, 60, 60,
       60, 50, 50, 50, 50, 40, 40, 40,
       40, 40, 30, 30, 30, 30, 30, 30,
       30, 20, 20, 20, 20, 20, 20, 20,
       20, 10, 10, 10, 10, 10, 10, 10
    },
    {
      500,450,400,370,340,310,285,265,
      245,225,210,195,185,180,170,160,
      150,145,135,130,125,115,110,107,
      100, 96, 93, 89, 85, 82, 75, 74,
       70, 68, 64, 60, 57, 56, 52, 50,
       49, 45, 44, 43, 40, 38, 37, 35,
       33, 32, 30, 29, 28, 25, 24, 22,
       21, 19, 18, 17, 15, 13, 12, 10
    },
    {
      30,25,20,20,15,15,14,14,
      13,13,12,12,11,11,10,10,
       9, 9, 8, 8, 7, 7, 7, 7,
       6, 6, 6, 6, 5, 5, 5, 5,
       4, 4, 4, 4, 3, 3, 3, 3,
       2, 2, 2, 2, 2, 2, 2, 2,
       0, 0, 0, 0, 0, 0, 0, 0,
       0, 0, 0, 0, 0, 0, 0, 0
    },
    {
      {
        {1,OC_VP31_RANGE_SIZES,OC_VP31_BASES_INTRA_Y},
        {1,OC_VP31_RANGE_SIZES,OC_VP31_BASES_INTRA_C},
        {1,OC_VP31_RANGE_SIZES,OC_VP31_BASES_INTRA_C}
      },
      {
        {1,OC_VP31_RANGE_SIZES,OC_VP31_BASES_INTER},
        {1,OC_VP31_RANGE_SIZES,OC_VP31_BASES_INTER},
        {1,OC_VP31_RANGE_SIZES,OC_VP31_BASES_INTER}
      }
    }
  };
  
  /*The current default quantization parameters.*/
  static const int OC_DEF_QRANGE_SIZES[3]={32,16,15};
  static const th_quant_base OC_DEF_BASES_INTRA_Y[4]={
    {
       15, 15, 15, 15, 15, 15, 15, 15,
       15, 15, 15, 15, 15, 15, 15, 15,
       15, 15, 15, 15, 15, 15, 15, 15,
       15, 15, 15, 15, 15, 15, 15, 15,
       15, 15, 15, 15, 15, 15, 15, 15,
       15, 15, 15, 15, 15, 15, 15, 15,
       15, 15, 15, 15, 15, 15, 15, 15,
       15, 15, 15, 15, 15, 15, 15, 15,
    },
    {
       15, 12, 12, 15, 18, 20, 20, 21,
       13, 13, 14, 17, 18, 21, 21, 20,
       14, 14, 15, 18, 20, 21, 21, 21,
       14, 16, 17, 19, 20, 21, 21, 21,
       16, 17, 20, 21, 21, 21, 21, 21,
       18, 19, 20, 21, 21, 21, 21, 21,
       20, 21, 21, 21, 21, 21, 21, 21,
       21, 21, 21, 21, 21, 21, 21, 21
    },
    {
       16, 12, 11, 16, 20, 25, 27, 28,
       13, 13, 14, 18, 21, 28, 28, 27,
       14, 13, 16, 20, 25, 28, 28, 28,
       14, 16, 19, 22, 27, 29, 29, 28,
       17, 19, 25, 28, 28, 30, 30, 29,
       20, 24, 27, 28, 29, 30, 30, 29,
       27, 28, 29, 29, 30, 30, 30, 30,
       29, 29, 29, 29, 30, 30, 30, 29
    },
    {
       16, 11, 10, 16, 24, 40, 51, 61,
       12, 12, 14, 19, 26, 58, 60, 55,
       14, 13, 16, 24, 40, 57, 69, 56,
       14, 17, 22, 29, 51, 87, 80, 62,
       18, 22, 37, 58, 68,109,103, 77,
       24, 35, 55, 64, 81,104,113, 92,
       49, 64, 78, 87,103,121,120,101,
       72, 92, 95, 98,112,100,103, 99
    }
  };
  static const th_quant_base OC_DEF_BASES_INTRA_C[4]={
    {
       19, 19, 19, 19, 19, 19, 19, 19,
       19, 19, 19, 19, 19, 19, 19, 19,
       19, 19, 19, 19, 19, 19, 19, 19,
       19, 19, 19, 19, 19, 19, 19, 19,
       19, 19, 19, 19, 19, 19, 19, 19,
       19, 19, 19, 19, 19, 19, 19, 19,
       19, 19, 19, 19, 19, 19, 19, 19,
       19, 19, 19, 19, 19, 19, 19, 19
    },
    {
       18, 18, 21, 25, 26, 26, 26, 26,
       18, 20, 22, 26, 26, 26, 26, 26,
       21, 22, 25, 26, 26, 26, 26, 26,
       25, 26, 26, 26, 26, 26, 26, 26,
       26, 26, 26, 26, 26, 26, 26, 26,
       26, 26, 26, 26, 26, 26, 26, 26,
       26, 26, 26, 26, 26, 26, 26, 26,
       26, 26, 26, 26, 26, 26, 26, 26
    },
    {
       17, 18, 22, 31, 36, 36, 36, 36,
       18, 20, 24, 34, 36, 36, 36, 36,
       22, 24, 33, 36, 36, 36, 36, 36,
       31, 34, 36, 36, 36, 36, 36, 36,
       36, 36, 36, 36, 36, 36, 36, 36,
       36, 36, 36, 36, 36, 36, 36, 36,
       36, 36, 36, 36, 36, 36, 36, 36,
       36, 36, 36, 36, 36, 36, 36, 36
    },
    {
       17, 18, 24, 47, 99, 99, 99, 99,
       18, 21, 26, 66, 99, 99, 99, 99,
       24, 26, 56, 99, 99, 99, 99, 99,
       47, 66, 99, 99, 99, 99, 99, 99,
       99, 99, 99, 99, 99, 99, 99, 99,
       99, 99, 99, 99, 99, 99, 99, 99,
       99, 99, 99, 99, 99, 99, 99, 99,
       99, 99, 99, 99, 99, 99, 99, 99
    }
  };
  static const th_quant_base OC_DEF_BASES_INTER[4]={
    {
       21, 21, 21, 21, 21, 21, 21, 21,
       21, 21, 21, 21, 21, 21, 21, 21,
       21, 21, 21, 21, 21, 21, 21, 21,
       21, 21, 21, 21, 21, 21, 21, 21,
       21, 21, 21, 21, 21, 21, 21, 21,
       21, 21, 21, 21, 21, 21, 21, 21,
       21, 21, 21, 21, 21, 21, 21, 21,
       21, 21, 21, 21, 21, 21, 21, 21
    },
    {
       18, 18, 18, 21, 23, 24, 25, 27,
       18, 18, 21, 23, 24, 25, 27, 28,
       18, 21, 23, 24, 25, 27, 28, 29,
       21, 23, 24, 25, 27, 28, 29, 29,
       23, 24, 25, 27, 28, 29, 29, 29,
       24, 25, 27, 28, 29, 29, 29, 30,
       25, 27, 28, 29, 29, 29, 30, 30,
       27, 28, 29, 29, 29, 30, 30, 30
    },
    {
       17, 17, 17, 20, 23, 26, 28, 32,
       17, 17, 20, 23, 26, 28, 32, 34,
       17, 20, 23, 26, 28, 32, 34, 37,
       20, 23, 26, 28, 32, 34, 37, 37,
       23, 26, 28, 32, 34, 37, 37, 37,
       26, 28, 32, 34, 37, 37, 37, 41,
       28, 32, 34, 37, 37, 37, 41, 42,
       32, 34, 37, 37, 37, 41, 42, 42
    },
    {
       16, 16, 16, 20, 24, 28, 32, 40,
       16, 16, 20, 24, 28, 32, 40, 48,
       16, 20, 24, 28, 32, 40, 48, 64,
       20, 24, 28, 32, 40, 48, 64, 64,
       24, 28, 32, 40, 48, 64, 64, 64,
       28, 32, 40, 48, 64, 64, 64, 96,
       32, 40, 48, 64, 64, 64, 96,128,
       40, 48, 64, 64, 64, 96,128,128
    }
  };
  
  const th_quant_info TH_DEF_QUANT_INFO={
    {
      365,348,333,316,300,287,277,265,
      252,240,229,219,206,197,189,180,
      171,168,160,153,146,139,132,127,
      121,115,110,107,101, 97, 94, 89,
       85, 83, 78, 73, 72, 67, 66, 62,
       60, 59, 56, 53, 52, 48, 47, 43,
       42, 40, 36, 35, 34, 33, 31, 30,
       28, 25, 24, 22, 20, 17, 14, 10
    },
    {
      365,348,333,316,300,287,277,265,
      252,240,229,219,206,197,189,180,
      171,168,160,153,146,139,132,127,
      121,115,110,107,101, 97, 94, 89,
       85, 83, 78, 73, 72, 67, 66, 62,
       60, 59, 56, 53, 52, 48, 47, 43,
       42, 40, 36, 35, 34, 33, 31, 30,
       28, 25, 24, 22, 20, 17, 14, 10
    },
    {
      30,25,20,20,15,15,14,14,
      13,13,12,12,11,11,10,10,
       9, 9, 8, 8, 7, 7, 7, 7,
       6, 6, 6, 6, 5, 5, 5, 5,
       4, 4, 4, 4, 3, 3, 3, 3,
       2, 2, 2, 2, 2, 2, 2, 2,
       0, 0, 0, 0, 0, 0, 0, 0,
       0, 0, 0, 0, 0, 0, 0, 0
    },
    {
      {
        {3,OC_DEF_QRANGE_SIZES,OC_DEF_BASES_INTRA_Y},
        {3,OC_DEF_QRANGE_SIZES,OC_DEF_BASES_INTRA_C},
        {3,OC_DEF_QRANGE_SIZES,OC_DEF_BASES_INTRA_C}
      },
      {
        {3,OC_DEF_QRANGE_SIZES,OC_DEF_BASES_INTER},
        {3,OC_DEF_QRANGE_SIZES,OC_DEF_BASES_INTER},
        {3,OC_DEF_QRANGE_SIZES,OC_DEF_BASES_INTER}
      }
    }
  };
  
  
  
  /*The Huffman codes used for macro block modes.*/
  
  const unsigned char OC_MODE_BITS[2][OC_NMODES]={
    /*Codebook 0: a maximally skewed prefix code.*/
    {1,2,3,4,5,6,7,7},
    /*Codebook 1: a fixed-length code.*/
    {3,3,3,3,3,3,3,3}
  };
  
  static const unsigned char OC_MODE_CODES[2][OC_NMODES]={
    /*Codebook 0: a maximally skewed prefix code.*/
    {0x00,0x02,0x06,0x0E,0x1E,0x3E,0x7E,0x7F},
    /*Codebook 1: a fixed-length code.*/
    {0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07}
  };
  
  
  /*The Huffman codes used for motion vectors.*/
  
  const unsigned char OC_MV_BITS[2][64]={
    /*Codebook 0: VLC code.*/
    {
        8,8,8,8,8,8,8,8,8,8,8,8,8,8,8,
      8,7,7,7,7,7,7,7,7,6,6,6,6,4,4,3,
      3,
      3,4,4,6,6,6,6,7,7,7,7,7,7,7,7,8,
      8,8,8,8,8,8,8,8,8,8,8,8,8,8,8
    },
    /*Codebook 1: (5 bit magnitude, 1 bit sign).
      This wastes a code word (0x01, negative zero), or a bit (0x00, positive
       zero, requires only 5 bits to uniquely decode), but is hopefully not used
       very often.*/
    {
        6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,
      6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,
      6,
      6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,6,
      6,6,6,6,6,6,6,6,6,6,6,6,6,6,6
    }
  };
  
  static const unsigned char OC_MV_CODES[2][64]={
    /*Codebook 0: VLC code.*/
    {
           0xFF,0xFD,0xFB,0xF9,0xF7,0xF5,0xF3,
      0xF1,0xEF,0xED,0xEB,0xE9,0xE7,0xE5,0xE3,
      0xE1,0x6F,0x6D,0x6B,0x69,0x67,0x65,0x63,
      0x61,0x2F,0x2D,0x2B,0x29,0x09,0x07,0x02,
      0x00,
      0x01,0x06,0x08,0x28,0x2A,0x2C,0x2E,0x60,
      0x62,0x64,0x66,0x68,0x6A,0x6C,0x6E,0xE0,
      0xE2,0xE4,0xE6,0xE8,0xEA,0xEC,0xEE,0xF0,
      0xF2,0xF4,0xF6,0xF8,0xFA,0xFC,0xFE
    },
    /*Codebook 1: (5 bit magnitude, 1 bit sign).*/
    {
           0x3F,0x3D,0x3B,0x39,0x37,0x35,0x33,
      0x31,0x2F,0x2D,0x2B,0x29,0x27,0x25,0x23,
      0x21,0x1F,0x1D,0x1B,0x19,0x17,0x15,0x13,
      0x11,0x0F,0x0D,0x0B,0x09,0x07,0x05,0x03,
      0x00,
      0x02,0x04,0x06,0x08,0x0A,0x0C,0x0E,0x10,
      0x12,0x14,0x16,0x18,0x1A,0x1C,0x1E,0x20,
      0x22,0x24,0x26,0x28,0x2A,0x2C,0x2E,0x30,
      0x32,0x34,0x36,0x38,0x3A,0x3C,0x3E
    }
  };
  
  
  
  /*Super block run coding scheme:
     Codeword             Run Length
     0                       1
     10x                     2-3
     110x                    4-5
     1110xx                  6-9
     11110xxx                10-17
     111110xxxx              18-33
     111111xxxxxxxxxxxx      34-4129*/
  const ogg_uint16_t    OC_SB_RUN_VAL_MIN[8]={1,2,4,6,10,18,34,4130};
  static const unsigned OC_SB_RUN_CODE_PREFIX[7]={
    0,4,0xC,0x38,0xF0,0x3E0,0x3F000
  };
  const unsigned char   OC_SB_RUN_CODE_NBITS[7]={1,3,4,6,8,10,18};
  
  
  /*Writes the bit pattern for the run length of a super block run to the given
     oggpack_buffer.
    _opb:       The buffer to write to.
    _run_count: The length of the run, which must be positive.
    _flag:      The current flag.
    _done:      Whether or not more flags are to be encoded.*/
  static void oc_sb_run_pack(oggpack_buffer *_opb,ptrdiff_t _run_count,
   int _flag,int _done){
    int i;
    if(_run_count>=4129){
      do{
        oggpackB_write(_opb,0x3FFFF,18);
        _run_count-=4129;
        if(_run_count>0)oggpackB_write(_opb,_flag,1);
        else if(!_done)oggpackB_write(_opb,!_flag,1);
      }
      while(_run_count>=4129);
      if(_run_count<=0)return;
    }
    for(i=0;_run_count>=OC_SB_RUN_VAL_MIN[i+1];i++);
    oggpackB_write(_opb,OC_SB_RUN_CODE_PREFIX[i]+_run_count-OC_SB_RUN_VAL_MIN[i],
     OC_SB_RUN_CODE_NBITS[i]);
  }
  
  
  
  /*Block run coding scheme:
     Codeword             Run Length
     0x                      1-2
     10x                     3-4
     110x                    5-6
     1110xx                  7-10
     11110xx                 11-14
     11111xxxx               15-30*/
  const unsigned char OC_BLOCK_RUN_CODE_NBITS[30]={
    2,2,3,3,4,4,6,6,6,6,7,7,7,7,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9
  };
  static const ogg_uint16_t  OC_BLOCK_RUN_CODE_PATTERN[30]={
          0x000,0x001,0x004,0x005,0x00C,0x00D,0x038,
    0x039,0x03A,0x03B,0x078,0x079,0x07A,0x07B,0x1F0,
    0x1F1,0x1F2,0x1F3,0x1F4,0x1F5,0x1F6,0x1F7,0x1F8,
    0x1F9,0x1FA,0x1FB,0x1FC,0x1FD,0x1FE,0x1FF
  };
  
  
  /*Writes the bit pattern for the run length of a block run to the given
     oggpack_buffer.
    _opb:       The buffer to write to.
    _run_count: The length of the run.
                This must be positive, and no more than 30.*/
  static void oc_block_run_pack(oggpack_buffer *_opb,int _run_count){
    oggpackB_write(_opb,OC_BLOCK_RUN_CODE_PATTERN[_run_count-1],
     OC_BLOCK_RUN_CODE_NBITS[_run_count-1]);
  }
  
  
  
  static void oc_enc_frame_header_pack(oc_enc_ctx *_enc){
    /*Mark this as a data packet.*/
    oggpackB_write(&_enc->opb,0,1);
    /*Output the frame type (key frame or delta frame).*/
    oggpackB_write(&_enc->opb,_enc->state.frame_type,1);
    /*Write out the current qi list.*/
    oggpackB_write(&_enc->opb,_enc->state.qis[0],6);
    if(_enc->state.nqis>1){
      oggpackB_write(&_enc->opb,1,1);
      oggpackB_write(&_enc->opb,_enc->state.qis[1],6);
      if(_enc->state.nqis>2){
        oggpackB_write(&_enc->opb,1,1);
        oggpackB_write(&_enc->opb,_enc->state.qis[2],6);
      }
      else oggpackB_write(&_enc->opb,0,1);
    }
    else oggpackB_write(&_enc->opb,0,1);
    if(_enc->state.frame_type==OC_INTRA_FRAME){
      /*Key frames have 3 unused configuration bits, holdovers from the VP3 days.
        Most of the other unused bits in the VP3 headers were eliminated.
        Monty kept these to leave us some wiggle room for future expansion,
         though a single bit in all frames would have been far more useful.*/
      oggpackB_write(&_enc->opb,0,3);
    }
  }
  
  /*Writes the bit flags for whether or not each super block is partially coded
     or not.
    These flags are run-length encoded, with the flag value alternating between
     each run.
    Return: The number partially coded SBs.*/
  static unsigned oc_enc_partial_sb_flags_pack(oc_enc_ctx *_enc){
    const oc_sb_flags *sb_flags;
    unsigned           nsbs;
    unsigned           sbi;
    unsigned           npartial;
    int                flag;
    sb_flags=_enc->state.sb_flags;
    nsbs=_enc->state.nsbs;
    flag=sb_flags[0].coded_partially;
    oggpackB_write(&_enc->opb,flag,1);
    sbi=npartial=0;
    do{
      unsigned run_count;
      for(run_count=0;sbi<nsbs;sbi++){
        if(sb_flags[sbi].coded_partially!=flag)break;
        run_count++;
        npartial+=flag;
      }
      oc_sb_run_pack(&_enc->opb,run_count,flag,sbi>=nsbs);
      flag=!flag;
    }
    while(sbi<nsbs);
    return npartial;
  }
  
  /*Writes the coded/not coded flags for each super block that is not partially
     coded.
    These flags are run-length encoded, with the flag value altenating between
     each run.*/
  static void oc_enc_coded_sb_flags_pack(oc_enc_ctx *_enc){
    const oc_sb_flags *sb_flags;
    unsigned           nsbs;
    unsigned           sbi;
    int                flag;
    sb_flags=_enc->state.sb_flags;
    nsbs=_enc->state.nsbs;
    /*Skip partially coded super blocks; their flags have already been coded.*/
    for(sbi=0;sb_flags[sbi].coded_partially;sbi++);
    flag=sb_flags[sbi].coded_fully;
    oggpackB_write(&_enc->opb,flag,1);
    do{
      unsigned run_count;
      for(run_count=0;sbi<nsbs;sbi++){
        if(sb_flags[sbi].coded_partially)continue;
        if(sb_flags[sbi].coded_fully!=flag)break;
        run_count++;
      }
      oc_sb_run_pack(&_enc->opb,run_count,flag,sbi>=nsbs);
      flag=!flag;
    }
    while(sbi<nsbs);
  }
  
  static void oc_enc_coded_flags_pack(oc_enc_ctx *_enc){
    const oc_sb_map   *sb_maps;
    const oc_sb_flags *sb_flags;
    unsigned           nsbs;
    const oc_fragment *frags;
    unsigned           npartial;
    int                run_count;
    int                flag;
    int                pli;
    unsigned           sbi;
    npartial=oc_enc_partial_sb_flags_pack(_enc);
    if(npartial<_enc->state.nsbs)oc_enc_coded_sb_flags_pack(_enc);
    sb_maps=(const oc_sb_map *)_enc->state.sb_maps;
    sb_flags=_enc->state.sb_flags;
    nsbs=_enc->state.nsbs;
    frags=_enc->state.frags;
    for(sbi=0;sbi<nsbs&&!sb_flags[sbi].coded_partially;sbi++);
    /*If there's at least one partial SB, store individual coded block flags.*/
    if(sbi<nsbs){
      flag=frags[sb_maps[sbi][0][0]].coded;
      oggpackB_write(&_enc->opb,flag,1);
      run_count=0;
      nsbs=sbi=0;
      for(pli=0;pli<3;pli++){
        nsbs+=_enc->state.fplanes[pli].nsbs;
        for(;sbi<nsbs;sbi++){
          int       quadi;
          int       bi;
          ptrdiff_t fragi;
          if(sb_flags[sbi].coded_partially){
            for(quadi=0;quadi<4;quadi++){
              for(bi=0;bi<4;bi++){
                fragi=sb_maps[sbi][quadi][bi];
                if(fragi>=0){
                  if(frags[fragi].coded!=flag){
                    oc_block_run_pack(&_enc->opb,run_count);
                    flag=!flag;
                    run_count=1;
                  }
                  else run_count++;
                }
              }
            }
          }
        }
      }
      /*Flush any trailing block coded run.*/
      if(run_count>0)oc_block_run_pack(&_enc->opb,run_count);
    }
  }
  
  static void oc_enc_mb_modes_pack(oc_enc_ctx *_enc){
    const unsigned char *mode_codes;
    const unsigned char *mode_bits;
    const unsigned char *mode_ranks;
    unsigned            *coded_mbis;
    size_t               ncoded_mbis;
    const signed char   *mb_modes;
    unsigned             mbii;
    int                  scheme;
    int                  mb_mode;
    scheme=_enc->chooser.scheme_list[0];
    /*Encode the best scheme.*/
    oggpackB_write(&_enc->opb,scheme,3);
    /*If the chosen scheme is scheme 0, send the mode frequency ordering.*/
    if(scheme==0){
      for(mb_mode=0;mb_mode<OC_NMODES;mb_mode++){
        oggpackB_write(&_enc->opb,_enc->chooser.scheme0_ranks[mb_mode],3);
      }
    }
    mode_ranks=_enc->chooser.mode_ranks[scheme];
    mode_bits=OC_MODE_BITS[scheme+1>>3];
    mode_codes=OC_MODE_CODES[scheme+1>>3];
    coded_mbis=_enc->coded_mbis;
    ncoded_mbis=_enc->ncoded_mbis;
    mb_modes=_enc->state.mb_modes;
    for(mbii=0;mbii<ncoded_mbis;mbii++){
      int rank;
      rank=mode_ranks[mb_modes[coded_mbis[mbii]]];
      oggpackB_write(&_enc->opb,mode_codes[rank],mode_bits[rank]);
    }
  }
  
  static void oc_enc_mv_pack(oc_enc_ctx *_enc,int _mv_scheme,int _dx,int _dy){
    oggpackB_write(&_enc->opb,
     OC_MV_CODES[_mv_scheme][_dx+31],OC_MV_BITS[_mv_scheme][_dx+31]);
    oggpackB_write(&_enc->opb,
     OC_MV_CODES[_mv_scheme][_dy+31],OC_MV_BITS[_mv_scheme][_dy+31]);
  }
  
  static void oc_enc_mvs_pack(oc_enc_ctx *_enc){
    const unsigned     *coded_mbis;
    size_t              ncoded_mbis;
    const oc_mb_map    *mb_maps;
    const signed char  *mb_modes;
    const oc_fragment  *frags;
    const oc_mv        *frag_mvs;
    unsigned            mbii;
    int                 mv_scheme;
    /*Choose the coding scheme.*/
    mv_scheme=_enc->mv_bits[1]<_enc->mv_bits[0];
    oggpackB_write(&_enc->opb,mv_scheme,1);
    /*Encode the motion vectors.
      Macro blocks are iterated in Hilbert scan order, but the MVs within the
       macro block are coded in raster order.*/
    coded_mbis=_enc->coded_mbis;
    ncoded_mbis=_enc->ncoded_mbis;
    mb_modes=_enc->state.mb_modes;
    mb_maps=(const oc_mb_map *)_enc->state.mb_maps;
    frags=_enc->state.frags;
    frag_mvs=(const oc_mv *)_enc->state.frag_mvs;
    for(mbii=0;mbii<ncoded_mbis;mbii++){
      ptrdiff_t fragi;
      unsigned  mbi;
      int       bi;
      mbi=coded_mbis[mbii];
      switch(mb_modes[mbi]){
        case OC_MODE_INTER_MV:
        case OC_MODE_GOLDEN_MV:{
          for(bi=0;;bi++){
            fragi=mb_maps[mbi][0][bi];
            if(frags[fragi].coded){
              oc_enc_mv_pack(_enc,mv_scheme,
               frag_mvs[fragi][0],frag_mvs[fragi][1]);
              /*Only code a single MV for this macro block.*/
              break;
            }
          }
        }break;
        case OC_MODE_INTER_MV_FOUR:{
          for(bi=0;bi<4;bi++){
            fragi=mb_maps[mbi][0][bi];
            if(frags[fragi].coded){
              oc_enc_mv_pack(_enc,mv_scheme,
               frag_mvs[fragi][0],frag_mvs[fragi][1]);
              /*Keep coding all the MVs for this macro block.*/
            }
          }
        }break;
      }
    }
  }
  
  static void oc_enc_block_qis_pack(oc_enc_ctx *_enc){
    const oc_fragment *frags;
    ptrdiff_t         *coded_fragis;
    ptrdiff_t          ncoded_fragis;
    ptrdiff_t          fragii;
    ptrdiff_t          run_count;
    ptrdiff_t          nqi0;
    int                flag;
    if(_enc->state.nqis<=1)return;
    ncoded_fragis=_enc->state.ntotal_coded_fragis;
    if(ncoded_fragis<=0)return;
    coded_fragis=_enc->state.coded_fragis;
    frags=_enc->state.frags;
    flag=!!frags[coded_fragis[0]].qii;
    oggpackB_write(&_enc->opb,flag,1);
    nqi0=0;
    for(fragii=0;fragii<ncoded_fragis;){
      for(run_count=0;fragii<ncoded_fragis;fragii++){
        if(!!frags[coded_fragis[fragii]].qii!=flag)break;
        run_count++;
        nqi0+=!flag;
      }
      oc_sb_run_pack(&_enc->opb,run_count,flag,fragii>=ncoded_fragis);
      flag=!flag;
    }
    if(_enc->state.nqis<3||nqi0>=ncoded_fragis)return;
    for(fragii=0;!frags[coded_fragis[fragii]].qii;fragii++);
    flag=frags[coded_fragis[fragii]].qii-1;
    oggpackB_write(&_enc->opb,flag,1);
    while(fragii<ncoded_fragis){
      for(run_count=0;fragii<ncoded_fragis;fragii++){
        int qii;
        qii=frags[coded_fragis[fragii]].qii;
        if(!qii)continue;
        if(qii-1!=flag)break;
        run_count++;
      }
      oc_sb_run_pack(&_enc->opb,run_count,flag,fragii>=ncoded_fragis);
      flag=!flag;
    }
  }
  
  /*Counts the tokens of each type used for the given range of coefficient
     indices in zig-zag order.
    _zzi_start:      The first zig-zag index to include.
    _zzi_end:        The first zig-zag index to not include.
    _token_counts_y: Returns the token counts for the Y' plane.
    _token_counts_c: Returns the token counts for the Cb and Cr planes.*/
  static void oc_enc_count_tokens(oc_enc_ctx *_enc,int _zzi_start,int _zzi_end,
   ptrdiff_t _token_counts_y[32],ptrdiff_t _token_counts_c[32]){
    const unsigned char *dct_tokens;
    ptrdiff_t            ndct_tokens;
    int                  pli;
    int                  zzi;
    ptrdiff_t            ti;
    memset(_token_counts_y,0,32*sizeof(*_token_counts_y));
    memset(_token_counts_c,0,32*sizeof(*_token_counts_c));
    for(zzi=_zzi_start;zzi<_zzi_end;zzi++){
      dct_tokens=_enc->dct_tokens[0][zzi];
      ndct_tokens=_enc->ndct_tokens[0][zzi];
      for(ti=_enc->dct_token_offs[0][zzi];ti<ndct_tokens;ti++){
        _token_counts_y[dct_tokens[ti]]++;
      }
    }
    for(pli=1;pli<3;pli++){
      for(zzi=_zzi_start;zzi<_zzi_end;zzi++){
        dct_tokens=_enc->dct_tokens[pli][zzi];
        ndct_tokens=_enc->ndct_tokens[pli][zzi];
        for(ti=_enc->dct_token_offs[pli][zzi];ti<ndct_tokens;ti++){
          _token_counts_c[dct_tokens[ti]]++;
        }
      }
    }
  }
  
  /*Computes the number of bits used for each of the potential Huffman code for
     the given list of token counts.
    The bits are added to whatever the current bit counts are.*/
  static void oc_enc_count_bits(oc_enc_ctx *_enc,int _hgi,
   const ptrdiff_t _token_counts[32],size_t _bit_counts[16]){
    int huffi;
    int huff_offs;
    int token;
    huff_offs=_hgi<<4;
    for(huffi=0;huffi<16;huffi++){
      for(token=0;token<32;token++){
        _bit_counts[huffi]+=
         _token_counts[token]*_enc->huff_codes[huffi+huff_offs][token].nbits;
      }
    }
  }
  
  /*Returns the Huffman index using the fewest number of bits.*/
  static int oc_select_huff_idx(size_t _bit_counts[16]){
    int best_huffi;
    int huffi;
    best_huffi=0;
    for(huffi=1;huffi<16;huffi++)if(_bit_counts[huffi]<_bit_counts[best_huffi]){
      best_huffi=huffi;
    }
    return best_huffi;
  }
  
  static void oc_enc_huff_group_pack(oc_enc_ctx *_enc,
   int _zzi_start,int _zzi_end,const int _huff_idxs[2]){
    int zzi;
    for(zzi=_zzi_start;zzi<_zzi_end;zzi++){
      int pli;
      for(pli=0;pli<3;pli++){
        const unsigned char *dct_tokens;
        const ogg_uint16_t  *extra_bits;
        ptrdiff_t            ndct_tokens;
        const th_huff_code  *huff_codes;
        ptrdiff_t            ti;
        dct_tokens=_enc->dct_tokens[pli][zzi];
        extra_bits=_enc->extra_bits[pli][zzi];
        ndct_tokens=_enc->ndct_tokens[pli][zzi];
        huff_codes=_enc->huff_codes[_huff_idxs[pli+1>>1]];
        for(ti=_enc->dct_token_offs[pli][zzi];ti<ndct_tokens;ti++){
          int token;
          int neb;
          token=dct_tokens[ti];
          oggpackB_write(&_enc->opb,huff_codes[token].pattern,
           huff_codes[token].nbits);
          neb=OC_DCT_TOKEN_EXTRA_BITS[token];
          if(neb)oggpackB_write(&_enc->opb,extra_bits[ti],neb);
        }
      }
    }
  }
  
  static void oc_enc_residual_tokens_pack(oc_enc_ctx *_enc){
    static const unsigned char  OC_HUFF_GROUP_MIN[6]={0,1,6,15,28,64};
    static const unsigned char *OC_HUFF_GROUP_MAX=OC_HUFF_GROUP_MIN+1;
    ptrdiff_t token_counts_y[32];
    ptrdiff_t token_counts_c[32];
    size_t    bits_y[16];
    size_t    bits_c[16];
    int       huff_idxs[2];
    int       frame_type;
    int       hgi;
    frame_type=_enc->state.frame_type;
    /*Choose which Huffman tables to use for the DC token list.*/
    oc_enc_count_tokens(_enc,0,1,token_counts_y,token_counts_c);
    memset(bits_y,0,sizeof(bits_y));
    memset(bits_c,0,sizeof(bits_c));
    oc_enc_count_bits(_enc,0,token_counts_y,bits_y);
    oc_enc_count_bits(_enc,0,token_counts_c,bits_c);
    huff_idxs[0]=oc_select_huff_idx(bits_y);
    huff_idxs[1]=oc_select_huff_idx(bits_c);
    /*Write the DC token list with the chosen tables.*/
    oggpackB_write(&_enc->opb,huff_idxs[0],4);
    oggpackB_write(&_enc->opb,huff_idxs[1],4);
    _enc->huff_idxs[frame_type][0][0]=(unsigned char)huff_idxs[0];
    _enc->huff_idxs[frame_type][0][1]=(unsigned char)huff_idxs[1];
    oc_enc_huff_group_pack(_enc,0,1,huff_idxs);
    /*Choose which Huffman tables to use for the AC token lists.*/
    memset(bits_y,0,sizeof(bits_y));
    memset(bits_c,0,sizeof(bits_c));
    for(hgi=1;hgi<5;hgi++){
      oc_enc_count_tokens(_enc,OC_HUFF_GROUP_MIN[hgi],OC_HUFF_GROUP_MAX[hgi],
       token_counts_y,token_counts_c);
      oc_enc_count_bits(_enc,hgi,token_counts_y,bits_y);
      oc_enc_count_bits(_enc,hgi,token_counts_c,bits_c);
    }
    huff_idxs[0]=oc_select_huff_idx(bits_y);
    huff_idxs[1]=oc_select_huff_idx(bits_c);
    /*Write the AC token lists using the chosen tables.*/
    oggpackB_write(&_enc->opb,huff_idxs[0],4);
    oggpackB_write(&_enc->opb,huff_idxs[1],4);
    _enc->huff_idxs[frame_type][1][0]=(unsigned char)huff_idxs[0];
    _enc->huff_idxs[frame_type][1][1]=(unsigned char)huff_idxs[1];
    for(hgi=1;hgi<5;hgi++){
      huff_idxs[0]+=16;
      huff_idxs[1]+=16;
      oc_enc_huff_group_pack(_enc,
       OC_HUFF_GROUP_MIN[hgi],OC_HUFF_GROUP_MAX[hgi],huff_idxs);
    }
  }
  
  static void oc_enc_frame_pack(oc_enc_ctx *_enc){
    oggpackB_reset(&_enc->opb);
    /*Only proceed if we have some coded blocks.
      If there are no coded blocks, we can drop this frame simply by emitting a
       0 byte packet.*/
    if(_enc->state.ntotal_coded_fragis>0){
      oc_enc_frame_header_pack(_enc);
      if(_enc->state.frame_type==OC_INTER_FRAME){
        /*Coded block flags, MB modes, and MVs are only needed for delta frames.*/
        oc_enc_coded_flags_pack(_enc);
        oc_enc_mb_modes_pack(_enc);
        oc_enc_mvs_pack(_enc);
      }
      oc_enc_block_qis_pack(_enc);
      oc_enc_tokenize_finish(_enc);
      oc_enc_residual_tokens_pack(_enc);
    }
    /*Success: Mark the packet as ready to be flushed.*/
    _enc->packet_state=OC_PACKET_READY;
  #if defined(OC_COLLECT_METRICS)
    oc_enc_mode_metrics_collect(_enc);
  #endif
  }
  
  
  void oc_enc_vtable_init_c(oc_enc_ctx *_enc){
    /*The implementations prefixed with oc_enc_ are encoder-specific.
      The rest we re-use from the decoder.*/
    _enc->opt_vtable.frag_sad=oc_enc_frag_sad_c;
    _enc->opt_vtable.frag_sad_thresh=oc_enc_frag_sad_thresh_c;
    _enc->opt_vtable.frag_sad2_thresh=oc_enc_frag_sad2_thresh_c;
    _enc->opt_vtable.frag_satd_thresh=oc_enc_frag_satd_thresh_c;
    _enc->opt_vtable.frag_satd2_thresh=oc_enc_frag_satd2_thresh_c;
    _enc->opt_vtable.frag_intra_satd=oc_enc_frag_intra_satd_c;
    _enc->opt_vtable.frag_sub=oc_enc_frag_sub_c;
    _enc->opt_vtable.frag_sub_128=oc_enc_frag_sub_128_c;
    _enc->opt_vtable.frag_copy2=oc_enc_frag_copy2_c;
    _enc->opt_vtable.frag_recon_intra=oc_frag_recon_intra_c;
    _enc->opt_vtable.frag_recon_inter=oc_frag_recon_inter_c;
    _enc->opt_vtable.fdct8x8=oc_enc_fdct8x8_c;
  }
  
  /*Initialize the macro block neighbor lists for MC analysis.
    This assumes that the entire mb_info memory region has been initialized with
     zeros.*/
  static void oc_enc_mb_info_init(oc_enc_ctx *_enc){
    oc_mb_enc_info    *embs;
    const signed char *mb_modes;
    unsigned           nhsbs;
    unsigned           nvsbs;
    unsigned           nhmbs;
    unsigned           nvmbs;
    unsigned           sby;
    mb_modes=_enc->state.mb_modes;
    embs=_enc->mb_info;
    nhsbs=_enc->state.fplanes[0].nhsbs;
    nvsbs=_enc->state.fplanes[0].nvsbs;
    nhmbs=_enc->state.nhmbs;
    nvmbs=_enc->state.nvmbs;
    for(sby=0;sby<nvsbs;sby++){
      unsigned sbx;
      for(sbx=0;sbx<nhsbs;sbx++){
        int quadi;
        for(quadi=0;quadi<4;quadi++){
          /*Because of the Hilbert curve ordering the macro blocks are
             visited in, the available neighbors change depending on where in
             a super block the macro block is located.
            Only the first three vectors are used in the median calculation
             for the optimal predictor, and so the most important should be
             listed first.
            Additional vectors are used, so there will always be at least 3,
             except for in the upper-left most macro block.*/
          /*The number of current neighbors for each macro block position.*/
          static const unsigned char NCNEIGHBORS[4]={4,3,2,4};
          /*The offset of each current neighbor in the X direction.*/
          static const signed char   CDX[4][4]={
            {-1,0,1,-1},
            {-1,0,-1,},
            {-1,-1},
            {-1,0,0,1}
          };
          /*The offset of each current neighbor in the Y direction.*/
          static const signed char   CDY[4][4]={
            {0,-1,-1,-1},
            {0,-1,-1},
            {0,-1},
            {0,-1,1,-1}
          };
          /*The offset of each previous neighbor in the X direction.*/
          static const signed char   PDX[4]={-1,0,1,0};
          /*The offset of each previous neighbor in the Y direction.*/
          static const signed char   PDY[4]={0,-1,0,1};
          unsigned mbi;
          int      mbx;
          int      mby;
          unsigned nmbi;
          int      nmbx;
          int      nmby;
          int      ni;
          mbi=(sby*nhsbs+sbx<<2)+quadi;
          if(mb_modes[mbi]==OC_MODE_INVALID)continue;
          mbx=2*sbx+(quadi>>1);
          mby=2*sby+(quadi+1>>1&1);
          /*Fill in the neighbors with current motion vectors available.*/
          for(ni=0;ni<NCNEIGHBORS[quadi];ni++){
            nmbx=mbx+CDX[quadi][ni];
            nmby=mby+CDY[quadi][ni];
            if(nmbx<0||nmbx>=nhmbs||nmby<0||nmby>=nvmbs)continue;
            nmbi=(nmby&~1)*nhmbs+((nmbx&~1)<<1)+OC_MB_MAP[nmby&1][nmbx&1];
            if(mb_modes[nmbi]==OC_MODE_INVALID)continue;
            embs[mbi].cneighbors[embs[mbi].ncneighbors++]=nmbi;
          }
          /*Fill in the neighbors with previous motion vectors available.*/
          for(ni=0;ni<4;ni++){
            nmbx=mbx+PDX[ni];
            nmby=mby+PDY[ni];
            if(nmbx<0||nmbx>=nhmbs||nmby<0||nmby>=nvmbs)continue;
            nmbi=(nmby&~1)*nhmbs+((nmbx&~1)<<1)+OC_MB_MAP[nmby&1][nmbx&1];
            if(mb_modes[nmbi]==OC_MODE_INVALID)continue;
            embs[mbi].pneighbors[embs[mbi].npneighbors++]=nmbi;
          }
        }
      }
    }
  }
  
  static int oc_enc_set_huffman_codes(oc_enc_ctx *_enc,
   const th_huff_code _codes[TH_NHUFFMAN_TABLES][TH_NDCT_TOKENS]){
    int ret;
    if(_enc==NULL)return TH_EFAULT;
    if(_enc->packet_state>OC_PACKET_SETUP_HDR)return TH_EINVAL;
    if(_codes==NULL)_codes=TH_VP31_HUFF_CODES;
    /*Validate the codes.*/
    oggpackB_reset(&_enc->opb);
    ret=oc_huff_codes_pack(&_enc->opb,_codes);
    if(ret<0)return ret;
    memcpy(_enc->huff_codes,_codes,sizeof(_enc->huff_codes));
    return 0;
  }
  
  /*Sets the quantization parameters to use.
    This may only be called before the setup header is written.
    If it is called multiple times, only the last call has any effect.
    _qinfo: The quantization parameters.
            These are described in more detail in theoraenc.h.
            This can be NULL, in which case the default quantization parameters
             will be used.*/
  static int oc_enc_set_quant_params(oc_enc_ctx *_enc,
   const th_quant_info *_qinfo){
    int qi;
    int pli;
    int qti;
    if(_enc==NULL)return TH_EFAULT;
    if(_enc->packet_state>OC_PACKET_SETUP_HDR)return TH_EINVAL;
    if(_qinfo==NULL)_qinfo=&TH_DEF_QUANT_INFO;
    /*TODO: Analyze for packing purposes instead of just doing a shallow copy.*/
    memcpy(&_enc->qinfo,_qinfo,sizeof(_enc->qinfo));
    for(qi=0;qi<64;qi++)for(pli=0;pli<3;pli++)for(qti=0;qti<2;qti++){
      _enc->state.dequant_tables[qi][pli][qti]=
       _enc->state.dequant_table_data[qi][pli][qti];
      _enc->enquant_tables[qi][pli][qti]=_enc->enquant_table_data[qi][pli][qti];
    }
    oc_enquant_tables_init(_enc->state.dequant_tables,
     _enc->enquant_tables,_qinfo);
    memcpy(_enc->state.loop_filter_limits,_qinfo->loop_filter_limits,
     sizeof(_enc->state.loop_filter_limits));
    oc_enquant_qavg_init(_enc->log_qavg,_enc->state.dequant_tables,
     _enc->state.info.pixel_fmt);
    return 0;
  }
  
  static void oc_enc_clear(oc_enc_ctx *_enc);
  
  static int oc_enc_init(oc_enc_ctx *_enc,const th_info *_info){
    th_info   info;
    size_t    mcu_nmbs;
    ptrdiff_t mcu_nfrags;
    int       hdec;
    int       vdec;
    int       ret;
    int       pli;
    /*Clean up the requested settings.*/
    memcpy(&info,_info,sizeof(info));
    info.version_major=TH_VERSION_MAJOR;
    info.version_minor=TH_VERSION_MINOR;
    info.version_subminor=TH_VERSION_SUB;
    if(info.quality>63)info.quality=63;
    if(info.quality<0)info.quality=32;
    if(info.target_bitrate<0)info.target_bitrate=0;
    /*Initialize the shared encoder/decoder state.*/
    ret=oc_state_init(&_enc->state,&info,4);
    if(ret<0)return ret;
    _enc->mb_info=_ogg_calloc(_enc->state.nmbs,sizeof(*_enc->mb_info));
    _enc->frag_dc=_ogg_calloc(_enc->state.nfrags,sizeof(*_enc->frag_dc));
    _enc->coded_mbis=
     (unsigned *)_ogg_malloc(_enc->state.nmbs*sizeof(*_enc->coded_mbis));
    hdec=!(_enc->state.info.pixel_fmt&1);
    vdec=!(_enc->state.info.pixel_fmt&2);
    /*If chroma is sub-sampled in the vertical direction, we have to encode two
       super block rows of Y' for each super block row of Cb and Cr.*/
    _enc->mcu_nvsbs=1<<vdec;
    mcu_nmbs=_enc->mcu_nvsbs*_enc->state.fplanes[0].nhsbs*(size_t)4;
    mcu_nfrags=4*mcu_nmbs+(8*mcu_nmbs>>hdec+vdec);
    _enc->mcu_skip_ssd=(unsigned *)_ogg_malloc(
     mcu_nfrags*sizeof(*_enc->mcu_skip_ssd));
    for(pli=0;pli<3;pli++){
      _enc->dct_tokens[pli]=(unsigned char **)oc_malloc_2d(64,
       _enc->state.fplanes[pli].nfrags,sizeof(**_enc->dct_tokens));
      _enc->extra_bits[pli]=(ogg_uint16_t **)oc_malloc_2d(64,
       _enc->state.fplanes[pli].nfrags,sizeof(**_enc->extra_bits));
    }
  #if defined(OC_COLLECT_METRICS)
    _enc->frag_satd=_ogg_calloc(_enc->state.nfrags,sizeof(*_enc->frag_satd));
    _enc->frag_ssd=_ogg_calloc(_enc->state.nfrags,sizeof(*_enc->frag_ssd));
  #endif
  #if defined(OC_X86_ASM)
    oc_enc_vtable_init_x86(_enc);
  #else
    oc_enc_vtable_init_c(_enc);
  #endif
    _enc->keyframe_frequency_force=1<<_enc->state.info.keyframe_granule_shift;
    _enc->state.qis[0]=_enc->state.info.quality;
    _enc->state.nqis=1;
    oc_rc_state_init(&_enc->rc,_enc);
    oggpackB_writeinit(&_enc->opb);
    if(_enc->mb_info==NULL||_enc->frag_dc==NULL||_enc->coded_mbis==NULL||
     _enc->mcu_skip_ssd==NULL||_enc->dct_tokens[0]==NULL||
     _enc->dct_tokens[1]==NULL||_enc->dct_tokens[2]==NULL||
     _enc->extra_bits[0]==NULL||_enc->extra_bits[1]==NULL||
     _enc->extra_bits[2]==NULL
  #if defined(OC_COLLECT_METRICS)
     ||_enc->frag_satd==NULL||_enc->frag_ssd==NULL
  #endif
     ){
      oc_enc_clear(_enc);
      return TH_EFAULT;
    }
    oc_mode_scheme_chooser_init(&_enc->chooser);
    oc_enc_mb_info_init(_enc);
    memset(_enc->huff_idxs,0,sizeof(_enc->huff_idxs));
    /*Reset the packet-out state machine.*/
    _enc->packet_state=OC_PACKET_INFO_HDR;
    _enc->dup_count=0;
    _enc->nqueued_dups=0;
    _enc->prev_dup_count=0;
    /*Enable speed optimizations up through early skip by default.*/
    _enc->sp_level=OC_SP_LEVEL_EARLY_SKIP;
    /*Disable VP3 compatibility by default.*/
    _enc->vp3_compatible=0;
    /*No INTER frames coded yet.*/
    _enc->coded_inter_frame=0;
    memcpy(_enc->huff_codes,TH_VP31_HUFF_CODES,sizeof(_enc->huff_codes));
    oc_enc_set_quant_params(_enc,NULL);
    return 0;
  }
  
  static void oc_enc_clear(oc_enc_ctx *_enc){
    int pli;
    oc_rc_state_clear(&_enc->rc);
  #if defined(OC_COLLECT_METRICS)
    oc_enc_mode_metrics_dump(_enc);
  #endif
    oggpackB_writeclear(&_enc->opb);
  #if defined(OC_COLLECT_METRICS)
    _ogg_free(_enc->frag_ssd);
    _ogg_free(_enc->frag_satd);
  #endif
    for(pli=3;pli-->0;){
      oc_free_2d(_enc->extra_bits[pli]);
      oc_free_2d(_enc->dct_tokens[pli]);
    }
    _ogg_free(_enc->mcu_skip_ssd);
    _ogg_free(_enc->coded_mbis);
    _ogg_free(_enc->frag_dc);
    _ogg_free(_enc->mb_info);
    oc_state_clear(&_enc->state);
  }
  
  static void oc_enc_drop_frame(th_enc_ctx *_enc){
    /*Use the previous frame's reconstruction.*/
    _enc->state.ref_frame_idx[OC_FRAME_SELF]=
     _enc->state.ref_frame_idx[OC_FRAME_PREV];
    /*Flag motion vector analysis about the frame drop.*/
    _enc->prevframe_dropped=1;
    /*Zero the packet.*/
    oggpackB_reset(&_enc->opb);
  }
  
  static void oc_enc_compress_keyframe(oc_enc_ctx *_enc,int _recode){
    if(_enc->state.info.target_bitrate>0){
      _enc->state.qis[0]=oc_enc_select_qi(_enc,OC_INTRA_FRAME,
       _enc->state.curframe_num>0);
      _enc->state.nqis=1;
    }
    oc_enc_calc_lambda(_enc,OC_INTRA_FRAME);
    oc_enc_analyze_intra(_enc,_recode);
    oc_enc_frame_pack(_enc);
    /*On the first frame, the previous call was an initial dry-run to prime
       feed-forward statistics.*/
    if(!_recode&&_enc->state.curframe_num==0){
      if(_enc->state.info.target_bitrate>0){
        oc_enc_update_rc_state(_enc,oggpackB_bytes(&_enc->opb)<<3,
                               OC_INTRA_FRAME,_enc->state.qis[0],1,0);
      }
      oc_enc_compress_keyframe(_enc,1);
    }
  }
  
  static void oc_enc_compress_frame(oc_enc_ctx *_enc,int _recode){
    if(_enc->state.info.target_bitrate>0){
      _enc->state.qis[0]=oc_enc_select_qi(_enc,OC_INTER_FRAME,1);
      _enc->state.nqis=1;
    }
    oc_enc_calc_lambda(_enc,OC_INTER_FRAME);
    if(oc_enc_analyze_inter(_enc,_enc->rc.twopass!=2,_recode)){
      /*Mode analysis thinks this should have been a keyframe; start over.*/
      oc_enc_compress_keyframe(_enc,1);
    }
    else{
      oc_enc_frame_pack(_enc);
      if(!_enc->coded_inter_frame){
        /*On the first INTER frame, the previous call was an initial dry-run to
           prime feed-forward statistics.*/
        _enc->coded_inter_frame=1;
        if(_enc->state.info.target_bitrate>0){
          /*Rate control also needs to prime.*/
          oc_enc_update_rc_state(_enc,oggpackB_bytes(&_enc->opb)<<3,
           OC_INTER_FRAME,_enc->state.qis[0],1,0);
        }
        oc_enc_compress_frame(_enc,1);
      }
    }
  }
  
  /*Set the granule position for the next packet to output based on the current
     internal state.*/
  static void oc_enc_set_granpos(oc_enc_ctx *_enc){
    unsigned dup_offs;
    /*Add an offset for the number of duplicate frames we've emitted so far.*/
    dup_offs=_enc->prev_dup_count-_enc->nqueued_dups;
    /*If the current frame was a keyframe, use it for the high part.*/
    if(_enc->state.frame_type==OC_INTRA_FRAME){
      _enc->state.granpos=(_enc->state.curframe_num+_enc->state.granpos_bias<<
       _enc->state.info.keyframe_granule_shift)+dup_offs;
    }
    /*Otherwise use the last keyframe in the high part and put the current frame
       in the low part.*/
    else{
      _enc->state.granpos=
       (_enc->state.keyframe_num+_enc->state.granpos_bias<<
       _enc->state.info.keyframe_granule_shift)
       +_enc->state.curframe_num-_enc->state.keyframe_num+dup_offs;
    }
  }
  
  
  th_enc_ctx *th_encode_alloc(const th_info *_info){
    oc_enc_ctx *enc;
    if(_info==NULL)return NULL;
    enc=_ogg_malloc(sizeof(*enc));
    if(enc==NULL||oc_enc_init(enc,_info)<0){
      _ogg_free(enc);
      return NULL;
    }
    return enc;
  }
  
  void th_encode_free(th_enc_ctx *_enc){
    if(_enc!=NULL){
      oc_enc_clear(_enc);
      _ogg_free(_enc);
    }
  }
  
  int th_encode_ctl(th_enc_ctx *_enc,int _req,void *_buf,size_t _buf_sz){
    switch(_req){
      case TH_ENCCTL_SET_HUFFMAN_CODES:{
        if(_buf==NULL&&_buf_sz!=0||
         _buf!=NULL&&_buf_sz!=sizeof(th_huff_table)*TH_NHUFFMAN_TABLES){
          return TH_EINVAL;
        }
        return oc_enc_set_huffman_codes(_enc,(const th_huff_table *)_buf);
      }break;
      case TH_ENCCTL_SET_QUANT_PARAMS:{
        if(_buf==NULL&&_buf_sz!=0||
         _buf!=NULL&&_buf_sz!=sizeof(th_quant_info)){
          return TH_EINVAL;
        }
        return oc_enc_set_quant_params(_enc,(th_quant_info *)_buf);
      }break;
      case TH_ENCCTL_SET_KEYFRAME_FREQUENCY_FORCE:{
        ogg_uint32_t keyframe_frequency_force;
        if(_enc==NULL||_buf==NULL)return TH_EFAULT;
        if(_buf_sz!=sizeof(keyframe_frequency_force))return TH_EINVAL;
        keyframe_frequency_force=*(ogg_uint32_t *)_buf;
        if(keyframe_frequency_force<=0)keyframe_frequency_force=1;
        if(_enc->packet_state==OC_PACKET_INFO_HDR){
          /*It's still early enough to enlarge keyframe_granule_shift.*/
          _enc->state.info.keyframe_granule_shift=OC_CLAMPI(
           _enc->state.info.keyframe_granule_shift,
           OC_ILOG_32(keyframe_frequency_force-1),31);
        }
        _enc->keyframe_frequency_force=OC_MINI(keyframe_frequency_force,
         (ogg_uint32_t)1U<<_enc->state.info.keyframe_granule_shift);
        *(ogg_uint32_t *)_buf=_enc->keyframe_frequency_force;
        return 0;
      }break;
      case TH_ENCCTL_SET_VP3_COMPATIBLE:{
        int vp3_compatible;
        if(_enc==NULL||_buf==NULL)return TH_EFAULT;
        if(_buf_sz!=sizeof(vp3_compatible))return TH_EINVAL;
        vp3_compatible=*(int *)_buf;
        _enc->vp3_compatible=vp3_compatible;
        if(oc_enc_set_huffman_codes(_enc,TH_VP31_HUFF_CODES)<0)vp3_compatible=0;
        if(oc_enc_set_quant_params(_enc,&TH_VP31_QUANT_INFO)<0)vp3_compatible=0;
        if(_enc->state.info.pixel_fmt!=TH_PF_420||
         _enc->state.info.pic_width<_enc->state.info.frame_width||
         _enc->state.info.pic_height<_enc->state.info.frame_height||
        /*If we have more than 4095 super blocks, VP3's RLE coding might
           overflow.
          We could overcome this by ensuring we flip the coded/not-coded flags on
           at least one super block in the frame, but we pick the simple solution
           of just telling the user the stream will be incompatible instead.
          It's unlikely the old VP3 codec would be able to decode streams at this
           resolution in real time in the first place.*/
         _enc->state.nsbs>4095){
          vp3_compatible=0;
        }
        *(int *)_buf=vp3_compatible;
        return 0;
      }break;
      case TH_ENCCTL_GET_SPLEVEL_MAX:{
        if(_enc==NULL||_buf==NULL)return TH_EFAULT;
        if(_buf_sz!=sizeof(int))return TH_EINVAL;
        *(int *)_buf=OC_SP_LEVEL_MAX;
        return 0;
      }break;
      case TH_ENCCTL_SET_SPLEVEL:{
        int speed;
        if(_enc==NULL||_buf==NULL)return TH_EFAULT;
        if(_buf_sz!=sizeof(speed))return TH_EINVAL;
        speed=*(int *)_buf;
        if(speed<0||speed>OC_SP_LEVEL_MAX)return TH_EINVAL;
        _enc->sp_level=speed;
        return 0;
      }break;
      case TH_ENCCTL_GET_SPLEVEL:{
        if(_enc==NULL||_buf==NULL)return TH_EFAULT;
        if(_buf_sz!=sizeof(int))return TH_EINVAL;
        *(int *)_buf=_enc->sp_level;
        return 0;
      }
      case TH_ENCCTL_SET_DUP_COUNT:{
        int dup_count;
        if(_enc==NULL||_buf==NULL)return TH_EFAULT;
        if(_buf_sz!=sizeof(dup_count))return TH_EINVAL;
        dup_count=*(int *)_buf;
        if(dup_count>=_enc->keyframe_frequency_force)return TH_EINVAL;
        _enc->dup_count=OC_MAXI(dup_count,0);
        return 0;
      }break;
      case TH_ENCCTL_SET_QUALITY:{
        int qi;
        if(_enc==NULL||_buf==NULL)return TH_EFAULT;
        if(_enc->state.info.target_bitrate>0)return TH_EINVAL;
        qi=*(int *)_buf;
        if(qi<0||qi>63)return TH_EINVAL;
        _enc->state.info.quality=qi;
        _enc->state.qis[0]=(unsigned char)qi;
        _enc->state.nqis=1;
        return 0;
      }break;
      case TH_ENCCTL_SET_BITRATE:{
        long bitrate;
        int  reset;
        if(_enc==NULL||_buf==NULL)return TH_EFAULT;
        bitrate=*(long *)_buf;
        if(bitrate<=0)return TH_EINVAL;
        reset=_enc->state.info.target_bitrate<=0;
        _enc->state.info.target_bitrate=bitrate>INT_MAX?INT_MAX:bitrate;
        if(reset)oc_rc_state_init(&_enc->rc,_enc);
        else oc_enc_rc_resize(_enc);
        return 0;
      }break;
      case TH_ENCCTL_SET_RATE_FLAGS:{
        int set;
        if(_enc==NULL||_buf==NULL)return TH_EFAULT;
        if(_buf_sz!=sizeof(set))return TH_EINVAL;
        if(_enc->state.info.target_bitrate<=0)return TH_EINVAL;
        set=*(int *)_buf;
        _enc->rc.drop_frames=set&TH_RATECTL_DROP_FRAMES;
        _enc->rc.cap_overflow=set&TH_RATECTL_CAP_OVERFLOW;
        _enc->rc.cap_underflow=set&TH_RATECTL_CAP_UNDERFLOW;
        return 0;
      }break;
      case TH_ENCCTL_SET_RATE_BUFFER:{
        int set;
        if(_enc==NULL||_buf==NULL)return TH_EFAULT;
        if(_buf_sz!=sizeof(set))return TH_EINVAL;
        if(_enc->state.info.target_bitrate<=0)return TH_EINVAL;
        set=*(int *)_buf;
        _enc->rc.buf_delay=set;
        oc_enc_rc_resize(_enc);
        *(int *)_buf=_enc->rc.buf_delay;
        return 0;
      }break;
      case TH_ENCCTL_2PASS_OUT:{
        if(_enc==NULL||_buf==NULL)return TH_EFAULT;
        if(_enc->state.info.target_bitrate<=0||
         _enc->state.curframe_num>=0&&_enc->rc.twopass!=1||
         _buf_sz!=sizeof(unsigned char *)){
          return TH_EINVAL;
        }
        return oc_enc_rc_2pass_out(_enc,(unsigned char **)_buf);
      }break;
      case TH_ENCCTL_2PASS_IN:{
        if(_enc==NULL)return TH_EFAULT;
        if(_enc->state.info.target_bitrate<=0||
         _enc->state.curframe_num>=0&&_enc->rc.twopass!=2){
          return TH_EINVAL;
        }
        return oc_enc_rc_2pass_in(_enc,_buf,_buf_sz);
      }break;
      default:return TH_EIMPL;
    }
  }
  
  int th_encode_flushheader(th_enc_ctx *_enc,th_comment *_tc,ogg_packet *_op){
    if(_enc==NULL)return TH_EFAULT;
    return oc_state_flushheader(&_enc->state,&_enc->packet_state,&_enc->opb,
     &_enc->qinfo,(const th_huff_table *)_enc->huff_codes,th_version_string(),
     _tc,_op);
  }
  
  static void oc_img_plane_copy_pad(th_img_plane *_dst,th_img_plane *_src,
   ogg_int32_t _pic_x,ogg_int32_t _pic_y,
   ogg_int32_t _pic_width,ogg_int32_t _pic_height){
    unsigned char *dst;
    int            dstride;
    ogg_uint32_t   frame_width;
    ogg_uint32_t   frame_height;
    ogg_uint32_t   y;
    frame_width=_dst->width;
    frame_height=_dst->height;
    /*If we have _no_ data, just encode a dull green.*/
    if(_pic_width==0||_pic_height==0){
      dst=_dst->data;
      dstride=_dst->stride;
      for(y=0;y<frame_height;y++){
        memset(dst,0,frame_width*sizeof(*dst));
        dst+=dstride;
      }
    }
    /*Otherwise, copy what we do have, and add our own padding.*/
    else{
      unsigned char *dst_data;
      unsigned char *src_data;
      unsigned char *src;
      int            sstride;
      ogg_uint32_t   x;
      /*Step 1: Copy the data we do have.*/
      dstride=_dst->stride;
      sstride=_src->stride;
      dst_data=_dst->data;
      src_data=_src->data;
      dst=dst_data+_pic_y*(ptrdiff_t)dstride+_pic_x;
      src=src_data+_pic_y*(ptrdiff_t)sstride+_pic_x;
      for(y=0;y<_pic_height;y++){
        memcpy(dst,src,_pic_width);
        dst+=dstride;
        src+=sstride;
      }
      /*Step 2: Perform a low-pass extension into the padding region.*/
      /*Left side.*/
      for(x=_pic_x;x-->0;){
        dst=dst_data+_pic_y*(ptrdiff_t)dstride+x;
        for(y=0;y<_pic_height;y++){
          dst[0]=(dst[1]<<1)+(dst-(dstride&-(y>0)))[1]
           +(dst+(dstride&-(y+1<_pic_height)))[1]+2>>2;
          dst+=dstride;
        }
      }
      /*Right side.*/
      for(x=_pic_x+_pic_width;x<frame_width;x++){
        dst=dst_data+_pic_y*(ptrdiff_t)dstride+x-1;
        for(y=0;y<_pic_height;y++){
          dst[1]=(dst[0]<<1)+(dst-(dstride&-(y>0)))[0]
           +(dst+(dstride&-(y+1<_pic_height)))[0]+2>>2;
          dst+=dstride;
        }
      }
      /*Top.*/
      dst=dst_data+_pic_y*(ptrdiff_t)dstride;
      for(y=_pic_y;y-->0;){
        for(x=0;x<frame_width;x++){
          (dst-dstride)[x]=(dst[x]<<1)+dst[x-(x>0)]
           +dst[x+(x+1<frame_width)]+2>>2;
        }
        dst-=dstride;
      }
      /*Bottom.*/
      dst=dst_data+(_pic_y+_pic_height)*(ptrdiff_t)dstride;
      for(y=_pic_y+_pic_height;y<frame_height;y++){
        for(x=0;x<frame_width;x++){
          dst[x]=((dst-dstride)[x]<<1)+(dst-dstride)[x-(x>0)]
           +(dst-dstride)[x+(x+1<frame_width)]+2>>2;
        }
        dst+=dstride;
      }
    }
  }
  
  int th_encode_ycbcr_in(th_enc_ctx *_enc,th_ycbcr_buffer _img){
    th_ycbcr_buffer img;
    int             cframe_width;
    int             cframe_height;
    int             cpic_width;
    int             cpic_height;
    int             cpic_x;
    int             cpic_y;
    int             hdec;
    int             vdec;
    int             pli;
    int             refi;
    int             drop;
    /*Step 1: validate parameters.*/
    if(_enc==NULL||_img==NULL)return TH_EFAULT;
    if(_enc->packet_state==OC_PACKET_DONE)return TH_EINVAL;
    if(_enc->rc.twopass&&_enc->rc.twopass_buffer_bytes==0)return TH_EINVAL;
    if((ogg_uint32_t)_img[0].width!=_enc->state.info.frame_width||
     (ogg_uint32_t)_img[0].height!=_enc->state.info.frame_height){
      return TH_EINVAL;
    }
    hdec=!(_enc->state.info.pixel_fmt&1);
    vdec=!(_enc->state.info.pixel_fmt&2);
    cframe_width=_enc->state.info.frame_width>>hdec;
    cframe_height=_enc->state.info.frame_height>>vdec;
    if(_img[1].width!=cframe_width||_img[2].width!=cframe_width||
     _img[1].height!=cframe_height||_img[2].height!=cframe_height){
      return TH_EINVAL;
    }
    /*Step 2: Copy the input to our internal buffer.
      This lets us add padding, if necessary, so we don't have to worry about
       dereferencing possibly invalid addresses, and allows us to use the same
       strides and fragment offsets for both the input frame and the reference
       frames.*/
    /*Flip the input buffer upside down.*/
    oc_ycbcr_buffer_flip(img,_img);
    oc_img_plane_copy_pad(_enc->state.ref_frame_bufs[OC_FRAME_IO]+0,img+0,
     _enc->state.info.pic_x,_enc->state.info.pic_y,
     _enc->state.info.pic_width,_enc->state.info.pic_height);
    cpic_x=_enc->state.info.pic_x>>hdec;
    cpic_y=_enc->state.info.pic_y>>vdec;
    cpic_width=(_enc->state.info.pic_x+_enc->state.info.pic_width+hdec>>hdec)
     -cpic_x;
    cpic_height=(_enc->state.info.pic_y+_enc->state.info.pic_height+vdec>>vdec)
     -cpic_y;
    for(pli=1;pli<3;pli++){
      oc_img_plane_copy_pad(_enc->state.ref_frame_bufs[OC_FRAME_IO]+pli,img+pli,
       cpic_x,cpic_y,cpic_width,cpic_height);
    }
    /*Step 3: Update the buffer state.*/
    if(_enc->state.ref_frame_idx[OC_FRAME_SELF]>=0){
      _enc->state.ref_frame_idx[OC_FRAME_PREV]=
       _enc->state.ref_frame_idx[OC_FRAME_SELF];
      if(_enc->state.frame_type==OC_INTRA_FRAME){
        /*The new frame becomes both the previous and gold reference frames.*/
        _enc->state.keyframe_num=_enc->state.curframe_num;
        _enc->state.ref_frame_idx[OC_FRAME_GOLD]=
         _enc->state.ref_frame_idx[OC_FRAME_SELF];
      }
    }
    /*Select a free buffer to use for the reconstructed version of this frame.*/
    for(refi=0;refi==_enc->state.ref_frame_idx[OC_FRAME_GOLD]||
     refi==_enc->state.ref_frame_idx[OC_FRAME_PREV];refi++);
    _enc->state.ref_frame_idx[OC_FRAME_SELF]=refi;
    _enc->state.curframe_num+=_enc->prev_dup_count+1;
    /*Step 4: Compress the frame.*/
    /*Start with a keyframe, and don't allow the generation of invalid files that
       overflow the keyframe_granule_shift.*/
    if(_enc->rc.twopass_force_kf||_enc->state.curframe_num==0||
     _enc->state.curframe_num-_enc->state.keyframe_num+_enc->dup_count>=
     _enc->keyframe_frequency_force){
      oc_enc_compress_keyframe(_enc,0);
      drop=0;
    }
    else{
      oc_enc_compress_frame(_enc,0);
      drop=1;
    }
    oc_restore_fpu(&_enc->state);
    /*drop currently indicates if the frame is droppable.*/
    if(_enc->state.info.target_bitrate>0){
      drop=oc_enc_update_rc_state(_enc,oggpackB_bytes(&_enc->opb)<<3,
       _enc->state.frame_type,_enc->state.qis[0],0,drop);
    }
    else drop=0;
    /*drop now indicates if the frame was dropped.*/
    if(drop)oc_enc_drop_frame(_enc);
    else _enc->prevframe_dropped=0;
    _enc->packet_state=OC_PACKET_READY;
    _enc->prev_dup_count=_enc->nqueued_dups=_enc->dup_count;
    _enc->dup_count=0;
  #if defined(OC_DUMP_IMAGES)
    oc_enc_set_granpos(_enc);
    oc_state_dump_frame(&_enc->state,OC_FRAME_IO,"src");
    oc_state_dump_frame(&_enc->state,OC_FRAME_SELF,"rec");
  #endif
    return 0;
  }
  
  int th_encode_packetout(th_enc_ctx *_enc,int _last_p,ogg_packet *_op){
    if(_enc==NULL||_op==NULL)return TH_EFAULT;
    if(_enc->packet_state==OC_PACKET_READY){
      _enc->packet_state=OC_PACKET_EMPTY;
      if(_enc->rc.twopass!=1){
        unsigned char *packet;
        packet=oggpackB_get_buffer(&_enc->opb);
        /*If there's no packet, malloc failed while writing; it's lost forever.*/
        if(packet==NULL)return TH_EFAULT;
        _op->packet=packet;
        _op->bytes=oggpackB_bytes(&_enc->opb);
      }
      /*For the first pass in 2-pass mode, don't emit any packet data.*/
      else{
        _op->packet=NULL;
        _op->bytes=0;
      }
    }
    else if(_enc->packet_state==OC_PACKET_EMPTY){
      if(_enc->nqueued_dups>0){
        _enc->nqueued_dups--;
        _op->packet=NULL;
        _op->bytes=0;
      }
      else{
        if(_last_p)_enc->packet_state=OC_PACKET_DONE;
        return 0;
      }
    }
    else return 0;
    _last_p=_last_p&&_enc->nqueued_dups<=0;
    _op->b_o_s=0;
    _op->e_o_s=_last_p;
    oc_enc_set_granpos(_enc);
    _op->packetno=th_granule_frame(_enc,_enc->state.granpos)+3;
    _op->granulepos=_enc->state.granpos;
    if(_last_p)_enc->packet_state=OC_PACKET_DONE;
    return 1+_enc->nqueued_dups;
  }
  