Datasets:

claudios

/

ReVeal

like 2

debian

static void fetch_symref ( const char * path , char * * symref , unsigned char * sha1 ) { char * url = xstrfmt ( "%s%s" , repo -> url , path ) ; struct strbuf buffer = STRBUF_INIT ; const char * name ; if ( http_get_strbuf ( url , & buffer , NULL ) != HTTP_OK ) die ( "Couldn't get %s for remote symref\n%s" , url , curl_errorstr ) ; free ( url ) ; free ( * symref ) ; * symref = NULL ; hashclr ( sha1 ) ; if ( buffer . len == 0 ) return ; strbuf_rtrim ( & buffer ) ; if ( skip_prefix ( buffer . buf , "ref: " , & name ) ) { * symref = xmemdupz ( name , buffer . len - ( name - buffer . buf ) ) ; } else { get_sha1_hex ( buffer . buf , sha1 ) ; } strbuf_release ( & buffer ) ; }

chrome

static int get_qzbin_factor ( int q , vpx_bit_depth_t bit_depth ) { const int quant = vp9_dc_quant ( q , 0 , bit_depth ) ; # if CONFIG_VP9_HIGHBITDEPTH switch ( bit_depth ) { case VPX_BITS_8 : return q == 0 ? 64 : ( quant < 148 ? 84 : 80 ) ; case VPX_BITS_10 : return q == 0 ? 64 : ( quant < 592 ? 84 : 80 ) ; case VPX_BITS_12 : return q == 0 ? 64 : ( quant < 2368 ? 84 : 80 ) ; default : assert ( 0 && "bit_depth should be VPX_BITS_8, VPX_BITS_10 or VPX_BITS_12" ) ; return - 1 ; } # else ( void ) bit_depth ; return q == 0 ? 64 : ( quant < 148 ? 84 : 80 ) ; # endif }

debian

inline static bool is_negative_caching_appropriate ( HttpTransact : : State * s ) { if ( ! s -> txn_conf -> negative_caching_enabled || ! s -> hdr_info . server_response . valid ( ) ) { return false ; } switch ( s -> hdr_info . server_response . status_get ( ) ) { case HTTP_STATUS_NO_CONTENT : case HTTP_STATUS_USE_PROXY : case HTTP_STATUS_BAD_REQUEST : case HTTP_STATUS_FORBIDDEN : case HTTP_STATUS_NOT_FOUND : case HTTP_STATUS_METHOD_NOT_ALLOWED : case HTTP_STATUS_REQUEST_URI_TOO_LONG : case HTTP_STATUS_INTERNAL_SERVER_ERROR : case HTTP_STATUS_NOT_IMPLEMENTED : case HTTP_STATUS_BAD_GATEWAY : case HTTP_STATUS_SERVICE_UNAVAILABLE : case HTTP_STATUS_GATEWAY_TIMEOUT : return true ; default : break ; } return false ; }

chrome

void vp9_denoiser_denoise ( VP9_DENOISER * denoiser , MACROBLOCK * mb , int mi_row , int mi_col , BLOCK_SIZE bs , PICK_MODE_CONTEXT * ctx ) { int motion_magnitude = 0 ; VP9_DENOISER_DECISION decision = FILTER_BLOCK ; YV12_BUFFER_CONFIG avg = denoiser -> running_avg_y [ INTRA_FRAME ] ; YV12_BUFFER_CONFIG mc_avg = denoiser -> mc_running_avg_y ; uint8_t * avg_start = block_start ( avg . y_buffer , avg . y_stride , mi_row , mi_col ) ; uint8_t * mc_avg_start = block_start ( mc_avg . y_buffer , mc_avg . y_stride , mi_row , mi_col ) ; struct buf_2d src = mb -> plane [ 0 ] . src ; decision = perform_motion_compensation ( denoiser , mb , bs , denoiser -> increase_denoising , mi_row , mi_col , ctx , & motion_magnitude ) ; if ( decision == FILTER_BLOCK ) { decision = denoiser_filter ( src . buf , src . stride , mc_avg_start , mc_avg . y_stride , avg_start , avg . y_stride , 0 , bs , motion_magnitude ) ; } if ( decision == FILTER_BLOCK ) { copy_block ( src . buf , src . stride , avg_start , avg . y_stride , bs ) ; } else { copy_block ( avg_start , avg . y_stride , src . buf , src . stride , bs ) ; } }

debian

static void timerblock_write ( void * opaque , hwaddr addr , uint64_t value , unsigned size ) { TimerBlock * tb = ( TimerBlock * ) opaque ; int64_t old ; switch ( addr ) { case 0 : tb -> load = value ; case 4 : if ( ( tb -> control & 1 ) && tb -> count ) { qemu_del_timer ( tb -> timer ) ; } tb -> count = value ; if ( tb -> control & 1 ) { timerblock_reload ( tb , 1 ) ; } break ; case 8 : old = tb -> control ; tb -> control = value ; if ( ( ( old & 1 ) == 0 ) && ( value & 1 ) ) { if ( tb -> count == 0 && ( tb -> control & 2 ) ) { tb -> count = tb -> load ; } timerblock_reload ( tb , 1 ) ; } break ; case 12 : tb -> status &= ~ value ; timerblock_update_irq ( tb ) ; break ; } }

debian

static void dissect_rtp_hext_rfc5215_onebyte ( tvbuff_t * tvb , packet_info * pinfo , proto_tree * rtp_hext_tree ) { proto_item * ti = NULL ; proto_tree * rtp_hext_rfc5285_tree = NULL ; guint ext_offset = 0 , start_ext_offset ; while ( ext_offset < tvb_length ( tvb ) ) { guint8 ext_hdr_hdr ; guint8 ext_id ; guint8 ext_length ; tvbuff_t * subtvb = NULL ; start_ext_offset = ext_offset ; while ( tvb_get_guint8 ( tvb , ext_offset ) == 0 ) { ext_offset ++ ; if ( ext_offset >= tvb_length ( tvb ) ) return ; } if ( ext_offset > start_ext_offset ) proto_tree_add_item ( rtp_hext_tree , hf_rtp_padding_data , tvb , ext_offset , ext_offset - start_ext_offset , ENC_NA ) ; ext_hdr_hdr = tvb_get_guint8 ( tvb , ext_offset ) ; ext_id = ext_hdr_hdr >> 4 ; if ( ext_id == 15 ) return ; ext_length = ( ext_hdr_hdr & 0x0F ) + 1 ; if ( rtp_hext_tree ) { ti = proto_tree_add_text ( rtp_hext_tree , tvb , ext_offset , ext_length + 1 , "RFC 5285 Header Extension (One-Byte Header)" ) ; rtp_hext_rfc5285_tree = proto_item_add_subtree ( ti , ett_hdr_ext_rfc5285 ) ; proto_tree_add_uint ( rtp_hext_rfc5285_tree , hf_rtp_ext_rfc5285_id , tvb , ext_offset , 1 , ext_id ) ; proto_tree_add_uint ( rtp_hext_rfc5285_tree , hf_rtp_ext_rfc5285_length , tvb , ext_offset , 1 , ext_length ) ; } ext_offset ++ ; subtvb = tvb_new_subset ( tvb , ext_offset , ext_length , ext_length ) ; if ( ! dissector_try_uint ( rtp_hdr_ext_rfc5285_dissector_table , ext_id , subtvb , pinfo , rtp_hext_rfc5285_tree ) ) { if ( rtp_hext_tree ) proto_tree_add_item ( rtp_hext_rfc5285_tree , hf_rtp_ext_rfc5285_data , subtvb , 0 , ext_length , ENC_NA ) ; } ext_offset += ext_length ; } }

debian

static void mpc7_decode_flush ( AVCodecContext * avctx ) { MPCContext * c = avctx -> priv_data ; memset ( c -> oldDSCF , 0 , sizeof ( c -> oldDSCF ) ) ; c -> frames_to_skip = 32 ; }

debian

int auth_server_connection_connect ( struct auth_server_connection * conn ) { const char * handshake ; int fd ; i_assert ( ! conn -> connected ) ; i_assert ( conn -> fd == - 1 ) ; conn -> last_connect = ioloop_time ; timeout_remove ( & conn -> to ) ; fd = net_connect_unix_with_retries ( conn -> client -> auth_socket_path , 1000 ) ; if ( fd == - 1 ) { if ( errno == EACCES ) { i_error ( "auth: %s" , eacces_error_get ( "connect" , conn -> client -> auth_socket_path ) ) ; } else { i_error ( "auth: connect(%s) failed: %m" , conn -> client -> auth_socket_path ) ; } return - 1 ; } conn -> fd = fd ; conn -> io = io_add ( fd , IO_READ , auth_server_connection_input , conn ) ; conn -> input = i_stream_create_fd ( fd , AUTH_SERVER_CONN_MAX_LINE_LENGTH ) ; conn -> output = o_stream_create_fd ( fd , ( size_t ) - 1 ) ; conn -> connected = TRUE ; handshake = t_strdup_printf ( "VERSION\t%u\t%u\nCPID\t%u\n" , AUTH_CLIENT_PROTOCOL_MAJOR_VERSION , AUTH_CLIENT_PROTOCOL_MINOR_VERSION , conn -> client -> client_pid ) ; if ( o_stream_send_str ( conn -> output , handshake ) < 0 ) { i_warning ( "Error sending handshake to auth server: %s" , o_stream_get_error ( conn -> output ) ) ; auth_server_connection_disconnect ( conn , o_stream_get_error ( conn -> output ) ) ; return - 1 ; } conn -> to = timeout_add ( AUTH_HANDSHAKE_TIMEOUT , auth_client_handshake_timeout , conn ) ; return 0 ; }

debian

static krb5_error_code process_db_args ( krb5_context context , char * * db_args , xargs_t * xargs , OPERATION optype ) { int i = 0 ; krb5_error_code st = 0 ; char * arg = NULL , * arg_val = NULL ; char * * dptr = NULL ; unsigned int arg_val_len = 0 ; if ( db_args ) { for ( i = 0 ; db_args [ i ] ; ++ i ) { arg = strtok_r ( db_args [ i ] , "=" , & arg_val ) ; if ( strcmp ( arg , TKTPOLICY_ARG ) == 0 ) { dptr = & xargs -> tktpolicydn ; } else { if ( strcmp ( arg , USERDN_ARG ) == 0 ) { if ( optype == MODIFY_PRINCIPAL || xargs -> dn != NULL || xargs -> containerdn != NULL || xargs -> linkdn != NULL ) { st = EINVAL ; k5_setmsg ( context , st , _ ( "%s option not supported" ) , arg ) ; goto cleanup ; } dptr = & xargs -> dn ; } else if ( strcmp ( arg , CONTAINERDN_ARG ) == 0 ) { if ( optype == MODIFY_PRINCIPAL || xargs -> dn != NULL || xargs -> containerdn != NULL ) { st = EINVAL ; k5_setmsg ( context , st , _ ( "%s option not supported" ) , arg ) ; goto cleanup ; } dptr = & xargs -> containerdn ; } else if ( strcmp ( arg , LINKDN_ARG ) == 0 ) { if ( xargs -> dn != NULL || xargs -> linkdn != NULL ) { st = EINVAL ; k5_setmsg ( context , st , _ ( "%s option not supported" ) , arg ) ; goto cleanup ; } dptr = & xargs -> linkdn ; } else { st = EINVAL ; k5_setmsg ( context , st , _ ( "unknown option: %s" ) , arg ) ; goto cleanup ; } xargs -> dn_from_kbd = TRUE ; if ( arg_val == NULL || strlen ( arg_val ) == 0 ) { st = EINVAL ; k5_setmsg ( context , st , _ ( "%s option value missing" ) , arg ) ; goto cleanup ; } } if ( arg_val == NULL ) { st = EINVAL ; k5_setmsg ( context , st , _ ( "%s option value missing" ) , arg ) ; goto cleanup ; } arg_val_len = strlen ( arg_val ) + 1 ; if ( strcmp ( arg , TKTPOLICY_ARG ) == 0 ) { if ( ( st = krb5_ldap_name_to_policydn ( context , arg_val , dptr ) ) != 0 ) goto cleanup ; } else { * dptr = k5memdup ( arg_val , arg_val_len , & st ) ; if ( * dptr == NULL ) goto cleanup ; } } } cleanup : return st ; }

debian

static void vmsvga_init ( DeviceState * dev , struct vmsvga_state_s * s , MemoryRegion * address_space , MemoryRegion * io ) { s -> scratch_size = SVGA_SCRATCH_SIZE ; s -> scratch = g_malloc ( s -> scratch_size * 4 ) ; s -> vga . con = graphic_console_init ( dev , 0 , & vmsvga_ops , s ) ; s -> fifo_size = SVGA_FIFO_SIZE ; memory_region_init_ram ( & s -> fifo_ram , NULL , "vmsvga.fifo" , s -> fifo_size , & error_abort ) ; vmstate_register_ram_global ( & s -> fifo_ram ) ; s -> fifo_ptr = memory_region_get_ram_ptr ( & s -> fifo_ram ) ; vga_common_init ( & s -> vga , OBJECT ( dev ) , true ) ; vga_init ( & s -> vga , OBJECT ( dev ) , address_space , io , true ) ; vmstate_register ( NULL , 0 , & vmstate_vga_common , & s -> vga ) ; s -> new_depth = 32 ; }

debian

int qemuAgentGetFSInfo ( qemuAgentPtr mon , virDomainFSInfoPtr * * info , virDomainDefPtr vmdef ) { size_t i , j , k ; int ret = - 1 ; ssize_t ndata = 0 , ndisk ; char * * alias ; virJSONValuePtr cmd ; virJSONValuePtr reply = NULL ; virJSONValuePtr data ; virDomainFSInfoPtr * info_ret = NULL ; virPCIDeviceAddress pci_address ; cmd = qemuAgentMakeCommand ( "guest-get-fsinfo" , NULL ) ; if ( ! cmd ) return ret ; if ( qemuAgentCommand ( mon , cmd , & reply , true , VIR_DOMAIN_QEMU_AGENT_COMMAND_BLOCK ) < 0 ) goto cleanup ; if ( ! ( data = virJSONValueObjectGet ( reply , "return" ) ) ) { virReportError ( VIR_ERR_INTERNAL_ERROR , "%s" , _ ( "guest-get-fsinfo reply was missing return data" ) ) ; goto cleanup ; } if ( data -> type != VIR_JSON_TYPE_ARRAY ) { virReportError ( VIR_ERR_INTERNAL_ERROR , "%s" , _ ( "guest-get-fsinfo return information was not " "an array" ) ) ; goto cleanup ; } ndata = virJSONValueArraySize ( data ) ; if ( ! ndata ) { ret = 0 ; * info = NULL ; goto cleanup ; } if ( VIR_ALLOC_N ( info_ret , ndata ) < 0 ) goto cleanup ; for ( i = 0 ; i < ndata ; i ++ ) { virJSONValuePtr entry = virJSONValueArrayGet ( data , ndata - 1 - i ) ; if ( ! entry ) { virReportError ( VIR_ERR_INTERNAL_ERROR , _ ( "array element '%zd' of '%zd' missing in " "guest-get-fsinfo return data" ) , i , ndata ) ; goto cleanup ; } if ( VIR_ALLOC ( info_ret [ i ] ) < 0 ) goto cleanup ; if ( VIR_STRDUP ( info_ret [ i ] -> mountpoint , virJSONValueObjectGetString ( entry , "mountpoint" ) ) < 0 ) { virReportError ( VIR_ERR_INTERNAL_ERROR , "%s" , _ ( "'mountpoint' missing in reply of " "guest-get-fsinfo" ) ) ; goto cleanup ; } if ( VIR_STRDUP ( info_ret [ i ] -> name , virJSONValueObjectGetString ( entry , "name" ) ) < 0 ) { virReportError ( VIR_ERR_INTERNAL_ERROR , "%s" , _ ( "'name' missing in reply of guest-get-fsinfo" ) ) ; goto cleanup ; } if ( VIR_STRDUP ( info_ret [ i ] -> fstype , virJSONValueObjectGetString ( entry , "type" ) ) < 0 ) { virReportError ( VIR_ERR_INTERNAL_ERROR , "%s" , _ ( "'type' missing in reply of guest-get-fsinfo" ) ) ; goto cleanup ; } if ( ! ( entry = virJSONValueObjectGet ( entry , "disk" ) ) ) { virReportError ( VIR_ERR_INTERNAL_ERROR , "%s" , _ ( "'disk' missing in reply of guest-get-fsinfo" ) ) ; goto cleanup ; } if ( entry -> type != VIR_JSON_TYPE_ARRAY ) { virReportError ( VIR_ERR_INTERNAL_ERROR , "%s" , _ ( "guest-get-fsinfo 'disk' data was not an array" ) ) ; goto cleanup ; } ndisk = virJSONValueArraySize ( entry ) ; if ( ! ndisk ) continue ; if ( VIR_ALLOC_N ( info_ret [ i ] -> devAlias , ndisk ) < 0 ) goto cleanup ; alias = info_ret [ i ] -> devAlias ; info_ret [ i ] -> ndevAlias = 0 ; for ( j = 0 ; j < ndisk ; j ++ ) { virJSONValuePtr disk = virJSONValueArrayGet ( entry , j ) ; virJSONValuePtr pci ; int diskaddr [ 3 ] , pciaddr [ 4 ] ; const char * diskaddr_comp [ ] = { "bus" , "target" , "unit" } ; const char * pciaddr_comp [ ] = { "domain" , "bus" , "slot" , "function" } ; virDomainDiskDefPtr diskDef ; if ( ! disk ) { virReportError ( VIR_ERR_INTERNAL_ERROR , _ ( "array element '%zd' of '%zd' missing in " "guest-get-fsinfo 'disk' data" ) , j , ndisk ) ; goto cleanup ; } if ( ! ( pci = virJSONValueObjectGet ( disk , "pci-controller" ) ) ) { virReportError ( VIR_ERR_INTERNAL_ERROR , "%s" , _ ( "'pci-controller' missing in guest-get-fsinfo " "'disk' data" ) ) ; goto cleanup ; } for ( k = 0 ; k < 3 ; k ++ ) { if ( virJSONValueObjectGetNumberInt ( disk , diskaddr_comp [ k ] , & diskaddr [ k ] ) < 0 ) { virReportError ( VIR_ERR_INTERNAL_ERROR , _ ( "'%s' missing in guest-get-fsinfo " "'disk' data" ) , diskaddr_comp [ k ] ) ; goto cleanup ; } } for ( k = 0 ; k < 4 ; k ++ ) { if ( virJSONValueObjectGetNumberInt ( pci , pciaddr_comp [ k ] , & pciaddr [ k ] ) < 0 ) { virReportError ( VIR_ERR_INTERNAL_ERROR , _ ( "'%s' missing in guest-get-fsinfo " "'pci-address' data" ) , pciaddr_comp [ k ] ) ; goto cleanup ; } } pci_address . domain = pciaddr [ 0 ] ; pci_address . bus = pciaddr [ 1 ] ; pci_address . slot = pciaddr [ 2 ] ; pci_address . function = pciaddr [ 3 ] ; if ( ! ( diskDef = virDomainDiskByAddress ( vmdef , & pci_address , diskaddr [ 0 ] , diskaddr [ 1 ] , diskaddr [ 2 ] ) ) ) continue ; if ( VIR_STRDUP ( * alias , diskDef -> dst ) < 0 ) goto cleanup ; if ( * alias ) { alias ++ ; info_ret [ i ] -> ndevAlias ++ ; } } } * info = info_ret ; info_ret = NULL ; ret = ndata ; cleanup : if ( info_ret ) { for ( i = 0 ; i < ndata ; i ++ ) virDomainFSInfoFree ( info_ret [ i ] ) ; VIR_FREE ( info_ret ) ; } virJSONValueFree ( cmd ) ; virJSONValueFree ( reply ) ; return ret ; }

debian

static int dissect_h245_T_iPSourceRouteAddress ( tvbuff_t * tvb _U_ , int offset _U_ , asn1_ctx_t * actx _U_ , proto_tree * tree _U_ , int hf_index _U_ ) { offset = dissect_per_sequence ( tvb , offset , actx , tree , hf_index , ett_h245_T_iPSourceRouteAddress , T_iPSourceRouteAddress_sequence ) ; return offset ; }

debian

static bool_t _xdr_kadm5_policy_ent_rec ( XDR * xdrs , kadm5_policy_ent_rec * objp , int vers ) { if ( ! xdr_nullstring ( xdrs , & objp -> policy ) ) { return ( FALSE ) ; } if ( ! xdr_long ( xdrs , & objp -> pw_min_life ) ) { return ( FALSE ) ; } if ( ! xdr_long ( xdrs , & objp -> pw_max_life ) ) { return ( FALSE ) ; } if ( ! xdr_long ( xdrs , & objp -> pw_min_length ) ) { return ( FALSE ) ; } if ( ! xdr_long ( xdrs , & objp -> pw_min_classes ) ) { return ( FALSE ) ; } if ( ! xdr_long ( xdrs , & objp -> pw_history_num ) ) { return ( FALSE ) ; } if ( ! xdr_long ( xdrs , & objp -> policy_refcnt ) ) { return ( FALSE ) ; } if ( xdrs -> x_op == XDR_DECODE ) { objp -> pw_max_fail = 0 ; objp -> pw_failcnt_interval = 0 ; objp -> pw_lockout_duration = 0 ; objp -> attributes = 0 ; objp -> max_life = 0 ; objp -> max_renewable_life = 0 ; objp -> allowed_keysalts = NULL ; objp -> n_tl_data = 0 ; objp -> tl_data = NULL ; } if ( vers >= KADM5_API_VERSION_3 ) { if ( ! xdr_krb5_kvno ( xdrs , & objp -> pw_max_fail ) ) return ( FALSE ) ; if ( ! xdr_krb5_deltat ( xdrs , & objp -> pw_failcnt_interval ) ) return ( FALSE ) ; if ( ! xdr_krb5_deltat ( xdrs , & objp -> pw_lockout_duration ) ) return ( FALSE ) ; } if ( vers >= KADM5_API_VERSION_4 ) { if ( ! xdr_krb5_flags ( xdrs , & objp -> attributes ) ) { return ( FALSE ) ; } if ( ! xdr_krb5_deltat ( xdrs , & objp -> max_life ) ) { return ( FALSE ) ; } if ( ! xdr_krb5_deltat ( xdrs , & objp -> max_renewable_life ) ) { return ( FALSE ) ; } if ( ! xdr_nullstring ( xdrs , & objp -> allowed_keysalts ) ) { return ( FALSE ) ; } if ( ! xdr_krb5_int16 ( xdrs , & objp -> n_tl_data ) ) { return ( FALSE ) ; } if ( ! xdr_nulltype ( xdrs , ( void * * ) & objp -> tl_data , xdr_krb5_tl_data ) ) { return FALSE ; } } return ( TRUE ) ; }

debian

int tm_destroy_event ( tm_event_t * event ) { if ( ! init_done ) return TM_BADINIT ; return TM_ENOTIMPLEMENTED ; }

debian

static my_off_t get_record_for_key ( MI_INFO * info , MI_KEYDEF * keyinfo , uchar * key ) { return _mi_dpos ( info , 0 , key + _mi_keylength ( keyinfo , key ) ) ; }

debian

static void dissect_zcl_appl_evtalt_get_alerts_rsp ( tvbuff_t * tvb , proto_tree * tree , guint * offset ) { proto_tree * sub_tree = NULL ; guint i ; guint8 count ; count = tvb_get_guint8 ( tvb , * offset ) & ZBEE_ZCL_APPL_EVTALT_COUNT_NUM_MASK ; proto_tree_add_item ( tree , hf_zbee_zcl_appl_evtalt_count_num , tvb , * offset , 1 , ENC_NA ) ; proto_tree_add_item ( tree , hf_zbee_zcl_appl_evtalt_count_type , tvb , * offset , 1 , ENC_NA ) ; * offset += 1 ; for ( i = 0 ; i < count ; i ++ ) { sub_tree = proto_tree_add_subtree_format ( tree , tvb , * offset , 1 , ett_zbee_zcl_appl_evtalt_alerts_struct [ i ] , NULL , "Alerts Structure #%u" , i ) ; dissect_zcl_appl_evtalt_alerts_struct ( tvb , sub_tree , offset ) ; } }

chrome

void vp9_fdct32x32_c ( const int16_t * input , int16_t * out , int stride ) { int i , j ; int output [ 32 * 32 ] ; for ( i = 0 ; i < 32 ; ++ i ) { int temp_in [ 32 ] , temp_out [ 32 ] ; for ( j = 0 ; j < 32 ; ++ j ) temp_in [ j ] = input [ j * stride + i ] * 4 ; fdct32 ( temp_in , temp_out , 0 ) ; for ( j = 0 ; j < 32 ; ++ j ) output [ j * 32 + i ] = ( temp_out [ j ] + 1 + ( temp_out [ j ] > 0 ) ) >> 2 ; } for ( i = 0 ; i < 32 ; ++ i ) { int temp_in [ 32 ] , temp_out [ 32 ] ; for ( j = 0 ; j < 32 ; ++ j ) temp_in [ j ] = output [ j + i * 32 ] ; fdct32 ( temp_in , temp_out , 0 ) ; for ( j = 0 ; j < 32 ; ++ j ) out [ j + i * 32 ] = ( temp_out [ j ] + 1 + ( temp_out [ j ] < 0 ) ) >> 2 ; } }

debian

static int dissect_CPMGetRowsetNotify ( tvbuff_t * tvb , packet_info * pinfo , proto_tree * parent_tree , gboolean in , void * data _U_ ) { gint offset = 16 ; proto_item * item ; proto_tree * tree ; col_append_str ( pinfo -> cinfo , COL_INFO , "GetRowsetNotify" ) ; if ( ! in ) { item = proto_tree_add_item ( parent_tree , hf_mswsp_msg , tvb , offset , - 1 , ENC_NA ) ; tree = proto_item_add_subtree ( item , ett_mswsp_msg ) ; proto_item_set_text ( item , "GetRowsetNotifyOut" ) ; proto_tree_add_item ( tree , hf_mswsp_msg_cpmgetrowsetnotify_wid , tvb , offset , 4 , ENC_LITTLE_ENDIAN ) ; offset += 4 ; proto_tree_add_item ( tree , hf_mswsp_msg_cpmgetrowsetnotify_moreevents , tvb , offset , 1 , ENC_LITTLE_ENDIAN ) ; proto_tree_add_item ( tree , hf_mswsp_msg_cpmgetrowsetnotify_eventtype , tvb , offset , 1 , ENC_LITTLE_ENDIAN ) ; offset += 1 ; proto_tree_add_item ( tree , hf_mswsp_msg_cpmgetrowsetnotify_rowsetitemstate , tvb , offset , 1 , ENC_LITTLE_ENDIAN ) ; offset += 1 ; proto_tree_add_item ( tree , hf_mswsp_msg_cpmgetrowsetnotify_changeditemstate , tvb , offset , 1 , ENC_LITTLE_ENDIAN ) ; offset += 1 ; proto_tree_add_item ( tree , hf_mswsp_msg_cpmgetrowsetnotify_rowsetevent , tvb , offset , 1 , ENC_LITTLE_ENDIAN ) ; offset += 1 ; proto_tree_add_item ( tree , hf_mswsp_msg_cpmgetrowsetnotify_rowseteventdata1 , tvb , offset , 8 , ENC_LITTLE_ENDIAN ) ; offset += 8 ; proto_tree_add_item ( tree , hf_mswsp_msg_cpmgetrowsetnotify_rowseteventdata2 , tvb , offset , 8 , ENC_LITTLE_ENDIAN ) ; } return tvb_reported_length ( tvb ) ; }

debian

static void print_servers ( void ) { GSList * tmp ; for ( tmp = servers ; tmp != NULL ; tmp = tmp -> next ) { SERVER_REC * rec = tmp -> data ; printformat ( NULL , NULL , MSGLEVEL_CRAP , TXT_SERVER_LIST , rec -> tag , rec -> connrec -> address , rec -> connrec -> port , rec -> connrec -> chatnet == NULL ? "" : rec -> connrec -> chatnet , rec -> connrec -> nick ) ; } }

chrome

void vp8_sixtap_predict16x16_neon ( unsigned char * src_ptr , int src_pixels_per_line , int xoffset , int yoffset , unsigned char * dst_ptr , int dst_pitch ) { unsigned char * src , * src_tmp , * dst , * tmpp ; unsigned char tmp [ 336 ] ; int i , j ; uint8x8_t d0u8 , d1u8 , d2u8 , d3u8 , d4u8 , d5u8 , d6u8 , d7u8 , d8u8 , d9u8 ; uint8x8_t d10u8 , d11u8 , d12u8 , d13u8 , d14u8 , d15u8 , d18u8 , d19u8 ; uint8x8_t d20u8 , d21u8 , d22u8 , d23u8 , d24u8 , d25u8 , d26u8 , d27u8 ; uint8x8_t d28u8 , d29u8 , d30u8 , d31u8 ; int8x8_t dtmps8 , d0s8 , d1s8 , d2s8 , d3s8 , d4s8 , d5s8 ; uint8x16_t q3u8 , q4u8 ; uint16x8_t q3u16 , q4u16 , q5u16 , q6u16 , q7u16 , q8u16 , q9u16 , q10u16 ; uint16x8_t q11u16 , q12u16 , q13u16 , q15u16 ; int16x8_t q3s16 , q4s16 , q5s16 , q6s16 , q7s16 , q8s16 , q9s16 , q10s16 ; int16x8_t q11s16 , q12s16 , q13s16 , q15s16 ; if ( xoffset == 0 ) { dtmps8 = vld1_s8 ( vp8_sub_pel_filters [ yoffset ] ) ; d0s8 = vdup_lane_s8 ( dtmps8 , 0 ) ; d1s8 = vdup_lane_s8 ( dtmps8 , 1 ) ; d2s8 = vdup_lane_s8 ( dtmps8 , 2 ) ; d3s8 = vdup_lane_s8 ( dtmps8 , 3 ) ; d4s8 = vdup_lane_s8 ( dtmps8 , 4 ) ; d5s8 = vdup_lane_s8 ( dtmps8 , 5 ) ; d0u8 = vreinterpret_u8_s8 ( vabs_s8 ( d0s8 ) ) ; d1u8 = vreinterpret_u8_s8 ( vabs_s8 ( d1s8 ) ) ; d2u8 = vreinterpret_u8_s8 ( vabs_s8 ( d2s8 ) ) ; d3u8 = vreinterpret_u8_s8 ( vabs_s8 ( d3s8 ) ) ; d4u8 = vreinterpret_u8_s8 ( vabs_s8 ( d4s8 ) ) ; d5u8 = vreinterpret_u8_s8 ( vabs_s8 ( d5s8 ) ) ; src_tmp = src_ptr - src_pixels_per_line * 2 ; for ( i = 0 ; i < 2 ; i ++ ) { src = src_tmp + i * 8 ; dst = dst_ptr + i * 8 ; d18u8 = vld1_u8 ( src ) ; src += src_pixels_per_line ; d19u8 = vld1_u8 ( src ) ; src += src_pixels_per_line ; d20u8 = vld1_u8 ( src ) ; src += src_pixels_per_line ; d21u8 = vld1_u8 ( src ) ; src += src_pixels_per_line ; d22u8 = vld1_u8 ( src ) ; src += src_pixels_per_line ; for ( j = 0 ; j < 4 ; j ++ ) { d23u8 = vld1_u8 ( src ) ; src += src_pixels_per_line ; d24u8 = vld1_u8 ( src ) ; src += src_pixels_per_line ; d25u8 = vld1_u8 ( src ) ; src += src_pixels_per_line ; d26u8 = vld1_u8 ( src ) ; src += src_pixels_per_line ; q3u16 = vmull_u8 ( d18u8 , d0u8 ) ; q4u16 = vmull_u8 ( d19u8 , d0u8 ) ; q5u16 = vmull_u8 ( d20u8 , d0u8 ) ; q6u16 = vmull_u8 ( d21u8 , d0u8 ) ; q3u16 = vmlsl_u8 ( q3u16 , d19u8 , d1u8 ) ; q4u16 = vmlsl_u8 ( q4u16 , d20u8 , d1u8 ) ; q5u16 = vmlsl_u8 ( q5u16 , d21u8 , d1u8 ) ; q6u16 = vmlsl_u8 ( q6u16 , d22u8 , d1u8 ) ; q3u16 = vmlsl_u8 ( q3u16 , d22u8 , d4u8 ) ; q4u16 = vmlsl_u8 ( q4u16 , d23u8 , d4u8 ) ; q5u16 = vmlsl_u8 ( q5u16 , d24u8 , d4u8 ) ; q6u16 = vmlsl_u8 ( q6u16 , d25u8 , d4u8 ) ; q3u16 = vmlal_u8 ( q3u16 , d20u8 , d2u8 ) ; q4u16 = vmlal_u8 ( q4u16 , d21u8 , d2u8 ) ; q5u16 = vmlal_u8 ( q5u16 , d22u8 , d2u8 ) ; q6u16 = vmlal_u8 ( q6u16 , d23u8 , d2u8 ) ; q3u16 = vmlal_u8 ( q3u16 , d23u8 , d5u8 ) ; q4u16 = vmlal_u8 ( q4u16 , d24u8 , d5u8 ) ; q5u16 = vmlal_u8 ( q5u16 , d25u8 , d5u8 ) ; q6u16 = vmlal_u8 ( q6u16 , d26u8 , d5u8 ) ; q7u16 = vmull_u8 ( d21u8 , d3u8 ) ; q8u16 = vmull_u8 ( d22u8 , d3u8 ) ; q9u16 = vmull_u8 ( d23u8 , d3u8 ) ; q10u16 = vmull_u8 ( d24u8 , d3u8 ) ; q3s16 = vreinterpretq_s16_u16 ( q3u16 ) ; q4s16 = vreinterpretq_s16_u16 ( q4u16 ) ; q5s16 = vreinterpretq_s16_u16 ( q5u16 ) ; q6s16 = vreinterpretq_s16_u16 ( q6u16 ) ; q7s16 = vreinterpretq_s16_u16 ( q7u16 ) ; q8s16 = vreinterpretq_s16_u16 ( q8u16 ) ; q9s16 = vreinterpretq_s16_u16 ( q9u16 ) ; q10s16 = vreinterpretq_s16_u16 ( q10u16 ) ; q7s16 = vqaddq_s16 ( q7s16 , q3s16 ) ; q8s16 = vqaddq_s16 ( q8s16 , q4s16 ) ; q9s16 = vqaddq_s16 ( q9s16 , q5s16 ) ; q10s16 = vqaddq_s16 ( q10s16 , q6s16 ) ; d6u8 = vqrshrun_n_s16 ( q7s16 , 7 ) ; d7u8 = vqrshrun_n_s16 ( q8s16 , 7 ) ; d8u8 = vqrshrun_n_s16 ( q9s16 , 7 ) ; d9u8 = vqrshrun_n_s16 ( q10s16 , 7 ) ; d18u8 = d22u8 ; d19u8 = d23u8 ; d20u8 = d24u8 ; d21u8 = d25u8 ; d22u8 = d26u8 ; vst1_u8 ( dst , d6u8 ) ; dst += dst_pitch ; vst1_u8 ( dst , d7u8 ) ; dst += dst_pitch ; vst1_u8 ( dst , d8u8 ) ; dst += dst_pitch ; vst1_u8 ( dst , d9u8 ) ; dst += dst_pitch ; } } return ; } dtmps8 = vld1_s8 ( vp8_sub_pel_filters [ xoffset ] ) ; d0s8 = vdup_lane_s8 ( dtmps8 , 0 ) ; d1s8 = vdup_lane_s8 ( dtmps8 , 1 ) ; d2s8 = vdup_lane_s8 ( dtmps8 , 2 ) ; d3s8 = vdup_lane_s8 ( dtmps8 , 3 ) ; d4s8 = vdup_lane_s8 ( dtmps8 , 4 ) ; d5s8 = vdup_lane_s8 ( dtmps8 , 5 ) ; d0u8 = vreinterpret_u8_s8 ( vabs_s8 ( d0s8 ) ) ; d1u8 = vreinterpret_u8_s8 ( vabs_s8 ( d1s8 ) ) ; d2u8 = vreinterpret_u8_s8 ( vabs_s8 ( d2s8 ) ) ; d3u8 = vreinterpret_u8_s8 ( vabs_s8 ( d3s8 ) ) ; d4u8 = vreinterpret_u8_s8 ( vabs_s8 ( d4s8 ) ) ; d5u8 = vreinterpret_u8_s8 ( vabs_s8 ( d5s8 ) ) ; if ( yoffset == 0 ) { src = src_ptr - 2 ; dst = dst_ptr ; for ( i = 0 ; i < 8 ; i ++ ) { d6u8 = vld1_u8 ( src ) ; d7u8 = vld1_u8 ( src + 8 ) ; d8u8 = vld1_u8 ( src + 16 ) ; src += src_pixels_per_line ; d9u8 = vld1_u8 ( src ) ; d10u8 = vld1_u8 ( src + 8 ) ; d11u8 = vld1_u8 ( src + 16 ) ; src += src_pixels_per_line ; __builtin_prefetch ( src ) ; __builtin_prefetch ( src + src_pixels_per_line ) ; q6u16 = vmull_u8 ( d6u8 , d0u8 ) ; q7u16 = vmull_u8 ( d7u8 , d0u8 ) ; q8u16 = vmull_u8 ( d9u8 , d0u8 ) ; q9u16 = vmull_u8 ( d10u8 , d0u8 ) ; d20u8 = vext_u8 ( d6u8 , d7u8 , 1 ) ; d21u8 = vext_u8 ( d9u8 , d10u8 , 1 ) ; d22u8 = vext_u8 ( d7u8 , d8u8 , 1 ) ; d23u8 = vext_u8 ( d10u8 , d11u8 , 1 ) ; d24u8 = vext_u8 ( d6u8 , d7u8 , 4 ) ; d25u8 = vext_u8 ( d9u8 , d10u8 , 4 ) ; d26u8 = vext_u8 ( d7u8 , d8u8 , 4 ) ; d27u8 = vext_u8 ( d10u8 , d11u8 , 4 ) ; d28u8 = vext_u8 ( d6u8 , d7u8 , 5 ) ; d29u8 = vext_u8 ( d9u8 , d10u8 , 5 ) ; q6u16 = vmlsl_u8 ( q6u16 , d20u8 , d1u8 ) ; q8u16 = vmlsl_u8 ( q8u16 , d21u8 , d1u8 ) ; q7u16 = vmlsl_u8 ( q7u16 , d22u8 , d1u8 ) ; q9u16 = vmlsl_u8 ( q9u16 , d23u8 , d1u8 ) ; q6u16 = vmlsl_u8 ( q6u16 , d24u8 , d4u8 ) ; q8u16 = vmlsl_u8 ( q8u16 , d25u8 , d4u8 ) ; q7u16 = vmlsl_u8 ( q7u16 , d26u8 , d4u8 ) ; q9u16 = vmlsl_u8 ( q9u16 , d27u8 , d4u8 ) ; q6u16 = vmlal_u8 ( q6u16 , d28u8 , d5u8 ) ; q8u16 = vmlal_u8 ( q8u16 , d29u8 , d5u8 ) ; d20u8 = vext_u8 ( d7u8 , d8u8 , 5 ) ; d21u8 = vext_u8 ( d10u8 , d11u8 , 5 ) ; d22u8 = vext_u8 ( d6u8 , d7u8 , 2 ) ; d23u8 = vext_u8 ( d9u8 , d10u8 , 2 ) ; d24u8 = vext_u8 ( d7u8 , d8u8 , 2 ) ; d25u8 = vext_u8 ( d10u8 , d11u8 , 2 ) ; d26u8 = vext_u8 ( d6u8 , d7u8 , 3 ) ; d27u8 = vext_u8 ( d9u8 , d10u8 , 3 ) ; d28u8 = vext_u8 ( d7u8 , d8u8 , 3 ) ; d29u8 = vext_u8 ( d10u8 , d11u8 , 3 ) ; q7u16 = vmlal_u8 ( q7u16 , d20u8 , d5u8 ) ; q9u16 = vmlal_u8 ( q9u16 , d21u8 , d5u8 ) ; q6u16 = vmlal_u8 ( q6u16 , d22u8 , d2u8 ) ; q8u16 = vmlal_u8 ( q8u16 , d23u8 , d2u8 ) ; q7u16 = vmlal_u8 ( q7u16 , d24u8 , d2u8 ) ; q9u16 = vmlal_u8 ( q9u16 , d25u8 , d2u8 ) ; q10u16 = vmull_u8 ( d26u8 , d3u8 ) ; q11u16 = vmull_u8 ( d27u8 , d3u8 ) ; q12u16 = vmull_u8 ( d28u8 , d3u8 ) ; q15u16 = vmull_u8 ( d29u8 , d3u8 ) ; q6s16 = vreinterpretq_s16_u16 ( q6u16 ) ; q7s16 = vreinterpretq_s16_u16 ( q7u16 ) ; q8s16 = vreinterpretq_s16_u16 ( q8u16 ) ; q9s16 = vreinterpretq_s16_u16 ( q9u16 ) ; q10s16 = vreinterpretq_s16_u16 ( q10u16 ) ; q11s16 = vreinterpretq_s16_u16 ( q11u16 ) ; q12s16 = vreinterpretq_s16_u16 ( q12u16 ) ; q15s16 = vreinterpretq_s16_u16 ( q15u16 ) ; q6s16 = vqaddq_s16 ( q6s16 , q10s16 ) ; q8s16 = vqaddq_s16 ( q8s16 , q11s16 ) ; q7s16 = vqaddq_s16 ( q7s16 , q12s16 ) ; q9s16 = vqaddq_s16 ( q9s16 , q15s16 ) ; d6u8 = vqrshrun_n_s16 ( q6s16 , 7 ) ; d7u8 = vqrshrun_n_s16 ( q7s16 , 7 ) ; d8u8 = vqrshrun_n_s16 ( q8s16 , 7 ) ; d9u8 = vqrshrun_n_s16 ( q9s16 , 7 ) ; q3u8 = vcombine_u8 ( d6u8 , d7u8 ) ; q4u8 = vcombine_u8 ( d8u8 , d9u8 ) ; vst1q_u8 ( dst , q3u8 ) ; dst += dst_pitch ; vst1q_u8 ( dst , q4u8 ) ; dst += dst_pitch ; } return ; } src = src_ptr - 2 - src_pixels_per_line * 2 ; tmpp = tmp ; for ( i = 0 ; i < 7 ; i ++ ) { d6u8 = vld1_u8 ( src ) ; d7u8 = vld1_u8 ( src + 8 ) ; d8u8 = vld1_u8 ( src + 16 ) ; src += src_pixels_per_line ; d9u8 = vld1_u8 ( src ) ; d10u8 = vld1_u8 ( src + 8 ) ; d11u8 = vld1_u8 ( src + 16 ) ; src += src_pixels_per_line ; d12u8 = vld1_u8 ( src ) ; d13u8 = vld1_u8 ( src + 8 ) ; d14u8 = vld1_u8 ( src + 16 ) ; src += src_pixels_per_line ; __builtin_prefetch ( src ) ; __builtin_prefetch ( src + src_pixels_per_line ) ; __builtin_prefetch ( src + src_pixels_per_line * 2 ) ; q8u16 = vmull_u8 ( d6u8 , d0u8 ) ; q9u16 = vmull_u8 ( d7u8 , d0u8 ) ; q10u16 = vmull_u8 ( d9u8 , d0u8 ) ; q11u16 = vmull_u8 ( d10u8 , d0u8 ) ; q12u16 = vmull_u8 ( d12u8 , d0u8 ) ; q13u16 = vmull_u8 ( d13u8 , d0u8 ) ; d28u8 = vext_u8 ( d6u8 , d7u8 , 1 ) ; d29u8 = vext_u8 ( d9u8 , d10u8 , 1 ) ; d30u8 = vext_u8 ( d12u8 , d13u8 , 1 ) ; q8u16 = vmlsl_u8 ( q8u16 , d28u8 , d1u8 ) ; q10u16 = vmlsl_u8 ( q10u16 , d29u8 , d1u8 ) ; q12u16 = vmlsl_u8 ( q12u16 , d30u8 , d1u8 ) ; d28u8 = vext_u8 ( d7u8 , d8u8 , 1 ) ; d29u8 = vext_u8 ( d10u8 , d11u8 , 1 ) ; d30u8 = vext_u8 ( d13u8 , d14u8 , 1 ) ; q9u16 = vmlsl_u8 ( q9u16 , d28u8 , d1u8 ) ; q11u16 = vmlsl_u8 ( q11u16 , d29u8 , d1u8 ) ; q13u16 = vmlsl_u8 ( q13u16 , d30u8 , d1u8 ) ; d28u8 = vext_u8 ( d6u8 , d7u8 , 4 ) ; d29u8 = vext_u8 ( d9u8 , d10u8 , 4 ) ; d30u8 = vext_u8 ( d12u8 , d13u8 , 4 ) ; q8u16 = vmlsl_u8 ( q8u16 , d28u8 , d4u8 ) ; q10u16 = vmlsl_u8 ( q10u16 , d29u8 , d4u8 ) ; q12u16 = vmlsl_u8 ( q12u16 , d30u8 , d4u8 ) ; d28u8 = vext_u8 ( d7u8 , d8u8 , 4 ) ; d29u8 = vext_u8 ( d10u8 , d11u8 , 4 ) ; d30u8 = vext_u8 ( d13u8 , d14u8 , 4 ) ; q9u16 = vmlsl_u8 ( q9u16 , d28u8 , d4u8 ) ; q11u16 = vmlsl_u8 ( q11u16 , d29u8 , d4u8 ) ; q13u16 = vmlsl_u8 ( q13u16 , d30u8 , d4u8 ) ; d28u8 = vext_u8 ( d6u8 , d7u8 , 5 ) ; d29u8 = vext_u8 ( d9u8 , d10u8 , 5 ) ; d30u8 = vext_u8 ( d12u8 , d13u8 , 5 ) ; q8u16 = vmlal_u8 ( q8u16 , d28u8 , d5u8 ) ; q10u16 = vmlal_u8 ( q10u16 , d29u8 , d5u8 ) ; q12u16 = vmlal_u8 ( q12u16 , d30u8 , d5u8 ) ; d28u8 = vext_u8 ( d7u8 , d8u8 , 5 ) ; d29u8 = vext_u8 ( d10u8 , d11u8 , 5 ) ; d30u8 = vext_u8 ( d13u8 , d14u8 , 5 ) ; q9u16 = vmlal_u8 ( q9u16 , d28u8 , d5u8 ) ; q11u16 = vmlal_u8 ( q11u16 , d29u8 , d5u8 ) ; q13u16 = vmlal_u8 ( q13u16 , d30u8 , d5u8 ) ; d28u8 = vext_u8 ( d6u8 , d7u8 , 2 ) ; d29u8 = vext_u8 ( d9u8 , d10u8 , 2 ) ; d30u8 = vext_u8 ( d12u8 , d13u8 , 2 ) ; q8u16 = vmlal_u8 ( q8u16 , d28u8 , d2u8 ) ; q10u16 = vmlal_u8 ( q10u16 , d29u8 , d2u8 ) ; q12u16 = vmlal_u8 ( q12u16 , d30u8 , d2u8 ) ; d28u8 = vext_u8 ( d7u8 , d8u8 , 2 ) ; d29u8 = vext_u8 ( d10u8 , d11u8 , 2 ) ; d30u8 = vext_u8 ( d13u8 , d14u8 , 2 ) ; q9u16 = vmlal_u8 ( q9u16 , d28u8 , d2u8 ) ; q11u16 = vmlal_u8 ( q11u16 , d29u8 , d2u8 ) ; q13u16 = vmlal_u8 ( q13u16 , d30u8 , d2u8 ) ; d28u8 = vext_u8 ( d6u8 , d7u8 , 3 ) ; d29u8 = vext_u8 ( d9u8 , d10u8 , 3 ) ; d30u8 = vext_u8 ( d12u8 , d13u8 , 3 ) ; d15u8 = vext_u8 ( d7u8 , d8u8 , 3 ) ; d31u8 = vext_u8 ( d10u8 , d11u8 , 3 ) ; d6u8 = vext_u8 ( d13u8 , d14u8 , 3 ) ; q4u16 = vmull_u8 ( d28u8 , d3u8 ) ; q5u16 = vmull_u8 ( d29u8 , d3u8 ) ; q6u16 = vmull_u8 ( d30u8 , d3u8 ) ; q4s16 = vreinterpretq_s16_u16 ( q4u16 ) ; q5s16 = vreinterpretq_s16_u16 ( q5u16 ) ; q6s16 = vreinterpretq_s16_u16 ( q6u16 ) ; q8s16 = vreinterpretq_s16_u16 ( q8u16 ) ; q10s16 = vreinterpretq_s16_u16 ( q10u16 ) ; q12s16 = vreinterpretq_s16_u16 ( q12u16 ) ; q8s16 = vqaddq_s16 ( q8s16 , q4s16 ) ; q10s16 = vqaddq_s16 ( q10s16 , q5s16 ) ; q12s16 = vqaddq_s16 ( q12s16 , q6s16 ) ; q6u16 = vmull_u8 ( d15u8 , d3u8 ) ; q7u16 = vmull_u8 ( d31u8 , d3u8 ) ; q3u16 = vmull_u8 ( d6u8 , d3u8 ) ; q3s16 = vreinterpretq_s16_u16 ( q3u16 ) ; q6s16 = vreinterpretq_s16_u16 ( q6u16 ) ; q7s16 = vreinterpretq_s16_u16 ( q7u16 ) ; q9s16 = vreinterpretq_s16_u16 ( q9u16 ) ; q11s16 = vreinterpretq_s16_u16 ( q11u16 ) ; q13s16 = vreinterpretq_s16_u16 ( q13u16 ) ; q9s16 = vqaddq_s16 ( q9s16 , q6s16 ) ; q11s16 = vqaddq_s16 ( q11s16 , q7s16 ) ; q13s16 = vqaddq_s16 ( q13s16 , q3s16 ) ; d6u8 = vqrshrun_n_s16 ( q8s16 , 7 ) ; d7u8 = vqrshrun_n_s16 ( q9s16 , 7 ) ; d8u8 = vqrshrun_n_s16 ( q10s16 , 7 ) ; d9u8 = vqrshrun_n_s16 ( q11s16 , 7 ) ; d10u8 = vqrshrun_n_s16 ( q12s16 , 7 ) ; d11u8 = vqrshrun_n_s16 ( q13s16 , 7 ) ; vst1_u8 ( tmpp , d6u8 ) ; tmpp += 8 ; vst1_u8 ( tmpp , d7u8 ) ; tmpp += 8 ; vst1_u8 ( tmpp , d8u8 ) ; tmpp += 8 ; vst1_u8 ( tmpp , d9u8 ) ; tmpp += 8 ; vst1_u8 ( tmpp , d10u8 ) ; tmpp += 8 ; vst1_u8 ( tmpp , d11u8 ) ; tmpp += 8 ; } dtmps8 = vld1_s8 ( vp8_sub_pel_filters [ yoffset ] ) ; d0s8 = vdup_lane_s8 ( dtmps8 , 0 ) ; d1s8 = vdup_lane_s8 ( dtmps8 , 1 ) ; d2s8 = vdup_lane_s8 ( dtmps8 , 2 ) ; d3s8 = vdup_lane_s8 ( dtmps8 , 3 ) ; d4s8 = vdup_lane_s8 ( dtmps8 , 4 ) ; d5s8 = vdup_lane_s8 ( dtmps8 , 5 ) ; d0u8 = vreinterpret_u8_s8 ( vabs_s8 ( d0s8 ) ) ; d1u8 = vreinterpret_u8_s8 ( vabs_s8 ( d1s8 ) ) ; d2u8 = vreinterpret_u8_s8 ( vabs_s8 ( d2s8 ) ) ; d3u8 = vreinterpret_u8_s8 ( vabs_s8 ( d3s8 ) ) ; d4u8 = vreinterpret_u8_s8 ( vabs_s8 ( d4s8 ) ) ; d5u8 = vreinterpret_u8_s8 ( vabs_s8 ( d5s8 ) ) ; for ( i = 0 ; i < 2 ; i ++ ) { dst = dst_ptr + 8 * i ; tmpp = tmp + 8 * i ; d18u8 = vld1_u8 ( tmpp ) ; tmpp += 16 ; d19u8 = vld1_u8 ( tmpp ) ; tmpp += 16 ; d20u8 = vld1_u8 ( tmpp ) ; tmpp += 16 ; d21u8 = vld1_u8 ( tmpp ) ; tmpp += 16 ; d22u8 = vld1_u8 ( tmpp ) ; tmpp += 16 ; for ( j = 0 ; j < 4 ; j ++ ) { d23u8 = vld1_u8 ( tmpp ) ; tmpp += 16 ; d24u8 = vld1_u8 ( tmpp ) ; tmpp += 16 ; d25u8 = vld1_u8 ( tmpp ) ; tmpp += 16 ; d26u8 = vld1_u8 ( tmpp ) ; tmpp += 16 ; q3u16 = vmull_u8 ( d18u8 , d0u8 ) ; q4u16 = vmull_u8 ( d19u8 , d0u8 ) ; q5u16 = vmull_u8 ( d20u8 , d0u8 ) ; q6u16 = vmull_u8 ( d21u8 , d0u8 ) ; q3u16 = vmlsl_u8 ( q3u16 , d19u8 , d1u8 ) ; q4u16 = vmlsl_u8 ( q4u16 , d20u8 , d1u8 ) ; q5u16 = vmlsl_u8 ( q5u16 , d21u8 , d1u8 ) ; q6u16 = vmlsl_u8 ( q6u16 , d22u8 , d1u8 ) ; q3u16 = vmlsl_u8 ( q3u16 , d22u8 , d4u8 ) ; q4u16 = vmlsl_u8 ( q4u16 , d23u8 , d4u8 ) ; q5u16 = vmlsl_u8 ( q5u16 , d24u8 , d4u8 ) ; q6u16 = vmlsl_u8 ( q6u16 , d25u8 , d4u8 ) ; q3u16 = vmlal_u8 ( q3u16 , d20u8 , d2u8 ) ; q4u16 = vmlal_u8 ( q4u16 , d21u8 , d2u8 ) ; q5u16 = vmlal_u8 ( q5u16 , d22u8 , d2u8 ) ; q6u16 = vmlal_u8 ( q6u16 , d23u8 , d2u8 ) ; q3u16 = vmlal_u8 ( q3u16 , d23u8 , d5u8 ) ; q4u16 = vmlal_u8 ( q4u16 , d24u8 , d5u8 ) ; q5u16 = vmlal_u8 ( q5u16 , d25u8 , d5u8 ) ; q6u16 = vmlal_u8 ( q6u16 , d26u8 , d5u8 ) ; q7u16 = vmull_u8 ( d21u8 , d3u8 ) ; q8u16 = vmull_u8 ( d22u8 , d3u8 ) ; q9u16 = vmull_u8 ( d23u8 , d3u8 ) ; q10u16 = vmull_u8 ( d24u8 , d3u8 ) ; q3s16 = vreinterpretq_s16_u16 ( q3u16 ) ; q4s16 = vreinterpretq_s16_u16 ( q4u16 ) ; q5s16 = vreinterpretq_s16_u16 ( q5u16 ) ; q6s16 = vreinterpretq_s16_u16 ( q6u16 ) ; q7s16 = vreinterpretq_s16_u16 ( q7u16 ) ; q8s16 = vreinterpretq_s16_u16 ( q8u16 ) ; q9s16 = vreinterpretq_s16_u16 ( q9u16 ) ; q10s16 = vreinterpretq_s16_u16 ( q10u16 ) ; q7s16 = vqaddq_s16 ( q7s16 , q3s16 ) ; q8s16 = vqaddq_s16 ( q8s16 , q4s16 ) ; q9s16 = vqaddq_s16 ( q9s16 , q5s16 ) ; q10s16 = vqaddq_s16 ( q10s16 , q6s16 ) ; d6u8 = vqrshrun_n_s16 ( q7s16 , 7 ) ; d7u8 = vqrshrun_n_s16 ( q8s16 , 7 ) ; d8u8 = vqrshrun_n_s16 ( q9s16 , 7 ) ; d9u8 = vqrshrun_n_s16 ( q10s16 , 7 ) ; d18u8 = d22u8 ; d19u8 = d23u8 ; d20u8 = d24u8 ; d21u8 = d25u8 ; d22u8 = d26u8 ; vst1_u8 ( dst , d6u8 ) ; dst += dst_pitch ; vst1_u8 ( dst , d7u8 ) ; dst += dst_pitch ; vst1_u8 ( dst , d8u8 ) ; dst += dst_pitch ; vst1_u8 ( dst , d9u8 ) ; dst += dst_pitch ; } } return ; }

debian

op_array_table * get_local_op_array ( const gs_memory_t * mem ) { gs_main_instance * minst = get_minst_from_memory ( mem ) ; return & minst -> i_ctx_p -> op_array_table_local ; }

debian

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 . f . 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 . f . 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 ; } }

