开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多媒体 > midi > 查看源码
dirac.c
资源名称：vlc-1.0.5.zip　[点击查看]
上传用户：kjfoods
上传日期：2020-07-06
资源大小：29949k
文件大小：37k
源码类别：

midi

开发平台：

Unix_Linux

dirac.c：源码内容
  1. /*****************************************************************************
  2.  * dirac.c: Dirac encoder module making use of libdirac (dirac-research).
  3.  *          (http://www.bbc.co.uk/rd/projects/dirac/index.shtml)
  4.  *          ##
  5.  *          ## NB, this is a temporary encoder only module until schroedinger
  6.  *          ## offers superior encoding quality than dirac-research
  7.  *          ##
  8.  *****************************************************************************
  9.  * Copyright (C) 2004-2008 the VideoLAN team
  10.  * $Id: f397ba281a829f9073778fc0356d9cfe7cd5b746 $
  11.  *
  12.  * Authors: Gildas Bazin <gbazin@videolan.org>
  13.  * Rewritten: David Flynn <davidf at rd.bbc.co.uk>
  14.  *
  15.  * This program is free software; you can redistribute it and/or modify
  16.  * it under the terms of the GNU General Public License as published by
  17.  * the Free Software Foundation; either version 2 of the License, or
  18.  * (at your option) any later version.
  19.  *
  20.  * This program is distributed in the hope that it will be useful,
  21.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  22.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  23.  * GNU General Public License for more details.
  24.  *
  25.  * You should have received a copy of the GNU General Public License
  26.  * along with this program; if not, write to the Free Software
  27.  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
  28.  *****************************************************************************/
  30. /*****************************************************************************
  31.  * Preamble
  32.  *****************************************************************************/
  33. #ifdef HAVE_CONFIG_H
  34. # include "config.h"
  35. #endif
  37. #include <limits.h>
  38. #include <assert.h>
  40. #include <vlc_common.h>
  41. #include <vlc_plugin.h>
  42. #include <vlc_codec.h>
  43. #include <vlc_sout.h>
  44. #include <vlc_vout.h>
  46. #include <libdirac_encoder/dirac_encoder.h>
  48. #ifndef DIRAC_RESEARCH_VERSION_ATLEAST
  49. # define DIRAC_RESEARCH_VERSION_ATLEAST(x,y,z) 0
  50. #endif
  52. /*****************************************************************************
  53.  * Local prototypes
  54.  *****************************************************************************/
  55. static int  OpenEncoder( vlc_object_t *p_this );
  56. static void CloseEncoder( vlc_object_t *p_this );
  57. static block_t *Encode( encoder_t *p_enc, picture_t *p_pict );
  59. #define ENC_CFG_PREFIX "sout-dirac-"
  61. #define ENC_QUALITY_FACTOR "quality"
  62. #define ENC_QUALITY_FACTOR_TEXT N_("Constant quality factor")
  63. #define ENC_QUALITY_FACTOR_LONGTEXT N_("If bitrate=0, use this value for constant quality")
  65. #define ENC_TARGETRATE "bitrate"
  66. #define ENC_TARGETRATE_TEXT N_("CBR bitrate (kbps)")
  67. #define ENC_TARGETRATE_LONGTEXT N_("A value > 0 enables constant bitrate mode")
  69. #define ENC_LOSSLESS "lossless"
  70. #define ENC_LOSSLESS_TEXT N_("Enable lossless coding")
  71. #define ENC_LOSSLESS_LONGTEXT N_("Lossless coding ignores bitrate and quality settings, " 
  72.                                  "allowing for perfect reproduction of the original")
  74. #define ENC_PREFILTER "prefilter"
  75. #define ENC_PREFILTER_TEXT N_("Prefilter")
  76. #define ENC_PREFILTER_LONGTEXT N_("Enable adaptive prefiltering")
  77. static const char *const enc_prefilter_list[] =
  78.   { "none", "cwm", "rectlp", "diaglp" };
  79. static const char *const enc_prefilter_list_text[] =
  80.   { N_("none"), N_("Centre Weighted Median"),
  81.     N_("Rectangular Linear Phase"), N_("Diagonal Linear Phase") };
  83. #define ENC_PREFILTER_STRENGTH "prefilter-strength"
  84. #define ENC_PREFILTER_STRENGTH_TEXT N_("Amount of prefiltering")
  85. #define ENC_PREFILTER_STRENGTH_LONGTEXT N_("Higher value implies more prefiltering")
  87. #define ENC_CHROMAFMT "chroma-fmt"
  88. #define ENC_CHROMAFMT_TEXT N_("Chroma format")
  89. #define ENC_CHROMAFMT_LONGTEXT N_("Picking chroma format will force a " 
  90.                                   "conversion of the video into that format")
  91. static const char *const enc_chromafmt_list[] =
  92.   { "420", "422", "444" };
  93. static const char *const enc_chromafmt_list_text[] =
  94.   { N_("4:2:0"), N_("4:2:2"), N_("4:4:4") };
  96. #define ENC_L1SEP "l1-sep"
  97. #define ENC_L1SEP_TEXT N_("Distance between 'P' frames")
  98. #define ENC_L1SEP_LONGTEXT ENC_L1SEP_TEXT
  100. #define ENC_L1NUM "num-l1"
  101. #define ENC_L1NUM_TEXT N_("Number of 'P' frames per GOP")
  102. #define ENC_L1NUM_LONGTEXT ENC_L1NUM_TEXT
  104. #define ENC_CODINGMODE "coding-mode"
  105. #define ENC_CODINGMODE_TEXT N_("Picture coding mode")
  106. #define ENC_CODINGMODE_LONGTEXT N_("Field coding is where interlaced fields are coded" 
  107.                                    " seperately as opposed to a pseudo-progressive frame")
  108. static const char *const enc_codingmode_list[] =
  109.   { "auto", "progressive", "field" };
  110. static const char *const enc_codingmode_list_text[] =
  111.   { N_("auto - let encoder decide based upon input (Best)"),
  112.     N_("force coding frame as single picture"),
  113.     N_("force coding frame as seperate interlaced fields"),
  114.   };
  116. #define ENC_MCBLK_WIDTH "mc-blk-width"
  117. #define ENC_MCBLK_WIDTH_TEXT N_("Width of motion compensation blocks")
  118. #define ENC_MCBLK_WIDTH_LONGTEXT ""
  120. #define ENC_MCBLK_HEIGHT "mc-blk-height"
  121. #define ENC_MCBLK_HEIGHT_TEXT N_("Height of motion compensation blocks")
  122. #define ENC_MCBLK_HEIGHT_LONGTEXT ""
  124. /* also known as XBSEP and YBSEP */
  125. #define ENC_MCBLK_OVERLAP "mc-blk-overlap"
  126. #define ENC_MCBLK_OVERLAP_TEXT N_("Block overlap (%)")
  127. #define ENC_MCBLK_OVERLAP_LONGTEXT N_("Amount that each motion block should " 
  128.                                        "be overlapped by its neighbours")
  130. /* advanced option only */
  131. #define ENC_MCBLK_XBLEN "mc-blk-xblen"
  132. #define ENC_MCBLK_XBLEN_TEXT N_("xblen")
  133. #define ENC_MCBLK_XBLEN_LONGTEXT N_("Total horizontal block length including overlaps")
  135. /* advanded option only */
  136. #define ENC_MCBLK_YBLEN "mc-blk-yblen"
  137. #define ENC_MCBLK_YBLEN_TEXT N_("yblen")
  138. #define ENC_MCBLK_YBLEN_LONGTEXT N_("Total vertical block length including overlaps")
  140. #define ENC_MVPREC "mv-prec"
  141. #define ENC_MVPREC_TEXT N_("Motion vector precision")
  142. #define ENC_MVPREC_LONGTEXT N_("Motion vector precision in pels.")
  143. static const char *const enc_mvprec_list[] =
  144.   { "1", "1/2", "1/4", "1/8" };
  146. #define ENC_ME_SIMPLESEARCH "me-simple-search"
  147. #define ENC_ME_SIMPLESEARCH_TEXT N_("Simple ME search area x:y")
  148. #define ENC_ME_SIMPLESEARCH_LONGTEXT N_("(Not recommended) Perform a simple (non hierarchical " 
  149.                                         "block matching motion vector search with search range " 
  150.                                         "of +/-x, +/-y")
  152. #define ENC_ME_COMBINED "me-combined"
  153. #define ENC_ME_COMBINED_TEXT N_("Three component motion estimation")
  154. #define ENC_ME_COMBINED_LONGTEXT N_("Use chroma as part of the motion estimation process")
  156. #define ENC_DWTINTRA "dwt-intra"
  157. #define ENC_DWTINTRA_TEXT N_("Intra picture DWT filter")
  158. #define ENC_DWTINTRA_LONGTEXT ENC_DWTINTRA_TEXT
  160. #define ENC_DWTINTER "dwt-inter"
  161. #define ENC_DWTINTER_TEXT N_("Inter picture DWT filter")
  162. #define ENC_DWTINTER_LONGTEXT ENC_DWTINTER_TEXT
  164. #define ENC_DWTDEPTH "dwt-depth"
  165. #define ENC_DWTDEPTH_TEXT N_("Number of DWT iterations")
  166. #define ENC_DWTDEPTH_LONGTEXT N_("Also known as DWT levels")
  168. /* advanced option only */
  169. #define ENC_MULTIQUANT "multi-quant"
  170. #define ENC_MULTIQUANT_TEXT N_("Enable multiple quantizers")
  171. #define ENC_MULTIQUANT_LONGTEXT N_("Enable multiple quantizers per subband (one per codeblock)")
  173. /* advanced option only */
  174. #define ENC_SPARTITION "spartition"
  175. #define ENC_SPARTITION_TEXT N_("Enable spatial partitioning")
  176. #define ENC_SPARTITION_LONGTEXT ENC_SPARTITION_TEXT
  178. #define ENC_NOAC "noac"
  179. #define ENC_NOAC_TEXT N_("Disable arithmetic coding")
  180. #define ENC_NOAC_LONGTEXT N_("Use variable length codes instead, useful for very high bitrates")
  182. /* visual modelling */
  183. /* advanced option only */
  184. #define ENC_CPD "cpd"
  185. #define ENC_CPD_TEXT N_("cycles per degree")
  186. #define ENC_CPD_LONGTEXT ENC_CPD_TEXT
  188. static const char *const ppsz_enc_options[] = {
  189.     ENC_QUALITY_FACTOR, ENC_TARGETRATE, ENC_LOSSLESS, ENC_PREFILTER, ENC_PREFILTER_STRENGTH,
  190.     ENC_CHROMAFMT, ENC_L1SEP, ENC_L1NUM, ENC_CODINGMODE,
  191.     ENC_MCBLK_WIDTH, ENC_MCBLK_HEIGHT, ENC_MCBLK_OVERLAP,
  192.     ENC_MVPREC, ENC_ME_SIMPLESEARCH, ENC_ME_COMBINED,
  193.     ENC_DWTINTRA, ENC_DWTINTER, ENC_DWTDEPTH,
  194.     ENC_MULTIQUANT, ENC_SPARTITION, ENC_NOAC,
  195.     ENC_CPD,
  196.     NULL
  197. };
  200. /*****************************************************************************
  201.  * Module descriptor
  202.  *****************************************************************************/
  204. vlc_module_begin()
  205.     set_category( CAT_INPUT )
  206.     set_subcategory( SUBCAT_INPUT_VCODEC )
  207.     set_description( N_("Dirac video encoder using dirac-research library") )
  208.     set_capability( "encoder", 100 )
  209.     set_callbacks( OpenEncoder, CloseEncoder )
  211.     add_float( ENC_CFG_PREFIX ENC_QUALITY_FACTOR, 5.5, NULL,
  212.                ENC_QUALITY_FACTOR_TEXT, ENC_QUALITY_FACTOR_LONGTEXT, false )
  213.     change_float_range(0., 10.);
  215.     add_integer( ENC_CFG_PREFIX ENC_TARGETRATE, -1, NULL,
  216.                  ENC_TARGETRATE_TEXT, ENC_TARGETRATE_LONGTEXT, false )
  217.     change_integer_range(-1, INT_MAX);
  219.     add_bool( ENC_CFG_PREFIX ENC_LOSSLESS, false, NULL,
  220.               ENC_LOSSLESS_TEXT, ENC_LOSSLESS_LONGTEXT, false )
  222.     add_string( ENC_CFG_PREFIX ENC_PREFILTER, "diaglp", NULL,
  223.                 ENC_PREFILTER_TEXT, ENC_PREFILTER_LONGTEXT, false )
  224.     change_string_list( enc_prefilter_list, enc_prefilter_list_text, 0 );
  226.     add_integer( ENC_CFG_PREFIX ENC_PREFILTER_STRENGTH, 1, NULL,
  227.                  ENC_PREFILTER_STRENGTH_TEXT, ENC_PREFILTER_STRENGTH_LONGTEXT, false )
  228.     change_integer_range(0, 10);
  230.     add_string( ENC_CFG_PREFIX ENC_CHROMAFMT, "420", NULL,
  231.                 ENC_CHROMAFMT_TEXT, ENC_CHROMAFMT_LONGTEXT, false )
  232.     change_string_list( enc_chromafmt_list, enc_chromafmt_list_text, 0 );
  234.     add_integer( ENC_CFG_PREFIX ENC_L1SEP, -1, NULL,
  235.                  ENC_L1SEP_TEXT, ENC_L1SEP_LONGTEXT, false )
  236.     change_integer_range(-1, INT_MAX);
  238.     add_integer( ENC_CFG_PREFIX ENC_L1NUM, -1, NULL,
  239.                  ENC_L1NUM_TEXT, ENC_L1NUM_LONGTEXT, false )
  240.     change_integer_range(-1, INT_MAX);
  242.     add_string( ENC_CFG_PREFIX ENC_CODINGMODE, "auto", NULL,
  243.                 ENC_CODINGMODE_TEXT, ENC_CODINGMODE_LONGTEXT, false )
  244.     change_string_list( enc_codingmode_list, enc_codingmode_list_text, 0 );
  246.     add_string( ENC_CFG_PREFIX ENC_MVPREC, "1/2", NULL,
  247.                 ENC_MVPREC_TEXT, ENC_MVPREC_LONGTEXT, false )
  248.     change_string_list( enc_mvprec_list, enc_mvprec_list, 0 );
  250.     add_integer( ENC_CFG_PREFIX ENC_MCBLK_WIDTH, -1, NULL,
  251.                  ENC_MCBLK_WIDTH_TEXT, ENC_MCBLK_WIDTH_LONGTEXT, false )
  252.     add_deprecated_alias( ENC_CFG_PREFIX ENC_MCBLK_XBLEN );
  253.     change_integer_range(-1, INT_MAX);
  255.     add_integer( ENC_CFG_PREFIX ENC_MCBLK_HEIGHT, -1, NULL,
  256.                  ENC_MCBLK_HEIGHT, ENC_MCBLK_HEIGHT_LONGTEXT, false )
  257.     add_deprecated_alias( ENC_CFG_PREFIX ENC_MCBLK_YBLEN );
  258.     change_integer_range(-1, INT_MAX);
  260.     add_integer( ENC_CFG_PREFIX ENC_MCBLK_OVERLAP, -1, NULL,
  261.                  ENC_MCBLK_OVERLAP_TEXT, ENC_MCBLK_OVERLAP_LONGTEXT, false )
  262.     change_integer_range(-1, 100);
  264.     /* advanced option only */
  265.     add_integer( ENC_CFG_PREFIX ENC_MCBLK_XBLEN, -1, NULL,
  266.                  ENC_MCBLK_XBLEN_TEXT, ENC_MCBLK_XBLEN_LONGTEXT, true )
  267.     change_integer_range(-1, INT_MAX);
  268.     /* advanced option only */
  269.     add_integer( ENC_CFG_PREFIX ENC_MCBLK_YBLEN, -1, NULL,
  270.                  ENC_MCBLK_YBLEN_TEXT, ENC_MCBLK_YBLEN_LONGTEXT, true )
  271.     change_integer_range(-1, INT_MAX);
  273.     add_string( ENC_CFG_PREFIX ENC_ME_SIMPLESEARCH, "", NULL,
  274.               ENC_ME_SIMPLESEARCH_TEXT, ENC_ME_SIMPLESEARCH_LONGTEXT, false )
  276. #if DIRAC_RESEARCH_VERSION_ATLEAST(1,0,1)
  277.     add_bool( ENC_CFG_PREFIX ENC_ME_COMBINED, true, NULL,
  278.               ENC_ME_COMBINED_TEXT, ENC_ME_COMBINED_LONGTEXT, false )
  279. #endif
  281.     add_integer( ENC_CFG_PREFIX ENC_DWTINTRA, -1, NULL,
  282.                  ENC_DWTINTRA_TEXT, ENC_DWTINTRA_LONGTEXT, false )
  283.     change_integer_range(-1, 6);
  285.     add_integer( ENC_CFG_PREFIX ENC_DWTINTER, -1, NULL,
  286.                  ENC_DWTINTER_TEXT, ENC_DWTINTER_LONGTEXT, false )
  287.     change_integer_range(-1, 6);
  289.     add_integer( ENC_CFG_PREFIX ENC_DWTDEPTH, -1, NULL,
  290.                  ENC_DWTDEPTH_TEXT, ENC_DWTDEPTH_LONGTEXT, false )
  291.     change_integer_range(-1, 4);
  293.     /* advanced option only */
  294.     /* NB, unforunately vlc doesn't have a concept of 'dont care' */
  295.     add_integer( ENC_CFG_PREFIX ENC_MULTIQUANT, -1, NULL,
  296.                  ENC_MULTIQUANT_TEXT, ENC_MULTIQUANT_LONGTEXT, true )
  297.     change_integer_range(-1, 1);
  299.     /* advanced option only */
  300.     /* NB, unforunately vlc doesn't have a concept of 'dont care' */
  301.     add_integer( ENC_CFG_PREFIX ENC_SPARTITION, -1, NULL,
  302.                  ENC_SPARTITION_TEXT, ENC_SPARTITION_LONGTEXT, true )
  303.     change_integer_range(-1, 1);
  305.     add_bool( ENC_CFG_PREFIX ENC_NOAC, false, NULL,
  306.               ENC_NOAC_TEXT, ENC_NOAC_LONGTEXT, false )
  308.     /* advanced option only */
  309.     add_float( ENC_CFG_PREFIX ENC_CPD, -1, NULL,
  310.                ENC_CPD_TEXT, ENC_CPD_LONGTEXT, true )
  311.     change_integer_range(-1, INT_MAX);
  312. vlc_module_end()
  314. /*****************************************************************************
  315.  * picture_pts_t : store pts alongside picture number, not carried through
  316.  * encoder
  317.  *****************************************************************************/
  318. struct picture_pts_t
  319. {
  320.    bool b_empty;      /* entry is invalid */
  321.    uint32_t u_pnum;  /* dirac picture number */
  322.    mtime_t i_pts;    /* associated pts */
  323. };
  325. /*****************************************************************************
  326.  * encoder_sys_t : dirac encoder descriptor
  327.  *****************************************************************************/
  328. #define PTS_TLB_SIZE 256
  329. struct encoder_sys_t
  330. {
  331.     dirac_encoder_t *p_dirac;
  332.     dirac_encoder_context_t ctx;
  333.     bool b_auto_field_coding;
  335.     uint8_t *p_buffer_in;
  336.     int i_buffer_in;
  337.     uint32_t i_input_picnum;
  338.     block_fifo_t *p_dts_fifo;
  340.     int i_buffer_out;
  341.     uint8_t *p_buffer_out;
  342.     block_t *p_chain;
  344.     struct picture_pts_t pts_tlb[PTS_TLB_SIZE];
  345.     mtime_t i_pts_offset;
  346.     mtime_t i_field_time;
  347. };
  349. static struct
  350. {
  351.     unsigned int i_height;
  352.     int i_approx_fps;
  353.     VideoFormat i_vf;
  354. } dirac_format_guess[] = {
  355.     /* Important: Keep this list ordered in ascending picture height */
  356.     {1, 0, VIDEO_FORMAT_CUSTOM},
  357.     {120, 15, VIDEO_FORMAT_QSIF525},
  358.     {144, 12, VIDEO_FORMAT_QCIF},
  359.     {240, 15, VIDEO_FORMAT_SIF525},
  360.     {288, 12, VIDEO_FORMAT_CIF},
  361.     {480, 30, VIDEO_FORMAT_SD_480I60},
  362.     {480, 15, VIDEO_FORMAT_4SIF525},
  363.     {576, 12, VIDEO_FORMAT_4CIF},
  364.     {576, 25, VIDEO_FORMAT_SD_576I50},
  365.     {720, 50, VIDEO_FORMAT_HD_720P50},
  366.     {720, 60, VIDEO_FORMAT_HD_720P60},
  367.     {1080, 24, VIDEO_FORMAT_DIGI_CINEMA_2K24},
  368.     {1080, 25, VIDEO_FORMAT_HD_1080I50},
  369.     {1080, 30, VIDEO_FORMAT_HD_1080I60},
  370.     {1080, 50, VIDEO_FORMAT_HD_1080P50},
  371.     {1080, 60, VIDEO_FORMAT_HD_1080P60},
  372.     {2160, 24, VIDEO_FORMAT_DIGI_CINEMA_4K24},
  373.     {2160, 50, VIDEO_FORMAT_UHDTV_4K50},
  374.     {2160, 60, VIDEO_FORMAT_UHDTV_4K60},
  375.     {3840, 50, VIDEO_FORMAT_UHDTV_8K50},
  376.     {3840, 60, VIDEO_FORMAT_UHDTV_8K60},
  377.     {0, 0, 0},
  378. };
  380. /*****************************************************************************
  381.  * ResetPTStlb: Purge all entries in @p_dec@'s PTS-tlb
  382.  *****************************************************************************/
  383. static void ResetPTStlb( encoder_t *p_enc )
  384. {
  385.     encoder_sys_t *p_sys = p_enc->p_sys;
  386.     for( int i=0; i<PTS_TLB_SIZE; i++)
  387.     {
  388.         p_sys->pts_tlb[i].b_empty = true;
  389.     }
  390. }
  392. /*****************************************************************************
  393.  * StorePicturePTS: Store the PTS value for a particular picture number
  394.  *****************************************************************************/
  395. static void StorePicturePTS( encoder_t *p_enc, uint32_t u_pnum, mtime_t i_pts )
  396. {
  397.     encoder_sys_t *p_sys = p_enc->p_sys;
  399.     for( int i=0; i<PTS_TLB_SIZE; i++ )
  400.     {
  401.         if( p_sys->pts_tlb[i].b_empty )
  402.         {
  403.             p_sys->pts_tlb[i].u_pnum = u_pnum;
  404.             p_sys->pts_tlb[i].i_pts = i_pts;
  405.             p_sys->pts_tlb[i].b_empty = false;
  407.             return;
  408.         }
  409.     }
  411.     msg_Err( p_enc, "Could not store PTS %"PRId64" for frame %u", i_pts, u_pnum );
  412. }
  414. /*****************************************************************************
  415.  * GetPicturePTS: Retrieve the PTS value for a particular picture number
  416.  *****************************************************************************/
  417. static mtime_t GetPicturePTS( encoder_t *p_enc, uint32_t u_pnum )
  418. {
  419.     encoder_sys_t *p_sys = p_enc->p_sys;
  421.     for( int i=0; i<PTS_TLB_SIZE; i++ )
  422.     {
  423.         if( !p_sys->pts_tlb[i].b_empty &&
  424.             p_sys->pts_tlb[i].u_pnum == u_pnum )
  425.         {
  426.              p_sys->pts_tlb[i].b_empty = true;
  427.              return p_sys->pts_tlb[i].i_pts;
  428.         }
  429.     }
  431.     msg_Err( p_enc, "Could not retrieve PTS for picture %u", u_pnum );
  432.     return 0;
  433. }
  435. /*****************************************************************************
  436.  * OpenEncoder: probe the encoder and return score
  437.  *****************************************************************************/
  438. static int OpenEncoder( vlc_object_t *p_this )
  439. {
  440.     encoder_t *p_enc = (encoder_t *)p_this;
  441.     encoder_sys_t *p_sys = p_enc->p_sys;
  442.     int i_tmp;
  443.     float f_tmp;
  444.     char *psz_tmp;
  446.     if( p_enc->fmt_out.i_codec != VLC_FOURCC('d','r','a','c') &&
  447.         !p_enc->b_force )
  448.     {
  449.         return VLC_EGENERIC;
  450.     }
  452.     if( !p_enc->fmt_in.video.i_frame_rate || !p_enc->fmt_in.video.i_frame_rate_base ||
  453.         !p_enc->fmt_in.video.i_height || !p_enc->fmt_in.video.i_width )
  454.     {
  455.         msg_Err( p_enc, "Framerate and picture dimensions must be non-zero" );
  456.         return VLC_EGENERIC;
  457.     }
  459.     /* Allocate the memory needed to store the decoder's structure */
  460.     if( ( p_sys = calloc( 1, sizeof(*p_sys) ) ) == NULL )
  461.         return VLC_ENOMEM;
  463.     p_enc->p_sys = p_sys;
  464.     p_enc->pf_encode_video = Encode;
  465.     p_enc->fmt_out.i_codec = VLC_FOURCC('d','r','a','c');
  466.     p_enc->fmt_out.i_cat = VIDEO_ES;
  468.     if( ( p_sys->p_dts_fifo = block_FifoNew() ) == NULL )
  469.     {
  470.         CloseEncoder( p_this );
  471.         return VLC_ENOMEM;
  472.     }
  474.     ResetPTStlb( p_enc );
  476.     /* guess the video format based upon number of lines and picture height */
  477.     int i = 0;
  478.     VideoFormat guessed_video_fmt = VIDEO_FORMAT_CUSTOM;
  479.     /* Pick the dirac_video_format in this order of preference:
  480.      *  1. an exact match in frame height and an approximate fps match
  481.      *  2. the previous preset with a smaller number of lines.
  482.      */
  483.     do
  484.     {
  485.         if( dirac_format_guess[i].i_height > p_enc->fmt_in.video.i_height )
  486.         {
  487.             guessed_video_fmt = dirac_format_guess[i-1].i_vf;
  488.             break;
  489.         }
  490.         if( dirac_format_guess[i].i_height != p_enc->fmt_in.video.i_height )
  491.             continue;
  492.         int src_fps = p_enc->fmt_in.video.i_frame_rate / p_enc->fmt_in.video.i_frame_rate_base;
  493.         int delta_fps = abs( dirac_format_guess[i].i_approx_fps - src_fps );
  494.         if( delta_fps > 2 )
  495.             continue;
  497.         guessed_video_fmt = dirac_format_guess[i].i_vf;
  498.         break;
  499.     } while( dirac_format_guess[++i].i_height );
  501.     dirac_encoder_context_init( &p_sys->ctx, guessed_video_fmt );
  503.     /* constants set from the input video format */
  504.     p_sys->ctx.src_params.width = p_enc->fmt_in.video.i_width;
  505.     p_sys->ctx.src_params.height = p_enc->fmt_in.video.i_height;
  506.     p_sys->ctx.src_params.frame_rate.numerator = p_enc->fmt_in.video.i_frame_rate;
  507.     p_sys->ctx.src_params.frame_rate.denominator = p_enc->fmt_in.video.i_frame_rate_base;
  508.     unsigned u_asr_num, u_asr_den;
  509.     vlc_ureduce( &u_asr_num, &u_asr_den,
  510.                  p_enc->fmt_in.video.i_height * p_enc->fmt_in.video.i_aspect,
  511.                  p_enc->fmt_in.video.i_width * VOUT_ASPECT_FACTOR,
  512.                  0 );
  513.     p_sys->ctx.src_params.pix_asr.numerator = u_asr_num;
  514.     p_sys->ctx.src_params.pix_asr.denominator = u_asr_den;
  516.     config_ChainParse( p_enc, ENC_CFG_PREFIX, ppsz_enc_options, p_enc->p_cfg );
  518.     psz_tmp = var_GetString( p_enc, ENC_CFG_PREFIX ENC_CHROMAFMT );
  519.     if( !psz_tmp )
  520.         goto error;
  521.     else if( !strcmp( psz_tmp, "420" ) ) {
  522.         p_enc->fmt_in.i_codec = VLC_FOURCC('I','4','2','0');
  523.         p_enc->fmt_in.video.i_bits_per_pixel = 12;
  524.         p_sys->ctx.src_params.chroma = format420;
  525.         p_sys->i_buffer_in = p_enc->fmt_in.video.i_width * p_enc->fmt_in.video.i_height * 3 / 2;
  526.     }
  527.     else if( !strcmp( psz_tmp, "422" ) ) {
  528.         p_enc->fmt_in.i_codec = VLC_FOURCC('I','4','2','2');
  529.         p_enc->fmt_in.video.i_bits_per_pixel = 16;
  530.         p_sys->ctx.src_params.chroma = format422;
  531.         p_sys->i_buffer_in = p_enc->fmt_in.video.i_width * p_enc->fmt_in.video.i_height * 2;
  532.     }
  533.     else if( !strcmp( psz_tmp, "444" ) ) {
  534.         p_enc->fmt_in.i_codec = VLC_FOURCC('I','4','4','4');
  535.         p_enc->fmt_in.video.i_bits_per_pixel = 24;
  536.         p_sys->ctx.src_params.chroma = format444;
  537.         p_sys->i_buffer_in = p_enc->fmt_in.video.i_width * p_enc->fmt_in.video.i_height * 3;
  538.     }
  539.     else {
  540.         msg_Err( p_enc, "Invalid chroma format: %s", psz_tmp );
  541.         free( psz_tmp );
  542.         goto error;
  543.     }
  544.     free( psz_tmp );
  546.     p_sys->ctx.enc_params.qf = var_GetFloat( p_enc, ENC_CFG_PREFIX ENC_QUALITY_FACTOR );
  548.     /* use bitrate from sout-transcode-vb in kbps */
  549.     p_sys->ctx.enc_params.trate = p_enc->fmt_out.i_bitrate / 1000;
  550.     i_tmp = var_GetInteger( p_enc, ENC_CFG_PREFIX ENC_TARGETRATE );
  551.     if( i_tmp > -1 )
  552.         p_sys->ctx.enc_params.trate = i_tmp;
  553.     p_enc->fmt_out.i_bitrate = p_sys->ctx.enc_params.trate * 1000;
  555.     p_sys->ctx.enc_params.lossless = var_GetBool( p_enc, ENC_CFG_PREFIX ENC_LOSSLESS );
  557.     psz_tmp = var_GetString( p_enc, ENC_CFG_PREFIX ENC_PREFILTER );
  558.     if( !psz_tmp )
  559.         goto error;
  560.     else if( !strcmp( psz_tmp, "none" ) ) {
  561.         p_sys->ctx.enc_params.prefilter = NO_PF;
  562.     }
  563.     else if( !strcmp( psz_tmp, "cwm" ) ) {
  564.         p_sys->ctx.enc_params.prefilter = CWM;
  565.     }
  566.     else if( !strcmp( psz_tmp, "rectlp" ) ) {
  567.         p_sys->ctx.enc_params.prefilter = RECTLP;
  568.     }
  569.     else if( !strcmp( psz_tmp, "diaglp" ) ) {
  570.         p_sys->ctx.enc_params.prefilter = DIAGLP;
  571.     }
  572.     else {
  573.         msg_Err( p_enc, "Invalid prefilter: %s", psz_tmp );
  574.         free( psz_tmp );
  575.         goto error;
  576.     }
  577.     free( psz_tmp );
  579.     p_sys->ctx.enc_params.prefilter_strength =
  580.         var_GetInteger( p_enc, ENC_CFG_PREFIX ENC_PREFILTER_STRENGTH );
  582.     i_tmp = var_GetInteger( p_enc, ENC_CFG_PREFIX ENC_L1SEP );
  583.     if( i_tmp > -1 )
  584.         p_sys->ctx.enc_params.L1_sep = i_tmp;
  586.     i_tmp = var_GetInteger( p_enc, ENC_CFG_PREFIX ENC_L1NUM );
  587.     if( i_tmp > -1 )
  588.         p_sys->ctx.enc_params.num_L1 = i_tmp;
  590.     psz_tmp = var_GetString( p_enc, ENC_CFG_PREFIX ENC_CODINGMODE );
  591.     if( !psz_tmp )
  592.         goto error;
  593.     else if( !strcmp( psz_tmp, "auto" ) ) {
  594.         p_sys->b_auto_field_coding = true;
  595.     }
  596.     else if( !strcmp( psz_tmp, "progressive" ) ) {
  597.         p_sys->b_auto_field_coding = false;
  598.         p_sys->ctx.enc_params.picture_coding_mode = 0;
  599.     }
  600.     else if( !strcmp( psz_tmp, "field" ) ) {
  601.         p_sys->b_auto_field_coding = false;
  602.         p_sys->ctx.enc_params.picture_coding_mode = 1;
  603.     }
  604.     else {
  605.         msg_Err( p_enc, "Invalid codingmode: %s", psz_tmp );
  606.         free( psz_tmp );
  607.         goto error;
  608.     }
  609.     free( psz_tmp );
  611.     psz_tmp = var_GetString( p_enc, ENC_CFG_PREFIX ENC_MVPREC );
  612.     if( !psz_tmp )
  613.         goto error;
  614.     else if( !strcmp( psz_tmp, "1" ) ) {
  615.         p_sys->ctx.enc_params.mv_precision = MV_PRECISION_PIXEL;
  616.     }
  617.     else if( !strcmp( psz_tmp, "1/2" ) ) {
  618.         p_sys->ctx.enc_params.mv_precision = MV_PRECISION_HALF_PIXEL;
  619.     }
  620.     else if( !strcmp( psz_tmp, "1/4" ) ) {
  621.         p_sys->ctx.enc_params.mv_precision = MV_PRECISION_QUARTER_PIXEL;
  622.     }
  623.     else if( !strcmp( psz_tmp, "1/8" ) ) {
  624.         p_sys->ctx.enc_params.mv_precision = MV_PRECISION_EIGHTH_PIXEL;
  625.     }
  626.     else {
  627.         msg_Err( p_enc, "Invalid mv-prec: %s", psz_tmp );
  628.         free( psz_tmp );
  629.         goto error;
  630.     }
  631.     free( psz_tmp );
  633.     /*
  634.      * {x,y}b{len,sep} must be multiples of 4
  635.      */
  636.     i_tmp = var_GetInteger( p_enc, ENC_CFG_PREFIX ENC_MCBLK_WIDTH );
  637.     if( i_tmp > -1 )
  638.         p_sys->ctx.enc_params.xbsep = i_tmp / 4 * 4;
  640.     i_tmp = var_GetInteger( p_enc, ENC_CFG_PREFIX ENC_MCBLK_HEIGHT );
  641.     if( i_tmp > -1 )
  642.         p_sys->ctx.enc_params.ybsep = i_tmp / 4 * 4;
  644.     i_tmp = var_GetInteger( p_enc, ENC_CFG_PREFIX ENC_MCBLK_OVERLAP );
  645.     if( i_tmp > -1 ) {
  646.         p_sys->ctx.enc_params.xblen = p_sys->ctx.enc_params.xbsep * (100 + i_tmp) / 400 * 4;
  647.         p_sys->ctx.enc_params.yblen = p_sys->ctx.enc_params.ybsep * (100 + i_tmp) / 400 * 4;
  648.     }
  650.     /*
  651.      * {x,y}blen >= {x,y}bsep
  652.      * {x,y}blen <= 2* {x,y}bsep
  653.      */
  654.     i_tmp = var_GetInteger( p_enc, ENC_CFG_PREFIX ENC_MCBLK_XBLEN );
  655.     if( i_tmp > -1 ) {
  656.         int xblen = __MAX( i_tmp, p_sys->ctx.enc_params.xbsep );
  657.         xblen = __MIN( xblen, 2 * p_sys->ctx.enc_params.xbsep );
  658.         p_sys->ctx.enc_params.xblen = xblen;
  659.     }
  661.     i_tmp = var_GetInteger( p_enc, ENC_CFG_PREFIX ENC_MCBLK_YBLEN );
  662.     if( i_tmp > -1 ) {
  663.         int yblen = __MAX( i_tmp, p_sys->ctx.enc_params.ybsep );
  664.         yblen = __MIN( yblen, 2 * p_sys->ctx.enc_params.ybsep );
  665.         p_sys->ctx.enc_params.yblen = yblen;
  666.     }
  668.     psz_tmp = var_GetString( p_enc, ENC_CFG_PREFIX ENC_ME_SIMPLESEARCH );
  669.     if( !psz_tmp )
  670.         goto error;
  671.     if( *psz_tmp != '' ) {
  672.         /* of the form [0-9]+:[0-9]+ */
  673.         char *psz_start = psz_tmp;
  674.         char *psz_end = psz_tmp;
  675.         p_sys->ctx.enc_params.x_range_me = strtol(psz_start, &psz_end, 10);
  676.         if( *psz_end != ':'  || psz_end == psz_start ) {
  677.             msg_Err( p_enc, "Invalid simple search range: %s", psz_tmp );
  678.             free( psz_tmp );
  679.             goto error;
  680.         }
  681.         psz_start = ++psz_end;
  682.         p_sys->ctx.enc_params.y_range_me = strtol(psz_start, &psz_end, 10);
  683.         if( *psz_end != ''  || psz_end == psz_start ) {
  684.             msg_Err( p_enc, "Invalid simple search range: %s", psz_tmp );
  685.             free( psz_tmp );
  686.             goto error;
  687.         }
  688.         if( p_sys->ctx.enc_params.x_range_me < 0 ||
  689.             p_sys->ctx.enc_params.y_range_me < 0 )
  690.         {
  691.             msg_Err( p_enc, "Invalid negative simple search range: %s", psz_tmp );
  692.             free( psz_tmp );
  693.             goto error;
  694.         }
  695.         p_sys->ctx.enc_params.full_search = 1;
  696.     }
  697.     free( psz_tmp );
  699. #if DIRAC_RESEARCH_VERSION_ATLEAST(1,0,1)
  700.     p_sys->ctx.enc_params.combined_me = var_GetBool( p_enc, ENC_CFG_PREFIX ENC_ME_COMBINED );
  701. #endif
  703.     i_tmp = var_GetInteger( p_enc, ENC_CFG_PREFIX ENC_DWTINTRA );
  704.     if( i_tmp > -1 )
  705.         p_sys->ctx.enc_params.intra_wlt_filter = i_tmp;
  707.     i_tmp = var_GetInteger( p_enc, ENC_CFG_PREFIX ENC_DWTINTER );
  708.     if( i_tmp > -1 )
  709.         p_sys->ctx.enc_params.inter_wlt_filter = i_tmp;
  711.     i_tmp = var_GetInteger( p_enc, ENC_CFG_PREFIX ENC_DWTDEPTH );
  712.     if( i_tmp > -1 )
  713.         p_sys->ctx.enc_params.wlt_depth = i_tmp;
  715.     i_tmp = var_GetInteger( p_enc, ENC_CFG_PREFIX ENC_MULTIQUANT );
  716.     if( i_tmp > -1 )
  717.         p_sys->ctx.enc_params.multi_quants = i_tmp;
  719.     i_tmp = var_GetInteger( p_enc, ENC_CFG_PREFIX ENC_SPARTITION );
  720.     if( i_tmp > -1 )
  721.         p_sys->ctx.enc_params.spatial_partition = i_tmp;
  723.     p_sys->ctx.enc_params.using_ac = !var_GetBool( p_enc, ENC_CFG_PREFIX ENC_NOAC );
  725.     f_tmp = var_GetFloat( p_enc, ENC_CFG_PREFIX ENC_CPD );
  726.     if( f_tmp > -1 )
  727.         p_sys->ctx.enc_params.cpd = f_tmp;
  729.     /* Allocate the buffer for inputing frames into the encoder */
  730.     if( ( p_sys->p_buffer_in = malloc( p_sys->i_buffer_in ) ) == NULL )
  731.     {
  732.         CloseEncoder( p_this );
  733.         return VLC_ENOMEM;
  734.     }
  736.     /* Set up output buffer */
  737.     /* Unfortunately it isn't possible to determine if the buffer
  738.      * is too small (and then reallocate it) */
  739.     p_sys->i_buffer_out = 4096 + p_sys->i_buffer_in;
  740.     if( ( p_sys->p_buffer_out = malloc( p_sys->i_buffer_out ) ) == NULL )
  741.     {
  742.         CloseEncoder( p_this );
  743.         return VLC_ENOMEM;
  744.     }
  746.     return VLC_SUCCESS;
  747. error:
  748.     CloseEncoder( p_this );
  749.     return VLC_EGENERIC;
  750. }
  752. /* Attempt to find dirac picture number in an encapsulation unit */
  753. static int ReadDiracPictureNumber( uint32_t *p_picnum, block_t *p_block )
  754. {
  755.     uint32_t u_pos = 4;
  756.     /* protect against falling off the edge */
  757.     while( u_pos + 13 < p_block->i_buffer )
  758.     {
  759.         /* find the picture startcode */
  760.         if( p_block->p_buffer[u_pos] & 0x08 )
  761.         {
  762.             *p_picnum = GetDWBE( p_block->p_buffer + u_pos + 9 );
  763.             return 1;
  764.         }
  765.         /* skip to the next dirac data unit */
  766.         uint32_t u_npo = GetDWBE( p_block->p_buffer + u_pos + 1 );
  767.         assert( u_npo <= UINT32_MAX - u_pos );
  768.         if( u_npo == 0 )
  769.             u_npo = 13;
  770.         u_pos += u_npo;
  771.     }
  772.     return 0;
  773. }
  775. /****************************************************************************
  776.  * Encode: the whole thing
  777.  ****************************************************************************
  778.  * This function spits out encapsulation units.
  779.  ****************************************************************************/
  780. static block_t *Encode( encoder_t *p_enc, picture_t *p_pic )
  781. {
  782.     encoder_sys_t *p_sys = p_enc->p_sys;
  783.     block_t *p_block, *p_output_chain = NULL;
  784.     int i_plane, i_line, i_width, i_src_stride;
  785.     uint8_t *p_dst;
  787.     /* we only know if the sequence is interlaced when the first
  788.      * picture arrives, so final setup is done here */
  789.     /* XXX todo, detect change of interlace */
  790.     p_sys->ctx.src_params.topfieldfirst = p_pic->b_top_field_first;
  791.     p_sys->ctx.src_params.source_sampling = !p_pic->b_progressive;
  793.     if( p_sys->b_auto_field_coding )
  794.         p_sys->ctx.enc_params.picture_coding_mode = !p_pic->b_progressive;
  796.     if( !p_sys->p_dirac )
  797.     {
  798.         date_t date;
  799.         /* Initialise the encoder with the encoder context */
  800.         p_sys->p_dirac = dirac_encoder_init( &p_sys->ctx, 0 );
  801.         if( !p_sys->p_dirac )
  802.         {
  803.             msg_Err( p_enc, "Failed to initialize dirac encoder" );
  804.             p_enc->b_error = 1;
  805.             return NULL;
  806.         }
  807.         date_Init( &date, p_enc->fmt_in.video.i_frame_rate, p_enc->fmt_in.video.i_frame_rate_base );
  808. #if DIRAC_RESEARCH_VERSION_ATLEAST(1,0,2)
  809.         int i_delayinpics = dirac_encoder_pts_offset( p_sys->p_dirac );
  810.         i_delayinpics /= p_sys->ctx.enc_params.picture_coding_mode + 1;
  811.         date_Increment( &date, i_delayinpics );
  812. #else
  813.         date_Increment( &date, 1 );
  814. #endif
  815.         p_sys->i_pts_offset = date_Get( &date );
  817.         /* picture_coding_mode = 1 == FIELD_CODING, two pictures are produced
  818.          * for each frame input. Calculate time between fields for offsetting
  819.          * the second field later. */
  820.         if( 1 == p_sys->ctx.enc_params.picture_coding_mode )
  821.         {
  822.             date_Set( &date, 0 );
  823.             date_Increment( &date, 1 );
  824.             p_sys->i_field_time = date_Get( &date ) / 2;
  825.         }
  826.     }
  828.     /* Copy input picture into encoder input buffer (stride by stride) */
  829.     /* Would be lovely to just pass the picture in, but there is noway for the
  830.      * library to free it */
  831.     p_dst = p_sys->p_buffer_in;
  832.     for( i_plane = 0; i_plane < p_pic->i_planes; i_plane++ )
  833.     {
  834.         uint8_t *p_src = p_pic->p[i_plane].p_pixels;
  835.         i_width = p_pic->p[i_plane].i_visible_pitch;
  836.         i_src_stride = p_pic->p[i_plane].i_pitch;
  838.         for( i_line = 0; i_line < p_pic->p[i_plane].i_visible_lines; i_line++ )
  839.         {
  840.             vlc_memcpy( p_dst, p_src, i_width );
  841.             p_dst += i_width;
  842.             p_src += i_src_stride;
  843.         }
  844.     }
  846.     /* Load one frame of data into encoder */
  847.     if( dirac_encoder_load( p_sys->p_dirac, p_sys->p_buffer_in,
  848.                             p_sys->i_buffer_in ) < 0 )
  849.     {
  850.         msg_Dbg( p_enc, "dirac_encoder_load() error" );
  851.         return NULL;
  852.     }
  854.     /* store pts in a lookaside buffer, so that the same pts may
  855.      * be used for the picture in coded order */
  856.     StorePicturePTS( p_enc, p_sys->i_input_picnum, p_pic->date );
  857.     p_sys->i_input_picnum++;
  859.     /* store dts in a queue, so that they appear in order in
  860.      * coded order */
  861.     p_block = block_New( p_enc, 1 );
  862.     if( !p_block )
  863.     {
  864.         p_enc->b_error = 1;
  865.         return NULL;
  866.     }
  867.     p_block->i_dts = p_pic->date - p_sys->i_pts_offset;
  868.     block_FifoPut( p_sys->p_dts_fifo, p_block );
  869.     p_block = NULL;
  871.     /* for field coding mode, insert an extra value into both the
  872.      * pts lookaside buffer and dts queue, offset to correspond
  873.      * to a one field delay. */
  874.     if( 1 == p_sys->ctx.enc_params.picture_coding_mode )
  875.     {
  876.         StorePicturePTS( p_enc, p_sys->i_input_picnum, p_pic->date + p_sys->i_field_time );
  877.         p_sys->i_input_picnum++;
  879.         p_block = block_New( p_enc, 1 );
  880.         if( !p_block )
  881.         {
  882.             p_enc->b_error = 1;
  883.             return NULL;
  884.         }
  885.         p_block->i_dts = p_pic->date - p_sys->i_pts_offset + p_sys->i_field_time;
  886.         block_FifoPut( p_sys->p_dts_fifo, p_block );
  887.         p_block = NULL;
  888.     }
  890.     dirac_encoder_state_t state;
  891.     /* Retrieve encoded frames from encoder */
  892.     do
  893.     {
  894.         p_sys->p_dirac->enc_buf.buffer = p_sys->p_buffer_out;
  895.         p_sys->p_dirac->enc_buf.size = p_sys->i_buffer_out;
  896.         state = dirac_encoder_output( p_sys->p_dirac );
  897.         switch( state )
  898.         {
  899.         case ENC_STATE_AVAIL: {
  900.             uint32_t pic_num;
  902.             /* extract data from encoder temporary buffer. */
  903.             p_block = block_New( p_enc, p_sys->p_dirac->enc_buf.size );
  904.             if( !p_block )
  905.             {
  906.                 p_enc->b_error = 1;
  907.                 return NULL;
  908.             }
  909.             memcpy( p_block->p_buffer, p_sys->p_dirac->enc_buf.buffer,
  910.                     p_sys->p_dirac->enc_buf.size );
  912.             /* if some flags were set for a previous block, prevent
  913.              * them from getting lost */
  914.             if( p_sys->p_chain )
  915.                 p_block->i_flags |= p_sys->p_chain->i_flags;
  917.             /* store all extracted blocks in a chain and gather up when an
  918.              * entire encapsulation unit is avaliable (ends with a picture) */
  919.             block_ChainAppend( &p_sys->p_chain, p_block );
  921.             /* Presence of a Sequence header indicates a seek point */
  922.             if( 0 == p_block->p_buffer[4] )
  923.             {
  924.                 p_block->i_flags |= BLOCK_FLAG_TYPE_I;
  926.                 if( !p_enc->fmt_out.p_extra ) {
  927.                     const uint8_t eos[] = { 'B','B','C','D',0x10,0,0,0,13,0,0,0,0 };
  928.                     uint32_t len = GetDWBE( p_block->p_buffer + 5 );
  929.                     /* if it hasn't been done so far, stash a copy of the
  930.                      * sequence header for muxers such as ogg */
  931.                     /* The OggDirac spec advises that a Dirac EOS DataUnit
  932.                      * is appended to the sequence header to allow guard
  933.                      * against poor streaming servers */
  934.                     /* XXX, should this be done using the packetizer ? */
  935.                     p_enc->fmt_out.p_extra = malloc( len + sizeof(eos) );
  936.                     if( !p_enc->fmt_out.p_extra )
  937.                     {
  938.                         p_enc->b_error = 1;
  939.                         return NULL;
  940.                     }
  941.                     memcpy( p_enc->fmt_out.p_extra, p_block->p_buffer, len);
  942.                     memcpy( (uint8_t*)p_enc->fmt_out.p_extra + len, eos, sizeof(eos) );
  943.                     SetDWBE( (uint8_t*)p_enc->fmt_out.p_extra + len + 10, len );
  944.                     p_enc->fmt_out.i_extra = len + sizeof(eos);
  945.                 }
  946.             }
  948.             if( ReadDiracPictureNumber( &pic_num, p_block ) )
  949.             {
  950.                 /* Finding a picture terminates an ecapsulation unit, gather
  951.                  * all data and output; use the next dts value queued up
  952.                  * and find correct pts in the tlb */
  953.                 p_block = block_FifoGet( p_sys->p_dts_fifo );
  954.                 p_sys->p_chain->i_dts = p_block->i_dts;
  955.                 p_sys->p_chain->i_pts = GetPicturePTS( p_enc, pic_num );
  956.                 block_Release( p_block );
  957.                 block_ChainAppend( &p_output_chain, block_ChainGather( p_sys->p_chain ) );
  958.                 p_sys->p_chain = NULL;
  959.             } else {
  960.                 p_block = NULL;
  961.             }
  962.             break;
  963.             }
  965.         case ENC_STATE_BUFFER:
  966.             break;
  967.         case ENC_STATE_INVALID:
  968.         default:
  969.             break;
  970.         }
  971.     } while( state == ENC_STATE_AVAIL );
  973.     return p_output_chain;
  974. }
  976. /*****************************************************************************
  977.  * CloseEncoder: dirac encoder destruction
  978.  *****************************************************************************/
  979. static void CloseEncoder( vlc_object_t *p_this )
  980. {
  981.     encoder_t *p_enc = (encoder_t *)p_this;
  982.     encoder_sys_t *p_sys = p_enc->p_sys;
  984.     /* Free the encoder resources */
  985.     if( p_sys->p_dirac )
  986.         dirac_encoder_close( p_sys->p_dirac );
  988.     free( p_sys->p_buffer_in );
  989.     free( p_sys->p_buffer_out );
  991.     if( p_sys->p_dts_fifo )
  992.         block_FifoRelease( p_sys->p_dts_fifo );
  993.     block_ChainRelease( p_sys->p_chain );
  995.     free( p_sys );
  996. }