hash
int64 -9,197,960,073,880,366,000
9,199,363,627B
| project
stringclasses 2
values | size
int64 2
5.68k
| label
int64 0
1
| functionSource
stringlengths 31
235k
|
|---|---|---|---|---|
-7,855,974,557,509,681,000 |
debian
| 12 | 0 |
Oid get_transform_tosql ( Oid typid , Oid langid , List * trftypes ) {
HeapTuple tup ;
if ( ! list_member_oid ( trftypes , typid ) ) return InvalidOid ;
tup = SearchSysCache2 ( TRFTYPELANG , typid , langid ) ;
if ( HeapTupleIsValid ( tup ) ) {
Oid funcid ;
funcid = ( ( Form_pg_transform ) GETSTRUCT ( tup ) ) -> trftosql ;
ReleaseSysCache ( tup ) ;
return funcid ;
}
else return InvalidOid ;
}
|
7,039,307,292,471,245,000 |
debian
| 27 | 0 |
static guint16 de_bcd_num ( tvbuff_t * tvb , proto_tree * tree , packet_info * pinfo , guint32 offset , guint len , int header_field , const gchar * * extracted_address ) {
guint8 extension ;
guint32 curr_offset , num_string_len ;
proto_item * item ;
* extracted_address = NULL ;
curr_offset = offset ;
extension = tvb_get_guint8 ( tvb , curr_offset ) & 0x80 ;
proto_tree_add_item ( tree , hf_gsm_a_extension , tvb , curr_offset , 1 , ENC_BIG_ENDIAN ) ;
proto_tree_add_item ( tree , hf_gsm_a_dtap_type_of_number , tvb , curr_offset , 1 , ENC_BIG_ENDIAN ) ;
proto_tree_add_item ( tree , hf_gsm_a_dtap_numbering_plan_id , tvb , curr_offset , 1 , ENC_BIG_ENDIAN ) ;
curr_offset ++ ;
if ( ! extension ) {
proto_tree_add_item ( tree , hf_gsm_a_extension , tvb , curr_offset , 1 , ENC_BIG_ENDIAN ) ;
proto_tree_add_item ( tree , hf_gsm_a_dtap_present_ind , tvb , curr_offset , 1 , ENC_BIG_ENDIAN ) ;
proto_tree_add_bits_item ( tree , hf_gsm_a_spare_bits , tvb , ( curr_offset << 3 ) + 3 , 3 , ENC_BIG_ENDIAN ) ;
proto_tree_add_item ( tree , hf_gsm_a_dtap_screening_ind , tvb , curr_offset , 1 , ENC_BIG_ENDIAN ) ;
curr_offset ++ ;
}
NO_MORE_DATA_CHECK ( len ) ;
num_string_len = len - ( curr_offset - offset ) ;
* extracted_address = tvb_bcd_dig_to_wmem_packet_str ( tvb , curr_offset , num_string_len , & Dgt_mbcd , FALSE ) ;
item = proto_tree_add_string ( tree , header_field , tvb , curr_offset , num_string_len , * extracted_address ) ;
if ( strchr ( * extracted_address , '?' ) ) {
expert_add_info ( pinfo , item , & ei_gsm_a_dtap_end_mark_unexpected ) ;
}
return ( len ) ;
}
|
373,200,843,854,506,750 |
chrome
| 40 | 0 |
static uint32_t getToUnicodeValue ( CnvExtData * extData , UCMTable * table , UCMapping * m ) {
UChar32 * u32 ;
UChar * u ;
uint32_t value ;
int32_t u16Length , ratio ;
UErrorCode errorCode ;
if ( m -> uLen == 1 ) {
u16Length = U16_LENGTH ( m -> u ) ;
value = ( uint32_t ) ( UCNV_EXT_TO_U_MIN_CODE_POINT + m -> u ) ;
}
else {
u32 = UCM_GET_CODE_POINTS ( table , m ) ;
errorCode = U_ZERO_ERROR ;
u_strFromUTF32 ( NULL , 0 , & u16Length , u32 , m -> uLen , & errorCode ) ;
if ( U_FAILURE ( errorCode ) && errorCode != U_BUFFER_OVERFLOW_ERROR ) {
exit ( errorCode ) ;
}
value = ( ( ( uint32_t ) u16Length + UCNV_EXT_TO_U_LENGTH_OFFSET ) << UCNV_EXT_TO_U_LENGTH_SHIFT ) | ( ( uint32_t ) utm_countItems ( extData -> toUUChars ) ) ;
u = utm_allocN ( extData -> toUUChars , u16Length ) ;
errorCode = U_ZERO_ERROR ;
u_strFromUTF32 ( u , u16Length , NULL , u32 , m -> uLen , & errorCode ) ;
if ( U_FAILURE ( errorCode ) && errorCode != U_BUFFER_OVERFLOW_ERROR ) {
exit ( errorCode ) ;
}
}
if ( m -> f == 0 ) {
value |= UCNV_EXT_TO_U_ROUNDTRIP_FLAG ;
}
if ( m -> bLen > extData -> maxInBytes ) {
extData -> maxInBytes = m -> bLen ;
}
if ( u16Length > extData -> maxOutUChars ) {
extData -> maxOutUChars = u16Length ;
}
ratio = ( u16Length + ( m -> bLen - 1 ) ) / m -> bLen ;
if ( ratio > extData -> maxUCharsPerByte ) {
extData -> maxUCharsPerByte = ratio ;
}
return value ;
}
|
2,709,342,705,526,909,400 |
debian
| 40 | 0 |
WORK_STATE tls_finish_handshake ( SSL * s , WORK_STATE wst ) {
void ( * cb ) ( const SSL * ssl , int type , int val ) = NULL ;
# ifndef OPENSSL_NO_SCTP if ( SSL_IS_DTLS ( s ) && BIO_dgram_is_sctp ( SSL_get_wbio ( s ) ) ) {
WORK_STATE ret ;
ret = dtls_wait_for_dry ( s ) ;
if ( ret != WORK_FINISHED_CONTINUE ) return ret ;
}
# endif ssl3_cleanup_key_block ( s ) ;
if ( ! SSL_IS_DTLS ( s ) ) {
BUF_MEM_free ( s -> init_buf ) ;
s -> init_buf = NULL ;
}
ssl_free_wbio_buffer ( s ) ;
s -> init_num = 0 ;
if ( ! s -> server || s -> renegotiate == 2 ) {
s -> renegotiate = 0 ;
s -> new_session = 0 ;
if ( s -> server ) {
ssl_update_cache ( s , SSL_SESS_CACHE_SERVER ) ;
s -> ctx -> stats . sess_accept_good ++ ;
s -> handshake_func = ossl_statem_accept ;
}
else {
ssl_update_cache ( s , SSL_SESS_CACHE_CLIENT ) ;
if ( s -> hit ) s -> ctx -> stats . sess_hit ++ ;
s -> handshake_func = ossl_statem_connect ;
s -> ctx -> stats . sess_connect_good ++ ;
}
if ( s -> info_callback != NULL ) cb = s -> info_callback ;
else if ( s -> ctx -> info_callback != NULL ) cb = s -> ctx -> info_callback ;
if ( cb != NULL ) cb ( s , SSL_CB_HANDSHAKE_DONE , 1 ) ;
if ( SSL_IS_DTLS ( s ) ) {
s -> d1 -> handshake_read_seq = 0 ;
s -> d1 -> handshake_write_seq = 0 ;
s -> d1 -> next_handshake_write_seq = 0 ;
dtls1_clear_received_buffer ( s ) ;
}
}
return WORK_FINISHED_STOP ;
}
|
-2,226,094,829,431,805,200 |
debian
| 13 | 0 |
jpc_pi_t * jpc_pi_create0 ( ) {
jpc_pi_t * pi ;
if ( ! ( pi = jas_malloc ( sizeof ( jpc_pi_t ) ) ) ) {
return 0 ;
}
pi -> picomps = 0 ;
pi -> pchgno = 0 ;
if ( ! ( pi -> pchglist = jpc_pchglist_create ( ) ) ) {
jas_free ( pi ) ;
return 0 ;
}
return pi ;
}
|
-866,921,002,076,081,900 |
debian
| 25 | 0 |
static int parent_proxy_fail ( TSCont contp , TSEvent event , void * edata ) {
ParentTest * ptest = ( ParentTest * ) TSContDataGet ( contp ) ;
TSHttpTxn txnp = ( TSHttpTxn ) edata ;
TSMBuffer mbuf ;
TSMLoc hdr ;
TSHttpStatus expected = TS_HTTP_STATUS_BAD_GATEWAY ;
TSHttpStatus received ;
int status ;
switch ( event ) {
case TS_EVENT_HTTP_SEND_RESPONSE_HDR : ink_release_assert ( TSHttpTxnClientRespGet ( txnp , & mbuf , & hdr ) == TS_SUCCESS ) ;
received = TSHttpHdrStatusGet ( mbuf , hdr ) ;
if ( expected != received ) {
status = REGRESSION_TEST_FAILED ;
SDK_RPRINT ( ptest -> regtest , "TSHttpTxnParentProxySet" , "TestCase" , TC_FAIL , "Expected response status %d, received %d" , expected , received ) ;
}
else {
status = REGRESSION_TEST_PASSED ;
SDK_RPRINT ( ptest -> regtest , "TSHttpTxnParentProxySet" , "TestCase" , TC_PASS , "Received expected response status %d" , expected ) ;
}
TSHandleMLocRelease ( mbuf , TS_NULL_MLOC , hdr ) ;
return status ;
default : SDK_RPRINT ( ptest -> regtest , "TSHttpTxnParentProxySet" , ptest -> testcase , TC_FAIL , "Unexpected event %d" , event ) ;
return REGRESSION_TEST_FAILED ;
}
}
|
-7,049,333,455,584,635,000 |
chrome
| 13 | 0 |
static void U_CALLCONV _UTF16LEReset ( UConverter * cnv , UConverterResetChoice choice ) {
if ( choice <= UCNV_RESET_TO_UNICODE ) {
if ( UCNV_GET_VERSION ( cnv ) == 0 ) {
cnv -> mode = 8 ;
}
else {
cnv -> mode = 0 ;
}
}
if ( choice != UCNV_RESET_TO_UNICODE && UCNV_GET_VERSION ( cnv ) == 1 ) {
cnv -> fromUnicodeStatus = UCNV_NEED_TO_WRITE_BOM ;
}
}
|
7,191,899,184,788,440,000 |
debian
| 8 | 0 |
static void print_field_types ( MYSQL_RES * result ) {
MYSQL_FIELD * field ;
uint i = 0 ;
while ( ( field = mysql_fetch_field ( result ) ) ) {
tee_fprintf ( PAGER , "Field %3u: `%s`\n" "Catalog: `%s`\n" "Database: `%s`\n" "Table: `%s`\n" "Org_table: `%s`\n" "Type: %s\n" "Collation: %s (%u)\n" "Length: %lu\n" "Max_length: %lu\n" "Decimals: %u\n" "Flags: %s\n\n" , ++ i , field -> name , field -> catalog , field -> db , field -> table , field -> org_table , fieldtype2str ( field -> type ) , get_charset_name ( field -> charsetnr ) , field -> charsetnr , field -> length , field -> max_length , field -> decimals , fieldflags2str ( field -> flags ) ) ;
}
tee_puts ( "" , PAGER ) ;
}
|
3,887,066,622,454,352,400 |
chrome
| 13 | 0 |
int64_t vp9_block_error_c ( const tran_low_t * coeff , const tran_low_t * dqcoeff , intptr_t block_size , int64_t * ssz ) {
int i ;
int64_t error = 0 , sqcoeff = 0 ;
for ( i = 0 ;
i < block_size ;
i ++ ) {
const int diff = coeff [ i ] - dqcoeff [ i ] ;
error += diff * diff ;
sqcoeff += coeff [ i ] * coeff [ i ] ;
}
* ssz = sqcoeff ;
return error ;
}
|
3,599,206,110,384,554,500 |
debian
| 16 | 0 |
static ossl_inline int sk_ ## t1 ## _is_sorted ( const STACK_OF ( t1 ) * sk ) {
return OPENSSL_sk_is_sorted ( ( const OPENSSL_STACK * ) sk ) ;
}
static ossl_inline STACK_OF ( t1 ) * sk_ ## t1 ## _dup ( const STACK_OF ( t1 ) * sk ) {
return ( STACK_OF ( t1 ) * ) OPENSSL_sk_dup ( ( const OPENSSL_STACK * ) sk ) ;
}
static ossl_inline STACK_OF ( t1 ) * sk_ ## t1 ## _deep_copy ( const STACK_OF ( t1 ) * sk , sk_ ## t1 ## _copyfunc copyfunc , sk_ ## t1 ## _freefunc freefunc ) {
return ( STACK_OF ( t1 ) * ) OPENSSL_sk_deep_copy ( ( const OPENSSL_STACK * ) sk , ( OPENSSL_sk_copyfunc ) copyfunc , ( OPENSSL_sk_freefunc ) freefunc ) ;
}
static ossl_inline sk_ ## t1 ## _compfunc sk_ ## t1 ## _set_cmp_func ( STACK_OF ( t1 ) * sk , sk_ ## t1 ## _compfunc compare ) {
return ( sk_ ## t1 ## _compfunc ) OPENSSL_sk_set_cmp_func ( ( OPENSSL_STACK * ) sk , ( OPENSSL_sk_compfunc ) compare ) ;
}
# define DEFINE_SPECIAL_STACK_OF ( t1 , t2 ) SKM_DEFINE_STACK_OF ( t1 , t2 , t2 ) # define DEFINE_STACK_OF ( t ) SKM_DEFINE_STACK_OF ( t , t , t ) # define DEFINE_SPECIAL_STACK_OF_CONST ( t1 , t2 ) SKM_DEFINE_STACK_OF ( t1 , const t2 , t2 ) # define DEFINE_STACK_OF_CONST ( t ) SKM_DEFINE_STACK_OF ( t , const t , t ) typedef char * OPENSSL_STRING ;
typedef const char * OPENSSL_CSTRING ;
DEFINE_SPECIAL_STACK_OF ( OPENSSL_STRING , char ) DEFINE_SPECIAL_STACK_OF_CONST ( OPENSSL_CSTRING , char ) typedef void * OPENSSL_BLOCK ;
DEFINE_SPECIAL_STACK_OF ( OPENSSL_BLOCK , void )
|
-6,105,298,668,491,047,000 |
debian
| 80 | 1 |
static int msmpeg4v34_decode_mb ( MpegEncContext * s , int16_t block [ 6 ] [ 64 ] ) {
int cbp , code , i ;
uint8_t * coded_val ;
uint32_t * const mb_type_ptr = & s -> current_picture . f . mb_type [ s -> mb_x + s -> mb_y * s -> mb_stride ] ;
if ( s -> pict_type == AV_PICTURE_TYPE_P ) {
if ( s -> use_skip_mb_code ) {
if ( get_bits1 ( & s -> gb ) ) {
s -> mb_intra = 0 ;
for ( i = 0 ;
i < 6 ;
i ++ ) s -> block_last_index [ i ] = - 1 ;
s -> mv_dir = MV_DIR_FORWARD ;
s -> mv_type = MV_TYPE_16X16 ;
s -> mv [ 0 ] [ 0 ] [ 0 ] = 0 ;
s -> mv [ 0 ] [ 0 ] [ 1 ] = 0 ;
s -> mb_skipped = 1 ;
* mb_type_ptr = MB_TYPE_SKIP | MB_TYPE_L0 | MB_TYPE_16x16 ;
return 0 ;
}
}
code = get_vlc2 ( & s -> gb , ff_mb_non_intra_vlc [ DEFAULT_INTER_INDEX ] . table , MB_NON_INTRA_VLC_BITS , 3 ) ;
if ( code < 0 ) return - 1 ;
s -> mb_intra = ( ~ code & 0x40 ) >> 6 ;
cbp = code & 0x3f ;
}
else {
s -> mb_intra = 1 ;
code = get_vlc2 ( & s -> gb , ff_msmp4_mb_i_vlc . table , MB_INTRA_VLC_BITS , 2 ) ;
if ( code < 0 ) return - 1 ;
cbp = 0 ;
for ( i = 0 ;
i < 6 ;
i ++ ) {
int val = ( ( code >> ( 5 - i ) ) & 1 ) ;
if ( i < 4 ) {
int pred = ff_msmpeg4_coded_block_pred ( s , i , & coded_val ) ;
val = val ^ pred ;
* coded_val = val ;
}
cbp |= val << ( 5 - i ) ;
}
}
if ( ! s -> mb_intra ) {
int mx , my ;
if ( s -> per_mb_rl_table && cbp ) {
s -> rl_table_index = decode012 ( & s -> gb ) ;
s -> rl_chroma_table_index = s -> rl_table_index ;
}
ff_h263_pred_motion ( s , 0 , 0 , & mx , & my ) ;
if ( ff_msmpeg4_decode_motion ( s , & mx , & my ) < 0 ) return - 1 ;
s -> mv_dir = MV_DIR_FORWARD ;
s -> mv_type = MV_TYPE_16X16 ;
s -> mv [ 0 ] [ 0 ] [ 0 ] = mx ;
s -> mv [ 0 ] [ 0 ] [ 1 ] = my ;
* mb_type_ptr = MB_TYPE_L0 | MB_TYPE_16x16 ;
}
else {
av_dlog ( s , "I at %d %d %d %06X\n" , s -> mb_x , s -> mb_y , ( ( cbp & 3 ) ? 1 : 0 ) + ( ( cbp & 0x3C ) ? 2 : 0 ) , show_bits ( & s -> gb , 24 ) ) ;
s -> ac_pred = get_bits1 ( & s -> gb ) ;
* mb_type_ptr = MB_TYPE_INTRA ;
if ( s -> inter_intra_pred ) {
s -> h263_aic_dir = get_vlc2 ( & s -> gb , ff_inter_intra_vlc . table , INTER_INTRA_VLC_BITS , 1 ) ;
av_dlog ( s , "%d%d %d %d/" , s -> ac_pred , s -> h263_aic_dir , s -> mb_x , s -> mb_y ) ;
}
if ( s -> per_mb_rl_table && cbp ) {
s -> rl_table_index = decode012 ( & s -> gb ) ;
s -> rl_chroma_table_index = s -> rl_table_index ;
}
}
s -> dsp . clear_blocks ( s -> block [ 0 ] ) ;
for ( i = 0 ;
i < 6 ;
i ++ ) {
if ( ff_msmpeg4_decode_block ( s , block [ i ] , i , ( cbp >> ( 5 - i ) ) & 1 , NULL ) < 0 ) {
av_log ( s -> avctx , AV_LOG_ERROR , "\nerror while decoding block: %d x %d (%d)\n" , s -> mb_x , s -> mb_y , i ) ;
return - 1 ;
}
}
return 0 ;
}
|
3,935,234,056,444,097,500 |
debian
| 47 | 0 |
static int rtp_xiph_pack_headers ( size_t room , void * p_extra , size_t i_extra , uint8_t * * p_buffer , size_t * i_buffer , uint8_t * theora_pixel_fmt ) {
unsigned packet_size [ XIPH_MAX_HEADER_COUNT ] ;
void * packet [ XIPH_MAX_HEADER_COUNT ] ;
unsigned packet_count ;
if ( xiph_SplitHeaders ( packet_size , packet , & packet_count , i_extra , p_extra ) ) return VLC_EGENERIC ;
;
if ( packet_count < 3 ) return VLC_EGENERIC ;
;
if ( theora_pixel_fmt != NULL ) {
if ( packet_size [ 0 ] < 42 ) return VLC_EGENERIC ;
* theora_pixel_fmt = ( ( ( uint8_t * ) packet [ 0 ] ) [ 41 ] >> 3 ) & 0x03 ;
}
unsigned length_size [ 2 ] = {
0 , 0 }
;
for ( int i = 0 ;
i < 2 ;
i ++ ) {
unsigned size = packet_size [ i ] ;
while ( size > 0 ) {
length_size [ i ] ++ ;
size >>= 7 ;
}
}
* i_buffer = room + 1 + length_size [ 0 ] + length_size [ 1 ] + packet_size [ 0 ] + packet_size [ 1 ] + packet_size [ 2 ] ;
* p_buffer = malloc ( * i_buffer ) ;
if ( * p_buffer == NULL ) return VLC_ENOMEM ;
uint8_t * p = * p_buffer + room ;
* p ++ = 2 ;
for ( int i = 0 ;
i < 2 ;
i ++ ) {
unsigned size = length_size [ i ] ;
while ( size > 0 ) {
* p = ( packet_size [ i ] >> ( 7 * ( size - 1 ) ) ) & 0x7f ;
if ( -- size > 0 ) * p |= 0x80 ;
p ++ ;
}
}
for ( int i = 0 ;
i < 3 ;
i ++ ) {
memcpy ( p , packet [ i ] , packet_size [ i ] ) ;
p += packet_size [ i ] ;
}
return VLC_SUCCESS ;
}
|
8,461,782,184,979,846,000 |
chrome
| 7 | 0 |
TEST_F ( ProtocolHandlerRegistryTest , TestIsEquivalentRegistered ) {
ProtocolHandler ph1 = CreateProtocolHandler ( "test" , GURL ( "http://test/%s" ) ) ;
ProtocolHandler ph2 = CreateProtocolHandler ( "test" , GURL ( "http://test/%s" ) ) ;
registry ( ) -> OnAcceptRegisterProtocolHandler ( ph1 ) ;
ASSERT_TRUE ( registry ( ) -> IsRegistered ( ph1 ) ) ;
ASSERT_TRUE ( registry ( ) -> HasRegisteredEquivalent ( ph2 ) ) ;
}
|
-970,074,718,378,997,900 |
debian
| 49 | 0 |
int ff_mpeg4_set_direct_mv ( MpegEncContext * s , int mx , int my ) {
const int mb_index = s -> mb_x + s -> mb_y * s -> mb_stride ;
const int colocated_mb_type = s -> next_picture . mb_type [ mb_index ] ;
uint16_t time_pp ;
uint16_t time_pb ;
int i ;
if ( IS_8X8 ( colocated_mb_type ) ) {
s -> mv_type = MV_TYPE_8X8 ;
for ( i = 0 ;
i < 4 ;
i ++ ) {
ff_mpeg4_set_one_direct_mv ( s , mx , my , i ) ;
}
return MB_TYPE_DIRECT2 | MB_TYPE_8x8 | MB_TYPE_L0L1 ;
}
else if ( IS_INTERLACED ( colocated_mb_type ) ) {
s -> mv_type = MV_TYPE_FIELD ;
for ( i = 0 ;
i < 2 ;
i ++ ) {
int field_select = s -> next_picture . ref_index [ 0 ] [ 4 * mb_index + 2 * i ] ;
s -> field_select [ 0 ] [ i ] = field_select ;
s -> field_select [ 1 ] [ i ] = i ;
if ( s -> top_field_first ) {
time_pp = s -> pp_field_time - field_select + i ;
time_pb = s -> pb_field_time - field_select + i ;
}
else {
time_pp = s -> pp_field_time + field_select - i ;
time_pb = s -> pb_field_time + field_select - i ;
}
s -> mv [ 0 ] [ i ] [ 0 ] = s -> p_field_mv_table [ i ] [ 0 ] [ mb_index ] [ 0 ] * time_pb / time_pp + mx ;
s -> mv [ 0 ] [ i ] [ 1 ] = s -> p_field_mv_table [ i ] [ 0 ] [ mb_index ] [ 1 ] * time_pb / time_pp + my ;
s -> mv [ 1 ] [ i ] [ 0 ] = mx ? s -> mv [ 0 ] [ i ] [ 0 ] - s -> p_field_mv_table [ i ] [ 0 ] [ mb_index ] [ 0 ] : s -> p_field_mv_table [ i ] [ 0 ] [ mb_index ] [ 0 ] * ( time_pb - time_pp ) / time_pp ;
s -> mv [ 1 ] [ i ] [ 1 ] = my ? s -> mv [ 0 ] [ i ] [ 1 ] - s -> p_field_mv_table [ i ] [ 0 ] [ mb_index ] [ 1 ] : s -> p_field_mv_table [ i ] [ 0 ] [ mb_index ] [ 1 ] * ( time_pb - time_pp ) / time_pp ;
}
return MB_TYPE_DIRECT2 | MB_TYPE_16x8 | MB_TYPE_L0L1 | MB_TYPE_INTERLACED ;
}
else {
ff_mpeg4_set_one_direct_mv ( s , mx , my , 0 ) ;
s -> mv [ 0 ] [ 1 ] [ 0 ] = s -> mv [ 0 ] [ 2 ] [ 0 ] = s -> mv [ 0 ] [ 3 ] [ 0 ] = s -> mv [ 0 ] [ 0 ] [ 0 ] ;
s -> mv [ 0 ] [ 1 ] [ 1 ] = s -> mv [ 0 ] [ 2 ] [ 1 ] = s -> mv [ 0 ] [ 3 ] [ 1 ] = s -> mv [ 0 ] [ 0 ] [ 1 ] ;
s -> mv [ 1 ] [ 1 ] [ 0 ] = s -> mv [ 1 ] [ 2 ] [ 0 ] = s -> mv [ 1 ] [ 3 ] [ 0 ] = s -> mv [ 1 ] [ 0 ] [ 0 ] ;
s -> mv [ 1 ] [ 1 ] [ 1 ] = s -> mv [ 1 ] [ 2 ] [ 1 ] = s -> mv [ 1 ] [ 3 ] [ 1 ] = s -> mv [ 1 ] [ 0 ] [ 1 ] ;
if ( ( s -> avctx -> workaround_bugs & FF_BUG_DIRECT_BLOCKSIZE ) || ! s -> quarter_sample ) s -> mv_type = MV_TYPE_16X16 ;
else s -> mv_type = MV_TYPE_8X8 ;
return MB_TYPE_DIRECT2 | MB_TYPE_16x16 | MB_TYPE_L0L1 ;
}
}
|
594,127,775,011,357,000 |
debian
| 257 | 0 |
static void ImportBGRQuantum ( const Image * image , QuantumInfo * quantum_info , const MagickSizeType number_pixels , const unsigned char * magick_restrict p , Quantum * magick_restrict q , ExceptionInfo * exception ) {
QuantumAny range ;
register ssize_t x ;
ssize_t bit ;
unsigned int pixel ;
assert ( image != ( Image * ) NULL ) ;
assert ( image -> signature == MagickCoreSignature ) ;
switch ( quantum_info -> depth ) {
case 8 : {
unsigned char pixel ;
for ( x = 0 ;
x < ( ssize_t ) number_pixels ;
x ++ ) {
p = PushCharPixel ( p , & pixel ) ;
SetPixelBlue ( image , ScaleCharToQuantum ( pixel ) , q ) ;
p = PushCharPixel ( p , & pixel ) ;
SetPixelGreen ( image , ScaleCharToQuantum ( pixel ) , q ) ;
p = PushCharPixel ( p , & pixel ) ;
SetPixelRed ( image , ScaleCharToQuantum ( pixel ) , q ) ;
SetPixelAlpha ( image , OpaqueAlpha , q ) ;
p += quantum_info -> pad ;
q += GetPixelChannels ( image ) ;
}
break ;
}
case 10 : {
range = GetQuantumRange ( quantum_info -> depth ) ;
if ( quantum_info -> pack == MagickFalse ) {
for ( x = 0 ;
x < ( ssize_t ) number_pixels ;
x ++ ) {
p = PushLongPixel ( quantum_info -> endian , p , & pixel ) ;
SetPixelRed ( image , ScaleAnyToQuantum ( ( pixel >> 22 ) & 0x3ff , range ) , q ) ;
SetPixelGreen ( image , ScaleAnyToQuantum ( ( pixel >> 12 ) & 0x3ff , range ) , q ) ;
SetPixelBlue ( image , ScaleAnyToQuantum ( ( pixel >> 2 ) & 0x3ff , range ) , q ) ;
p += quantum_info -> pad ;
q += GetPixelChannels ( image ) ;
}
break ;
}
if ( quantum_info -> quantum == 32U ) {
for ( x = 0 ;
x < ( ssize_t ) number_pixels ;
x ++ ) {
p = PushQuantumLongPixel ( quantum_info , p , & pixel ) ;
SetPixelBlue ( image , ScaleAnyToQuantum ( pixel , range ) , q ) ;
p = PushQuantumLongPixel ( quantum_info , p , & pixel ) ;
SetPixelGreen ( image , ScaleAnyToQuantum ( pixel , range ) , q ) ;
p = PushQuantumLongPixel ( quantum_info , p , & pixel ) ;
SetPixelRed ( image , ScaleAnyToQuantum ( pixel , range ) , q ) ;
q += GetPixelChannels ( image ) ;
}
break ;
}
for ( x = 0 ;
x < ( ssize_t ) number_pixels ;
x ++ ) {
p = PushQuantumPixel ( quantum_info , p , & pixel ) ;
SetPixelBlue ( image , ScaleAnyToQuantum ( pixel , range ) , q ) ;
p = PushQuantumPixel ( quantum_info , p , & pixel ) ;
SetPixelGreen ( image , ScaleAnyToQuantum ( pixel , range ) , q ) ;
p = PushQuantumPixel ( quantum_info , p , & pixel ) ;
SetPixelRed ( image , ScaleAnyToQuantum ( pixel , range ) , q ) ;
q += GetPixelChannels ( image ) ;
}
break ;
}
case 12 : {
range = GetQuantumRange ( quantum_info -> depth ) ;
if ( quantum_info -> pack == MagickFalse ) {
unsigned short pixel ;
for ( x = 0 ;
x < ( ssize_t ) ( 3 * number_pixels - 1 ) ;
x += 2 ) {
p = PushShortPixel ( quantum_info -> endian , p , & pixel ) ;
switch ( x % 3 ) {
default : case 0 : {
SetPixelRed ( image , ScaleAnyToQuantum ( ( QuantumAny ) ( pixel >> 4 ) , range ) , q ) ;
break ;
}
case 1 : {
SetPixelGreen ( image , ScaleAnyToQuantum ( ( QuantumAny ) ( pixel >> 4 ) , range ) , q ) ;
break ;
}
case 2 : {
SetPixelBlue ( image , ScaleAnyToQuantum ( ( QuantumAny ) ( pixel >> 4 ) , range ) , q ) ;
q += GetPixelChannels ( image ) ;
break ;
}
}
p = PushShortPixel ( quantum_info -> endian , p , & pixel ) ;
switch ( ( x + 1 ) % 3 ) {
default : case 0 : {
SetPixelRed ( image , ScaleAnyToQuantum ( ( QuantumAny ) ( pixel >> 4 ) , range ) , q ) ;
break ;
}
case 1 : {
SetPixelGreen ( image , ScaleAnyToQuantum ( ( QuantumAny ) ( pixel >> 4 ) , range ) , q ) ;
break ;
}
case 2 : {
SetPixelBlue ( image , ScaleAnyToQuantum ( ( QuantumAny ) ( pixel >> 4 ) , range ) , q ) ;
q += GetPixelChannels ( image ) ;
break ;
}
}
p += quantum_info -> pad ;
}
for ( bit = 0 ;
bit < ( ssize_t ) ( 3 * number_pixels % 2 ) ;
bit ++ ) {
p = PushShortPixel ( quantum_info -> endian , p , & pixel ) ;
switch ( ( x + bit ) % 3 ) {
default : case 0 : {
SetPixelRed ( image , ScaleAnyToQuantum ( ( QuantumAny ) ( pixel >> 4 ) , range ) , q ) ;
break ;
}
case 1 : {
SetPixelGreen ( image , ScaleAnyToQuantum ( ( QuantumAny ) ( pixel >> 4 ) , range ) , q ) ;
break ;
}
case 2 : {
SetPixelBlue ( image , ScaleAnyToQuantum ( ( QuantumAny ) ( pixel >> 4 ) , range ) , q ) ;
q += GetPixelChannels ( image ) ;
break ;
}
}
p += quantum_info -> pad ;
}
if ( bit != 0 ) p ++ ;
break ;
}
if ( quantum_info -> quantum == 32U ) {
for ( x = 0 ;
x < ( ssize_t ) number_pixels ;
x ++ ) {
p = PushQuantumLongPixel ( quantum_info , p , & pixel ) ;
SetPixelBlue ( image , ScaleAnyToQuantum ( pixel , range ) , q ) ;
p = PushQuantumLongPixel ( quantum_info , p , & pixel ) ;
SetPixelGreen ( image , ScaleAnyToQuantum ( pixel , range ) , q ) ;
p = PushQuantumLongPixel ( quantum_info , p , & pixel ) ;
SetPixelRed ( image , ScaleAnyToQuantum ( pixel , range ) , q ) ;
q += GetPixelChannels ( image ) ;
}
break ;
}
for ( x = 0 ;
x < ( ssize_t ) number_pixels ;
x ++ ) {
p = PushQuantumPixel ( quantum_info , p , & pixel ) ;
SetPixelBlue ( image , ScaleAnyToQuantum ( pixel , range ) , q ) ;
p = PushQuantumPixel ( quantum_info , p , & pixel ) ;
SetPixelGreen ( image , ScaleAnyToQuantum ( pixel , range ) , q ) ;
p = PushQuantumPixel ( quantum_info , p , & pixel ) ;
SetPixelRed ( image , ScaleAnyToQuantum ( pixel , range ) , q ) ;
q += GetPixelChannels ( image ) ;
}
break ;
}
case 16 : {
unsigned short pixel ;
if ( quantum_info -> format == FloatingPointQuantumFormat ) {
for ( x = 0 ;
x < ( ssize_t ) number_pixels ;
x ++ ) {
p = PushShortPixel ( quantum_info -> endian , p , & pixel ) ;
SetPixelRed ( image , ClampToQuantum ( QuantumRange * HalfToSinglePrecision ( pixel ) ) , q ) ;
p = PushShortPixel ( quantum_info -> endian , p , & pixel ) ;
SetPixelGreen ( image , ClampToQuantum ( QuantumRange * HalfToSinglePrecision ( pixel ) ) , q ) ;
p = PushShortPixel ( quantum_info -> endian , p , & pixel ) ;
SetPixelBlue ( image , ClampToQuantum ( QuantumRange * HalfToSinglePrecision ( pixel ) ) , q ) ;
p += quantum_info -> pad ;
q += GetPixelChannels ( image ) ;
}
break ;
}
for ( x = 0 ;
x < ( ssize_t ) number_pixels ;
x ++ ) {
p = PushShortPixel ( quantum_info -> endian , p , & pixel ) ;
SetPixelBlue ( image , ScaleShortToQuantum ( pixel ) , q ) ;
p = PushShortPixel ( quantum_info -> endian , p , & pixel ) ;
SetPixelGreen ( image , ScaleShortToQuantum ( pixel ) , q ) ;
p = PushShortPixel ( quantum_info -> endian , p , & pixel ) ;
SetPixelRed ( image , ScaleShortToQuantum ( pixel ) , q ) ;
p += quantum_info -> pad ;
q += GetPixelChannels ( image ) ;
}
break ;
}
case 32 : {
unsigned int pixel ;
if ( quantum_info -> format == FloatingPointQuantumFormat ) {
float pixel ;
for ( x = 0 ;
x < ( ssize_t ) number_pixels ;
x ++ ) {
p = PushFloatPixel ( quantum_info , p , & pixel ) ;
SetPixelRed ( image , ClampToQuantum ( pixel ) , q ) ;
p = PushFloatPixel ( quantum_info , p , & pixel ) ;
SetPixelGreen ( image , ClampToQuantum ( pixel ) , q ) ;
p = PushFloatPixel ( quantum_info , p , & pixel ) ;
SetPixelBlue ( image , ClampToQuantum ( pixel ) , q ) ;
p += quantum_info -> pad ;
q += GetPixelChannels ( image ) ;
}
break ;
}
for ( x = 0 ;
x < ( ssize_t ) number_pixels ;
x ++ ) {
p = PushLongPixel ( quantum_info -> endian , p , & pixel ) ;
SetPixelBlue ( image , ScaleLongToQuantum ( pixel ) , q ) ;
p = PushLongPixel ( quantum_info -> endian , p , & pixel ) ;
SetPixelGreen ( image , ScaleLongToQuantum ( pixel ) , q ) ;
p = PushLongPixel ( quantum_info -> endian , p , & pixel ) ;
SetPixelRed ( image , ScaleLongToQuantum ( pixel ) , q ) ;
p += quantum_info -> pad ;
q += GetPixelChannels ( image ) ;
}
break ;
}
case 64 : {
if ( quantum_info -> format == FloatingPointQuantumFormat ) {
double pixel ;
for ( x = 0 ;
x < ( ssize_t ) number_pixels ;
x ++ ) {
p = PushDoublePixel ( quantum_info , p , & pixel ) ;
SetPixelRed ( image , ClampToQuantum ( pixel ) , q ) ;
p = PushDoublePixel ( quantum_info , p , & pixel ) ;
SetPixelGreen ( image , ClampToQuantum ( pixel ) , q ) ;
p = PushDoublePixel ( quantum_info , p , & pixel ) ;
SetPixelBlue ( image , ClampToQuantum ( pixel ) , q ) ;
p += quantum_info -> pad ;
q += GetPixelChannels ( image ) ;
}
break ;
}
}
default : {
range = GetQuantumRange ( quantum_info -> depth ) ;
for ( x = 0 ;
x < ( ssize_t ) number_pixels ;
x ++ ) {
p = PushQuantumPixel ( quantum_info , p , & pixel ) ;
SetPixelBlue ( image , ScaleAnyToQuantum ( pixel , range ) , q ) ;
p = PushQuantumPixel ( quantum_info , p , & pixel ) ;
SetPixelGreen ( image , ScaleAnyToQuantum ( pixel , range ) , q ) ;
p = PushQuantumPixel ( quantum_info , p , & pixel ) ;
SetPixelRed ( image , ScaleAnyToQuantum ( pixel , range ) , q ) ;
q += GetPixelChannels ( image ) ;
}
break ;
}
}
}
|
-9,032,389,459,913,766,000 |
debian
| 3 | 0 |
static inline int __ipv6_addr_src_scope ( int type ) {
return ( type == IPV6_ADDR_ANY ) ? __IPV6_ADDR_SCOPE_INVALID : ( type >> 16 ) ;
}
|
6,393,050,609,822,898,000 |
debian
| 31 | 0 |
static void xhci_set_ep_state ( XHCIState * xhci , XHCIEPContext * epctx , XHCIStreamContext * sctx , uint32_t state ) {
XHCIRing * ring = NULL ;
uint32_t ctx [ 5 ] ;
uint32_t ctx2 [ 2 ] ;
xhci_dma_read_u32s ( xhci , epctx -> pctx , ctx , sizeof ( ctx ) ) ;
ctx [ 0 ] &= ~ EP_STATE_MASK ;
ctx [ 0 ] |= state ;
if ( epctx -> nr_pstreams ) {
if ( sctx != NULL ) {
ring = & sctx -> ring ;
xhci_dma_read_u32s ( xhci , sctx -> pctx , ctx2 , sizeof ( ctx2 ) ) ;
ctx2 [ 0 ] &= 0xe ;
ctx2 [ 0 ] |= sctx -> ring . dequeue | sctx -> ring . ccs ;
ctx2 [ 1 ] = ( sctx -> ring . dequeue >> 16 ) >> 16 ;
xhci_dma_write_u32s ( xhci , sctx -> pctx , ctx2 , sizeof ( ctx2 ) ) ;
}
}
else {
ring = & epctx -> ring ;
}
if ( ring ) {
ctx [ 2 ] = ring -> dequeue | ring -> ccs ;
ctx [ 3 ] = ( ring -> dequeue >> 16 ) >> 16 ;
DPRINTF ( "xhci: set epctx: " DMA_ADDR_FMT " state=%d dequeue=%08x%08x\n" , epctx -> pctx , state , ctx [ 3 ] , ctx [ 2 ] ) ;
}
xhci_dma_write_u32s ( xhci , epctx -> pctx , ctx , sizeof ( ctx ) ) ;
if ( epctx -> state != state ) {
trace_usb_xhci_ep_state ( epctx -> slotid , epctx -> epid , ep_state_name ( epctx -> state ) , ep_state_name ( state ) ) ;
}
epctx -> state = state ;
}
|
7,039,307,292,471,245,000 |
debian
| 11 | 0 |
static void dtap_mm_cm_srvc_rej ( tvbuff_t * tvb , proto_tree * tree , packet_info * pinfo _U_ , guint32 offset , guint len ) {
guint32 curr_offset ;
guint32 consumed ;
guint curr_len ;
curr_offset = offset ;
curr_len = len ;
is_uplink = IS_UPLINK_FALSE ;
ELEM_MAND_V ( GSM_A_PDU_TYPE_DTAP , DE_REJ_CAUSE , NULL ) ;
ELEM_OPT_TLV ( 0x36 , GSM_A_PDU_TYPE_DTAP , DE_MM_TIMER , " - T3246 value" ) ;
EXTRANEOUS_DATA_CHECK ( curr_len , 0 , pinfo , & ei_gsm_a_dtap_extraneous_data ) ;
}
|
-6,552,851,419,396,579,000 |
debian
| 6 | 0 |
static int dissect_spoolss_buffer ( tvbuff_t * tvb , gint offset , packet_info * pinfo , proto_tree * tree , dcerpc_info * di , guint8 * drep , BUFFER * b ) {
if ( b ) memset ( b , 0 , sizeof ( BUFFER ) ) ;
di -> private_data = b ;
offset = dissect_ndr_pointer ( tvb , offset , pinfo , tree , di , drep , dissect_spoolss_buffer_data , NDR_POINTER_UNIQUE , "Buffer" , - 1 ) ;
return offset ;
}
|
-5,456,913,190,944,845,000 |
chrome
| 50 | 0 |
TEST_F ( TemplateURLTest , ReplaceCurrentPageUrl ) {
struct TestData {
const base : : string16 search_term ;
const std : : string current_page_url ;
const std : : string url ;
const std : : string expected_result ;
}
test_data [ ] = {
{
ASCIIToUTF16 ( "foo" ) , "http://www.google.com/" , "{
google:baseURL}
?{
searchTerms}
&{
google:currentPageUrl}
" , "http://www.google.com/?foo&url=http%3A%2F%2Fwww.google.com%2F&" }
, {
ASCIIToUTF16 ( "foo" ) , "" , "{
google:baseURL}
?{
searchTerms}
&{
google:currentPageUrl}
" , "http://www.google.com/?foo&" }
, {
ASCIIToUTF16 ( "foo" ) , "http://g.com/+-/*&=" , "{
google:baseURL}
?{
searchTerms}
&{
google:currentPageUrl}
" , "http://www.google.com/?foo&url=http%3A%2F%2Fg.com%2F%2B-%2F*%26%3D&" }
, }
;
TemplateURLData data ;
data . input_encodings . push_back ( "UTF-8" ) ;
for ( size_t i = 0 ;
i < arraysize ( test_data ) ;
++ i ) {
data . SetURL ( test_data [ i ] . url ) ;
TemplateURL url ( data ) ;
EXPECT_TRUE ( url . url_ref ( ) . IsValid ( search_terms_data_ ) ) ;
ASSERT_TRUE ( url . url_ref ( ) . SupportsReplacement ( search_terms_data_ ) ) ;
TemplateURLRef : : SearchTermsArgs search_terms_args ( test_data [ i ] . search_term ) ;
search_terms_args . current_page_url = test_data [ i ] . current_page_url ;
GURL result ( url . url_ref ( ) . ReplaceSearchTerms ( search_terms_args , search_terms_data_ ) ) ;
ASSERT_TRUE ( result . is_valid ( ) ) ;
EXPECT_EQ ( test_data [ i ] . expected_result , result . spec ( ) ) ;
}
}
|
-7,440,595,807,730,782,000 |
debian
| 3 | 0 |
static void cmd_dcc_resume ( const char * data ) {
cmd_dcc_receive ( data , dcc_send_resume , dcc_send_resume ) ;
}
|
-8,054,970,867,770,516,000 |
debian
| 9 | 0 |
static const u_char * print_sl_change ( netdissect_options * ndo , const char * str , register const u_char * cp ) {
register u_int i ;
if ( ( i = * cp ++ ) == 0 ) {
i = EXTRACT_16BITS ( cp ) ;
cp += 2 ;
}
ND_PRINT ( ( ndo , " %s%d" , str , i ) ) ;
return ( cp ) ;
}
|
-3,165,961,362,620,712,400 |
chrome
| 230 | 1 |
static void initial_reordering_consonant_syllable ( const hb_ot_shape_plan_t * plan , hb_face_t * face , hb_buffer_t * buffer , unsigned int start , unsigned int end ) {
const indic_shape_plan_t * indic_plan = ( const indic_shape_plan_t * ) plan -> data ;
hb_glyph_info_t * info = buffer -> info ;
unsigned int base = end ;
bool has_reph = false ;
{
unsigned int limit = start ;
if ( indic_plan -> config -> reph_pos != REPH_POS_DONT_CARE && indic_plan -> mask_array [ RPHF ] && start + 3 <= end && ( ( indic_plan -> config -> reph_mode == REPH_MODE_IMPLICIT && ! is_joiner ( info [ start + 2 ] ) ) || ( indic_plan -> config -> reph_mode == REPH_MODE_EXPLICIT && info [ start + 2 ] . indic_category ( ) == OT_ZWJ ) ) ) {
hb_codepoint_t glyphs [ 3 ] = {
info [ start ] . codepoint , info [ start + 1 ] . codepoint , indic_plan -> config -> reph_mode == REPH_MODE_EXPLICIT ? info [ start + 2 ] . codepoint : 0 }
;
if ( indic_plan -> rphf . would_substitute ( glyphs , 2 , face ) || ( indic_plan -> config -> reph_mode == REPH_MODE_EXPLICIT && indic_plan -> rphf . would_substitute ( glyphs , 3 , face ) ) ) {
limit += 2 ;
while ( limit < end && is_joiner ( info [ limit ] ) ) limit ++ ;
base = start ;
has_reph = true ;
}
}
else if ( indic_plan -> config -> reph_mode == REPH_MODE_LOG_REPHA && info [ start ] . indic_category ( ) == OT_Repha ) {
limit += 1 ;
while ( limit < end && is_joiner ( info [ limit ] ) ) limit ++ ;
base = start ;
has_reph = true ;
}
switch ( indic_plan -> config -> base_pos ) {
default : assert ( false ) ;
case BASE_POS_LAST : {
unsigned int i = end ;
bool seen_below = false ;
do {
i -- ;
if ( is_consonant ( info [ i ] ) ) {
if ( info [ i ] . indic_position ( ) != POS_BELOW_C && ( info [ i ] . indic_position ( ) != POS_POST_C || seen_below ) ) {
base = i ;
break ;
}
if ( info [ i ] . indic_position ( ) == POS_BELOW_C ) seen_below = true ;
base = i ;
}
else {
if ( start < i && info [ i ] . indic_category ( ) == OT_ZWJ && info [ i - 1 ] . indic_category ( ) == OT_H ) break ;
}
}
while ( i > limit ) ;
}
break ;
case BASE_POS_LAST_SINHALA : {
if ( ! has_reph ) base = limit ;
for ( unsigned int i = limit ;
i < end ;
i ++ ) if ( is_consonant ( info [ i ] ) ) {
if ( limit < i && info [ i - 1 ] . indic_category ( ) == OT_ZWJ ) break ;
else base = i ;
}
for ( unsigned int i = base + 1 ;
i < end ;
i ++ ) if ( is_consonant ( info [ i ] ) ) info [ i ] . indic_position ( ) = POS_BELOW_C ;
}
break ;
case BASE_POS_FIRST : {
assert ( indic_plan -> config -> reph_mode == REPH_MODE_VIS_REPHA ) ;
assert ( ! has_reph ) ;
base = start ;
for ( unsigned int i = base + 1 ;
i < end ;
i ++ ) if ( is_consonant ( info [ i ] ) ) info [ i ] . indic_position ( ) = POS_BELOW_C ;
}
break ;
}
if ( has_reph && base == start && limit - base <= 2 ) {
has_reph = false ;
}
}
for ( unsigned int i = start ;
i < base ;
i ++ ) info [ i ] . indic_position ( ) = MIN ( POS_PRE_C , ( indic_position_t ) info [ i ] . indic_position ( ) ) ;
if ( base < end ) info [ base ] . indic_position ( ) = POS_BASE_C ;
for ( unsigned int i = base + 1 ;
i < end ;
i ++ ) if ( info [ i ] . indic_category ( ) == OT_M ) {
for ( unsigned int j = i + 1 ;
j < end ;
j ++ ) if ( is_consonant ( info [ j ] ) ) {
info [ j ] . indic_position ( ) = POS_FINAL_C ;
break ;
}
break ;
}
if ( has_reph ) info [ start ] . indic_position ( ) = POS_RA_TO_BECOME_REPH ;
if ( indic_plan -> is_old_spec ) {
bool disallow_double_halants = buffer -> props . script != HB_SCRIPT_MALAYALAM ;
for ( unsigned int i = base + 1 ;
i < end ;
i ++ ) if ( info [ i ] . indic_category ( ) == OT_H ) {
unsigned int j ;
for ( j = end - 1 ;
j > i ;
j -- ) if ( is_consonant ( info [ j ] ) || ( disallow_double_halants && info [ j ] . indic_category ( ) == OT_H ) ) break ;
if ( info [ j ] . indic_category ( ) != OT_H && j > i ) {
hb_glyph_info_t t = info [ i ] ;
memmove ( & info [ i ] , & info [ i + 1 ] , ( j - i ) * sizeof ( info [ 0 ] ) ) ;
info [ j ] = t ;
}
break ;
}
}
{
indic_position_t last_pos = POS_START ;
for ( unsigned int i = start ;
i < end ;
i ++ ) {
if ( ( FLAG ( info [ i ] . indic_category ( ) ) & ( JOINER_FLAGS | FLAG ( OT_N ) | FLAG ( OT_RS ) | MEDIAL_FLAGS | HALANT_OR_COENG_FLAGS ) ) ) {
info [ i ] . indic_position ( ) = last_pos ;
if ( unlikely ( info [ i ] . indic_category ( ) == OT_H && info [ i ] . indic_position ( ) == POS_PRE_M ) ) {
for ( unsigned int j = i ;
j > start ;
j -- ) if ( info [ j - 1 ] . indic_position ( ) != POS_PRE_M ) {
info [ i ] . indic_position ( ) = info [ j - 1 ] . indic_position ( ) ;
break ;
}
}
}
else if ( info [ i ] . indic_position ( ) != POS_SMVD ) {
last_pos = ( indic_position_t ) info [ i ] . indic_position ( ) ;
}
}
}
{
unsigned int last = base ;
for ( unsigned int i = base + 1 ;
i < end ;
i ++ ) if ( is_consonant ( info [ i ] ) ) {
for ( unsigned int j = last + 1 ;
j < i ;
j ++ ) if ( info [ j ] . indic_position ( ) < POS_SMVD ) info [ j ] . indic_position ( ) = info [ i ] . indic_position ( ) ;
last = i ;
}
else if ( info [ i ] . indic_category ( ) == OT_M ) last = i ;
}
{
unsigned int syllable = info [ start ] . syllable ( ) ;
for ( unsigned int i = start ;
i < end ;
i ++ ) info [ i ] . syllable ( ) = i - start ;
hb_bubble_sort ( info + start , end - start , compare_indic_order ) ;
base = end ;
for ( unsigned int i = start ;
i < end ;
i ++ ) if ( info [ i ] . indic_position ( ) == POS_BASE_C ) {
base = i ;
break ;
}
if ( indic_plan -> is_old_spec || end - base > 127 ) buffer -> merge_clusters ( base , end ) ;
else {
for ( unsigned int i = base ;
i < end ;
i ++ ) if ( info [ i ] . syllable ( ) != 255 ) {
unsigned int max = i ;
unsigned int j = start + info [ i ] . syllable ( ) ;
while ( j != i ) {
max = MAX ( max , j ) ;
unsigned int next = start + info [ j ] . syllable ( ) ;
info [ j ] . syllable ( ) = 255 ;
j = next ;
}
if ( i != max ) buffer -> merge_clusters ( i , max + 1 ) ;
}
}
for ( unsigned int i = start ;
i < end ;
i ++ ) info [ i ] . syllable ( ) = syllable ;
}
{
hb_mask_t mask ;
for ( unsigned int i = start ;
i < end && info [ i ] . indic_position ( ) == POS_RA_TO_BECOME_REPH ;
i ++ ) info [ i ] . mask |= indic_plan -> mask_array [ RPHF ] ;
mask = indic_plan -> mask_array [ HALF ] ;
if ( ! indic_plan -> is_old_spec && indic_plan -> config -> blwf_mode == BLWF_MODE_PRE_AND_POST ) mask |= indic_plan -> mask_array [ BLWF ] ;
for ( unsigned int i = start ;
i < base ;
i ++ ) info [ i ] . mask |= mask ;
mask = 0 ;
if ( base < end ) info [ base ] . mask |= mask ;
mask = indic_plan -> mask_array [ BLWF ] | indic_plan -> mask_array [ ABVF ] | indic_plan -> mask_array [ PSTF ] ;
for ( unsigned int i = base + 1 ;
i < end ;
i ++ ) info [ i ] . mask |= mask ;
}
if ( indic_plan -> is_old_spec && buffer -> props . script == HB_SCRIPT_DEVANAGARI ) {
for ( unsigned int i = start ;
i + 1 < base ;
i ++ ) if ( info [ i ] . indic_category ( ) == OT_Ra && info [ i + 1 ] . indic_category ( ) == OT_H && ( i + 2 == base || info [ i + 2 ] . indic_category ( ) != OT_ZWJ ) ) {
info [ i ] . mask |= indic_plan -> mask_array [ BLWF ] ;
info [ i + 1 ] . mask |= indic_plan -> mask_array [ BLWF ] ;
}
}
unsigned int pref_len = indic_plan -> config -> pref_len ;
if ( indic_plan -> mask_array [ PREF ] && base + pref_len < end ) {
assert ( 1 <= pref_len && pref_len <= 2 ) ;
for ( unsigned int i = base + 1 ;
i + pref_len - 1 < end ;
i ++ ) {
hb_codepoint_t glyphs [ 2 ] ;
for ( unsigned int j = 0 ;
j < pref_len ;
j ++ ) glyphs [ j ] = info [ i + j ] . codepoint ;
if ( indic_plan -> pref . would_substitute ( glyphs , pref_len , face ) ) {
for ( unsigned int j = 0 ;
j < pref_len ;
j ++ ) info [ i ++ ] . mask |= indic_plan -> mask_array [ PREF ] ;
if ( indic_plan -> mask_array [ CFAR ] ) for ( ;
i < end ;
i ++ ) info [ i ] . mask |= indic_plan -> mask_array [ CFAR ] ;
break ;
}
}
}
for ( unsigned int i = start + 1 ;
i < end ;
i ++ ) if ( is_joiner ( info [ i ] ) ) {
bool non_joiner = info [ i ] . indic_category ( ) == OT_ZWNJ ;
unsigned int j = i ;
do {
j -- ;
if ( non_joiner ) info [ j ] . mask &= ~ indic_plan -> mask_array [ HALF ] ;
}
while ( j > start && ! is_consonant ( info [ j ] ) ) ;
}
}
|
-2,915,908,172,644,761,000 |
debian
| 75 | 0 |
static int decode_tilehdr ( WmallDecodeCtx * s ) {
uint16_t num_samples [ WMALL_MAX_CHANNELS ] = {
0 }
;
uint8_t contains_subframe [ WMALL_MAX_CHANNELS ] ;
int channels_for_cur_subframe = s -> num_channels ;
int fixed_channel_layout = 0 ;
int min_channel_len = 0 ;
int c , tile_aligned ;
for ( c = 0 ;
c < s -> num_channels ;
c ++ ) s -> channel [ c ] . num_subframes = 0 ;
tile_aligned = get_bits1 ( & s -> gb ) ;
if ( s -> max_num_subframes == 1 || tile_aligned ) fixed_channel_layout = 1 ;
do {
int subframe_len , in_use = 0 ;
for ( c = 0 ;
c < s -> num_channels ;
c ++ ) {
if ( num_samples [ c ] == min_channel_len ) {
if ( fixed_channel_layout || channels_for_cur_subframe == 1 || ( min_channel_len == s -> samples_per_frame - s -> min_samples_per_subframe ) ) {
contains_subframe [ c ] = in_use = 1 ;
}
else {
if ( get_bits1 ( & s -> gb ) ) contains_subframe [ c ] = in_use = 1 ;
}
}
else contains_subframe [ c ] = 0 ;
}
if ( ! in_use ) {
av_log ( s -> avctx , AV_LOG_ERROR , "Found empty subframe\n" ) ;
return AVERROR_INVALIDDATA ;
}
if ( ( subframe_len = decode_subframe_length ( s , min_channel_len ) ) <= 0 ) return AVERROR_INVALIDDATA ;
min_channel_len += subframe_len ;
for ( c = 0 ;
c < s -> num_channels ;
c ++ ) {
WmallChannelCtx * chan = & s -> channel [ c ] ;
if ( contains_subframe [ c ] ) {
if ( chan -> num_subframes >= MAX_SUBFRAMES ) {
av_log ( s -> avctx , AV_LOG_ERROR , "broken frame: num subframes > 31\n" ) ;
return AVERROR_INVALIDDATA ;
}
chan -> subframe_len [ chan -> num_subframes ] = subframe_len ;
num_samples [ c ] += subframe_len ;
++ chan -> num_subframes ;
if ( num_samples [ c ] > s -> samples_per_frame ) {
av_log ( s -> avctx , AV_LOG_ERROR , "broken frame: " "channel len(%d) > samples_per_frame(%d)\n" , num_samples [ c ] , s -> samples_per_frame ) ;
return AVERROR_INVALIDDATA ;
}
}
else if ( num_samples [ c ] <= min_channel_len ) {
if ( num_samples [ c ] < min_channel_len ) {
channels_for_cur_subframe = 0 ;
min_channel_len = num_samples [ c ] ;
}
++ channels_for_cur_subframe ;
}
}
}
while ( min_channel_len < s -> samples_per_frame ) ;
for ( c = 0 ;
c < s -> num_channels ;
c ++ ) {
int i , offset = 0 ;
for ( i = 0 ;
i < s -> channel [ c ] . num_subframes ;
i ++ ) {
s -> channel [ c ] . subframe_offsets [ i ] = offset ;
offset += s -> channel [ c ] . subframe_len [ i ] ;
}
}
return 0 ;
}
|
-6,215,323,349,888,018,000 |
debian
| 15 | 0 |
static void dropTablespaces ( PGconn * conn ) {
PGresult * res ;
int i ;
res = executeQuery ( conn , "SELECT spcname " "FROM pg_catalog.pg_tablespace " "WHERE spcname !~ '^pg_' " "ORDER BY 1" ) ;
if ( PQntuples ( res ) > 0 ) fprintf ( OPF , "--\n-- Drop tablespaces\n--\n\n" ) ;
for ( i = 0 ;
i < PQntuples ( res ) ;
i ++ ) {
char * spcname = PQgetvalue ( res , i , 0 ) ;
fprintf ( OPF , "DROP TABLESPACE %s%s;
\n" , if_exists ? "IF EXISTS " : "" , fmtId ( spcname ) ) ;
}
PQclear ( res ) ;
fprintf ( OPF , "\n\n" ) ;
}
|
-1,929,262,071,302,712,000 |
debian
| 12 | 0 |
static void * Type_DateTime_Read ( struct _cms_typehandler_struct * self , cmsIOHANDLER * io , cmsUInt32Number * nItems , cmsUInt32Number SizeOfTag ) {
cmsDateTimeNumber timestamp ;
struct tm * NewDateTime ;
* nItems = 0 ;
NewDateTime = ( struct tm * ) _cmsMalloc ( self -> ContextID , sizeof ( struct tm ) ) ;
if ( NewDateTime == NULL ) return NULL ;
if ( io -> Read ( io , & timestamp , sizeof ( cmsDateTimeNumber ) , 1 ) != 1 ) return NULL ;
_cmsDecodeDateTimeNumber ( & timestamp , NewDateTime ) ;
* nItems = 1 ;
return NewDateTime ;
cmsUNUSED_PARAMETER ( SizeOfTag ) ;
}
|
7,039,307,292,471,245,000 |
debian
| 17 | 0 |
static guint16 de_stream_id ( tvbuff_t * tvb , proto_tree * tree , packet_info * pinfo _U_ , guint32 offset , guint len _U_ , gchar * add_string , int string_len ) {
guint32 curr_offset ;
guint8 oct ;
curr_offset = offset ;
oct = tvb_get_guint8 ( tvb , curr_offset ) ;
if ( oct == 0x00 ) {
proto_tree_add_uint_format_value ( tree , hf_gsm_a_dtap_stream_identifier , tvb , curr_offset , 1 , oct , "No Bearer (%u)" , oct ) ;
if ( add_string ) g_snprintf ( add_string , string_len , " - (No Bearer)" ) ;
}
else {
proto_tree_add_item ( tree , hf_gsm_a_dtap_stream_identifier , tvb , curr_offset , 1 , ENC_BIG_ENDIAN ) ;
if ( add_string ) g_snprintf ( add_string , string_len , " - (%u)" , oct ) ;
}
curr_offset ++ ;
EXTRANEOUS_DATA_CHECK ( len , curr_offset - offset , pinfo , & ei_gsm_a_dtap_extraneous_data ) ;
return ( len ) ;
}
|
-5,268,859,819,325,808,000 |
debian
| 39 | 0 |
static void query_info_callback ( GObject * source_object , GAsyncResult * res , gpointer user_data ) {
NautilusDirectory * directory ;
NautilusFile * get_info_file ;
GFileInfo * info ;
GetInfoState * state ;
GError * error ;
state = user_data ;
if ( state -> directory == NULL ) {
get_info_state_free ( state ) ;
return ;
}
directory = nautilus_directory_ref ( state -> directory ) ;
get_info_file = directory -> details -> get_info_file ;
g_assert ( NAUTILUS_IS_FILE ( get_info_file ) ) ;
directory -> details -> get_info_file = NULL ;
directory -> details -> get_info_in_progress = NULL ;
nautilus_file_ref ( get_info_file ) ;
error = NULL ;
info = g_file_query_info_finish ( G_FILE ( source_object ) , res , & error ) ;
if ( info == NULL ) {
if ( error -> domain == G_IO_ERROR && error -> code == G_IO_ERROR_NOT_FOUND ) {
nautilus_file_mark_gone ( get_info_file ) ;
}
get_info_file -> details -> file_info_is_up_to_date = TRUE ;
nautilus_file_clear_info ( get_info_file ) ;
get_info_file -> details -> get_info_failed = TRUE ;
get_info_file -> details -> get_info_error = error ;
}
else {
nautilus_file_update_info ( get_info_file , info ) ;
g_object_unref ( info ) ;
}
nautilus_file_changed ( get_info_file ) ;
nautilus_file_unref ( get_info_file ) ;
async_job_end ( directory , "file info" ) ;
nautilus_directory_async_state_changed ( directory ) ;
nautilus_directory_unref ( directory ) ;
get_info_state_free ( state ) ;
}
|
-1,493,847,185,972,313,000 |
debian
| 24 | 0 |
void av_image_copy ( uint8_t * dst_data [ 4 ] , int dst_linesizes [ 4 ] , const uint8_t * src_data [ 4 ] , const int src_linesizes [ 4 ] , enum PixelFormat pix_fmt , int width , int height ) {
const AVPixFmtDescriptor * desc = & av_pix_fmt_descriptors [ pix_fmt ] ;
if ( desc -> flags & PIX_FMT_HWACCEL ) return ;
if ( desc -> flags & PIX_FMT_PAL ) {
av_image_copy_plane ( dst_data [ 0 ] , dst_linesizes [ 0 ] , src_data [ 0 ] , src_linesizes [ 0 ] , width , height ) ;
memcpy ( dst_data [ 1 ] , src_data [ 1 ] , 4 * 256 ) ;
}
else {
int i , planes_nb = 0 ;
for ( i = 0 ;
i < desc -> nb_components ;
i ++ ) planes_nb = FFMAX ( planes_nb , desc -> comp [ i ] . plane + 1 ) ;
for ( i = 0 ;
i < planes_nb ;
i ++ ) {
int h = height ;
int bwidth = av_image_get_linesize ( pix_fmt , width , i ) ;
if ( i == 1 || i == 2 ) {
h = - ( ( - height ) >> desc -> log2_chroma_h ) ;
}
av_image_copy_plane ( dst_data [ i ] , dst_linesizes [ i ] , src_data [ i ] , src_linesizes [ i ] , bwidth , h ) ;
}
}
}
|
3,035,587,999,006,680,600 |
debian
| 8 | 0 |
static unsigned int dtls1_guess_mtu ( unsigned int curr_mtu ) {
unsigned int i ;
if ( curr_mtu == 0 ) return g_probable_mtu [ 0 ] ;
for ( i = 0 ;
i < sizeof ( g_probable_mtu ) / sizeof ( g_probable_mtu [ 0 ] ) ;
i ++ ) if ( curr_mtu > g_probable_mtu [ i ] ) return g_probable_mtu [ i ] ;
return curr_mtu ;
}
|
7,153,080,989,267,739,000 |
debian
| 40 | 0 |
static int mxpeg_decode_mxm ( MXpegDecodeContext * s , const uint8_t * buf_ptr , int buf_size ) {
unsigned bitmask_size , mb_count ;
int i ;
s -> mb_width = AV_RL16 ( buf_ptr + 4 ) ;
s -> mb_height = AV_RL16 ( buf_ptr + 6 ) ;
mb_count = s -> mb_width * s -> mb_height ;
bitmask_size = ( mb_count + 7 ) >> 3 ;
if ( bitmask_size > buf_size - 12 ) {
av_log ( s -> jpg . avctx , AV_LOG_ERROR , "MXM bitmask is not complete\n" ) ;
return AVERROR ( EINVAL ) ;
}
if ( s -> bitmask_size != bitmask_size ) {
av_freep ( & s -> mxm_bitmask ) ;
s -> mxm_bitmask = av_malloc ( bitmask_size ) ;
if ( ! s -> mxm_bitmask ) {
av_log ( s -> jpg . avctx , AV_LOG_ERROR , "MXM bitmask memory allocation error\n" ) ;
return AVERROR ( ENOMEM ) ;
}
av_freep ( & s -> completion_bitmask ) ;
s -> completion_bitmask = av_mallocz ( bitmask_size ) ;
if ( ! s -> completion_bitmask ) {
av_log ( s -> jpg . avctx , AV_LOG_ERROR , "Completion bitmask memory allocation error\n" ) ;
return AVERROR ( ENOMEM ) ;
}
s -> bitmask_size = bitmask_size ;
}
memcpy ( s -> mxm_bitmask , buf_ptr + 12 , bitmask_size ) ;
s -> got_mxm_bitmask = 1 ;
if ( ! s -> has_complete_frame ) {
uint8_t completion_check = 0xFF ;
for ( i = 0 ;
i < bitmask_size ;
++ i ) {
s -> completion_bitmask [ i ] |= s -> mxm_bitmask [ i ] ;
completion_check &= s -> completion_bitmask [ i ] ;
}
s -> has_complete_frame = ! ( completion_check ^ 0xFF ) ;
}
return 0 ;
}
|
6,632,536,031,698,733,000 |
debian
| 7 | 0 |
static void default_print_section_footer ( WriterContext * wctx ) {
DefaultContext * def = wctx -> priv ;
const struct section * section = wctx -> section [ wctx -> level ] ;
char buf [ 32 ] ;
if ( def -> noprint_wrappers || def -> nested_section [ wctx -> level ] ) return ;
if ( ! ( section -> flags & ( SECTION_FLAG_IS_WRAPPER | SECTION_FLAG_IS_ARRAY ) ) ) printf ( "[/%s]\n" , upcase_string ( buf , sizeof ( buf ) , section -> name ) ) ;
}
|
-1,672,864,273,235,910,400 |
debian
| 35 | 0 |
static void _slurm_rpc_dump_front_end ( slurm_msg_t * msg ) {
DEF_TIMERS ;
char * dump = NULL ;
int dump_size = 0 ;
slurm_msg_t response_msg ;
front_end_info_request_msg_t * front_end_req_msg = ( front_end_info_request_msg_t * ) msg -> data ;
slurmctld_lock_t node_read_lock = {
READ_LOCK , NO_LOCK , NO_LOCK , READ_LOCK , NO_LOCK }
;
uid_t uid = g_slurm_auth_get_uid ( msg -> auth_cred , slurmctld_config . auth_info ) ;
START_TIMER ;
debug3 ( "Processing RPC: REQUEST_FRONT_END_INFO from uid=%d" , uid ) ;
lock_slurmctld ( node_read_lock ) ;
if ( ( front_end_req_msg -> last_update - 1 ) >= last_front_end_update ) {
unlock_slurmctld ( node_read_lock ) ;
debug3 ( "_slurm_rpc_dump_front_end, no change" ) ;
slurm_send_rc_msg ( msg , SLURM_NO_CHANGE_IN_DATA ) ;
}
else {
pack_all_front_end ( & dump , & dump_size , uid , msg -> protocol_version ) ;
unlock_slurmctld ( node_read_lock ) ;
END_TIMER2 ( "_slurm_rpc_dump_front_end" ) ;
debug2 ( "_slurm_rpc_dump_front_end, size=%d %s" , dump_size , TIME_STR ) ;
slurm_msg_t_init ( & response_msg ) ;
response_msg . flags = msg -> flags ;
response_msg . protocol_version = msg -> protocol_version ;
response_msg . address = msg -> address ;
response_msg . conn = msg -> conn ;
response_msg . msg_type = RESPONSE_FRONT_END_INFO ;
response_msg . data = dump ;
response_msg . data_size = dump_size ;
slurm_send_node_msg ( msg -> conn_fd , & response_msg ) ;
xfree ( dump ) ;
}
}
|
6,323,824,267,898,511,000 |
debian
| 110 | 0 |
static void fast_cmyk_to_gray ( fz_context * ctx , fz_pixmap * dst , fz_pixmap * src , fz_colorspace * prf , const fz_default_colorspaces * default_cs , const fz_color_params * color_params , int copy_spots ) {
unsigned char * s = src -> samples ;
unsigned char * d = dst -> samples ;
size_t w = src -> w ;
int h = src -> h ;
int sn = src -> n ;
int ss = src -> s ;
int sa = src -> alpha ;
int dn = dst -> n ;
int ds = dst -> s ;
int da = dst -> alpha ;
ptrdiff_t d_line_inc = dst -> stride - w * dn ;
ptrdiff_t s_line_inc = src -> stride - w * sn ;
if ( ( copy_spots && ss != ds ) || ( ! da && sa ) ) {
assert ( "This should never happen" == NULL ) ;
fz_throw ( ctx , FZ_ERROR_GENERIC , "Cannot convert between incompatible pixmaps" ) ;
}
if ( ( int ) w < 0 || h < 0 ) return ;
if ( d_line_inc == 0 && s_line_inc == 0 ) {
w *= h ;
h = 1 ;
}
if ( ss == 0 && ds == 0 ) {
if ( da ) {
if ( sa ) {
while ( h -- ) {
size_t ww = w ;
while ( ww -- ) {
unsigned char c = fz_mul255 ( s [ 0 ] , 77 ) ;
unsigned char m = fz_mul255 ( s [ 1 ] , 150 ) ;
unsigned char y = fz_mul255 ( s [ 2 ] , 28 ) ;
d [ 0 ] = 255 - ( unsigned char ) fz_mini ( c + m + y + s [ 3 ] , 255 ) ;
d [ 1 ] = s [ 4 ] ;
s += 5 ;
d += 2 ;
}
d += d_line_inc ;
s += s_line_inc ;
}
}
else {
while ( h -- ) {
size_t ww = w ;
while ( ww -- ) {
unsigned char c = fz_mul255 ( s [ 0 ] , 77 ) ;
unsigned char m = fz_mul255 ( s [ 1 ] , 150 ) ;
unsigned char y = fz_mul255 ( s [ 2 ] , 28 ) ;
d [ 0 ] = 255 - ( unsigned char ) fz_mini ( c + m + y + s [ 3 ] , 255 ) ;
d [ 1 ] = 255 ;
s += 3 ;
d += 2 ;
}
d += d_line_inc ;
s += s_line_inc ;
}
}
}
else {
while ( h -- ) {
size_t ww = w ;
while ( ww -- ) {
unsigned char c = fz_mul255 ( s [ 0 ] , 77 ) ;
unsigned char m = fz_mul255 ( s [ 1 ] , 150 ) ;
unsigned char y = fz_mul255 ( s [ 2 ] , 28 ) ;
d [ 0 ] = 255 - ( unsigned char ) fz_mini ( c + m + y + s [ 3 ] , 255 ) ;
s += 4 ;
d ++ ;
}
d += d_line_inc ;
s += s_line_inc ;
}
}
}
else if ( copy_spots ) {
while ( h -- ) {
int i ;
size_t ww = w ;
while ( ww -- ) {
unsigned char c = fz_mul255 ( s [ 0 ] , 77 ) ;
unsigned char m = fz_mul255 ( s [ 1 ] , 150 ) ;
unsigned char y = fz_mul255 ( s [ 2 ] , 28 ) ;
d [ 0 ] = 255 - ( unsigned char ) fz_mini ( c + m + y + s [ 3 ] , 255 ) ;
s += 4 ;
d ++ ;
for ( i = ss ;
i > 0 ;
i -- ) * d ++ = * s ++ ;
if ( da ) * d ++ = sa ? * s ++ : 255 ;
}
d += d_line_inc ;
s += s_line_inc ;
}
}
else {
while ( h -- ) {
size_t ww = w ;
while ( ww -- ) {
unsigned char c = fz_mul255 ( 255 - s [ 0 ] , 77 ) ;
unsigned char m = fz_mul255 ( 255 - s [ 1 ] , 150 ) ;
unsigned char y = fz_mul255 ( 255 - s [ 2 ] , 28 ) ;
d [ 0 ] = ( unsigned char ) fz_maxi ( s [ 3 ] - c - m - y , 0 ) ;
s += sn ;
d += dn ;
if ( da ) d [ - 1 ] = sa ? s [ - 1 ] : 255 ;
}
d += d_line_inc ;
s += s_line_inc ;
}
}
}
|
-6,068,976,579,504,841,000 |
debian
| 35 | 0 |
static void ctl_putdata ( const char * dp , unsigned int dlen , int bin ) {
int overhead ;
unsigned int currentlen ;
overhead = 0 ;
if ( ! bin ) {
datanotbinflag = TRUE ;
overhead = 3 ;
if ( datasent ) {
* datapt ++ = ',' ;
datalinelen ++ ;
if ( ( dlen + datalinelen + 1 ) >= MAXDATALINELEN ) {
* datapt ++ = '\r' ;
* datapt ++ = '\n' ;
datalinelen = 0 ;
}
else {
* datapt ++ = ' ' ;
datalinelen ++ ;
}
}
}
while ( dlen + overhead + datapt > dataend ) {
currentlen = MIN ( dlen , ( unsigned int ) ( dataend - datapt ) ) ;
memcpy ( datapt , dp , currentlen ) ;
datapt += currentlen ;
dp += currentlen ;
dlen -= currentlen ;
datalinelen += currentlen ;
ctl_flushpkt ( CTL_MORE ) ;
}
memcpy ( datapt , dp , dlen ) ;
datapt += dlen ;
datalinelen += dlen ;
datasent = TRUE ;
}
|
-1,919,011,628,477,389,000 |
debian
| 24 | 0 |
static void openpic_set_irq ( void * opaque , int n_IRQ , int level ) {
OpenPICState * opp = opaque ;
IRQSource * src ;
if ( n_IRQ >= OPENPIC_MAX_IRQ ) {
fprintf ( stderr , "%s: IRQ %d out of range\n" , __func__ , n_IRQ ) ;
abort ( ) ;
}
src = & opp -> src [ n_IRQ ] ;
DPRINTF ( "openpic: set irq %d = %d ivpr=0x%08x\n" , n_IRQ , level , src -> ivpr ) ;
if ( src -> level ) {
src -> pending = level ;
openpic_update_irq ( opp , n_IRQ ) ;
}
else {
if ( level ) {
src -> pending = 1 ;
openpic_update_irq ( opp , n_IRQ ) ;
}
if ( src -> output != OPENPIC_OUTPUT_INT ) {
src -> pending = 0 ;
openpic_update_irq ( opp , n_IRQ ) ;
}
}
}
|
7,749,168,290,238,235,000 |
debian
| 19 | 0 |
static int test_forward_match ( xd3_stream * stream , int unused ) {
usize_t i ;
uint8_t buf1 [ 256 ] , buf2 [ 256 ] ;
memset ( buf1 , 0 , 256 ) ;
memset ( buf2 , 0 , 256 ) ;
for ( i = 0 ;
i < 256 ;
i ++ ) {
CHECK ( xd3_forward_match ( buf1 , buf2 , i ) == ( int ) i ) ;
}
for ( i = 0 ;
i < 255 ;
i ++ ) {
buf2 [ i ] = 1 ;
CHECK ( xd3_forward_match ( buf1 , buf2 , 256 ) == ( int ) i ) ;
buf2 [ i ] = 0 ;
}
return 0 ;
}
|
-4,558,261,210,024,070,700 |
chrome
| 7 | 1 |
xmlListPtr xmlListDup ( const xmlListPtr old ) {
xmlListPtr cur ;
if ( old == NULL ) return ( NULL ) ;
if ( NULL == ( cur = xmlListCreate ( NULL , old -> linkCompare ) ) ) return ( NULL ) ;
if ( 0 != xmlListCopy ( cur , old ) ) return NULL ;
return cur ;
}
|
-3,528,294,111,382,233,600 |
chrome
| 3 | 1 |
static void _Latin1GetUnicodeSet ( const UConverter * cnv , const USetAdder * sa , UConverterUnicodeSet which , UErrorCode * pErrorCode ) {
sa -> addRange ( sa -> set , 0 , 0xff ) ;
}
|
2,100,112,064,176,019,200 |
chrome
| 15 | 0 |
xsltDocumentPtr xsltNewStyleDocument ( xsltStylesheetPtr style , xmlDocPtr doc ) {
xsltDocumentPtr cur ;
cur = ( xsltDocumentPtr ) xmlMalloc ( sizeof ( xsltDocument ) ) ;
if ( cur == NULL ) {
xsltTransformError ( NULL , style , ( xmlNodePtr ) doc , "xsltNewStyleDocument : malloc failed\n" ) ;
return ( NULL ) ;
}
memset ( cur , 0 , sizeof ( xsltDocument ) ) ;
cur -> doc = doc ;
if ( style != NULL ) {
cur -> next = style -> docList ;
style -> docList = cur ;
}
return ( cur ) ;
}
|
-1,335,877,942,018,854,400 |
chrome
| 9 | 0 |
IN_PROC_BROWSER_TEST_F ( FastUnloadTest , BrowserListForceCloseWithBeforeUnloadWithFastUnload ) {
NavigateToDataURL ( BEFORE_UNLOAD_HTML , "beforeunload" ) ;
content : : WindowedNotificationObserver window_observer ( chrome : : NOTIFICATION_BROWSER_CLOSED , content : : NotificationService : : AllSources ( ) ) ;
UnloadResults unload_results ;
BrowserList : : CloseAllBrowsersWithProfile ( browser ( ) -> profile ( ) , base : : Bind ( & UnloadResults : : AddSuccess , base : : Unretained ( & unload_results ) ) , base : : Bind ( & UnloadResults : : AddAbort , base : : Unretained ( & unload_results ) ) , true ) ;
window_observer . Wait ( ) ;
EXPECT_EQ ( 1 , unload_results . get_successes ( ) ) ;
EXPECT_EQ ( 0 , unload_results . get_aborts ( ) ) ;
}
|
914,926,989,019,402,500 |
debian
| 16 | 0 |
static int main_external_compression_finish ( void ) {
int i ;
int ret ;
for ( i = 0 ;
i < num_subprocs ;
i += 1 ) {
if ( ! ext_subprocs [ i ] ) {
continue ;
}
if ( ( ret = main_waitpid_check ( ext_subprocs [ i ] ) ) ) {
return ret ;
}
ext_subprocs [ i ] = 0 ;
}
return 0 ;
}
|
-8,054,970,867,770,516,000 |
debian
| 29 | 1 |
static void sliplink_print ( netdissect_options * ndo , register const u_char * p , register const struct ip * ip , register u_int length ) {
int dir ;
u_int hlen ;
dir = p [ SLX_DIR ] ;
ND_PRINT ( ( ndo , dir == SLIPDIR_IN ? "I " : "O " ) ) ;
if ( ndo -> ndo_nflag ) {
register int i ;
for ( i = SLX_CHDR ;
i < SLX_CHDR + CHDR_LEN - 1 ;
++ i ) ND_PRINT ( ( ndo , "%02x." , p [ i ] ) ) ;
ND_PRINT ( ( ndo , "%02x: " , p [ SLX_CHDR + CHDR_LEN - 1 ] ) ) ;
return ;
}
switch ( p [ SLX_CHDR ] & 0xf0 ) {
case TYPE_IP : ND_PRINT ( ( ndo , "ip %d: " , length + SLIP_HDRLEN ) ) ;
break ;
case TYPE_UNCOMPRESSED_TCP : lastconn = ( ( const struct ip * ) & p [ SLX_CHDR ] ) -> ip_p ;
hlen = IP_HL ( ip ) ;
hlen += TH_OFF ( ( const struct tcphdr * ) & ( ( const int * ) ip ) [ hlen ] ) ;
lastlen [ dir ] [ lastconn ] = length - ( hlen << 2 ) ;
ND_PRINT ( ( ndo , "utcp %d: " , lastconn ) ) ;
break ;
default : if ( p [ SLX_CHDR ] & TYPE_COMPRESSED_TCP ) {
compressed_sl_print ( ndo , & p [ SLX_CHDR ] , ip , length , dir ) ;
ND_PRINT ( ( ndo , ": " ) ) ;
}
else ND_PRINT ( ( ndo , "slip-%d!: " , p [ SLX_CHDR ] ) ) ;
}
}
|
-331,579,171,381,918,900 |
debian
| 7 | 0 |
int SRP_VBASE_free ( SRP_VBASE * vb ) {
sk_SRP_user_pwd_pop_free ( vb -> users_pwd , SRP_user_pwd_free ) ;
sk_SRP_gN_cache_free ( vb -> gN_cache ) ;
OPENSSL_free ( vb -> seed_key ) ;
OPENSSL_free ( vb ) ;
return 0 ;
}
|
2,687,336,064,028,423,000 |
chrome
| 6 | 0 |
static const char * debug_ntoa ( u32 address ) {
static char buf [ 32 ] ;
u32 a = ntohl ( address ) ;
evutil_snprintf ( buf , sizeof ( buf ) , "%d.%d.%d.%d" , ( int ) ( u8 ) ( ( a >> 24 ) & 0xff ) , ( int ) ( u8 ) ( ( a >> 16 ) & 0xff ) , ( int ) ( u8 ) ( ( a >> 8 ) & 0xff ) , ( int ) ( u8 ) ( ( a ) & 0xff ) ) ;
return buf ;
}
|
-2,648,356,651,055,439,400 |
debian
| 3 | 0 |
static gboolean gsm_a_bssmap_stat_packet ( void * tapdata , packet_info * pinfo _U_ , epan_dissect_t * edt _U_ , const void * gatr_ptr ) {
return gsm_a_stat_packet ( tapdata , gatr_ptr , BSSAP_PDU_TYPE_BSSMAP , 0 ) ;
}
|
-6,333,668,321,124,139,000 |
debian
| 41 | 1 |
void srtp_add_address ( packet_info * pinfo , address * addr , int port , int other_port , const gchar * setup_method , guint32 setup_frame_number , gboolean is_video _U_ , GHashTable * rtp_dyn_payload , struct srtp_info * srtp_info ) {
address null_addr ;
conversation_t * p_conv ;
struct _rtp_conversation_info * p_conv_data = NULL ;
if ( ( pinfo -> fd -> flags . visited ) || ( rtp_handle == NULL ) ) {
return ;
}
DPRINT ( ( "#%u: %srtp_add_address(%s, %u, %u, %s, %u)" , pinfo -> fd -> num , ( srtp_info ) ? "s" : "" , ep_address_to_str ( addr ) , port , other_port , setup_method , setup_frame_number ) ) ;
DINDENT ( ) ;
SET_ADDRESS ( & null_addr , AT_NONE , 0 , NULL ) ;
p_conv = find_conversation ( setup_frame_number , addr , & null_addr , PT_UDP , port , other_port , NO_ADDR_B | ( ! other_port ? NO_PORT_B : 0 ) ) ;
DENDENT ( ) ;
DPRINT ( ( "did %sfind conversation" , p_conv ? "" : "NOT " ) ) ;
if ( ! p_conv || p_conv -> setup_frame != setup_frame_number ) {
p_conv = conversation_new ( setup_frame_number , addr , & null_addr , PT_UDP , ( guint32 ) port , ( guint32 ) other_port , NO_ADDR2 | ( ! other_port ? NO_PORT2 : 0 ) ) ;
}
conversation_set_dissector ( p_conv , rtp_handle ) ;
p_conv_data = ( struct _rtp_conversation_info * ) conversation_get_proto_data ( p_conv , proto_rtp ) ;
if ( ! p_conv_data ) {
DPRINT ( ( "creating new conversation data" ) ) ;
p_conv_data = wmem_new ( wmem_file_scope ( ) , struct _rtp_conversation_info ) ;
p_conv_data -> rtp_dyn_payload = NULL ;
p_conv_data -> extended_seqno = 0x10000 ;
p_conv_data -> rtp_conv_info = wmem_new ( wmem_file_scope ( ) , rtp_private_conv_info ) ;
p_conv_data -> rtp_conv_info -> multisegment_pdus = wmem_tree_new ( wmem_file_scope ( ) ) ;
DINDENT ( ) ;
conversation_add_proto_data ( p_conv , proto_rtp , p_conv_data ) ;
DENDENT ( ) ;
}
# ifdef DEBUG_CONVERSATION else {
DPRINT ( ( "conversation already exists" ) ) ;
}
# endif if ( p_conv_data -> rtp_dyn_payload != rtp_dyn_payload ) rtp_free_hash_dyn_payload ( p_conv_data -> rtp_dyn_payload ) ;
g_strlcpy ( p_conv_data -> method , setup_method , MAX_RTP_SETUP_METHOD_SIZE + 1 ) ;
p_conv_data -> frame_number = setup_frame_number ;
p_conv_data -> is_video = is_video ;
p_conv_data -> rtp_dyn_payload = rtp_dyn_payload ;
p_conv_data -> srtp_info = srtp_info ;
p_conv_data -> bta2dp_info = NULL ;
p_conv_data -> btvdp_info = NULL ;
}
|
4,180,964,683,905,831,000 |
debian
| 6 | 0 |
static void selinux_sock_graft ( struct sock * sk , struct socket * parent ) {
struct inode_security_struct * isec = inode_security_novalidate ( SOCK_INODE ( parent ) ) ;
struct sk_security_struct * sksec = sk -> sk_security ;
if ( sk -> sk_family == PF_INET || sk -> sk_family == PF_INET6 || sk -> sk_family == PF_UNIX ) isec -> sid = sksec -> sid ;
sksec -> sclass = isec -> sclass ;
}
|
1,760,449,185,745,615,400 |
debian
| 6 | 0 |
int TSUrlLengthGet ( TSMBuffer bufp , TSMLoc obj ) {
sdk_assert ( sdk_sanity_check_mbuffer ( bufp ) == TS_SUCCESS ) ;
sdk_assert ( sdk_sanity_check_url_handle ( obj ) == TS_SUCCESS ) ;
URLImpl * url_impl = ( URLImpl * ) obj ;
return url_length_get ( url_impl ) ;
}
|
9,046,191,708,840,219,000 |
debian
| 3 | 0 |
static __inline__ __u32 tipc_addr ( unsigned int zone , unsigned int cluster , unsigned int node ) {
return ( zone << TIPC_ZONE_OFFSET ) | ( cluster << TIPC_CLUSTER_OFFSET ) | node ;
}
|
-3,591,633,859,713,840,600 |
debian
| 6 | 0 |
static void ff_init_long_region ( MPADecodeContext * s , GranuleDef * g , int ra1 , int ra2 ) {
int l ;
g -> region_size [ 0 ] = band_index_long [ s -> sample_rate_index ] [ ra1 + 1 ] >> 1 ;
l = FFMIN ( ra1 + ra2 + 2 , 22 ) ;
g -> region_size [ 1 ] = band_index_long [ s -> sample_rate_index ] [ l ] >> 1 ;
}
|
103,178,053,094,187,410 |
chrome
| 91 | 0 |
xmlChar * xsltAttrTemplateValueProcessNode ( xsltTransformContextPtr ctxt , const xmlChar * str , xmlNodePtr inst ) {
xmlChar * ret = NULL ;
const xmlChar * cur ;
xmlChar * expr , * val ;
xmlNsPtr * nsList = NULL ;
int nsNr = 0 ;
if ( str == NULL ) return ( NULL ) ;
if ( * str == 0 ) return ( xmlStrndup ( ( xmlChar * ) "" , 0 ) ) ;
cur = str ;
while ( * cur != 0 ) {
if ( * cur == '{
' ) {
if ( * ( cur + 1 ) == '{
' ) {
cur ++ ;
ret = xmlStrncat ( ret , str , cur - str ) ;
cur ++ ;
str = cur ;
continue ;
}
ret = xmlStrncat ( ret , str , cur - str ) ;
str = cur ;
cur ++ ;
while ( ( * cur != 0 ) && ( * cur != '}
' ) ) {
if ( ( * cur == '\'' ) || ( * cur == '"' ) ) {
char delim = * ( cur ++ ) ;
while ( ( * cur != 0 ) && ( * cur != delim ) ) cur ++ ;
if ( * cur != 0 ) cur ++ ;
}
else cur ++ ;
}
if ( * cur == 0 ) {
xsltTransformError ( ctxt , NULL , inst , "xsltAttrTemplateValueProcessNode: unmatched '{
'\n" ) ;
ret = xmlStrncat ( ret , str , cur - str ) ;
return ( ret ) ;
}
str ++ ;
expr = xmlStrndup ( str , cur - str ) ;
if ( expr == NULL ) return ( ret ) ;
else if ( * expr == '{
' ) {
ret = xmlStrcat ( ret , expr ) ;
xmlFree ( expr ) ;
}
else {
xmlXPathCompExprPtr comp ;
if ( ( nsList == NULL ) && ( inst != NULL ) ) {
int i = 0 ;
nsList = xmlGetNsList ( inst -> doc , inst ) ;
if ( nsList != NULL ) {
while ( nsList [ i ] != NULL ) i ++ ;
nsNr = i ;
}
}
comp = xmlXPathCompile ( expr ) ;
val = xsltEvalXPathStringNs ( ctxt , comp , nsNr , nsList ) ;
xmlXPathFreeCompExpr ( comp ) ;
xmlFree ( expr ) ;
if ( val != NULL ) {
ret = xmlStrcat ( ret , val ) ;
xmlFree ( val ) ;
}
}
cur ++ ;
str = cur ;
}
else if ( * cur == '}
' ) {
cur ++ ;
if ( * cur == '}
' ) {
ret = xmlStrncat ( ret , str , cur - str ) ;
cur ++ ;
str = cur ;
continue ;
}
else {
xsltTransformError ( ctxt , NULL , inst , "xsltAttrTemplateValueProcessNode: unmatched '}
'\n" ) ;
}
}
else cur ++ ;
}
if ( cur != str ) {
ret = xmlStrncat ( ret , str , cur - str ) ;
}
if ( nsList != NULL ) xmlFree ( nsList ) ;
return ( ret ) ;
}
|
6,570,435,103,925,347,000 |
chrome
| 4 | 0 |
void vp9_model_to_full_probs ( const vp9_prob * model , vp9_prob * full ) {
if ( full != model ) vpx_memcpy ( full , model , sizeof ( vp9_prob ) * UNCONSTRAINED_NODES ) ;
extend_to_full_distribution ( & full [ UNCONSTRAINED_NODES ] , model [ PIVOT_NODE ] ) ;
}
|
-39,241,708,394,196,480 |
chrome
| 4 | 0 |
static inline void decompose_cluster ( const hb_ot_shape_normalize_context_t * c , unsigned int end , bool might_short_circuit , bool always_short_circuit ) {
if ( likely ( c -> buffer -> idx + 1 == end ) ) decompose_current_character ( c , might_short_circuit ) ;
else decompose_multi_char_cluster ( c , end , always_short_circuit ) ;
}
|
7,037,573,792,123,851,000 |
debian
| 72 | 0 |
static PHP_MINIT_FUNCTION ( zip ) {
# ifdef PHP_ZIP_USE_OO zend_class_entry ce ;
memcpy ( & zip_object_handlers , zend_get_std_object_handlers ( ) , sizeof ( zend_object_handlers ) ) ;
zip_object_handlers . clone_obj = NULL ;
zip_object_handlers . get_property_ptr_ptr = php_zip_get_property_ptr_ptr ;
zip_object_handlers . get_gc = php_zip_get_gc ;
zip_object_handlers . get_properties = php_zip_get_properties ;
zip_object_handlers . read_property = php_zip_read_property ;
zip_object_handlers . has_property = php_zip_has_property ;
INIT_CLASS_ENTRY ( ce , "ZipArchive" , zip_class_functions ) ;
ce . create_object = php_zip_object_new ;
zip_class_entry = zend_register_internal_class ( & ce TSRMLS_CC ) ;
zend_hash_init ( & zip_prop_handlers , 0 , NULL , NULL , 1 ) ;
php_zip_register_prop_handler ( & zip_prop_handlers , "status" , php_zip_status , NULL , NULL , IS_LONG TSRMLS_CC ) ;
php_zip_register_prop_handler ( & zip_prop_handlers , "statusSys" , php_zip_status_sys , NULL , NULL , IS_LONG TSRMLS_CC ) ;
php_zip_register_prop_handler ( & zip_prop_handlers , "numFiles" , php_zip_get_num_files , NULL , NULL , IS_LONG TSRMLS_CC ) ;
php_zip_register_prop_handler ( & zip_prop_handlers , "filename" , NULL , NULL , php_zipobj_get_filename , IS_STRING TSRMLS_CC ) ;
php_zip_register_prop_handler ( & zip_prop_handlers , "comment" , NULL , php_zipobj_get_zip_comment , NULL , IS_STRING TSRMLS_CC ) ;
REGISTER_ZIP_CLASS_CONST_LONG ( "CREATE" , ZIP_CREATE ) ;
REGISTER_ZIP_CLASS_CONST_LONG ( "EXCL" , ZIP_EXCL ) ;
REGISTER_ZIP_CLASS_CONST_LONG ( "CHECKCONS" , ZIP_CHECKCONS ) ;
REGISTER_ZIP_CLASS_CONST_LONG ( "OVERWRITE" , ZIP_OVERWRITE ) ;
REGISTER_ZIP_CLASS_CONST_LONG ( "FL_NOCASE" , ZIP_FL_NOCASE ) ;
REGISTER_ZIP_CLASS_CONST_LONG ( "FL_NODIR" , ZIP_FL_NODIR ) ;
REGISTER_ZIP_CLASS_CONST_LONG ( "FL_COMPRESSED" , ZIP_FL_COMPRESSED ) ;
REGISTER_ZIP_CLASS_CONST_LONG ( "FL_UNCHANGED" , ZIP_FL_UNCHANGED ) ;
REGISTER_ZIP_CLASS_CONST_LONG ( "CM_DEFAULT" , ZIP_CM_DEFAULT ) ;
REGISTER_ZIP_CLASS_CONST_LONG ( "CM_STORE" , ZIP_CM_STORE ) ;
REGISTER_ZIP_CLASS_CONST_LONG ( "CM_SHRINK" , ZIP_CM_SHRINK ) ;
REGISTER_ZIP_CLASS_CONST_LONG ( "CM_REDUCE_1" , ZIP_CM_REDUCE_1 ) ;
REGISTER_ZIP_CLASS_CONST_LONG ( "CM_REDUCE_2" , ZIP_CM_REDUCE_2 ) ;
REGISTER_ZIP_CLASS_CONST_LONG ( "CM_REDUCE_3" , ZIP_CM_REDUCE_3 ) ;
REGISTER_ZIP_CLASS_CONST_LONG ( "CM_REDUCE_4" , ZIP_CM_REDUCE_4 ) ;
REGISTER_ZIP_CLASS_CONST_LONG ( "CM_IMPLODE" , ZIP_CM_IMPLODE ) ;
REGISTER_ZIP_CLASS_CONST_LONG ( "CM_DEFLATE" , ZIP_CM_DEFLATE ) ;
REGISTER_ZIP_CLASS_CONST_LONG ( "CM_DEFLATE64" , ZIP_CM_DEFLATE64 ) ;
REGISTER_ZIP_CLASS_CONST_LONG ( "CM_PKWARE_IMPLODE" , ZIP_CM_PKWARE_IMPLODE ) ;
REGISTER_ZIP_CLASS_CONST_LONG ( "CM_BZIP2" , ZIP_CM_BZIP2 ) ;
REGISTER_ZIP_CLASS_CONST_LONG ( "CM_LZMA" , ZIP_CM_LZMA ) ;
REGISTER_ZIP_CLASS_CONST_LONG ( "CM_TERSE" , ZIP_CM_TERSE ) ;
REGISTER_ZIP_CLASS_CONST_LONG ( "CM_LZ77" , ZIP_CM_LZ77 ) ;
REGISTER_ZIP_CLASS_CONST_LONG ( "CM_WAVPACK" , ZIP_CM_WAVPACK ) ;
REGISTER_ZIP_CLASS_CONST_LONG ( "CM_PPMD" , ZIP_CM_PPMD ) ;
REGISTER_ZIP_CLASS_CONST_LONG ( "ER_OK" , ZIP_ER_OK ) ;
REGISTER_ZIP_CLASS_CONST_LONG ( "ER_MULTIDISK" , ZIP_ER_MULTIDISK ) ;
REGISTER_ZIP_CLASS_CONST_LONG ( "ER_RENAME" , ZIP_ER_RENAME ) ;
REGISTER_ZIP_CLASS_CONST_LONG ( "ER_CLOSE" , ZIP_ER_CLOSE ) ;
REGISTER_ZIP_CLASS_CONST_LONG ( "ER_SEEK" , ZIP_ER_SEEK ) ;
REGISTER_ZIP_CLASS_CONST_LONG ( "ER_READ" , ZIP_ER_READ ) ;
REGISTER_ZIP_CLASS_CONST_LONG ( "ER_WRITE" , ZIP_ER_WRITE ) ;
REGISTER_ZIP_CLASS_CONST_LONG ( "ER_CRC" , ZIP_ER_CRC ) ;
REGISTER_ZIP_CLASS_CONST_LONG ( "ER_ZIPCLOSED" , ZIP_ER_ZIPCLOSED ) ;
REGISTER_ZIP_CLASS_CONST_LONG ( "ER_NOENT" , ZIP_ER_NOENT ) ;
REGISTER_ZIP_CLASS_CONST_LONG ( "ER_EXISTS" , ZIP_ER_EXISTS ) ;
REGISTER_ZIP_CLASS_CONST_LONG ( "ER_OPEN" , ZIP_ER_OPEN ) ;
REGISTER_ZIP_CLASS_CONST_LONG ( "ER_TMPOPEN" , ZIP_ER_TMPOPEN ) ;
REGISTER_ZIP_CLASS_CONST_LONG ( "ER_ZLIB" , ZIP_ER_ZLIB ) ;
REGISTER_ZIP_CLASS_CONST_LONG ( "ER_MEMORY" , ZIP_ER_MEMORY ) ;
REGISTER_ZIP_CLASS_CONST_LONG ( "ER_CHANGED" , ZIP_ER_CHANGED ) ;
REGISTER_ZIP_CLASS_CONST_LONG ( "ER_COMPNOTSUPP" , ZIP_ER_COMPNOTSUPP ) ;
REGISTER_ZIP_CLASS_CONST_LONG ( "ER_EOF" , ZIP_ER_EOF ) ;
REGISTER_ZIP_CLASS_CONST_LONG ( "ER_INVAL" , ZIP_ER_INVAL ) ;
REGISTER_ZIP_CLASS_CONST_LONG ( "ER_NOZIP" , ZIP_ER_NOZIP ) ;
REGISTER_ZIP_CLASS_CONST_LONG ( "ER_INTERNAL" , ZIP_ER_INTERNAL ) ;
REGISTER_ZIP_CLASS_CONST_LONG ( "ER_INCONS" , ZIP_ER_INCONS ) ;
REGISTER_ZIP_CLASS_CONST_LONG ( "ER_REMOVE" , ZIP_ER_REMOVE ) ;
REGISTER_ZIP_CLASS_CONST_LONG ( "ER_DELETED" , ZIP_ER_DELETED ) ;
php_register_url_stream_wrapper ( "zip" , & php_stream_zip_wrapper TSRMLS_CC ) ;
# endif le_zip_dir = zend_register_list_destructors_ex ( php_zip_free_dir , NULL , le_zip_dir_name , module_number ) ;
le_zip_entry = zend_register_list_destructors_ex ( php_zip_free_entry , NULL , le_zip_entry_name , module_number ) ;
return SUCCESS ;
}
|
7,072,059,544,915,634,000 |
chrome
| 404 | 0 |
static void U_CALLCONV _LMBCSOpen ## n ( UConverter * _this , UConverterLoadArgs * pArgs , UErrorCode * err ) \ {
_LMBCSOpenWorker ( _this , pArgs , err , n ) ;
}
static void _LMBCSOpenWorker ( UConverter * _this , UConverterLoadArgs * pArgs , UErrorCode * err , ulmbcs_byte_t OptGroup ) {
UConverterDataLMBCS * extraInfo = ( UConverterDataLMBCS * ) uprv_malloc ( sizeof ( UConverterDataLMBCS ) ) ;
_this -> extraInfo = extraInfo ;
if ( extraInfo != NULL ) {
UConverterNamePieces stackPieces ;
UConverterLoadArgs stackArgs = UCNV_LOAD_ARGS_INITIALIZER ;
ulmbcs_byte_t i ;
uprv_memset ( extraInfo , 0 , sizeof ( UConverterDataLMBCS ) ) ;
stackArgs . onlyTestIsLoadable = pArgs -> onlyTestIsLoadable ;
for ( i = 0 ;
i <= ULMBCS_GRP_LAST && U_SUCCESS ( * err ) ;
i ++ ) {
if ( OptGroupByteToCPName [ i ] != NULL ) {
extraInfo -> OptGrpConverter [ i ] = ucnv_loadSharedData ( OptGroupByteToCPName [ i ] , & stackPieces , & stackArgs , err ) ;
}
}
if ( U_FAILURE ( * err ) || pArgs -> onlyTestIsLoadable ) {
_LMBCSClose ( _this ) ;
return ;
}
extraInfo -> OptGroup = OptGroup ;
extraInfo -> localeConverterIndex = FindLMBCSLocale ( pArgs -> locale ) ;
}
else {
* err = U_MEMORY_ALLOCATION_ERROR ;
}
}
U_CDECL_BEGIN static void U_CALLCONV _LMBCSClose ( UConverter * _this ) {
if ( _this -> extraInfo != NULL ) {
ulmbcs_byte_t Ix ;
UConverterDataLMBCS * extraInfo = ( UConverterDataLMBCS * ) _this -> extraInfo ;
for ( Ix = 0 ;
Ix <= ULMBCS_GRP_LAST ;
Ix ++ ) {
if ( extraInfo -> OptGrpConverter [ Ix ] != NULL ) ucnv_unloadSharedDataIfReady ( extraInfo -> OptGrpConverter [ Ix ] ) ;
}
if ( ! _this -> isExtraLocal ) {
uprv_free ( _this -> extraInfo ) ;
_this -> extraInfo = NULL ;
}
}
}
typedef struct LMBCSClone {
UConverter cnv ;
UConverterDataLMBCS lmbcs ;
}
LMBCSClone ;
static UConverter * U_CALLCONV _LMBCSSafeClone ( const UConverter * cnv , void * stackBuffer , int32_t * pBufferSize , UErrorCode * status ) {
( void ) status ;
LMBCSClone * newLMBCS ;
UConverterDataLMBCS * extraInfo ;
int32_t i ;
if ( * pBufferSize <= 0 ) {
* pBufferSize = ( int32_t ) sizeof ( LMBCSClone ) ;
return NULL ;
}
extraInfo = ( UConverterDataLMBCS * ) cnv -> extraInfo ;
newLMBCS = ( LMBCSClone * ) stackBuffer ;
uprv_memcpy ( & newLMBCS -> lmbcs , extraInfo , sizeof ( UConverterDataLMBCS ) ) ;
for ( i = 0 ;
i <= ULMBCS_GRP_LAST ;
++ i ) {
if ( extraInfo -> OptGrpConverter [ i ] != NULL ) {
ucnv_incrementRefCount ( extraInfo -> OptGrpConverter [ i ] ) ;
}
}
newLMBCS -> cnv . extraInfo = & newLMBCS -> lmbcs ;
newLMBCS -> cnv . isExtraLocal = TRUE ;
return & newLMBCS -> cnv ;
}
static size_t LMBCSConversionWorker ( UConverterDataLMBCS * extraInfo , ulmbcs_byte_t group , ulmbcs_byte_t * pStartLMBCS , UChar * pUniChar , ulmbcs_byte_t * lastConverterIndex , UBool * groups_tried ) {
ulmbcs_byte_t * pLMBCS = pStartLMBCS ;
UConverterSharedData * xcnv = extraInfo -> OptGrpConverter [ group ] ;
int bytesConverted ;
uint32_t value ;
ulmbcs_byte_t firstByte ;
U_ASSERT ( xcnv ) ;
U_ASSERT ( group < ULMBCS_GRP_UNICODE ) ;
bytesConverted = ucnv_MBCSFromUChar32 ( xcnv , * pUniChar , & value , FALSE ) ;
if ( bytesConverted > 0 ) {
firstByte = ( ulmbcs_byte_t ) ( value >> ( ( bytesConverted - 1 ) * 8 ) ) ;
}
else {
groups_tried [ group ] = TRUE ;
return 0 ;
}
* lastConverterIndex = group ;
U_ASSERT ( ( firstByte <= ULMBCS_C0END ) || ( firstByte >= ULMBCS_C1START ) || ( group == ULMBCS_GRP_EXCEPT ) ) ;
if ( group != ULMBCS_GRP_EXCEPT && extraInfo -> OptGroup != group ) {
* pLMBCS ++ = group ;
if ( bytesConverted == 1 && group >= ULMBCS_DOUBLEOPTGROUP_START ) {
* pLMBCS ++ = group ;
}
}
if ( bytesConverted == 1 && firstByte < 0x20 ) return 0 ;
switch ( bytesConverted ) {
case 4 : * pLMBCS ++ = ( ulmbcs_byte_t ) ( value >> 24 ) ;
U_FALLTHROUGH ;
case 3 : * pLMBCS ++ = ( ulmbcs_byte_t ) ( value >> 16 ) ;
U_FALLTHROUGH ;
case 2 : * pLMBCS ++ = ( ulmbcs_byte_t ) ( value >> 8 ) ;
U_FALLTHROUGH ;
case 1 : * pLMBCS ++ = ( ulmbcs_byte_t ) value ;
U_FALLTHROUGH ;
default : break ;
}
return ( pLMBCS - pStartLMBCS ) ;
}
static size_t LMBCSConvertUni ( ulmbcs_byte_t * pLMBCS , UChar uniChar ) {
uint8_t LowCh = ( uint8_t ) ( uniChar & 0x00FF ) ;
uint8_t HighCh = ( uint8_t ) ( uniChar >> 8 ) ;
* pLMBCS ++ = ULMBCS_GRP_UNICODE ;
if ( LowCh == 0 ) {
* pLMBCS ++ = ULMBCS_UNICOMPATZERO ;
* pLMBCS ++ = HighCh ;
}
else {
* pLMBCS ++ = HighCh ;
* pLMBCS ++ = LowCh ;
}
return ULMBCS_UNICODE_SIZE ;
}
static void U_CALLCONV _LMBCSFromUnicode ( UConverterFromUnicodeArgs * args , UErrorCode * err ) {
ulmbcs_byte_t lastConverterIndex = 0 ;
UChar uniChar ;
ulmbcs_byte_t LMBCS [ ULMBCS_CHARSIZE_MAX ] ;
ulmbcs_byte_t * pLMBCS ;
int32_t bytes_written ;
UBool groups_tried [ ULMBCS_GRP_LAST + 1 ] ;
UConverterDataLMBCS * extraInfo = ( UConverterDataLMBCS * ) args -> converter -> extraInfo ;
int sourceIndex = 0 ;
ulmbcs_byte_t OldConverterIndex = 0 ;
while ( args -> source < args -> sourceLimit && ! U_FAILURE ( * err ) ) {
OldConverterIndex = extraInfo -> localeConverterIndex ;
if ( args -> target >= args -> targetLimit ) {
* err = U_BUFFER_OVERFLOW_ERROR ;
break ;
}
uniChar = * ( args -> source ) ;
bytes_written = 0 ;
pLMBCS = LMBCS ;
if ( ( uniChar >= 0x80 ) && ( uniChar <= 0xff ) && ( uniChar != 0xB1 ) && ( uniChar != 0xD7 ) && ( uniChar != 0xF7 ) && ( uniChar != 0xB0 ) && ( uniChar != 0xB4 ) && ( uniChar != 0xB6 ) && ( uniChar != 0xA7 ) && ( uniChar != 0xA8 ) ) {
extraInfo -> localeConverterIndex = ULMBCS_GRP_L1 ;
}
if ( ( ( uniChar > ULMBCS_C0END ) && ( uniChar < ULMBCS_C1START ) ) || uniChar == 0 || uniChar == ULMBCS_HT || uniChar == ULMBCS_CR || uniChar == ULMBCS_LF || uniChar == ULMBCS_123SYSTEMRANGE ) {
* pLMBCS ++ = ( ulmbcs_byte_t ) uniChar ;
bytes_written = 1 ;
}
if ( ! bytes_written ) {
ulmbcs_byte_t group = FindLMBCSUniRange ( uniChar ) ;
if ( group == ULMBCS_GRP_UNICODE ) {
pLMBCS += LMBCSConvertUni ( pLMBCS , uniChar ) ;
bytes_written = ( int32_t ) ( pLMBCS - LMBCS ) ;
}
else if ( group == ULMBCS_GRP_CTRL ) {
if ( uniChar <= ULMBCS_C0END ) {
* pLMBCS ++ = ULMBCS_GRP_CTRL ;
* pLMBCS ++ = ( ulmbcs_byte_t ) ( ULMBCS_CTRLOFFSET + uniChar ) ;
}
else if ( uniChar >= ULMBCS_C1START && uniChar <= ULMBCS_C1START + ULMBCS_CTRLOFFSET ) {
* pLMBCS ++ = ULMBCS_GRP_CTRL ;
* pLMBCS ++ = ( ulmbcs_byte_t ) ( uniChar & 0x00FF ) ;
}
bytes_written = ( int32_t ) ( pLMBCS - LMBCS ) ;
}
else if ( group < ULMBCS_GRP_UNICODE ) {
bytes_written = ( int32_t ) LMBCSConversionWorker ( extraInfo , group , pLMBCS , & uniChar , & lastConverterIndex , groups_tried ) ;
}
if ( ! bytes_written ) {
uprv_memset ( groups_tried , 0 , sizeof ( groups_tried ) ) ;
if ( ( extraInfo -> OptGroup != 1 ) && ( ULMBCS_AMBIGUOUS_MATCH ( group , extraInfo -> OptGroup ) ) ) {
if ( extraInfo -> localeConverterIndex < ULMBCS_DOUBLEOPTGROUP_START ) {
bytes_written = LMBCSConversionWorker ( extraInfo , ULMBCS_GRP_L1 , pLMBCS , & uniChar , & lastConverterIndex , groups_tried ) ;
if ( ! bytes_written ) {
bytes_written = LMBCSConversionWorker ( extraInfo , ULMBCS_GRP_EXCEPT , pLMBCS , & uniChar , & lastConverterIndex , groups_tried ) ;
}
if ( ! bytes_written ) {
bytes_written = LMBCSConversionWorker ( extraInfo , extraInfo -> localeConverterIndex , pLMBCS , & uniChar , & lastConverterIndex , groups_tried ) ;
}
}
else {
bytes_written = LMBCSConversionWorker ( extraInfo , extraInfo -> localeConverterIndex , pLMBCS , & uniChar , & lastConverterIndex , groups_tried ) ;
}
}
if ( ! bytes_written && ( extraInfo -> localeConverterIndex ) && ( ULMBCS_AMBIGUOUS_MATCH ( group , extraInfo -> localeConverterIndex ) ) ) {
bytes_written = ( int32_t ) LMBCSConversionWorker ( extraInfo , extraInfo -> localeConverterIndex , pLMBCS , & uniChar , & lastConverterIndex , groups_tried ) ;
}
if ( ! bytes_written && ( lastConverterIndex ) && ( ULMBCS_AMBIGUOUS_MATCH ( group , lastConverterIndex ) ) ) {
bytes_written = ( int32_t ) LMBCSConversionWorker ( extraInfo , lastConverterIndex , pLMBCS , & uniChar , & lastConverterIndex , groups_tried ) ;
}
if ( ! bytes_written ) {
ulmbcs_byte_t grp_start ;
ulmbcs_byte_t grp_end ;
ulmbcs_byte_t grp_ix ;
grp_start = ( ulmbcs_byte_t ) ( ( group == ULMBCS_AMBIGUOUS_MBCS ) ? ULMBCS_DOUBLEOPTGROUP_START : ULMBCS_GRP_L1 ) ;
grp_end = ( ulmbcs_byte_t ) ( ( group == ULMBCS_AMBIGUOUS_MBCS ) ? ULMBCS_GRP_LAST : ULMBCS_GRP_TH ) ;
if ( group == ULMBCS_AMBIGUOUS_ALL ) {
grp_start = ULMBCS_GRP_L1 ;
grp_end = ULMBCS_GRP_LAST ;
}
for ( grp_ix = grp_start ;
grp_ix <= grp_end && ! bytes_written ;
grp_ix ++ ) {
if ( extraInfo -> OptGrpConverter [ grp_ix ] && ! groups_tried [ grp_ix ] ) {
bytes_written = ( int32_t ) LMBCSConversionWorker ( extraInfo , grp_ix , pLMBCS , & uniChar , & lastConverterIndex , groups_tried ) ;
}
}
if ( ! bytes_written && grp_start == ULMBCS_GRP_L1 ) {
bytes_written = ( int32_t ) LMBCSConversionWorker ( extraInfo , ULMBCS_GRP_EXCEPT , pLMBCS , & uniChar , & lastConverterIndex , groups_tried ) ;
}
}
if ( ! bytes_written ) {
pLMBCS += LMBCSConvertUni ( pLMBCS , uniChar ) ;
bytes_written = ( int32_t ) ( pLMBCS - LMBCS ) ;
}
}
}
args -> source ++ ;
pLMBCS = LMBCS ;
while ( args -> target < args -> targetLimit && bytes_written -- ) {
* ( args -> target ) ++ = * pLMBCS ++ ;
if ( args -> offsets ) {
* ( args -> offsets ) ++ = sourceIndex ;
}
}
sourceIndex ++ ;
if ( bytes_written > 0 ) {
uint8_t * pErrorBuffer = args -> converter -> charErrorBuffer ;
* err = U_BUFFER_OVERFLOW_ERROR ;
args -> converter -> charErrorBufferLength = ( int8_t ) bytes_written ;
while ( bytes_written -- ) {
* pErrorBuffer ++ = * pLMBCS ++ ;
}
}
extraInfo -> localeConverterIndex = OldConverterIndex ;
}
}
static UChar GetUniFromLMBCSUni ( char const * * ppLMBCSin ) {
uint8_t HighCh = * ( * ppLMBCSin ) ++ ;
uint8_t LowCh = * ( * ppLMBCSin ) ++ ;
if ( HighCh == ULMBCS_UNICOMPATZERO ) {
HighCh = LowCh ;
LowCh = 0 ;
}
return ( UChar ) ( ( HighCh << 8 ) | LowCh ) ;
}
# define CHECK_SOURCE_LIMIT ( index ) if ( args -> source + index > args -> sourceLimit ) {
* err = U_TRUNCATED_CHAR_FOUND ;
args -> source = args -> sourceLimit ;
return 0xffff ;
}
static UChar32 U_CALLCONV _LMBCSGetNextUCharWorker ( UConverterToUnicodeArgs * args , UErrorCode * err ) {
UChar32 uniChar = 0 ;
ulmbcs_byte_t CurByte ;
if ( args -> source >= args -> sourceLimit ) {
* err = U_ILLEGAL_ARGUMENT_ERROR ;
return 0xffff ;
}
CurByte = * ( ( ulmbcs_byte_t * ) ( args -> source ++ ) ) ;
if ( ( ( CurByte > ULMBCS_C0END ) && ( CurByte < ULMBCS_C1START ) ) || ( CurByte == 0 ) || CurByte == ULMBCS_HT || CurByte == ULMBCS_CR || CurByte == ULMBCS_LF || CurByte == ULMBCS_123SYSTEMRANGE ) {
uniChar = CurByte ;
}
else {
UConverterDataLMBCS * extraInfo ;
ulmbcs_byte_t group ;
UConverterSharedData * cnv ;
if ( CurByte == ULMBCS_GRP_CTRL ) {
ulmbcs_byte_t C0C1byte ;
CHECK_SOURCE_LIMIT ( 1 ) ;
C0C1byte = * ( args -> source ) ++ ;
uniChar = ( C0C1byte < ULMBCS_C1START ) ? C0C1byte - ULMBCS_CTRLOFFSET : C0C1byte ;
}
else if ( CurByte == ULMBCS_GRP_UNICODE ) {
CHECK_SOURCE_LIMIT ( 2 ) ;
return GetUniFromLMBCSUni ( & ( args -> source ) ) ;
}
else if ( CurByte <= ULMBCS_CTRLOFFSET ) {
group = CurByte ;
extraInfo = ( UConverterDataLMBCS * ) args -> converter -> extraInfo ;
if ( group > ULMBCS_GRP_LAST || ( cnv = extraInfo -> OptGrpConverter [ group ] ) == NULL ) {
* err = U_INVALID_CHAR_FOUND ;
}
else if ( group >= ULMBCS_DOUBLEOPTGROUP_START ) {
CHECK_SOURCE_LIMIT ( 2 ) ;
if ( * args -> source == group ) {
++ args -> source ;
uniChar = ucnv_MBCSSimpleGetNextUChar ( cnv , args -> source , 1 , FALSE ) ;
++ args -> source ;
}
else {
uniChar = ucnv_MBCSSimpleGetNextUChar ( cnv , args -> source , 2 , FALSE ) ;
args -> source += 2 ;
}
}
else {
CHECK_SOURCE_LIMIT ( 1 ) ;
CurByte = * ( args -> source ) ++ ;
if ( CurByte >= ULMBCS_C1START ) {
uniChar = _MBCS_SINGLE_SIMPLE_GET_NEXT_BMP ( cnv , CurByte ) ;
}
else {
char bytes [ 2 ] ;
extraInfo = ( UConverterDataLMBCS * ) args -> converter -> extraInfo ;
cnv = extraInfo -> OptGrpConverter [ ULMBCS_GRP_EXCEPT ] ;
bytes [ 0 ] = group ;
bytes [ 1 ] = CurByte ;
uniChar = ucnv_MBCSSimpleGetNextUChar ( cnv , bytes , 2 , FALSE ) ;
}
}
}
else if ( CurByte >= ULMBCS_C1START ) {
extraInfo = ( UConverterDataLMBCS * ) args -> converter -> extraInfo ;
group = extraInfo -> OptGroup ;
cnv = extraInfo -> OptGrpConverter [ group ] ;
if ( group >= ULMBCS_DOUBLEOPTGROUP_START ) {
if ( ! ucnv_MBCSIsLeadByte ( cnv , CurByte ) ) {
CHECK_SOURCE_LIMIT ( 0 ) ;
uniChar = ucnv_MBCSSimpleGetNextUChar ( cnv , args -> source - 1 , 1 , FALSE ) ;
}
else {
CHECK_SOURCE_LIMIT ( 1 ) ;
uniChar = ucnv_MBCSSimpleGetNextUChar ( cnv , args -> source - 1 , 2 , FALSE ) ;
++ args -> source ;
}
}
else {
uniChar = _MBCS_SINGLE_SIMPLE_GET_NEXT_BMP ( cnv , CurByte ) ;
}
}
}
return uniChar ;
}
static void U_CALLCONV _LMBCSToUnicodeWithOffsets ( UConverterToUnicodeArgs * args , UErrorCode * err ) {
char LMBCS [ ULMBCS_CHARSIZE_MAX ] ;
UChar uniChar ;
const char * saveSource ;
const char * pStartLMBCS = args -> source ;
const char * errSource = NULL ;
int8_t savebytes = 0 ;
while ( U_SUCCESS ( * err ) && args -> sourceLimit > args -> source && args -> targetLimit > args -> target ) {
saveSource = args -> source ;
if ( args -> converter -> toULength ) {
const char * saveSourceLimit ;
size_t size_old = args -> converter -> toULength ;
size_t size_new_maybe_1 = sizeof ( LMBCS ) - size_old ;
size_t size_new_maybe_2 = args -> sourceLimit - args -> source ;
size_t size_new = ( size_new_maybe_1 < size_new_maybe_2 ) ? size_new_maybe_1 : size_new_maybe_2 ;
uprv_memcpy ( LMBCS , args -> converter -> toUBytes , size_old ) ;
uprv_memcpy ( LMBCS + size_old , args -> source , size_new ) ;
saveSourceLimit = args -> sourceLimit ;
args -> source = errSource = LMBCS ;
args -> sourceLimit = LMBCS + size_old + size_new ;
savebytes = ( int8_t ) ( size_old + size_new ) ;
uniChar = ( UChar ) _LMBCSGetNextUCharWorker ( args , err ) ;
args -> source = saveSource + ( ( args -> source - LMBCS ) - size_old ) ;
args -> sourceLimit = saveSourceLimit ;
if ( * err == U_TRUNCATED_CHAR_FOUND ) {
args -> converter -> toULength = savebytes ;
uprv_memcpy ( args -> converter -> toUBytes , LMBCS , savebytes ) ;
args -> source = args -> sourceLimit ;
* err = U_ZERO_ERROR ;
return ;
}
else {
args -> converter -> toULength = 0 ;
}
}
else {
errSource = saveSource ;
uniChar = ( UChar ) _LMBCSGetNextUCharWorker ( args , err ) ;
savebytes = ( int8_t ) ( args -> source - saveSource ) ;
}
if ( U_SUCCESS ( * err ) ) {
if ( uniChar < 0xfffe ) {
* ( args -> target ) ++ = uniChar ;
if ( args -> offsets ) {
* ( args -> offsets ) ++ = ( int32_t ) ( saveSource - pStartLMBCS ) ;
}
}
else if ( uniChar == 0xfffe ) {
* err = U_INVALID_CHAR_FOUND ;
}
else {
* err = U_ILLEGAL_CHAR_FOUND ;
}
}
}
if ( U_SUCCESS ( * err ) && args -> sourceLimit > args -> source && args -> targetLimit <= args -> target ) {
* err = U_BUFFER_OVERFLOW_ERROR ;
}
else if ( U_FAILURE ( * err ) ) {
args -> converter -> toULength = savebytes ;
if ( savebytes > 0 ) {
uprv_memcpy ( args -> converter -> toUBytes , errSource , savebytes ) ;
}
if ( * err == U_TRUNCATED_CHAR_FOUND ) {
* err = U_ZERO_ERROR ;
}
}
}
DEFINE_LMBCS_OPEN ( 1 ) DEFINE_LMBCS_OPEN ( 2 ) DEFINE_LMBCS_OPEN ( 3 )
|
1,223,258,652,239,369,200 |
debian
| 44 | 0 |
static zend_object_value spl_filesystem_object_clone ( zval * zobject TSRMLS_DC ) {
zend_object_value new_obj_val ;
zend_object * old_object ;
zend_object * new_object ;
zend_object_handle handle = Z_OBJ_HANDLE_P ( zobject ) ;
spl_filesystem_object * intern ;
spl_filesystem_object * source ;
int index , skip_dots ;
old_object = zend_objects_get_address ( zobject TSRMLS_CC ) ;
source = ( spl_filesystem_object * ) old_object ;
new_obj_val = spl_filesystem_object_new_ex ( old_object -> ce , & intern TSRMLS_CC ) ;
new_object = & intern -> std ;
intern -> flags = source -> flags ;
switch ( source -> type ) {
case SPL_FS_INFO : intern -> _path_len = source -> _path_len ;
intern -> _path = estrndup ( source -> _path , source -> _path_len ) ;
intern -> file_name_len = source -> file_name_len ;
intern -> file_name = estrndup ( source -> file_name , intern -> file_name_len ) ;
break ;
case SPL_FS_DIR : spl_filesystem_dir_open ( intern , source -> _path TSRMLS_CC ) ;
skip_dots = SPL_HAS_FLAG ( source -> flags , SPL_FILE_DIR_SKIPDOTS ) ;
for ( index = 0 ;
index < source -> u . dir . index ;
++ index ) {
do {
spl_filesystem_dir_read ( intern TSRMLS_CC ) ;
}
while ( skip_dots && spl_filesystem_is_dot ( intern -> u . dir . entry . d_name ) ) ;
}
intern -> u . dir . index = index ;
break ;
case SPL_FS_FILE : php_error_docref ( NULL TSRMLS_CC , E_ERROR , "An object of class %s cannot be cloned" , old_object -> ce -> name ) ;
break ;
}
intern -> file_class = source -> file_class ;
intern -> info_class = source -> info_class ;
intern -> oth = source -> oth ;
intern -> oth_handler = source -> oth_handler ;
zend_objects_clone_members ( new_object , new_obj_val , old_object , handle TSRMLS_CC ) ;
if ( intern -> oth_handler && intern -> oth_handler -> clone ) {
intern -> oth_handler -> clone ( source , intern TSRMLS_CC ) ;
}
return new_obj_val ;
}
|
3,887,066,622,454,352,400 |
chrome
| 472 | 0 |
int64_t vp9_rd_pick_inter_mode_sb ( VP9_COMP * cpi , MACROBLOCK * x , const TileInfo * const tile , int mi_row , int mi_col , int * returnrate , int64_t * returndistortion , BLOCK_SIZE bsize , PICK_MODE_CONTEXT * ctx , int64_t best_rd_so_far ) {
VP9_COMMON * const cm = & cpi -> common ;
RD_OPT * const rd_opt = & cpi -> rd ;
MACROBLOCKD * const xd = & x -> e_mbd ;
MB_MODE_INFO * const mbmi = & xd -> mi [ 0 ] . src_mi -> mbmi ;
const struct segmentation * const seg = & cm -> seg ;
struct macroblockd_plane * const pd = xd -> plane ;
PREDICTION_MODE this_mode ;
MV_REFERENCE_FRAME ref_frame , second_ref_frame ;
unsigned char segment_id = mbmi -> segment_id ;
int comp_pred , i , k ;
int_mv frame_mv [ MB_MODE_COUNT ] [ MAX_REF_FRAMES ] ;
struct buf_2d yv12_mb [ 4 ] [ MAX_MB_PLANE ] ;
int_mv single_newmv [ MAX_REF_FRAMES ] = {
{
0 }
}
;
INTERP_FILTER single_inter_filter [ MB_MODE_COUNT ] [ MAX_REF_FRAMES ] ;
int single_skippable [ MB_MODE_COUNT ] [ MAX_REF_FRAMES ] ;
static const int flag_list [ 4 ] = {
0 , VP9_LAST_FLAG , VP9_GOLD_FLAG , VP9_ALT_FLAG }
;
int64_t best_rd = best_rd_so_far ;
int64_t best_tx_rd [ TX_MODES ] ;
int64_t best_tx_diff [ TX_MODES ] ;
int64_t best_pred_diff [ REFERENCE_MODES ] ;
int64_t best_pred_rd [ REFERENCE_MODES ] ;
int64_t best_filter_rd [ SWITCHABLE_FILTER_CONTEXTS ] ;
int64_t best_filter_diff [ SWITCHABLE_FILTER_CONTEXTS ] ;
MB_MODE_INFO best_mbmode ;
int best_mode_skippable = 0 ;
int midx , best_mode_index = - 1 ;
unsigned int ref_costs_single [ MAX_REF_FRAMES ] , ref_costs_comp [ MAX_REF_FRAMES ] ;
vp9_prob comp_mode_p ;
int64_t best_intra_rd = INT64_MAX ;
unsigned int best_pred_sse = UINT_MAX ;
PREDICTION_MODE best_intra_mode = DC_PRED ;
int rate_uv_intra [ TX_SIZES ] , rate_uv_tokenonly [ TX_SIZES ] ;
int64_t dist_uv [ TX_SIZES ] ;
int skip_uv [ TX_SIZES ] ;
PREDICTION_MODE mode_uv [ TX_SIZES ] ;
const int intra_cost_penalty = * vp9_dc_quant ( cm -> base_qindex , cm -> y_dc_delta_q , cm -> bit_depth ) ;
int best_skip2 = 0 ;
uint8_t ref_frame_skip_mask [ 2 ] = {
0 }
;
uint16_t mode_skip_mask [ MAX_REF_FRAMES ] = {
0 }
;
int mode_skip_start = cpi -> sf . mode_skip_start + 1 ;
const int * const rd_threshes = rd_opt -> threshes [ segment_id ] [ bsize ] ;
const int * const rd_thresh_freq_fact = rd_opt -> thresh_freq_fact [ bsize ] ;
int mode_threshold [ MAX_MODES ] ;
int * mode_map = rd_opt -> mode_map [ bsize ] ;
const int mode_search_skip_flags = cpi -> sf . mode_search_skip_flags ;
vp9_zero ( best_mbmode ) ;
x -> skip_encode = cpi -> sf . skip_encode_frame && x -> q_index < QIDX_SKIP_THRESH ;
estimate_ref_frame_costs ( cm , xd , segment_id , ref_costs_single , ref_costs_comp , & comp_mode_p ) ;
for ( i = 0 ;
i < REFERENCE_MODES ;
++ i ) best_pred_rd [ i ] = INT64_MAX ;
for ( i = 0 ;
i < TX_MODES ;
i ++ ) best_tx_rd [ i ] = INT64_MAX ;
for ( i = 0 ;
i < SWITCHABLE_FILTER_CONTEXTS ;
i ++ ) best_filter_rd [ i ] = INT64_MAX ;
for ( i = 0 ;
i < TX_SIZES ;
i ++ ) rate_uv_intra [ i ] = INT_MAX ;
for ( i = 0 ;
i < MAX_REF_FRAMES ;
++ i ) x -> pred_sse [ i ] = INT_MAX ;
for ( i = 0 ;
i < MB_MODE_COUNT ;
++ i ) {
for ( k = 0 ;
k < MAX_REF_FRAMES ;
++ k ) {
single_inter_filter [ i ] [ k ] = SWITCHABLE ;
single_skippable [ i ] [ k ] = 0 ;
}
}
* returnrate = INT_MAX ;
for ( ref_frame = LAST_FRAME ;
ref_frame <= ALTREF_FRAME ;
++ ref_frame ) {
x -> pred_mv_sad [ ref_frame ] = INT_MAX ;
if ( cpi -> ref_frame_flags & flag_list [ ref_frame ] ) {
setup_buffer_inter ( cpi , x , tile , ref_frame , bsize , mi_row , mi_col , frame_mv [ NEARESTMV ] , frame_mv [ NEARMV ] , yv12_mb ) ;
}
frame_mv [ NEWMV ] [ ref_frame ] . as_int = INVALID_MV ;
frame_mv [ ZEROMV ] [ ref_frame ] . as_int = 0 ;
}
for ( ref_frame = LAST_FRAME ;
ref_frame <= ALTREF_FRAME ;
++ ref_frame ) {
if ( ! ( cpi -> ref_frame_flags & flag_list [ ref_frame ] ) ) {
ref_frame_skip_mask [ 0 ] |= ( 1 << ref_frame ) ;
ref_frame_skip_mask [ 1 ] |= SECOND_REF_FRAME_MASK ;
}
else if ( cpi -> sf . reference_masking ) {
for ( i = LAST_FRAME ;
i <= ALTREF_FRAME ;
++ i ) {
if ( ( x -> pred_mv_sad [ ref_frame ] >> 2 ) > x -> pred_mv_sad [ i ] ) {
mode_skip_mask [ ref_frame ] |= INTER_NEAREST_NEAR_ZERO ;
break ;
}
}
}
if ( vp9_segfeature_active ( seg , segment_id , SEG_LVL_REF_FRAME ) && vp9_get_segdata ( seg , segment_id , SEG_LVL_REF_FRAME ) != ( int ) ref_frame ) {
ref_frame_skip_mask [ 0 ] |= ( 1 << ref_frame ) ;
ref_frame_skip_mask [ 1 ] |= SECOND_REF_FRAME_MASK ;
}
}
if ( ! vp9_segfeature_active ( seg , segment_id , SEG_LVL_REF_FRAME ) ) {
if ( cpi -> rc . is_src_frame_alt_ref && ( cpi -> oxcf . arnr_max_frames == 0 ) ) {
ref_frame_skip_mask [ 0 ] = ( 1 << LAST_FRAME ) | ( 1 << GOLDEN_FRAME ) ;
ref_frame_skip_mask [ 1 ] = SECOND_REF_FRAME_MASK ;
mode_skip_mask [ ALTREF_FRAME ] = ~ INTER_NEAREST_NEAR_ZERO ;
if ( frame_mv [ NEARMV ] [ ALTREF_FRAME ] . as_int != 0 ) mode_skip_mask [ ALTREF_FRAME ] |= ( 1 << NEARMV ) ;
if ( frame_mv [ NEARESTMV ] [ ALTREF_FRAME ] . as_int != 0 ) mode_skip_mask [ ALTREF_FRAME ] |= ( 1 << NEARESTMV ) ;
}
}
if ( cpi -> rc . is_src_frame_alt_ref ) {
if ( cpi -> sf . alt_ref_search_fp ) {
mode_skip_mask [ ALTREF_FRAME ] = 0 ;
ref_frame_skip_mask [ 0 ] = ~ ( 1 << ALTREF_FRAME ) ;
ref_frame_skip_mask [ 1 ] = SECOND_REF_FRAME_MASK ;
}
}
if ( bsize > cpi -> sf . max_intra_bsize ) {
ref_frame_skip_mask [ 0 ] |= ( 1 << INTRA_FRAME ) ;
ref_frame_skip_mask [ 1 ] |= ( 1 << INTRA_FRAME ) ;
}
mode_skip_mask [ INTRA_FRAME ] |= ~ ( cpi -> sf . intra_y_mode_mask [ max_txsize_lookup [ bsize ] ] ) ;
for ( i = 0 ;
i < MAX_MODES ;
++ i ) mode_threshold [ i ] = ( ( int64_t ) rd_threshes [ i ] * rd_thresh_freq_fact [ i ] ) >> 5 ;
midx = cpi -> sf . schedule_mode_search ? mode_skip_start : 0 ;
while ( midx > 4 ) {
uint8_t end_pos = 0 ;
for ( i = 5 ;
i < midx ;
++ i ) {
if ( mode_threshold [ mode_map [ i - 1 ] ] > mode_threshold [ mode_map [ i ] ] ) {
uint8_t tmp = mode_map [ i ] ;
mode_map [ i ] = mode_map [ i - 1 ] ;
mode_map [ i - 1 ] = tmp ;
end_pos = i ;
}
}
midx = end_pos ;
}
for ( midx = 0 ;
midx < MAX_MODES ;
++ midx ) {
int mode_index = mode_map [ midx ] ;
int mode_excluded = 0 ;
int64_t this_rd = INT64_MAX ;
int disable_skip = 0 ;
int compmode_cost = 0 ;
int rate2 = 0 , rate_y = 0 , rate_uv = 0 ;
int64_t distortion2 = 0 , distortion_y = 0 , distortion_uv = 0 ;
int skippable = 0 ;
int64_t tx_cache [ TX_MODES ] ;
int this_skip2 = 0 ;
int64_t total_sse = INT64_MAX ;
int early_term = 0 ;
this_mode = vp9_mode_order [ mode_index ] . mode ;
ref_frame = vp9_mode_order [ mode_index ] . ref_frame [ 0 ] ;
second_ref_frame = vp9_mode_order [ mode_index ] . ref_frame [ 1 ] ;
if ( midx == mode_skip_start && best_mode_index >= 0 ) {
switch ( best_mbmode . ref_frame [ 0 ] ) {
case INTRA_FRAME : break ;
case LAST_FRAME : ref_frame_skip_mask [ 0 ] |= LAST_FRAME_MODE_MASK ;
ref_frame_skip_mask [ 1 ] |= SECOND_REF_FRAME_MASK ;
break ;
case GOLDEN_FRAME : ref_frame_skip_mask [ 0 ] |= GOLDEN_FRAME_MODE_MASK ;
ref_frame_skip_mask [ 1 ] |= SECOND_REF_FRAME_MASK ;
break ;
case ALTREF_FRAME : ref_frame_skip_mask [ 0 ] |= ALT_REF_MODE_MASK ;
break ;
case NONE : case MAX_REF_FRAMES : assert ( 0 && "Invalid Reference frame" ) ;
break ;
}
}
if ( ref_frame_skip_mask [ 0 ] & ( 1 << ref_frame ) && ref_frame_skip_mask [ 1 ] & ( 1 << MAX ( 0 , second_ref_frame ) ) ) continue ;
if ( mode_skip_mask [ ref_frame ] & ( 1 << this_mode ) ) continue ;
if ( best_mode_skippable && cpi -> sf . schedule_mode_search ) mode_threshold [ mode_index ] <<= 1 ;
if ( best_rd < mode_threshold [ mode_index ] ) continue ;
if ( cpi -> sf . motion_field_mode_search ) {
const int mi_width = MIN ( num_8x8_blocks_wide_lookup [ bsize ] , tile -> mi_col_end - mi_col ) ;
const int mi_height = MIN ( num_8x8_blocks_high_lookup [ bsize ] , tile -> mi_row_end - mi_row ) ;
const int bsl = mi_width_log2 ( bsize ) ;
int cb_partition_search_ctrl = ( ( ( mi_row + mi_col ) >> bsl ) + get_chessboard_index ( cm -> current_video_frame ) ) & 0x1 ;
MB_MODE_INFO * ref_mbmi ;
int const_motion = 1 ;
int skip_ref_frame = ! cb_partition_search_ctrl ;
MV_REFERENCE_FRAME rf = NONE ;
int_mv ref_mv ;
ref_mv . as_int = INVALID_MV ;
if ( ( mi_row - 1 ) >= tile -> mi_row_start ) {
ref_mv = xd -> mi [ - xd -> mi_stride ] . src_mi -> mbmi . mv [ 0 ] ;
rf = xd -> mi [ - xd -> mi_stride ] . src_mi -> mbmi . ref_frame [ 0 ] ;
for ( i = 0 ;
i < mi_width ;
++ i ) {
ref_mbmi = & xd -> mi [ - xd -> mi_stride + i ] . src_mi -> mbmi ;
const_motion &= ( ref_mv . as_int == ref_mbmi -> mv [ 0 ] . as_int ) && ( ref_frame == ref_mbmi -> ref_frame [ 0 ] ) ;
skip_ref_frame &= ( rf == ref_mbmi -> ref_frame [ 0 ] ) ;
}
}
if ( ( mi_col - 1 ) >= tile -> mi_col_start ) {
if ( ref_mv . as_int == INVALID_MV ) ref_mv = xd -> mi [ - 1 ] . src_mi -> mbmi . mv [ 0 ] ;
if ( rf == NONE ) rf = xd -> mi [ - 1 ] . src_mi -> mbmi . ref_frame [ 0 ] ;
for ( i = 0 ;
i < mi_height ;
++ i ) {
ref_mbmi = & xd -> mi [ i * xd -> mi_stride - 1 ] . src_mi -> mbmi ;
const_motion &= ( ref_mv . as_int == ref_mbmi -> mv [ 0 ] . as_int ) && ( ref_frame == ref_mbmi -> ref_frame [ 0 ] ) ;
skip_ref_frame &= ( rf == ref_mbmi -> ref_frame [ 0 ] ) ;
}
}
if ( skip_ref_frame && this_mode != NEARESTMV && this_mode != NEWMV ) if ( rf > INTRA_FRAME ) if ( ref_frame != rf ) continue ;
if ( const_motion ) if ( this_mode == NEARMV || this_mode == ZEROMV ) continue ;
}
comp_pred = second_ref_frame > INTRA_FRAME ;
if ( comp_pred ) {
if ( ! cm -> allow_comp_inter_inter ) continue ;
if ( ! ( cpi -> ref_frame_flags & flag_list [ second_ref_frame ] ) ) continue ;
if ( vp9_segfeature_active ( seg , segment_id , SEG_LVL_REF_FRAME ) ) continue ;
if ( ( mode_search_skip_flags & FLAG_SKIP_COMP_BESTINTRA ) && best_mode_index >= 0 && best_mbmode . ref_frame [ 0 ] == INTRA_FRAME ) continue ;
mode_excluded = cm -> reference_mode == SINGLE_REFERENCE ;
}
else {
if ( ref_frame != INTRA_FRAME ) mode_excluded = cm -> reference_mode == COMPOUND_REFERENCE ;
}
if ( ref_frame == INTRA_FRAME ) {
if ( cpi -> sf . adaptive_mode_search ) if ( ( x -> source_variance << num_pels_log2_lookup [ bsize ] ) > best_pred_sse ) continue ;
if ( this_mode != DC_PRED ) {
const unsigned int skip_intra_var_thresh = 64 ;
if ( ( mode_search_skip_flags & FLAG_SKIP_INTRA_LOWVAR ) && x -> source_variance < skip_intra_var_thresh ) continue ;
if ( ( mode_search_skip_flags & FLAG_SKIP_INTRA_BESTINTER ) && ( this_mode >= D45_PRED && this_mode <= TM_PRED ) ) {
if ( best_mode_index >= 0 && best_mbmode . ref_frame [ 0 ] > INTRA_FRAME ) continue ;
}
if ( mode_search_skip_flags & FLAG_SKIP_INTRA_DIRMISMATCH ) {
if ( conditional_skipintra ( this_mode , best_intra_mode ) ) continue ;
}
}
}
else {
const MV_REFERENCE_FRAME ref_frames [ 2 ] = {
ref_frame , second_ref_frame }
;
if ( ! check_best_zero_mv ( cpi , mbmi -> mode_context , frame_mv , this_mode , ref_frames ) ) continue ;
}
mbmi -> mode = this_mode ;
mbmi -> uv_mode = DC_PRED ;
mbmi -> ref_frame [ 0 ] = ref_frame ;
mbmi -> ref_frame [ 1 ] = second_ref_frame ;
mbmi -> interp_filter = cm -> interp_filter == SWITCHABLE ? EIGHTTAP : cm -> interp_filter ;
mbmi -> mv [ 0 ] . as_int = mbmi -> mv [ 1 ] . as_int = 0 ;
x -> skip = 0 ;
set_ref_ptrs ( cm , xd , ref_frame , second_ref_frame ) ;
for ( i = 0 ;
i < MAX_MB_PLANE ;
i ++ ) {
xd -> plane [ i ] . pre [ 0 ] = yv12_mb [ ref_frame ] [ i ] ;
if ( comp_pred ) xd -> plane [ i ] . pre [ 1 ] = yv12_mb [ second_ref_frame ] [ i ] ;
}
for ( i = 0 ;
i < TX_MODES ;
++ i ) tx_cache [ i ] = INT64_MAX ;
if ( ref_frame == INTRA_FRAME ) {
TX_SIZE uv_tx ;
super_block_yrd ( cpi , x , & rate_y , & distortion_y , & skippable , NULL , bsize , tx_cache , best_rd ) ;
if ( rate_y == INT_MAX ) continue ;
uv_tx = get_uv_tx_size_impl ( mbmi -> tx_size , bsize , pd [ 1 ] . subsampling_x , pd [ 1 ] . subsampling_y ) ;
if ( rate_uv_intra [ uv_tx ] == INT_MAX ) {
choose_intra_uv_mode ( cpi , ctx , bsize , uv_tx , & rate_uv_intra [ uv_tx ] , & rate_uv_tokenonly [ uv_tx ] , & dist_uv [ uv_tx ] , & skip_uv [ uv_tx ] , & mode_uv [ uv_tx ] ) ;
}
rate_uv = rate_uv_tokenonly [ uv_tx ] ;
distortion_uv = dist_uv [ uv_tx ] ;
skippable = skippable && skip_uv [ uv_tx ] ;
mbmi -> uv_mode = mode_uv [ uv_tx ] ;
rate2 = rate_y + cpi -> mbmode_cost [ mbmi -> mode ] + rate_uv_intra [ uv_tx ] ;
if ( this_mode != DC_PRED && this_mode != TM_PRED ) rate2 += intra_cost_penalty ;
distortion2 = distortion_y + distortion_uv ;
}
else {
this_rd = handle_inter_mode ( cpi , x , bsize , tx_cache , & rate2 , & distortion2 , & skippable , & rate_y , & distortion_y , & rate_uv , & distortion_uv , & disable_skip , frame_mv , mi_row , mi_col , single_newmv , single_inter_filter , single_skippable , & total_sse , best_rd ) ;
if ( this_rd == INT64_MAX ) continue ;
compmode_cost = vp9_cost_bit ( comp_mode_p , comp_pred ) ;
if ( cm -> reference_mode == REFERENCE_MODE_SELECT ) rate2 += compmode_cost ;
}
if ( comp_pred ) {
rate2 += ref_costs_comp [ ref_frame ] ;
}
else {
rate2 += ref_costs_single [ ref_frame ] ;
}
if ( ! disable_skip ) {
if ( skippable ) {
rate2 -= ( rate_y + rate_uv ) ;
rate2 += vp9_cost_bit ( vp9_get_skip_prob ( cm , xd ) , 1 ) ;
}
else if ( ref_frame != INTRA_FRAME && ! xd -> lossless ) {
if ( RDCOST ( x -> rdmult , x -> rddiv , rate_y + rate_uv , distortion2 ) < RDCOST ( x -> rdmult , x -> rddiv , 0 , total_sse ) ) {
rate2 += vp9_cost_bit ( vp9_get_skip_prob ( cm , xd ) , 0 ) ;
}
else {
rate2 += vp9_cost_bit ( vp9_get_skip_prob ( cm , xd ) , 1 ) ;
distortion2 = total_sse ;
assert ( total_sse >= 0 ) ;
rate2 -= ( rate_y + rate_uv ) ;
this_skip2 = 1 ;
}
}
else {
rate2 += vp9_cost_bit ( vp9_get_skip_prob ( cm , xd ) , 0 ) ;
}
this_rd = RDCOST ( x -> rdmult , x -> rddiv , rate2 , distortion2 ) ;
}
if ( ref_frame == INTRA_FRAME ) {
if ( this_rd < best_intra_rd ) {
best_intra_rd = this_rd ;
best_intra_mode = mbmi -> mode ;
}
}
if ( ! disable_skip && ref_frame == INTRA_FRAME ) {
for ( i = 0 ;
i < REFERENCE_MODES ;
++ i ) best_pred_rd [ i ] = MIN ( best_pred_rd [ i ] , this_rd ) ;
for ( i = 0 ;
i < SWITCHABLE_FILTER_CONTEXTS ;
i ++ ) best_filter_rd [ i ] = MIN ( best_filter_rd [ i ] , this_rd ) ;
}
if ( this_rd < best_rd || x -> skip ) {
int max_plane = MAX_MB_PLANE ;
if ( ! mode_excluded ) {
best_mode_index = mode_index ;
if ( ref_frame == INTRA_FRAME ) {
mbmi -> mv [ 0 ] . as_int = 0 ;
max_plane = 1 ;
}
else {
best_pred_sse = x -> pred_sse [ ref_frame ] ;
}
* returnrate = rate2 ;
* returndistortion = distortion2 ;
best_rd = this_rd ;
best_mbmode = * mbmi ;
best_skip2 = this_skip2 ;
best_mode_skippable = skippable ;
if ( ! x -> select_tx_size ) swap_block_ptr ( x , ctx , 1 , 0 , 0 , max_plane ) ;
vpx_memcpy ( ctx -> zcoeff_blk , x -> zcoeff_blk [ mbmi -> tx_size ] , sizeof ( uint8_t ) * ctx -> num_4x4_blk ) ;
if ( ( mode_search_skip_flags & FLAG_EARLY_TERMINATE ) && ( mode_index > MIN_EARLY_TERM_INDEX ) ) {
const int qstep = xd -> plane [ 0 ] . dequant [ 1 ] ;
int scale = 4 ;
if ( x -> source_variance < UINT_MAX ) {
const int var_adjust = ( x -> source_variance < 16 ) ;
scale -= var_adjust ;
}
if ( ref_frame > INTRA_FRAME && distortion2 * scale < qstep * qstep ) {
early_term = 1 ;
}
}
}
}
if ( ! disable_skip && ref_frame != INTRA_FRAME ) {
int64_t single_rd , hybrid_rd , single_rate , hybrid_rate ;
if ( cm -> reference_mode == REFERENCE_MODE_SELECT ) {
single_rate = rate2 - compmode_cost ;
hybrid_rate = rate2 ;
}
else {
single_rate = rate2 ;
hybrid_rate = rate2 + compmode_cost ;
}
single_rd = RDCOST ( x -> rdmult , x -> rddiv , single_rate , distortion2 ) ;
hybrid_rd = RDCOST ( x -> rdmult , x -> rddiv , hybrid_rate , distortion2 ) ;
if ( ! comp_pred ) {
if ( single_rd < best_pred_rd [ SINGLE_REFERENCE ] ) best_pred_rd [ SINGLE_REFERENCE ] = single_rd ;
}
else {
if ( single_rd < best_pred_rd [ COMPOUND_REFERENCE ] ) best_pred_rd [ COMPOUND_REFERENCE ] = single_rd ;
}
if ( hybrid_rd < best_pred_rd [ REFERENCE_MODE_SELECT ] ) best_pred_rd [ REFERENCE_MODE_SELECT ] = hybrid_rd ;
if ( ! mode_excluded && cm -> interp_filter != BILINEAR ) {
int64_t ref = rd_opt -> filter_cache [ cm -> interp_filter == SWITCHABLE ? SWITCHABLE_FILTERS : cm -> interp_filter ] ;
for ( i = 0 ;
i < SWITCHABLE_FILTER_CONTEXTS ;
i ++ ) {
int64_t adj_rd ;
if ( ref == INT64_MAX ) adj_rd = 0 ;
else if ( rd_opt -> filter_cache [ i ] == INT64_MAX ) adj_rd = rd_opt -> mask_filter - ref + 10 ;
else adj_rd = rd_opt -> filter_cache [ i ] - ref ;
adj_rd += this_rd ;
best_filter_rd [ i ] = MIN ( best_filter_rd [ i ] , adj_rd ) ;
}
}
}
if ( bsize < BLOCK_32X32 ) {
if ( bsize < BLOCK_16X16 ) tx_cache [ ALLOW_16X16 ] = tx_cache [ ALLOW_8X8 ] ;
tx_cache [ ALLOW_32X32 ] = tx_cache [ ALLOW_16X16 ] ;
}
if ( ! mode_excluded && this_rd != INT64_MAX ) {
for ( i = 0 ;
i < TX_MODES && tx_cache [ i ] < INT64_MAX ;
i ++ ) {
int64_t adj_rd = INT64_MAX ;
adj_rd = this_rd + tx_cache [ i ] - tx_cache [ cm -> tx_mode ] ;
if ( adj_rd < best_tx_rd [ i ] ) best_tx_rd [ i ] = adj_rd ;
}
}
if ( early_term ) break ;
if ( x -> skip && ! comp_pred ) break ;
}
if ( best_mbmode . mode == NEWMV ) {
const MV_REFERENCE_FRAME refs [ 2 ] = {
best_mbmode . ref_frame [ 0 ] , best_mbmode . ref_frame [ 1 ] }
;
int comp_pred_mode = refs [ 1 ] > INTRA_FRAME ;
if ( frame_mv [ NEARESTMV ] [ refs [ 0 ] ] . as_int == best_mbmode . mv [ 0 ] . as_int && ( ( comp_pred_mode && frame_mv [ NEARESTMV ] [ refs [ 1 ] ] . as_int == best_mbmode . mv [ 1 ] . as_int ) || ! comp_pred_mode ) ) best_mbmode . mode = NEARESTMV ;
else if ( frame_mv [ NEARMV ] [ refs [ 0 ] ] . as_int == best_mbmode . mv [ 0 ] . as_int && ( ( comp_pred_mode && frame_mv [ NEARMV ] [ refs [ 1 ] ] . as_int == best_mbmode . mv [ 1 ] . as_int ) || ! comp_pred_mode ) ) best_mbmode . mode = NEARMV ;
else if ( best_mbmode . mv [ 0 ] . as_int == 0 && ( ( comp_pred_mode && best_mbmode . mv [ 1 ] . as_int == 0 ) || ! comp_pred_mode ) ) best_mbmode . mode = ZEROMV ;
}
if ( best_mode_index < 0 || best_rd >= best_rd_so_far ) return INT64_MAX ;
if ( cpi -> sf . use_uv_intra_rd_estimate ) {
if ( best_mbmode . ref_frame [ 0 ] == INTRA_FRAME ) {
TX_SIZE uv_tx_size ;
* mbmi = best_mbmode ;
uv_tx_size = get_uv_tx_size ( mbmi , & xd -> plane [ 1 ] ) ;
rd_pick_intra_sbuv_mode ( cpi , x , ctx , & rate_uv_intra [ uv_tx_size ] , & rate_uv_tokenonly [ uv_tx_size ] , & dist_uv [ uv_tx_size ] , & skip_uv [ uv_tx_size ] , bsize < BLOCK_8X8 ? BLOCK_8X8 : bsize , uv_tx_size ) ;
}
}
assert ( ( cm -> interp_filter == SWITCHABLE ) || ( cm -> interp_filter == best_mbmode . interp_filter ) || ! is_inter_block ( & best_mbmode ) ) ;
if ( ! cpi -> rc . is_src_frame_alt_ref ) update_rd_thresh_fact ( cpi , bsize , best_mode_index ) ;
* mbmi = best_mbmode ;
x -> skip |= best_skip2 ;
for ( i = 0 ;
i < REFERENCE_MODES ;
++ i ) {
if ( best_pred_rd [ i ] == INT64_MAX ) best_pred_diff [ i ] = INT_MIN ;
else best_pred_diff [ i ] = best_rd - best_pred_rd [ i ] ;
}
if ( ! x -> skip ) {
for ( i = 0 ;
i < SWITCHABLE_FILTER_CONTEXTS ;
i ++ ) {
if ( best_filter_rd [ i ] == INT64_MAX ) best_filter_diff [ i ] = 0 ;
else best_filter_diff [ i ] = best_rd - best_filter_rd [ i ] ;
}
if ( cm -> interp_filter == SWITCHABLE ) assert ( best_filter_diff [ SWITCHABLE_FILTERS ] == 0 ) ;
for ( i = 0 ;
i < TX_MODES ;
i ++ ) {
if ( best_tx_rd [ i ] == INT64_MAX ) best_tx_diff [ i ] = 0 ;
else best_tx_diff [ i ] = best_rd - best_tx_rd [ i ] ;
}
}
else {
vp9_zero ( best_filter_diff ) ;
vp9_zero ( best_tx_diff ) ;
}
x -> skip |= best_mode_skippable ;
store_coding_context ( x , ctx , best_mode_index , best_pred_diff , best_tx_diff , best_filter_diff , best_mode_skippable ) ;
return best_rd ;
}
|
-5,280,794,106,681,745,000 |
debian
| 45 | 0 |
static GstFlowReturn gst_asf_demux_pull_indices ( GstASFDemux * demux ) {
GstBuffer * buf = NULL ;
guint64 offset ;
guint num_read = 0 ;
GstFlowReturn ret = GST_FLOW_OK ;
offset = demux -> index_offset ;
if ( G_UNLIKELY ( offset == 0 ) ) {
GST_DEBUG_OBJECT ( demux , "can't read indices, don't know index offset" ) ;
return GST_FLOW_OK ;
}
while ( gst_asf_demux_pull_data ( demux , offset , 16 + 8 , & buf , NULL ) ) {
AsfObject obj ;
GstMapInfo map ;
guint8 * bufdata ;
guint64 obj_size ;
gst_buffer_map ( buf , & map , GST_MAP_READ ) ;
g_assert ( map . size >= 16 + 8 ) ;
if ( ! asf_demux_peek_object ( demux , map . data , 16 + 8 , & obj , TRUE ) ) {
gst_buffer_unmap ( buf , & map ) ;
gst_buffer_replace ( & buf , NULL ) ;
ret = GST_FLOW_ERROR ;
break ;
}
gst_buffer_unmap ( buf , & map ) ;
gst_buffer_replace ( & buf , NULL ) ;
if ( G_UNLIKELY ( obj . size > ( 5 * 1024 * 1024 ) ) ) {
GST_DEBUG_OBJECT ( demux , "implausible index object size, bailing out" ) ;
break ;
}
if ( G_UNLIKELY ( ! gst_asf_demux_pull_data ( demux , offset , obj . size , & buf , NULL ) ) ) break ;
GST_LOG_OBJECT ( demux , "index object at offset 0x%" G_GINT64_MODIFIER "X" ", size %u" , offset , ( guint ) obj . size ) ;
offset += obj . size ;
gst_buffer_map ( buf , & map , GST_MAP_READ ) ;
g_assert ( map . size >= obj . size ) ;
bufdata = ( guint8 * ) map . data ;
obj_size = obj . size ;
ret = gst_asf_demux_process_object ( demux , & bufdata , & obj_size ) ;
gst_buffer_unmap ( buf , & map ) ;
gst_buffer_replace ( & buf , NULL ) ;
if ( G_UNLIKELY ( ret != GST_FLOW_OK ) ) break ;
++ num_read ;
}
GST_DEBUG_OBJECT ( demux , "read %u index objects" , num_read ) ;
return ret ;
}
|
7,424,930,167,238,098,000 |
debian
| 17 | 0 |
static void free_async ( struct async * as ) {
int i ;
put_pid ( as -> pid ) ;
if ( as -> cred ) put_cred ( as -> cred ) ;
for ( i = 0 ;
i < as -> urb -> num_sgs ;
i ++ ) {
if ( sg_page ( & as -> urb -> sg [ i ] ) ) kfree ( sg_virt ( & as -> urb -> sg [ i ] ) ) ;
}
kfree ( as -> urb -> sg ) ;
if ( as -> usbm == NULL ) kfree ( as -> urb -> transfer_buffer ) ;
else dec_usb_memory_use_count ( as -> usbm , & as -> usbm -> urb_use_count ) ;
kfree ( as -> urb -> setup_packet ) ;
usb_free_urb ( as -> urb ) ;
usbfs_decrease_memory_usage ( as -> mem_usage ) ;
kfree ( as ) ;
}
|
-1,338,403,456,839,869,200 |
debian
| 229 | 1 |
static void dissect_q931_IEs ( tvbuff_t * tvb , packet_info * pinfo , proto_tree * root_tree , proto_tree * q931_tree , gboolean is_over_ip , int offset , int initial_codeset ) {
proto_item * ti ;
proto_tree * ie_tree = NULL ;
guint8 info_element ;
guint8 dummy ;
guint16 info_element_len ;
int codeset , locked_codeset ;
gboolean non_locking_shift , first_segment ;
tvbuff_t * h225_tvb , * next_tvb ;
e164_info_t e164_info ;
e164_info . e164_number_type = NONE ;
e164_info . nature_of_address = NONE ;
e164_info . E164_number_str = "" ;
e164_info . E164_number_length = NONE ;
codeset = locked_codeset = initial_codeset ;
first_segment = FALSE ;
while ( tvb_reported_length_remaining ( tvb , offset ) > 0 ) {
info_element = tvb_get_guint8 ( tvb , offset ) ;
if ( ( info_element & Q931_IE_SO_MASK ) && ( ( info_element & Q931_IE_SO_IDENTIFIER_MASK ) == Q931_IE_SHIFT ) ) {
non_locking_shift = info_element & Q931_IE_SHIFT_NON_LOCKING ;
codeset = info_element & Q931_IE_SHIFT_CODESET ;
if ( ! non_locking_shift ) locked_codeset = codeset ;
if ( q931_tree != NULL ) {
proto_tree_add_uint_format ( q931_tree , hf_q931_locking_codeset , tvb , offset , 1 , codeset , "%s shift to codeset %u: %s" , ( non_locking_shift ? "Non-locking" : "Locking" ) , codeset , val_to_str ( codeset , q931_codeset_vals , "Unknown (0x%02X)" ) ) ;
}
offset += 1 ;
continue ;
}
if ( info_element & Q931_IE_SO_MASK ) {
if ( dissector_get_uint_handle ( codeset_dissector_table , codeset ) || dissector_get_uint_handle ( ie_dissector_table , ( codeset << 8 ) | ( info_element & Q931_IE_SO_IDENTIFIER_MASK ) ) ) {
next_tvb = tvb_new_subset_length ( tvb , offset , 1 ) ;
if ( dissector_try_uint ( ie_dissector_table , ( codeset << 8 ) | ( info_element & Q931_IE_SO_IDENTIFIER_MASK ) , next_tvb , pinfo , q931_tree ) || dissector_try_uint ( codeset_dissector_table , codeset , next_tvb , pinfo , q931_tree ) ) {
offset += 1 ;
codeset = locked_codeset ;
continue ;
}
}
switch ( ( codeset << 8 ) | ( info_element & Q931_IE_SO_IDENTIFIER_MASK ) ) {
case CS0 | Q931_IE_MORE_DATA_OR_SEND_COMP : switch ( info_element ) {
case Q931_IE_MORE_DATA : proto_tree_add_item ( q931_tree , hf_q931_more_data , tvb , offset , 1 , ENC_NA ) ;
break ;
case Q931_IE_SENDING_COMPLETE : proto_tree_add_item ( q931_tree , hf_q931_sending_complete , tvb , offset , 1 , ENC_NA ) ;
break ;
default : proto_tree_add_expert_format ( q931_tree , pinfo , & ei_q931_information_element , tvb , offset , 1 , "Unknown information element (0x%02X)" , info_element ) ;
break ;
}
break ;
case CS0 | Q931_IE_CONGESTION_LEVEL : proto_tree_add_item ( q931_tree , hf_q931_congestion_level , tvb , offset , 1 , ENC_BIG_ENDIAN ) ;
break ;
case CS0 | Q931_IE_REPEAT_INDICATOR : proto_tree_add_item ( q931_tree , hf_q931_repeat_indicator , tvb , offset , 1 , ENC_BIG_ENDIAN ) ;
break ;
default : proto_tree_add_expert_format ( q931_tree , pinfo , & ei_q931_information_element , tvb , offset , 1 , "Unknown information element (0x%02X)" , info_element ) ;
break ;
}
offset += 1 ;
codeset = locked_codeset ;
continue ;
}
if ( is_over_ip && tvb_bytes_exist ( tvb , offset , 4 ) && codeset == 0 && tvb_get_guint8 ( tvb , offset ) == Q931_IE_USER_USER && tvb_get_guint8 ( tvb , offset + 3 ) == Q931_PROTOCOL_DISCRIMINATOR_ASN1 ) {
info_element_len = tvb_get_ntohs ( tvb , offset + 1 ) ;
if ( q931_tree != NULL ) {
ie_tree = proto_tree_add_subtree ( q931_tree , tvb , offset , 1 + 2 + info_element_len , ett_q931_ie [ info_element ] , NULL , val_to_str ( info_element , q931_info_element_vals [ codeset ] , "Unknown information element (0x%02X)" ) ) ;
proto_tree_add_uint_format_value ( ie_tree , hf_q931_information_element , tvb , offset , 1 , info_element , "%s" , val_to_str ( info_element , q931_info_element_vals [ codeset ] , "Unknown (0x%02X)" ) ) ;
proto_tree_add_item ( ie_tree , hf_q931_information_element_len , tvb , offset + 1 , 2 , ENC_BIG_ENDIAN ) ;
proto_tree_add_item ( ie_tree , hf_q931_user_protocol_discriminator , tvb , offset + 3 , 1 , ENC_NA ) ;
}
if ( info_element_len > 1 ) {
if ( ! pinfo -> can_desegment ) {
info_element_len = MIN ( info_element_len , tvb_captured_length_remaining ( tvb , offset + 3 ) ) ;
}
if ( h225_handle != NULL ) {
h225_tvb = tvb_new_subset_length ( tvb , offset + 4 , info_element_len - 1 ) ;
call_dissector ( h225_handle , h225_tvb , pinfo , root_tree ) ;
}
else {
proto_tree_add_item ( ie_tree , hf_q931_user_information_bytes , tvb , offset + 4 , info_element_len - 1 , ENC_NA ) ;
}
}
offset += 1 + 2 + info_element_len ;
}
else {
info_element_len = tvb_get_guint8 ( tvb , offset + 1 ) ;
if ( first_segment && ( tvb_reported_length_remaining ( tvb , offset + 2 ) < info_element_len ) ) {
proto_tree_add_expert ( q931_tree , pinfo , & ei_q931_incomplete_ie , tvb , offset , - 1 ) ;
break ;
}
if ( dissector_get_uint_handle ( codeset_dissector_table , codeset ) || dissector_get_uint_handle ( ie_dissector_table , ( codeset << 8 ) | info_element ) ) {
next_tvb = tvb_new_subset_length ( tvb , offset , info_element_len + 2 ) ;
if ( dissector_try_uint ( ie_dissector_table , ( codeset << 8 ) | info_element , next_tvb , pinfo , q931_tree ) || dissector_try_uint ( codeset_dissector_table , codeset , next_tvb , pinfo , q931_tree ) ) {
offset += 2 + info_element_len ;
codeset = locked_codeset ;
continue ;
}
}
ie_tree = proto_tree_add_subtree ( q931_tree , tvb , offset , 1 + 1 + info_element_len , ett_q931_ie [ info_element ] , & ti , val_to_str ( info_element , q931_info_element_vals [ codeset ] , "Unknown information element (0x%02X)" ) ) ;
proto_tree_add_uint_format_value ( ie_tree , hf_q931_information_element , tvb , offset , 1 , info_element , "%s" , val_to_str ( info_element , q931_info_element_vals [ codeset ] , "Unknown (0x%02X)" ) ) ;
proto_tree_add_uint ( ie_tree , hf_q931_information_element_len , tvb , offset + 1 , 1 , info_element_len ) ;
if ( ( ( codeset << 8 ) | info_element ) == ( CS0 | Q931_IE_SEGMENTED_MESSAGE ) ) {
dissect_q931_segmented_message_ie ( tvb , pinfo , offset + 2 , info_element_len , ie_tree , ti ) ;
col_append_fstr ( pinfo -> cinfo , COL_INFO , " of %s" , val_to_str_ext ( tvb_get_guint8 ( tvb , offset + 3 ) , & q931_message_type_vals_ext , "Unknown message type (0x%02X)" ) ) ;
if ( tvb_get_guint8 ( tvb , offset + 2 ) & 0x80 ) {
first_segment = TRUE ;
}
else {
proto_tree_add_item ( q931_tree , hf_q931_message_segment , tvb , offset + 4 , - 1 , ENC_NA ) ;
info_element_len += tvb_reported_length_remaining ( tvb , offset + 4 ) ;
}
}
else {
switch ( ( codeset << 8 ) | info_element ) {
case CS0 | Q931_IE_BEARER_CAPABILITY : case CS0 | Q931_IE_LOW_LAYER_COMPAT : if ( q931_tree != NULL ) {
dissect_q931_bearer_capability_ie ( tvb , offset + 2 , info_element_len , ie_tree ) ;
}
break ;
case CS0 | Q931_IE_CAUSE : dissect_q931_cause_ie_unsafe ( tvb , offset + 2 , info_element_len , ie_tree , hf_q931_cause_value , & dummy , q931_info_element_vals0 ) ;
break ;
case CS0 | Q931_IE_CHANGE_STATUS : if ( q931_tree != NULL ) {
dissect_q931_change_status_ie ( tvb , offset + 2 , info_element_len , ie_tree ) ;
}
break ;
case CS0 | Q931_IE_CALL_STATE : if ( q931_tree != NULL ) {
dissect_q931_call_state_ie ( tvb , offset + 2 , info_element_len , ie_tree ) ;
}
break ;
case CS0 | Q931_IE_CHANNEL_IDENTIFICATION : if ( q931_tree != NULL ) {
dissect_q931_channel_identification_ie ( tvb , offset + 2 , info_element_len , ie_tree ) ;
}
break ;
case CS0 | Q931_IE_PROGRESS_INDICATOR : if ( q931_tree != NULL ) {
dissect_q931_progress_indicator_ie ( tvb , offset + 2 , info_element_len , ie_tree ) ;
}
break ;
case CS0 | Q931_IE_NETWORK_SPECIFIC_FACIL : case CS0 | Q931_IE_TRANSIT_NETWORK_SEL : if ( q931_tree != NULL ) {
dissect_q931_ns_facilities_ie ( tvb , offset + 2 , info_element_len , ie_tree ) ;
}
break ;
case CS0 | Q931_IE_NOTIFICATION_INDICATOR : if ( q931_tree != NULL ) {
dissect_q931_notification_indicator_ie ( tvb , offset + 2 , info_element_len , ie_tree ) ;
}
break ;
case CS0 | Q931_IE_DISPLAY : if ( q931_tree != NULL ) {
dissect_q931_ia5_ie ( tvb , offset + 2 , info_element_len , ie_tree , hf_q931_display_information ) ;
}
break ;
case CS0 | Q931_IE_DATE_TIME : dissect_q931_date_time_ie ( tvb , pinfo , offset + 2 , info_element_len , ie_tree ) ;
break ;
case CS0 | Q931_IE_KEYPAD_FACILITY : if ( q931_tree != NULL ) {
dissect_q931_ia5_ie ( tvb , offset + 2 , info_element_len , ie_tree , hf_q931_keypad_facility ) ;
}
break ;
case CS0 | Q931_IE_SIGNAL : dissect_q931_signal_ie ( tvb , pinfo , offset + 2 , info_element_len , ie_tree , ti ) ;
break ;
case CS0 | Q931_IE_INFORMATION_RATE : dissect_q931_information_rate_ie ( tvb , pinfo , offset + 2 , info_element_len , ie_tree , ti ) ;
break ;
case CS0 | Q931_IE_E2E_TRANSIT_DELAY : dissect_q931_e2e_transit_delay_ie ( tvb , pinfo , offset + 2 , info_element_len , ie_tree , ti ) ;
break ;
case CS0 | Q931_IE_TD_SELECTION_AND_INT : dissect_q931_td_selection_and_int_ie ( tvb , pinfo , offset + 2 , info_element_len , ie_tree , ti ) ;
break ;
case CS0 | Q931_IE_PL_BINARY_PARAMETERS : if ( q931_tree != NULL ) {
dissect_q931_pl_binary_parameters_ie ( tvb , offset + 2 , info_element_len , ie_tree ) ;
}
break ;
case CS0 | Q931_IE_PL_WINDOW_SIZE : if ( q931_tree != NULL ) {
dissect_q931_pl_window_size_ie ( tvb , offset + 2 , info_element_len , ie_tree ) ;
}
break ;
case CS0 | Q931_IE_PACKET_SIZE : if ( q931_tree != NULL ) {
dissect_q931_packet_size_ie ( tvb , offset + 2 , info_element_len , ie_tree ) ;
}
break ;
case CS0 | Q931_IE_CUG : if ( q931_tree != NULL ) {
dissect_q931_cug_ie ( tvb , offset + 2 , info_element_len , ie_tree ) ;
}
break ;
case CS0 | Q931_IE_REVERSE_CHARGE_IND : if ( q931_tree != NULL ) {
dissect_q931_reverse_charge_ind_ie ( tvb , offset + 2 , info_element_len , ie_tree ) ;
}
break ;
case CS0 | Q931_IE_CONNECTED_NUMBER_DEFAULT : if ( q931_tree != NULL ) {
dissect_q931_number_ie ( tvb , offset + 2 , info_element_len , ie_tree , hf_q931_connected_number , e164_info ) ;
}
break ;
case CS0 | Q931_IE_CALLING_PARTY_NUMBER : e164_info . e164_number_type = CALLING_PARTY_NUMBER ;
dissect_q931_number_ie ( tvb , offset + 2 , info_element_len , ie_tree , hf_q931_calling_party_number , e164_info ) ;
break ;
case CS0 | Q931_IE_CALLED_PARTY_NUMBER : e164_info . e164_number_type = CALLED_PARTY_NUMBER ;
dissect_q931_number_ie ( tvb , offset + 2 , info_element_len , ie_tree , hf_q931_called_party_number , e164_info ) ;
break ;
case CS0 | Q931_IE_CALLING_PARTY_SUBADDR : case CS0 | Q931_IE_CALLED_PARTY_SUBADDR : if ( q931_tree != NULL ) {
dissect_q931_party_subaddr_ie ( tvb , offset + 2 , info_element_len , ie_tree ) ;
}
break ;
case CS0 | Q931_IE_REDIRECTING_NUMBER : if ( q931_tree != NULL ) {
dissect_q931_number_ie ( tvb , offset + 2 , info_element_len , ie_tree , hf_q931_redirecting_number , e164_info ) ;
}
break ;
case CS0 | Q931_IE_RESTART_INDICATOR : dissect_q931_restart_indicator_ie ( tvb , pinfo , offset + 2 , info_element_len , ie_tree , ti ) ;
break ;
case CS0 | Q931_IE_HIGH_LAYER_COMPAT : if ( q931_tree != NULL ) {
dissect_q931_high_layer_compat_ie ( tvb , offset + 2 , info_element_len , ie_tree ) ;
}
break ;
case CS0 | Q931_IE_USER_USER : if ( q931_tree != NULL ) {
dissect_q931_user_user_ie ( tvb , pinfo , offset + 2 , info_element_len , ie_tree ) ;
}
break ;
case CS5 | Q931_IE_PARTY_CATEGORY : if ( q931_tree != NULL ) {
dissect_q931_party_category_ie ( tvb , offset + 2 , info_element_len , ie_tree ) ;
}
break ;
case CS6 | Q931_IE_DISPLAY : if ( q931_tree != NULL ) {
dissect_q931_ia5_ie ( tvb , offset + 2 , info_element_len , ie_tree , hf_q931_avaya_display ) ;
}
break ;
default : if ( q931_tree != NULL ) {
proto_tree_add_item ( ie_tree , hf_q931_data , tvb , offset + 2 , info_element_len , ENC_NA ) ;
}
break ;
}
}
offset += 1 + 1 + info_element_len ;
}
codeset = locked_codeset ;
}
if ( have_valid_q931_pi ) {
tap_queue_packet ( q931_tap , pinfo , q931_pi ) ;
}
have_valid_q931_pi = FALSE ;
}
|
2,972,516,716,299,328,500 |
debian
| 13 | 0 |
void addToHeaderList ( const char * strings [ ] , HttpHeaderList & headers ) {
for ( int i = 0 ;
strings [ i ] ;
i += 2 ) {
if ( i % 4 == 0 ) {
headers . push_back ( HttpHeader ( strings [ i ] , - 1 , strings [ i + 1 ] , - 1 ) ) ;
headers . push_back ( HttpHeader ( ) ) ;
}
else {
headers . push_back ( HttpHeader ( strings [ i ] , strlen ( strings [ i ] ) , strings [ i + 1 ] , strlen ( strings [ i + 1 ] ) ) ) ;
}
}
}
|
-5,981,110,360,267,990,000 |
chrome
| 39 | 0 |
TEST ( IdlCompiler , ArrayTypes ) {
base : : ListValue list ;
list . AppendInteger ( 33 ) ;
list . Append ( std : : make_unique < base : : ListValue > ( ) ) ;
std : : unique_ptr < Function10 : : Params > f10_params = Function10 : : Params : : Create ( list ) ;
ASSERT_TRUE ( f10_params != NULL ) ;
EXPECT_EQ ( 33 , f10_params -> x ) ;
EXPECT_TRUE ( f10_params -> y . empty ( ) ) ;
list . Clear ( ) ;
list . AppendInteger ( 33 ) ;
std : : unique_ptr < base : : ListValue > sublist ( new base : : ListValue ) ;
sublist -> AppendInteger ( 34 ) ;
sublist -> AppendInteger ( 35 ) ;
list . Append ( std : : move ( sublist ) ) ;
f10_params = Function10 : : Params : : Create ( list ) ;
ASSERT_TRUE ( f10_params != NULL ) ;
EXPECT_EQ ( 33 , f10_params -> x ) ;
ASSERT_EQ ( 2u , f10_params -> y . size ( ) ) ;
EXPECT_EQ ( 34 , f10_params -> y [ 0 ] ) ;
EXPECT_EQ ( 35 , f10_params -> y [ 1 ] ) ;
list . Clear ( ) ;
MyType1 a ;
MyType1 b ;
a . x = 5 ;
b . x = 6 ;
a . y = std : : string ( "foo" ) ;
b . y = std : : string ( "bar" ) ;
std : : unique_ptr < base : : ListValue > sublist2 ( new base : : ListValue ) ;
sublist2 -> Append ( a . ToValue ( ) ) ;
sublist2 -> Append ( b . ToValue ( ) ) ;
list . Append ( std : : move ( sublist2 ) ) ;
std : : unique_ptr < Function11 : : Params > f11_params = Function11 : : Params : : Create ( list ) ;
ASSERT_TRUE ( f11_params != NULL ) ;
ASSERT_EQ ( 2u , f11_params -> arg . size ( ) ) ;
EXPECT_EQ ( 5 , f11_params -> arg [ 0 ] . x ) ;
EXPECT_EQ ( "foo" , f11_params -> arg [ 0 ] . y ) ;
EXPECT_EQ ( 6 , f11_params -> arg [ 1 ] . x ) ;
EXPECT_EQ ( "bar" , f11_params -> arg [ 1 ] . y ) ;
}
|
7,749,168,290,238,235,000 |
debian
| 9 | 1 |
static int test_save_copy ( const char * origname ) {
char buf [ TESTBUFSIZE ] ;
int ret ;
snprintf_func ( buf , TESTBUFSIZE , "cp -f %s %s" , origname , TEST_COPY_FILE ) ;
if ( ( ret = system ( buf ) ) != 0 ) {
return XD3_INTERNAL ;
}
return 0 ;
}
|
2,898,965,519,451,754,000 |
chrome
| 20 | 1 |
int main ( int argc , char * * argv ) {
using std : : string ;
if ( argc != 2 ) {
fprintf ( stderr , "One argument, the input filename, must be provided.\n" ) ;
return 1 ;
}
string filename ( argv [ 1 ] ) ;
string outfilename = filename . substr ( 0 , filename . find_last_of ( "." ) ) + ".ttf" ;
fprintf ( stdout , "Processing %s => %s\n" , filename . c_str ( ) , outfilename . c_str ( ) ) ;
string input = woff2 : : GetFileContent ( filename ) ;
size_t decompressed_size = woff2 : : ComputeWOFF2FinalSize ( reinterpret_cast < const uint8_t * > ( input . data ( ) ) , input . size ( ) ) ;
string output ( decompressed_size , 0 ) ;
const bool ok = woff2 : : ConvertWOFF2ToTTF ( reinterpret_cast < uint8_t * > ( & output [ 0 ] ) , decompressed_size , reinterpret_cast < const uint8_t * > ( input . data ( ) ) , input . size ( ) ) ;
if ( ! ok ) {
fprintf ( stderr , "Decompression failed\n" ) ;
return 1 ;
}
woff2 : : SetFileContents ( outfilename , output ) ;
return 0 ;
}
|
1,458,662,858,915,721,500 |
debian
| 3 | 0 |
static inline void tb_reset_jump ( TranslationBlock * tb , int n ) {
tb_set_jmp_target ( tb , n , ( uintptr_t ) ( tb -> tc_ptr + tb -> tb_next_offset [ n ] ) ) ;
}
|
2,687,336,064,028,423,000 |
chrome
| 16 | 0 |
struct evdns_server_port * evdns_add_server_port ( int socket , int is_tcp , evdns_request_callback_fn_type cb , void * user_data ) {
struct evdns_server_port * port ;
if ( ! ( port = malloc ( sizeof ( struct evdns_server_port ) ) ) ) return NULL ;
memset ( port , 0 , sizeof ( struct evdns_server_port ) ) ;
assert ( ! is_tcp ) ;
port -> socket = socket ;
port -> refcnt = 1 ;
port -> choked = 0 ;
port -> closing = 0 ;
port -> user_callback = cb ;
port -> user_data = user_data ;
port -> pending_replies = NULL ;
event_set ( & port -> event , port -> socket , EV_READ | EV_PERSIST , server_port_ready_callback , port ) ;
event_add ( & port -> event , NULL ) ;
return port ;
}
|
6,120,640,898,537,304,000 |
debian
| 24 | 0 |
void pdf_process_contents ( fz_context * ctx , pdf_processor * proc , pdf_document * doc , pdf_obj * rdb , pdf_obj * stmobj , fz_cookie * cookie ) {
pdf_csi csi ;
pdf_lexbuf buf ;
fz_stream * stm = NULL ;
if ( ! stmobj ) return ;
fz_var ( stm ) ;
pdf_lexbuf_init ( ctx , & buf , PDF_LEXBUF_SMALL ) ;
pdf_init_csi ( ctx , & csi , doc , rdb , & buf , cookie ) ;
fz_try ( ctx ) {
fz_defer_reap_start ( ctx ) ;
stm = pdf_open_contents_stream ( ctx , doc , stmobj ) ;
pdf_process_stream ( ctx , proc , & csi , stm ) ;
pdf_process_end ( ctx , proc , & csi ) ;
}
fz_always ( ctx ) {
fz_defer_reap_end ( ctx ) ;
fz_drop_stream ( ctx , stm ) ;
pdf_clear_stack ( ctx , & csi ) ;
pdf_lexbuf_fin ( ctx , & buf ) ;
}
fz_catch ( ctx ) {
fz_rethrow ( ctx ) ;
}
}
|
-1,658,505,547,857,059,300 |
debian
| 24 | 0 |
int ff_generate_sliding_window_mmcos ( H264Context * h , int first_slice ) {
MMCO mmco_temp [ MAX_MMCO_COUNT ] , * mmco = first_slice ? h -> mmco : mmco_temp ;
int mmco_index = 0 , i ;
assert ( h -> long_ref_count + h -> short_ref_count <= h -> sps . ref_frame_count ) ;
if ( h -> short_ref_count && h -> long_ref_count + h -> short_ref_count == h -> sps . ref_frame_count && ! ( FIELD_PICTURE && ! h -> first_field && h -> cur_pic_ptr -> reference ) ) {
mmco [ 0 ] . opcode = MMCO_SHORT2UNUSED ;
mmco [ 0 ] . short_pic_num = h -> short_ref [ h -> short_ref_count - 1 ] -> frame_num ;
mmco_index = 1 ;
if ( FIELD_PICTURE ) {
mmco [ 0 ] . short_pic_num *= 2 ;
mmco [ 1 ] . opcode = MMCO_SHORT2UNUSED ;
mmco [ 1 ] . short_pic_num = mmco [ 0 ] . short_pic_num + 1 ;
mmco_index = 2 ;
}
}
if ( first_slice ) {
h -> mmco_index = mmco_index ;
}
else if ( ! first_slice && mmco_index >= 0 && ( mmco_index != h -> mmco_index || ( i = check_opcodes ( h -> mmco , mmco_temp , mmco_index ) ) ) ) {
av_log ( h -> avctx , AV_LOG_ERROR , "Inconsistent MMCO state between slices [%d, %d, %d]\n" , mmco_index , h -> mmco_index , i ) ;
return AVERROR_INVALIDDATA ;
}
return 0 ;
}
|
-8,830,528,631,587,258,000 |
debian
| 13 | 0 |
int handle_compressed ( void * procctx , PKT_compressed * cd , int ( * callback ) ( IOBUF , void * ) , void * passthru ) {
compress_filter_context_t * cfx ;
int rc ;
if ( check_compress_algo ( cd -> algorithm ) ) return G10ERR_COMPR_ALGO ;
cfx = xmalloc_clear ( sizeof * cfx ) ;
cfx -> release = release_context ;
cfx -> algo = cd -> algorithm ;
push_compress_filter ( cd -> buf , cfx , cd -> algorithm ) ;
if ( callback ) rc = callback ( cd -> buf , passthru ) ;
else rc = proc_packets ( procctx , cd -> buf ) ;
cd -> buf = NULL ;
return rc ;
}
|
1,245,821,301,839,614,700 |
debian
| 41 | 0 |
static int run_simple_dialog_va ( CommonJob * job , gboolean ignore_close_box , GtkMessageType message_type , char * primary_text , char * secondary_text , const char * details_text , gboolean show_all , va_list varargs ) {
RunSimpleDialogData * data ;
int res ;
const char * button_title ;
GPtrArray * ptr_array ;
g_timer_stop ( job -> time ) ;
data = g_new0 ( RunSimpleDialogData , 1 ) ;
data -> parent_window = & job -> parent_window ;
data -> ignore_close_box = ignore_close_box ;
data -> message_type = message_type ;
data -> primary_text = primary_text ;
data -> secondary_text = secondary_text ;
data -> details_text = details_text ;
data -> show_all = show_all ;
data -> completed = FALSE ;
g_mutex_init ( & data -> mutex ) ;
g_cond_init ( & data -> cond ) ;
ptr_array = g_ptr_array_new ( ) ;
while ( ( button_title = va_arg ( varargs , const char * ) ) != NULL ) {
g_ptr_array_add ( ptr_array , ( char * ) button_title ) ;
}
g_ptr_array_add ( ptr_array , NULL ) ;
data -> button_titles = ( const char * * ) g_ptr_array_free ( ptr_array , FALSE ) ;
nautilus_progress_info_pause ( job -> progress ) ;
g_mutex_lock ( & data -> mutex ) ;
g_main_context_invoke ( NULL , do_run_simple_dialog , data ) ;
while ( ! data -> completed ) {
g_cond_wait ( & data -> cond , & data -> mutex ) ;
}
nautilus_progress_info_resume ( job -> progress ) ;
res = data -> result ;
g_mutex_unlock ( & data -> mutex ) ;
g_mutex_clear ( & data -> mutex ) ;
g_cond_clear ( & data -> cond ) ;
g_free ( data -> button_titles ) ;
g_free ( data ) ;
g_timer_continue ( job -> time ) ;
g_free ( primary_text ) ;
g_free ( secondary_text ) ;
return res ;
}
|
7,424,930,167,238,098,000 |
debian
| 7 | 0 |
static int proc_disconnectsignal ( struct usb_dev_state * ps , void __user * arg ) {
struct usbdevfs_disconnectsignal ds ;
if ( copy_from_user ( & ds , arg , sizeof ( ds ) ) ) return - EFAULT ;
ps -> discsignr = ds . signr ;
ps -> disccontext = ds . context ;
return 0 ;
}
|
-4,885,528,830,177,757,000 |
debian
| 101 | 0 |
static int chk_index ( MI_CHECK * param , MI_INFO * info , MI_KEYDEF * keyinfo , my_off_t page , uchar * buff , ha_rows * keys , ha_checksum * key_checksum , uint level ) {
int flag ;
uint used_length , comp_flag , nod_flag , key_length = 0 ;
uchar key [ HA_MAX_POSSIBLE_KEY_BUFF ] , * temp_buff , * keypos , * old_keypos , * endpos ;
my_off_t next_page , record ;
char llbuff [ 22 ] ;
uint diff_pos [ 2 ] ;
DBUG_ENTER ( "chk_index" ) ;
DBUG_DUMP ( "buff" , ( uchar * ) buff , mi_getint ( buff ) ) ;
if ( keyinfo -> flag & HA_SPATIAL ) DBUG_RETURN ( 0 ) ;
if ( ! ( temp_buff = ( uchar * ) my_alloca ( ( uint ) keyinfo -> block_length ) ) ) {
mi_check_print_error ( param , "Not enough memory for keyblock" ) ;
DBUG_RETURN ( - 1 ) ;
}
if ( keyinfo -> flag & HA_NOSAME ) comp_flag = SEARCH_FIND | SEARCH_UPDATE ;
else comp_flag = SEARCH_SAME ;
nod_flag = mi_test_if_nod ( buff ) ;
used_length = mi_getint ( buff ) ;
keypos = buff + 2 + nod_flag ;
endpos = buff + used_length ;
param -> keydata += used_length ;
param -> totaldata += keyinfo -> block_length ;
param -> key_blocks ++ ;
if ( level > param -> max_level ) param -> max_level = level ;
if ( used_length > keyinfo -> block_length ) {
mi_check_print_error ( param , "Wrong pageinfo at page: %s" , llstr ( page , llbuff ) ) ;
goto err ;
}
for ( ;
;
) {
if ( * killed_ptr ( param ) ) goto err ;
memcpy ( ( char * ) info -> lastkey , ( char * ) key , key_length ) ;
info -> lastkey_length = key_length ;
if ( nod_flag ) {
next_page = _mi_kpos ( nod_flag , keypos ) ;
if ( chk_index_down ( param , info , keyinfo , next_page , temp_buff , keys , key_checksum , level + 1 ) ) goto err ;
}
old_keypos = keypos ;
if ( keypos >= endpos || ( key_length = ( * keyinfo -> get_key ) ( keyinfo , nod_flag , & keypos , key ) ) == 0 ) break ;
if ( keypos > endpos ) {
mi_check_print_error ( param , "Wrong key block length at page: %s" , llstr ( page , llbuff ) ) ;
goto err ;
}
if ( ( * keys ) ++ && ( flag = ha_key_cmp ( keyinfo -> seg , info -> lastkey , key , key_length , comp_flag , diff_pos ) ) >= 0 ) {
DBUG_DUMP ( "old" , ( uchar * ) info -> lastkey , info -> lastkey_length ) ;
DBUG_DUMP ( "new" , ( uchar * ) key , key_length ) ;
DBUG_DUMP ( "new_in_page" , ( uchar * ) old_keypos , ( uint ) ( keypos - old_keypos ) ) ;
if ( comp_flag & SEARCH_FIND && flag == 0 ) mi_check_print_error ( param , "Found duplicated key at page %s" , llstr ( page , llbuff ) ) ;
else mi_check_print_error ( param , "Key in wrong position at page %s" , llstr ( page , llbuff ) ) ;
goto err ;
}
if ( param -> testflag & T_STATISTICS ) {
if ( * keys != 1L ) {
if ( param -> stats_method == MI_STATS_METHOD_NULLS_NOT_EQUAL ) ha_key_cmp ( keyinfo -> seg , info -> lastkey , key , USE_WHOLE_KEY , SEARCH_FIND | SEARCH_NULL_ARE_NOT_EQUAL , diff_pos ) ;
else if ( param -> stats_method == MI_STATS_METHOD_IGNORE_NULLS ) {
diff_pos [ 0 ] = mi_collect_stats_nonulls_next ( keyinfo -> seg , param -> notnull_count , info -> lastkey , key ) ;
}
param -> unique_count [ diff_pos [ 0 ] - 1 ] ++ ;
}
else {
if ( param -> stats_method == MI_STATS_METHOD_IGNORE_NULLS ) mi_collect_stats_nonulls_first ( keyinfo -> seg , param -> notnull_count , key ) ;
}
}
( * key_checksum ) += mi_byte_checksum ( ( uchar * ) key , key_length - info -> s -> rec_reflength ) ;
record = _mi_dpos ( info , 0 , key + key_length ) ;
if ( keyinfo -> flag & HA_FULLTEXT ) {
uint off ;
int subkeys ;
get_key_full_length_rdonly ( off , key ) ;
subkeys = ft_sintXkorr ( key + off ) ;
if ( subkeys < 0 ) {
ha_rows tmp_keys = 0 ;
if ( chk_index_down ( param , info , & info -> s -> ft2_keyinfo , record , temp_buff , & tmp_keys , key_checksum , 1 ) ) goto err ;
if ( tmp_keys + subkeys ) {
mi_check_print_error ( param , "Number of words in the 2nd level tree " "does not match the number in the header. " "Parent word in on the page %s, offset %u" , llstr ( page , llbuff ) , ( uint ) ( old_keypos - buff ) ) ;
goto err ;
}
( * keys ) += tmp_keys - 1 ;
continue ;
}
}
if ( record >= info -> state -> data_file_length ) {
# ifndef DBUG_OFF char llbuff2 [ 22 ] , llbuff3 [ 22 ] ;
# endif mi_check_print_error ( param , "Found key at page %s that points to record outside datafile" , llstr ( page , llbuff ) ) ;
DBUG_PRINT ( "test" , ( "page: %s record: %s filelength: %s" , llstr ( page , llbuff ) , llstr ( record , llbuff2 ) , llstr ( info -> state -> data_file_length , llbuff3 ) ) ) ;
DBUG_DUMP ( "key" , ( uchar * ) key , key_length ) ;
DBUG_DUMP ( "new_in_page" , ( uchar * ) old_keypos , ( uint ) ( keypos - old_keypos ) ) ;
goto err ;
}
param -> record_checksum += ( ha_checksum ) record ;
}
if ( keypos != endpos ) {
mi_check_print_error ( param , "Keyblock size at page %s is not correct. Block length: %d key length: %d" , llstr ( page , llbuff ) , used_length , ( keypos - buff ) ) ;
goto err ;
}
my_afree ( ( uchar * ) temp_buff ) ;
DBUG_RETURN ( 0 ) ;
err : my_afree ( ( uchar * ) temp_buff ) ;
DBUG_RETURN ( 1 ) ;
}
|
7,092,216,800,726,730,000 |
debian
| 6 | 0 |
static int dissect_h245_MultiplexTableEntryNumber ( tvbuff_t * tvb _U_ , int offset _U_ , asn1_ctx_t * actx _U_ , proto_tree * tree _U_ , int hf_index _U_ ) {
# line 65 "../../asn1/h245/h245.cnf" guint32 value ;
offset = dissect_per_constrained_integer ( tvb , offset , actx , tree , hf_index , 1U , 15U , & value , FALSE ) ;
h223_mc = value & 0xf ;
return offset ;
}
|
-2,423,144,171,479,607,000 |
debian
| 7 | 0 |
static void pdf_run_j ( fz_context * ctx , pdf_processor * proc , int linejoin ) {
pdf_run_processor * pr = ( pdf_run_processor * ) proc ;
pdf_gstate * gstate = pdf_flush_text ( ctx , pr ) ;
pr -> dev -> flags &= ~ FZ_DEVFLAG_LINEJOIN_UNDEFINED ;
gstate -> stroke_state = fz_unshare_stroke_state ( ctx , gstate -> stroke_state ) ;
gstate -> stroke_state -> linejoin = linejoin ;
}
|
2,895,622,461,494,525,400 |
debian
| 37 | 0 |
static void test_select_prepare ( ) {
int rc ;
MYSQL_STMT * stmt ;
myheader ( "test_select_prepare" ) ;
rc = mysql_autocommit ( mysql , TRUE ) ;
myquery ( rc ) ;
rc = mysql_query ( mysql , "DROP TABLE IF EXISTS test_select" ) ;
myquery ( rc ) ;
rc = mysql_query ( mysql , "CREATE TABLE test_select(id int, name varchar(50))" ) ;
myquery ( rc ) ;
rc = mysql_query ( mysql , "INSERT INTO test_select VALUES(10, 'venu')" ) ;
myquery ( rc ) ;
rc = mysql_commit ( mysql ) ;
myquery ( rc ) ;
stmt = mysql_simple_prepare ( mysql , "SELECT * FROM test_select" ) ;
check_stmt ( stmt ) ;
rc = mysql_stmt_execute ( stmt ) ;
check_execute ( stmt , rc ) ;
rc = my_process_stmt_result ( stmt ) ;
DIE_UNLESS ( rc == 1 ) ;
mysql_stmt_close ( stmt ) ;
rc = mysql_query ( mysql , "DROP TABLE test_select" ) ;
myquery ( rc ) ;
rc = mysql_query ( mysql , "CREATE TABLE test_select(id tinyint, id1 int, " " id2 float, id3 float, " " name varchar(50))" ) ;
myquery ( rc ) ;
rc = mysql_query ( mysql , "INSERT INTO test_select(id, id1, id2, name) VALUES(10, 5, 2.3, 'venu')" ) ;
myquery ( rc ) ;
rc = mysql_commit ( mysql ) ;
myquery ( rc ) ;
stmt = mysql_simple_prepare ( mysql , "SELECT * FROM test_select" ) ;
check_stmt ( stmt ) ;
rc = mysql_stmt_execute ( stmt ) ;
check_execute ( stmt , rc ) ;
rc = my_process_stmt_result ( stmt ) ;
DIE_UNLESS ( rc == 1 ) ;
mysql_stmt_close ( stmt ) ;
}
|
-6,333,668,321,124,139,000 |
debian
| 3 | 0 |
gboolean rtp_dyn_payload_remove ( rtp_dyn_payload_t * rtp_dyn_payload , const guint8 pt ) {
return ( rtp_dyn_payload && rtp_dyn_payload -> table && g_hash_table_remove ( rtp_dyn_payload -> table , GUINT_TO_POINTER ( pt ) ) ) ;
}
|
-7,855,974,557,509,681,000 |
debian
| 12 | 0 |
Oid get_rel_namespace ( Oid relid ) {
HeapTuple tp ;
tp = SearchSysCache1 ( RELOID , ObjectIdGetDatum ( relid ) ) ;
if ( HeapTupleIsValid ( tp ) ) {
Form_pg_class reltup = ( Form_pg_class ) GETSTRUCT ( tp ) ;
Oid result ;
result = reltup -> relnamespace ;
ReleaseSysCache ( tp ) ;
return result ;
}
else return InvalidOid ;
}
|
-8,263,083,159,286,475,000 |
debian
| 17 | 0 |
static int init_offset ( ShortenContext * s ) {
int32_t mean = 0 ;
int chan , i ;
int nblock = FFMAX ( 1 , s -> nmean ) ;
switch ( s -> internal_ftype ) {
case TYPE_S16HL : case TYPE_S16LH : mean = 0 ;
break ;
default : av_log ( s -> avctx , AV_LOG_ERROR , "unknown audio type" ) ;
return AVERROR_INVALIDDATA ;
}
for ( chan = 0 ;
chan < s -> channels ;
chan ++ ) for ( i = 0 ;
i < nblock ;
i ++ ) s -> offset [ chan ] [ i ] = mean ;
return 0 ;
}
|
7,563,956,670,602,033,000 |
chrome
| 9 | 0 |
IN_PROC_BROWSER_TEST_F ( HostedAppTest , ShouldShowLocationBarForHTTPBookmarkApp ) {
base : : CommandLine : : ForCurrentProcess ( ) -> AppendSwitch ( switches : : kEnableNewBookmarkApps ) ;
SetupApp ( "app" , true ) ;
NavigateAndCheckForLocationBar ( app_browser_ , "http://www.example.com/empty.html" , false ) ;
NavigateAndCheckForLocationBar ( app_browser_ , "http://www.example.com/blah" , false ) ;
NavigateAndCheckForLocationBar ( app_browser_ , "https://www.example.com/blah" , false ) ;
NavigateAndCheckForLocationBar ( app_browser_ , "http://www.foo.com/blah" , true ) ;
NavigateAndCheckForLocationBar ( app_browser_ , "http://www.example.com/blah" , false ) ;
}
|
3,557,739,556,029,059,000 |
chrome
| 18 | 0 |
unsigned int vp9_sad ## m ## x ## n ## _avg_c ( const uint8_t * src , int src_stride , const uint8_t * ref , int ref_stride , const uint8_t * second_pred ) {
uint8_t comp_pred [ m * n ] ;
vp9_comp_avg_pred ( comp_pred , second_pred , m , n , ref , ref_stride ) ;
return sad ( src , src_stride , comp_pred , m , m , n ) ;
\ }
# define sadMxNxK ( m , n , k ) void vp9_sad ## m ## x ## n ## x ## k ## _c ( const uint8_t * src , int src_stride , const uint8_t * ref , int ref_stride , unsigned int * sads ) {
int i ;
for ( i = 0 ;
i < k ;
++ i ) sads [ i ] = vp9_sad ## m ## x ## n ## _c ( src , src_stride , & ref [ i ] , ref_stride ) ;
\ }
# define sadMxNx4D ( m , n ) void vp9_sad ## m ## x ## n ## x4d_c ( const uint8_t * src , int src_stride , const uint8_t * const refs [ ] , int ref_stride , unsigned int * sads ) {
int i ;
for ( i = 0 ;
i < 4 ;
++ i ) sads [ i ] = vp9_sad ## m ## x ## n ## _c ( src , src_stride , refs [ i ] , ref_stride ) ;
\ }
sadMxN ( 64 , 64 )
|
7,092,216,800,726,730,000 |
debian
| 4 | 0 |
static int dissect_h245_T_transferMode ( tvbuff_t * tvb _U_ , int offset _U_ , asn1_ctx_t * actx _U_ , proto_tree * tree _U_ , int hf_index _U_ ) {
offset = dissect_per_choice ( tvb , offset , actx , tree , hf_index , ett_h245_T_transferMode , T_transferMode_choice , NULL ) ;
return offset ;
}
|
-1,315,695,702,746,584,300 |
debian
| 18 | 0 |
static void register_type_length_mismatch ( void ) {
static ei_register_info ei [ ] = {
{
& ei_type_length_mismatch_error , {
"_ws.type_length.mismatch" , PI_MALFORMED , PI_ERROR , "Trying to fetch X with length Y" , EXPFILL }
}
, {
& ei_type_length_mismatch_warn , {
"_ws.type_length.mismatch" , PI_MALFORMED , PI_WARN , "Trying to fetch X with length Y" , EXPFILL }
}
, }
;
expert_module_t * expert_type_length_mismatch ;
proto_type_length_mismatch = proto_register_protocol ( "Type Length Mismatch" , "Type length mismatch" , "_ws.type_length" ) ;
expert_type_length_mismatch = expert_register_protocol ( proto_type_length_mismatch ) ;
expert_register_field_array ( expert_type_length_mismatch , ei , array_length ( ei ) ) ;
proto_set_cant_toggle ( proto_type_length_mismatch ) ;
}
|
-3,819,889,754,140,204,000 |
debian
| 31 | 0 |
METHOD ( certificate_t , has_subject , id_match_t , private_x509_cert_t * this , identification_t * subject ) {
identification_t * current ;
enumerator_t * enumerator ;
id_match_t match , best ;
chunk_t encoding ;
if ( subject -> get_type ( subject ) == ID_KEY_ID ) {
encoding = subject -> get_encoding ( subject ) ;
if ( this -> encoding_hash . len && chunk_equals ( this -> encoding_hash , encoding ) ) {
return ID_MATCH_PERFECT ;
}
if ( this -> subjectKeyIdentifier . len && chunk_equals ( this -> subjectKeyIdentifier , encoding ) ) {
return ID_MATCH_PERFECT ;
}
if ( this -> public_key && this -> public_key -> has_fingerprint ( this -> public_key , encoding ) ) {
return ID_MATCH_PERFECT ;
}
if ( chunk_equals ( this -> serialNumber , encoding ) ) {
return ID_MATCH_PERFECT ;
}
}
best = this -> subject -> matches ( this -> subject , subject ) ;
enumerator = this -> subjectAltNames -> create_enumerator ( this -> subjectAltNames ) ;
while ( enumerator -> enumerate ( enumerator , & current ) ) {
match = current -> matches ( current , subject ) ;
if ( match > best ) {
best = match ;
}
}
enumerator -> destroy ( enumerator ) ;
return best ;
}
|
-5,612,058,238,993,494,000 |
debian
| 4 | 0 |
static void handle_mlppp ( netdissect_options * ndo , const u_char * p , int length ) {
if ( ! ndo -> ndo_eflag ) ND_PRINT ( ( ndo , "MLPPP, " ) ) ;
ND_PRINT ( ( ndo , "seq 0x%03x, Flags [%s], length %u" , ( EXTRACT_16BITS ( p ) ) & 0x0fff , bittok2str ( ppp_ml_flag_values , "none" , * p & 0xc0 ) , length ) ) ;
}
|
-1,335,877,942,018,854,400 |
chrome
| 12 | 0 |
IN_PROC_BROWSER_TEST_F ( UnloadTest , BrowserCloseBeforeUnloadCancel ) {
NavigateToDataURL ( BEFORE_UNLOAD_HTML , "beforeunload" ) ;
chrome : : CloseWindow ( browser ( ) ) ;
base : : string16 expected_title = base : : ASCIIToUTF16 ( "cancelled" ) ;
content : : TitleWatcher title_watcher ( browser ( ) -> tab_strip_model ( ) -> GetActiveWebContents ( ) , expected_title ) ;
ClickModalDialogButton ( false ) ;
ASSERT_EQ ( expected_title , title_watcher . WaitAndGetTitle ( ) ) ;
content : : WindowedNotificationObserver window_observer ( chrome : : NOTIFICATION_BROWSER_CLOSED , content : : NotificationService : : AllSources ( ) ) ;
chrome : : CloseWindow ( browser ( ) ) ;
ClickModalDialogButton ( true ) ;
window_observer . Wait ( ) ;
}
|
8,801,969,307,247,113,000 |
debian
| 7 | 0 |
static int aes_cbc_cipher ( EVP_CIPHER_CTX * ctx , unsigned char * out , const unsigned char * in , size_t len ) {
EVP_AES_KEY * dat = EVP_C_DATA ( EVP_AES_KEY , ctx ) ;
if ( dat -> stream . cbc ) ( * dat -> stream . cbc ) ( in , out , len , & dat -> ks , EVP_CIPHER_CTX_iv_noconst ( ctx ) , EVP_CIPHER_CTX_encrypting ( ctx ) ) ;
else if ( EVP_CIPHER_CTX_encrypting ( ctx ) ) CRYPTO_cbc128_encrypt ( in , out , len , & dat -> ks , EVP_CIPHER_CTX_iv_noconst ( ctx ) , dat -> block ) ;
else CRYPTO_cbc128_decrypt ( in , out , len , & dat -> ks , EVP_CIPHER_CTX_iv_noconst ( ctx ) , dat -> block ) ;
return 1 ;
}
|
-8,721,757,784,652,752,000 |
debian
| 59 | 0 |
void calcrdslopes ( jpc_enc_cblk_t * cblk ) {
jpc_enc_pass_t * endpasses ;
jpc_enc_pass_t * pass0 ;
jpc_enc_pass_t * pass1 ;
jpc_enc_pass_t * pass2 ;
jpc_flt_t slope0 ;
jpc_flt_t slope ;
jpc_flt_t dd ;
long dr ;
endpasses = & cblk -> passes [ cblk -> numpasses ] ;
pass2 = cblk -> passes ;
slope0 = 0 ;
while ( pass2 != endpasses ) {
pass0 = 0 ;
for ( pass1 = cblk -> passes ;
pass1 != endpasses ;
++ pass1 ) {
dd = pass1 -> cumwmsedec ;
dr = pass1 -> end ;
if ( pass0 ) {
dd -= pass0 -> cumwmsedec ;
dr -= pass0 -> end ;
}
if ( dd <= 0 ) {
pass1 -> rdslope = JPC_BADRDSLOPE ;
if ( pass1 >= pass2 ) {
pass2 = & pass1 [ 1 ] ;
}
continue ;
}
if ( pass1 < pass2 && pass1 -> rdslope <= 0 ) {
continue ;
}
if ( ! dr ) {
assert ( pass0 ) ;
pass0 -> rdslope = 0 ;
break ;
}
slope = dd / dr ;
if ( pass0 && slope >= slope0 ) {
pass0 -> rdslope = 0 ;
break ;
}
pass1 -> rdslope = slope ;
if ( pass1 >= pass2 ) {
pass2 = & pass1 [ 1 ] ;
}
pass0 = pass1 ;
slope0 = slope ;
}
}
# if 0 for ( pass0 = cblk -> passes ;
pass0 != endpasses ;
++ pass0 ) {
if ( pass0 -> rdslope > 0.0 ) {
jas_eprintf ( "pass %02d nmsedec=%lf dec=%lf end=%d %lf\n" , pass0 - cblk -> passes , fixtodbl ( pass0 -> nmsedec ) , pass0 -> wmsedec , pass0 -> end , pass0 -> rdslope ) ;
}
}
# endif }
|
-3,299,391,226,809,811,500 |
debian
| 20 | 0 |
VIR_ONCE_GLOBAL_INIT ( qemuAgent ) # if DEBUG_RAW_IO # include < c - ctype . h > static char * qemuAgentEscapeNonPrintable ( const char * text ) {
size_t i ;
virBuffer buf = VIR_BUFFER_INITIALIZER ;
for ( i = 0 ;
text [ i ] != '\0' ;
i ++ ) {
if ( text [ i ] == '\\' ) virBufferAddLit ( & buf , "\\\\" ) ;
else if ( c_isprint ( text [ i ] ) || text [ i ] == '\n' || ( text [ i ] == '\r' && text [ i + 1 ] == '\n' ) ) virBufferAddChar ( & buf , text [ i ] ) ;
else virBufferAsprintf ( & buf , "\\x%02x" , text [ i ] ) ;
}
return virBufferContentAndReset ( & buf ) ;
}
# endif static void qemuAgentDispose ( void * obj ) {
qemuAgentPtr mon = obj ;
VIR_DEBUG ( "mon=%p" , mon ) ;
if ( mon -> cb && mon -> cb -> destroy ) ( mon -> cb -> destroy ) ( mon , mon -> vm ) ;
virCondDestroy ( & mon -> notify ) ;
VIR_FREE ( mon -> buffer ) ;
virResetError ( & mon -> lastError ) ;
}
|
8,280,197,130,498,467,000 |
debian
| 4 | 0 |
static int incomplete_class_has_property ( zval * object , zval * member , int check_empty , const zend_literal * key TSRMLS_DC ) {
incomplete_class_message ( object , E_NOTICE TSRMLS_CC ) ;
return 0 ;
}
|
927,123,821,003,322,000 |
chrome
| 12 | 0 |
IN_PROC_BROWSER_TEST_F ( SessionRestorePageLoadMetricsBrowserTest , MultipleTabsSessionRestore ) {
ui_test_utils : : NavigateToURL ( browser ( ) , GetTestURL ( ) ) ;
ui_test_utils : : NavigateToURLWithDisposition ( browser ( ) , GetTestURL ( ) , WindowOpenDisposition : : NEW_BACKGROUND_TAB , ui_test_utils : : BROWSER_TEST_WAIT_FOR_NAVIGATION ) ;
SessionRestorePaintWaiter session_restore_paint_waiter ;
Browser * new_browser = QuitBrowserAndRestore ( browser ( ) ) ;
TabStripModel * tab_strip = new_browser -> tab_strip_model ( ) ;
ASSERT_TRUE ( tab_strip ) ;
ASSERT_EQ ( 2 , tab_strip -> count ( ) ) ;
session_restore_paint_waiter . WaitForForegroundTabs ( 1 ) ;
ASSERT_NO_FATAL_FAILURE ( WaitForTabsToLoad ( new_browser ) ) ;
ExpectFirstPaintMetricsTotalCount ( 1 ) ;
}
|
7,092,216,800,726,730,000 |
debian
| 8 | 0 |
static int dissect_h245_T_nsd_data ( tvbuff_t * tvb _U_ , int offset _U_ , asn1_ctx_t * actx _U_ , proto_tree * tree _U_ , int hf_index _U_ ) {
# line 981 "../../asn1/h245/h245.cnf" tvbuff_t * next_tvb = NULL ;
offset = dissect_per_octet_string ( tvb , offset , actx , tree , hf_index , NO_BOUND , NO_BOUND , FALSE , & next_tvb ) ;
if ( next_tvb && tvb_length ( next_tvb ) ) {
call_dissector ( ( nsp_handle ) ? nsp_handle : data_handle , next_tvb , actx -> pinfo , tree ) ;
}
return offset ;
}
|
-5,697,857,125,570,094,000 |
chrome
| 3 | 0 |
static const char * ultag_getScript ( const ULanguageTag * langtag ) {
return langtag -> script ;
}
|
6,302,861,533,225,985,000 |
debian
| 22 | 0 |
static inline void pxa2xx_fir_update ( PXA2xxFIrState * s ) {
static const int tresh [ 4 ] = {
8 , 16 , 32 , 0 }
;
int intr = 0 ;
if ( ( s -> control [ 0 ] & ( 1 << 4 ) ) && s -> rx_len >= tresh [ s -> control [ 2 ] & 3 ] ) s -> status [ 0 ] |= 1 << 4 ;
else s -> status [ 0 ] &= ~ ( 1 << 4 ) ;
if ( s -> control [ 0 ] & ( 1 << 3 ) ) s -> status [ 0 ] |= 1 << 3 ;
else s -> status [ 0 ] &= ~ ( 1 << 3 ) ;
if ( s -> rx_len ) s -> status [ 1 ] |= 1 << 2 ;
else s -> status [ 1 ] &= ~ ( 1 << 2 ) ;
if ( s -> control [ 0 ] & ( 1 << 4 ) ) s -> status [ 1 ] |= 1 << 0 ;
else s -> status [ 1 ] &= ~ ( 1 << 0 ) ;
intr |= ( s -> control [ 0 ] & ( 1 << 5 ) ) && ( s -> status [ 0 ] & ( 1 << 4 ) ) ;
intr |= ( s -> control [ 0 ] & ( 1 << 6 ) ) && ( s -> status [ 0 ] & ( 1 << 3 ) ) ;
intr |= ( s -> control [ 2 ] & ( 1 << 4 ) ) && ( s -> status [ 0 ] & ( 1 << 6 ) ) ;
intr |= ( s -> control [ 0 ] & ( 1 << 2 ) ) && ( s -> status [ 0 ] & ( 1 << 1 ) ) ;
intr |= s -> status [ 0 ] & 0x25 ;
qemu_set_irq ( s -> rx_dma , ( s -> status [ 0 ] >> 4 ) & 1 ) ;
qemu_set_irq ( s -> tx_dma , ( s -> status [ 0 ] >> 3 ) & 1 ) ;
qemu_set_irq ( s -> irq , intr && s -> enable ) ;
}
|
4,365,405,643,121,995,300 |
debian
| 7 | 0 |
static void set_ping_group_range ( struct ctl_table * table , gid_t range [ 2 ] ) {
gid_t * data = table -> data ;
write_seqlock ( & sysctl_local_ports . lock ) ;
data [ 0 ] = range [ 0 ] ;
data [ 1 ] = range [ 1 ] ;
write_sequnlock ( & sysctl_local_ports . lock ) ;
}
|
4,206,838,170,759,624,700 |
debian
| 21 | 0 |
static SocketAddress * nbd_build_socket_address ( const char * sockpath , const char * bindto , const char * port ) {
SocketAddress * saddr ;
saddr = g_new0 ( SocketAddress , 1 ) ;
if ( sockpath ) {
saddr -> type = SOCKET_ADDRESS_TYPE_UNIX ;
saddr -> u . q_unix . path = g_strdup ( sockpath ) ;
}
else {
InetSocketAddress * inet ;
saddr -> type = SOCKET_ADDRESS_TYPE_INET ;
inet = & saddr -> u . inet ;
inet -> host = g_strdup ( bindto ) ;
if ( port ) {
inet -> port = g_strdup ( port ) ;
}
else {
inet -> port = g_strdup_printf ( "%d" , NBD_DEFAULT_PORT ) ;
}
}
return saddr ;
}
|
-1,315,695,702,746,584,300 |
debian
| 11 | 0 |
proto_item * proto_tree_add_uint64_format_value ( proto_tree * tree , int hfindex , tvbuff_t * tvb , gint start , gint length , guint64 value , const char * format , ... ) {
proto_item * pi ;
va_list ap ;
pi = proto_tree_add_uint64 ( tree , hfindex , tvb , start , length , value ) ;
if ( pi != tree ) {
va_start ( ap , format ) ;
proto_tree_set_representation_value ( pi , format , ap ) ;
va_end ( ap ) ;
}
return pi ;
}
|
-5,861,178,779,585,942,000 |
debian
| 17 | 0 |
int fn_printn ( netdissect_options * ndo , register const u_char * s , register u_int n , register const u_char * ep ) {
register u_char c ;
while ( n > 0 && ( ep == NULL || s < ep ) ) {
n -- ;
c = * s ++ ;
if ( ! ND_ISASCII ( c ) ) {
c = ND_TOASCII ( c ) ;
ND_PRINT ( ( ndo , "M-" ) ) ;
}
if ( ! ND_ISPRINT ( c ) ) {
c ^= 0x40 ;
ND_PRINT ( ( ndo , "^" ) ) ;
}
ND_PRINT ( ( ndo , "%c" , c ) ) ;
}
return ( n == 0 ) ? 0 : 1 ;
}
|
1,353,431,100,313,404,400 |
chrome
| 40 | 0 |
static void setup_frame_size_with_refs ( VP9_COMMON * cm , struct vp9_read_bit_buffer * rb ) {
int width , height ;
int found = 0 , i ;
int has_valid_ref_frame = 0 ;
for ( i = 0 ;
i < REFS_PER_FRAME ;
++ i ) {
if ( vp9_rb_read_bit ( rb ) ) {
YV12_BUFFER_CONFIG * const buf = cm -> frame_refs [ i ] . buf ;
width = buf -> y_crop_width ;
height = buf -> y_crop_height ;
if ( buf -> corrupted ) {
vpx_internal_error ( & cm -> error , VPX_CODEC_CORRUPT_FRAME , "Frame reference is corrupt" ) ;
}
found = 1 ;
break ;
}
}
if ( ! found ) vp9_read_frame_size ( rb , & width , & height ) ;
if ( width <= 0 || height <= 0 ) vpx_internal_error ( & cm -> error , VPX_CODEC_CORRUPT_FRAME , "Invalid frame size" ) ;
for ( i = 0 ;
i < REFS_PER_FRAME ;
++ i ) {
RefBuffer * const ref_frame = & cm -> frame_refs [ i ] ;
has_valid_ref_frame |= valid_ref_frame_size ( ref_frame -> buf -> y_crop_width , ref_frame -> buf -> y_crop_height , width , height ) ;
}
if ( ! has_valid_ref_frame ) vpx_internal_error ( & cm -> error , VPX_CODEC_CORRUPT_FRAME , "Referenced frame has invalid size" ) ;
for ( i = 0 ;
i < REFS_PER_FRAME ;
++ i ) {
RefBuffer * const ref_frame = & cm -> frame_refs [ i ] ;
if ( ! valid_ref_frame_img_fmt ( ref_frame -> buf -> bit_depth , ref_frame -> buf -> uv_crop_width < ref_frame -> buf -> y_crop_width , ref_frame -> buf -> uv_crop_height < ref_frame -> buf -> y_crop_height , cm -> bit_depth , cm -> subsampling_x , cm -> subsampling_y ) ) vpx_internal_error ( & cm -> error , VPX_CODEC_CORRUPT_FRAME , "Referenced frame has incompatible color space" ) ;
}
resize_context_buffers ( cm , width , height ) ;
setup_display_size ( cm , rb ) ;
if ( vp9_realloc_frame_buffer ( get_frame_new_buffer ( cm ) , cm -> width , cm -> height , cm -> subsampling_x , cm -> subsampling_y , # if CONFIG_VP9_HIGHBITDEPTH cm -> use_highbitdepth , # endif VP9_DEC_BORDER_IN_PIXELS , & cm -> frame_bufs [ cm -> new_fb_idx ] . raw_frame_buffer , cm -> get_fb_cb , cm -> cb_priv ) ) {
vpx_internal_error ( & cm -> error , VPX_CODEC_MEM_ERROR , "Failed to allocate frame buffer" ) ;
}
cm -> frame_bufs [ cm -> new_fb_idx ] . buf . bit_depth = ( unsigned int ) cm -> bit_depth ;
}
|
1,760,449,185,745,615,400 |
debian
| 20 | 0 |
TSVConn TSHttpConnectWithPluginId ( sockaddr const * addr , const char * tag , int64_t id ) {
sdk_assert ( addr ) ;
sdk_assert ( ats_is_ip ( addr ) ) ;
sdk_assert ( ats_ip_port_cast ( addr ) ) ;
if ( plugin_http_accept ) {
PluginVCCore * new_pvc = PluginVCCore : : alloc ( plugin_http_accept ) ;
new_pvc -> set_active_addr ( addr ) ;
new_pvc -> set_plugin_id ( id ) ;
new_pvc -> set_plugin_tag ( tag ) ;
PluginVC * return_vc = new_pvc -> connect ( ) ;
if ( return_vc != nullptr ) {
PluginVC * other_side = return_vc -> get_other_side ( ) ;
if ( other_side != nullptr ) {
other_side -> set_is_internal_request ( true ) ;
}
}
return reinterpret_cast < TSVConn > ( return_vc ) ;
}
return nullptr ;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.