debian

int qemuMonitorTextOpenGraphics ( qemuMonitorPtr mon , const char * protocol , const char * fdname , bool skipauth ) { char * cmd = NULL ; char * reply = NULL ; int ret = - 1 ; if ( virAsprintf ( & cmd , "add_client %s %s %d" , protocol , fdname , skipauth ? 0 : 1 ) < 0 ) { virReportOOMError ( ) ; goto cleanup ; } if ( qemuMonitorHMPCommand ( mon , cmd , & reply ) < 0 ) { qemuReportError ( VIR_ERR_OPERATION_FAILED , "%s" , _ ( "adding graphics client failed" ) ) ; goto cleanup ; } if ( STRNEQ ( reply , "" ) ) goto cleanup ; ret = 0 ; cleanup : VIR_FREE ( reply ) ; VIR_FREE ( cmd ) ; return ret ; }

debian

static int init_context_frame ( MpegEncContext * s ) { int y_size , c_size , yc_size , i , mb_array_size , mv_table_size , x , y ; s -> mb_width = ( s -> width + 15 ) / 16 ; s -> mb_stride = s -> mb_width + 1 ; s -> b8_stride = s -> mb_width * 2 + 1 ; s -> b4_stride = s -> mb_width * 4 + 1 ; mb_array_size = s -> mb_height * s -> mb_stride ; mv_table_size = ( s -> mb_height + 2 ) * s -> mb_stride + 1 ; s -> h_edge_pos = s -> mb_width * 16 ; s -> v_edge_pos = s -> mb_height * 16 ; s -> mb_num = s -> mb_width * s -> mb_height ; s -> block_wrap [ 0 ] = s -> block_wrap [ 1 ] = s -> block_wrap [ 2 ] = s -> block_wrap [ 3 ] = s -> b8_stride ; s -> block_wrap [ 4 ] = s -> block_wrap [ 5 ] = s -> mb_stride ; y_size = s -> b8_stride * ( 2 * s -> mb_height + 1 ) ; c_size = s -> mb_stride * ( s -> mb_height + 1 ) ; yc_size = y_size + 2 * c_size ; FF_ALLOCZ_OR_GOTO ( s -> avctx , s -> mb_index2xy , ( s -> mb_num + 1 ) * sizeof ( int ) , fail ) ; for ( y = 0 ; y < s -> mb_height ; y ++ ) for ( x = 0 ; x < s -> mb_width ; x ++ ) s -> mb_index2xy [ x + y * s -> mb_width ] = x + y * s -> mb_stride ; s -> mb_index2xy [ s -> mb_height * s -> mb_width ] = ( s -> mb_height - 1 ) * s -> mb_stride + s -> mb_width ; if ( s -> encoding ) { FF_ALLOCZ_OR_GOTO ( s -> avctx , s -> p_mv_table_base , mv_table_size * 2 * sizeof ( int16_t ) , fail ) ; FF_ALLOCZ_OR_GOTO ( s -> avctx , s -> b_forw_mv_table_base , mv_table_size * 2 * sizeof ( int16_t ) , fail ) ; FF_ALLOCZ_OR_GOTO ( s -> avctx , s -> b_back_mv_table_base , mv_table_size * 2 * sizeof ( int16_t ) , fail ) ; FF_ALLOCZ_OR_GOTO ( s -> avctx , s -> b_bidir_forw_mv_table_base , mv_table_size * 2 * sizeof ( int16_t ) , fail ) ; FF_ALLOCZ_OR_GOTO ( s -> avctx , s -> b_bidir_back_mv_table_base , mv_table_size * 2 * sizeof ( int16_t ) , fail ) ; FF_ALLOCZ_OR_GOTO ( s -> avctx , s -> b_direct_mv_table_base , mv_table_size * 2 * sizeof ( int16_t ) , fail ) ; s -> p_mv_table = s -> p_mv_table_base + s -> mb_stride + 1 ; s -> b_forw_mv_table = s -> b_forw_mv_table_base + s -> mb_stride + 1 ; s -> b_back_mv_table = s -> b_back_mv_table_base + s -> mb_stride + 1 ; s -> b_bidir_forw_mv_table = s -> b_bidir_forw_mv_table_base + s -> mb_stride + 1 ; s -> b_bidir_back_mv_table = s -> b_bidir_back_mv_table_base + s -> mb_stride + 1 ; s -> b_direct_mv_table = s -> b_direct_mv_table_base + s -> mb_stride + 1 ; FF_ALLOCZ_OR_GOTO ( s -> avctx , s -> mb_type , mb_array_size * sizeof ( uint16_t ) , fail ) ; FF_ALLOCZ_OR_GOTO ( s -> avctx , s -> lambda_table , mb_array_size * sizeof ( int ) , fail ) ; FF_ALLOC_OR_GOTO ( s -> avctx , s -> cplx_tab , mb_array_size * sizeof ( float ) , fail ) ; FF_ALLOC_OR_GOTO ( s -> avctx , s -> bits_tab , mb_array_size * sizeof ( float ) , fail ) ; } if ( s -> codec_id == AV_CODEC_ID_MPEG4 || ( s -> flags & CODEC_FLAG_INTERLACED_ME ) ) { for ( i = 0 ; i < 2 ; i ++ ) { int j , k ; for ( j = 0 ; j < 2 ; j ++ ) { for ( k = 0 ; k < 2 ; k ++ ) { FF_ALLOCZ_OR_GOTO ( s -> avctx , s -> b_field_mv_table_base [ i ] [ j ] [ k ] , mv_table_size * 2 * sizeof ( int16_t ) , fail ) ; s -> b_field_mv_table [ i ] [ j ] [ k ] = s -> b_field_mv_table_base [ i ] [ j ] [ k ] + s -> mb_stride + 1 ; } FF_ALLOCZ_OR_GOTO ( s -> avctx , s -> b_field_select_table [ i ] [ j ] , mb_array_size * 2 * sizeof ( uint8_t ) , fail ) ; FF_ALLOCZ_OR_GOTO ( s -> avctx , s -> p_field_mv_table_base [ i ] [ j ] , mv_table_size * 2 * sizeof ( int16_t ) , fail ) ; s -> p_field_mv_table [ i ] [ j ] = s -> p_field_mv_table_base [ i ] [ j ] + s -> mb_stride + 1 ; } FF_ALLOCZ_OR_GOTO ( s -> avctx , s -> p_field_select_table [ i ] , mb_array_size * 2 * sizeof ( uint8_t ) , fail ) ; } } if ( s -> out_format == FMT_H263 ) { FF_ALLOCZ_OR_GOTO ( s -> avctx , s -> coded_block_base , y_size , fail ) ; s -> coded_block = s -> coded_block_base + s -> b8_stride + 1 ; FF_ALLOCZ_OR_GOTO ( s -> avctx , s -> cbp_table , mb_array_size * sizeof ( uint8_t ) , fail ) ; FF_ALLOCZ_OR_GOTO ( s -> avctx , s -> pred_dir_table , mb_array_size * sizeof ( uint8_t ) , fail ) ; } if ( s -> h263_pred || s -> h263_plus || ! s -> encoding ) { FF_ALLOCZ_OR_GOTO ( s -> avctx , s -> dc_val_base , yc_size * sizeof ( int16_t ) , fail ) ; s -> dc_val [ 0 ] = s -> dc_val_base + s -> b8_stride + 1 ; s -> dc_val [ 1 ] = s -> dc_val_base + y_size + s -> mb_stride + 1 ; s -> dc_val [ 2 ] = s -> dc_val [ 1 ] + c_size ; for ( i = 0 ; i < yc_size ; i ++ ) s -> dc_val_base [ i ] = 1024 ; } FF_ALLOCZ_OR_GOTO ( s -> avctx , s -> mbintra_table , mb_array_size , fail ) ; memset ( s -> mbintra_table , 1 , mb_array_size ) ; FF_ALLOCZ_OR_GOTO ( s -> avctx , s -> mbskip_table , mb_array_size + 2 , fail ) ; if ( ( s -> avctx -> debug & ( FF_DEBUG_VIS_QP | FF_DEBUG_VIS_MB_TYPE ) ) || s -> avctx -> debug_mv ) { s -> visualization_buffer [ 0 ] = av_malloc ( ( s -> mb_width * 16 + 2 * EDGE_WIDTH ) * s -> mb_height * 16 + 2 * EDGE_WIDTH ) ; s -> visualization_buffer [ 1 ] = av_malloc ( ( s -> mb_width * 16 + 2 * EDGE_WIDTH ) * s -> mb_height * 16 + 2 * EDGE_WIDTH ) ; s -> visualization_buffer [ 2 ] = av_malloc ( ( s -> mb_width * 16 + 2 * EDGE_WIDTH ) * s -> mb_height * 16 + 2 * EDGE_WIDTH ) ; } return init_er ( s ) ; fail : return AVERROR ( ENOMEM ) ; }

