project stringclasses 2
values | commit_id stringlengths 40 40 | target int64 0 1 | func stringlengths 26 142k | idx int64 0 27.3k |
|---|---|---|---|---|
qemu | 61007b316cd71ee7333ff7a0a749a8949527575f | 0 | void bdrv_flush_io_queue(BlockDriverState *bs)
{
BlockDriver *drv = bs->drv;
if (drv && drv->bdrv_flush_io_queue) {
drv->bdrv_flush_io_queue(bs);
} else if (bs->file) {
bdrv_flush_io_queue(bs->file);
}
}
| 15,438 |
qemu | bff3063837a76b37a4bbbfe614324ca38e859f2b | 0 | static void rtas_event_log_queue(int log_type, void *data, bool exception)
{
sPAPRMachineState *spapr = SPAPR_MACHINE(qdev_get_machine());
sPAPREventLogEntry *entry = g_new(sPAPREventLogEntry, 1);
g_assert(data);
entry->log_type = log_type;
entry->exception = exception;
entry->data = da... | 15,439 |
qemu | 5e434f4e60f8e5a9dadf324b3ee31c3ce0e80165 | 0 | static int pci_set_default_subsystem_id(PCIDevice *pci_dev)
{
uint16_t *id;
id = (void*)(&pci_dev->config[PCI_SUBSYSTEM_VENDOR_ID]);
id[0] = cpu_to_le16(pci_default_sub_vendor_id);
id[1] = cpu_to_le16(pci_default_sub_device_id);
return 0;
}
| 15,440 |
qemu | 7e84c2498f0ff3999937d18d1e9abaa030400000 | 0 | static inline uint8_t *get_seg_base(uint32_t e1, uint32_t e2)
{
return (uint8_t *)((e1 >> 16) | ((e2 & 0xff) << 16) | (e2 & 0xff000000));
}
| 15,441 |
FFmpeg | 4cc1ce4a91788a71670ea43fa0026b5a969e9e9e | 0 | int ff_h264_decode_seq_parameter_set(GetBitContext *gb, AVCodecContext *avctx,
H264ParamSets *ps, int ignore_truncation)
{
AVBufferRef *sps_buf;
int profile_idc, level_idc, constraint_set_flags = 0;
unsigned int sps_id;
int i, log2_max_frame_num_minus4;
SP... | 15,442 |
qemu | e87f7778b64d4a6a78e16c288c7fdc6c15317d5f | 0 | static void invalidate_and_set_dirty(MemoryRegion *mr, hwaddr addr,
hwaddr length)
{
if (cpu_physical_memory_range_includes_clean(addr, length)) {
uint8_t dirty_log_mask = memory_region_get_dirty_log_mask(mr);
if (dirty_log_mask & (1 << DIRTY_MEMORY_CODE)) {... | 15,443 |
qemu | fba72476c6b7be60ac74c5bcdc06c61242d1fe4f | 0 | void ich9_lpc_pm_init(PCIDevice *lpc_pci)
{
ICH9LPCState *lpc = ICH9_LPC_DEVICE(lpc_pci);
ich9_pm_init(lpc_pci, &lpc->pm, qemu_allocate_irq(ich9_set_sci, lpc, 0));
ich9_lpc_reset(&lpc->d.qdev);
}
| 15,444 |
qemu | 7e2515e87c41e2e658aaed466e11cbdf1ea8bcb1 | 0 | static void term_show_prompt(void)
{
term_show_prompt2();
term_cmd_buf_index = 0;
term_cmd_buf_size = 0;
}
| 15,446 |
qemu | e37dac06dc4e85a2f46c24261c0dfdf2a30b50e3 | 0 | static int vfio_add_capabilities(VFIOPCIDevice *vdev)
{
PCIDevice *pdev = &vdev->pdev;
int ret;
if (!(pdev->config[PCI_STATUS] & PCI_STATUS_CAP_LIST) ||
!pdev->config[PCI_CAPABILITY_LIST]) {
return 0; /* Nothing to add */
}
ret = vfio_add_std_cap(vdev, pdev->config[PCI_CA... | 15,447 |
qemu | f17fd4fdf0df3d2f3444399d04c38d22b9a3e1b7 | 0 | static void test_qemu_strtosz_units(void)
{
const char *none = "1";
const char *b = "1B";
const char *k = "1K";
const char *m = "1M";
const char *g = "1G";
const char *t = "1T";
const char *p = "1P";
const char *e = "1E";
char *endptr = NULL;
int64_t res;
/* def... | 15,448 |
qemu | 42a268c241183877192c376d03bd9b6d527407c7 | 0 | static inline void gen_op_arith_divd(DisasContext *ctx, TCGv ret, TCGv arg1,
TCGv arg2, int sign, int compute_ov)
{
int l1 = gen_new_label();
int l2 = gen_new_label();
tcg_gen_brcondi_i64(TCG_COND_EQ, arg2, 0, l1);
if (sign) {
int l3 = gen_new_label(... | 15,450 |
qemu | ea26ce765cb661a13e4055f38744036a19465e87 | 0 | static int os_host_main_loop_wait(int timeout)
{
int ret, i;
PollingEntry *pe;
WaitObjects *w = &wait_objects;
static struct timeval tv0;
/* XXX: need to suppress polling by better using win32 events */
ret = 0;
for (pe = first_polling_entry; pe != NULL; pe = pe->next) {
r... | 15,451 |
FFmpeg | 90901860c21468d6e9ae437c2bacb099c7bd3acf | 0 | static int asf_write_header(AVFormatContext *s)
{
ASFContext *asf = s->priv_data;
asf->packet_size = PACKET_SIZE;
asf->nb_packets = 0;
asf->last_indexed_pts = 0;
asf->index_ptr = (ASFIndex*)av_malloc( sizeof(ASFIndex) * ASF_INDEX_BLOCK );
asf->nb_index_memory_alloc = ASF_INDEX_BLOCK;
... | 15,452 |
qemu | 4a1418e07bdcfaa3177739e04707ecaec75d89e1 | 0 | static int do_syscall(CPUState *env,
struct kqemu_cpu_state *kenv)
{
int selector;
selector = (env->star >> 32) & 0xffff;
#ifdef TARGET_X86_64
if (env->hflags & HF_LMA_MASK) {
int code64;
env->regs[R_ECX] = kenv->next_eip;
env->regs[11] = env->eflag... | 15,453 |
qemu | 5819e3e072f41cbf81ad80d822a5c468a91f54e0 | 0 | gdb_handlesig(CPUState *cpu, int sig)
{
GDBState *s;
char buf[256];
int n;
s = gdbserver_state;
if (gdbserver_fd < 0 || s->fd < 0) {
return sig;
}
/* disable single step if it was enabled */
cpu_single_step(cpu, 0);
tb_flush(cpu);
if (sig != 0) {
... | 15,454 |
qemu | cd1ba7de230b3a85fb4dba53bb681b7ea626b4eb | 0 | void xen_map_cache_init(void)
{
unsigned long size;
struct rlimit rlimit_as;
mapcache = g_malloc0(sizeof (MapCache));
QTAILQ_INIT(&mapcache->locked_entries);
mapcache->last_address_index = -1;
if (geteuid() == 0) {
rlimit_as.rlim_cur = RLIM_INFINITY;
rlimit_as.rlim... | 15,455 |
qemu | 264813cb9d0eea199d48c6ea917060683685d1e0 | 0 | static void nvdimm_build_nfit(AcpiNVDIMMState *state, GArray *table_offsets,
GArray *table_data, BIOSLinker *linker)
{
NvdimmFitBuffer *fit_buf = &state->fit_buf;
unsigned int header;
/* NVDIMM device is not plugged? */
if (!fit_buf->fit->len) {
return;
... | 15,456 |
qemu | 185698715dfb18c82ad2a5dbc169908602d43e81 | 0 | static inline uint32_t efsctui(uint32_t val)
{
CPU_FloatU u;
u.l = val;
/* NaN are not treated the same way IEEE 754 does */
if (unlikely(float32_is_nan(u.f)))
return 0;
return float32_to_uint32(u.f, &env->vec_status);
}
| 15,459 |
qemu | 61007b316cd71ee7333ff7a0a749a8949527575f | 0 | BlockAIOCB *bdrv_aio_ioctl(BlockDriverState *bs,
unsigned long int req, void *buf,
BlockCompletionFunc *cb, void *opaque)
{
BlockDriver *drv = bs->drv;
if (drv && drv->bdrv_aio_ioctl)
return drv->bdrv_aio_ioctl(bs, req, buf, cb, opaque);
return NULL;
}
| 15,460 |
qemu | af5374aa044af8ebc5a7dd387ea0dec48b5d956b | 0 | static int lsi_scsi_init(PCIDevice *dev)
{
LSIState *s = DO_UPCAST(LSIState, dev, dev);
uint8_t *pci_conf;
pci_conf = s->dev.config;
/* PCI Vendor ID (word) */
pci_config_set_vendor_id(pci_conf, PCI_VENDOR_ID_LSI_LOGIC);
/* PCI device ID (word) */
pci_config_set_device_id(pci_con... | 15,461 |
qemu | 582b55a96ac4f66cea64d82e47651bd5ef38a8ec | 0 | void cpu_physical_memory_write_rom(hwaddr addr,
const uint8_t *buf, int len)
{
hwaddr l;
uint8_t *ptr;
hwaddr addr1;
MemoryRegion *mr;
while (len > 0) {
l = len;
mr = address_space_translate(&address_space_memory,
... | 15,462 |
FFmpeg | 851ded8918c977d8160c6617b69604f758cabf50 | 0 | static int decode_cabac_mb_type( H264Context *h ) {
MpegEncContext * const s = &h->s;
if( h->slice_type == I_TYPE ) {
return decode_cabac_intra_mb_type(h, 3, 1);
} else if( h->slice_type == P_TYPE ) {
if( get_cabac( &h->cabac, &h->cabac_state[14] ) == 0 ) {
/* P-type */
... | 15,464 |
qemu | 2a5ff735dc1074171a0cbb1dc228d6d6e907f571 | 0 | static int ehci_state_fetchentry(EHCIState *ehci, int async)
{
int again = 0;
uint32_t entry = ehci_get_fetch_addr(ehci, async);
if (entry < 0x1000) {
DPRINTF("fetchentry: entry invalid (0x%08x)\n", entry);
ehci_set_state(ehci, async, EST_ACTIVE);
goto out;
}
/* ... | 15,465 |
qemu | 72cf2d4f0e181d0d3a3122e04129c58a95da713e | 0 | static int ssi_slave_init(DeviceState *dev, DeviceInfo *base_info)
{
SSISlaveInfo *info = container_of(base_info, SSISlaveInfo, qdev);
SSISlave *s = SSI_SLAVE_FROM_QDEV(dev);
SSIBus *bus;
bus = FROM_QBUS(SSIBus, qdev_get_parent_bus(dev));
if (LIST_FIRST(&bus->qbus.children) != dev
|... | 15,466 |
qemu | 2a1639291bf9f3c88c62d10459fedaa677536ff5 | 0 | struct pxa2xx_state_s *pxa255_init(unsigned int sdram_size,
DisplayState *ds)
{
struct pxa2xx_state_s *s;
struct pxa2xx_ssp_s *ssp;
int iomemtype, i;
s = (struct pxa2xx_state_s *) qemu_mallocz(sizeof(struct pxa2xx_state_s));
s->env = cpu_init();
cpu_arm_set_model(s->env... | 15,467 |
qemu | a8170e5e97ad17ca169c64ba87ae2f53850dab4c | 0 | void stq_le_phys(target_phys_addr_t addr, uint64_t val)
{
val = cpu_to_le64(val);
cpu_physical_memory_write(addr, &val, 8);
}
| 15,468 |
qemu | e508a92b621c7160122e99d3754e568f2b8e255e | 0 | static int arm946_prbs_write(CPUARMState *env, const ARMCPRegInfo *ri,
uint64_t value)
{
if (ri->crm >= 8) {
return EXCP_UDEF;
}
env->cp15.c6_region[ri->crm] = value;
return 0;
}
| 15,469 |
qemu | 21d5d12bb0ad4de7cc92a7a2d018e7ec0f9fd148 | 0 | static int64_t get_clock(void)
{
#if defined(__linux__) || (defined(__FreeBSD__) && __FreeBSD_version >= 500000) \
|| defined(__DragonFly__)
if (use_rt_clock) {
struct timespec ts;
clock_gettime(CLOCK_MONOTONIC, &ts);
return ts.tv_sec * 1000000000LL + ts.tv_nsec;
} else
#endif
... | 15,470 |
qemu | f8b0aa25599782eef91edc00ebf620bd14db720c | 0 | static void setup_frame(int sig, struct emulated_sigaction * ka,
target_sigset_t *set, CPUState *regs)
{
struct sigframe *frame;
abi_ulong frame_addr;
int i;
frame_addr = get_sigframe(ka, regs, sizeof(*frame));
if (!lock_user_struct(VERIFY_WRITE, frame, frame_addr, 0... | 15,471 |
qemu | 0d7937974cd0504f30ad483c3368b21da426ddf9 | 0 | static void vmsvga_text_update(void *opaque, console_ch_t *chardata)
{
struct vmsvga_state_s *s = opaque;
if (s->vga.text_update)
s->vga.text_update(&s->vga, chardata);
}
| 15,473 |
qemu | 3cf0bed8369267184e5dc5b58882811519d67437 | 0 | static int send_response(GAState *s, QObject *payload)
{
const char *buf;
QString *payload_qstr;
GIOStatus status;
g_assert(payload && s->channel);
payload_qstr = qobject_to_json(payload);
if (!payload_qstr) {
return -EINVAL;
}
qstring_append_chr(payload_qstr, '\n... | 15,474 |
qemu | e8ede0a8bb5298a6979bcf7ed84ef64a64a4e3fe | 0 | float64 HELPER(ucf64_addd)(float64 a, float64 b, CPUUniCore32State *env)
{
return float64_add(a, b, &env->ucf64.fp_status);
}
| 15,475 |
qemu | d57e4e482e3997b1382625c84149ad0b69155fc0 | 0 | static void term_exit(void)
{
tcsetattr (0, TCSANOW, &oldtty);
}
| 15,477 |
qemu | c2b38b277a7882a592f4f2ec955084b2b756daaa | 0 | void timer_mod_ns(QEMUTimer *ts, int64_t expire_time)
{
QEMUTimerList *timer_list = ts->timer_list;
bool rearm;
qemu_mutex_lock(&timer_list->active_timers_lock);
timer_del_locked(timer_list, ts);
rearm = timer_mod_ns_locked(timer_list, ts, expire_time);
qemu_mutex_unlock(&timer_list->ac... | 15,478 |
qemu | aad15de4275d2fc90acdf6101493dfee4e39b803 | 0 | static int convert_do_copy(ImgConvertState *s)
{
uint8_t *buf = NULL;
int64_t sector_num, allocated_done;
int ret;
int n;
/* Check whether we have zero initialisation or can get it efficiently */
s->has_zero_init = s->min_sparse && !s->target_has_backing
? bdrv_has... | 15,479 |
qemu | b3db211f3c80bb996a704d665fe275619f728bd4 | 0 | static void test_visitor_in_native_list_uint16(TestInputVisitorData *data,
const void *unused)
{
test_native_list_integer_helper(data, unused,
USER_DEF_NATIVE_LIST_UNION_KIND_U16);
}
| 15,480 |
qemu | 6ef4716cecdfa1b3794c1a33edba9840e1aa6b5f | 0 | static void validate_bootdevices(char *devices)
{
/* We just do some generic consistency checks */
const char *p;
int bitmap = 0;
for (p = devices; *p != '\0'; p++) {
/* Allowed boot devices are:
* a-b: floppy disk drives
* c-f: IDE disk drives
* g-m: machin... | 15,481 |
qemu | 75973bfe415774babe7c1e18fa682c050fdce73b | 0 | void s390_add_running_cpu(S390CPU *cpu)
{
CPUState *cs = CPU(cpu);
if (cs->halted) {
s390_running_cpus++;
cs->halted = 0;
cs->exception_index = -1;
}
}
| 15,483 |
qemu | 079d0b7f1eedcc634c371fe05b617fdc55c8b762 | 0 | static int usb_audio_handle_data(USBDevice *dev, USBPacket *p)
{
USBAudioState *s = (USBAudioState *) dev;
int ret = 0;
switch (p->pid) {
case USB_TOKEN_OUT:
switch (p->devep) {
case 1:
ret = usb_audio_handle_dataout(s, p);
break;
default:
... | 15,484 |
qemu | ade0d0c0d3a0444c626ec5f46ef75af7395236f6 | 0 | int arm_cpu_write_elf32_note(WriteCoreDumpFunction f, CPUState *cs,
int cpuid, void *opaque)
{
struct arm_note note;
CPUARMState *env = &ARM_CPU(cs)->env;
DumpState *s = opaque;
int ret, i;
arm_note_init(¬e, s, "CORE", 5, NT_PRSTATUS, sizeof(note.prstatus));
... | 15,485 |
FFmpeg | d24e08e978792e09d212018677d1c0b8208ecef8 | 0 | static int write_manifest(AVFormatContext *s, int final)
{
DASHContext *c = s->priv_data;
AVIOContext *out;
char temp_filename[1024];
int ret, i;
const char *proto = avio_find_protocol_name(s->filename);
int use_rename = proto && !strcmp(proto, "file");
static unsigned int warned_non... | 15,487 |
qemu | 63f0f45f2e89b60ff8245fec81328ddfde42a303 | 0 | static void curl_close(BlockDriverState *bs)
{
BDRVCURLState *s = bs->opaque;
int i;
DPRINTF("CURL: Close\n");
for (i=0; i<CURL_NUM_STATES; i++) {
if (s->states[i].in_use)
curl_clean_state(&s->states[i]);
if (s->states[i].curl) {
curl_easy_cleanup(s->st... | 15,488 |
qemu | b5302e1a9d8a47bd29a3e1876fba34be111728a2 | 0 | if_output(struct socket *so, struct mbuf *ifm)
{
struct mbuf *ifq;
int on_fastq = 1;
DEBUG_CALL("if_output");
DEBUG_ARG("so = %lx", (long)so);
DEBUG_ARG("ifm = %lx", (long)ifm);
/*
* First remove the mbuf from m_usedlist,
* since we're gonna use m_next and m_prev ourselves
* XXX Shouldn't need... | 15,490 |
qemu | e3f5ec2b5e92706e3b807059f79b1fb5d936e567 | 0 | static int ne2000_can_receive(void *opaque)
{
NE2000State *s = opaque;
if (s->cmd & E8390_STOP)
return 1;
return !ne2000_buffer_full(s);
}
| 15,491 |
qemu | 9b5b76d44930dc9266bb6d30862704cb3c86d2ca | 0 | static void *bochs_bios_init(void)
{
void *fw_cfg;
uint8_t *smbios_table;
size_t smbios_len;
uint64_t *numa_fw_cfg;
int i, j;
register_ioport_write(0x400, 1, 2, bochs_bios_write, NULL);
register_ioport_write(0x401, 1, 2, bochs_bios_write, NULL);
register_ioport_write(0x402, 1,... | 15,493 |
qemu | e2779de053b64f023de382fd87b3596613d47d1e | 0 | static int xen_pt_word_reg_read(XenPCIPassthroughState *s, XenPTReg *cfg_entry,
uint16_t *value, uint16_t valid_mask)
{
XenPTRegInfo *reg = cfg_entry->reg;
uint16_t valid_emu_mask = 0;
/* emulate word register */
valid_emu_mask = reg->emu_mask & valid_mask;
*... | 15,494 |
qemu | f0536bb848ad6eb2709a7dc675f261bd160c751b | 0 | static int img_rebase(int argc, char **argv)
{
BlockDriverState *bs, *bs_old_backing = NULL, *bs_new_backing = NULL;
BlockDriver *old_backing_drv, *new_backing_drv;
char *filename;
const char *fmt, *cache, *out_basefmt, *out_baseimg;
int c, flags, ret;
int unsafe = 0;
int progress = ... | 15,496 |
FFmpeg | 3e2b6358e0c9744aee2a024c2be8e51e8900b0b1 | 0 | int get_buffer(ByteIOContext *s, unsigned char *buf, int size)
{
int len, size1;
size1 = size;
while (size > 0) {
len = s->buf_end - s->buf_ptr;
if (len > size)
len = size;
if (len == 0) {
fill_buffer(s);
len = s->buf_end - s->buf_ptr;
... | 15,497 |
FFmpeg | c3bd1d60af97e8d2568dac9fcce7bdabb4ff93c8 | 0 | AVFilterFormats *ff_make_format_list(const int *fmts)
{
AVFilterFormats *formats;
int count;
for (count = 0; fmts[count] != -1; count++)
;
formats = av_mallocz(sizeof(*formats));
if (count)
formats->formats = av_malloc(sizeof(*formats->formats) * count);
... | 15,498 |
qemu | 12f8def0e02232d7c6416ad9b66640f973c531d1 | 1 | void qemu_cond_destroy(QemuCond *cond)
{
BOOL result;
result = CloseHandle(cond->continue_event);
if (!result) {
error_exit(GetLastError(), __func__);
}
cond->continue_event = 0;
result = CloseHandle(cond->sema);
if (!result) {
error_exit(GetLastError(), __func__);
... | 15,500 |
qemu | d8fd2954996255ba6ad610917e7849832d0120b7 | 1 | static inline void gen_intermediate_code_internal(CPUARMState *env,
TranslationBlock *tb,
int search_pc)
{
DisasContext dc1, *dc = &dc1;
CPUBreakpoint *bp;
uint16_t *gen_opc_end;
int j, lj;
ta... | 15,502 |
qemu | 2bf3aa85f08186b8162b76e7e8efe5b5a44306a6 | 1 | static int ram_save_page(RAMState *rs, PageSearchStatus *pss, bool last_stage)
{
int pages = -1;
uint64_t bytes_xmit;
ram_addr_t current_addr;
uint8_t *p;
int ret;
bool send_async = true;
RAMBlock *block = pss->block;
ram_addr_t offset = pss->page << TARGET_PAGE_BITS;
p =... | 15,503 |
qemu | 4dedc07ffbbc66002e0fd2b97d5516fe6aca5eea | 1 | static inline int vmsvga_fifo_empty(struct vmsvga_state_s *s)
{
if (!s->config || !s->enable)
return 1;
return (s->cmd->next_cmd == s->cmd->stop);
}
| 15,504 |
FFmpeg | 6f1ccca4ae3b93b6a2a820a7a0e72081ab35767c | 0 | static int dnxhd_decode_dct_block_10_444(const DNXHDContext *ctx,
RowContext *row, int n)
{
return dnxhd_decode_dct_block(ctx, row, n, 6, 32, 6);
}
| 15,505 |
FFmpeg | b74ecb82fa51aba52a95992668546afe8ed2bd9f | 0 | av_cold int swri_rematrix_init(SwrContext *s){
int i, j;
int nb_in = av_get_channel_layout_nb_channels(s->in_ch_layout);
int nb_out = av_get_channel_layout_nb_channels(s->out_ch_layout);
s->mix_any_f = NULL;
if (!s->rematrix_custom) {
int r = auto_matrix(s);
if (r)
... | 15,506 |
FFmpeg | 7c2e31d1f0198fad23cddbd8f206a04173fe6d0d | 0 | static int unpack_modes(Vp3DecodeContext *s, GetBitContext *gb)
{
int i, j, k, sb_x, sb_y;
int scheme;
int current_macroblock;
int current_fragment;
int coding_mode;
int custom_mode_alphabet[CODING_MODE_COUNT];
if (s->keyframe) {
for (i = 0; i < s->fragment_count; i++)
... | 15,507 |
FFmpeg | 3646ef6f7c0c02dc6d2f393f9fd0f6ebcbf15b44 | 0 | static int h264_probe(AVProbeData *p)
{
uint32_t code = -1;
int sps = 0, pps = 0, idr = 0, res = 0, sli = 0;
int i;
for (i = 0; i < p->buf_size; i++) {
code = (code << 8) + p->buf[i];
if ((code & 0xffffff00) == 0x100) {
int ref_idc = (code >> 5) & 3;
in... | 15,508 |
FFmpeg | 373211d828f351d86908d47828444f620bfd176d | 0 | static int mov_write_tapt_tag(AVIOContext *pb, MOVTrack *track)
{
int32_t width = av_rescale(track->enc->sample_aspect_ratio.num, track->enc->width,
track->enc->sample_aspect_ratio.den);
int64_t pos = avio_tell(pb);
avio_wb32(pb, 0); /* size */
ffio_wfourcc(pb, "... | 15,509 |
FFmpeg | d1adad3cca407f493c3637e20ecd4f7124e69212 | 0 | static inline void RENAME(rgb24ToUV_half)(uint8_t *dstU, uint8_t *dstV, const uint8_t *src1, const uint8_t *src2, long width, uint32_t *unused)
{
int i;
assert(src1==src2);
for (i=0; i<width; i++) {
int r= src1[6*i + 0] + src1[6*i + 3];
int g= src1[6*i + 1] + src1[6*i + 4];
in... | 15,510 |
FFmpeg | 6a37abc59af4d87d4c55f7d812ac62d4d6a7464b | 0 | static inline int parse_nal_units(AVCodecParserContext *s,
AVCodecContext *avctx,
const uint8_t * const buf, int buf_size)
{
H264ParseContext *p = s->priv_data;
H2645NAL nal = { NULL };
int buf_index, next_avc;
unsigned int pps_i... | 15,511 |
qemu | 1f9296b51a26650916a2c4191268bb64057bdc5f | 1 | static void balloon_stats_change_timer(VirtIOBalloon *s, int secs)
{
timer_mod(s->stats_timer, qemu_clock_get_ms(QEMU_CLOCK_VIRTUAL) + secs * 1000);
}
| 15,512 |
FFmpeg | 3a1a7e32ace7af47de74e8ae779cb4e04c89aa97 | 1 | static int tta_decode_init(AVCodecContext * avctx)
{
TTAContext *s = avctx->priv_data;
int i;
s->avctx = avctx;
// 30bytes includes a seektable with one frame
if (avctx->extradata_size < 30)
init_get_bits(&s->gb, avctx->extradata, avctx->extradata_size);
if (show_bits_long(&s->gb, 32) == bsw... | 15,513 |
FFmpeg | bf5af5687569e34d6e3a4d31fc6bb5dc44efdb29 | 1 | void show_licence(void)
{
printf(
"ffmpeg version " FFMPEG_VERSION "\n"
"Copyright (c) 2000, 2001, 2002 Gerard Lantau\n"
"This program is free software; you can redistribute it and/or modify\n"
"it under the terms of the GNU General Public License as published by\n"
"the Free Software Fou... | 15,516 |
qemu | 449041d4db1f82f281fe097e832f07cd9ee1e864 | 1 | static int parse_hex64(DeviceState *dev, Property *prop, const char *str)
{
uint64_t *ptr = qdev_get_prop_ptr(dev, prop);
if (sscanf(str, "%" PRIx64, ptr) != 1)
return -EINVAL;
return 0;
}
| 15,518 |
qemu | a9a72aeefbd3ef8bcbbeeccaf174ee10db2978ac | 1 | const TPMDriverOps *tpm_get_backend_driver(const char *type)
{
int i;
for (i = 0; i < TPM_MAX_DRIVERS && be_drivers[i] != NULL; i++) {
if (!strcmp(TpmType_lookup[be_drivers[i]->type], type)) {
return be_drivers[i];
}
}
return NULL;
}
| 15,519 |
qemu | c2b38b277a7882a592f4f2ec955084b2b756daaa | 0 | static void glib_pollfds_fill(int64_t *cur_timeout)
{
GMainContext *context = g_main_context_default();
int timeout = 0;
int64_t timeout_ns;
int n;
g_main_context_prepare(context, &max_priority);
glib_pollfds_idx = gpollfds->len;
n = glib_n_poll_fds;
do {
GPollFD *p... | 15,522 |
qemu | a8170e5e97ad17ca169c64ba87ae2f53850dab4c | 0 | static uint64_t musicpal_misc_read(void *opaque, target_phys_addr_t offset,
unsigned size)
{
switch (offset) {
case MP_MISC_BOARD_REVISION:
return MP_BOARD_REVISION;
default:
return 0;
}
}
| 15,525 |
qemu | a5b8dd2ce83208cd7d6eb4562339ecf5aae13574 | 0 | static void dmg_refresh_limits(BlockDriverState *bs, Error **errp)
{
bs->request_alignment = BDRV_SECTOR_SIZE; /* No sub-sector I/O supported */
}
| 15,527 |
qemu | 7c72ac49ae9f38fa0125296e05988655157decb5 | 0 | static void sigp_store_adtl_status(void *arg)
{
SigpInfo *si = arg;
if (!kvm_check_extension(kvm_state, KVM_CAP_S390_VECTOR_REGISTERS)) {
set_sigp_status(si, SIGP_STAT_INVALID_ORDER);
return;
}
/* cpu has to be stopped */
if (s390_cpu_get_state(si->cpu) != CPU_STATE_STOPP... | 15,528 |
qemu | bdb5ee3064d5ae786b0bcb6cf6ff4e3554a72990 | 0 | static void rom_reset(void *unused)
{
Rom *rom;
QTAILQ_FOREACH(rom, &roms, next) {
if (rom->fw_file) {
continue;
}
if (rom->data == NULL)
continue;
cpu_physical_memory_write_rom(rom->addr, rom->data, rom->romsize);
if (rom->isrom) {
... | 15,529 |
FFmpeg | 6c7f1155bb648eced8e5aa08b1fd490df2f8b325 | 0 | static void mp3_parse_info_tag(AVFormatContext *s, AVStream *st,
MPADecodeHeader *c, uint32_t spf)
{
#define LAST_BITS(k, n) ((k) & ((1 << (n)) - 1))
#define MIDDLE_BITS(k, m, n) LAST_BITS((k) >> (m), ((n) - (m)))
uint16_t crc;
uint32_t v;
char version[10];
u... | 15,531 |
FFmpeg | cd15b7c03d8df29d4c69b0620cf27d4a8c9dfb65 | 0 | int av_samples_alloc(uint8_t **audio_data, int *linesize, int nb_channels,
int nb_samples, enum AVSampleFormat sample_fmt, int align)
{
uint8_t *buf;
int size = av_samples_get_buffer_size(NULL, nb_channels, nb_samples,
sample_fmt, align);
... | 15,532 |
qemu | 8e682019e37c8f8939244fcf44a592fa6347d127 | 0 | static void do_interrupt_protected(int intno, int is_int, int error_code,
unsigned int next_eip, int is_hw)
{
SegmentCache *dt;
uint8_t *ptr, *ssp;
int type, dpl, selector, ss_dpl, cpl, sp_mask;
int has_error_code, new_stack, shift;
uint32_t e1, e2, offset, ... | 15,533 |
qemu | 364031f17932814484657e5551ba12957d993d7e | 0 | static int v9fs_synth_remove(FsContext *ctx, const char *path)
{
errno = EPERM;
return -1;
}
| 15,536 |
qemu | 42a268c241183877192c376d03bd9b6d527407c7 | 0 | static void dec_b(DisasContext *dc)
{
if (dc->r0 == R_RA) {
LOG_DIS("ret\n");
} else if (dc->r0 == R_EA) {
LOG_DIS("eret\n");
} else if (dc->r0 == R_BA) {
LOG_DIS("bret\n");
} else {
LOG_DIS("b r%d\n", dc->r0);
}
/* restore IE.IE in case of an eret */... | 15,538 |
qemu | b2c98d9d392c87c9b9e975d30f79924719d9cbbe | 0 | static void query_facilities(void)
{
unsigned long hwcap = qemu_getauxval(AT_HWCAP);
/* Is STORE FACILITY LIST EXTENDED available? Honestly, I believe this
is present on all 64-bit systems, but let's check for it anyway. */
if (hwcap & HWCAP_S390_STFLE) {
register int r0 __asm__("0"... | 15,539 |
qemu | 41ecc72ba5932381208e151bf2d2149a0342beff | 0 | static void setup_rt_frame(int sig, struct target_sigaction *ka,
target_siginfo_t *info,
target_sigset_t *set, CPUOpenRISCState *env)
{
int err = 0;
abi_ulong frame_addr;
unsigned long return_ip;
struct target_rt_sigframe *frame;
abi_ulon... | 15,540 |
qemu | 81f17e0d435c3db3a3e67e0d32ebf9c98973211f | 0 | static void imx_enet_do_tx(IMXFECState *s)
{
int frame_size = 0;
uint8_t frame[ENET_MAX_FRAME_SIZE];
uint8_t *ptr = frame;
uint32_t addr = s->tx_descriptor;
while (1) {
IMXENETBufDesc bd;
int len;
imx_enet_read_bd(&bd, addr);
FEC_PRINTF("tx_bd %x flags %... | 15,541 |
qemu | a8170e5e97ad17ca169c64ba87ae2f53850dab4c | 0 | static uint64_t ne2000_read(void *opaque, target_phys_addr_t addr,
unsigned size)
{
NE2000State *s = opaque;
if (addr < 0x10 && size == 1) {
return ne2000_ioport_read(s, addr);
} else if (addr == 0x10) {
if (size <= 2) {
return ne2000_asic_io... | 15,542 |
FFmpeg | 4b1f5e5090abed6c618c8ba380cd7d28d140f867 | 0 | static const OptionDef *find_option(const OptionDef *po, const char *name)
{
const char *p = strchr(name, ':');
int len = p ? p - name : strlen(name);
while (po->name != NULL) {
if (!strncmp(name, po->name, len) && strlen(po->name) == len)
break;
po++;
}
return... | 15,543 |
qemu | 8d551c988e96ac4cfe462e6b34d513bba2da572f | 0 | uint32 float64_to_uint32( float64 a STATUS_PARAM )
{
int64_t v;
uint32 res;
v = float64_to_int64(a STATUS_VAR);
if (v < 0) {
res = 0;
float_raise( float_flag_invalid STATUS_VAR);
} else if (v > 0xffffffff) {
res = 0xffffffff;
float_raise( float_flag_invali... | 15,544 |
qemu | 51b19ebe4320f3dcd93cea71235c1219318ddfd2 | 0 | static void virtio_gpu_handle_cursor(VirtIODevice *vdev, VirtQueue *vq)
{
VirtIOGPU *g = VIRTIO_GPU(vdev);
VirtQueueElement elem;
size_t s;
struct virtio_gpu_update_cursor cursor_info;
if (!virtio_queue_ready(vq)) {
return;
}
while (virtqueue_pop(vq, &elem)) {
s =... | 15,545 |
qemu | e1123a3b40a1a9a625a29c8ed4debb7e206ea690 | 0 | static int iscsi_truncate(BlockDriverState *bs, int64_t offset)
{
IscsiLun *iscsilun = bs->opaque;
Error *local_err = NULL;
if (iscsilun->type != TYPE_DISK) {
return -ENOTSUP;
}
iscsi_readcapacity_sync(iscsilun, &local_err);
if (local_err != NULL) {
error_free(local_... | 15,546 |
qemu | 4a1418e07bdcfaa3177739e04707ecaec75d89e1 | 0 | static void save_native_fp_fxsave(CPUState *env)
{
struct fpxstate *fp = &fpx1;
int fptag, i, j;
uint16_t fpuc;
asm volatile ("fxsave %0" : : "m" (*fp));
env->fpuc = fp->fpuc;
env->fpstt = (fp->fpus >> 11) & 7;
env->fpus = fp->fpus & ~0x3800;
fptag = fp->fptag ^ 0xff;
for... | 15,547 |
qemu | 1085daf9411e355ce3bd6d7034e23a8405599889 | 0 | static int vmdk_create(const char *filename, QemuOpts *opts, Error **errp)
{
int idx = 0;
BlockDriverState *new_bs = NULL;
Error *local_err = NULL;
char *desc = NULL;
int64_t total_size = 0, filesize;
char *adapter_type = NULL;
char *backing_file = NULL;
char *fmt = NULL;
i... | 15,548 |
qemu | b64bd51efa9bbf30df1b2f91477d2805678d0b93 | 0 | void bdrv_reset_dirty_bitmap(BdrvDirtyBitmap *bitmap,
int64_t cur_sector, int64_t nr_sectors)
{
assert(bdrv_dirty_bitmap_enabled(bitmap));
hbitmap_reset(bitmap->bitmap, cur_sector, nr_sectors);
}
| 15,551 |
FFmpeg | b1306823d0b3ae998c8e10ad832004eb13bdd93e | 0 | static int set_string(void *obj, const AVOption *o, const char *val, uint8_t **dst)
{
av_freep(dst);
*dst = av_strdup(val);
return 0;
}
| 15,553 |
FFmpeg | 7631f14bb35e8467d4ffaaa2b34e60614eb37c71 | 0 | static int mkv_write_native_codecprivate(AVFormatContext *s,
AVCodecParameters *par,
AVIOContext *dyn_cp)
{
switch (par->codec_id) {
case AV_CODEC_ID_VORBIS:
case AV_CODEC_ID_THEORA:
return put_xiph_codecpriv(s,... | 15,554 |
qemu | 6f9b6d57ae3cd8a5f82e06f79d22e7a591116b5b | 1 | static void set_cfg_value(bool is_max, int index, int value)
{
if (is_max) {
cfg.buckets[index].max = value;
} else {
cfg.buckets[index].avg = value;
}
} | 15,556 |
qemu | b952b5589a36114e06201c0d2e82c293dbad2b1f | 1 | static int coroutine_fn mirror_iteration(MirrorBlockJob *s)
{
BlockDriverState *source = s->common.bs;
BlockDriverState *target = s->target;
QEMUIOVector qiov;
int ret, nb_sectors;
int64_t end;
struct iovec iov;
end = s->common.len >> BDRV_SECTOR_BITS;
s->sector_num = bdrv_get... | 15,557 |
qemu | 2b9d09bb3c44de934de03864d56ddd8a38ed863a | 1 | static void decode_rr_divide(CPUTriCoreState *env, DisasContext *ctx)
{
uint32_t op2;
int r1, r2, r3;
TCGv temp, temp2;
op2 = MASK_OP_RR_OP2(ctx->opcode);
r3 = MASK_OP_RR_D(ctx->opcode);
r2 = MASK_OP_RR_S2(ctx->opcode);
r1 = MASK_OP_RR_S1(ctx->opcode);
switch (op2) {
... | 15,558 |
qemu | df4938a6651b1f980018f9eaf86af43e6b9d7fed | 1 | static int local_unlinkat(FsContext *ctx, V9fsPath *dir,
const char *name, int flags)
{
int ret;
V9fsString fullname;
char *buffer;
v9fs_string_init(&fullname);
v9fs_string_sprintf(&fullname, "%s/%s", dir->data, name);
if (ctx->export_flags & V9FS_SM_MAPPED_... | 15,559 |
qemu | ce8f0905a59232982c8a220169e11c14c73e7dea | 1 | static uint64_t pl011_read(void *opaque, hwaddr offset,
unsigned size)
{
PL011State *s = (PL011State *)opaque;
uint32_t c;
if (offset >= 0xfe0 && offset < 0x1000) {
return s->id[(offset - 0xfe0) >> 2];
}
switch (offset >> 2) {
case 0: /* UARTDR */
... | 15,560 |
qemu | a069e2f1372a0a823ab506fc019852a2a652aa54 | 1 | static BlockAIOCB *inject_error(BlockDriverState *bs,
BlockCompletionFunc *cb, void *opaque, BlkdebugRule *rule)
{
BDRVBlkdebugState *s = bs->opaque;
int error = rule->options.inject.error;
struct BlkdebugAIOCB *acb;
QEMUBH *bh;
if (rule->options.inject.once) {
QSIMPLEQ_INIT(&s... | 15,561 |
qemu | d25a7dabf242163ce95b60f6f75cf017b1715d55 | 1 | static void colo_old_packet_check_one_conn(void *opaque,
void *user_data)
{
Connection *conn = opaque;
GList *result = NULL;
int64_t check_time = REGULAR_PACKET_CHECK_MS;
result = g_queue_find_custom(&conn->primary_list,
... | 15,562 |
qemu | eba2af633fb8fa3b20ad578184d79e1f0eabcefe | 1 | int bdrv_open(BlockDriverState *bs, const char *filename, int snapshot)
{
int fd;
int64_t size;
struct cow_header_v2 cow_header;
#ifndef _WIN32
char template[] = "/tmp/vl.XXXXXX";
int cow_fd;
struct stat st;
#endif
bs->read_only = 0;
bs->fd = -1;
bs->cow_fd = -1;
b... | 15,563 |
qemu | cbf82fa01e6fd4ecb234b235b10ffce548154a95 | 1 | static void ehci_detach(USBPort *port)
{
EHCIState *s = port->opaque;
uint32_t *portsc = &s->portsc[port->index];
const char *owner = (*portsc & PORTSC_POWNER) ? "comp" : "ehci";
trace_usb_ehci_port_detach(port->index, owner);
if (*portsc & PORTSC_POWNER) {
USBPort *companion = s-... | 15,564 |
FFmpeg | 6e42e6c4b410dbef8b593c2d796a5dad95f89ee4 | 1 | static inline void RENAME(rgb32to15)(const uint8_t *src, uint8_t *dst, long src_size)
{
const uint8_t *s = src;
const uint8_t *end;
#ifdef HAVE_MMX
const uint8_t *mm_end;
#endif
uint16_t *d = (uint16_t *)dst;
end = s + src_size;
#ifdef HAVE_MMX
mm_end = end - 15;
#if 1 //is faster only if multiplies ar... | 15,565 |
qemu | d9bce9d99f4656ae0b0127f7472db9067b8f84ab | 1 | PPC_OP(tlbie)
{
do_tlbie();
RETURN();
}
| 15,566 |
FFmpeg | 87e8788680e16c51f6048af26f3f7830c35207a5 | 0 | static int avs_probe(AVProbeData * p)
{
const uint8_t *d;
if (p->buf_size < 2)
return 0;
d = p->buf;
if (d[0] == 'w' && d[1] == 'W' && d[2] == 0x10 && d[3] == 0)
return 50;
return 0;
}
| 15,568 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.