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

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

midi

开发平台：

Unix_Linux

dirac.c：源码内容
  1. /*****************************************************************************
  2.  * dirac.c
  3.  *****************************************************************************
  4.  * Copyright (C) 2008 the VideoLAN team
  5.  * $Id: 75f9ce5796c3c6fc74f12cbc2066dc93b31dcc0b $
  6.  *
  7.  * Authors: David Flynn <davidf@rd.bbc.co.uk>
  8.  *
  9.  * This program is free software; you can redistribute it and/or modify
  10.  * it under the terms of the GNU General Public License as published by
  11.  * the Free Software Foundation; either version 2 of the License
  12.  * (at your option) any later version.
  13.  *
  14.  * This program is distributed in the hope that it will be useful,
  15.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17.  * GNU General Public License for more details.
  18.  *
  19.  * You should have received a copy of the GNU General Public License
  20.  * along with this program; if not, write to the Free Software
  21.  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
  22.  *****************************************************************************/
  24. /* Dirac packetizer, formed of three parts:
  25.  *  1) Bitstream synchroniser (dirac_DoSync)
  26.  *      - Given an arbitary sequence of bytes, extract whole Dirac Data Units
  27.  *      - Maps timestamps in supplied block_t's to the extracted Data Unit
  28.  *        A time stamp applies to the next Data Unit to commence at, or after
  29.  *        the first byte of the block_t with the timestamp.
  30.  *  2) Encapsulation Unit generation (dirac_BuildEncapsulationUnit)
  31.  *      - Takes multiple well formed Dirac Data Units and forms them into a
  32.  *        single encapsulation unit, suitable for muxing.
  33.  *      - Sorts out any time stamps so that they only apply to pictures.
  34.  *  3) Timestamp generator (dirac_TimeGenPush)
  35.  *      - Many streams will not be correctly timestamped, ie, DTS&PTS for
  36.  *        every encapsulation unit.  Timestamp generator syncs to avaliable
  37.  *        timestamps and produces DTS&PTS for each encapsulation unit.
  38.  *      - For 'Occasional' missing PTS|DTS:
  39.  *          Missing timestamp is generated using interpolation from last
  40.  *          known good values.
  41.  *      - for All PTS missing:
  42.  *          It is assumed that DTS values are fake, and are actually
  43.  *          in the sequence of the PTS values at the output of a decoder.
  44.  *          Fill in PTS by copying from DTS (accounting for reordering,
  45.  *          by simulating reorder buffer); adjust DTS to provide correct
  46.  *          value.  This is how demuxers like AVI work.
  47.  *      - for All DTS missing:
  48.  *          (Ie, PTS is present), reorder buffer is simulated to determine
  49.  *          PTS for each encapsulation unit.
  50.  *      - NB, doesn't handle all pts missing with real dts. (no way to
  51.  *        distinguish from the fake dts case.)
  52.  *
  53.  *  DIRAC_NON_DATED is used to show a block should not have a time stamp
  54.  *  associated (ie, don't interpolate a counter).  At the ouput, these
  55.  *  blocks get dated with the last used timestamp (or are merged with
  56.  *  another encapsulation unit).
  57.  */
  59. /*****************************************************************************
  60.  * Preamble
  61.  *****************************************************************************/
  63. #ifdef HAVE_CONFIG_H
  64. # include "config.h"
  65. #endif
  67. #include <assert.h>
  68. #include <vlc_common.h>
  69. #include <vlc_plugin.h>
  70. #include <vlc_codec.h>
  71. #include <vlc_block.h>
  73. #include "vlc_bits.h"
  74. #include "vlc_block_helper.h"
  76. #define SANITIZE_PREV_PARSE_OFFSET 1
  78. /*****************************************************************************
  79.  * Module descriptor
  80.  *****************************************************************************/
  81. static int  Open ( vlc_object_t * );
  82. static void Close( vlc_object_t * );
  84. vlc_module_begin()
  85.     set_category( CAT_SOUT )
  86.     set_subcategory( SUBCAT_SOUT_PACKETIZER )
  87.     set_description( N_("Dirac packetizer") )
  88.     set_capability( "packetizer", 50 )
  89.     set_callbacks( Open, Close )
  90. vlc_module_end()
  92. /*****************************************************************************
  93.  * Local prototypes
  94.  *****************************************************************************/
  95. struct decoder_sys_t
  96. {
  97.     /* sync state */
  98.     block_bytestream_t bytestream;
  99.     int i_state;
  100.     size_t i_offset;
  101.     uint32_t u_last_npo;
  102.     /* recovered timestamp from bytesteram for use
  103.      * by synchroniser: should only get reset by the
  104.      * synchronizer upon a discontinuity sentinel */
  105.     mtime_t i_sync_pts;
  106.     mtime_t i_sync_dts;
  108.     /* build encapsulation unit state */
  109.     block_t *p_eu; /*< Current encapsulation unit being built */
  110.     block_t **pp_eu_last;
  111.     uint32_t u_eu_last_npo; /* last next_parse_offset at input to encapsulation */
  112.     mtime_t i_eu_pts;
  113.     mtime_t i_eu_dts;
  115.     /* timestamp generator state */
  116.     date_t dts; /*< timegen decode clock, increments at picture rate */
  117.     bool b_dts; /*< timegen decode clock valid */
  119.     bool b_pts; /*< timegen presentation time valid */
  120.     mtime_t i_pts; /*< timegen presentation time of picture u_pts_picnum */
  121.     uint32_t u_pts_picnum; /*< picture number of timegen presentation time */
  123.     mtime_t i_pts_offset; /*< maximum time between pts and dts */
  125.     /* p_outqueue is the list of encapsulation units that have been
  126.      * fed to the timegenerator.  the timegenerator stamps them in
  127.      * the order it solves the time.  the main packetizer loop removes
  128.      * completed encapsulation units from the front */
  129.     block_t *p_outqueue;
  130.     block_t **pp_outqueue_last;
  131.     /* p_out_dts points to an element in p_outqueue.  It is used for VLC's
  132.      * fake pts hidden in DTS hack, as used by AVI */
  133.     block_t *p_out_dts;
  135.     uint32_t u_tg_last_picnum; /*< most recent picturenumber output from RoB */
  136.     bool b_tg_last_picnum; /*< u_tg_last_picnum valid */
  138.     struct dirac_reorder_buffer {
  139.         int u_size_max;
  140.         int u_size;
  141.         struct dirac_reorder_entry {
  142.             struct dirac_reorder_entry *p_next;
  143.             block_t *p_eu;
  144.             uint32_t u_picnum;
  145.         } p_entries[32], *p_head, *p_empty;
  146.     } reorder_buf; /*< reorder buffer, used by timegenerator */
  148.     /* packetizer state */
  149.     mtime_t i_pts_last_out; /*< last output [from packetizer] pts */
  150.     mtime_t i_dts_last_out; /*< last output [from packetizer] dts */
  152.     struct seq_hdr_t {
  153.         uint32_t u_width;
  154.         uint32_t u_height;
  155.         uint32_t u_fps_num;
  156.         uint32_t u_fps_den;
  157.         enum picture_coding_mode_t {
  158.             DIRAC_FRAME_CODING=0,
  159.             DIRAC_FIELD_CODING=1,
  160.         } u_picture_coding_mode;
  161.     } seq_hdr; /*< sequence header */
  162.     bool b_seen_seq_hdr; /* sequence header valid */
  163.     bool b_seen_eos; /* last data unit to be handled was an EOS */
  164. };
  166. typedef struct {
  167.     uint32_t u_next_offset;
  168.     uint32_t u_prev_offset;
  169.     int i_parse_code;
  170. } parse_info_t;
  172. typedef struct {
  173.     block_free_t pf_blk_release;
  174.     /*> next_parse_offset of the final data unit in associated block_t */
  175.     uint32_t u_last_next_offset;
  176.     /*> picture number is invalid if block has flags DIRAC_NON_DATED */
  177.     uint32_t u_picture_number;
  178. } dirac_block_encap_t;
  180. enum {
  181.     NOT_SYNCED=0,
  182.     TRY_SYNC,
  183.     SYNCED,
  184.     SYNCED_INCOMPLETEDU,
  185. };
  187. enum {
  188.     DIRAC_NON_DATED = (1 << BLOCK_FLAG_PRIVATE_SHIFT),
  189.     DIRAC_DISCARD   = (2 << BLOCK_FLAG_PRIVATE_SHIFT),
  190. };
  192. enum {
  193.     DIRAC_DU_IN_EU,
  194.     DIRAC_DU_ENDS_EU,
  195. };
  197. /***
  198.  * Block encapsulation functions.
  199.  * Things are greately simplified by associating some metadata
  200.  * with a block as it passes through the packetizer (saves having
  201.  * to determine it again)
  202.  *
  203.  * unfortunately p_block doesn't have a p_priv, so some fakage
  204.  * needs to happen:
  205.  *   - Create a dummy block that has some extra storage, set up
  206.  *     members to be identical to the actual block
  207.  *   - Store private data there and pointer to orig block
  208.  *   - modify block pointer to point to fake block
  209.  *
  210.  * NB, the add/new functions must not be used to blocks
  211.  * that are referenced in lists, etc., [in this code, this is ok]
  212.  * NB, don't call add on the same block multiple times (will leak)
  213.  *
  214.  * davidf has a patch that reverts this to use a p_priv in block_t.
  215.  */
  216. typedef struct {
  217.     block_t fake;
  218.     block_t *p_orig;
  219.     void *p_priv;
  220. } fake_block_t;
  222. static dirac_block_encap_t *dirac_RemoveBlockEncap( block_t *p_block )
  223. {
  224.     fake_block_t *p_fake = (fake_block_t *)p_block;
  225.     dirac_block_encap_t *p_dbe = p_fake->p_priv;
  226.     if( !p_dbe ) return NULL;
  227.     p_fake->p_priv = NULL;
  228.     p_dbe->pf_blk_release = NULL;
  229.     return p_dbe;
  230. }
  232. static void dirac_ReleaseBlockAndEncap( block_t *p_block )
  233. {
  234.     fake_block_t *p_fake = (fake_block_t *)p_block;
  235.     free( dirac_RemoveBlockEncap( p_block ) );
  236.     p_fake->p_orig->pf_release( p_fake->p_orig );
  237.     free( p_fake );
  238. }
  240. static void dirac_AddBlockEncap( block_t **pp_block, dirac_block_encap_t *p_dbe )
  241. {
  242.     fake_block_t *p_fake = calloc( 1, sizeof( *p_fake ) );
  243.     assert( p_fake ); /* must not fail, fixby: adding a p_priv to block_t */
  244.     p_fake->p_orig = *pp_block;
  245.     memcpy( &p_fake->fake, *pp_block, sizeof( block_t ) );
  246.     *pp_block = &p_fake->fake;
  248.     p_fake->p_priv = p_dbe;
  249.     p_dbe->pf_blk_release = p_fake->p_orig->pf_release;
  250.     p_fake->fake.pf_release = dirac_ReleaseBlockAndEncap;
  251. }
  253. static dirac_block_encap_t *dirac_NewBlockEncap( block_t **pp_block )
  254. {
  255.     dirac_block_encap_t *p_dbe = calloc( 1, sizeof( *p_dbe ) );
  256.     if( p_dbe ) dirac_AddBlockEncap( pp_block, p_dbe );
  257.     return p_dbe;
  258. }
  260. static dirac_block_encap_t *dirac_GetBlockEncap( block_t *p_block )
  261. {
  262.     return (dirac_block_encap_t*) ((fake_block_t *)p_block)->p_priv;
  263. }
  265. /***
  266.  * General utility funcions
  267.  */
  269. /**
  270.  * given a chain of block_t, allocate and return an array containing
  271.  * pointers to all the blocks. (Acts as a replacement for the old p_prev
  272.  * member of block_t) */
  273. static int block_ChainToArray( block_t *p_block, block_t ***ppp_array)
  274. {
  275.     if( !ppp_array )
  276.         return 0;
  278.     int i_num_blocks;
  279.     block_ChainProperties( p_block, &i_num_blocks, NULL, NULL );
  281.     *ppp_array = calloc( i_num_blocks, sizeof( block_t* ) );
  282.     if( !ppp_array ) return 0;
  284.     for( int i = 0; i < i_num_blocks; i++ )
  285.     {
  286.         (*ppp_array)[i] = p_block;
  287.         p_block = p_block->p_next;
  288.     }
  290.     return i_num_blocks;
  291. }
  293. /**
  294.  * Destructively find and recover the earliest timestamp from start of
  295.  * bytestream, upto i_length.
  296.  */
  297. static void dirac_RecoverTimestamps ( decoder_t *p_dec, size_t i_length )
  298. {
  299.     decoder_sys_t *p_sys = p_dec->p_sys;
  300.     block_t *p_block = p_sys->bytestream.p_block;
  302.     /* Find the block with first non-flushed data */
  303.     size_t i_offset = p_sys->bytestream.i_offset;
  304.     for(; p_block != NULL; p_block = p_block->p_next )
  305.     {
  306.         if( i_offset < p_block->i_buffer )
  307.             break;
  308.         i_offset -= p_block->i_buffer;
  309.     }
  311.     i_offset += i_length;
  312.     for(; p_block != NULL; p_block = p_block->p_next )
  313.     {
  314.         if( p_sys->i_sync_pts <= VLC_TS_INVALID && p_sys->i_sync_dts <= VLC_TS_INVALID )
  315.         {
  316.             /* oldest timestamp wins */
  317.             p_sys->i_sync_pts = p_block->i_pts;
  318.             p_sys->i_sync_dts = p_block->i_dts;
  319.         }
  320.         /* clear timestamps -- more than one data unit can come from a block */
  321.         p_block->i_flags = 0;
  322.         p_block->i_pts = p_block->i_dts = VLC_TS_INVALID;
  323.         if( i_offset < p_block->i_buffer )
  324.             break;
  325.         i_offset -= p_block->i_buffer;
  326.     }
  327. }
  329. /* backdate the list [p_block .. p_block->p_next where p_next == p_last] */
  330. static void dirac_BackdateDTS( block_t *p_block, block_t *p_last, date_t *p_dts )
  331. {
  332.     /* Transverse p_last backwards.  (no p_prev anymore) */
  333.     block_t **pp_array = NULL;
  334.     int n = block_ChainToArray( p_block, &pp_array );
  335.     while( n ) if( pp_array[--n] == p_last ) break;
  336.     /* want to start at p_last->p_prev */
  337.     while( n-- )
  338.     {
  339.         if( pp_array[n]->i_flags & DIRAC_NON_DATED )
  340.             continue;
  341.         if( pp_array[n]->i_dts <= VLC_TS_INVALID )
  342.             pp_array[n]->i_dts = date_Decrement( p_dts, 1 );
  343.     }
  344.     free( pp_array );
  345. }
  347. /* backdate the list [p_block .. p_block->p_next where p_next == p_last] */
  348. static void dirac_BackdatePTS( block_t *p_block, block_t *p_last, date_t *p_pts, uint32_t u_pts_picnum )
  349. {
  350.     /* Transverse p_last backwards.  (no p_prev anymore) */
  351.     block_t **pp_array = NULL;
  352.     int n = block_ChainToArray( p_block, &pp_array );
  353.     while( n ) if( pp_array[--n] == p_last ) break;
  354.     /* want to start at p_last->p_prev */
  355.     while( n-- )
  356.     {
  357.         if( pp_array[n]->i_flags & DIRAC_NON_DATED )
  358.             continue;
  359.         if( pp_array[n]->i_dts > VLC_TS_INVALID )
  360.             continue;
  361.         dirac_block_encap_t *dbe = dirac_GetBlockEncap( pp_array[n] );
  362.         int32_t u_pic_num = dbe ? dbe->u_picture_number : 0;
  363.         int32_t i_dist = u_pic_num - u_pts_picnum;
  364.         date_t pts = *p_pts;
  365.         if( i_dist >= 0 )
  366.             pp_array[n]->i_pts = date_Increment( &pts, i_dist );
  367.         else
  368.             pp_array[n]->i_pts = date_Decrement( &pts, -i_dist );
  369.     }
  370.     free( pp_array );
  371. }
  373. /***
  374.  * Dirac spec defined relations
  375.  */
  377. static bool dirac_isEOS( uint8_t u_parse_code ) { return 0x10 == u_parse_code; }
  378. static bool dirac_isSeqHdr( uint8_t u_parse_code ) { return 0 == u_parse_code; }
  379. static bool dirac_isPicture( uint8_t u_parse_code ) { return 0x08 & u_parse_code; }
  380. static int dirac_numRefs( uint8_t u_parse_code ) { return 0x3 & u_parse_code; }
  382. static inline bool dirac_PictureNbeforeM( uint32_t u_n, uint32_t u_m )
  383. {
  384.     /* specified as: u_n occurs before u_m if:
  385.      *   (u_m - u_n) mod (1<<32) < D */
  386.     return (uint32_t)(u_m - u_n) < (1u<<31);
  387. }
  389. /***
  390.  * Reorder buffer model
  391.  */
  393. static void dirac_ReorderInit( struct dirac_reorder_buffer *p_rb )
  394. {
  395.     memset( p_rb, 0, sizeof(*p_rb) );
  396.     p_rb->u_size_max = 2;
  397.     p_rb->p_empty = p_rb->p_entries;
  398.     p_rb->p_entries[31].p_next = NULL;
  400.     for( int i = 0; i < 31; i++ )
  401.         p_rb->p_entries[i].p_next = &p_rb->p_entries[i+1];
  402. }
  404. /* simulate the dirac picture reorder buffer */
  405. static block_t *dirac_Reorder( decoder_t *p_dec, block_t *p_block_in, uint32_t u_picnum )
  406. {
  407.     decoder_sys_t *p_sys = p_dec->p_sys;
  409.     if( !p_sys->reorder_buf.u_size_max )
  410.         /* reorder buffer disabled */
  411.         return p_block_in;
  413.     /* Modeling the reorder buffer:
  414.      * 1. If the reorder buffer is not full, insert picture for reordering.
  415.      *    No picture is output by the system this picture period
  416.      * 2. If the reorder buffer is full:
  417.      *    a. The picture decoded this period (u_picnum) bypasses the reorder
  418.      *       buffer if it has a lower picture number than any entry in the
  419.      *       reorder buffer. This picture is output by the system.
  420.      *    b. Otherwise, the lowest picture number in the reorder buffer is
  421.      *       removed from the buffer and output by the system.  The current
  422.      *       decoded picture (u_picnum) is inserted into the reorder buffer
  423.      */
  425.     block_t *p_block = NULL;
  426.     /* Determine if the picture needs to be inserted */
  427.     if( p_sys->reorder_buf.u_size == p_sys->reorder_buf.u_size_max )
  428.     {
  429.         /* (2) reorder buffer is full */
  430.         if( !p_sys->reorder_buf.u_size_max ||
  431.             dirac_PictureNbeforeM( u_picnum, p_sys->reorder_buf.p_head->u_picnum ) )
  432.         {
  433.             /* (2a) current picture is first in order */
  434.             return p_block_in;
  435.         }
  437.         /* (2b) extract the youngest picture in the buffer */
  438.         p_block = p_sys->reorder_buf.p_head->p_eu;
  440.         struct dirac_reorder_entry *p_tmp = p_sys->reorder_buf.p_head;
  441.         p_sys->reorder_buf.p_head = p_tmp->p_next;
  442.         p_tmp->p_next = p_sys->reorder_buf.p_empty;
  443.         p_sys->reorder_buf.p_empty = p_tmp;
  445.         p_sys->reorder_buf.u_size--;
  446.     }
  448.     /* (1) and (2b) both require u_picnum to be inserted */
  449.     struct dirac_reorder_entry *p_current = p_sys->reorder_buf.p_empty;
  450.     p_sys->reorder_buf.p_empty = p_current->p_next;
  451.     p_sys->reorder_buf.u_size++;
  453.     /* insertion sort to keep p_head always sorted, earliest first */
  454.     struct dirac_reorder_entry **pp_at = &p_sys->reorder_buf.p_head;
  455.     for( ; *pp_at; pp_at = &(*pp_at)->p_next )
  456.         if( dirac_PictureNbeforeM( u_picnum, (*pp_at)->u_picnum ) )
  457.             break;
  459.     p_current->u_picnum = u_picnum;
  460.     p_current->p_eu = p_block_in;
  461.     p_current->p_next = *pp_at;
  462.     *pp_at = p_current;
  464.     return p_block;
  465. }
  467. /***
  468.  * bytestream parsing and unmarshalling functions
  469.  */
  471. static bool dirac_UnpackParseInfo( parse_info_t *p_pi, block_bytestream_t *p_bs,
  472.                                    size_t u_offset )
  473. {
  474.     uint8_t p_d[13];
  475.     if( VLC_SUCCESS != block_PeekOffsetBytes( p_bs, u_offset, p_d, 13 ) )
  476.         return false;
  478.     if( p_d[0] != 'B' || p_d[1] != 'B' || p_d[2] != 'C' || p_d[3] != 'D' )
  479.         return false;
  481.     p_pi->i_parse_code = p_d[4];
  482.     p_pi->u_next_offset = p_d[5] << 24 | p_d[6] << 16 | p_d[7] << 8 | p_d[8];
  483.     p_pi->u_prev_offset = p_d[9] << 24 | p_d[10] << 16 | p_d[11] << 8 | p_d[12];
  484.     return true;
  485. }
  487. static uint32_t dirac_uint( bs_t *p_bs )
  488. {
  489.     uint32_t u_count = 0, u_value = 0;
  490.     while( !bs_eof( p_bs ) && !bs_read( p_bs, 1 ) )
  491.     {
  492.         u_count++;
  493.         u_value <<= 1;
  494.         u_value |= bs_read( p_bs, 1 );
  495.     }
  496.     return (1 << u_count) - 1 + u_value;
  497. }
  499. static int dirac_bool( bs_t *p_bs )
  500. {
  501.     return bs_read( p_bs, 1 );
  502. }
  504. /* read in useful bits from sequence header */
  505. static bool dirac_UnpackSeqHdr( struct seq_hdr_t *p_sh, block_t *p_block )
  506. {
  507.     bs_t bs;
  508.     bs_init( &bs, p_block->p_buffer, p_block->i_buffer );
  509.     bs_skip( &bs, 13*8 ); /* parse_info_header */
  510.     dirac_uint( &bs ); /* major_version */
  511.     dirac_uint( &bs ); /* minor_version */
  512.     dirac_uint( &bs ); /* profile */
  513.     dirac_uint( &bs ); /* level */
  515.     uint32_t u_video_format = dirac_uint( &bs ); /* index */
  516.     if( u_video_format > 20 )
  517.     {
  518.         /* dont know how to parse this header */
  519.         return false;
  520.     }
  522.     static const struct {
  523.         uint32_t u_w, u_h;
  524.     } dirac_size_tbl[] = {
  525.         {640,480}, {176,120}, {176,144}, {352,240}, {352,288}, {704,480},
  526.         {704,576}, {720,480}, {720,576}, {1280,720}, {1280,720}, {1920,1080},
  527.         {1920,1080}, {1920,1080}, {1920,1080}, {2048,1080}, {4096,2160},
  528.         {3840,2160}, {3840,2160}, {7680,4320}, {7680,4320},
  529.     };
  531.     p_sh->u_width = dirac_size_tbl[u_video_format].u_w;
  532.     p_sh->u_height = dirac_size_tbl[u_video_format].u_h;
  533.     if( dirac_bool( &bs ) )
  534.     {
  535.         p_sh->u_width = dirac_uint( &bs ); /* frame_width */
  536.         p_sh->u_height = dirac_uint( &bs ); /* frame_height */
  537.     }
  539.     if( dirac_bool( &bs ) )
  540.     {
  541.         dirac_uint( &bs ); /* chroma_format */
  542.     }
  544.     if( dirac_bool( &bs ) )
  545.     {
  546.         dirac_uint( &bs ); /* scan_format */
  547.     }
  549.     static const struct {
  550.         uint32_t u_n /* numerator */, u_d /* denominator */;
  551.     } dirac_frate_tbl[] = { /* table 10.3 */
  552.         {1, 1}, /* this value is not used */
  553.         {24000,1001}, {24,1}, {25,1}, {30000,1001}, {30,1},
  554.         {50,1}, {60000,1001}, {60,1}, {15000,1001}, {25,2},
  555.     };
  557.     const unsigned dirac_frate_tbl_size =
  558.         sizeof( dirac_frate_tbl ) / sizeof( *dirac_frate_tbl );
  560.     static const uint32_t dirac_vidfmt_frate[] = { /* table C.1 */
  561.         1, 9, 10, 9, 10, 9, 10, 4, 3, 7, 6, 4, 3, 7, 6, 2, 2, 7, 6, 7, 6,
  562.     };
  564.     p_sh->u_fps_num = dirac_frate_tbl[dirac_vidfmt_frate[u_video_format]].u_n;
  565.     p_sh->u_fps_den = dirac_frate_tbl[dirac_vidfmt_frate[u_video_format]].u_d;
  566.     if( dirac_bool( &bs ) )
  567.     {
  568.         uint32_t frame_rate_index = dirac_uint( &bs );
  569.         p_sh->u_fps_num = dirac_frate_tbl[frame_rate_index].u_n;
  570.         p_sh->u_fps_den = dirac_frate_tbl[frame_rate_index].u_d;
  571.         if( frame_rate_index >= dirac_frate_tbl_size )
  572.         {
  573.             /* invalid header */
  574.             return false;
  575.         }
  576.         if( frame_rate_index == 0 )
  577.         {
  578.             p_sh->u_fps_num = dirac_uint( &bs ); /* frame_rate_numerator */
  579.             p_sh->u_fps_den = dirac_uint( &bs ); /* frame_rate_denominator */
  580.         }
  581.     }
  583.     /* must have a valid framerate */
  584.     if( !p_sh->u_fps_num || !p_sh->u_fps_den )
  585.         return false;
  587.     if( dirac_bool( &bs ) )
  588.     {
  589.         uint32_t par_index = dirac_uint( &bs );
  590.         if( !par_index )
  591.         {
  592.             dirac_uint( &bs ); /* par_num */
  593.             dirac_uint( &bs ); /* par_den */
  594.         }
  595.     }
  597.     if( dirac_bool( &bs ) )
  598.     {
  599.         dirac_uint( &bs ); /* clean_width */
  600.         dirac_uint( &bs ); /* clean_height */
  601.         dirac_uint( &bs ); /* clean_left_offset */
  602.         dirac_uint( &bs ); /* clean_top_offset */
  603.     }
  605.     if( dirac_bool( &bs ) )
  606.     {
  607.         uint32_t signal_range_index = dirac_uint( &bs );
  608.         if( !signal_range_index )
  609.         {
  610.             dirac_uint( &bs ); /* luma_offset */
  611.             dirac_uint( &bs ); /* luma_excursion */
  612.             dirac_uint( &bs ); /* chroma_offset */
  613.             dirac_uint( &bs ); /* chroma_excursion */
  614.         }
  615.     }
  617.     if( dirac_bool( &bs ) )
  618.     {
  619.         uint32_t colour_spec_index = dirac_uint( &bs );
  620.         if( !colour_spec_index )
  621.         {
  622.             if( dirac_bool( &bs ) )
  623.             {
  624.                 dirac_uint( &bs ); /* colour_primaries_index */
  625.             }
  626.             if( dirac_bool( &bs ) )
  627.             {
  628.                 dirac_uint( &bs ); /* colour_matrix_index */
  629.             }
  630.             if( dirac_bool( &bs ) )
  631.             {
  632.                 dirac_uint( &bs ); /* transfer_function_index */
  633.             }
  634.         }
  635.     }
  637.     p_sh->u_picture_coding_mode = dirac_uint( &bs );
  639.     return true;
  640. }
  642. /***
  643.  * Data Unit marshalling functions
  644.  */
  646. static block_t *dirac_EmitEOS( decoder_t *p_dec, uint32_t i_prev_parse_offset )
  647. {
  648.     const uint8_t p_eos[] = { 'B','B','C','D',0x10,0,0,0,13,0,0,0,0 };
  649.     block_t *p_block = block_New( p_dec, 13 );
  650.     if( !p_block )
  651.         return NULL;
  652.     memcpy( p_block->p_buffer, p_eos, 13 );
  654.     SetDWBE( p_block->p_buffer + 9, i_prev_parse_offset );
  656.     p_block->i_flags = DIRAC_NON_DATED;
  658.     return p_block;
  660.     (void) p_dec;
  661. }
  663. /***
  664.  * Bytestream synchronizer
  665.  * maps [Bytes] -> DataUnit
  666.  */
  667. static block_t *dirac_DoSync( decoder_t *p_dec )
  668. {
  669.     decoder_sys_t *p_sys = p_dec->p_sys;
  670.     parse_info_t pu;
  672.     static const uint8_t p_parsecode[4] = {'B','B','C','D'};
  673.     do {
  674.         switch( p_sys->i_state )
  675.         {
  676.         case NOT_SYNCED:
  677.         {
  678.             if( VLC_SUCCESS !=
  679.                 block_FindStartcodeFromOffset( &p_sys->bytestream, &p_sys->i_offset, p_parsecode, 4 ) )
  680.             {
  681.                 /* p_sys->i_offset will have been set to:
  682.                  *   end of bytestream - amount of prefix found
  683.                  * can resume search from this point when more data arrives */
  684.                 return NULL;
  685.             }
  686.             /* candidate parse_code_prefix has been found at p_sys->i_offset */
  687.             if( VLC_SUCCESS != block_PeekOffsetBytes( &p_sys->bytestream, p_sys->i_offset + 12, NULL, 0 ) )
  688.             {
  689.                 /* insufficient data has been accumulated to fully extract
  690.                  * a parse_info header. exit for now in the hope of more
  691.                  * data later to retry at exactly the same point */
  692.                 return NULL;
  693.             }
  694.             p_sys->i_state = TRY_SYNC;
  695.             break; /* candidate found, try to sync */
  696.         }
  697.         case SYNCED: /* -> TRY_SYNC | NOT_SYNCED */
  698.             /* sanity: can only reach this after having extracted a DU,
  699.              * which causes data to be consumed and local i_offset to be reset */
  700.             assert( p_sys->i_offset == 0 );
  701.             if( VLC_SUCCESS != block_PeekOffsetBytes( &p_sys->bytestream, 12, NULL, 0 ) )
  702.             {
  703.                 /* insufficient data has been accumulated to fully extract
  704.                  * a parse_info header, retry later */
  705.                 return NULL;
  706.             }
  707.             if( !dirac_UnpackParseInfo( &pu, &p_sys->bytestream, 0 )
  708.              || !pu.u_next_offset || (p_sys->u_last_npo != pu.u_prev_offset) )
  709.             {
  710.                 /* !a: not a valid parse info.
  711.                  * !pu.u_next_offset: don't know the length of the data unit
  712.                  *                    search for the next one that points back
  713.                  *                    to this one to determine length.
  714.                  * (p_sys->u_last_npo != pu.u_prev_offset): some desync
  715.                  */
  716.                 p_sys->i_state = NOT_SYNCED;
  717.                 break;
  718.             }
  719.             if( pu.u_next_offset > 1024*1024 )
  720.             {
  721.                 /* sanity check for erronious hugs next_parse_offsets
  722.                  * (eg, 2^32-1) that would cause a very long wait
  723.                  * and large space consumption: fall back to try sync */
  724.                 p_sys->i_state = TRY_SYNC;
  725.                 break;
  726.             }
  727.             /* check that the start of the next data unit is avaliable */
  728.             if( VLC_SUCCESS !=
  729.                 block_PeekOffsetBytes( &p_sys->bytestream, pu.u_next_offset + 12, NULL, 0 ) )
  730.             {
  731.                 return NULL; /* retry later */
  732.             }
  733.             /* attempt to syncronise backwards from pu.u_next_offset */
  734.             p_sys->i_offset = pu.u_next_offset;
  735.             /* fall through */
  736.         case TRY_SYNC: /* -> SYNCED | NOT_SYNCED */
  737.         {
  738.             if( !p_sys->i_offset )
  739.                 goto sync_fail; /* if a is at start of bytestream, b can't be in buffer */
  741.             parse_info_t pu_a;
  742.             bool a = dirac_UnpackParseInfo( &pu_a, &p_sys->bytestream, p_sys->i_offset );
  743.             if( !a || (pu_a.u_prev_offset > p_sys->i_offset) )
  744.                 goto sync_fail; /* b lies beyond start of bytestream: can't sync */
  746.             if( !pu_a.u_prev_offset )
  747.             {
  748.                 if( p_sys->i_state == TRY_SYNC )
  749.                 {
  750.                     goto sync_fail; /* can't find different pu_b from pu_a */
  751.                 }
  752.                 /* state == SYNCED: already know where pu_b is.
  753.                  * pu_a has probably been inserted by something that doesn't
  754.                  * know what the last next_parse_offset was */
  755.                 pu_a.u_prev_offset = pu.u_next_offset;
  756.             }
  758.             parse_info_t *pu_b = &pu;
  759.             bool b = dirac_UnpackParseInfo( pu_b, &p_sys->bytestream, p_sys->i_offset - pu_a.u_prev_offset );
  760.             if( !b || (pu_b->u_next_offset && pu_a.u_prev_offset != pu_b->u_next_offset) )
  761.             {
  762.                 /* if pu_b->u_next_offset = 0, have to assume we've synced, ie,
  763.                  * just rely on finding a valid pu_b from pu_a. */
  764.                 goto sync_fail;
  765.             }
  766.             p_sys->u_last_npo = pu_b->u_next_offset;
  767.             if( !pu_b->u_next_offset ) pu_b->u_next_offset = pu_a.u_prev_offset;
  768.             /* offset was pointing at pu_a, rewind to point at pu_b */
  769.             p_sys->i_offset -= pu_a.u_prev_offset;
  770.             p_sys->i_state = SYNCED;
  771.             break;
  772.         }
  773. sync_fail:
  774.             if( p_sys->i_state == SYNCED ) p_sys->i_offset = 0;
  775.             p_sys->i_offset++;
  776.             p_sys->i_state = NOT_SYNCED;
  777.             break; /* find somewhere else to try again */
  778.         default:;
  779.         }
  780.     } while( SYNCED != p_sys->i_state );
  782.     /*
  783.      * synced, attempt to extract a data unit
  784.      */
  786.     /* recover any timestamps from the data that is about to be flushed */
  787.     dirac_RecoverTimestamps( p_dec, p_sys->i_offset );
  789.     /* flush everything upto the start of the DU */
  790.     block_SkipBytes( &p_sys->bytestream, p_sys->i_offset );
  791.     block_BytestreamFlush( &p_sys->bytestream );
  792.     p_sys->i_offset = 0;
  794.     /* setup the data unit buffer */
  795.     block_t *p_block = block_New( p_dec, pu.u_next_offset );
  796.     if( !p_block )
  797.         return NULL;
  799.     p_block->i_pts = p_sys->i_sync_pts;
  800.     p_block->i_dts = p_sys->i_sync_dts;
  801.     p_sys->i_sync_pts = p_sys->i_sync_dts = VLC_TS_INVALID;
  803.     /* recover any new timestamps from the data that is about to be consumed */
  804.     dirac_RecoverTimestamps( p_dec, p_sys->i_offset );
  806.     block_GetBytes( &p_sys->bytestream, p_block->p_buffer, p_block->i_buffer );
  808.     /* save parse offset in private area for later use */
  809.     dirac_block_encap_t *p_dbe = dirac_NewBlockEncap( &p_block );
  810.     if( p_dbe ) p_dbe->u_last_next_offset = pu.u_next_offset;
  812.     return p_block;
  813. }
  815. /***
  816.  * Packet (Data Unit) inspection, learns parameters from sequence
  817.  * headers, sets up flags, drops unwanted data units, sets
  818.  * encapsulation unit termination policy
  819.  */
  820. static int dirac_InspectDataUnit( decoder_t *p_dec, block_t **pp_block, block_t *p_eu )
  821. {
  822.     decoder_sys_t *p_sys = p_dec->p_sys;
  823.     block_t *p_block = *pp_block;
  824.     uint8_t u_parse_code = p_block->p_buffer[4];
  826.     if( dirac_isEOS( u_parse_code ) )
  827.     {
  828.         if( p_sys->b_seen_eos )
  829.         {
  830.             /* remove duplicate EOS packets */
  831.             block_Release( p_block );
  832.             *pp_block = NULL;
  833.             return DIRAC_DU_IN_EU;
  834.         }
  835.         /* p_block is an EOS packet */
  836.         p_eu->i_flags |= BLOCK_FLAG_END_OF_SEQUENCE;
  837.         /* for the moment, let this end an encapsulation unit */
  838.         /* seeing an eos packet requires a flush of the packetizer
  839.          * this is detected by the caller of this function */
  840.         p_sys->b_seen_seq_hdr = false;
  841.         p_sys->b_seen_eos = true;
  842.         return DIRAC_DU_ENDS_EU;
  843. #if 0
  844.         /* let anything down streem know too */
  845.         /*
  846.         Actually, this is a bad idea:
  847.          - It sets the discontinuity for every dirac EOS packet
  848.            which doesnt imply a time discontinuity.
  849.          - When the syncronizer detects a real discontinuity, it
  850.            should copy the flags through.
  851.         p_eu->i_flags |= BLOCK_FLAG_DISCONTINUITY;
  852.         */
  853. #endif
  854.     }
  855.     p_sys->b_seen_eos = false;
  857.     if( dirac_isPicture( u_parse_code ) )
  858.     {
  859.         /* timestamps apply to pictures only */
  860.         p_eu->i_dts = p_sys->i_eu_dts;
  861.         p_eu->i_pts = p_sys->i_eu_pts;
  862.         p_sys->i_eu_dts = p_sys->i_eu_pts = VLC_TS_INVALID;
  864.         if( !p_sys->b_seen_seq_hdr )
  865.         {
  866.             /* can't timestamp in this case, discard later
  867.              * so that the timestamps aren't lost */
  868.             p_eu->i_flags |= DIRAC_DISCARD;
  869.         }
  870.         /* p_block is a picture -- it ends the 'encapsulation unit' */
  871.         if( dirac_numRefs( u_parse_code ) )
  872.         {
  873.             /* if this picture is not an I frame, ensure that the
  874.              * random access point flags are not set */
  875.             p_eu->i_flags &= ~BLOCK_FLAG_TYPE_I;
  876.         }
  877.         dirac_block_encap_t *p_dbe = dirac_GetBlockEncap( p_block );
  878.         if( p_dbe && p_block->i_buffer > 13+4 )
  879.         {
  880.             /* record the picture number to save the time gen functions
  881.              * from having to inspect the data for it */
  882.             p_dbe->u_picture_number = GetDWBE( p_block->p_buffer + 13 );
  883.         }
  884.         return DIRAC_DU_ENDS_EU;
  885.     }
  887.     if( dirac_isSeqHdr( u_parse_code ) )
  888.     {
  889.         if( !dirac_UnpackSeqHdr( &p_sys->seq_hdr, p_block ) )
  890.         {
  891.             /* couldn't parse the sequence header, just ignore it */
  892.             return DIRAC_DU_IN_EU;
  893.         }
  894.         p_sys->b_seen_seq_hdr = true;
  896.        /* a sequence header followed by an I frame is a random
  897.         * access point; assume that this is the case */
  898.         p_eu->i_flags |= BLOCK_FLAG_TYPE_I;
  900.         es_format_t *p_es = &p_dec->fmt_out;
  902.         p_es->video.i_width  = p_sys->seq_hdr.u_width;
  903.         p_es->video.i_height = p_sys->seq_hdr.u_height;
  905.         vlc_ureduce( &p_es->video.i_frame_rate, &p_es->video.i_frame_rate_base
  906.                    , p_sys->seq_hdr.u_fps_num, p_sys->seq_hdr.u_fps_den, 0 );
  908.         /* when field coding, dts needs to be incremented in terms of field periods */
  909.         unsigned u_pics_per_sec = p_sys->seq_hdr.u_fps_num;
  910.         if( p_sys->seq_hdr.u_picture_coding_mode == DIRAC_FIELD_CODING )
  911.         {
  912.             u_pics_per_sec *= 2;
  913.         }
  914.         date_Change( &p_sys->dts, u_pics_per_sec, p_sys->seq_hdr.u_fps_den );
  916.         /* TODO: set p_sys->reorder_buf.u_size_max */
  917.         p_sys->i_pts_offset = p_sys->reorder_buf.u_size_max
  918.                             * 1000000
  919.                             * p_es->video.i_frame_rate_base / p_es->video.i_frame_rate + 1;
  921.         /* stash a copy of the seqhdr
  922.          *  - required for ogg muxing
  923.          *  - useful for error checking
  924.          *  - it isn't allowed to change until an eos */
  925.         if( p_es->p_extra )
  926.             free( p_es->p_extra );
  927.         p_es->p_extra = calloc( 1, p_block->i_buffer + 13 );
  928.         if( !p_es->p_extra )
  929.         {
  930.             p_es->i_extra = 0;
  931.             return DIRAC_DU_IN_EU;
  932.         }
  933.         p_es->i_extra = p_block->i_buffer;
  934.         memcpy( p_es->p_extra, p_block->p_buffer, p_block->i_buffer );
  935.         /* append EOS as per Ogg guidelines */
  936.         p_block = dirac_EmitEOS( p_dec, p_block->i_buffer );
  937.         if( p_block )
  938.         {
  939.             memcpy( (uint8_t*)p_es->p_extra + p_es->i_extra, p_block->p_buffer, 13 );
  940.             p_es->i_extra += 13;
  941.         }
  943.         return DIRAC_DU_IN_EU;
  944.     }
  946.     /* doesn't end an encapsulation unit */
  947.     return DIRAC_DU_IN_EU;
  948. }
  950. /***
  951.  * Encapsulation (packetization) suitable for all muxing standards
  952.  * maps [DataUnit] -> EncapsulationUnit
  953.  */
  954. static block_t *dirac_BuildEncapsulationUnit( decoder_t *p_dec, block_t *p_block )
  955. {
  956.     decoder_sys_t *p_sys = p_dec->p_sys;
  958.     assert(p_block->i_buffer >= 13 && 0x42424344 == GetDWBE( p_block->p_buffer ));
  960.     if( p_sys->i_eu_pts <= VLC_TS_INVALID && p_sys->i_eu_dts <= VLC_TS_INVALID )
  961.     {
  962.         /* earliest block with pts/dts gets to set the pts/dts for the dated
  963.          * encapsulation unit as a whole */
  964.         /* NB, the 'earliest block' criteria is aribtary */
  965.         if( p_block->i_pts > VLC_TS_INVALID || p_block->i_dts > VLC_TS_INVALID )
  966.         {
  967.             p_sys->i_eu_pts = p_block->i_pts;
  968.             p_sys->i_eu_dts = p_block->i_dts;
  969.         }
  970.     }
  972.     /* inpectdataunit also updates flags for the EU.
  973.      *  - if this is the first block in the EU, then it hasn't been added
  974.      *    to the chain yet (so, p_block will become the front of the chain
  975.      *  - otherwise, use the flags of the chain (first block) */
  976.     block_t *p_eu = p_sys->p_eu ? p_sys->p_eu : p_block;
  977.     int i_block = dirac_InspectDataUnit( p_dec, &p_block, p_eu);
  979.     if( !p_block )
  980.     {
  981.         /* block has been discarded during inspection */
  982.         /* becareful, don't discard anything that is dated,
  983.          * as this needs to go into the timegen loop.  set
  984.          * the DIRAC_DISCARD block flag, and it'll be dropped
  985.          * at output time */
  986.         return NULL;
  987.     }
  989.     block_ChainLastAppend( &p_sys->pp_eu_last, p_block );
  991.     dirac_block_encap_t *p_dbe = dirac_GetBlockEncap( p_block );
  992. #ifdef SANITIZE_PREV_PARSE_OFFSET
  993.     /* fixup prev_parse_offset to point to the last data unit
  994.      * to arrive */
  995.     if( p_dbe )
  996.     {
  997.         SetDWBE( p_block->p_buffer + 9, p_sys->u_eu_last_npo );
  998.         p_sys->u_eu_last_npo = p_dbe->u_last_next_offset;
  999.     }
  1000. #endif
  1002.     if( i_block != DIRAC_DU_ENDS_EU )
  1003.     {
  1004.         /* encapsulation unit not ended */
  1005.         return NULL;
  1006.     }
  1008.     /* gather up encapsulation unit, reassociating the final
  1009.      * private state with the gathered block */
  1010.     block_t *p_eu_last = (block_t*) p_sys->pp_eu_last - offsetof( block_t, p_next );
  1011.     p_dbe = dirac_RemoveBlockEncap( p_eu_last );
  1013.     uint8_t u_parse_code = p_block->p_buffer[4];
  1015.     /* gather up the encapsulation unit */
  1016.     p_block = block_ChainGather( p_sys->p_eu );
  1017.     assert( p_block ); /* block_ChainGather doesn't define when it frees chain */
  1019.     p_block->i_flags |= DIRAC_NON_DATED;
  1020.     if( p_dbe )
  1021.     {
  1022.         dirac_AddBlockEncap( &p_block, p_dbe );
  1023.         if( dirac_isPicture( u_parse_code ) ) p_block->i_flags &= ~DIRAC_NON_DATED;
  1024.     }
  1025.     p_sys->p_eu = NULL;
  1026.     p_sys->pp_eu_last = &p_sys->p_eu;
  1027.     return p_block;
  1028. }
  1030. /**
  1031.  * dirac_TimeGenPush:
  1032.  * @p_dec: vlc object
  1033.  * @p_block_in: whole encapsulation unit to generate timestamps for
  1034.  *
  1035.  * Returns:
  1036.  *  0: everything ok
  1037.  *  1: EOS occured, please flush and reset
  1038.  *  2: picture number discontinuity, please flush and reset
  1039.  */
  1040. static int dirac_TimeGenPush( decoder_t *p_dec, block_t *p_block_in )
  1041. {
  1042.     decoder_sys_t *p_sys = p_dec->p_sys;
  1043.     dirac_block_encap_t *p_dbe;
  1045.     if( p_block_in->i_flags & BLOCK_FLAG_END_OF_SEQUENCE )
  1046.     {
  1047.         /* NB, this test occurs after the timegen push, so as to
  1048.          * push the block into the output queue */
  1049.         return 1;
  1050.     }
  1052.     if( p_block_in->i_flags & DIRAC_NON_DATED )
  1053.     {
  1054.         /* no picture found, which means p_block_in is a non-dated EU,
  1055.          * do not try and put a date on it */
  1056.         return 0;
  1057.     }
  1059.     p_dbe = dirac_GetBlockEncap( p_block_in );
  1060.     uint32_t u_picnum = p_dbe ? p_dbe->u_picture_number : 0;
  1061.     /*
  1062.      * Simple DTS regeneration:
  1063.      *  - DTS values linearly increase in stream order.
  1064.      *  - Every time a DTS occurs at the input, sync to it
  1065.      *    - If this is the first DTS seen, backdate all the previous ones that are undated
  1066.      *  - If a DTS is missing, guess that it increases by one picture period
  1067.      *  - If never seen DTS, don't do anything
  1068.      */
  1069.     /*
  1070.      * Simple PTS regeneration
  1071.      *  - PTS values do not linearly increase in stream order.
  1072.      *  - Every time a PTS occurs at the input, sync to it and record picture number
  1073.      *  - If a PTS is missing, guess that it differs by the product of picture
  1074.      *    period and difference between picture number of sync point and current picture
  1075.      *  - If this is the first PTS seen, backdate all previous ones that are undated
  1076.      *  - If never seen PTS, don't do anything
  1077.      */
  1078.     /*
  1079.      * Stage 1, sync to input timestamps, backdate timestamps for old
  1080.      * EUs that are in the outqueue with missing dates
  1081.      */
  1082.     if( p_block_in->i_dts > VLC_TS_INVALID )
  1083.     do {
  1084.         /* if timestamps exist, sync to them */
  1085.         if( p_sys->b_dts )
  1086.             break;
  1087.         /* first dts seen, backdate any packets in outqueue */
  1088.         p_sys->b_dts = true;
  1089.         date_t dts = p_sys->dts;
  1090.         dirac_BackdateDTS( p_sys->p_outqueue, p_block_in, &dts );
  1091.     } while( 0 );
  1093.     if( p_block_in->i_pts > VLC_TS_INVALID )
  1094.     do {
  1095.         /* if timestamps exist, sync to them */
  1096.         p_sys->u_pts_picnum = u_picnum;
  1097.         p_sys->i_pts = p_block_in->i_pts;
  1098.         if( p_sys->b_pts )
  1099.             break;
  1100.         /* first pts seen, backdate any packets in outqueue */
  1101.         p_sys->b_pts = true;
  1102.         date_t pts = p_sys->dts;
  1103.         date_Set( &pts, p_sys->i_pts );
  1104.         dirac_BackdatePTS( p_sys->p_outqueue, p_block_in, &pts, p_sys->u_pts_picnum );
  1105.     } while( 0 );
  1107.     /*
  1108.      * Stage 2, don't attempt to forwards interpolate timestamps for
  1109.      * blocks if the picture rates aren't known
  1110.      */
  1111.     if( !p_sys->b_seen_seq_hdr )
  1112.     {
  1113.         return 0;
  1114.     }
  1116.     /*
  1117.      * Stage 3, for block_in, interpolate any missing timestamps
  1118.      */
  1119.     if( p_sys->b_dts && p_block_in->i_dts <= VLC_TS_INVALID )
  1120.     {
  1121.         /* dts has previously been seen, but not this time, interpolate */
  1122.         p_block_in->i_dts = date_Increment( &p_sys->dts, 1 );
  1123.     }
  1125.     if( p_sys->b_pts && p_block_in->i_pts <= VLC_TS_INVALID )
  1126.     {
  1127.         /* pts has previously been seen, but not this time, interpolate */
  1128.         date_t pts = p_sys->dts;
  1129.         date_Set( &pts, p_sys->i_pts );
  1130.         int32_t i_dist = u_picnum - p_sys->u_pts_picnum;
  1131.         if( i_dist >= 0 )
  1132.             p_block_in->i_pts = date_Increment( &pts, i_dist );
  1133.         else
  1134.             p_block_in->i_pts = date_Decrement( &pts, -i_dist );
  1135.     }
  1137.     /* If pts and dts have been seen, there is no need to simulate operation
  1138.      * of the decoder reorder buffer */
  1139.     /* If neither have been seen, there is little point in simulating */
  1140.     if( p_sys->b_dts == p_sys->b_pts )
  1141.         return 0;
  1143.     if( !p_sys->p_out_dts )
  1144.         p_sys->p_out_dts = p_sys->p_outqueue;
  1146.     /* model the reorder buffer */
  1147.     block_t *p_block = dirac_Reorder( p_dec, p_block_in, u_picnum );
  1148.     if( !p_block )
  1149.         return 0;
  1151.     /* A future ehancement is to stop modeling the reorder buffer as soon as
  1152.      * the first packet is output -- interpolate the past and freewheel for
  1153.      * the future */
  1155.     p_dbe = dirac_GetBlockEncap( p_block );
  1156.     u_picnum = p_dbe ? p_dbe->u_picture_number : 0;
  1157.     if( p_sys->b_tg_last_picnum )
  1158.     {
  1159.         if( dirac_PictureNbeforeM( u_picnum, p_sys->u_tg_last_picnum ) )
  1160.         {
  1161.             msg_Warn( p_dec, "stream jumped? %d < %d: resetting"
  1162.                     , u_picnum, p_sys->u_tg_last_picnum );
  1163.             /* pictures only emerge from the reorder buffer in sequence
  1164.              * if a stream suddenly jumped backwards without a signaling
  1165.              * a discontinuity, some pictures will get stuck in the RoB.
  1166.              * flush the RoB. */
  1167.             /* this could be a bit less indiscriminate */
  1168.             p_dbe = dirac_GetBlockEncap( p_sys->p_outqueue );
  1169.             uint32_t u_prev_parse_offset = p_dbe ? p_dbe->u_last_next_offset : 0;
  1170.             block_ChainRelease( p_sys->p_outqueue );
  1171.             p_sys->p_outqueue = dirac_EmitEOS( p_dec, u_prev_parse_offset );
  1172.             if( p_sys->p_outqueue )
  1173.                 p_sys->p_outqueue->i_flags = BLOCK_FLAG_DISCONTINUITY | DIRAC_NON_DATED;
  1174.             /* return 2, so as not to reset the b_dts flags -- needed if
  1175.              * using the rawdirac demuxer with broken stream */
  1176.             return 2;
  1177.         }
  1178.     }
  1179.     p_sys->b_tg_last_picnum = true;
  1180.     p_sys->u_tg_last_picnum = u_picnum;
  1182.     if( !p_sys->b_pts )
  1183.     {
  1184.         /* some demuxers (eg, AVI) will provide a series of fake dts values,
  1185.          * which are actually inorder pts values (ie, what should be seen at
  1186.          * the output of a decoder.  A main reason for simulating the reorder
  1187.          * buffer is to turn the inorder fakedts into an out-of-order pts */
  1188.         p_block->i_pts = p_sys->p_out_dts->i_dts;
  1189.         p_sys->p_out_dts->i_dts = VLC_TS_INVALID;
  1190.     }
  1192.     /* If pts was copied from dts, the dts needs to be corrected to account for reordering*/
  1193.     /* If dts has never been seen, the same needs to happen */
  1194.     p_sys->p_out_dts->i_dts = p_block->i_pts - p_sys->i_pts_offset;
  1196.     /* move dts pointer */
  1197.     if( p_sys->p_out_dts )
  1198.         p_sys->p_out_dts = p_sys->p_out_dts->p_next;
  1200.     return 0;
  1201. }
  1203. /*****************************************************************************
  1204.  * Packetize: form dated encapsulation units from anything
  1205.  *****************************************************************************/
  1206. static block_t *Packetize( decoder_t *p_dec, block_t **pp_block )
  1207. {
  1208.     decoder_sys_t *p_sys = p_dec->p_sys;
  1209.     block_t *p_block = NULL;
  1210.     int i_flushing = 0;
  1212.     if( pp_block && *pp_block )
  1213.     {
  1214.         p_block = *pp_block;
  1215.         *pp_block = NULL;
  1217.         if( p_block->i_flags & BLOCK_FLAG_DISCONTINUITY )
  1218.         {
  1219.             /* pre-emptively insert an EOS at a discontinuity, protects
  1220.              * any decoders from any sudden changes */
  1221.             block_Release( p_block );
  1222.             p_block = dirac_EmitEOS( p_dec, 0 );
  1223.             if( p_block )
  1224.             {
  1225.                 p_block->p_next = dirac_EmitEOS( p_dec, 13 );
  1226.                 /* need two EOS to ensure it gets detected by syncro
  1227.                  * duplicates get discarded in forming encapsulation unit */
  1228.             }
  1229.         }
  1230.         else if( p_block->i_flags & BLOCK_FLAG_CORRUPTED )
  1231.         {
  1232.             /* silently discard corruption sentinels,
  1233.              * synchronizer will then discard affected data units.
  1234.              * do not produce an EOS data unit as this is very
  1235.              * disruptive to the stream (and may make a larger error). */
  1236.             block_Release( p_block );
  1237.             p_block = NULL;
  1238.         }
  1239.         if( p_block )
  1240.             block_BytestreamPush( &p_sys->bytestream, p_block );
  1241.     }
  1243.     /* form as many encapsulation units as possible, give up
  1244.      * when the syncronizer runs out of input data */
  1245.     while( ( p_block = dirac_DoSync( p_dec ) ) )
  1246.     {
  1247.         p_block = dirac_BuildEncapsulationUnit( p_dec, p_block );
  1248.         if( !p_block )
  1249.             continue;
  1250.         /* add to tail of output queue (ie, not reordered) */
  1251.         block_ChainLastAppend( &p_sys->pp_outqueue_last, p_block );
  1252.         /* insert encapsulation unit into timestamp generator
  1253.          * which then calculates some timestamps if required */
  1254.         i_flushing = dirac_TimeGenPush( p_dec, p_block );
  1255.         if( i_flushing )
  1256.             break;
  1257.     }
  1259.     block_t *p_output = NULL;
  1260.     block_t **pp_output = &p_output;
  1262.     /* extract all the dated packets from the head of the ouput queue */
  1263.     /* explicitly nondated packets repeat the previous timestamps to
  1264.      * stop vlc discarding them */
  1265.     while( (p_block = p_sys->p_outqueue) )
  1266.     {
  1267.         if( p_block->i_flags & DIRAC_DISCARD )
  1268.         {
  1269.             p_sys->p_outqueue = p_block->p_next;
  1270.             p_block->p_next = NULL;
  1271.             block_Release( p_block );
  1272.             continue;
  1273.         }
  1275.         if( i_flushing || p_block->i_flags & DIRAC_NON_DATED )
  1276.         {
  1277.             p_block->i_dts = p_sys->i_dts_last_out;
  1278.             p_block->i_pts = p_sys->i_pts_last_out;
  1279.         }
  1280.         else if( p_block->i_pts <= VLC_TS_INVALID ) break;
  1281.         else if( p_block->i_dts <= VLC_TS_INVALID ) break;
  1283.         p_sys->i_dts_last_out = p_block->i_dts;
  1284.         p_sys->i_pts_last_out = p_block->i_pts;
  1286.         p_sys->p_outqueue = p_block->p_next;
  1287.         p_block->p_next = NULL;
  1288.         /* clear any flags we set */
  1289.         p_block->i_flags &= ~BLOCK_FLAG_PRIVATE_MASK;
  1290.         block_ChainLastAppend( &pp_output, p_block );
  1292.         mtime_t i_delay = p_block->i_pts - p_block->i_dts;
  1293.         if( i_delay < 0 )
  1294.             msg_Err( p_dec, "pts - dts is negative(%"PRId64"): incorrect RoB size", i_delay );
  1295.     }
  1297.     if( i_flushing )
  1298.     {
  1299.         p_sys->i_eu_dts = p_sys->i_eu_pts = VLC_TS_INVALID;
  1301.         /* reset timegen state (except synchronizer) */
  1302.         p_sys->b_seen_seq_hdr = false;
  1303.         if( i_flushing < 2 )
  1304.         {
  1305.             /* this state isn't safe to loose if there was
  1306.              * an unsignalled discontinuity */
  1307.             p_sys->b_pts = p_sys->b_dts = false;
  1308.         }
  1309.         p_sys->b_tg_last_picnum = false;
  1310.         dirac_ReorderInit( &p_sys->reorder_buf );
  1312.         assert( p_sys->p_outqueue == NULL );
  1313.         p_sys->p_out_dts = NULL;
  1314.     }
  1316.     /* perform sanity check:
  1317.      *  if there were a block at the front of outqueue that never
  1318.      *  satisfied the extraction criteria, but all blocks after did,
  1319.      *  the output queue would grow bounded by the stream length.
  1320.      * If there are 10 data units in the output queue, assume this
  1321.      * has happened and purge all blocks that fail extraction criteria */
  1322.     int i_count;
  1323.     block_ChainProperties( p_sys->p_outqueue, &i_count, NULL, NULL );
  1324.     if( i_count > 9 )
  1325.     {
  1326.         p_block = p_sys->p_outqueue;
  1327.         while( p_block )
  1328.         {
  1329.             block_t *p_block_next = p_block->p_next;
  1330.             if( p_block->i_pts > VLC_TS_INVALID && p_block->i_dts > VLC_TS_INVALID )
  1331.                 break;
  1332.             block_Release( p_block );
  1333.             p_sys->p_outqueue = p_block = p_block_next;
  1334.         }
  1335.     }
  1337.     if( !p_sys->p_outqueue )
  1338.     {
  1339.         p_sys->pp_outqueue_last = &p_sys->p_outqueue;
  1340.     }
  1341.     return p_output;
  1342. }
  1344. /*****************************************************************************
  1345.  * Open: probe the packetizer and return score
  1346.  *****************************************************************************/
  1347. static int Open( vlc_object_t *p_this )
  1348. {
  1349.     decoder_t     *p_dec = (decoder_t*)p_this;
  1350.     decoder_sys_t *p_sys;
  1352.     if( p_dec->fmt_in.i_codec !=  VLC_FOURCC( 'd','r','a','c' ) )
  1353.         return VLC_EGENERIC;
  1355.     p_dec->pf_packetize = Packetize;
  1357.     /* Create the output format */
  1358.     es_format_Copy( &p_dec->fmt_out, &p_dec->fmt_in );
  1359.     p_dec->p_sys = p_sys = calloc( 1, sizeof( decoder_sys_t ) );
  1361.     if( !p_sys )
  1362.         return VLC_ENOMEM;
  1364.     p_sys->i_eu_pts = p_sys->i_eu_dts = VLC_TS_INVALID;
  1365.     p_sys->i_sync_pts = p_sys->i_sync_dts = VLC_TS_INVALID;
  1366.     p_sys->i_dts_last_out = p_sys->i_pts_last_out = VLC_TS_INVALID;
  1368.     p_sys->i_state = NOT_SYNCED;
  1369.     p_sys->bytestream = block_BytestreamInit();
  1371.     p_sys->pp_outqueue_last = &p_sys->p_outqueue;
  1372.     p_sys->pp_eu_last = &p_sys->p_eu;
  1374.     date_Init( &p_sys->dts, 1, 1 );
  1375.     dirac_ReorderInit( &p_sys->reorder_buf );
  1377.     if( p_dec->fmt_in.i_extra > 0 )
  1378.     {
  1379.         /* handle hacky systems like ogg that dump some headers
  1380.          * in p_extra. and packetizers that expect it to be filled
  1381.          * in before real startup */
  1382.         block_t *p_init = block_New( p_dec, p_dec->fmt_in.i_extra );
  1383.         if( !p_init )
  1384.         {
  1385.             /* memory might be avaliable soon.  it isn't the end of
  1386.              * the world that fmt_in.i_extra isn't handled */
  1387.             return VLC_SUCCESS;
  1388.         }
  1389.         memcpy( p_init->p_buffer, p_dec->fmt_in.p_extra, p_dec->fmt_in.i_extra );
  1390.         /* in theory p_extra should contain just a seqhdr&EOS.  if just a
  1391.          * seqhdr, ensure it is extracted by appending an EOS with
  1392.          * prev_offset = seqhdr length, ie i_extra.  If all were actually
  1393.          * ok, this won't do anything bad */
  1394.         if( ( p_init->p_next = dirac_EmitEOS( p_dec, p_dec->fmt_in.i_extra ) ) )
  1395.         {
  1396.             /* to ensure that one of these two EOS dataunits gets extracted,
  1397.              * send a second one */
  1398.             p_init->p_next->p_next = dirac_EmitEOS( p_dec, 13 );
  1399.         }
  1401.         block_t *p_block;
  1402.         while( ( p_block = Packetize( p_dec, &p_init ) ) )
  1403.             block_Release( p_block );
  1404.     }
  1406.     return VLC_SUCCESS;
  1407. }
  1409. /*****************************************************************************
  1410.  * Close:
  1411.  *****************************************************************************/
  1412. static void Close( vlc_object_t *p_this )
  1413. {
  1414.     decoder_t     *p_dec = (decoder_t*)p_this;
  1415.     decoder_sys_t *p_sys = p_dec->p_sys;
  1417.     block_BytestreamRelease( &p_sys->bytestream );
  1418.     if( p_sys->p_outqueue )
  1419.         block_ChainRelease( p_sys->p_outqueue );
  1420.     if( p_sys->p_eu )
  1421.         block_ChainRelease( p_sys->p_eu );
  1422.     free( p_sys );
  1423. }