debian

static guint32 lbmpdm_fetch_uint32_encoded ( tvbuff_t * tvb , int offset , int encoding ) { guint32 value = 0 ; if ( encoding == ENC_BIG_ENDIAN ) { value = tvb_get_ntohl ( tvb , offset ) ; } else { value = tvb_get_letohl ( tvb , offset ) ; } return ( value ) ; }

debian

static void dissect_zcl_pwr_prof_pwrprofreq ( tvbuff_t * tvb , proto_tree * tree , guint * offset ) { proto_tree_add_item ( tree , hf_zbee_zcl_pwr_prof_pwr_prof_id , tvb , * offset , 1 , ENC_NA ) ; * offset += 1 ; }

debian

static void vapic_register ( void ) { type_register_static ( & vapic_type ) ; }

debian

static int kvm_put_sregs ( X86CPU * cpu ) { CPUX86State * env = & cpu -> env ; struct kvm_sregs sregs ; memset ( sregs . interrupt_bitmap , 0 , sizeof ( sregs . interrupt_bitmap ) ) ; if ( env -> interrupt_injected >= 0 ) { sregs . interrupt_bitmap [ env -> interrupt_injected / 64 ] |= ( uint64_t ) 1 << ( env -> interrupt_injected % 64 ) ; } if ( ( env -> eflags & VM_MASK ) ) { set_v8086_seg ( & sregs . cs , & env -> segs [ R_CS ] ) ; set_v8086_seg ( & sregs . ds , & env -> segs [ R_DS ] ) ; set_v8086_seg ( & sregs . es , & env -> segs [ R_ES ] ) ; set_v8086_seg ( & sregs . fs , & env -> segs [ R_FS ] ) ; set_v8086_seg ( & sregs . gs , & env -> segs [ R_GS ] ) ; set_v8086_seg ( & sregs . ss , & env -> segs [ R_SS ] ) ; } else { set_seg ( & sregs . cs , & env -> segs [ R_CS ] ) ; set_seg ( & sregs . ds , & env -> segs [ R_DS ] ) ; set_seg ( & sregs . es , & env -> segs [ R_ES ] ) ; set_seg ( & sregs . fs , & env -> segs [ R_FS ] ) ; set_seg ( & sregs . gs , & env -> segs [ R_GS ] ) ; set_seg ( & sregs . ss , & env -> segs [ R_SS ] ) ; } set_seg ( & sregs . tr , & env -> tr ) ; set_seg ( & sregs . ldt , & env -> ldt ) ; sregs . idt . limit = env -> idt . limit ; sregs . idt . base = env -> idt . base ; memset ( sregs . idt . padding , 0 , sizeof sregs . idt . padding ) ; sregs . gdt . limit = env -> gdt . limit ; sregs . gdt . base = env -> gdt . base ; memset ( sregs . gdt . padding , 0 , sizeof sregs . gdt . padding ) ; sregs . cr0 = env -> cr [ 0 ] ; sregs . cr2 = env -> cr [ 2 ] ; sregs . cr3 = env -> cr [ 3 ] ; sregs . cr4 = env -> cr [ 4 ] ; sregs . cr8 = cpu_get_apic_tpr ( cpu -> apic_state ) ; sregs . apic_base = cpu_get_apic_base ( cpu -> apic_state ) ; sregs . efer = env -> efer ; return kvm_vcpu_ioctl ( CPU ( cpu ) , KVM_SET_SREGS , & sregs ) ; }

debian

void proto_register_gsm_a_common ( void ) { guint i ; guint last_offset ; static hf_register_info hf [ ] = { { & hf_gsm_a_common_elem_id , { "Element ID" , "gsm_a.common.elem_id" , FT_UINT8 , BASE_HEX , NULL , 0 , NULL , HFILL } } , { & hf_gsm_a_common_elem_id_f0 , { "Element ID" , "gsm_a.common.elem_id" , FT_UINT8 , BASE_HEX , NULL , 0xF0 , NULL , HFILL } } , { & hf_gsm_a_l_ext , { "ext" , "gsm_a.l_ext" , FT_UINT8 , BASE_DEC , NULL , 0x80 , NULL , HFILL } } , { & hf_gsm_a_tmsi , { "TMSI/P-TMSI" , "gsm_a.tmsi" , FT_UINT32 , BASE_HEX , 0 , 0x0 , NULL , HFILL } } , { & hf_gsm_a_imei , { "IMEI" , "gsm_a.imei" , FT_STRING , BASE_NONE , 0 , 0 , NULL , HFILL } } , { & hf_gsm_a_imeisv , { "IMEISV" , "gsm_a.imeisv" , FT_STRING , BASE_NONE , 0 , 0 , NULL , HFILL } } , { & hf_gsm_a_MSC_rev , { "Revision Level" , "gsm_a.MSC_rev" , FT_UINT8 , BASE_DEC , VALS ( gsm_a_msc_rev_vals ) , 0x60 , NULL , HFILL } } , { & hf_gsm_a_ES_IND , { "ES IND" , "gsm_a.ES_IND" , FT_BOOLEAN , 8 , TFS ( & ES_IND_vals ) , 0x10 , NULL , HFILL } } , { & hf_gsm_a_A5_1_algorithm_sup , { "A5/1 algorithm supported" , "gsm_a.A5_1_algorithm_sup" , FT_BOOLEAN , 8 , TFS ( & A5_1_algorithm_sup_vals ) , 0x08 , NULL , HFILL } } , { & hf_gsm_a_RF_power_capability , { "RF Power Capability" , "gsm_a.RF_power_capability" , FT_UINT8 , BASE_DEC , VALS ( RF_power_capability_vals ) , 0x07 , NULL , HFILL } } , { & hf_gsm_a_ps_sup_cap , { "PS capability (pseudo-synchronization capability)" , "gsm_a.ps_sup_cap" , FT_BOOLEAN , 8 , TFS ( & ps_sup_cap_vals ) , 0x40 , NULL , HFILL } } , { & hf_gsm_a_SS_screening_indicator , { "SS Screening Indicator" , "gsm_a.SS_screening_indicator" , FT_UINT8 , BASE_DEC , VALS ( SS_screening_indicator_vals ) , 0x30 , NULL , HFILL } } , { & hf_gsm_a_SM_capability , { "SM capability (MT SMS pt to pt capability)" , "gsm_a.SM_cap" , FT_BOOLEAN , 8 , TFS ( & SM_capability_vals ) , 0x08 , NULL , HFILL } } , { & hf_gsm_a_VBS_notification_rec , { "VBS notification reception" , "gsm_a.VBS_notification_rec" , FT_BOOLEAN , 8 , TFS ( & VBS_notification_rec_vals ) , 0x04 , NULL , HFILL } } , { & hf_gsm_a_VGCS_notification_rec , { "VGCS notification reception" , "gsm_a.VGCS_notification_rec" , FT_BOOLEAN , 8 , TFS ( & VGCS_notification_rec_vals ) , 0x02 , NULL , HFILL } } , { & hf_gsm_a_FC_frequency_cap , { "FC Frequency Capability" , "gsm_a.FC_frequency_cap" , FT_BOOLEAN , 8 , TFS ( & FC_frequency_cap_vals ) , 0x01 , NULL , HFILL } } , { & hf_gsm_a_CM3 , { "CM3" , "gsm_a.CM3" , FT_BOOLEAN , 8 , TFS ( & CM3_vals ) , 0x80 , NULL , HFILL } } , { & hf_gsm_a_LCS_VA_cap , { "LCS VA capability (LCS value added location request notification capability)" , "gsm_a.LCS_VA_cap" , FT_BOOLEAN , 8 , TFS ( & LCS_VA_cap_vals ) , 0x20 , NULL , HFILL } } , { & hf_gsm_a_UCS2_treatment , { "UCS2 treatment" , "gsm_a.UCS2_treatment" , FT_BOOLEAN , 8 , TFS ( & UCS2_treatment_vals ) , 0x10 , NULL , HFILL } } , { & hf_gsm_a_SoLSA , { "SoLSA" , "gsm_a.SoLSA" , FT_BOOLEAN , 8 , TFS ( & SoLSA_vals ) , 0x08 , NULL , HFILL } } , { & hf_gsm_a_CMSP , { "CMSP: CM Service Prompt" , "gsm_a.CMSP" , FT_BOOLEAN , 8 , TFS ( & CMSP_vals ) , 0x04 , NULL , HFILL } } , { & hf_gsm_a_A5_7_algorithm_sup , { "A5/7 algorithm supported" , "gsm_a.A5_7_algorithm_sup" , FT_BOOLEAN , BASE_NONE , TFS ( & A5_7_algorithm_sup_vals ) , 0x0 , NULL , HFILL } } , { & hf_gsm_a_A5_6_algorithm_sup , { "A5/6 algorithm supported" , "gsm_a.A5_6_algorithm_sup" , FT_BOOLEAN , BASE_NONE , TFS ( & A5_6_algorithm_sup_vals ) , 0x0 , NULL , HFILL } } , { & hf_gsm_a_A5_5_algorithm_sup , { "A5/5 algorithm supported" , "gsm_a.A5_5_algorithm_sup" , FT_BOOLEAN , BASE_NONE , TFS ( & A5_5_algorithm_sup_vals ) , 0x0 , NULL , HFILL } } , { & hf_gsm_a_A5_4_algorithm_sup , { "A5/4 algorithm supported" , "gsm_a.A5_4_algorithm_sup" , FT_BOOLEAN , BASE_NONE , TFS ( & A5_4_algorithm_sup_vals ) , 0x0 , NULL , HFILL } } , { & hf_gsm_a_A5_3_algorithm_sup , { "A5/3 algorithm supported" , "gsm_a.A5_3_algorithm_sup" , FT_BOOLEAN , 8 , TFS ( & A5_3_algorithm_sup_vals ) , 0x02 , NULL , HFILL } } , { & hf_gsm_a_A5_2_algorithm_sup , { "A5/2 algorithm supported" , "gsm_a.A5_2_algorithm_sup" , FT_BOOLEAN , 8 , TFS ( & A5_2_algorithm_sup_vals ) , 0x01 , NULL , HFILL } } , { & hf_gsm_a_mobile_identity_type , { "Mobile Identity Type" , "gsm_a.ie.mobileid.type" , FT_UINT8 , BASE_DEC , VALS ( mobile_identity_type_vals ) , 0x07 , NULL , HFILL } } , { & hf_gsm_a_id_dig_1 , { "Identity Digit 1" , "gsm_a.id_dig_1" , FT_UINT8 , BASE_DEC , NULL , 0xf0 , NULL , HFILL } } , { & hf_gsm_a_odd_even_ind , { "Odd/even indication" , "gsm_a.oddevenind" , FT_BOOLEAN , 8 , TFS ( & oddevenind_vals ) , 0x08 , NULL , HFILL } } , { & hf_gsm_a_unused , { "Unused" , "gsm_a.unused" , FT_UINT8 , BASE_HEX , NULL , 0xf0 , NULL , HFILL } } , { & hf_gsm_a_tmgi_mcc_mnc_ind , { "MCC/MNC indication" , "gsm_a.tmgi_mcc_mnc_ind" , FT_BOOLEAN , 8 , TFS ( & gsm_a_present_vals ) , 0x10 , NULL , HFILL } } , { & hf_gsm_a_mbs_ses_id_ind , { "MBMS Session Identity indication" , "gsm_a.mbs_session_id_ind" , FT_BOOLEAN , 8 , TFS ( & gsm_a_present_vals ) , 0x20 , NULL , HFILL } } , { & hf_gsm_a_mbs_service_id , { "MBMS Service ID" , "gsm_a.mbs_service_id" , FT_UINT24 , BASE_HEX , NULL , 0x0 , NULL , HFILL } } , { & hf_gsm_a_mbs_session_id , { "MBMS Session ID" , "gsm_a.mbs_session_id" , FT_UINT8 , BASE_HEX , NULL , 0x0 , NULL , HFILL } } , { & hf_gsm_a_length , { "Length" , "gsm_a.len" , FT_UINT16 , BASE_DEC , NULL , 0 , NULL , HFILL } } , { & hf_gsm_a_element_value , { "Element Value" , "gsm_a.element_value" , FT_BYTES , BASE_NONE , NULL , 0 , NULL , HFILL } } , { & hf_gsm_a_extension , { "Extension" , "gsm_a.extension" , FT_BOOLEAN , 8 , TFS ( & gsm_a_extension_value ) , 0x80 , NULL , HFILL } } , { & hf_gsm_a_L3_protocol_discriminator , { "Protocol discriminator" , "gsm_a.L3_protocol_discriminator" , FT_UINT8 , BASE_HEX , VALS ( protocol_discriminator_vals ) , 0x0f , NULL , HFILL } } , { & hf_gsm_a_call_prio , { "Call priority" , "gsm_a.call_prio" , FT_UINT8 , BASE_DEC , VALS ( gsm_a_call_prio_vals ) , 0x00 , NULL , HFILL } } , { & hf_gsm_a_type_of_ciph_alg , { "Call priority" , "gsm_a.call_prio" , FT_UINT8 , BASE_DEC , VALS ( gsm_a_gm_type_of_ciph_alg_vals ) , 0x07 , NULL , HFILL } } , { & hf_gsm_a_att , { "ATT" , "gsm_a.att" , FT_BOOLEAN , 8 , TFS ( & gsm_a_att_value ) , 0x01 , "ttach-detach allowed" , HFILL } } , { & hf_gsm_a_nmo_1 , { "NMO I" , "gsm_a.nmo_1" , FT_BOOLEAN , 8 , TFS ( & gsm_a_nmo_1_value ) , 0x02 , "Network Mode of Operation I" , HFILL } } , { & hf_gsm_a_nmo , { "NMO" , "gsm_a.nmo" , FT_BOOLEAN , 8 , TFS ( & gsm_a_nmo_value ) , 0x01 , "Network Mode of Operation" , HFILL } } , { & hf_gsm_a_old_xid , { "Old XID" , "gsm_a.old_xid" , FT_UINT8 , BASE_DEC , VALS ( gsm_a_pld_xid_vals ) , 0x10 , NULL , HFILL } } , { & hf_gsm_a_iov_ui , { "IOV-UI" , "gsm_a.iov_ui" , FT_UINT32 , BASE_HEX , NULL , 0x0 , NULL , HFILL } } , { & hf_gsm_a_ext_periodic_timers , { "Extended periodic timers" , "gsm_a.ext_periodic_timers" , FT_BOOLEAN , BASE_NONE , TFS ( & gsm_a_ext_periodic_timers_value ) , 0x0 , NULL , HFILL } } , { & hf_gsm_a_skip_ind , { "Skip Indicator" , "gsm_a.skip.ind" , FT_UINT8 , BASE_DEC , VALS ( gsm_a_skip_ind_vals ) , 0xf0 , NULL , HFILL } } , { & hf_gsm_a_b7spare , { "Spare" , "gsm_a.spareb7" , FT_UINT8 , BASE_DEC , NULL , 0x40 , NULL , HFILL } } , { & hf_gsm_a_b8spare , { "Spare" , "gsm_a.spareb8" , FT_UINT8 , BASE_DEC , NULL , 0x80 , NULL , HFILL } } , { & hf_gsm_a_spare_bits , { "Spare bit(s)" , "gsm_a.spare_bits" , FT_UINT8 , BASE_DEC , NULL , 0x0 , NULL , HFILL } } , { & hf_gsm_a_multi_bnd_sup_fields , { "Multiband supported field" , "gsm_a.multi_bnd_sup_fields" , FT_UINT8 , BASE_DEC , NULL , 0x0 , NULL , HFILL } } , { & hf_gsm_a_pgsm_supported , { "P-GSM Supported" , "gsm_a.classmark3.pgsmSupported" , FT_BOOLEAN , BASE_NONE , TFS ( & true_false_vals ) , 0x0 , NULL , HFILL } } , { & hf_gsm_a_egsm_supported , { "E-GSM or R-GSM Supported" , "gsm_a.classmark3.egsmSupported" , FT_BOOLEAN , BASE_NONE , TFS ( & true_false_vals ) , 0x0 , NULL , HFILL } } , { & hf_gsm_a_gsm1800_supported , { "GSM 1800 Supported" , "gsm_a.classmark3.gsm1800Supported" , FT_BOOLEAN , BASE_NONE , TFS ( & true_false_vals ) , 0x0 , NULL , HFILL } } , { & hf_gsm_a_ass_radio_cap1 , { "Associated Radio Capability 1" , "gsm_a.classmark3.ass_radio_cap1" , FT_UINT8 , BASE_DEC , NULL , 0x0 , NULL , HFILL } } , { & hf_gsm_a_ass_radio_cap2 , { "Associated Radio Capability 2" , "gsm_a.classmark3.ass_radio_cap2" , FT_UINT8 , BASE_DEC , NULL , 0x0 , NULL , HFILL } } , { & hf_gsm_a_cm3_A5_bits , { "A5 bits" , "gsm_a.classmark3.a5_bits" , FT_UINT8 , BASE_HEX , NULL , 0x00 , NULL , HFILL } } , { & hf_gsm_a_rsupport , { "R Support" , "gsm_a.classmark3.rsupport" , FT_BOOLEAN , BASE_NONE , TFS ( & true_false_vals ) , 0x0 , NULL , HFILL } } , { & hf_gsm_a_r_capabilities , { "R-GSM band Associated Radio Capability" , "gsm_a.classmark3.r_capabilities" , FT_UINT8 , BASE_DEC , NULL , 0x0 , NULL , HFILL } } , { & hf_gsm_a_multislot_capabilities , { "HSCSD Multi Slot Capability" , "gsm_a.classmark3.multislot_capabilities" , FT_BOOLEAN , BASE_NONE , TFS ( & true_false_vals ) , 0x0 , NULL , HFILL } } , { & hf_gsm_a_multislot_class , { "HSCSD Multi Slot Class" , "gsm_a.classmark3.multislot_cap" , FT_UINT8 , BASE_DEC , NULL , 0x0 , NULL , HFILL } } , { & hf_gsm_a_ucs2_treatment , { "UCS2 treatment" , "gsm_a.UCS2_treatment" , FT_BOOLEAN , BASE_NONE , TFS ( & UCS2_treatment_vals ) , 0x0 , NULL , HFILL } } , { & hf_gsm_a_extended_measurement_cap , { "Extended Measurement Capability" , "gsm_a.classmark3.ext_meas_cap" , FT_BOOLEAN , BASE_NONE , TFS ( & true_false_vals ) , 0x0 , NULL , HFILL } } , { & hf_gsm_a_ms_measurement_capability , { "MS measurement capability" , "gsm_a.classmark3.ms_measurement_capability" , FT_BOOLEAN , BASE_NONE , TFS ( & true_false_vals ) , 0x0 , NULL , HFILL } } , { & hf_gsm_a_sms_value , { "SMS_VALUE (Switch-Measure-Switch)" , "gsm_a.classmark3.sms_value" , FT_UINT8 , BASE_DEC , VALS ( gsm_a_sms_vals ) , 0x0 , NULL , HFILL } } , { & hf_gsm_a_sm_value , { "SM_VALUE (Switch-Measure)" , "gsm_a.classmark3.sm_value" , FT_UINT8 , BASE_DEC , VALS ( gsm_a_sms_vals ) , 0x0 , NULL , HFILL } } , { & hf_gsm_a_ms_pos_method_cap_present , { "MS Positioning Method Capability present" , "gsm_a.classmark3.ms_pos_method_cap_present" , FT_BOOLEAN , BASE_NONE , TFS ( & true_false_vals ) , 0x00 , NULL , HFILL } } , { & hf_gsm_a_ms_pos_method , { "MS Positioning Method" , "gsm_a.classmark3.ms_pos_method" , FT_UINT8 , BASE_HEX , NULL , 0x00 , NULL , HFILL } } , { & hf_gsm_a_ms_assisted_e_otd , { "MS assisted E-OTD" , "gsm_a.classmark3.ms_assisted_e_otd" , FT_BOOLEAN , BASE_NONE , TFS ( & ms_assisted_e_otd_vals ) , 0x0 , NULL , HFILL } } , { & hf_gsm_a_ms_based_e_otd , { "MS based E-OTD" , "gsm_a.classmark3.ms_based_e_otd" , FT_BOOLEAN , BASE_NONE , TFS ( & ms_based_e_otd_vals ) , 0x0 , NULL , HFILL } } , { & hf_gsm_a_ms_assisted_gps , { "MS assisted GPS" , "gsm_a.classmark3.ms_assisted_gps" , FT_BOOLEAN , BASE_NONE , TFS ( & ms_assisted_gps_vals ) , 0x0 , NULL , HFILL } } , { & hf_gsm_a_ms_based_gps , { "MS based GPS" , "gsm_a.classmark3.ms_based_gps" , FT_BOOLEAN , BASE_NONE , TFS ( & ms_based_gps_vals ) , 0x0 , NULL , HFILL } } , { & hf_gsm_a_ms_conventional_gps , { "MS Conventional GPS" , "gsm_a.classmark3.ms_conventional_gps" , FT_BOOLEAN , BASE_NONE , TFS ( & ms_conventional_gps_vals ) , 0x0 , NULL , HFILL } } , { & hf_gsm_a_ecsd_multi_slot_capability , { "ECSD Multi Slot Capability present" , "gsm_a.classmark3.ecsd_multi_slot_capability" , FT_BOOLEAN , BASE_NONE , TFS ( & true_false_vals ) , 0x00 , NULL , HFILL } } , { & hf_gsm_a_ecsd_multi_slot_class , { "ECSD Multi Slot Class" , "gsm_a.classmark3.ecsd_multi_slot_class" , FT_UINT8 , BASE_DEC , NULL , 0x00 , NULL , HFILL } } , { & hf_gsm_a_8_psk_struct_present , { "8-PSK Struct present" , "gsm_a.classmark3.8_psk_struct_present" , FT_BOOLEAN , BASE_NONE , TFS ( & true_false_vals ) , 0x00 , NULL , HFILL } } , { & hf_gsm_a_8_psk_struct , { "8-PSK Struct" , "gsm_a.classmark3.8_psk_struct" , FT_UINT8 , BASE_HEX , NULL , 0x00 , NULL , HFILL } } , { & hf_gsm_a_modulation_capability , { "Modulation Capability" , "gsm_a.classmark3.modulation_capability" , FT_BOOLEAN , BASE_NONE , TFS ( & modulation_capability_vals ) , 0x00 , NULL , HFILL } } , { & hf_gsm_a_8_psk_rf_power_capability_1_present , { "8-PSK RF Power Capability 1 present" , "gsm_a.classmark3.8_psk_rf_power_capability_1_present" , FT_BOOLEAN , BASE_NONE , TFS ( & true_false_vals ) , 0x00 , NULL , HFILL } } , { & hf_gsm_a_8_psk_rf_power_capability_1 , { "8-PSK RF Power Capability 1" , "gsm_a.classmark3.8_psk_rf_power_capability_1" , FT_UINT8 , BASE_HEX , VALS ( eight_psk_rf_power_capability_vals ) , 0x00 , NULL , HFILL } } , { & hf_gsm_a_8_psk_rf_power_capability_2_present , { "8-PSK RF Power Capability 2 present" , "gsm_a.classmark3.8_psk_rf_power_capability_2_present" , FT_BOOLEAN , BASE_NONE , TFS ( & true_false_vals ) , 0x00 , NULL , HFILL } } , { & hf_gsm_a_8_psk_rf_power_capability_2 , { "8-PSK RF Power Capability 2" , "gsm_a.classmark3.8_psk_rf_power_capability_2" , FT_UINT8 , BASE_HEX , VALS ( eight_psk_rf_power_capability_vals ) , 0x00 , NULL , HFILL } } , { & hf_gsm_a_gsm_400_band_info_present , { "GSM 400 Band Information present" , "gsm_a.classmark3.gsm_400_band_info_present" , FT_BOOLEAN , BASE_NONE , TFS ( & true_false_vals ) , 0x00 , NULL , HFILL } } , { & hf_gsm_a_gsm_400_bands_supported , { "GSM 400 Bands Supported" , "gsm_a.classmark3.gsm_400_bands_supported" , FT_UINT8 , BASE_HEX , VALS ( gsm_400_bands_supported_vals ) , 0x00 , NULL , HFILL } } , { & hf_gsm_a_gsm_400_assoc_radio_cap , { "GSM 400 Associated Radio Capability" , "gsm_a.classmark3.gsm_400_assoc_radio_cap" , FT_UINT8 , BASE_HEX , NULL , 0x00 , NULL , HFILL } } , { & hf_gsm_a_gsm_850_assoc_radio_cap_present , { "GSM 850 Associated Radio Capability present" , "gsm_a.classmark3.gsm_850_assoc_radio_cap_present" , FT_BOOLEAN , BASE_NONE , TFS ( & true_false_vals ) , 0x00 , NULL , HFILL } } , { & hf_gsm_a_gsm_850_assoc_radio_cap , { "GSM 850 Associated Radio Capability" , "gsm_a.classmark3.gsm_850_assoc_radio_cap" , FT_UINT8 , BASE_HEX , NULL , 0x00 , NULL , HFILL } } , { & hf_gsm_a_gsm_1900_assoc_radio_cap_present , { "GSM 1900 Associated Radio Capability present" , "gsm_a.classmark3.gsm_1900_assoc_radio_cap_present" , FT_BOOLEAN , BASE_NONE , TFS ( & true_false_vals ) , 0x00 , NULL , HFILL } } , { & hf_gsm_a_gsm_1900_assoc_radio_cap , { "GSM 1900 Associated Radio Capability" , "gsm_a.classmark3.gsm_1900_assoc_radio_cap" , FT_UINT8 , BASE_HEX , NULL , 0x00 , NULL , HFILL } } , { & hf_gsm_a_umts_fdd_rat_cap , { "UMTS FDD Radio Access Technology Capability" , "gsm_a.classmark3.umts_fdd_rat_cap" , FT_BOOLEAN , BASE_NONE , TFS ( & umts_fdd_rat_cap_vals ) , 0x00 , NULL , HFILL } } , { & hf_gsm_a_umts_384_mcps_tdd_rat_cap , { "UMTS 3.84 Mcps TDD Radio Access Technology Capability" , "gsm_a.classmark3.umts_384_mcps_tdd_rat_cap" , FT_BOOLEAN , BASE_NONE , TFS ( & umts_384_mcps_tdd_rat_cap_vals ) , 0x00 , NULL , HFILL } } , { & hf_gsm_a_cdma_2000_rat_cap , { "CDMA 2000 Radio Access Technology Capability" , "gsm_a.classmark3.cdma_2000_rat_cap" , FT_BOOLEAN , BASE_NONE , TFS ( & cdma_2000_rat_cap_vals ) , 0x00 , NULL , HFILL } } , { & hf_gsm_a_dtm_e_gprs_multi_slot_info_present , { "DTM E/GPRS Multi Slot Information present" , "gsm_a.classmark3.dtm_e_gprs_multi_slot_info_present" , FT_BOOLEAN , BASE_NONE , TFS ( & true_false_vals ) , 0x00 , NULL , HFILL } } , { & hf_gsm_a_dtm_gprs_multi_slot_class , { "DTM GPRS Multi Slot Class" , "gsm_a.classmark3.dtm_gprs_multi_slot_class" , FT_UINT8 , BASE_DEC , VALS ( dtm_gprs_multi_slot_class_vals ) , 0x00 , NULL , HFILL } } , { & hf_gsm_a_single_slot_dtm , { "Single Slot DTM" , "gsm_a.classmark3.single_slot_dtm_supported" , FT_BOOLEAN , BASE_NONE , TFS ( & single_slot_dtm_vals ) , 0x0 , NULL , HFILL } } , { & hf_gsm_a_dtm_egprs_multi_slot_class_present , { "DTM EGPRS Multi Slot Class present" , "gsm_a.classmark3.dtm_egprs_multi_slot_class_present" , FT_BOOLEAN , BASE_NONE , TFS ( & true_false_vals ) , 0x00 , NULL , HFILL } } , { & hf_gsm_a_dtm_egprs_multi_slot_class , { "DTM EGPRS Multi Slot Class" , "gsm_a.classmark3.dtm_egprs_multi_slot_class" , FT_UINT8 , BASE_DEC , VALS ( dtm_gprs_multi_slot_class_vals ) , 0x00 , NULL , HFILL } } , { & hf_gsm_a_single_band_support , { "Single Band Support" , "gsm_a.classmark3.single_band_support" , FT_BOOLEAN , BASE_NONE , TFS ( & true_false_vals ) , 0x00 , NULL , HFILL } } , { & hf_gsm_a_gsm_band , { "GSM Band" , "gsm_a.classmark3.gsm_band" , FT_UINT8 , BASE_DEC , VALS ( gsm_band_vals ) , 0x00 , NULL , HFILL } } , { & hf_gsm_a_gsm_750_assoc_radio_cap_present , { "GSM 750 Associated Radio Capability present" , "gsm_a.classmark3.gsm_750_assoc_radio_cap_present" , FT_BOOLEAN , BASE_NONE , TFS ( & true_false_vals ) , 0x00 , NULL , HFILL } } , { & hf_gsm_a_gsm_750_assoc_radio_cap , { "GSM 750 Associated Radio Capability" , "gsm_a.classmark3.gsm_750_assoc_radio_cap" , FT_UINT8 , BASE_HEX , NULL , 0x00 , NULL , HFILL } } , { & hf_gsm_a_umts_128_mcps_tdd_rat_cap , { "UMTS 1.28 Mcps TDD Radio Access Technology Capability" , "gsm_a.classmark3.umts_128_mcps_tdd_rat_cap" , FT_BOOLEAN , BASE_NONE , TFS ( & umts_128_mcps_tdd_rat_cap_vals ) , 0x00 , NULL , HFILL } } , { & hf_gsm_a_geran_feature_package_1 , { "GERAN Feature Package 1" , "gsm_a.classmark3.geran_feature_package_1" , FT_BOOLEAN , BASE_NONE , TFS ( & geran_feature_package_1_vals ) , 0x00 , NULL , HFILL } } , { & hf_gsm_a_ext_dtm_e_gprs_multi_slot_info_present , { "Extended DTM E/GPRS Multi Slot Information present" , "gsm_a.classmark3.ext_dtm_e_gprs_info_present" , FT_BOOLEAN , BASE_NONE , TFS ( & true_false_vals ) , 0x00 , NULL , HFILL } } , { & hf_gsm_a_ext_dtm_gprs_multi_slot_class , { "Extended DTM GPRS Multi Slot Class" , "gsm_a.classmark3.ext_dtm_gprs_multi_slot_class" , FT_UINT8 , BASE_HEX , NULL , 0x00 , NULL , HFILL } } , { & hf_gsm_a_ext_dtm_egprs_multi_slot_class , { "Extended DTM EGPRS Multi Slot Class" , "gsm_a.classmark3.ext_dtm_egprs_multi_slot_class" , FT_UINT8 , BASE_HEX , NULL , 0x00 , NULL , HFILL } } , { & hf_gsm_a_high_multislot_cap_present , { "High Multislot Capability present" , "gsm_a.classmark3.high_multislot_cap_present" , FT_BOOLEAN , BASE_NONE , TFS ( & true_false_vals ) , 0x00 , NULL , HFILL } } , { & hf_gsm_a_high_multislot_cap , { "High Multislot Capability" , "gsm_a.classmark3.high_multislot_cap" , FT_UINT8 , BASE_HEX , NULL , 0x00 , NULL , HFILL } } , { & hf_gsm_a_geran_iu_mode_support , { "GERAN Iu Mode Support" , "gsm_a.classmark3.geran_iu_mode_support" , FT_BOOLEAN , BASE_NONE , TFS ( & true_false_vals ) , 0x00 , NULL , HFILL } } , { & hf_gsm_a_geran_iu_mode_cap , { "GERAN Iu Mode Capabilities" , "gsm_a.classmark3.geran_iu_mode_cap" , FT_UINT24 , BASE_HEX , NULL , 0x00 , NULL , HFILL } } , { & hf_gsm_a_geran_iu_mode_cap_length , { "Length" , "gsm_a.classmark3.geran_iu_mode_cap.length" , FT_UINT8 , BASE_DEC , NULL , 0x00 , NULL , HFILL } } , { & hf_gsm_a_flo_iu_cap , { "FLO Iu Capability" , "gsm_a.classmark3.geran_iu_mode_cap.flo_iu_cap" , FT_BOOLEAN , BASE_NONE , TFS ( & flo_iu_cap_vals ) , 0x00 , NULL , HFILL } } , { & hf_gsm_a_geran_feature_package_2 , { "GERAN Feature Package 2" , "gsm_a.classmark3.geran_feature_package_2" , FT_BOOLEAN , BASE_NONE , TFS ( & geran_feature_package_2_vals ) , 0x00 , NULL , HFILL } } , { & hf_gsm_a_gmsk_multislot_power_prof , { "GMSK Multislot Power Profile" , "gsm_a.classmark3.gmsk_multislot_power_prof" , FT_UINT8 , BASE_DEC , VALS ( gmsk_multislot_power_prof_vals ) , 0x00 , NULL , HFILL } } , { & hf_gsm_a_8_psk_multislot_power_prof , { "8-PSK Multislot Power Profile" , "gsm_a.classmark3.8_psk_multislot_power_prof" , FT_UINT8 , BASE_DEC , VALS ( eight_psk_multislot_power_prof_vals ) , 0x00 , NULL , HFILL } } , { & hf_gsm_a_t_gsm_400_band_info_present , { "T-GSM 400 Band Information present" , "gsm_a.classmark3.gsm_400_band_info_present" , FT_BOOLEAN , BASE_NONE , TFS ( & true_false_vals ) , 0x00 , NULL , HFILL } } , { & hf_gsm_a_t_gsm_400_bands_supported , { "T-GSM 400 Bands Supported" , "gsm_a.classmark3.t_gsm_400_bands_supported" , FT_UINT8 , BASE_HEX , VALS ( t_gsm_400_bands_supported_vals ) , 0x00 , NULL , HFILL } } , { & hf_gsm_a_t_gsm_400_assoc_radio_cap , { "T-GSM 400 Associated Radio Capability" , "gsm_a.classmark3.t_gsm_400_assoc_radio_cap" , FT_UINT8 , BASE_HEX , NULL , 0x00 , NULL , HFILL } } , { & hf_gsm_a_t_gsm_900_assoc_radio_cap_present , { "T-GSM 900 Associated Radio Capability present" , "gsm_a.classmark3.t_gsm_900_assoc_radio_cap_present" , FT_BOOLEAN , BASE_NONE , TFS ( & true_false_vals ) , 0x00 , NULL , HFILL } } , { & hf_gsm_a_t_gsm_900_assoc_radio_cap , { "T-GSM 900 Associated Radio Capability" , "gsm_a.classmark3.t_gsm_900_assoc_radio_cap" , FT_UINT8 , BASE_HEX , NULL , 0x00 , NULL , HFILL } } , { & hf_gsm_a_downlink_adv_receiver_perf , { "Downlink Advanced Receiver Performance" , "gsm_a.classmark3.downlink_adv_receiver_perf" , FT_UINT8 , BASE_DEC , VALS ( downlink_adv_receiver_perf_vals ) , 0x00 , NULL , HFILL } } , { & hf_gsm_a_dtm_enhancements_cap , { "DTM Enhancements Capability" , "gsm_a.classmark3.dtm_enhancements_capability" , FT_BOOLEAN , BASE_NONE , TFS ( & dtm_enhancements_cap_vals ) , 0x00 , NULL , HFILL } } , { & hf_gsm_a_dtm_e_gprs_high_multi_slot_info_present , { "DTM E/GPRS High Multi Slot Information present" , "gsm_a.classmark3.dtm_e_gprs_high_mutli_slot_info_present" , FT_BOOLEAN , BASE_NONE , TFS ( & true_false_vals ) , 0x00 , NULL , HFILL } } , { & hf_gsm_a_dtm_gprs_high_multi_slot_class , { "DTM GPRS Multi Slot Class" , "gsm_a.classmark3.dtm_gprs_multi_slot_class" , FT_UINT8 , BASE_DEC , VALS ( dtm_gprs_high_multi_slot_class_vals ) , 0x00 , NULL , HFILL } } , { & hf_gsm_a_offset_required , { "Offset required" , "gsm_a.classmark3.offset_required" , FT_BOOLEAN , BASE_NONE , TFS ( & offset_required_vals ) , 0x0 , NULL , HFILL } } , { & hf_gsm_a_dtm_egprs_high_multi_slot_class_present , { "DTM EGPRS High Multi Slot Class present" , "gsm_a.classmark3.dtm_egprs_high_multi_slot_class_present" , FT_BOOLEAN , BASE_NONE , TFS ( & true_false_vals ) , 0x00 , NULL , HFILL } } , { & hf_gsm_a_dtm_egprs_high_multi_slot_class , { "DTM EGPRS High Multi Slot Class" , "gsm_a.classmark3.dtm_egprs_high_multi_slot_class" , FT_UINT8 , BASE_DEC , VALS ( dtm_gprs_high_multi_slot_class_vals ) , 0x00 , NULL , HFILL } } , { & hf_gsm_a_repeated_acch_cap , { "Repeated ACCH Capability" , "gsm_a.classmark3.repeated_acch_cap" , FT_BOOLEAN , BASE_NONE , TFS ( & repeated_acch_cap_vals ) , 0x00 , NULL , HFILL } } , { & hf_gsm_a_gsm_710_assoc_radio_cap_present , { "GSM 710 Associated Radio Capability present" , "gsm_a.classmark3.gsm_710_assoc_radio_cap_present" , FT_BOOLEAN , BASE_NONE , TFS ( & true_false_vals ) , 0x00 , NULL , HFILL } } , { & hf_gsm_a_gsm_710_assoc_radio_cap , { "GSM 710 Associated Radio Capability" , "gsm_a.classmark3.gsm_710_assoc_radio_cap" , FT_UINT8 , BASE_HEX , NULL , 0x00 , NULL , HFILL } } , { & hf_gsm_a_t_gsm_810_assoc_radio_cap_present , { "T-GSM 810 Associated Radio Capability present" , "gsm_a.classmark3.t_gsm_810_assoc_radio_cap_present" , FT_BOOLEAN , BASE_NONE , TFS ( & true_false_vals ) , 0x00 , NULL , HFILL } } , { & hf_gsm_a_t_gsm_810_assoc_radio_cap , { "T-GSM 810 Associated Radio Capability" , "gsm_a.classmark3.t_gsm_810_assoc_radio_cap" , FT_UINT8 , BASE_HEX , NULL , 0x00 , NULL , HFILL } } , { & hf_gsm_a_ciphering_mode_setting_cap , { "Ciphering Mode Setting Capability" , "gsm_a.classmark3.ciphering_mode_setting_cap" , FT_BOOLEAN , BASE_NONE , TFS ( & ciphering_mode_setting_cap_vals ) , 0x00 , NULL , HFILL } } , { & hf_gsm_a_additional_positioning_caps , { "Additional Positioning Capabilities" , "gsm_a.classmark3.additional_positioning_caps" , FT_BOOLEAN , BASE_NONE , TFS ( & additional_positioning_caps_vals ) , 0x00 , NULL , HFILL } } , { & hf_gsm_a_e_utra_fdd_support , { "E-UTRA FDD support" , "gsm_a.classmark3.e_utra_fdd_support" , FT_BOOLEAN , BASE_NONE , TFS ( & e_utra_fdd_support_vals ) , 0x00 , NULL , HFILL } } , { & hf_gsm_a_e_utra_tdd_support , { "E-UTRA TDD support" , "gsm_a.classmark3.e_utra_tdd_support" , FT_BOOLEAN , BASE_NONE , TFS ( & e_utra_tdd_support_vals ) , 0x00 , NULL , HFILL } } , { & hf_gsm_a_e_utra_meas_and_report_support , { "E-UTRA Measurement and Reporting support" , "gsm_a.classmark3.e_utra_meas_and_report_support" , FT_BOOLEAN , BASE_NONE , TFS ( & e_utra_meas_and_report_support_vals ) , 0x00 , NULL , HFILL } } , { & hf_gsm_a_prio_based_resel_support , { "Priority-based reselection support" , "gsm_a.classmark3.prio_based_resel_support" , FT_BOOLEAN , BASE_NONE , TFS ( & prio_based_resel_support_vals ) , 0x00 , NULL , HFILL } } , { & hf_gsm_a_utra_csg_cells_reporting , { "UTRA CSG Cells Reporting" , "gsm_a.classmark3.utra_csg_cells_reporting" , FT_BOOLEAN , BASE_NONE , TFS ( & utra_csg_cells_reporting_vals ) , 0x00 , NULL , HFILL } } , { & hf_gsm_a_vamos_level , { "VAMOS Level" , "gsm_a.classmark3.vamos_level" , FT_UINT8 , BASE_DEC , VALS ( vamos_level_vals ) , 0x00 , NULL , HFILL } } , { & hf_gsm_a_tighter_cap , { "TIGHTER Capability" , "gsm_a.classmark3.tighter_cap" , FT_UINT8 , BASE_DEC , VALS ( tighter_cap_level_vals ) , 0x00 , NULL , HFILL } } , { & hf_gsm_a_selective_ciph_down_sacch , { "Selective Ciphering of Downlink SACCH" , "gsm_a.classmark3.selective_ciph_down_sacch" , FT_BOOLEAN , BASE_NONE , TFS ( & tfs_supported_not_supported ) , 0x00 , NULL , HFILL } } , { & hf_gsm_a_cs_to_ps_srvcc_geran_to_utra , { "CS to PS SRVCC from GERAN to UTRA" , "gsm_a.classmark3.cs_to_ps_srvcc_geran_to_utra" , FT_UINT8 , BASE_DEC , VALS ( cs_to_ps_srvcc_geran_to_utra_vals ) , 0x00 , NULL , HFILL } } , { & hf_gsm_a_cs_to_ps_srvcc_geran_to_eutra , { "CS to PS SRVCC from GERAN to E-UTRA" , "gsm_a.classmark3.cs_to_ps_srvcc_geran_to_eutra" , FT_UINT8 , BASE_DEC , VALS ( cs_to_ps_srvcc_geran_to_eutra_vals ) , 0x00 , NULL , HFILL } } , { & hf_gsm_a_geran_network_sharing_support , { "GERAN Network Sharing support" , "gsm_a.classmark3.geran_network_sharing_support" , FT_BOOLEAN , BASE_NONE , TFS ( & true_false_vals ) , 0x00 , NULL , HFILL } } , { & hf_gsm_a_eutra_wb_rsrq_support , { "E-UTRA Wideband RSRQ measurements support" , "gsm_a.classmark3.eutra_wb_rsrq_support" , FT_BOOLEAN , BASE_NONE , TFS ( & true_false_vals ) , 0x00 , NULL , HFILL } } , { & hf_gsm_a_er_band_support , { "ER Band support" , "gsm_a.classmark3.er_band_support" , FT_BOOLEAN , BASE_NONE , TFS ( & true_false_vals ) , 0x00 , NULL , HFILL } } , { & hf_gsm_a_utra_mfbi_support , { "UTRA Multiple Frequency Band Indicators support" , "gsm_a.classmark3.utra_mfbi_support" , FT_BOOLEAN , BASE_NONE , TFS ( & true_false_vals ) , 0x00 , NULL , HFILL } } , { & hf_gsm_a_eutra_mfbi_support , { "E-UTRA Multiple Frequency Band Indicators support" , "gsm_a.classmark3.eutra_mfbi_support" , FT_BOOLEAN , BASE_NONE , TFS ( & true_false_vals ) , 0x00 , NULL , HFILL } } , { & hf_gsm_a_ext_tsc_set_cap_support , { "Extended TSC Set Capability support" , "gsm_a.classmark3.ext_tsc_set_cap_support" , FT_BOOLEAN , BASE_NONE , TFS ( & true_false_vals ) , 0x00 , NULL , HFILL } } , { & hf_gsm_a_ext_earfcn_value_range , { "Extended EARFCN value range" , "gsm_a.classmark3.ext_earfcn_value_range" , FT_BOOLEAN , BASE_NONE , TFS ( & tfs_supported_not_supported ) , 0x00 , NULL , HFILL } } , { & hf_gsm_a_geo_loc_type_of_shape , { "Location estimate" , "gsm_a.gad.location_estimate" , FT_UINT8 , BASE_DEC , VALS ( type_of_shape_vals ) , 0xf0 , NULL , HFILL } } , { & hf_gsm_a_geo_loc_sign_of_lat , { "Sign of latitude" , "gsm_a.gad.sign_of_latitude" , FT_UINT8 , BASE_DEC , VALS ( sign_of_latitude_vals ) , 0x80 , NULL , HFILL } } , { & hf_gsm_a_geo_loc_deg_of_lat , { "Degrees of latitude" , "gsm_a.gad.deg_of_latitude" , FT_UINT24 , BASE_DEC , NULL , 0x7fffff , NULL , HFILL } } , { & hf_gsm_a_geo_loc_deg_of_long , { "Degrees of longitude" , "gsm_a.gad.deg_of_longitude" , FT_INT24 , BASE_DEC , NULL , 0xffffff , NULL , HFILL } } , { & hf_gsm_a_geo_loc_uncertainty_code , { "Uncertainty code" , "gsm_a.gad.uncertainty_code" , FT_UINT8 , BASE_DEC , NULL , 0x7f , NULL , HFILL } } , { & hf_gsm_a_geo_loc_uncertainty_semi_major , { "Uncertainty semi-major" , "gsm_a.gad.uncertainty_semi_major" , FT_UINT8 , BASE_DEC , NULL , 0x7f , NULL , HFILL } } , { & hf_gsm_a_geo_loc_uncertainty_semi_minor , { "Uncertainty semi-minor" , "gsm_a.gad.uncertainty_semi_minor" , FT_UINT8 , BASE_DEC , NULL , 0x7f , NULL , HFILL } } , { & hf_gsm_a_geo_loc_orientation_of_major_axis , { "Orientation of major axis" , "gsm_a.gad.orientation_of_major_axis" , FT_UINT8 , BASE_DEC , NULL , 0x0 , NULL , HFILL } } , { & hf_gsm_a_geo_loc_uncertainty_altitude , { "Uncertainty Altitude" , "gsm_a.gad.uncertainty_altitude" , FT_UINT8 , BASE_DEC , NULL , 0x7f , NULL , HFILL } } , { & hf_gsm_a_geo_loc_confidence , { "Confidence(%)" , "gsm_a.gad.confidence" , FT_UINT8 , BASE_DEC , NULL , 0x7f , NULL , HFILL } } , { & hf_gsm_a_geo_loc_no_of_points , { "Number of points" , "gsm_a.gad.no_of_points" , FT_UINT8 , BASE_DEC , NULL , 0x0f , NULL , HFILL } } , { & hf_gsm_a_velocity_type , { "Number of points" , "gsm_a.gad.velocity_type" , FT_UINT8 , BASE_DEC , VALS ( gsm_a_velocity_type_vals ) , 0xf0 , NULL , HFILL } } , { & hf_gsm_a_bearing , { "Bearing" , "gsm_a.gad.bearing" , FT_UINT16 , BASE_DEC , NULL , 0x0 , NULL , HFILL } } , { & hf_gsm_a_horizontal_speed , { "Horizontal Speed" , "gsm_a.gad.horizontal_velocity" , FT_UINT16 , BASE_DEC , NULL , 0x0 , NULL , HFILL } } , { & hf_gsm_a_vertical_speed , { "Vertical Speed" , "gsm_a.gad.vertical_speed" , FT_UINT8 , BASE_DEC , NULL , 0x0 , NULL , HFILL } } , { & hf_gsm_a_uncertainty_speed , { "Uncertainty Speed" , "gsm_a.gad.uncertainty_speed" , FT_UINT8 , BASE_DEC , NULL , 0x0 , NULL , HFILL } } , { & hf_gsm_a_h_uncertainty_speed , { "Horizontal Uncertainty Speed" , "gsm_a.gad.v_uncertainty_speed" , FT_UINT8 , BASE_DEC , NULL , 0x0 , NULL , HFILL } } , { & hf_gsm_a_v_uncertainty_speed , { "Vertical Uncertainty Speed" , "gsm_a.gad.h_uncertainty_speed" , FT_UINT8 , BASE_DEC , NULL , 0x0 , NULL , HFILL } } , { & hf_gsm_a_d , { "Direction of Vertical Speed" , "gsm_a.gad.d" , FT_BOOLEAN , 8 , TFS ( & gsm_a_dir_of_ver_speed_vals ) , 0x08 , NULL , HFILL } } , { & hf_gsm_a_geo_loc_D , { "D: Direction of Altitude" , "gsm_a.gad.D" , FT_UINT16 , BASE_DEC , VALS ( dir_of_alt_vals ) , 0x8000 , NULL , HFILL } } , { & hf_gsm_a_geo_loc_altitude , { "Altitude in meters" , "gsm_a.gad.altitude" , FT_UINT16 , BASE_DEC , NULL , 0x7fff , NULL , HFILL } } , { & hf_gsm_a_geo_loc_inner_radius , { "Inner radius" , "gsm_a.gad.altitude" , FT_UINT16 , BASE_DEC , NULL , 0x0 , NULL , HFILL } } , { & hf_gsm_a_geo_loc_uncertainty_radius , { "Uncertainty radius" , "gsm_a.gad.no_of_points" , FT_UINT8 , BASE_DEC , NULL , 0x7f , NULL , HFILL } } , { & hf_gsm_a_geo_loc_offset_angle , { "Offset angle" , "gsm_a.gad.offset_angle" , FT_UINT8 , BASE_DEC , NULL , 0x0 , NULL , HFILL } } , { & hf_gsm_a_geo_loc_included_angle , { "Included angle" , "gsm_a.gad.included_angle" , FT_UINT8 , BASE_DEC , NULL , 0x0 , NULL , HFILL } } , { & hf_gsm_a_key_seq , { "key sequence" , "gsm_a.key_seq" , FT_UINT8 , BASE_DEC , VALS ( gsm_a_key_seq_vals ) , 0x00 , NULL , HFILL } } , { & hf_gsm_a_lac , { "Location Area Code (LAC)" , "gsm_a.lac" , FT_UINT16 , BASE_HEX_DEC , NULL , 0x00 , NULL , HFILL } } , { & hf_gsm_a_spare_nibble , { "Spare Nibble" , "gsm_a.spare" , FT_UINT8 , BASE_DEC_HEX , NULL , 0x00 , NULL , HFILL } } , { & hf_gsm_a_filler , { "Filler" , "gsm_a.filler" , FT_UINT8 , BASE_HEX , NULL , 0xF0 , NULL , HFILL } } , { & hf_gsm_a_identity_digit1 , { "Identity Digit 1" , "gsm_a.identity_digit1" , FT_UINT8 , BASE_HEX , NULL , 0xF0 , NULL , HFILL } } , { & hf_gsm_a_group_call_reference , { "Group or Broadcast call reference" , "gsm_a.group_call_reference" , FT_UINT32 , BASE_DEC_HEX , NULL , 0xffffffe0 , NULL , HFILL } } , { & hf_gsm_a_service_flag , { "SF Service Flag" , "gsm_a.service_flag" , FT_BOOLEAN , 32 , TFS ( & tfs_vgcs_vbs ) , 0x00000010 , NULL , HFILL } } , { & hf_gsm_a_af_acknowledgement , { "AF Acknowledgement" , "gsm_a.af_acknowledgement" , FT_BOOLEAN , 32 , TFS ( & tfs_required_not_required ) , 0x00000008 , NULL , HFILL } } , { & hf_gsm_a_call_priority , { "Call Priority" , "gsm_a.call_priority" , FT_UINT32 , BASE_DEC , VALS ( gsm_a_call_priority_vals ) , 0x00000007 , NULL , HFILL } } , { & hf_gsm_a_ciphering_info , { "Ciphering Information" , "gsm_a.ciphering_info" , FT_UINT8 , BASE_HEX , NULL , 0xf0 , NULL , HFILL } } , { & hf_gsm_a_sapi , { "SAPI (Service Access Point Identifier)" , "gsm_a.sapi" , FT_UINT8 , BASE_DEC , VALS ( gsm_a_sapi_vals ) , 0x30 , NULL , HFILL } } , { & hf_gsm_a_mobile_country_code , { "Mobile Country Code (MCC)" , "gsm_a.mobile_country_code" , FT_STRING , BASE_NONE , NULL , 0x0 , NULL , HFILL } } , { & hf_gsm_a_mobile_network_code , { "Mobile Network Code (MNC)" , "gsm_a.mobile_network_code" , FT_STRING , BASE_NONE , NULL , 0x0 , NULL , HFILL } } , } ; # define NUM_INDIVIDUAL_ELEMS 1 static gint * ett [ NUM_INDIVIDUAL_ELEMS + NUM_GSM_COMMON_ELEM ] ; static ei_register_info ei [ ] = { { & ei_gsm_a_extraneous_data , { "gsm_a.extraneous_data" , PI_PROTOCOL , PI_NOTE , "Extraneous Data, dissector bug or later version spec(report to wireshark.org)" , EXPFILL } } , { & ei_gsm_a_unknown_element , { "gsm_a.unknown_element" , PI_PROTOCOL , PI_ERROR , "Unknown - aborting dissection" , EXPFILL } } , { & ei_gsm_a_unknown_pdu_type , { "gsm_a.unknown_pdu_type" , PI_PROTOCOL , PI_WARN , "Unknown PDU type" , EXPFILL } } , { & ei_gsm_a_no_element_dissector , { "gsm_a.no_element_dissector" , PI_PROTOCOL , PI_WARN , "No element dissector, rest of dissection may be incorrect" , EXPFILL } } , { & ei_gsm_a_format_not_supported , { "gsm_a.format_not_supported" , PI_PROTOCOL , PI_WARN , "Format not supported" , EXPFILL } } , { & ei_gsm_a_mobile_identity_type , { "gsm_a.ie.mobileid.type.unknown" , PI_PROTOCOL , PI_WARN , "Format unknown" , EXPFILL } } , } ; expert_module_t * expert_a_common ; static tap_param gsm_a_stat_params [ ] = { { PARAM_FILTER , "filter" , "Filter" , NULL , TRUE } } ; static new_stat_tap_ui gsm_a_bssmap_stat_table = { REGISTER_STAT_GROUP_TELEPHONY_GSM , "A-Interface BSSMAP" , "gsm_a" , "gsm_a,bssmap" , gsm_a_bssmap_stat_init , gsm_a_bssmap_stat_packet , gsm_a_stat_reset , gsm_a_stat_free_table_item , NULL , sizeof ( gsm_a_stat_fields ) / sizeof ( stat_tap_table_item ) , gsm_a_stat_fields , sizeof ( gsm_a_stat_params ) / sizeof ( tap_param ) , gsm_a_stat_params , NULL } ; static new_stat_tap_ui gsm_a_dtap_mm_stat_table = { REGISTER_STAT_GROUP_TELEPHONY_GSM , "A-Interface DTAP Mobility Management" , "gsm_a" , "gsm_a,dtap_mm" , gsm_a_dtap_mm_stat_init , gsm_a_dtap_mm_stat_packet , gsm_a_stat_reset , NULL , NULL , sizeof ( gsm_a_stat_fields ) / sizeof ( stat_tap_table_item ) , gsm_a_stat_fields , sizeof ( gsm_a_stat_params ) / sizeof ( tap_param ) , gsm_a_stat_params , NULL } ; static new_stat_tap_ui gsm_a_dtap_rr_stat_table = { REGISTER_STAT_GROUP_TELEPHONY_GSM , "A-Interface DTAP Radio Resource Management" , "gsm_a" , "gsm_a,dtap_rr" , gsm_a_dtap_rr_stat_init , gsm_a_dtap_rr_stat_packet , gsm_a_stat_reset , NULL , NULL , sizeof ( gsm_a_stat_fields ) / sizeof ( stat_tap_table_item ) , gsm_a_stat_fields , sizeof ( gsm_a_stat_params ) / sizeof ( tap_param ) , gsm_a_stat_params , NULL } ; static new_stat_tap_ui gsm_a_dtap_cc_stat_table = { REGISTER_STAT_GROUP_TELEPHONY_GSM , "A-Interface DTAP Call Control" , "gsm_a" , "gsm_a,dtap_cc" , gsm_a_dtap_cc_stat_init , gsm_a_dtap_cc_stat_packet , gsm_a_stat_reset , NULL , NULL , sizeof ( gsm_a_stat_fields ) / sizeof ( stat_tap_table_item ) , gsm_a_stat_fields , sizeof ( gsm_a_stat_params ) / sizeof ( tap_param ) , gsm_a_stat_params , NULL } ; static new_stat_tap_ui gsm_a_dtap_gmm_stat_table = { REGISTER_STAT_GROUP_TELEPHONY_GSM , "A-Interface DTAP GPRS Mobility Management" , "gsm_a" , "gsm_a,dtap_gmm" , gsm_a_dtap_gmm_stat_init , gsm_a_dtap_gmm_stat_packet , gsm_a_stat_reset , NULL , NULL , sizeof ( gsm_a_stat_fields ) / sizeof ( stat_tap_table_item ) , gsm_a_stat_fields , sizeof ( gsm_a_stat_params ) / sizeof ( tap_param ) , gsm_a_stat_params , NULL } ; static new_stat_tap_ui gsm_a_dtap_sm_stat_table = { REGISTER_STAT_GROUP_TELEPHONY_GSM , "A-Interface DTAP GPRS Session Management" , "gsm_a" , "gsm_a,dtap_sm" , gsm_a_dtap_sm_stat_init , gsm_a_dtap_sm_stat_packet , gsm_a_stat_reset , NULL , NULL , sizeof ( gsm_a_stat_fields ) / sizeof ( stat_tap_table_item ) , gsm_a_stat_fields , sizeof ( gsm_a_stat_params ) / sizeof ( tap_param ) , gsm_a_stat_params , NULL } ; static new_stat_tap_ui gsm_a_dtap_sms_stat_table = { REGISTER_STAT_GROUP_TELEPHONY_GSM , "A-Interface DTAP Short Message Service" , "gsm_a" , "gsm_a,dtap_sms" , gsm_a_dtap_sms_stat_init , gsm_a_dtap_sms_stat_packet , gsm_a_stat_reset , NULL , NULL , sizeof ( gsm_a_stat_fields ) / sizeof ( stat_tap_table_item ) , gsm_a_stat_fields , sizeof ( gsm_a_stat_params ) / sizeof ( tap_param ) , gsm_a_stat_params , NULL } ; static new_stat_tap_ui gsm_a_dtap_tp_stat_table = { REGISTER_STAT_GROUP_TELEPHONY_GSM , "A-Interface DTAP Special Conformance Testing Functions" , "gsm_a" , "gsm_a,dtap_tp" , gsm_a_dtap_tp_stat_init , gsm_a_dtap_tp_stat_packet , gsm_a_stat_reset , NULL , NULL , sizeof ( gsm_a_stat_fields ) / sizeof ( stat_tap_table_item ) , gsm_a_stat_fields , sizeof ( gsm_a_stat_params ) / sizeof ( tap_param ) , gsm_a_stat_params , NULL } ; static new_stat_tap_ui gsm_a_dtap_ss_stat_table = { REGISTER_STAT_GROUP_TELEPHONY_GSM , "A-Interface DTAP Supplementary Services" , "gsm_a" , "gsm_a,dtap_ss" , gsm_a_dtap_ss_stat_init , gsm_a_dtap_ss_stat_packet , gsm_a_stat_reset , NULL , NULL , sizeof ( gsm_a_stat_fields ) / sizeof ( stat_tap_table_item ) , gsm_a_stat_fields , sizeof ( gsm_a_stat_params ) / sizeof ( tap_param ) , gsm_a_stat_params , NULL } ; static new_stat_tap_ui gsm_a_sacch_rr_stat_table = { REGISTER_STAT_GROUP_TELEPHONY_GSM , "A-Interface SACCH" , "gsm_a" , "gsm_a,dtap_sacch" , gsm_a_sacch_rr_stat_init , gsm_a_sacch_rr_stat_packet , gsm_a_stat_reset , NULL , NULL , sizeof ( gsm_a_stat_fields ) / sizeof ( stat_tap_table_item ) , gsm_a_stat_fields , sizeof ( gsm_a_stat_params ) / sizeof ( tap_param ) , gsm_a_stat_params , NULL } ; last_offset = NUM_INDIVIDUAL_ELEMS ; ett [ 0 ] = & ett_gsm_a_plmn ; for ( i = 0 ; i < NUM_GSM_COMMON_ELEM ; i ++ , last_offset ++ ) { ett_gsm_common_elem [ i ] = - 1 ; ett [ last_offset ] = & ett_gsm_common_elem [ i ] ; } proto_a_common = proto_register_protocol ( "GSM A-I/F COMMON" , "GSM COMMON" , "gsm_a" ) ; proto_register_field_array ( proto_a_common , hf , array_length ( hf ) ) ; proto_register_subtree_array ( ett , array_length ( ett ) ) ; expert_a_common = expert_register_protocol ( proto_a_common ) ; expert_register_field_array ( expert_a_common , ei , array_length ( ei ) ) ; gsm_a_tap = register_tap ( "gsm_a" ) ; register_new_stat_tap_ui ( & gsm_a_bssmap_stat_table ) ; register_new_stat_tap_ui ( & gsm_a_dtap_mm_stat_table ) ; register_new_stat_tap_ui ( & gsm_a_dtap_rr_stat_table ) ; register_new_stat_tap_ui ( & gsm_a_dtap_cc_stat_table ) ; register_new_stat_tap_ui ( & gsm_a_dtap_gmm_stat_table ) ; register_new_stat_tap_ui ( & gsm_a_dtap_sms_stat_table ) ; register_new_stat_tap_ui ( & gsm_a_dtap_sm_stat_table ) ; register_new_stat_tap_ui ( & gsm_a_dtap_ss_stat_table ) ; register_new_stat_tap_ui ( & gsm_a_dtap_tp_stat_table ) ; register_new_stat_tap_ui ( & gsm_a_sacch_rr_stat_table ) ; }

debian

int i2d_ECPrivateKey ( EC_KEY * a , unsigned char * * out ) { int ret = 0 , ok = 0 ; unsigned char * buffer = NULL ; size_t buf_len = 0 , tmp_len ; EC_PRIVATEKEY * priv_key = NULL ; if ( a == NULL || a -> group == NULL || a -> priv_key == NULL ) { ECerr ( EC_F_I2D_ECPRIVATEKEY , ERR_R_PASSED_NULL_PARAMETER ) ; goto err ; } if ( ( priv_key = EC_PRIVATEKEY_new ( ) ) == NULL ) { ECerr ( EC_F_I2D_ECPRIVATEKEY , ERR_R_MALLOC_FAILURE ) ; goto err ; } priv_key -> version = a -> version ; buf_len = ( size_t ) BN_num_bytes ( a -> priv_key ) ; buffer = OPENSSL_malloc ( buf_len ) ; if ( buffer == NULL ) { ECerr ( EC_F_I2D_ECPRIVATEKEY , ERR_R_MALLOC_FAILURE ) ; goto err ; } if ( ! BN_bn2bin ( a -> priv_key , buffer ) ) { ECerr ( EC_F_I2D_ECPRIVATEKEY , ERR_R_BN_LIB ) ; goto err ; } if ( ! M_ASN1_OCTET_STRING_set ( priv_key -> privateKey , buffer , buf_len ) ) { ECerr ( EC_F_I2D_ECPRIVATEKEY , ERR_R_ASN1_LIB ) ; goto err ; } if ( ! ( a -> enc_flag & EC_PKEY_NO_PARAMETERS ) ) { if ( ( priv_key -> parameters = ec_asn1_group2pkparameters ( a -> group , priv_key -> parameters ) ) == NULL ) { ECerr ( EC_F_I2D_ECPRIVATEKEY , ERR_R_EC_LIB ) ; goto err ; } } if ( ! ( a -> enc_flag & EC_PKEY_NO_PUBKEY ) ) { priv_key -> publicKey = M_ASN1_BIT_STRING_new ( ) ; if ( priv_key -> publicKey == NULL ) { ECerr ( EC_F_I2D_ECPRIVATEKEY , ERR_R_MALLOC_FAILURE ) ; goto err ; } tmp_len = EC_POINT_point2oct ( a -> group , a -> pub_key , a -> conv_form , NULL , 0 , NULL ) ; if ( tmp_len > buf_len ) { unsigned char * tmp_buffer = OPENSSL_realloc ( buffer , tmp_len ) ; if ( ! tmp_buffer ) { ECerr ( EC_F_I2D_ECPRIVATEKEY , ERR_R_MALLOC_FAILURE ) ; goto err ; } buffer = tmp_buffer ; buf_len = tmp_len ; } if ( ! EC_POINT_point2oct ( a -> group , a -> pub_key , a -> conv_form , buffer , buf_len , NULL ) ) { ECerr ( EC_F_I2D_ECPRIVATEKEY , ERR_R_EC_LIB ) ; goto err ; } priv_key -> publicKey -> flags &= ~ ( ASN1_STRING_FLAG_BITS_LEFT | 0x07 ) ; priv_key -> publicKey -> flags |= ASN1_STRING_FLAG_BITS_LEFT ; if ( ! M_ASN1_BIT_STRING_set ( priv_key -> publicKey , buffer , buf_len ) ) { ECerr ( EC_F_I2D_ECPRIVATEKEY , ERR_R_ASN1_LIB ) ; goto err ; } } if ( ( ret = i2d_EC_PRIVATEKEY ( priv_key , out ) ) == 0 ) { ECerr ( EC_F_I2D_ECPRIVATEKEY , ERR_R_EC_LIB ) ; goto err ; } ok = 1 ; err : if ( buffer ) OPENSSL_free ( buffer ) ; if ( priv_key ) EC_PRIVATEKEY_free ( priv_key ) ; return ( ok ? ret : 0 ) ; }

debian

static void cluster_all_databases ( bool verbose , const char * maintenance_db , const char * host , const char * port , const char * username , enum trivalue prompt_password , const char * progname , bool echo , bool quiet ) { PGconn * conn ; PGresult * result ; int i ; conn = connectMaintenanceDatabase ( maintenance_db , host , port , username , prompt_password , progname ) ; result = executeQuery ( conn , "SELECT datname FROM pg_database WHERE datallowconn ORDER BY 1; " , progname , echo ) ; PQfinish ( conn ) ; for ( i = 0 ; i < PQntuples ( result ) ; i ++ ) { char * dbname = PQgetvalue ( result , i , 0 ) ; if ( ! quiet ) { printf ( _ ( "%s: clustering database \"%s\"\n" ) , progname , dbname ) ; fflush ( stdout ) ; } cluster_one_database ( dbname , verbose , NULL , host , port , username , prompt_password , progname , echo ) ; } PQclear ( result ) ; }

debian

void jpc_qmfb_join_colres ( jpc_fix_t * a , int numrows , int numcols , int stride , int parity ) { int bufsize = JPC_CEILDIVPOW2 ( numrows , 1 ) ; jpc_fix_t joinbuf [ QMFB_JOINBUFSIZE * JPC_QMFB_COLGRPSIZE ] ; jpc_fix_t * buf = joinbuf ; jpc_fix_t * srcptr ; jpc_fix_t * dstptr ; register jpc_fix_t * srcptr2 ; register jpc_fix_t * dstptr2 ; register int n ; register int i ; int hstartcol ; if ( bufsize > QMFB_JOINBUFSIZE ) { if ( ! ( buf = jas_alloc3 ( bufsize , numcols , sizeof ( jpc_fix_t ) ) ) ) { abort ( ) ; } } hstartcol = ( numrows + 1 - parity ) >> 1 ; n = hstartcol ; srcptr = & a [ 0 ] ; dstptr = buf ; while ( n -- > 0 ) { dstptr2 = dstptr ; srcptr2 = srcptr ; for ( i = 0 ; i < numcols ; ++ i ) { * dstptr2 = * srcptr2 ; ++ dstptr2 ; ++ srcptr2 ; } srcptr += stride ; dstptr += numcols ; } srcptr = & a [ hstartcol * stride ] ; dstptr = & a [ ( 1 - parity ) * stride ] ; n = numrows - hstartcol ; while ( n -- > 0 ) { dstptr2 = dstptr ; srcptr2 = srcptr ; for ( i = 0 ; i < numcols ; ++ i ) { * dstptr2 = * srcptr2 ; ++ dstptr2 ; ++ srcptr2 ; } dstptr += 2 * stride ; srcptr += stride ; } srcptr = buf ; dstptr = & a [ parity * stride ] ; n = hstartcol ; while ( n -- > 0 ) { dstptr2 = dstptr ; srcptr2 = srcptr ; for ( i = 0 ; i < numcols ; ++ i ) { * dstptr2 = * srcptr2 ; ++ dstptr2 ; ++ srcptr2 ; } dstptr += 2 * stride ; srcptr += numcols ; } if ( buf != joinbuf ) { jas_free ( buf ) ; } }

debian

static void e1000e_set_rfctl ( E1000ECore * core , int index , uint32_t val ) { trace_e1000e_rx_set_rfctl ( val ) ; if ( ! ( val & E1000_RFCTL_ISCSI_DIS ) ) { trace_e1000e_wrn_iscsi_filtering_not_supported ( ) ; } if ( ! ( val & E1000_RFCTL_NFSW_DIS ) ) { trace_e1000e_wrn_nfsw_filtering_not_supported ( ) ; } if ( ! ( val & E1000_RFCTL_NFSR_DIS ) ) { trace_e1000e_wrn_nfsr_filtering_not_supported ( ) ; } core -> mac [ RFCTL ] = val ; }

chrome

static void U_CALLCONV _Latin1ToUnicodeWithOffsets ( UConverterToUnicodeArgs * pArgs , UErrorCode * pErrorCode ) { const uint8_t * source ; UChar * target ; int32_t targetCapacity , length ; int32_t * offsets ; int32_t sourceIndex ; source = ( const uint8_t * ) pArgs -> source ; target = pArgs -> target ; targetCapacity = ( int32_t ) ( pArgs -> targetLimit - pArgs -> target ) ; offsets = pArgs -> offsets ; sourceIndex = 0 ; length = ( int32_t ) ( ( const uint8_t * ) pArgs -> sourceLimit - source ) ; if ( length <= targetCapacity ) { targetCapacity = length ; } else { * pErrorCode = U_BUFFER_OVERFLOW_ERROR ; length = targetCapacity ; } if ( targetCapacity >= 8 ) { int32_t count , loops ; loops = count = targetCapacity >> 3 ; length = targetCapacity &= 0x7 ; do { target [ 0 ] = source [ 0 ] ; target [ 1 ] = source [ 1 ] ; target [ 2 ] = source [ 2 ] ; target [ 3 ] = source [ 3 ] ; target [ 4 ] = source [ 4 ] ; target [ 5 ] = source [ 5 ] ; target [ 6 ] = source [ 6 ] ; target [ 7 ] = source [ 7 ] ; target += 8 ; source += 8 ; } while ( -- count > 0 ) ; if ( offsets != NULL ) { do { offsets [ 0 ] = sourceIndex ++ ; offsets [ 1 ] = sourceIndex ++ ; offsets [ 2 ] = sourceIndex ++ ; offsets [ 3 ] = sourceIndex ++ ; offsets [ 4 ] = sourceIndex ++ ; offsets [ 5 ] = sourceIndex ++ ; offsets [ 6 ] = sourceIndex ++ ; offsets [ 7 ] = sourceIndex ++ ; offsets += 8 ; } while ( -- loops > 0 ) ; } } while ( targetCapacity > 0 ) { * target ++ = * source ++ ; -- targetCapacity ; } pArgs -> source = ( const char * ) source ; pArgs -> target = target ; if ( offsets != NULL ) { while ( length > 0 ) { * offsets ++ = sourceIndex ++ ; -- length ; } pArgs -> offsets = offsets ; } }

chrome

static hb_ ## name ## _t * _hb_ ## name ## _reference ( const hb_ ## name ## _t * l ) { hb_ ## name ## _t * c = ( hb_ ## name ## _t * ) calloc ( 1 , sizeof ( hb_ ## name ## _t ) ) ; if ( unlikely ( ! c ) ) return NULL ; * c = * l ; return c ; } static void _hb_ ## name ## _destroy ( hb_ ## name ## _t * l ) { free ( l ) ; } HB_DEFINE_BOXED_TYPE ( name , _hb_ ## name ## _reference , _hb_ ## name ## _destroy ) ; HB_DEFINE_OBJECT_TYPE ( buffer ) HB_DEFINE_OBJECT_TYPE ( blob ) HB_DEFINE_OBJECT_TYPE ( face ) HB_DEFINE_OBJECT_TYPE ( font ) HB_DEFINE_OBJECT_TYPE ( font_funcs ) HB_DEFINE_OBJECT_TYPE ( set ) HB_DEFINE_OBJECT_TYPE ( shape_plan ) HB_DEFINE_OBJECT_TYPE ( unicode_funcs ) HB_DEFINE_VALUE_TYPE ( feature ) HB_DEFINE_VALUE_TYPE ( glyph_info ) HB_DEFINE_VALUE_TYPE ( glyph_position ) HB_DEFINE_VALUE_TYPE ( segment_properties ) HB_DEFINE_VALUE_TYPE ( user_data_key )

debian

static void dump_trigger_old ( FILE * sql_file , MYSQL_RES * show_triggers_rs , MYSQL_ROW * show_trigger_row , const char * table_name ) { char quoted_table_name_buf [ NAME_LEN * 2 + 3 ] ; char * quoted_table_name = quote_name ( table_name , quoted_table_name_buf , 1 ) ; char name_buff [ NAME_LEN * 4 + 3 ] ; const char * xml_msg = "\nWarning! mysqldump being run against old server " "that does not\nsupport 'SHOW CREATE TRIGGERS' " "statement. Skipping..\n" ; DBUG_ENTER ( "dump_trigger_old" ) ; if ( opt_xml ) { print_xml_comment ( sql_file , strlen ( xml_msg ) , xml_msg ) ; check_io ( sql_file ) ; DBUG_VOID_RETURN ; } fprintf ( sql_file , "--\n" "-- WARNING: old server version. " "The following dump may be incomplete.\n" "--\n" ) ; if ( opt_compact ) fprintf ( sql_file , "/*!50003 SET @OLD_SQL_MODE=@@SQL_MODE*/; \n" ) ; fprintf ( sql_file , "DELIMITER ; ; \n" "/*!50003 SET SESSION SQL_MODE=\"%s\" */; ; \n" "/*!50003 CREATE */ " , ( * show_trigger_row ) [ 6 ] ) ; if ( mysql_num_fields ( show_triggers_rs ) > 7 ) { size_t user_name_len ; char user_name_str [ USERNAME_LENGTH + 1 ] ; char quoted_user_name_str [ USERNAME_LENGTH * 2 + 3 ] ; size_t host_name_len ; char host_name_str [ HOSTNAME_LENGTH + 1 ] ; char quoted_host_name_str [ HOSTNAME_LENGTH * 2 + 3 ] ; parse_user ( ( * show_trigger_row ) [ 7 ] , strlen ( ( * show_trigger_row ) [ 7 ] ) , user_name_str , & user_name_len , host_name_str , & host_name_len ) ; fprintf ( sql_file , "/*!50017 DEFINER=%s@%s */ " , quote_name ( user_name_str , quoted_user_name_str , FALSE ) , quote_name ( host_name_str , quoted_host_name_str , FALSE ) ) ; } fprintf ( sql_file , "/*!50003 TRIGGER %s %s %s ON %s FOR EACH ROW%s%s */; ; \n" "DELIMITER ; \n" , quote_name ( ( * show_trigger_row ) [ 0 ] , name_buff , 0 ) , ( * show_trigger_row ) [ 4 ] , ( * show_trigger_row ) [ 1 ] , quoted_table_name , ( strchr ( " \t\n\r" , * ( ( * show_trigger_row ) [ 3 ] ) ) ) ? "" : " " , ( * show_trigger_row ) [ 3 ] ) ; if ( opt_compact ) fprintf ( sql_file , "/*!50003 SET SESSION SQL_MODE=@OLD_SQL_MODE */; \n" ) ; DBUG_VOID_RETURN ; }

chrome

IN_PROC_BROWSER_TEST_F ( PageLoadMetricsBrowserTest , PayloadSizeChildFrame ) { ASSERT_TRUE ( embedded_test_server ( ) -> Start ( ) ) ; auto waiter = CreatePageLoadMetricsWaiter ( ) ; waiter -> AddPageExpectation ( TimingField : : LOAD_EVENT ) ; ui_test_utils : : NavigateToURL ( browser ( ) , embedded_test_server ( ) -> GetURL ( "/page_load_metrics/large_iframe.html" ) ) ; waiter -> Wait ( ) ; NavigateToUntrackedUrl ( ) ; histogram_tester_ . ExpectTotalCount ( internal : : kHistogramPageLoadTotalBytes , 1 ) ; histogram_tester_ . ExpectBucketCount ( internal : : kHistogramPageLoadTotalBytes , 10 , 1 ) ; }

chrome

void vp9_update_temporal_layer_framerate ( VP9_COMP * const cpi ) { SVC * const svc = & cpi -> svc ; const VP9EncoderConfig * const oxcf = & cpi -> oxcf ; LAYER_CONTEXT * const lc = get_layer_context ( cpi ) ; RATE_CONTROL * const lrc = & lc -> rc ; const int layer = svc -> temporal_layer_id ; lc -> framerate = cpi -> framerate / oxcf -> ts_rate_decimator [ layer ] ; lrc -> avg_frame_bandwidth = ( int ) ( lc -> target_bandwidth / lc -> framerate ) ; lrc -> max_frame_bandwidth = cpi -> rc . max_frame_bandwidth ; if ( layer == 0 ) { lc -> avg_frame_size = lrc -> avg_frame_bandwidth ; } else { const double prev_layer_framerate = cpi -> framerate / oxcf -> ts_rate_decimator [ layer - 1 ] ; const int prev_layer_target_bandwidth = oxcf -> ts_target_bitrate [ layer - 1 ] ; lc -> avg_frame_size = ( int ) ( ( lc -> target_bandwidth - prev_layer_target_bandwidth ) / ( lc -> framerate - prev_layer_framerate ) ) ; } }

debian

static int m_authenticate ( struct Client * client_p , struct Client * source_p , int parc , const char * parv [ ] ) { struct Client * agent_p = NULL ; struct Client * saslserv_p = NULL ; if ( ! IsCapable ( source_p , CLICAP_SASL ) ) return 0 ; if ( strlen ( client_p -> id ) == 3 ) { exit_client ( client_p , client_p , client_p , "Mixing client and server protocol" ) ; return 0 ; } saslserv_p = find_named_client ( ConfigFileEntry . sasl_service ) ; if ( saslserv_p == NULL || ! IsService ( saslserv_p ) ) { sendto_one ( source_p , form_str ( ERR_SASLABORTED ) , me . name , EmptyString ( source_p -> name ) ? "*" : source_p -> name ) ; return 0 ; } if ( source_p -> localClient -> sasl_complete ) { * source_p -> localClient -> sasl_agent = '\0' ; source_p -> localClient -> sasl_complete = 0 ; } if ( strlen ( parv [ 1 ] ) > 400 ) { sendto_one ( source_p , form_str ( ERR_SASLTOOLONG ) , me . name , EmptyString ( source_p -> name ) ? "*" : source_p -> name ) ; return 0 ; } if ( ! * source_p -> id ) { strcpy ( source_p -> id , generate_uid ( ) ) ; add_to_id_hash ( source_p -> id , source_p ) ; } if ( * source_p -> localClient -> sasl_agent ) agent_p = find_id ( source_p -> localClient -> sasl_agent ) ; if ( agent_p == NULL ) { sendto_one ( saslserv_p , ":%s ENCAP %s SASL %s %s H %s %s" , me . id , saslserv_p -> servptr -> name , source_p -> id , saslserv_p -> id , source_p -> host , source_p -> sockhost ) ; if ( ! strcmp ( parv [ 1 ] , "EXTERNAL" ) && source_p -> certfp != NULL ) sendto_one ( saslserv_p , ":%s ENCAP %s SASL %s %s S %s %s" , me . id , saslserv_p -> servptr -> name , source_p -> id , saslserv_p -> id , parv [ 1 ] , source_p -> certfp ) ; else sendto_one ( saslserv_p , ":%s ENCAP %s SASL %s %s S %s" , me . id , saslserv_p -> servptr -> name , source_p -> id , saslserv_p -> id , parv [ 1 ] ) ; rb_strlcpy ( source_p -> localClient -> sasl_agent , saslserv_p -> id , IDLEN ) ; } else sendto_one ( agent_p , ":%s ENCAP %s SASL %s %s C %s" , me . id , agent_p -> servptr -> name , source_p -> id , agent_p -> id , parv [ 1 ] ) ; source_p -> localClient -> sasl_out ++ ; return 0 ; }

chrome

hb_blob_t * hb_blob_reference ( hb_blob_t * blob ) { return hb_object_reference ( blob ) ; }

debian

static int dissect_h225_BOOLEAN ( tvbuff_t * tvb _U_ , int offset _U_ , asn1_ctx_t * actx _U_ , proto_tree * tree _U_ , int hf_index _U_ ) { offset = dissect_per_boolean ( tvb , offset , actx , tree , hf_index , NULL ) ; return offset ; }

chrome

static void U_CALLCONV ucnv_toUnicode_UTF8 ( UConverterToUnicodeArgs * args , UErrorCode * err ) { UConverter * cnv = args -> converter ; const unsigned char * mySource = ( unsigned char * ) args -> source ; UChar * myTarget = args -> target ; const unsigned char * sourceLimit = ( unsigned char * ) args -> sourceLimit ; const UChar * targetLimit = args -> targetLimit ; unsigned char * toUBytes = cnv -> toUBytes ; UBool isCESU8 = hasCESU8Data ( cnv ) ; uint32_t ch , ch2 = 0 ; int32_t i , inBytes ; if ( cnv -> toUnicodeStatus && myTarget < targetLimit ) { inBytes = cnv -> mode ; i = cnv -> toULength ; cnv -> toULength = 0 ; ch = cnv -> toUnicodeStatus ; cnv -> toUnicodeStatus = 0 ; goto morebytes ; } while ( mySource < sourceLimit && myTarget < targetLimit ) { ch = * ( mySource ++ ) ; if ( ch < 0x80 ) { * ( myTarget ++ ) = ( UChar ) ch ; } else { toUBytes [ 0 ] = ( char ) ch ; inBytes = bytesFromUTF8 [ ch ] ; i = 1 ; morebytes : while ( i < inBytes ) { if ( mySource < sourceLimit ) { toUBytes [ i ] = ( char ) ( ch2 = * mySource ) ; if ( ! U8_IS_TRAIL ( ch2 ) ) { break ; } ch = ( ch << 6 ) + ch2 ; ++ mySource ; i ++ ; } else { cnv -> toUnicodeStatus = ch ; cnv -> mode = inBytes ; cnv -> toULength = ( int8_t ) i ; goto donefornow ; } } ch -= offsetsFromUTF8 [ inBytes ] ; if ( i == inBytes && ch <= MAXIMUM_UTF && ch >= utf8_minChar32 [ i ] && ( isCESU8 ? i <= 3 : ! U_IS_SURROGATE ( ch ) ) ) { if ( ch <= MAXIMUM_UCS2 ) { * ( myTarget ++ ) = ( UChar ) ch ; } else { ch -= HALF_BASE ; * ( myTarget ++ ) = ( UChar ) ( ( ch >> HALF_SHIFT ) + SURROGATE_HIGH_START ) ; ch = ( ch & HALF_MASK ) + SURROGATE_LOW_START ; if ( myTarget < targetLimit ) { * ( myTarget ++ ) = ( UChar ) ch ; } else { cnv -> UCharErrorBuffer [ 0 ] = ( UChar ) ch ; cnv -> UCharErrorBufferLength = 1 ; * err = U_BUFFER_OVERFLOW_ERROR ; break ; } } } else { cnv -> toULength = ( int8_t ) i ; * err = U_ILLEGAL_CHAR_FOUND ; break ; } } } donefornow : if ( mySource < sourceLimit && myTarget >= targetLimit && U_SUCCESS ( * err ) ) { * err = U_BUFFER_OVERFLOW_ERROR ; } args -> target = myTarget ; args -> source = ( const char * ) mySource ; }

debian

static int pfkey_send_policy_notify ( struct xfrm_policy * xp , int dir , const struct km_event * c ) { if ( xp && xp -> type != XFRM_POLICY_TYPE_MAIN ) return 0 ; switch ( c -> event ) { case XFRM_MSG_POLEXPIRE : return key_notify_policy_expire ( xp , c ) ; case XFRM_MSG_DELPOLICY : case XFRM_MSG_NEWPOLICY : case XFRM_MSG_UPDPOLICY : return key_notify_policy ( xp , dir , c ) ; case XFRM_MSG_FLUSHPOLICY : if ( c -> data . type != XFRM_POLICY_TYPE_MAIN ) break ; return key_notify_policy_flush ( c ) ; default : pr_err ( "pfkey: Unknown policy event %d\n" , c -> event ) ; break ; } return 0 ; }

debian

static int test_stdout_behavior ( xd3_stream * stream , int ignore ) { int ret ; char buf [ TESTBUFSIZE ] ; test_setup ( ) ; snprintf_func ( buf , TESTBUFSIZE , "cp /devull %s" , TEST_TARGET_FILE ) ; if ( ( ret = do_cmd ( stream , buf ) ) ) { return ret ; } snprintf_func ( buf , TESTBUFSIZE , "%s -e %s %s" , program_name , TEST_TARGET_FILE , TEST_DELTA_FILE ) ; if ( ( ret = do_cmd ( stream , buf ) ) ) { return ret ; } snprintf_func ( buf , TESTBUFSIZE , "%s -e -c %s > %s" , program_name , TEST_TARGET_FILE , TEST_DELTA_FILE ) ; if ( ( ret = do_cmd ( stream , buf ) ) ) { return ret ; } snprintf_func ( buf , TESTBUFSIZE , "%s -q -d %s " , program_name , TEST_DELTA_FILE ) ; if ( ( ret = do_fail ( stream , buf ) ) ) { return ret ; } snprintf_func ( buf , TESTBUFSIZE , "%s -d -c %s > /devull" , program_name , TEST_DELTA_FILE ) ; if ( ( ret = do_cmd ( stream , buf ) ) ) { return ret ; } test_cleanup ( ) ; return 0 ; }

debian

static int ws_snd_decode_frame ( AVCodecContext * avctx , void * data , int * got_frame_ptr , AVPacket * avpkt ) { AVFrame * frame = data ; const uint8_t * buf = avpkt -> data ; int buf_size = avpkt -> size ; int in_size , out_size , ret ; int sample = 128 ; uint8_t * samples ; uint8_t * samples_end ; if ( ! buf_size ) return 0 ; if ( buf_size < 4 ) { av_log ( avctx , AV_LOG_ERROR , "packet is too small\n" ) ; return AVERROR ( EINVAL ) ; } out_size = AV_RL16 ( & buf [ 0 ] ) ; in_size = AV_RL16 ( & buf [ 2 ] ) ; buf += 4 ; if ( in_size > buf_size ) { av_log ( avctx , AV_LOG_ERROR , "Frame data is larger than input buffer\n" ) ; return - 1 ; } frame -> nb_samples = out_size ; if ( ( ret = ff_get_buffer ( avctx , frame , 0 ) ) < 0 ) { av_log ( avctx , AV_LOG_ERROR , "get_buffer() failed\n" ) ; return ret ; } samples = frame -> data [ 0 ] ; samples_end = samples + out_size ; if ( in_size == out_size ) { memcpy ( samples , buf , out_size ) ; * got_frame_ptr = 1 ; return buf_size ; } while ( samples < samples_end && buf - avpkt -> data < buf_size ) { int code , smp , size ; uint8_t count ; code = * buf >> 6 ; count = * buf & 0x3F ; buf ++ ; switch ( code ) { case 0 : smp = 4 * ( count + 1 ) ; break ; case 1 : smp = 2 * ( count + 1 ) ; break ; case 2 : smp = ( count & 0x20 ) ? 1 : count + 1 ; break ; default : smp = count + 1 ; break ; } if ( samples_end - samples < smp ) break ; size = ( ( code == 2 && ( count & 0x20 ) ) || code == 3 ) ? 0 : count + 1 ; if ( ( buf - avpkt -> data ) + size > buf_size ) break ; switch ( code ) { case 0 : for ( count ++ ; count > 0 ; count -- ) { code = * buf ++ ; sample += ( code & 0x3 ) - 2 ; sample = av_clip_uint8 ( sample ) ; * samples ++ = sample ; sample += ( ( code >> 2 ) & 0x3 ) - 2 ; sample = av_clip_uint8 ( sample ) ; * samples ++ = sample ; sample += ( ( code >> 4 ) & 0x3 ) - 2 ; sample = av_clip_uint8 ( sample ) ; * samples ++ = sample ; sample += ( code >> 6 ) - 2 ; sample = av_clip_uint8 ( sample ) ; * samples ++ = sample ; } break ; case 1 : for ( count ++ ; count > 0 ; count -- ) { code = * buf ++ ; sample += ws_adpcm_4bit [ code & 0xF ] ; sample = av_clip_uint8 ( sample ) ; * samples ++ = sample ; sample += ws_adpcm_4bit [ code >> 4 ] ; sample = av_clip_uint8 ( sample ) ; * samples ++ = sample ; } break ; case 2 : if ( count & 0x20 ) { int8_t t ; t = count ; t <<= 3 ; sample += t >> 3 ; sample = av_clip_uint8 ( sample ) ; * samples ++ = sample ; } else { memcpy ( samples , buf , smp ) ; samples += smp ; buf += smp ; sample = buf [ - 1 ] ; } break ; default : memset ( samples , sample , smp ) ; samples += smp ; } } frame -> nb_samples = samples - frame -> data [ 0 ] ; * got_frame_ptr = 1 ; return buf_size ; }

debian

void TSVConnCacheHttpInfoSet ( TSVConn connp , TSCacheHttpInfo infop ) { sdk_assert ( sdk_sanity_check_iocore_structure ( connp ) == TS_SUCCESS ) ; CacheVC * vc = ( CacheVC * ) connp ; if ( vc -> base_stat == cache_scan_active_stat ) { vc -> set_http_info ( ( CacheHTTPInfo * ) infop ) ; } }

debian

int dissect_ber_bitstring32 ( gboolean implicit_tag , asn1_ctx_t * actx , proto_tree * parent_tree , tvbuff_t * tvb , int offset , int * * bit_fields , gint hf_id , gint ett_id , tvbuff_t * * out_tvb ) { tvbuff_t * tmp_tvb = NULL ; proto_tree * tree ; guint32 val ; int * * bf ; header_field_info * hfi ; const char * sep ; gboolean term ; unsigned int i , tvb_len ; offset = dissect_ber_bitstring ( implicit_tag , actx , parent_tree , tvb , offset , NULL , hf_id , ett_id , & tmp_tvb ) ; tree = proto_item_get_subtree ( actx -> created_item ) ; if ( bit_fields && tree && tmp_tvb ) { val = 0 ; tvb_len = tvb_reported_length ( tmp_tvb ) ; for ( i = 0 ; i < 4 ; i ++ ) { val <<= 8 ; if ( i < tvb_len ) { val |= tvb_get_guint8 ( tmp_tvb , i ) ; } } bf = bit_fields ; sep = " (" ; term = FALSE ; while ( * bf ) { if ( * * bf >= 0 ) { proto_tree_add_boolean ( tree , * * bf , tmp_tvb , 0 , tvb_len , val ) ; hfi = proto_registrar_get_nth ( * * bf ) ; if ( val & hfi -> bitmask ) { proto_item_append_text ( actx -> created_item , "%s%s" , sep , hfi -> name ) ; sep = ", " ; term = TRUE ; } } bf ++ ; } if ( term ) proto_item_append_text ( actx -> created_item , ")" ) ; } if ( out_tvb ) * out_tvb = tmp_tvb ; return offset ; }

debian

static const char * cmd_gsb_lookup_db ( cmd_parms * cmd , void * _dcfg , const char * p1 ) { const char * filename = resolve_relative_path ( cmd -> pool , cmd -> directive -> filename , p1 ) ; char * error_msg ; directory_config * dcfg = ( directory_config * ) _dcfg ; if ( dcfg == NULL ) return NULL ; if ( gsb_db_init ( dcfg , filename , & error_msg ) <= 0 ) { return error_msg ; } return NULL ; }

chrome

static void nonrd_use_partition ( VP9_COMP * cpi , const TileInfo * const tile , MODE_INFO * * mi , TOKENEXTRA * * tp , int mi_row , int mi_col , BLOCK_SIZE bsize , int output_enabled , int * totrate , int64_t * totdist , PC_TREE * pc_tree ) { VP9_COMMON * const cm = & cpi -> common ; MACROBLOCK * const x = & cpi -> mb ; MACROBLOCKD * const xd = & x -> e_mbd ; const int bsl = b_width_log2 ( bsize ) , hbs = ( 1 << bsl ) / 4 ; const int mis = cm -> mi_stride ; PARTITION_TYPE partition ; BLOCK_SIZE subsize ; int rate = INT_MAX ; int64_t dist = INT64_MAX ; if ( mi_row >= cm -> mi_rows || mi_col >= cm -> mi_cols ) return ; subsize = ( bsize >= BLOCK_8X8 ) ? mi [ 0 ] -> mbmi . sb_type : BLOCK_4X4 ; partition = partition_lookup [ bsl ] [ subsize ] ; switch ( partition ) { case PARTITION_NONE : nonrd_pick_sb_modes ( cpi , tile , mi_row , mi_col , totrate , totdist , subsize , & pc_tree -> none ) ; pc_tree -> none . mic . mbmi = xd -> mi [ 0 ] -> mbmi ; pc_tree -> none . skip_txfm [ 0 ] = x -> skip_txfm [ 0 ] ; pc_tree -> none . skip = x -> skip ; break ; case PARTITION_VERT : nonrd_pick_sb_modes ( cpi , tile , mi_row , mi_col , totrate , totdist , subsize , & pc_tree -> vertical [ 0 ] ) ; pc_tree -> vertical [ 0 ] . mic . mbmi = xd -> mi [ 0 ] -> mbmi ; pc_tree -> vertical [ 0 ] . skip_txfm [ 0 ] = x -> skip_txfm [ 0 ] ; pc_tree -> vertical [ 0 ] . skip = x -> skip ; if ( mi_col + hbs < cm -> mi_cols ) { nonrd_pick_sb_modes ( cpi , tile , mi_row , mi_col + hbs , & rate , & dist , subsize , & pc_tree -> vertical [ 1 ] ) ; pc_tree -> vertical [ 1 ] . mic . mbmi = xd -> mi [ 0 ] -> mbmi ; pc_tree -> vertical [ 1 ] . skip_txfm [ 0 ] = x -> skip_txfm [ 0 ] ; pc_tree -> vertical [ 1 ] . skip = x -> skip ; if ( rate != INT_MAX && dist != INT64_MAX && * totrate != INT_MAX && * totdist != INT64_MAX ) { * totrate += rate ; * totdist += dist ; } } break ; case PARTITION_HORZ : nonrd_pick_sb_modes ( cpi , tile , mi_row , mi_col , totrate , totdist , subsize , & pc_tree -> horizontal [ 0 ] ) ; pc_tree -> horizontal [ 0 ] . mic . mbmi = xd -> mi [ 0 ] -> mbmi ; pc_tree -> horizontal [ 0 ] . skip_txfm [ 0 ] = x -> skip_txfm [ 0 ] ; pc_tree -> horizontal [ 0 ] . skip = x -> skip ; if ( mi_row + hbs < cm -> mi_rows ) { nonrd_pick_sb_modes ( cpi , tile , mi_row + hbs , mi_col , & rate , & dist , subsize , & pc_tree -> horizontal [ 0 ] ) ; pc_tree -> horizontal [ 1 ] . mic . mbmi = xd -> mi [ 0 ] -> mbmi ; pc_tree -> horizontal [ 1 ] . skip_txfm [ 0 ] = x -> skip_txfm [ 0 ] ; pc_tree -> horizontal [ 1 ] . skip = x -> skip ; if ( rate != INT_MAX && dist != INT64_MAX && * totrate != INT_MAX && * totdist != INT64_MAX ) { * totrate += rate ; * totdist += dist ; } } break ; case PARTITION_SPLIT : subsize = get_subsize ( bsize , PARTITION_SPLIT ) ; nonrd_use_partition ( cpi , tile , mi , tp , mi_row , mi_col , subsize , output_enabled , totrate , totdist , pc_tree -> split [ 0 ] ) ; nonrd_use_partition ( cpi , tile , mi + hbs , tp , mi_row , mi_col + hbs , subsize , output_enabled , & rate , & dist , pc_tree -> split [ 1 ] ) ; if ( rate != INT_MAX && dist != INT64_MAX && * totrate != INT_MAX && * totdist != INT64_MAX ) { * totrate += rate ; * totdist += dist ; } nonrd_use_partition ( cpi , tile , mi + hbs * mis , tp , mi_row + hbs , mi_col , subsize , output_enabled , & rate , & dist , pc_tree -> split [ 2 ] ) ; if ( rate != INT_MAX && dist != INT64_MAX && * totrate != INT_MAX && * totdist != INT64_MAX ) { * totrate += rate ; * totdist += dist ; } nonrd_use_partition ( cpi , tile , mi + hbs * mis + hbs , tp , mi_row + hbs , mi_col + hbs , subsize , output_enabled , & rate , & dist , pc_tree -> split [ 3 ] ) ; if ( rate != INT_MAX && dist != INT64_MAX && * totrate != INT_MAX && * totdist != INT64_MAX ) { * totrate += rate ; * totdist += dist ; } break ; default : assert ( "Invalid partition type." ) ; break ; } if ( bsize == BLOCK_64X64 && output_enabled ) { if ( cpi -> oxcf . aq_mode == CYCLIC_REFRESH_AQ ) vp9_cyclic_refresh_set_rate_and_dist_sb ( cpi -> cyclic_refresh , * totrate , * totdist ) ; encode_sb_rt ( cpi , tile , tp , mi_row , mi_col , 1 , bsize , pc_tree ) ; } }

debian

static int output_data ( MLPDecodeContext * m , unsigned int substr , AVFrame * frame , int * got_frame_ptr ) { AVCodecContext * avctx = m -> avctx ; SubStream * s = & m -> substream [ substr ] ; unsigned int i , out_ch = 0 ; int32_t * data_32 ; int16_t * data_16 ; int ret ; int is32 = ( m -> avctx -> sample_fmt == AV_SAMPLE_FMT_S32 ) ; if ( m -> avctx -> channels != s -> max_matrix_channel + 1 ) { av_log ( m -> avctx , AV_LOG_ERROR , "channel count mismatch\n" ) ; return AVERROR_INVALIDDATA ; } if ( ! s -> blockpos ) { av_log ( avctx , AV_LOG_ERROR , "No samples to output.\n" ) ; return AVERROR_INVALIDDATA ; } frame -> nb_samples = s -> blockpos ; if ( ( ret = ff_get_buffer ( avctx , frame ) ) < 0 ) { av_log ( avctx , AV_LOG_ERROR , "get_buffer() failed\n" ) ; return ret ; } data_32 = ( int32_t * ) frame -> data [ 0 ] ; data_16 = ( int16_t * ) frame -> data [ 0 ] ; for ( i = 0 ; i < s -> blockpos ; i ++ ) { for ( out_ch = 0 ; out_ch <= s -> max_matrix_channel ; out_ch ++ ) { int mat_ch = s -> ch_assign [ out_ch ] ; int32_t sample = m -> sample_buffer [ i ] [ mat_ch ] << s -> output_shift [ mat_ch ] ; s -> lossless_check_data ^= ( sample & 0xffffff ) << mat_ch ; if ( is32 ) * data_32 ++ = sample << 8 ; else * data_16 ++ = sample >> 8 ; } } * got_frame_ptr = 1 ; return 0 ; }

chrome

int main ( int argc , const char * * argv_ ) { int pass ; vpx_image_t raw ; # if CONFIG_VP9 && CONFIG_VP9_HIGHBITDEPTH vpx_image_t raw_shift ; int allocated_raw_shift = 0 ; int use_16bit_internal = 0 ; int input_shift = 0 ; # endif int frame_avail , got_data ; struct VpxInputContext input ; struct VpxEncoderConfig global ; struct stream_state * streams = NULL ; char * * argv , * * argi ; uint64_t cx_time = 0 ; int stream_cnt = 0 ; int res = 0 ; memset ( & input , 0 , sizeof ( input ) ) ; exec_name = argv_ [ 0 ] ; if ( argc < 3 ) usage_exit ( ) ; input . framerate . numerator = 30 ; input . framerate . denominator = 1 ; input . only_i420 = 1 ; input . bit_depth = 0 ; argv = argv_dup ( argc - 1 , argv_ + 1 ) ; parse_global_config ( & global , argv ) ; switch ( global . color_type ) { case I420 : input . fmt = VPX_IMG_FMT_I420 ; break ; case I422 : input . fmt = VPX_IMG_FMT_I422 ; break ; case I444 : input . fmt = VPX_IMG_FMT_I444 ; break ; case YV12 : input . fmt = VPX_IMG_FMT_YV12 ; break ; } { struct stream_state * stream = NULL ; do { stream = new_stream ( & global , stream ) ; stream_cnt ++ ; if ( ! streams ) streams = stream ; } while ( parse_stream_params ( & global , stream , argv ) ) ; } for ( argi = argv ; * argi ; argi ++ ) if ( argi [ 0 ] [ 0 ] == '-' && argi [ 0 ] [ 1 ] ) die ( "Error: Unrecognized option %s\n" , * argi ) ; FOREACH_STREAM ( check_encoder_config ( global . disable_warning_prompt , & global , & stream -> config . cfg ) ; ) ; input . filename = argv [ 0 ] ; if ( ! input . filename ) usage_exit ( ) ; if ( global . codec -> fourcc == VP9_FOURCC ) input . only_i420 = 0 ; for ( pass = global . pass ? global . pass - 1 : 0 ; pass < global . passes ; pass ++ ) { int frames_in = 0 , seen_frames = 0 ; int64_t estimated_time_left = - 1 ; int64_t average_rate = - 1 ; int64_t lagged_count = 0 ; open_input_file ( & input ) ; if ( ! input . width || ! input . height ) FOREACH_STREAM ( { if ( stream -> config . cfg . g_w && stream -> config . cfg . g_h ) { input . width = stream -> config . cfg . g_w ; input . height = stream -> config . cfg . g_h ; break ; } } ) ; if ( ! input . width || ! input . height ) fatal ( "Specify stream dimensions with --width (-w) " " and --height (-h)" ) ; if ( ! input . bit_depth ) { FOREACH_STREAM ( { if ( stream -> config . cfg . g_input_bit_depth ) input . bit_depth = stream -> config . cfg . g_input_bit_depth ; else input . bit_depth = stream -> config . cfg . g_input_bit_depth = ( int ) stream -> config . cfg . g_bit_depth ; } ) ; if ( input . bit_depth > 8 ) input . fmt |= VPX_IMG_FMT_HIGHBITDEPTH ; } else { FOREACH_STREAM ( { stream -> config . cfg . g_input_bit_depth = input . bit_depth ; } ) ; } FOREACH_STREAM ( set_stream_dimensions ( stream , input . width , input . height ) ) ; FOREACH_STREAM ( validate_stream_config ( stream , & global ) ) ; if ( global . pass && global . passes == 2 ) FOREACH_STREAM ( { if ( ! stream -> config . stats_fn ) die ( "Stream %d: Must specify --fpf when --pass=%d" " and --passes=2\n" , stream -> index , global . pass ) ; } ) ; # if ! CONFIG_WEBM_IO FOREACH_STREAM ( { stream -> config . write_webm = 0 ; warn ( "vpxenc was compiled without WebM container support." "Producing IVF output" ) ; } ) ; # endif if ( ! global . have_framerate ) { global . framerate . num = input . framerate . numerator ; global . framerate . den = input . framerate . denominator ; } FOREACH_STREAM ( set_default_kf_interval ( stream , & global ) ) ; if ( global . verbose && pass == 0 ) FOREACH_STREAM ( show_stream_config ( stream , & global , & input ) ) ; if ( pass == ( global . pass ? global . pass - 1 : 0 ) ) { if ( input . file_type == FILE_TYPE_Y4M ) memset ( & raw , 0 , sizeof ( raw ) ) ; else vpx_img_alloc ( & raw , input . fmt , input . width , input . height , 32 ) ; FOREACH_STREAM ( stream -> rate_hist = init_rate_histogram ( & stream -> config . cfg , & global . framerate ) ) ; } FOREACH_STREAM ( setup_pass ( stream , & global , pass ) ) ; FOREACH_STREAM ( open_output_file ( stream , & global ) ) ; FOREACH_STREAM ( initialize_encoder ( stream , & global ) ) ; # if CONFIG_VP9 && CONFIG_VP9_HIGHBITDEPTH if ( strcmp ( global . codec -> name , "vp9" ) == 0 ) { FOREACH_STREAM ( { if ( stream -> config . use_16bit_internal ) { use_16bit_internal = 1 ; } if ( stream -> config . cfg . g_profile == 0 ) { input_shift = 0 ; } else { input_shift = ( int ) stream -> config . cfg . g_bit_depth - stream -> config . cfg . g_input_bit_depth ; } } ) ; } # endif frame_avail = 1 ; got_data = 0 ; while ( frame_avail || got_data ) { struct vpx_usec_timer timer ; if ( ! global . limit || frames_in < global . limit ) { frame_avail = read_frame ( & input , & raw ) ; if ( frame_avail ) frames_in ++ ; seen_frames = frames_in > global . skip_frames ? frames_in - global . skip_frames : 0 ; if ( ! global . quiet ) { float fps = usec_to_fps ( cx_time , seen_frames ) ; fprintf ( stderr , "\rPass %d/%d " , pass + 1 , global . passes ) ; if ( stream_cnt == 1 ) fprintf ( stderr , "frame %4d/%-4d %7" PRId64 "B " , frames_in , streams -> frames_out , ( int64_t ) streams -> nbytes ) ; else fprintf ( stderr , "frame %4d " , frames_in ) ; fprintf ( stderr , "%7" PRId64 " %s %.2f %s " , cx_time > 9999999 ? cx_time / 1000 : cx_time , cx_time > 9999999 ? "ms" : "us" , fps >= 1.0 ? fps : fps * 60 , fps >= 1.0 ? "fps" : "fpm" ) ; print_time ( "ETA" , estimated_time_left ) ; } } else frame_avail = 0 ; if ( frames_in > global . skip_frames ) { # if CONFIG_VP9 && CONFIG_VP9_HIGHBITDEPTH vpx_image_t * frame_to_encode ; if ( input_shift || ( use_16bit_internal && input . bit_depth == 8 ) ) { assert ( use_16bit_internal ) ; if ( ! allocated_raw_shift ) { vpx_img_alloc ( & raw_shift , raw . fmt | VPX_IMG_FMT_HIGHBITDEPTH , input . width , input . height , 32 ) ; allocated_raw_shift = 1 ; } img_upshift ( & raw_shift , & raw , input_shift ) ; frame_to_encode = & raw_shift ; } else { frame_to_encode = & raw ; } vpx_usec_timer_start ( & timer ) ; if ( use_16bit_internal ) { assert ( frame_to_encode -> fmt & VPX_IMG_FMT_HIGHBITDEPTH ) ; FOREACH_STREAM ( { if ( stream -> config . use_16bit_internal ) encode_frame ( stream , & global , frame_avail ? frame_to_encode : NULL , frames_in ) ; else assert ( 0 ) ; } ) ; } else { assert ( ( frame_to_encode -> fmt & VPX_IMG_FMT_HIGHBITDEPTH ) == 0 ) ; FOREACH_STREAM ( encode_frame ( stream , & global , frame_avail ? frame_to_encode : NULL , frames_in ) ) ; } # else vpx_usec_timer_start ( & timer ) ; FOREACH_STREAM ( encode_frame ( stream , & global , frame_avail ? & raw : NULL , frames_in ) ) ; # endif vpx_usec_timer_mark ( & timer ) ; cx_time += vpx_usec_timer_elapsed ( & timer ) ; FOREACH_STREAM ( update_quantizer_histogram ( stream ) ) ; got_data = 0 ; FOREACH_STREAM ( get_cx_data ( stream , & global , & got_data ) ) ; if ( ! got_data && input . length && streams != NULL && ! streams -> frames_out ) { lagged_count = global . limit ? seen_frames : ftello ( input . file ) ; } else if ( input . length ) { int64_t remaining ; int64_t rate ; if ( global . limit ) { const int64_t frame_in_lagged = ( seen_frames - lagged_count ) * 1000 ; rate = cx_time ? frame_in_lagged * ( int64_t ) 1000000 / cx_time : 0 ; remaining = 1000 * ( global . limit - global . skip_frames - seen_frames + lagged_count ) ; } else { const int64_t input_pos = ftello ( input . file ) ; const int64_t input_pos_lagged = input_pos - lagged_count ; const int64_t limit = input . length ; rate = cx_time ? input_pos_lagged * ( int64_t ) 1000000 / cx_time : 0 ; remaining = limit - input_pos + lagged_count ; } average_rate = ( average_rate <= 0 ) ? rate : ( average_rate * 7 + rate ) / 8 ; estimated_time_left = average_rate ? remaining / average_rate : - 1 ; } if ( got_data && global . test_decode != TEST_DECODE_OFF ) FOREACH_STREAM ( test_decode ( stream , global . test_decode , global . codec ) ) ; } fflush ( stdout ) ; if ( ! global . quiet ) fprintf ( stderr , "\033[K" ) ; } if ( stream_cnt > 1 ) fprintf ( stderr , "\n" ) ; if ( ! global . quiet ) FOREACH_STREAM ( fprintf ( stderr , "\rPass %d/%d frame %4d/%-4d %7" PRId64 "B %7lub/f %7" PRId64 "b/s" " %7" PRId64 " %s (%.2f fps)\033[K\n" , pass + 1 , global . passes , frames_in , stream -> frames_out , ( int64_t ) stream -> nbytes , seen_frames ? ( unsigned long ) ( stream -> nbytes * 8 / seen_frames ) : 0 , seen_frames ? ( int64_t ) stream -> nbytes * 8 * ( int64_t ) global . framerate . num / global . framerate . den / seen_frames : 0 , stream -> cx_time > 9999999 ? stream -> cx_time / 1000 : stream -> cx_time , stream -> cx_time > 9999999 ? "ms" : "us" , usec_to_fps ( stream -> cx_time , seen_frames ) ) ; ) ; if ( global . show_psnr ) FOREACH_STREAM ( show_psnr ( stream ) ) ; FOREACH_STREAM ( vpx_codec_destroy ( & stream -> encoder ) ) ; if ( global . test_decode != TEST_DECODE_OFF ) { FOREACH_STREAM ( vpx_codec_destroy ( & stream -> decoder ) ) ; } close_input_file ( & input ) ; if ( global . test_decode == TEST_DECODE_FATAL ) { FOREACH_STREAM ( res |= stream -> mismatch_seen ) ; } FOREACH_STREAM ( close_output_file ( stream , global . codec -> fourcc ) ) ; FOREACH_STREAM ( stats_close ( & stream -> stats , global . passes - 1 ) ) ; # if CONFIG_FP_MB_STATS FOREACH_STREAM ( stats_close ( & stream -> fpmb_stats , global . passes - 1 ) ) ; # endif if ( global . pass ) break ; } if ( global . show_q_hist_buckets ) FOREACH_STREAM ( show_q_histogram ( stream -> counts , global . show_q_hist_buckets ) ) ; if ( global . show_rate_hist_buckets ) FOREACH_STREAM ( show_rate_histogram ( stream -> rate_hist , & stream -> config . cfg , global . show_rate_hist_buckets ) ) ; FOREACH_STREAM ( destroy_rate_histogram ( stream -> rate_hist ) ) ; # if CONFIG_INTERNAL_STATS if ( ! ( global . pass == 1 && global . passes == 2 ) ) FOREACH_STREAM ( { FILE * f = fopen ( "opsnr.stt" , "a" ) ; if ( stream -> mismatch_seen ) { fprintf ( f , "First mismatch occurred in frame %d\n" , stream -> mismatch_seen ) ; } else { fprintf ( f , "No mismatch detected in recon buffers\n" ) ; } fclose ( f ) ; } ) ; # endif # if CONFIG_VP9 && CONFIG_VP9_HIGHBITDEPTH if ( allocated_raw_shift ) vpx_img_free ( & raw_shift ) ; # endif vpx_img_free ( & raw ) ; free ( argv ) ; free ( streams ) ; return res ? EXIT_FAILURE : EXIT_SUCCESS ; }

chrome

const xmlChar * xsltEvalStaticAttrValueTemplate ( xsltStylesheetPtr style , xmlNodePtr inst , const xmlChar * name , const xmlChar * ns , int * found ) { const xmlChar * ret ; xmlChar * expr ; if ( ( style == NULL ) || ( inst == NULL ) || ( name == NULL ) ) return ( NULL ) ; expr = xsltGetNsProp ( inst , name , ns ) ; if ( expr == NULL ) { * found = 0 ; return ( NULL ) ; } * found = 1 ; ret = xmlStrchr ( expr , '{ ' ) ; if ( ret != NULL ) { xmlFree ( expr ) ; return ( NULL ) ; } ret = xmlDictLookup ( style -> dict , expr , - 1 ) ; xmlFree ( expr ) ; return ( ret ) ; }

debian

static int dissect_h245_ConferenceIndication ( 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_ConferenceIndication , ConferenceIndication_choice , NULL ) ; return offset ; }

chrome

TEST_F ( TemplateURLTest , URLRefTestEncoding2 ) { TemplateURLData data ; data . SetURL ( "http://foo{ searchTerms} x{ inputEncoding} y{ outputEncoding} a" ) ; TemplateURL url ( data ) ; EXPECT_TRUE ( url . url_ref ( ) . IsValid ( search_terms_data_ ) ) ; ASSERT_TRUE ( url . url_ref ( ) . SupportsReplacement ( search_terms_data_ ) ) ; GURL result ( url . url_ref ( ) . ReplaceSearchTerms ( TemplateURLRef : : SearchTermsArgs ( ASCIIToUTF16 ( "X" ) ) , search_terms_data_ ) ) ; ASSERT_TRUE ( result . is_valid ( ) ) ; EXPECT_EQ ( "http://fooxxutf-8yutf-8a/" , result . spec ( ) ) ; }

chrome

hb_face_t * hb_face_create_for_tables ( hb_reference_table_func_t reference_table_func , void * user_data , hb_destroy_func_t destroy ) { hb_face_t * face ; if ( ! reference_table_func || ! ( face = hb_object_create < hb_face_t > ( ) ) ) { if ( destroy ) destroy ( user_data ) ; return hb_face_get_empty ( ) ; } face -> reference_table_func = reference_table_func ; face -> user_data = user_data ; face -> destroy = destroy ; face -> upem = 0 ; face -> num_glyphs = ( unsigned int ) - 1 ; return face ; }

chrome

static void update_reference_segmentation_map ( VP9_COMP * cpi ) { VP9_COMMON * const cm = & cpi -> common ; MODE_INFO * mi_8x8_ptr = cm -> mi ; uint8_t * cache_ptr = cm -> last_frame_seg_map ; int row , col ; for ( row = 0 ; row < cm -> mi_rows ; row ++ ) { MODE_INFO * mi_8x8 = mi_8x8_ptr ; uint8_t * cache = cache_ptr ; for ( col = 0 ; col < cm -> mi_cols ; col ++ , mi_8x8 ++ , cache ++ ) cache [ 0 ] = mi_8x8 [ 0 ] . src_mi -> mbmi . segment_id ; mi_8x8_ptr += cm -> mi_stride ; cache_ptr += cm -> mi_cols ; } }

debian

int ff_msmpeg4_decode_picture_header ( MpegEncContext * s ) { int code ; if ( s -> msmpeg4_version == 1 ) { int start_code = get_bits_long ( & s -> gb , 32 ) ; if ( start_code != 0x00000100 ) { av_log ( s -> avctx , AV_LOG_ERROR , "invalid startcode\n" ) ; return - 1 ; } skip_bits ( & s -> gb , 5 ) ; } s -> pict_type = get_bits ( & s -> gb , 2 ) + 1 ; if ( s -> pict_type != AV_PICTURE_TYPE_I && s -> pict_type != AV_PICTURE_TYPE_P ) { av_log ( s -> avctx , AV_LOG_ERROR , "invalid picture type\n" ) ; return - 1 ; } # if 0 { static int had_i = 0 ; if ( s -> pict_type == AV_PICTURE_TYPE_I ) had_i = 1 ; if ( ! had_i ) return - 1 ; } # endif s -> chroma_qscale = s -> qscale = get_bits ( & s -> gb , 5 ) ; if ( s -> qscale == 0 ) { av_log ( s -> avctx , AV_LOG_ERROR , "invalid qscale\n" ) ; return - 1 ; } if ( s -> pict_type == AV_PICTURE_TYPE_I ) { code = get_bits ( & s -> gb , 5 ) ; if ( s -> msmpeg4_version == 1 ) { if ( code == 0 || code > s -> mb_height ) { av_log ( s -> avctx , AV_LOG_ERROR , "invalid slice height %d\n" , code ) ; return - 1 ; } s -> slice_height = code ; } else { if ( code < 0x17 ) { av_log ( s -> avctx , AV_LOG_ERROR , "error, slice code was %X\n" , code ) ; return - 1 ; } s -> slice_height = s -> mb_height / ( code - 0x16 ) ; } switch ( s -> msmpeg4_version ) { case 1 : case 2 : s -> rl_chroma_table_index = 2 ; s -> rl_table_index = 2 ; s -> dc_table_index = 0 ; / ot used break ; case 3 : s -> rl_chroma_table_index = decode012 ( & s -> gb ) ; s -> rl_table_index = decode012 ( & s -> gb ) ; s -> dc_table_index = get_bits1 ( & s -> gb ) ; break ; case 4 : ff_msmpeg4_decode_ext_header ( s , ( 2 + 5 + 5 + 17 + 7 ) / 8 ) ; if ( s -> bit_rate > MBAC_BITRATE ) s -> per_mb_rl_table = get_bits1 ( & s -> gb ) ; else s -> per_mb_rl_table = 0 ; if ( ! s -> per_mb_rl_table ) { s -> rl_chroma_table_index = decode012 ( & s -> gb ) ; s -> rl_table_index = decode012 ( & s -> gb ) ; } s -> dc_table_index = get_bits1 ( & s -> gb ) ; s -> inter_intra_pred = 0 ; break ; } s -> no_rounding = 1 ; if ( s -> avctx -> debug & FF_DEBUG_PICT_INFO ) av_log ( s -> avctx , AV_LOG_DEBUG , "qscale:%d rlc:%d rl:%d dc:%d mbrl:%d slice:%d \n" , s -> qscale , s -> rl_chroma_table_index , s -> rl_table_index , s -> dc_table_index , s -> per_mb_rl_table , s -> slice_height ) ; } else { switch ( s -> msmpeg4_version ) { case 1 : case 2 : if ( s -> msmpeg4_version == 1 ) s -> use_skip_mb_code = 1 ; else s -> use_skip_mb_code = get_bits1 ( & s -> gb ) ; s -> rl_table_index = 2 ; s -> rl_chroma_table_index = s -> rl_table_index ; s -> dc_table_index = 0 ; / ot used s -> mv_table_index = 0 ; break ; case 3 : s -> use_skip_mb_code = get_bits1 ( & s -> gb ) ; s -> rl_table_index = decode012 ( & s -> gb ) ; s -> rl_chroma_table_index = s -> rl_table_index ; s -> dc_table_index = get_bits1 ( & s -> gb ) ; s -> mv_table_index = get_bits1 ( & s -> gb ) ; break ; case 4 : s -> use_skip_mb_code = get_bits1 ( & s -> gb ) ; if ( s -> bit_rate > MBAC_BITRATE ) s -> per_mb_rl_table = get_bits1 ( & s -> gb ) ; else s -> per_mb_rl_table = 0 ; if ( ! s -> per_mb_rl_table ) { s -> rl_table_index = decode012 ( & s -> gb ) ; s -> rl_chroma_table_index = s -> rl_table_index ; } s -> dc_table_index = get_bits1 ( & s -> gb ) ; s -> mv_table_index = get_bits1 ( & s -> gb ) ; s -> inter_intra_pred = ( s -> width * s -> height < 320 * 240 && s -> bit_rate <= II_BITRATE ) ; break ; } if ( s -> avctx -> debug & FF_DEBUG_PICT_INFO ) av_log ( s -> avctx , AV_LOG_DEBUG , "skip:%d rl:%d rlc:%d dc:%d mv:%d mbrl:%d qp:%d \n" , s -> use_skip_mb_code , s -> rl_table_index , s -> rl_chroma_table_index , s -> dc_table_index , s -> mv_table_index , s -> per_mb_rl_table , s -> qscale ) ; if ( s -> flipflop_rounding ) { s -> no_rounding ^= 1 ; } else { s -> no_rounding = 0 ; } } av_dlog ( s -> avctx , "%d %d %d %d %d\n" , s -> pict_type , s -> bit_rate , s -> inter_intra_pred , s -> width , s -> height ) ; s -> esc3_level_length = 0 ; s -> esc3_run_length = 0 ; return 0 ; }

debian

static void test_read_format_mtree1 ( void ) { const char reffile [ ] = "test_read_format_mtree.mtree" ; char buff [ 16 ] ; struct archive_entry * ae ; struct archive * a ; FILE * f ; static const long long max_int64 = ( ( ( ( long long ) 1 ) << 62 ) - 1 ) + ( ( ( long long ) 1 ) << 62 ) ; time_t min_time ; volatile time_t t ; extract_reference_file ( reffile ) ; assertMakeDir ( "dir" , 0775 ) ; assertMakeDir ( "dir2" , 0775 ) ; assert ( ( a = archive_read_new ( ) ) != NULL ) ; assertEqualIntA ( a , ARCHIVE_OK , archive_read_support_filter_all ( a ) ) ; assertEqualIntA ( a , ARCHIVE_OK , archive_read_support_format_all ( a ) ) ; assertEqualIntA ( a , ARCHIVE_OK , archive_read_set_options ( a , "mtree:checkfs" ) ) ; assertEqualIntA ( a , ARCHIVE_OK , archive_read_open_filename ( a , reffile , 11 ) ) ; f = fopen ( "file" , "wb" ) ; assert ( f != NULL ) ; assertEqualInt ( 3 , fwrite ( "hi\n" , 1 , 3 , f ) ) ; fclose ( f ) ; assertEqualIntA ( a , ARCHIVE_OK , archive_read_next_header ( a , & ae ) ) ; assertEqualInt ( archive_format ( a ) , ARCHIVE_FORMAT_MTREE ) ; assertEqualString ( archive_entry_pathname ( ae ) , "file" ) ; assertEqualInt ( archive_entry_uid ( ae ) , 18 ) ; assertEqualInt ( AE_IFREG , archive_entry_filetype ( ae ) ) ; assertEqualInt ( archive_entry_mode ( ae ) , AE_IFREG | 0123 ) ; assertEqualInt ( archive_entry_size ( ae ) , 3 ) ; assertEqualInt ( 3 , archive_read_data ( a , buff , 3 ) ) ; assertEqualMem ( buff , "hi\n" , 3 ) ; assertEqualInt ( archive_entry_is_encrypted ( ae ) , 0 ) ; assertEqualIntA ( a , archive_read_has_encrypted_entries ( a ) , ARCHIVE_READ_FORMAT_ENCRYPTION_UNSUPPORTED ) ; assertEqualIntA ( a , ARCHIVE_OK , archive_read_next_header ( a , & ae ) ) ; assertEqualString ( archive_entry_pathname ( ae ) , "dir" ) ; assertEqualInt ( AE_IFDIR , archive_entry_filetype ( ae ) ) ; assertEqualInt ( archive_entry_is_encrypted ( ae ) , 0 ) ; assertEqualIntA ( a , archive_read_has_encrypted_entries ( a ) , ARCHIVE_READ_FORMAT_ENCRYPTION_UNSUPPORTED ) ; assertEqualIntA ( a , ARCHIVE_OK , archive_read_next_header ( a , & ae ) ) ; assertEqualString ( archive_entry_pathname ( ae ) , "dir/file with space" ) ; assertEqualInt ( archive_entry_is_encrypted ( ae ) , 0 ) ; assertEqualIntA ( a , archive_read_has_encrypted_entries ( a ) , ARCHIVE_READ_FORMAT_ENCRYPTION_UNSUPPORTED ) ; assertEqualIntA ( a , ARCHIVE_OK , archive_read_next_header ( a , & ae ) ) ; assertEqualString ( archive_entry_pathname ( ae ) , "file with space" ) ; assertEqualInt ( archive_entry_is_encrypted ( ae ) , 0 ) ; assertEqualIntA ( a , archive_read_has_encrypted_entries ( a ) , ARCHIVE_READ_FORMAT_ENCRYPTION_UNSUPPORTED ) ; assertEqualIntA ( a , ARCHIVE_OK , archive_read_next_header ( a , & ae ) ) ; assertEqualString ( archive_entry_pathname ( ae ) , "dir2" ) ; assertEqualInt ( archive_entry_is_encrypted ( ae ) , 0 ) ; assertEqualIntA ( a , archive_read_has_encrypted_entries ( a ) , ARCHIVE_READ_FORMAT_ENCRYPTION_UNSUPPORTED ) ; assertEqualIntA ( a , ARCHIVE_OK , archive_read_next_header ( a , & ae ) ) ; assertEqualString ( archive_entry_pathname ( ae ) , "dir2/dir3a" ) ; assertEqualInt ( archive_entry_is_encrypted ( ae ) , 0 ) ; assertEqualIntA ( a , archive_read_has_encrypted_entries ( a ) , ARCHIVE_READ_FORMAT_ENCRYPTION_UNSUPPORTED ) ; assertEqualIntA ( a , ARCHIVE_OK , archive_read_next_header ( a , & ae ) ) ; assertEqualString ( archive_entry_pathname ( ae ) , "dir2/dir3a/indir3a" ) ; assertEqualInt ( archive_entry_is_encrypted ( ae ) , 0 ) ; assertEqualIntA ( a , archive_read_has_encrypted_entries ( a ) , ARCHIVE_READ_FORMAT_ENCRYPTION_UNSUPPORTED ) ; assertEqualIntA ( a , ARCHIVE_OK , archive_read_next_header ( a , & ae ) ) ; assertEqualString ( archive_entry_pathname ( ae ) , "dir2/fullindir2" ) ; assertEqualInt ( archive_entry_mode ( ae ) , AE_IFREG | 0644 ) ; assertEqualInt ( archive_entry_is_encrypted ( ae ) , 0 ) ; assertEqualIntA ( a , archive_read_has_encrypted_entries ( a ) , ARCHIVE_READ_FORMAT_ENCRYPTION_UNSUPPORTED ) ; assertEqualIntA ( a , ARCHIVE_OK , archive_read_next_header ( a , & ae ) ) ; assertEqualString ( archive_entry_pathname ( ae ) , "dir2/indir2" ) ; assertEqualInt ( archive_entry_is_encrypted ( ae ) , 0 ) ; assertEqualIntA ( a , archive_read_has_encrypted_entries ( a ) , ARCHIVE_READ_FORMAT_ENCRYPTION_UNSUPPORTED ) ; assertEqualIntA ( a , ARCHIVE_OK , archive_read_next_header ( a , & ae ) ) ; assertEqualString ( archive_entry_pathname ( ae ) , "dir2/dir3b" ) ; assertEqualInt ( archive_entry_is_encrypted ( ae ) , 0 ) ; assertEqualIntA ( a , archive_read_has_encrypted_entries ( a ) , ARCHIVE_READ_FORMAT_ENCRYPTION_UNSUPPORTED ) ; assertEqualIntA ( a , ARCHIVE_OK , archive_read_next_header ( a , & ae ) ) ; assertEqualString ( archive_entry_pathname ( ae ) , "dir2/dir3b/indir3b" ) ; assertEqualInt ( archive_entry_is_encrypted ( ae ) , 0 ) ; assertEqualIntA ( a , archive_read_has_encrypted_entries ( a ) , ARCHIVE_READ_FORMAT_ENCRYPTION_UNSUPPORTED ) ; assertEqualIntA ( a , ARCHIVE_OK , archive_read_next_header ( a , & ae ) ) ; assertEqualString ( archive_entry_pathname ( ae ) , "notindir" ) ; assertEqualInt ( archive_entry_is_encrypted ( ae ) , 0 ) ; assertEqualIntA ( a , archive_read_has_encrypted_entries ( a ) , ARCHIVE_READ_FORMAT_ENCRYPTION_UNSUPPORTED ) ; assertEqualIntA ( a , ARCHIVE_OK , archive_read_next_header ( a , & ae ) ) ; assertEqualString ( archive_entry_pathname ( ae ) , "dir2/emptyfile" ) ; assertEqualInt ( archive_entry_size ( ae ) , 0 ) ; assertEqualInt ( archive_entry_is_encrypted ( ae ) , 0 ) ; assertEqualIntA ( a , archive_read_has_encrypted_entries ( a ) , ARCHIVE_READ_FORMAT_ENCRYPTION_UNSUPPORTED ) ; assertEqualIntA ( a , ARCHIVE_OK , archive_read_next_header ( a , & ae ) ) ; assertEqualString ( archive_entry_pathname ( ae ) , "dir2/smallfile" ) ; assertEqualInt ( archive_entry_size ( ae ) , 1 ) ; assertEqualInt ( archive_entry_is_encrypted ( ae ) , 0 ) ; assertEqualIntA ( a , archive_read_has_encrypted_entries ( a ) , ARCHIVE_READ_FORMAT_ENCRYPTION_UNSUPPORTED ) ; assertEqualIntA ( a , ARCHIVE_OK , archive_read_next_header ( a , & ae ) ) ; assertEqualString ( archive_entry_pathname ( ae ) , "dir2/toosmallfile" ) ; assertEqualInt ( archive_entry_size ( ae ) , - 1 ) ; assertEqualInt ( archive_entry_is_encrypted ( ae ) , 0 ) ; assertEqualIntA ( a , archive_read_has_encrypted_entries ( a ) , ARCHIVE_READ_FORMAT_ENCRYPTION_UNSUPPORTED ) ; assertEqualIntA ( a , ARCHIVE_OK , archive_read_next_header ( a , & ae ) ) ; assertEqualString ( archive_entry_pathname ( ae ) , "dir2/bigfile" ) ; assertEqualInt ( archive_entry_size ( ae ) , max_int64 ) ; assertEqualInt ( archive_entry_is_encrypted ( ae ) , 0 ) ; assertEqualIntA ( a , archive_read_has_encrypted_entries ( a ) , ARCHIVE_READ_FORMAT_ENCRYPTION_UNSUPPORTED ) ; assertEqualIntA ( a , ARCHIVE_OK , archive_read_next_header ( a , & ae ) ) ; assertEqualString ( archive_entry_pathname ( ae ) , "dir2/toobigfile" ) ; assertEqualInt ( archive_entry_size ( ae ) , max_int64 ) ; assertEqualInt ( archive_entry_is_encrypted ( ae ) , 0 ) ; assertEqualIntA ( a , archive_read_has_encrypted_entries ( a ) , ARCHIVE_READ_FORMAT_ENCRYPTION_UNSUPPORTED ) ; assertEqualIntA ( a , ARCHIVE_OK , archive_read_next_header ( a , & ae ) ) ; assertEqualString ( archive_entry_pathname ( ae ) , "dir2/veryoldfile" ) ; min_time = archive_entry_mtime ( ae ) ; assert ( min_time <= 0 ) ; t = min_time - 1 ; assert ( t > 0 ) ; assertEqualInt ( archive_entry_is_encrypted ( ae ) , 0 ) ; assertEqualIntA ( a , archive_read_has_encrypted_entries ( a ) , ARCHIVE_READ_FORMAT_ENCRYPTION_UNSUPPORTED ) ; assertEqualIntA ( a , ARCHIVE_OK , archive_read_next_header ( a , & ae ) ) ; assertEqualString ( archive_entry_pathname ( ae ) , "dir2/toooldfile" ) ; assertEqualInt ( archive_entry_mtime ( ae ) , min_time ) ; assertEqualInt ( archive_entry_is_encrypted ( ae ) , 0 ) ; assertEqualIntA ( a , archive_read_has_encrypted_entries ( a ) , ARCHIVE_READ_FORMAT_ENCRYPTION_UNSUPPORTED ) ; assertEqualIntA ( a , ARCHIVE_EOF , archive_read_next_header ( a , & ae ) ) ; assertEqualInt ( 19 , archive_file_count ( a ) ) ; assertEqualInt ( ARCHIVE_OK , archive_read_close ( a ) ) ; assertEqualInt ( ARCHIVE_OK , archive_read_free ( a ) ) ; }

chrome

IN_PROC_BROWSER_TEST_F ( UnloadTest , BrowserListForceCloseNoUnloadListeners ) { NavigateToDataURL ( NOLISTENERS_HTML , "nolisteners" ) ; 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 ( ) ) ; }

debian

void spl_filesystem_info_set_filename ( spl_filesystem_object * intern , char * path , int len , int use_copy TSRMLS_DC ) { char * p1 , * p2 ; if ( intern -> file_name ) { efree ( intern -> file_name ) ; } intern -> file_name = use_copy ? estrndup ( path , len ) : path ; intern -> file_name_len = len ; while ( IS_SLASH_AT ( intern -> file_name , intern -> file_name_len - 1 ) && intern -> file_name_len > 1 ) { intern -> file_name [ intern -> file_name_len - 1 ] = 0 ; intern -> file_name_len -- ; } p1 = strrchr ( intern -> file_name , '/' ) ; # if defined ( PHP_WIN32 ) || defined ( NETWARE ) p2 = strrchr ( intern -> file_name , '\\' ) ; # else p2 = 0 ; # endif if ( p1 || p2 ) { intern -> _path_len = ( p1 > p2 ? p1 : p2 ) - intern -> file_name ; } else { intern -> _path_len = 0 ; } if ( intern -> _path ) { efree ( intern -> _path ) ; } intern -> _path = estrndup ( path , intern -> _path_len ) ; }

chrome

int vp8_denoiser_filter_uv_c ( unsigned char * mc_running_avg_uv , int mc_avg_uv_stride , unsigned char * running_avg_uv , int avg_uv_stride , unsigned char * sig , int sig_stride , unsigned int motion_magnitude , int increase_denoising ) { unsigned char * running_avg_uv_start = running_avg_uv ; unsigned char * sig_start = sig ; int sum_diff_thresh ; int r , c ; int sum_diff = 0 ; int sum_block = 0 ; int adj_val [ 3 ] = { 3 , 4 , 6 } ; int shift_inc1 = 0 ; int shift_inc2 = 1 ; if ( motion_magnitude <= MOTION_MAGNITUDE_THRESHOLD_UV ) { if ( increase_denoising ) { shift_inc1 = 1 ; shift_inc2 = 2 ; } adj_val [ 0 ] += shift_inc2 ; adj_val [ 1 ] += shift_inc2 ; adj_val [ 2 ] += shift_inc2 ; } for ( r = 0 ; r < 8 ; ++ r ) { for ( c = 0 ; c < 8 ; ++ c ) { sum_block += sig [ c ] ; } sig += sig_stride ; } if ( abs ( sum_block - ( 128 * 8 * 8 ) ) < SUM_DIFF_FROM_AVG_THRESH_UV ) { return COPY_BLOCK ; } sig -= sig_stride * 8 ; for ( r = 0 ; r < 8 ; ++ r ) { for ( c = 0 ; c < 8 ; ++ c ) { int diff = 0 ; int adjustment = 0 ; int absdiff = 0 ; diff = mc_running_avg_uv [ c ] - sig [ c ] ; absdiff = abs ( diff ) ; if ( absdiff <= 3 + shift_inc1 ) { running_avg_uv [ c ] = mc_running_avg_uv [ c ] ; sum_diff += diff ; } else { if ( absdiff >= 4 && absdiff <= 7 ) adjustment = adj_val [ 0 ] ; else if ( absdiff >= 8 && absdiff <= 15 ) adjustment = adj_val [ 1 ] ; else adjustment = adj_val [ 2 ] ; if ( diff > 0 ) { if ( ( sig [ c ] + adjustment ) > 255 ) running_avg_uv [ c ] = 255 ; else running_avg_uv [ c ] = sig [ c ] + adjustment ; sum_diff += adjustment ; } else { if ( ( sig [ c ] - adjustment ) < 0 ) running_avg_uv [ c ] = 0 ; else running_avg_uv [ c ] = sig [ c ] - adjustment ; sum_diff -= adjustment ; } } } sig += sig_stride ; mc_running_avg_uv += mc_avg_uv_stride ; running_avg_uv += avg_uv_stride ; } sum_diff_thresh = SUM_DIFF_THRESHOLD_UV ; if ( increase_denoising ) sum_diff_thresh = SUM_DIFF_THRESHOLD_HIGH_UV ; if ( abs ( sum_diff ) > sum_diff_thresh ) { int delta = ( ( abs ( sum_diff ) - sum_diff_thresh ) >> 8 ) + 1 ; if ( delta < 4 ) { sig -= sig_stride * 8 ; mc_running_avg_uv -= mc_avg_uv_stride * 8 ; running_avg_uv -= avg_uv_stride * 8 ; for ( r = 0 ; r < 8 ; ++ r ) { for ( c = 0 ; c < 8 ; ++ c ) { int diff = mc_running_avg_uv [ c ] - sig [ c ] ; int adjustment = abs ( diff ) ; if ( adjustment > delta ) adjustment = delta ; if ( diff > 0 ) { if ( running_avg_uv [ c ] - adjustment < 0 ) running_avg_uv [ c ] = 0 ; else running_avg_uv [ c ] = running_avg_uv [ c ] - adjustment ; sum_diff -= adjustment ; } else if ( diff < 0 ) { if ( running_avg_uv [ c ] + adjustment > 255 ) running_avg_uv [ c ] = 255 ; else running_avg_uv [ c ] = running_avg_uv [ c ] + adjustment ; sum_diff += adjustment ; } } sig += sig_stride ; mc_running_avg_uv += mc_avg_uv_stride ; running_avg_uv += avg_uv_stride ; } if ( abs ( sum_diff ) > sum_diff_thresh ) return COPY_BLOCK ; } else { return COPY_BLOCK ; } } vp8_copy_mem8x8 ( running_avg_uv_start , avg_uv_stride , sig_start , sig_stride ) ; return FILTER_BLOCK ; }

debian

void mime_field_value_set ( HdrHeap * heap , MIMEHdrImpl * mh , MIMEField * field , const char * value , int length , bool must_copy_string ) { heap -> free_string ( field -> m_ptr_value , field -> m_len_value ) ; if ( must_copy_string && value ) { field -> m_ptr_value = heap -> duplicate_str ( value , length ) ; } else { field -> m_ptr_value = value ; } field -> m_len_value = length ; field -> m_n_v_raw_printable = 0 ; if ( field -> is_live ( ) && field -> is_cooked ( ) ) { mh -> recompute_cooked_stuff ( field ) ; } }

debian

static int dissect_h245_OLC_ack_reverseLogicalChannelParameters ( tvbuff_t * tvb _U_ , int offset _U_ , asn1_ctx_t * actx _U_ , proto_tree * tree _U_ , int hf_index _U_ ) { offset = dissect_per_sequence ( tvb , offset , actx , tree , hf_index , ett_h245_OLC_ack_reverseLogicalChannelParameters , OLC_ack_reverseLogicalChannelParameters_sequence ) ; return offset ; }

debian

static void alloc_objects ( unsigned int cnt ) { struct object_entry_pool * b ; b = xmalloc ( sizeof ( struct object_entry_pool ) + cnt * sizeof ( struct object_entry ) ) ; b -> next_pool = blocks ; b -> next_free = b -> entries ; b -> end = b -> entries + cnt ; blocks = b ; alloc_count += cnt ; }

debian

static int dissect_h245_T_audioSampling ( 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_audioSampling , T_audioSampling_choice , NULL ) ; return offset ; }

debian

unsigned long # define BN_BYTES 8 # endif # ifdef SIXTY_FOUR_BIT # define BN_ULONG unsigned long long # define BN_BYTES 8 # endif # ifdef THIRTY_TWO_BIT # define BN_ULONG unsigned int # define BN_BYTES 4 # endif # define BN_BITS2 ( BN_BYTES * 8 ) # define BN_BITS ( BN_BITS2 * 2 ) # define BN_TBIT ( ( BN_ULONG ) 1 << ( BN_BITS2 - 1 ) ) # define BN_FLG_MALLOCED 0x01 # define BN_FLG_STATIC_DATA 0x02 # define BN_FLG_CONSTTIME 0x04 # define BN_FLG_SECURE 0x08 # if OPENSSL_API_COMPAT < 0x00908000L # define BN_FLG_EXP_CONSTTIME BN_FLG_CONSTTIME # define BN_FLG_FREE 0x8000 # endif void BN_set_flags ( BIGNUM * b , int n ) ; int BN_get_flags ( const BIGNUM * b , int n ) ; # define BN_RAND_TOP_ANY - 1 # define BN_RAND_TOP_ONE 0 # define BN_RAND_TOP_TWO 1 # define BN_RAND_BOTTOM_ANY 0 # define BN_RAND_BOTTOM_ODD 1 void BN_with_flags ( BIGNUM * dest , const BIGNUM * b , int flags ) ; int BN_GENCB_call ( BN_GENCB * cb , int a , int b ) ; BN_GENCB * BN_GENCB_new ( void ) ; void BN_GENCB_free ( BN_GENCB * cb ) ; void BN_GENCB_set_old ( BN_GENCB * gencb , void ( * callback ) ( int , int , void * ) , void * cb_arg ) ; void BN_GENCB_set ( BN_GENCB * gencb , int ( * callback ) ( int , int , BN_GENCB * ) , void * cb_arg ) ; void * BN_GENCB_get_arg ( BN_GENCB * cb ) ; # define BN_prime_checks 0 # define BN_prime_checks_for_size ( b ) ( ( b ) >= 3747 ? 3 : ( b ) >= 1345 ? 4 : ( b ) >= 476 ? 5 : ( b ) >= 400 ? 6 : ( b ) >= 347 ? 7 : ( b ) >= 308 ? 8 : ( b ) >= 55 ? 27 : 34 ) # define BN_num_bytes ( a ) ( ( BN_num_bits ( a ) + 7 ) / 8 ) int BN_abs_is_word ( const BIGNUM * a , const BN_ULONG w ) ; int BN_is_zero ( const BIGNUM * a ) ; int BN_is_one ( const BIGNUM * a ) ; int BN_is_word ( const BIGNUM * a , const BN_ULONG w ) ; int BN_is_odd ( const BIGNUM * a ) ; # define BN_one ( a ) ( BN_set_word ( ( a ) , 1 ) ) void BN_zero_ex ( BIGNUM * a ) ; # if OPENSSL_API_COMPAT >= 0x00908000L # define BN_zero ( a ) BN_zero_ex ( a ) # else # define BN_zero ( a ) ( BN_set_word ( ( a ) , 0 ) ) # endif const BIGNUM * BN_value_one ( void ) ; char * BN_options ( void ) ; BN_CTX * BN_CTX_new ( void ) ; BN_CTX * BN_CTX_secure_new ( void ) ; void BN_CTX_free ( BN_CTX * c ) ; void BN_CTX_start ( BN_CTX * ctx ) ; BIGNUM * BN_CTX_get ( BN_CTX * ctx ) ; void BN_CTX_end ( BN_CTX * ctx ) ; int BN_rand ( BIGNUM * rnd , int bits , int top , int bottom ) ; int BN_priv_rand ( BIGNUM * rnd , int bits , int top , int bottom ) ; int BN_rand_range ( BIGNUM * rnd , const BIGNUM * range ) ; int BN_priv_rand_range ( BIGNUM * rnd , const BIGNUM * range ) ; int BN_pseudo_rand ( BIGNUM * rnd , int bits , int top , int bottom ) ; int BN_pseudo_rand_range ( BIGNUM * rnd , const BIGNUM * range ) ; int BN_num_bits ( const BIGNUM * a ) ; int BN_num_bits_word ( BN_ULONG l ) ; int BN_security_bits ( int L , int N ) ; BIGNUM * BN_new ( void ) ; BIGNUM * BN_secure_new ( void ) ; void BN_clear_free ( BIGNUM * a ) ; BIGNUM * BN_copy ( BIGNUM * a , const BIGNUM * b ) ; void BN_swap ( BIGNUM * a , BIGNUM * b ) ; BIGNUM * BN_bin2bn ( const unsigned char * s , int len , BIGNUM * ret ) ; int BN_bn2bin ( const BIGNUM * a , unsigned char * to ) ; int BN_bn2binpad ( const BIGNUM * a , unsigned char * to , int tolen ) ; BIGNUM * BN_lebin2bn ( const unsigned char * s , int len , BIGNUM * ret ) ; int BN_bn2lebinpad ( const BIGNUM * a , unsigned char * to , int tolen ) ; BIGNUM * BN_mpi2bn ( const unsigned char * s , int len , BIGNUM * ret ) ; int BN_bn2mpi ( const BIGNUM * a , unsigned char * to ) ; int BN_sub ( BIGNUM * r , const BIGNUM * a , const BIGNUM * b ) ; int BN_usub ( BIGNUM * r , const BIGNUM * a , const BIGNUM * b ) ; int BN_uadd ( BIGNUM * r , const BIGNUM * a , const BIGNUM * b ) ; int BN_add ( BIGNUM * r , const BIGNUM * a , const BIGNUM * b ) ; int BN_mul ( BIGNUM * r , const BIGNUM * a , const BIGNUM * b , BN_CTX * ctx ) ; int BN_sqr ( BIGNUM * r , const BIGNUM * a , BN_CTX * ctx ) ; void BN_set_negative ( BIGNUM * b , int n ) ; int BN_is_negative ( const BIGNUM * b ) ; int BN_div ( BIGNUM * dv , BIGNUM * rem , const BIGNUM * m , const BIGNUM * d , BN_CTX * ctx ) ; # define BN_mod ( rem , m , d , ctx ) BN_div ( NULL , ( rem ) , ( m ) , ( d ) , ( ctx ) ) int BN_nnmod ( BIGNUM * r , const BIGNUM * m , const BIGNUM * d , BN_CTX * ctx ) ; int BN_mod_add ( BIGNUM * r , const BIGNUM * a , const BIGNUM * b , const BIGNUM * m , BN_CTX * ctx ) ; int BN_mod_add_quick ( BIGNUM * r , const BIGNUM * a , const BIGNUM * b , const BIGNUM * m ) ; int BN_mod_sub ( BIGNUM * r , const BIGNUM * a , const BIGNUM * b , const BIGNUM * m , BN_CTX * ctx ) ; int BN_mod_sub_quick ( BIGNUM * r , const BIGNUM * a , const BIGNUM * b , const BIGNUM * m ) ; int BN_mod_mul ( BIGNUM * r , const BIGNUM * a , const BIGNUM * b , const BIGNUM * m , BN_CTX * ctx ) ; int BN_mod_sqr ( BIGNUM * r , const BIGNUM * a , const BIGNUM * m , BN_CTX * ctx ) ; int BN_mod_lshift1 ( BIGNUM * r , const BIGNUM * a , const BIGNUM * m , BN_CTX * ctx ) ; int BN_mod_lshift1_quick ( BIGNUM * r , const BIGNUM * a , const BIGNUM * m ) ; int BN_mod_lshift ( BIGNUM * r , const BIGNUM * a , int n , const BIGNUM * m , BN_CTX * ctx ) ; int BN_mod_lshift_quick ( BIGNUM * r , const BIGNUM * a , int n , const BIGNUM * m ) ; BN_ULONG BN_mod_word ( const BIGNUM * a , BN_ULONG w ) ; BN_ULONG BN_div_word ( BIGNUM * a , BN_ULONG w )

debian

void pdf_map_one_to_many ( fz_context * ctx , pdf_cmap * cmap , unsigned int low , int * values , int len ) { if ( len == 1 ) { add_range ( ctx , cmap , low , low , values [ 0 ] , 1 , 0 ) ; return ; } if ( len == 2 && values [ 0 ] >= 0xD800 && values [ 0 ] <= 0xDBFF && values [ 1 ] >= 0xDC00 && values [ 1 ] <= 0xDFFF ) { int rune = ( ( values [ 0 ] - 0xD800 ) << 10 ) + ( values [ 1 ] - 0xDC00 ) + 0x10000 ; add_range ( ctx , cmap , low , low , rune , 1 , 0 ) ; return ; } if ( len > PDF_MRANGE_CAP ) { fz_warn ( ctx , "ignoring one to many mapping in cmap %s" , cmap -> cmap_name ) ; return ; } add_mrange ( ctx , cmap , low , values , len ) ; }

debian

static ossl_inline t2 * sk_ ## t1 ## _pop ( STACK_OF ( t1 ) * sk ) { return ( t2 * ) OPENSSL_sk_pop ( ( OPENSSL_STACK * ) sk ) ; } static ossl_inline t2 * sk_ ## t1 ## _shift ( STACK_OF ( t1 ) * sk ) { return ( t2 * ) OPENSSL_sk_shift ( ( OPENSSL_STACK * ) sk ) ; } static ossl_inline void sk_ ## t1 ## _pop_free ( STACK_OF ( t1 ) * sk , sk_ ## t1 ## _freefunc freefunc ) { OPENSSL_sk_pop_free ( ( OPENSSL_STACK * ) sk , ( OPENSSL_sk_freefunc ) freefunc ) ; } static ossl_inline int sk_ ## t1 ## _insert ( STACK_OF ( t1 ) * sk , t2 * ptr , int idx ) { return OPENSSL_sk_insert ( ( OPENSSL_STACK * ) sk , ( const void * ) ptr , idx ) ; } static ossl_inline t2 * sk_ ## t1 ## _set ( STACK_OF ( t1 ) * sk , int idx , t2 * ptr ) { return ( t2 * ) OPENSSL_sk_set ( ( OPENSSL_STACK * ) sk , idx , ( const void * ) ptr ) ; } static ossl_inline int sk_ ## t1 ## _find ( STACK_OF ( t1 ) * sk , t2 * ptr ) { return OPENSSL_sk_find ( ( OPENSSL_STACK * ) sk , ( const void * ) ptr ) ; } static ossl_inline int sk_ ## t1 ## _find_ex ( STACK_OF ( t1 ) * sk , t2 * ptr ) { return OPENSSL_sk_find_ex ( ( OPENSSL_STACK * ) sk , ( const void * ) ptr ) ; } static ossl_inline void sk_ ## t1 ## _sort ( STACK_OF ( t1 ) * sk ) { OPENSSL_sk_sort ( ( OPENSSL_STACK * ) sk ) ; } 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 )

chrome

void vp9_fht16x16_c ( const int16_t * input , int16_t * output , int stride , int tx_type ) { if ( tx_type == DCT_DCT ) { vp9_fdct16x16_c ( input , output , stride ) ; } else { int16_t out [ 256 ] ; int16_t * outptr = & out [ 0 ] ; int i , j ; int16_t temp_in [ 16 ] , temp_out [ 16 ] ; const transform_2d ht = FHT_16 [ tx_type ] ; for ( i = 0 ; i < 16 ; ++ i ) { for ( j = 0 ; j < 16 ; ++ j ) temp_in [ j ] = input [ j * stride + i ] * 4 ; ht . cols ( temp_in , temp_out ) ; for ( j = 0 ; j < 16 ; ++ j ) outptr [ j * 16 + i ] = ( temp_out [ j ] + 1 + ( temp_out [ j ] < 0 ) ) >> 2 ; } for ( i = 0 ; i < 16 ; ++ i ) { for ( j = 0 ; j < 16 ; ++ j ) temp_in [ j ] = out [ j + i * 16 ] ; ht . rows ( temp_in , temp_out ) ; for ( j = 0 ; j < 16 ; ++ j ) output [ j + i * 16 ] = temp_out [ j ] ; } } }

chrome

IN_PROC_BROWSER_TEST_F ( PrefsFunctionalTest , PRE_TestHomepageNewTabpagePrefs ) { browser ( ) -> profile ( ) -> GetPrefs ( ) -> SetBoolean ( prefs : : kHomePageIsNewTabPage , true ) ; }

debian

static DeviceState * slavio_intctl_init ( hwaddr addr , hwaddr addrg , qemu_irq * * parent_irq ) { DeviceState * dev ; SysBusDevice * s ; unsigned int i , j ; dev = qdev_create ( NULL , "slavio_intctl" ) ; qdev_init_nofail ( dev ) ; s = SYS_BUS_DEVICE ( dev ) ; for ( i = 0 ; i < MAX_CPUS ; i ++ ) { for ( j = 0 ; j < MAX_PILS ; j ++ ) { sysbus_connect_irq ( s , i * MAX_PILS + j , parent_irq [ i ] [ j ] ) ; } } sysbus_mmio_map ( s , 0 , addrg ) ; for ( i = 0 ; i < MAX_CPUS ; i ++ ) { sysbus_mmio_map ( s , i + 1 , addr + i * TARGET_PAGE_SIZE ) ; } return dev ; }

chrome

IN_PROC_BROWSER_TEST_F ( PageLoadMetricsBrowserTest , UseCounterUkmFeaturesLogged ) { ASSERT_TRUE ( embedded_test_server ( ) -> Start ( ) ) ; auto waiter = CreatePageLoadMetricsWaiter ( ) ; waiter -> AddPageExpectation ( TimingField : : LOAD_EVENT ) ; GURL url = embedded_test_server ( ) -> GetURL ( "/page_load_metrics/use_counter_features.html" ) ; ui_test_utils : : NavigateToURL ( browser ( ) , url ) ; waiter -> Wait ( ) ; NavigateToUntrackedUrl ( ) ; const auto & entries = test_ukm_recorder_ -> GetEntriesByName ( internal : : kUkmUseCounterEventName ) ; EXPECT_EQ ( 3u , entries . size ( ) ) ; std : : vector < int64_t > ukm_features ; for ( const auto * entry : entries ) { test_ukm_recorder_ -> ExpectEntrySourceHasUrl ( entry , url ) ; const auto * metric = test_ukm_recorder_ -> GetEntryMetric ( entry , internal : : kUkmUseCounterFeature ) ; EXPECT_TRUE ( metric ) ; ukm_features . push_back ( * metric ) ; } EXPECT_THAT ( ukm_features , UnorderedElementsAre ( static_cast < int64_t > ( WebFeature : : kNavigatorVibrate ) , static_cast < int64_t > ( WebFeature : : kDataUriHasOctothorpe ) , static_cast < int64_t > ( WebFeature : : kApplicationCacheManifestSelectSecureOrigin ) ) ) ; }

debian

static void bootstrap ( MYSQL_FILE * file ) { DBUG_ENTER ( "bootstrap" ) ; THD * thd = new THD ; thd -> bootstrap = 1 ; my_net_init ( & thd -> net , ( st_vio * ) 0 ) ; thd -> max_client_packet_length = thd -> net . max_packet ; thd -> security_ctx -> master_access = ~ ( ulong ) 0 ; thd -> thread_id = thd -> variables . pseudo_thread_id = thread_id ++ ; thread_count ++ ; in_bootstrap = TRUE ; bootstrap_file = file ; # ifndef EMBEDDED_LIBRARY int error ; if ( ( error = mysql_thread_create ( key_thread_bootstrap , & thd -> real_id , & connection_attrib , handle_bootstrap , ( void * ) thd ) ) ) { sql_print_warning ( "Can't create thread to handle bootstrap (errno= %d)" , error ) ; bootstrap_error = - 1 ; DBUG_VOID_RETURN ; } mysql_mutex_lock ( & LOCK_thread_count ) ; while ( in_bootstrap ) { mysql_cond_wait ( & COND_thread_count , & LOCK_thread_count ) ; DBUG_PRINT ( "quit" , ( "One thread died (count=%u)" , thread_count ) ) ; } mysql_mutex_unlock ( & LOCK_thread_count ) ; # else thd -> mysql = 0 ; do_handle_bootstrap ( thd ) ; # endif DBUG_VOID_RETURN ; }

debian

int main ( int argc , char * * argv ) { const Writer * w ; WriterContext * wctx ; char * buf ; char * w_name = NULL , * w_args = NULL ; int ret , i ; init_dynload ( ) ; # if HAVE_THREADS ret = pthread_mutex_init ( & log_mutex , NULL ) ; if ( ret != 0 ) { goto end ; } # endif av_log_set_flags ( AV_LOG_SKIP_REPEATED ) ; register_exit ( ffprobe_cleanup ) ; options = real_options ; parse_loglevel ( argc , argv , options ) ; av_register_all ( ) ; avformat_network_init ( ) ; init_opts ( ) ; # if CONFIG_AVDEVICE avdevice_register_all ( ) ; # endif show_banner ( argc , argv , options ) ; parse_options ( NULL , argc , argv , options , opt_input_file ) ; if ( do_show_log ) av_log_set_callback ( log_callback ) ; SET_DO_SHOW ( CHAPTERS , chapters ) ; SET_DO_SHOW ( ERROR , error ) ; SET_DO_SHOW ( FORMAT , format ) ; SET_DO_SHOW ( FRAMES , frames ) ; SET_DO_SHOW ( LIBRARY_VERSIONS , library_versions ) ; SET_DO_SHOW ( PACKETS , packets ) ; SET_DO_SHOW ( PIXEL_FORMATS , pixel_formats ) ; SET_DO_SHOW ( PIXEL_FORMAT_FLAGS , pixel_format_flags ) ; SET_DO_SHOW ( PIXEL_FORMAT_COMPONENTS , pixel_format_components ) ; SET_DO_SHOW ( PROGRAM_VERSION , program_version ) ; SET_DO_SHOW ( PROGRAMS , programs ) ; SET_DO_SHOW ( STREAMS , streams ) ; SET_DO_SHOW ( STREAM_DISPOSITION , stream_disposition ) ; SET_DO_SHOW ( PROGRAM_STREAM_DISPOSITION , stream_disposition ) ; SET_DO_SHOW ( CHAPTER_TAGS , chapter_tags ) ; SET_DO_SHOW ( FORMAT_TAGS , format_tags ) ; SET_DO_SHOW ( FRAME_TAGS , frame_tags ) ; SET_DO_SHOW ( PROGRAM_TAGS , program_tags ) ; SET_DO_SHOW ( STREAM_TAGS , stream_tags ) ; SET_DO_SHOW ( PROGRAM_STREAM_TAGS , stream_tags ) ; SET_DO_SHOW ( PACKET_TAGS , packet_tags ) ; if ( do_bitexact && ( do_show_program_version || do_show_library_versions ) ) { av_log ( NULL , AV_LOG_ERROR , "-bitexact and -show_program_version or -show_library_versions " "options are incompatible\n" ) ; ret = AVERROR ( EINVAL ) ; goto end ; } writer_register_all ( ) ; if ( ! print_format ) print_format = av_strdup ( "default" ) ; if ( ! print_format ) { ret = AVERROR ( ENOMEM ) ; goto end ; } w_name = av_strtok ( print_format , "=" , & buf ) ; if ( ! w_name ) { av_log ( NULL , AV_LOG_ERROR , "No name specified for the output format\n" ) ; ret = AVERROR ( EINVAL ) ; goto end ; } w_args = buf ; if ( show_data_hash ) { if ( ( ret = av_hash_alloc ( & hash , show_data_hash ) ) < 0 ) { if ( ret == AVERROR ( EINVAL ) ) { const char * n ; av_log ( NULL , AV_LOG_ERROR , "Unknown hash algorithm '%s'\nKnown algorithms:" , show_data_hash ) ; for ( i = 0 ; ( n = av_hash_names ( i ) ) ; i ++ ) av_log ( NULL , AV_LOG_ERROR , " %s" , n ) ; av_log ( NULL , AV_LOG_ERROR , "\n" ) ; } goto end ; } } w = writer_get_by_name ( w_name ) ; if ( ! w ) { av_log ( NULL , AV_LOG_ERROR , "Unknown output format with name '%s'\n" , w_name ) ; ret = AVERROR ( EINVAL ) ; goto end ; } if ( ( ret = writer_open ( & wctx , w , w_args , sections , FF_ARRAY_ELEMS ( sections ) ) ) >= 0 ) { if ( w == & xml_writer ) wctx -> string_validation_utf8_flags |= AV_UTF8_FLAG_EXCLUDE_XML_INVALID_CONTROL_CODES ; writer_print_section_header ( wctx , SECTION_ID_ROOT ) ; if ( do_show_program_version ) ffprobe_show_program_version ( wctx ) ; if ( do_show_library_versions ) ffprobe_show_library_versions ( wctx ) ; if ( do_show_pixel_formats ) ffprobe_show_pixel_formats ( wctx ) ; if ( ! input_filename && ( ( do_show_format || do_show_programs || do_show_streams || do_show_chapters || do_show_packets || do_show_error ) || ( ! do_show_program_version && ! do_show_library_versions && ! do_show_pixel_formats ) ) ) { show_usage ( ) ; av_log ( NULL , AV_LOG_ERROR , "You have to specify one input file.\n" ) ; av_log ( NULL , AV_LOG_ERROR , "Use -h to get full help or, even better, run 'man %s'.\n" , program_name ) ; ret = AVERROR ( EINVAL ) ; } else if ( input_filename ) { ret = probe_file ( wctx , input_filename ) ; if ( ret < 0 && do_show_error ) show_error ( wctx , ret ) ; } writer_print_section_footer ( wctx ) ; writer_close ( & wctx ) ; } end : av_freep ( & print_format ) ; av_freep ( & read_intervals ) ; av_hash_freep ( & hash ) ; uninit_opts ( ) ; for ( i = 0 ; i < FF_ARRAY_ELEMS ( sections ) ; i ++ ) av_dict_free ( & ( sections [ i ] . entries_to_show ) ) ; avformat_network_deinit ( ) ; return ret < 0 ; }

chrome

static int evdns_request_data_build ( const char * const name , const int name_len , const u16 trans_id , const u16 type , const u16 class , u8 * const buf , size_t buf_len ) { off_t j = 0 ; u16 _t ; APPEND16 ( trans_id ) ; APPEND16 ( 0x0100 ) ; APPEND16 ( 1 ) ; APPEND16 ( 0 ) ; APPEND16 ( 0 ) ; APPEND16 ( 0 ) ; j = dnsname_to_labels ( buf , buf_len , j , name , name_len , NULL ) ; if ( j < 0 ) { return ( int ) j ; } APPEND16 ( type ) ; APPEND16 ( class ) ; return ( int ) j ; overflow : return ( - 1 ) ; }

debian

static void fill_vaapi_plain_pred_weight_table ( H264Context * h , int list , unsigned char * luma_weight_flag , short luma_weight [ 32 ] , short luma_offset [ 32 ] , unsigned char * chroma_weight_flag , short chroma_weight [ 32 ] [ 2 ] , short chroma_offset [ 32 ] [ 2 ] ) { unsigned int i , j ; * luma_weight_flag = h -> luma_weight_flag [ list ] ; * chroma_weight_flag = h -> chroma_weight_flag [ list ] ; for ( i = 0 ; i < h -> ref_count [ list ] ; i ++ ) { if ( h -> luma_weight_flag [ list ] ) { luma_weight [ i ] = h -> luma_weight [ i ] [ list ] [ 0 ] ; luma_offset [ i ] = h -> luma_weight [ i ] [ list ] [ 1 ] ; } else { luma_weight [ i ] = 1 << h -> luma_log2_weight_denom ; luma_offset [ i ] = 0 ; } for ( j = 0 ; j < 2 ; j ++ ) { if ( h -> chroma_weight_flag [ list ] ) { chroma_weight [ i ] [ j ] = h -> chroma_weight [ i ] [ list ] [ j ] [ 0 ] ; chroma_offset [ i ] [ j ] = h -> chroma_weight [ i ] [ list ] [ j ] [ 1 ] ; } else { chroma_weight [ i ] [ j ] = 1 << h -> chroma_log2_weight_denom ; chroma_offset [ i ] [ j ] = 0 ; } } } }

debian

static void dissect_q931_information_rate_ie ( tvbuff_t * tvb , packet_info * pinfo , int offset , int len , proto_tree * tree , proto_item * item ) { if ( len != 4 ) { expert_add_info_format ( pinfo , item , & ei_q931_invalid_length , "Information rate: length is %d, should be 4" , len ) ; return ; } proto_tree_add_item ( tree , hf_q931_information_rate_incoming , tvb , offset + 0 , 1 , ENC_BIG_ENDIAN ) ; proto_tree_add_item ( tree , hf_q931_information_rate_outgoing , tvb , offset + 1 , 1 , ENC_BIG_ENDIAN ) ; proto_tree_add_item ( tree , hf_q931_information_rate_minimum_incoming , tvb , offset + 2 , 1 , ENC_BIG_ENDIAN ) ; proto_tree_add_item ( tree , hf_q931_information_rate_minimum_outgoing , tvb , offset + 3 , 1 , ENC_BIG_ENDIAN ) ; }

debian

static int dissect_h245_ConferenceCapability ( tvbuff_t * tvb _U_ , int offset _U_ , asn1_ctx_t * actx _U_ , proto_tree * tree _U_ , int hf_index _U_ ) { offset = dissect_per_sequence ( tvb , offset , actx , tree , hf_index , ett_h245_ConferenceCapability , ConferenceCapability_sequence ) ; return offset ; }

chrome

static void copy_partitioning ( VP9_COMMON * cm , MODE_INFO * * mi_8x8 , MODE_INFO * * prev_mi_8x8 ) { const int mis = cm -> mi_stride ; int block_row , block_col ; for ( block_row = 0 ; block_row < 8 ; ++ block_row ) { for ( block_col = 0 ; block_col < 8 ; ++ block_col ) { MODE_INFO * const prev_mi = prev_mi_8x8 [ block_row * mis + block_col ] ; const BLOCK_SIZE sb_type = prev_mi ? prev_mi -> mbmi . sb_type : 0 ; if ( prev_mi ) { const ptrdiff_t offset = prev_mi - cm -> prev_mi ; mi_8x8 [ block_row * mis + block_col ] = cm -> mi + offset ; mi_8x8 [ block_row * mis + block_col ] -> mbmi . sb_type = sb_type ; } } } }

chrome

IN_PROC_BROWSER_TEST_F ( DownloadNotificationTest , CloseNotificationAfterDownload ) { CreateDownload ( ) ; CompleteTheDownload ( ) ; CloseNotification ( ) ; VerifyDownloadState ( download : : DownloadItem : : COMPLETE ) ; }

chrome

int evbuffer_add_vprintf ( struct evbuffer * buf , const char * fmt , va_list ap ) { char * buffer ; size_t space ; size_t oldoff = buf -> off ; int sz ; va_list aq ; if ( evbuffer_expand ( buf , 64 ) < 0 ) return ( - 1 ) ; for ( ; ; ) { size_t used = buf -> misalign + buf -> off ; buffer = ( char * ) buf -> buffer + buf -> off ; assert ( buf -> totallen >= used ) ; space = buf -> totallen - used ; # ifndef va_copy # define va_copy ( dst , src ) memcpy ( & ( dst ) , & ( src ) , sizeof ( va_list ) ) # endif va_copy ( aq , ap ) ; sz = evutil_vsnprintf ( buffer , space , fmt , aq ) ; va_end ( aq ) ; if ( sz < 0 ) return ( - 1 ) ; if ( ( size_t ) sz < space ) { buf -> off += sz ; if ( buf -> cb != NULL ) ( * buf -> cb ) ( buf , oldoff , buf -> off , buf -> cbarg ) ; return ( sz ) ; } if ( evbuffer_expand ( buf , sz + 1 ) == - 1 ) return ( - 1 ) ; } }

chrome

TEST_F ( ProtocolHandlerRegistryTest , RemovingHandlerMeansItCanBeAddedAgain ) { registry ( ) -> OnAcceptRegisterProtocolHandler ( test_protocol_handler ( ) ) ; ASSERT_TRUE ( registry ( ) -> CanSchemeBeOverridden ( "test" ) ) ; registry ( ) -> RemoveHandler ( test_protocol_handler ( ) ) ; ASSERT_TRUE ( registry ( ) -> CanSchemeBeOverridden ( "test" ) ) ; }

debian

static uint64_t ar_atol10 ( const char * p , unsigned char_cnt ) { uint64_t l , limit , last_digit_limit ; unsigned int base , digit ; base = 10 ; limit = UINT64_MAX / base ; last_digit_limit = UINT64_MAX % base ; while ( ( * p == ' ' || * p == '\t' ) && char_cnt -- > 0 ) p ++ ; l = 0 ; digit = * p - '0' ; while ( * p >= '0' && digit < base && char_cnt -- > 0 ) { if ( l > limit || ( l == limit && digit > last_digit_limit ) ) { l = UINT64_MAX ; break ; } l = ( l * base ) + digit ; digit = * ++ p - '0' ; } return ( l ) ; }

debian

proto_item * proto_tree_add_text_internal ( proto_tree * tree , tvbuff_t * tvb , gint start , gint length , const char * format , ... ) { proto_item * pi ; va_list ap ; header_field_info * hfinfo ; if ( length == - 1 ) { length = 0 ; } tvb_ensure_bytes_exist ( tvb , start , length ) ; CHECK_FOR_NULL_TREE ( tree ) ; TRY_TO_FAKE_THIS_ITEM ( tree , hf_text_only , hfinfo ) ; pi = proto_tree_add_text_node ( tree , tvb , start , length ) ; TRY_TO_FAKE_THIS_REPR ( pi ) ; va_start ( ap , format ) ; proto_tree_set_representation ( pi , format , ap ) ; va_end ( ap ) ; return pi ; }

debian

static inline void cached_cmyk_conv ( unsigned char * restrict const pr , unsigned char * restrict const pg , unsigned char * restrict const pb , unsigned int * restrict const C , unsigned int * restrict const M , unsigned int * restrict const Y , unsigned int * restrict const K , unsigned int c , unsigned int m , unsigned int y , unsigned int k ) { # ifdef SLOWCMYK unsigned int r , g , b ; unsigned int cm , c1m , cm1 , c1m1 , c1m1y , c1m1y1 , c1my , c1my1 , cm1y , cm1y1 , cmy , cmy1 ; unsigned int x0 , x1 ; if ( c == * C && m == * M && y == * Y && k == * K ) { } else if ( k == 0 && c == 0 && m == 0 && y == 0 ) { * C = 0 ; * M = 0 ; * Y = 0 ; * K = 0 ; * pr = * pg = * pb = 255 ; } else if ( k == 255 ) { * C = 0 ; * M = 0 ; * Y = 0 ; * K = 255 ; * pr = * pg = * pb = 0 ; } else { * C = c ; * M = m ; * Y = y ; * K = k ; c += c >> 7 ; m += m >> 7 ; y += y >> 7 ; k += k >> 7 ; y >>= 1 ; cm = c * m ; c1m = ( m << 8 ) - cm ; cm1 = ( c << 8 ) - cm ; c1m1 = ( ( 256 - m ) << 8 ) - cm1 ; c1m1y = c1m1 * y ; c1m1y1 = ( c1m1 << 7 ) - c1m1y ; c1my = c1m * y ; c1my1 = ( c1m << 7 ) - c1my ; cm1y = cm1 * y ; cm1y1 = ( cm1 << 7 ) - cm1y ; cmy = cm * y ; cmy1 = ( cm << 7 ) - cmy ; x1 = c1m1y1 * k ; x0 = ( c1m1y1 << 8 ) - x1 ; x1 = x1 >> 8 ; r = g = b = x0 ; r += 35 * x1 ; g += 31 * x1 ; b += 32 * x1 ; x1 = c1m1y * k ; x0 = ( c1m1y << 8 ) - x1 ; x1 >>= 8 ; r += 28 * x1 ; g += 26 * x1 ; r += x0 ; x0 >>= 8 ; g += 243 * x0 ; x1 = c1my1 * k ; x0 = ( c1my1 << 8 ) - x1 ; x1 >>= 8 ; x0 >>= 8 ; r += 36 * x1 ; r += 237 * x0 ; b += 141 * x0 ; x1 = c1my * k ; x0 = ( c1my << 8 ) - x1 ; x1 >>= 8 ; x0 >>= 8 ; r += 34 * x1 ; r += 238 * x0 ; g += 28 * x0 ; b += 36 * x0 ; x1 = cm1y1 * k ; x0 = ( cm1y1 << 8 ) - x1 ; x1 >>= 8 ; x0 >>= 8 ; g += 15 * x1 ; b += 36 * x1 ; g += 174 * x0 ; b += 240 * x0 ; x1 = cm1y * k ; x0 = ( cm1y << 8 ) - x1 ; x1 >>= 8 ; x0 >>= 8 ; g += 19 * x1 ; g += 167 * x0 ; b += 80 * x0 ; x1 = cmy1 * k ; x0 = ( cmy1 << 8 ) - x1 ; x1 >>= 8 ; x0 >>= 8 ; b += 2 * x1 ; r += 46 * x0 ; g += 49 * x0 ; b += 147 * x0 ; x0 = cmy * ( 256 - k ) ; x0 >>= 8 ; r += 54 * x0 ; g += 54 * x0 ; b += 57 * x0 ; r -= ( r >> 8 ) ; g -= ( g >> 8 ) ; b -= ( b >> 8 ) ; * pr = r >> 23 ; * pg = g >> 23 ; * pb = b >> 23 ; } # else * pr = 255 - ( unsigned char ) fz_mini ( c + k , 255 ) ; * pg = 255 - ( unsigned char ) fz_mini ( m + k , 255 ) ; * pb = 255 - ( unsigned char ) fz_mini ( y + k , 255 ) ; # endif }

debian

static int jbig2_decode_generic_template3_unopt ( Jbig2Ctx * ctx , Jbig2Segment * segment , const Jbig2GenericRegionParams * params , Jbig2ArithState * as , Jbig2Image * image , Jbig2ArithCx * GB_stats ) { const int GBW = image -> width ; const int GBH = image -> height ; uint32_t CONTEXT ; int x , y ; bool bit ; for ( y = 0 ; y < GBH ; y ++ ) { for ( x = 0 ; x < GBW ; x ++ ) { CONTEXT = 0 ; CONTEXT |= jbig2_image_get_pixel ( image , x - 1 , y ) << 0 ; CONTEXT |= jbig2_image_get_pixel ( image , x - 2 , y ) << 1 ; CONTEXT |= jbig2_image_get_pixel ( image , x - 3 , y ) << 2 ; CONTEXT |= jbig2_image_get_pixel ( image , x - 4 , y ) << 3 ; CONTEXT |= jbig2_image_get_pixel ( image , x + params -> gbat [ 0 ] , y + params -> gbat [ 1 ] ) << 4 ; CONTEXT |= jbig2_image_get_pixel ( image , x + 1 , y - 1 ) << 5 ; CONTEXT |= jbig2_image_get_pixel ( image , x + 0 , y - 1 ) << 6 ; CONTEXT |= jbig2_image_get_pixel ( image , x - 1 , y - 1 ) << 7 ; CONTEXT |= jbig2_image_get_pixel ( image , x - 2 , y - 1 ) << 8 ; CONTEXT |= jbig2_image_get_pixel ( image , x - 3 , y - 1 ) << 9 ; bit = jbig2_arith_decode ( as , & GB_stats [ CONTEXT ] ) ; if ( bit < 0 ) return - 1 ; jbig2_image_set_pixel ( image , x , y , bit ) ; } } return 0 ; }

chrome

static inline void uprv_arrayCopy ( const double * src , double * dst , int32_t count ) { uprv_memcpy ( dst , src , ( size_t ) count * sizeof ( * src ) ) ; }

debian

static void sigcomp_init_udvm ( void ) { gchar * partial_state_str ; guint8 * sip_sdp_buff , * presence_buff ; state_buffer_table = g_hash_table_new_full ( g_str_hash , g_str_equal , g_free , g_free ) ; sip_sdp_buff = ( guint8 * ) g_malloc ( SIP_SDP_STATE_LENGTH + 8 ) ; partial_state_str = bytes_to_str ( NULL , sip_sdp_state_identifier , 6 ) ; memset ( sip_sdp_buff , 0 , 8 ) ; sip_sdp_buff [ 0 ] = SIP_SDP_STATE_LENGTH >> 8 ; sip_sdp_buff [ 1 ] = SIP_SDP_STATE_LENGTH & 0xff ; memcpy ( sip_sdp_buff + 8 , sip_sdp_static_dictionaty_for_sigcomp , SIP_SDP_STATE_LENGTH ) ; g_hash_table_insert ( state_buffer_table , g_strdup ( partial_state_str ) , sip_sdp_buff ) ; wmem_free ( NULL , partial_state_str ) ; presence_buff = ( guint8 * ) g_malloc ( PRESENCE_STATE_LENGTH + 8 ) ; partial_state_str = bytes_to_str ( NULL , presence_state_identifier , 6 ) ; memset ( presence_buff , 0 , 8 ) ; presence_buff [ 0 ] = PRESENCE_STATE_LENGTH >> 8 ; presence_buff [ 1 ] = PRESENCE_STATE_LENGTH & 0xff ; memcpy ( presence_buff + 8 , presence_static_dictionary_for_sigcomp , PRESENCE_STATE_LENGTH ) ; g_hash_table_insert ( state_buffer_table , g_strdup ( partial_state_str ) , presence_buff ) ; wmem_free ( NULL , partial_state_str ) ; }

debian

void proto_reg_handoff_pkt_ccc ( void ) { static gboolean initialized = FALSE ; static dissector_handle_t pkt_ccc_handle ; static guint saved_pkt_ccc_udp_port ; if ( ! initialized ) { pkt_ccc_handle = find_dissector ( "pkt_ccc" ) ; dissector_add_handle ( "udp.port" , pkt_ccc_handle ) ; initialized = TRUE ; } else { if ( saved_pkt_ccc_udp_port != 0 ) { dissector_delete_uint ( "udp.port" , saved_pkt_ccc_udp_port , pkt_ccc_handle ) ; } } if ( global_pkt_ccc_udp_port != 0 ) { dissector_add_uint ( "udp.port" , global_pkt_ccc_udp_port , pkt_ccc_handle ) ; } saved_pkt_ccc_udp_port = global_pkt_ccc_udp_port ; }

debian

static void h225_stat_init ( stat_tap_table_ui * new_stat , new_stat_tap_gui_init_cb gui_callback , void * gui_data ) { int num_fields = sizeof ( h225_stat_fields ) / sizeof ( stat_tap_table_item ) ; stat_tap_table * table = new_stat_tap_init_table ( "H.225 Messages and Message Reasons" , num_fields , 0 , NULL , gui_callback , gui_data ) ; int row_idx = 0 , msg_idx ; stat_tap_table_item_type items [ sizeof ( h225_stat_fields ) / sizeof ( stat_tap_table_item ) ] ; new_stat_tap_add_table ( new_stat , table ) ; items [ MESSAGE_TYPE_COLUMN ] . type = TABLE_ITEM_STRING ; items [ COUNT_COLUMN ] . type = TABLE_ITEM_UINT ; items [ COUNT_COLUMN ] . value . uint_value = 0 ; msg_idx = 0 ; do { items [ MESSAGE_TYPE_COLUMN ] . value . string_value = h225_RasMessage_vals [ msg_idx ] . strptr ? h225_RasMessage_vals [ msg_idx ] . strptr : "Unknown RAS message" ; ras_msg_idx [ msg_idx ] = row_idx ; new_stat_tap_init_table_row ( table , row_idx , num_fields , items ) ; row_idx ++ ; msg_idx ++ ; } while ( h225_RasMessage_vals [ msg_idx ] . strptr ) ; msg_idx = 0 ; do { items [ MESSAGE_TYPE_COLUMN ] . value . string_value = T_h323_message_body_vals [ msg_idx ] . strptr ? T_h323_message_body_vals [ msg_idx ] . strptr : "Unknown CS message" ; cs_msg_idx [ msg_idx ] = row_idx ; new_stat_tap_init_table_row ( table , row_idx , num_fields , items ) ; row_idx ++ ; msg_idx ++ ; } while ( T_h323_message_body_vals [ msg_idx ] . strptr ) ; msg_idx = 0 ; do { items [ MESSAGE_TYPE_COLUMN ] . value . string_value = GatekeeperRejectReason_vals [ msg_idx ] . strptr ? GatekeeperRejectReason_vals [ msg_idx ] . strptr : "Unknown gatekeeper reject reason" ; grj_reason_idx [ msg_idx ] = row_idx ; new_stat_tap_init_table_row ( table , row_idx , num_fields , items ) ; row_idx ++ ; msg_idx ++ ; } while ( GatekeeperRejectReason_vals [ msg_idx ] . strptr ) ; msg_idx = 0 ; do { items [ MESSAGE_TYPE_COLUMN ] . value . string_value = RegistrationRejectReason_vals [ msg_idx ] . strptr ? RegistrationRejectReason_vals [ msg_idx ] . strptr : "Unknown registration reject reason" ; rrj_reason_idx [ msg_idx ] = row_idx ; new_stat_tap_init_table_row ( table , row_idx , num_fields , items ) ; row_idx ++ ; msg_idx ++ ; } while ( RegistrationRejectReason_vals [ msg_idx ] . strptr ) ; msg_idx = 0 ; do { items [ MESSAGE_TYPE_COLUMN ] . value . string_value = UnregRequestReason_vals [ msg_idx ] . strptr ? UnregRequestReason_vals [ msg_idx ] . strptr : "Unknown unregistration request reason" ; urq_reason_idx [ msg_idx ] = row_idx ; new_stat_tap_init_table_row ( table , row_idx , num_fields , items ) ; row_idx ++ ; msg_idx ++ ; } while ( UnregRequestReason_vals [ msg_idx ] . strptr ) ; msg_idx = 0 ; do { items [ MESSAGE_TYPE_COLUMN ] . value . string_value = UnregRejectReason_vals [ msg_idx ] . strptr ? UnregRejectReason_vals [ msg_idx ] . strptr : "Unknown unregistration reject reason" ; urj_reason_idx [ msg_idx ] = row_idx ; new_stat_tap_init_table_row ( table , row_idx , num_fields , items ) ; row_idx ++ ; msg_idx ++ ; } while ( UnregRejectReason_vals [ msg_idx ] . strptr ) ; msg_idx = 0 ; do { items [ MESSAGE_TYPE_COLUMN ] . value . string_value = AdmissionRejectReason_vals [ msg_idx ] . strptr ? AdmissionRejectReason_vals [ msg_idx ] . strptr : "Unknown admission reject reason" ; arj_reason_idx [ msg_idx ] = row_idx ; new_stat_tap_init_table_row ( table , row_idx , num_fields , items ) ; row_idx ++ ; msg_idx ++ ; } while ( AdmissionRejectReason_vals [ msg_idx ] . strptr ) ; msg_idx = 0 ; do { items [ MESSAGE_TYPE_COLUMN ] . value . string_value = BandRejectReason_vals [ msg_idx ] . strptr ? BandRejectReason_vals [ msg_idx ] . strptr : "Unknown band reject reason" ; brj_reason_idx [ msg_idx ] = row_idx ; new_stat_tap_init_table_row ( table , row_idx , num_fields , items ) ; row_idx ++ ; msg_idx ++ ; } while ( BandRejectReason_vals [ msg_idx ] . strptr ) ; msg_idx = 0 ; do { items [ MESSAGE_TYPE_COLUMN ] . value . string_value = DisengageReason_vals [ msg_idx ] . strptr ? DisengageReason_vals [ msg_idx ] . strptr : "Unknown disengage reason" ; drq_reason_idx [ msg_idx ] = row_idx ; new_stat_tap_init_table_row ( table , row_idx , num_fields , items ) ; row_idx ++ ; msg_idx ++ ; } while ( DisengageReason_vals [ msg_idx ] . strptr ) ; msg_idx = 0 ; do { items [ MESSAGE_TYPE_COLUMN ] . value . string_value = DisengageRejectReason_vals [ msg_idx ] . strptr ? DisengageRejectReason_vals [ msg_idx ] . strptr : "Unknown disengage reject reason" ; drj_reason_idx [ msg_idx ] = row_idx ; new_stat_tap_init_table_row ( table , row_idx , num_fields , items ) ; row_idx ++ ; msg_idx ++ ; } while ( DisengageRejectReason_vals [ msg_idx ] . strptr ) ; msg_idx = 0 ; do { items [ MESSAGE_TYPE_COLUMN ] . value . string_value = LocationRejectReason_vals [ msg_idx ] . strptr ? LocationRejectReason_vals [ msg_idx ] . strptr : "Unknown location reject reason" ; lrj_reason_idx [ msg_idx ] = row_idx ; new_stat_tap_init_table_row ( table , row_idx , num_fields , items ) ; row_idx ++ ; msg_idx ++ ; } while ( LocationRejectReason_vals [ msg_idx ] . strptr ) ; msg_idx = 0 ; do { items [ MESSAGE_TYPE_COLUMN ] . value . string_value = InfoRequestNakReason_vals [ msg_idx ] . strptr ? InfoRequestNakReason_vals [ msg_idx ] . strptr : "Unknown info request nak reason" ; irqnak_reason_idx [ msg_idx ] = row_idx ; new_stat_tap_init_table_row ( table , row_idx , num_fields , items ) ; row_idx ++ ; msg_idx ++ ; } while ( InfoRequestNakReason_vals [ msg_idx ] . strptr ) ; msg_idx = 0 ; do { items [ MESSAGE_TYPE_COLUMN ] . value . string_value = h225_ReleaseCompleteReason_vals [ msg_idx ] . strptr ? h225_ReleaseCompleteReason_vals [ msg_idx ] . strptr : "Unknown release complete reason" ; rel_cmp_reason_idx [ msg_idx ] = row_idx ; new_stat_tap_init_table_row ( table , row_idx , num_fields , items ) ; row_idx ++ ; msg_idx ++ ; } while ( h225_ReleaseCompleteReason_vals [ msg_idx ] . strptr ) ; msg_idx = 0 ; do { items [ MESSAGE_TYPE_COLUMN ] . value . string_value = FacilityReason_vals [ msg_idx ] . strptr ? FacilityReason_vals [ msg_idx ] . strptr : "Unknown facility reason" ; facility_reason_idx [ msg_idx ] = row_idx ; new_stat_tap_init_table_row ( table , row_idx , num_fields , items ) ; row_idx ++ ; msg_idx ++ ; } while ( FacilityReason_vals [ msg_idx ] . strptr ) ; items [ MESSAGE_TYPE_COLUMN ] . value . string_value = "Unknown H.225 message" ; new_stat_tap_init_table_row ( table , row_idx , num_fields , items ) ; other_idx = row_idx ; }

debian

static jas_image_cmpt_t * jas_image_cmpt_create ( uint_fast32_t tlx , uint_fast32_t tly , uint_fast32_t hstep , uint_fast32_t vstep , uint_fast32_t width , uint_fast32_t height , uint_fast16_t depth , bool sgnd , uint_fast32_t inmem ) { jas_image_cmpt_t * cmpt ; long size ; if ( ! ( cmpt = jas_malloc ( sizeof ( jas_image_cmpt_t ) ) ) ) { return 0 ; } cmpt -> type_ = JAS_IMAGE_CT_UNKNOWN ; cmpt -> tlx_ = tlx ; cmpt -> tly_ = tly ; cmpt -> hstep_ = hstep ; cmpt -> vstep_ = vstep ; cmpt -> width_ = width ; cmpt -> height_ = height ; cmpt -> prec_ = depth ; cmpt -> sgnd_ = sgnd ; cmpt -> stream_ = 0 ; cmpt -> cps_ = ( depth + 7 ) / 8 ; size = cmpt -> width_ * cmpt -> height_ * cmpt -> cps_ ; cmpt -> stream_ = ( inmem ) ? jas_stream_memopen ( 0 , size ) : jas_stream_tmpfile ( ) ; if ( ! cmpt -> stream_ ) { jas_image_cmpt_destroy ( cmpt ) ; return 0 ; } if ( jas_stream_seek ( cmpt -> stream_ , size - 1 , SEEK_SET ) < 0 || jas_stream_putc ( cmpt -> stream_ , 0 ) == EOF || jas_stream_seek ( cmpt -> stream_ , 0 , SEEK_SET ) < 0 ) { jas_image_cmpt_destroy ( cmpt ) ; return 0 ; } return cmpt ; }

debian

static void * mspack_fmap_alloc ( struct mspack_system * self , size_t num ) { return malloc ( num ) ; }

debian

static void test_fetch_long ( ) { int rc ; myheader ( "test_fetch_long" ) ; rc = mysql_query ( mysql , "DROP TABLE IF EXISTS test_bind_fetch" ) ; myquery ( rc ) ; rc = mysql_query ( mysql , "CREATE TABLE test_bind_fetch(c1 int unsigned, \ c2 int unsigned, \ c3 int, \ c4 int, \ c5 int, \ c6 int unsigned, \ c7 int)" ) ; myquery ( rc ) ; bind_fetch ( 4 ) ; }

debian

static int dissect_h225_FastStart ( tvbuff_t * tvb _U_ , int offset _U_ , asn1_ctx_t * actx _U_ , proto_tree * tree _U_ , int hf_index _U_ ) { offset = dissect_per_sequence_of ( tvb , offset , actx , tree , hf_index , ett_h225_FastStart , FastStart_sequence_of ) ; return offset ; }

debian

int compare_files ( const char * filename1 , const char * filename2 ) { File fd ; int error ; if ( ( fd = my_open ( filename1 , O_RDONLY , MYF ( 0 ) ) ) < 0 ) die ( "Failed to open first file: '%s'" , filename1 ) ; error = compare_files2 ( fd , filename2 ) ; my_close ( fd , MYF ( 0 ) ) ; return error ; }

debian

static Datum ExecEvalWholeRowSlow ( WholeRowVarExprState * wrvstate , ExprContext * econtext , bool * isNull , ExprDoneCond * isDone ) { Var * variable = ( Var * ) wrvstate -> xprstate . expr ; TupleTableSlot * slot ; HeapTuple tuple ; TupleDesc tupleDesc ; TupleDesc var_tupdesc ; HeapTupleHeader dtuple ; int i ; if ( isDone ) * isDone = ExprSingleResult ; * isNull = false ; switch ( variable -> varno ) { case INNER_VAR : slot = econtext -> ecxt_innertuple ; break ; case OUTER_VAR : slot = econtext -> ecxt_outertuple ; break ; default : slot = econtext -> ecxt_scantuple ; break ; } if ( wrvstate -> wrv_junkFilter != NULL ) slot = ExecFilterJunk ( wrvstate -> wrv_junkFilter , slot ) ; tuple = ExecFetchSlotTuple ( slot ) ; tupleDesc = slot -> tts_tupleDescriptor ; Assert ( variable -> vartype != RECORDOID ) ; var_tupdesc = wrvstate -> wrv_tupdesc ; for ( i = 0 ; i < var_tupdesc -> natts ; i ++ ) { Form_pg_attribute vattr = var_tupdesc -> attrs [ i ] ; Form_pg_attribute sattr = tupleDesc -> attrs [ i ] ; if ( ! vattr -> attisdropped ) continue ; if ( heap_attisnull ( tuple , i + 1 ) ) continue ; if ( vattr -> attlen != sattr -> attlen || vattr -> attalign != sattr -> attalign ) ereport ( ERROR , ( errcode ( ERRCODE_DATATYPE_MISMATCH ) , errmsg ( "table row type and query-specified row type do not match" ) , errdetail ( "Physical storage mismatch on dropped attribute at ordinal position %d." , i + 1 ) ) ) ; } dtuple = DatumGetHeapTupleHeader ( ExecFetchSlotTupleDatum ( slot ) ) ; HeapTupleHeaderSetTypeId ( dtuple , wrvstate -> wrv_tupdesc -> tdtypeid ) ; HeapTupleHeaderSetTypMod ( dtuple , wrvstate -> wrv_tupdesc -> tdtypmod ) ; return PointerGetDatum ( dtuple ) ; }

debian

static void pdf_set_colorspace ( fz_context * ctx , pdf_run_processor * pr , int what , fz_colorspace * colorspace ) { pdf_gstate * gstate = pr -> gstate + pr -> gtop ; pdf_material * mat ; int n = fz_colorspace_n ( ctx , colorspace ) ; gstate = pdf_flush_text ( ctx , pr ) ; mat = what == PDF_FILL ? & gstate -> fill : & gstate -> stroke ; fz_drop_colorspace ( ctx , mat -> colorspace ) ; mat -> kind = PDF_MAT_COLOR ; mat -> colorspace = fz_keep_colorspace ( ctx , colorspace ) ; mat -> v [ 0 ] = 0 ; mat -> v [ 1 ] = 0 ; mat -> v [ 2 ] = 0 ; mat -> v [ 3 ] = 1 ; if ( pdf_is_tint_colorspace ( ctx , colorspace ) ) { int i ; for ( i = 0 ; i < n ; i ++ ) mat -> v [ i ] = 1.0f ; } }

debian

static inline void SetPixelGrayTraits ( Image * image , const PixelTrait traits ) { image -> channel_map [ GrayPixelChannel ] . traits = traits ; }

debian

int dissect_h225_GenericData ( tvbuff_t * tvb _U_ , int offset _U_ , asn1_ctx_t * actx _U_ , proto_tree * tree _U_ , int hf_index _U_ ) { # line 828 "./asn1/h225/h225.cnf" void * priv_data = actx -> private_data ; gef_ctx_t * gefx ; gefx = gef_ctx_get ( actx -> private_data ) ; if ( ! gefx ) { gefx = gef_ctx_alloc ( NULL , "GenericData" ) ; actx -> private_data = gefx ; } offset = dissect_per_sequence ( tvb , offset , actx , tree , hf_index , ett_h225_GenericData , GenericData_sequence ) ; # line 838 "./asn1/h225/h225.cnf" actx -> private_data = priv_data ; return offset ; }

debian

static int x ( struct vcache * avc , int afun , struct vrequest * areq , \ struct afs_pdata * ain , struct afs_pdata * aout , \ afs_ucred_t * * acred ) DECL_PIOCTL ( PGetFID ) ; DECL_PIOCTL ( PSetAcl ) ; DECL_PIOCTL ( PStoreBehind ) ; DECL_PIOCTL ( PGCPAGs ) ; DECL_PIOCTL ( PGetAcl ) ; DECL_PIOCTL ( PNoop ) ; DECL_PIOCTL ( PBogus ) ; DECL_PIOCTL ( PGetFileCell ) ; DECL_PIOCTL ( PGetWSCell ) ; DECL_PIOCTL ( PGetUserCell ) ; DECL_PIOCTL ( PSetTokens ) ; DECL_PIOCTL ( PGetVolumeStatus ) ; DECL_PIOCTL ( PSetVolumeStatus ) ; DECL_PIOCTL ( PFlush ) ; DECL_PIOCTL ( PNewStatMount ) ; DECL_PIOCTL ( PGetTokens ) ; DECL_PIOCTL ( PUnlog ) ; DECL_PIOCTL ( PMariner ) ; DECL_PIOCTL ( PCheckServers ) ; DECL_PIOCTL ( PCheckVolNames ) ; DECL_PIOCTL ( PCheckAuth ) ; DECL_PIOCTL ( PFindVolume ) ; DECL_PIOCTL ( PViceAccess ) ; DECL_PIOCTL ( PSetCacheSize ) ; DECL_PIOCTL ( PGetCacheSize ) ; DECL_PIOCTL ( PRemoveCallBack ) ; DECL_PIOCTL ( PNewCell ) ; DECL_PIOCTL ( PNewAlias ) ; DECL_PIOCTL ( PListCells ) ; DECL_PIOCTL ( PListAliases ) ; DECL_PIOCTL ( PRemoveMount ) ; DECL_PIOCTL ( PGetCellStatus ) ; DECL_PIOCTL ( PSetCellStatus ) ; DECL_PIOCTL ( PFlushVolumeData ) ; DECL_PIOCTL ( PFlushAllVolumeData ) ; DECL_PIOCTL ( PGetVnodeXStatus ) ; DECL_PIOCTL ( PGetVnodeXStatus2 ) ; DECL_PIOCTL ( PSetSysName ) ; DECL_PIOCTL ( PSetSPrefs ) ; DECL_PIOCTL ( PSetSPrefs33 ) ; DECL_PIOCTL ( PGetSPrefs ) ; DECL_PIOCTL ( PExportAfs ) ; DECL_PIOCTL ( PGag ) ; DECL_PIOCTL ( PTwiddleRx ) ; DECL_PIOCTL ( PGetInitParams ) ; DECL_PIOCTL ( PGetRxkcrypt ) ; DECL_PIOCTL ( PSetRxkcrypt )