project stringclasses 2
values | commit_id stringlengths 40 40 | target int64 0 1 | func stringlengths 26 142k | idx int64 0 27.3k |
|---|---|---|---|---|
qemu | 3a55fc0f243104998bee5106b121cff257df5d33 | 1 | static void ivshmem_check_version(void *opaque, const uint8_t * buf, int size)
{
IVShmemState *s = opaque;
int tmp;
int64_t version;
if (!fifo_update_and_get_i64(s, buf, size, &version)) {
return;
}
tmp = qemu_chr_fe_get_msgfd(s->server_chr);
if (tmp != -1 || version != ... | 10,832 |
FFmpeg | 675cfb2f86a0bd76b0784da0c7ec9a9225e37353 | 1 | static int parse_dsd_prop(AVFormatContext *s, AVStream *st, uint64_t eof)
{
AVIOContext *pb = s->pb;
char abss[24];
int hour, min, sec, i, ret, config;
int dsd_layout[6];
ID3v2ExtraMeta *id3v2_extra_meta;
while (avio_tell(pb) + 12 <= eof) {
uint32_t tag = avio_rl32(pb);
... | 10,833 |
FFmpeg | c89658008705d949c319df3fa6f400c481ad73e1 | 0 | static int tcp_read_packet(AVFormatContext *s, RTSPStream **prtsp_st,
uint8_t *buf, int buf_size)
{
RTSPState *rt = s->priv_data;
int id, len, i, ret;
RTSPStream *rtsp_st;
#ifdef DEBUG_RTP_TCP
dprintf(s, "tcp_read_packet:\n");
#endif
redo:
for(;;) {
R... | 10,834 |
FFmpeg | 1ea3c03743ec6a7c33312896de3bbdbe7f60d0f5 | 1 | static int read_ts(const char *s, int64_t *start, int *duration)
{
int64_t end;
int hh1, mm1, ss1, ms1;
int hh2, mm2, ss2, ms2;
if (sscanf(s, "%u:%u:%u.%u,%u:%u:%u.%u",
&hh1, &mm1, &ss1, &ms1, &hh2, &mm2, &ss2, &ms2) == 8) {
end = (hh2*3600 + mm2*60 + ss2) * 100 + ms2;... | 10,837 |
FFmpeg | a9d4a6ef3437d316450c2e30b9ed6a8fd4df4804 | 1 | static int rm_read_header_old(AVFormatContext *s, AVFormatParameters *ap)
{
RMContext *rm = s->priv_data;
AVStream *st;
rm->old_format = 1;
st = av_new_stream(s, 0);
if (!st)
goto fail;
rm_read_audio_stream_info(s, st, 1);
return 0;
fail:
return -1;
}
| 10,838 |
qemu | 60fe637bf0e4d7989e21e50f52526444765c63b4 | 1 | static void alloc_aio_bitmap(BlkMigDevState *bmds)
{
BlockDriverState *bs = bmds->bs;
int64_t bitmap_size;
bitmap_size = bdrv_nb_sectors(bs) + BDRV_SECTORS_PER_DIRTY_CHUNK * 8 - 1;
bitmap_size /= BDRV_SECTORS_PER_DIRTY_CHUNK * 8;
bmds->aio_bitmap = g_malloc0(bitmap_size);
}
| 10,839 |
qemu | 7fb394ad8a7c4609cefa2136dec16cf65d028f40 | 1 | static uint8_t *xen_map_cache_unlocked(hwaddr phys_addr, hwaddr size,
uint8_t lock, bool dma)
{
MapCacheEntry *entry, *pentry = NULL;
hwaddr address_index;
hwaddr address_offset;
hwaddr cache_size = size;
hwaddr test_bit_size;
bool translated G_GNUC... | 10,841 |
qemu | 3b3284486be6898937395fac3ddbd2e68c5cb52f | 1 | static void disas_arm_insn(CPUARMState * env, DisasContext *s)
{
unsigned int cond, insn, val, op1, i, shift, rm, rs, rn, rd, sh;
TCGv tmp;
TCGv tmp2;
TCGv tmp3;
TCGv addr;
TCGv_i64 tmp64;
insn = arm_ldl_code(env, s->pc, s->bswap_code);
s->pc += 4;
/* M variants do not ... | 10,844 |
FFmpeg | 8cd1c0febe88b757e915e9af15559575c21ca728 | 1 | static const uint8_t *pcx_rle_decode(const uint8_t *src, uint8_t *dst,
unsigned int bytes_per_scanline, int compressed) {
unsigned int i = 0;
unsigned char run, value;
if (compressed) {
while (i<bytes_per_scanline) {
run = 1;
value = *src+... | 10,845 |
qemu | 6d0ceb80ffe18ad4b28aab7356f440636c0be7be | 1 | static int coroutine_fn blkreplay_co_flush(BlockDriverState *bs)
{
uint64_t reqid = request_id++;
int ret = bdrv_co_flush(bs->file->bs);
block_request_create(reqid, bs, qemu_coroutine_self());
qemu_coroutine_yield();
return ret;
}
| 10,846 |
qemu | b946a1533209f61a93e34898aebb5b43154b99c3 | 1 | USBDevice *usb_net_init(NICInfo *nd)
{
USBNetState *s;
s = qemu_mallocz(sizeof(USBNetState));
s->dev.speed = USB_SPEED_FULL;
s->dev.handle_packet = usb_generic_handle_packet;
s->dev.handle_reset = usb_net_handle_reset;
s->dev.handle_control = usb_net_handle_control;
s->dev.handle... | 10,848 |
FFmpeg | d3958ab4edf49cb760412d8687c870d349f692c7 | 1 | x11grab_read_header(AVFormatContext *s1)
{
struct x11_grab *x11grab = s1->priv_data;
Display *dpy;
AVStream *st = NULL;
enum PixelFormat input_pixfmt;
XImage *image;
int x_off = 0;
int y_off = 0;
int screen;
int use_shm;
char *param, *offset;
int ret = 0;
AVR... | 10,850 |
FFmpeg | a5ee04c3e0f3c0f84089100b65bb09552ce1bdf8 | 1 | static int mpc7_decode_frame(AVCodecContext * avctx,
void *data, int *data_size,
uint8_t * buf, int buf_size)
{
MPCContext *c = avctx->priv_data;
GetBitContext gb;
uint8_t *bits;
int i, j, ch, t;
int mb = -1;
Band bands[BANDS];
... | 10,851 |
FFmpeg | 7a961a46ba28e49f88ff0e81b96395c96b424634 | 1 | void register_avcodec(AVCodec *codec)
{
AVCodec **p;
p = &first_avcodec;
while (*p != NULL) p = &(*p)->next;
*p = codec;
codec->next = NULL;
} | 10,852 |
qemu | 4f4321c11ff6e98583846bfd6f0e81954924b003 | 1 | static int uhci_broadcast_packet(UHCIState *s, USBPacket *p)
{
int i, ret;
DPRINTF("uhci: packet enter. pid %s addr 0x%02x ep %d len %d\n",
pid2str(p->pid), p->devaddr, p->devep, p->len);
if (p->pid == USB_TOKEN_OUT || p->pid == USB_TOKEN_SETUP)
dump_data(p->data, p->len);
... | 10,853 |
qemu | b5bd049fa907bccc4600ad1855e1c9c0e62f0be3 | 1 | static int vfio_early_setup_msix(VFIOPCIDevice *vdev)
{
uint8_t pos;
uint16_t ctrl;
uint32_t table, pba;
int fd = vdev->vbasedev.fd;
pos = pci_find_capability(&vdev->pdev, PCI_CAP_ID_MSIX);
if (!pos) {
return 0;
}
if (pread(fd, &ctrl, sizeof(ctrl),
vd... | 10,854 |
qemu | 12848bfc5d719bad536c5448205a3226be1fda47 | 1 | static int local_mkdir(FsContext *fs_ctx, const char *path, FsCred *credp)
{
int err = -1;
int serrno = 0;
/* Determine the security model */
if (fs_ctx->fs_sm == SM_MAPPED) {
err = mkdir(rpath(fs_ctx, path), SM_LOCAL_DIR_MODE_BITS);
if (err == -1) {
return err;
... | 10,855 |
FFmpeg | a960f3b91876d50d9a1bff63d11b2a5a6a16fd89 | 1 | static int pmp_header(AVFormatContext *s)
{
PMPContext *pmp = s->priv_data;
AVIOContext *pb = s->pb;
int tb_num, tb_den;
uint32_t index_cnt;
int audio_codec_id = AV_CODEC_ID_NONE;
int srate, channels;
int i;
uint64_t pos;
int64_t fsize = avio_size(pb);
AVStream *vst ... | 10,856 |
qemu | 469936ae0a9891b2de7e46743f683535b0819bee | 1 | cpu_x86_dump_seg_cache(CPUX86State *env, FILE *f, fprintf_function cpu_fprintf,
const char *name, struct SegmentCache *sc)
{
#ifdef TARGET_X86_64
if (env->hflags & HF_CS64_MASK) {
cpu_fprintf(f, "%-3s=%04x %016" PRIx64 " %08x %08x", name,
sc->selector, sc->ba... | 10,858 |
FFmpeg | e6aed5f404a0983b2971c90e9022f6964a75de0b | 1 | static int encode_frame(AVCodecContext *avctx,
uint8_t *buf, int buf_size,
void *data)
{
int tileno, ret;
J2kEncoderContext *s = avctx->priv_data;
// init:
s->buf = s->buf_start = buf;
s->buf_end = buf + buf_size;
s->picture = data;
... | 10,859 |
qemu | d9bce9d99f4656ae0b0127f7472db9067b8f84ab | 1 | void do_POWER_divs (void)
{
if ((Ts0 == INT32_MIN && Ts1 == -1) || Ts1 == 0) {
T0 = (long)((-1) * (T0 >> 31));
env->spr[SPR_MQ] = 0;
} else {
env->spr[SPR_MQ] = T0 % T1;
T0 = Ts0 / Ts1;
}
}
| 10,861 |
FFmpeg | 5a3a906ba29b53fa34d3047af78d9f8fd7678256 | 1 | static void vqa_decode_chunk(VqaContext *s)
{
unsigned int chunk_type;
unsigned int chunk_size;
int byte_skip;
unsigned int index = 0;
int i;
unsigned char r, g, b;
int index_shift;
int cbf0_chunk = -1;
int cbfz_chunk = -1;
int cbp0_chunk = -1;
int cbpz_chunk = ... | 10,863 |
FFmpeg | 7cc84d241ba6ef8e27e4d057176a4ad385ad3d59 | 1 | int decode_luma_intra_block(VC9Context *v, int mquant)
{
GetBitContext *gb = &v->s.gb;
int dcdiff;
dcdiff = get_vlc2(gb, v->luma_dc_vlc->table,
DC_VLC_BITS, 2);
if (dcdiff)
{
if (dcdiff == 119 /* ESC index value */)
{
/* TODO: Optimize */... | 10,864 |
qemu | cf5f7937b05c84d5565134f058c00cd48304a117 | 1 | static uint32_t nvic_readl(NVICState *s, uint32_t offset, MemTxAttrs attrs)
{
ARMCPU *cpu = s->cpu;
uint32_t val;
switch (offset) {
case 4: /* Interrupt Control Type. */
return ((s->num_irq - NVIC_FIRST_IRQ) / 32) - 1;
case 0x380 ... 0x3bf: /* NVIC_ITNS<n> */
{
int st... | 10,865 |
FFmpeg | 57d77b3963ce1023eaf5ada8cba58b9379405cc8 | 0 | static int init_opencl_env(GPUEnv *gpu_env, AVOpenCLExternalEnv *ext_opencl_env)
{
size_t device_length;
cl_int status;
cl_uint num_platforms, num_devices;
cl_platform_id *platform_ids = NULL;
cl_context_properties cps[3];
char platform_name[100];
int i, ret = 0;
cl_device_type ... | 10,866 |
qemu | cd98639f673d92836b6b5fd60279b411748f2f1e | 1 | static int vhost_user_call(struct vhost_dev *dev, unsigned long int request,
void *arg)
{
VhostUserMsg msg;
VhostUserRequest msg_request;
struct vhost_vring_file *file = 0;
int need_reply = 0;
int fds[VHOST_MEMORY_MAX_NREGIONS];
int i, fd;
size_t fd_num = 0;
assert(de... | 10,870 |
qemu | 6ff5816478940c76d3412593e503f644af531d49 | 1 | static int nbd_receive_list(QIOChannel *ioc, char **name, Error **errp)
{
uint64_t magic;
uint32_t opt;
uint32_t type;
uint32_t len;
uint32_t namelen;
*name = NULL;
if (read_sync(ioc, &magic, sizeof(magic)) != sizeof(magic)) {
error_setg(errp, "failed to read list option m... | 10,871 |
qemu | b5806108d20fc32b4692e721d8bd6376f4ca4a69 | 1 | int64_t throttle_compute_wait(LeakyBucket *bkt)
{
double extra; /* the number of extra units blocking the io */
double bucket_size; /* I/O before throttling to bkt->avg */
double burst_bucket_size; /* Before throttling to bkt->max */
if (!bkt->avg) {
return 0;
}
if (!bkt->m... | 10,872 |
qemu | ac43fa508cc1cfe6d6f67c8eb99dc012e52c164e | 1 | static uint64_t pci_host_data_read(void *opaque,
hwaddr addr, unsigned len)
{
PCIHostState *s = opaque;
uint32_t val;
if (!(s->config_reg & (1 << 31)))
return 0xffffffff;
val = pci_data_read(s->bus, s->config_reg | (addr & 3), len);
PCI_DPRINTF("rea... | 10,873 |
qemu | b4ba67d9a702507793c2724e56f98e9b0f7be02b | 1 | static void test_tco_timeout(void)
{
TestData d;
const uint16_t ticks = TCO_SECS_TO_TICKS(4);
uint32_t val;
int ret;
d.args = NULL;
d.noreboot = true;
test_init(&d);
stop_tco(&d);
clear_tco_status(&d);
reset_on_second_timeout(false);
set_tco_timeout(&d, ticks)... | 10,874 |
qemu | 53cb28cbfea038f8ad50132dc8a684e638c7d48b | 0 | hwaddr memory_region_section_get_iotlb(CPUArchState *env,
MemoryRegionSection *section,
target_ulong vaddr,
hwaddr paddr, hwaddr xlat,
int prot,
... | 10,876 |
qemu | de9e9d9f17a36ff76c1a02a5348835e5e0a081b0 | 0 | static inline void gen_op_eval_fbule(TCGv dst, TCGv src,
unsigned int fcc_offset)
{
gen_mov_reg_FCC0(dst, src, fcc_offset);
tcg_gen_xori_tl(dst, dst, 0x1);
gen_mov_reg_FCC1(cpu_tmp0, src, fcc_offset);
tcg_gen_and_tl(dst, dst, cpu_tmp0);
tcg_gen_xori_tl(dst,... | 10,878 |
qemu | c92cfba822245c42fec611f310ed74c1821be3d2 | 0 | PXA2xxState *pxa255_init(MemoryRegion *address_space, unsigned int sdram_size)
{
PXA2xxState *s;
int i;
DriveInfo *dinfo;
s = g_new0(PXA2xxState, 1);
s->cpu = cpu_arm_init("pxa255");
if (s->cpu == NULL) {
fprintf(stderr, "Unable to find CPU definition\n");
exit(1);
... | 10,879 |
FFmpeg | 5049f6b772891cdf4030a9d572362efc8f7ae97f | 0 | static int jpeg_parse_packet(AVFormatContext *ctx, PayloadContext *jpeg,
AVStream *st, AVPacket *pkt, uint32_t *timestamp,
const uint8_t *buf, int len, uint16_t seq,
int flags)
{
uint8_t type, q, width, height;
const ui... | 10,880 |
qemu | e387c33892be35ca70255739a2fe118f76c95ac3 | 0 | int kvm_on_sigbus_vcpu(CPUState *env, int code, void *addr)
{
#if defined(KVM_CAP_MCE)
struct kvm_x86_mce mce = {
.bank = 9,
};
void *vaddr;
ram_addr_t ram_addr;
target_phys_addr_t paddr;
int r;
if ((env->mcg_cap & MCG_SER_P) && addr
&& (code == BUS_MCEERR_AR... | 10,881 |
qemu | 28143b409f698210d85165ca518235ac7e7c5ac5 | 0 | int kvm_has_pit_state2(void)
{
return 0;
}
| 10,882 |
qemu | a8170e5e97ad17ca169c64ba87ae2f53850dab4c | 0 | void mcf_fec_init(MemoryRegion *sysmem, NICInfo *nd,
target_phys_addr_t base, qemu_irq *irq)
{
mcf_fec_state *s;
qemu_check_nic_model(nd, "mcf_fec");
s = (mcf_fec_state *)g_malloc0(sizeof(mcf_fec_state));
s->sysmem = sysmem;
s->irq = irq;
memory_region_init_io(&s-... | 10,883 |
qemu | 42a268c241183877192c376d03bd9b6d527407c7 | 0 | static void dec10_reg_scc(DisasContext *dc)
{
int cond = dc->dst;
LOG_DIS("s%s $r%u\n", cc_name(cond), dc->src);
if (cond != CC_A)
{
int l1;
gen_tst_cc (dc, cpu_R[dc->src], cond);
l1 = gen_new_label();
tcg_gen_brcondi_tl(TCG_COND_EQ, cpu_R[dc->src], 0, l1);... | 10,884 |
qemu | 5255fcf8e47acd059e2f0d414841c40231c1bd22 | 0 | void armv7m_nvic_acknowledge_irq(void *opaque)
{
NVICState *s = (NVICState *)opaque;
CPUARMState *env = &s->cpu->env;
const int pending = s->vectpending;
const int running = nvic_exec_prio(s);
int pendgroupprio;
VecInfo *vec;
assert(pending > ARMV7M_EXCP_RESET && pending < s->num_i... | 10,885 |
qemu | db39fcf1f690b02d612e2bfc00980700887abe03 | 0 | static CharDriverState *text_console_init(ChardevVC *vc)
{
CharDriverState *chr;
QemuConsole *s;
unsigned width = 0;
unsigned height = 0;
chr = g_malloc0(sizeof(CharDriverState));
if (vc->has_width) {
width = vc->width;
} else if (vc->has_cols) {
width = vc->col... | 10,886 |
qemu | 9be385980d37e8f4fd33f605f5fb1c3d144170a8 | 0 | static char *spapr_vio_get_dev_name(DeviceState *qdev)
{
VIOsPAPRDevice *dev = VIO_SPAPR_DEVICE(qdev);
VIOsPAPRDeviceClass *pc = VIO_SPAPR_DEVICE_GET_CLASS(dev);
char *name;
/* Device tree style name device@reg */
name = g_strdup_printf("%s@%x", pc->dt_name, dev->reg);
return name;
}... | 10,887 |
qemu | 1964a397063967acc5ce71a2a24ed26e74824ee1 | 0 | static int64_t migration_get_rate_limit(void *opaque)
{
MigrationState *s = opaque;
return s->xfer_limit;
}
| 10,888 |
qemu | 5a2223ca26b1a34e131b5b9a63599d9426d2c25c | 0 | static uint64_t pci_read(void *opaque, hwaddr addr, unsigned int size)
{
AcpiPciHpState *s = opaque;
uint32_t val = 0;
int bsel = s->hotplug_select;
if (bsel < 0 || bsel > ACPI_PCIHP_MAX_HOTPLUG_BUS) {
return 0;
}
switch (addr) {
case PCI_UP_BASE - PCI_HOTPLUG_ADDR:
... | 10,890 |
FFmpeg | 202a6697ba54293235ce2d7bd5724f4f461e417f | 0 | rdt_new_extradata (void)
{
PayloadContext *rdt = av_mallocz(sizeof(PayloadContext));
av_open_input_stream(&rdt->rmctx, NULL, "", &rdt_demuxer, NULL);
return rdt;
}
| 10,891 |
qemu | d5b68844e6f7c13d30b46cc92ba468e5f92119a6 | 0 | BlockInfoList *qmp_query_block(Error **errp)
{
BlockInfoList *head = NULL, **p_next = &head;
BlockBackend *blk;
Error *local_err = NULL;
for (blk = blk_next(NULL); blk; blk = blk_next(blk)) {
BlockInfoList *info = g_malloc0(sizeof(*info));
bdrv_query_info(blk, &info->value, &loc... | 10,892 |
qemu | db1e80ee2ed6fc9eb6b203873b39752144f5577f | 0 | static int vhdx_create_new_region_table(BlockDriverState *bs,
uint64_t image_size,
uint32_t block_size,
uint32_t sector_size,
uint32_t log_size,
... | 10,893 |
qemu | 8417f904bad50021b432dfea12613345d9fb1f68 | 0 | void s390_cpu_do_interrupt(CPUState *cs)
{
S390CPU *cpu = S390_CPU(cs);
CPUS390XState *env = &cpu->env;
qemu_log_mask(CPU_LOG_INT, "%s: %d at pc=%" PRIx64 "\n",
__func__, cs->exception_index, env->psw.addr);
s390_cpu_set_state(CPU_STATE_OPERATING, cpu);
/* handle machine... | 10,894 |
qemu | db0a762e4be965b8976abe9df82c6d47c57336fc | 0 | static int handle_primary_tcp_pkt(NetFilterState *nf,
Connection *conn,
Packet *pkt)
{
struct tcphdr *tcp_pkt;
tcp_pkt = (struct tcphdr *)pkt->transport_header;
if (trace_event_get_state(TRACE_COLO_FILTER_REWRITER_DEBUG)) {
... | 10,895 |
qemu | 4534ff5426afeeae5238ba10a696cafa9a0168ee | 0 | static int bdrv_qed_check(BlockDriverState *bs, BdrvCheckResult *result)
{
BDRVQEDState *s = bs->opaque;
return qed_check(s, result, false);
}
| 10,896 |
qemu | a0efbf16604770b9d805bcf210ec29942321134f | 0 | static void q35_host_initfn(Object *obj)
{
Q35PCIHost *s = Q35_HOST_DEVICE(obj);
PCIHostState *phb = PCI_HOST_BRIDGE(obj);
memory_region_init_io(&phb->conf_mem, obj, &pci_host_conf_le_ops, phb,
"pci-conf-idx", 4);
memory_region_init_io(&phb->data_mem, obj, &pci_host_dat... | 10,898 |
qemu | fd56e0612b6454a282fa6a953fdb09281a98c589 | 0 | static PXBDev *convert_to_pxb(PCIDevice *dev)
{
return pci_bus_is_express(dev->bus) ? PXB_PCIE_DEV(dev) : PXB_DEV(dev);
}
| 10,900 |
qemu | ee640c625e190a0c0e6b8966adc0e4720fb75200 | 1 | static void ivshmem_common_realize(PCIDevice *dev, Error **errp)
{
IVShmemState *s = IVSHMEM_COMMON(dev);
Error *err = NULL;
uint8_t *pci_conf;
uint8_t attr = PCI_BASE_ADDRESS_SPACE_MEMORY |
PCI_BASE_ADDRESS_MEM_PREFETCH;
Error *local_err = NULL;
/* IRQFD requires MSI */
i... | 10,901 |
FFmpeg | e55e8b2c362a60bad66929d83d8c83b0d7f5ffc9 | 1 | int attribute_align_arg avcodec_decode_audio4(AVCodecContext *avctx,
AVFrame *frame,
int *got_frame_ptr,
AVPacket *avpkt)
{
AVCodecInternal *avci = avctx->internal;
int... | 10,902 |
FFmpeg | 50be207759aa7a69a27de585f7d870ec41eba036 | 1 | static void extrapolate_isf(float isf[LP_ORDER_16k])
{
float diff_isf[LP_ORDER - 2], diff_mean;
float *diff_hi = diff_isf - LP_ORDER + 1; // diff array for extrapolated indexes
float corr_lag[3];
float est, scale;
int i, i_max_corr;
isf[LP_ORDER_16k - 1] = isf[LP_ORDER - 1];
/* C... | 10,903 |
qemu | 7f0278435df1fa845b3bd9556942f89296d4246b | 1 | QString *qobject_to_qstring(const QObject *obj)
{
if (qobject_type(obj) != QTYPE_QSTRING)
return NULL;
return container_of(obj, QString, base);
}
| 10,904 |
qemu | 9b2fadda3e0196ffd485adde4fe9cdd6fae35300 | 1 | static void gen_mfmsr(DisasContext *ctx)
{
#if defined(CONFIG_USER_ONLY)
gen_inval_exception(ctx, POWERPC_EXCP_PRIV_REG);
#else
if (unlikely(ctx->pr)) {
gen_inval_exception(ctx, POWERPC_EXCP_PRIV_REG);
return;
}
tcg_gen_mov_tl(cpu_gpr[rD(ctx->opcode)], cpu_msr);
#endif
}
| 10,905 |
qemu | 79b78a6bd47722ce23bc74287cd6322756698f09 | 1 | static void spapr_add_lmbs(DeviceState *dev, uint64_t addr, uint64_t size,
uint32_t node, Error **errp)
{
sPAPRDRConnector *drc;
sPAPRDRConnectorClass *drck;
uint32_t nr_lmbs = size/SPAPR_MEMORY_BLOCK_SIZE;
int i, fdt_offset, fdt_size;
void *fdt;
for (i = 0; ... | 10,906 |
qemu | b5eff355460643d09e533024360fe0522f368c07 | 1 | static int bdrv_wr_badreq_bytes(BlockDriverState *bs,
int64_t offset, int count)
{
int64_t size = bs->total_sectors << SECTOR_BITS;
if (count < 0 ||
offset < 0)
return 1;
if (offset > size - count) {
if (bs->autogrow)
bs->total_s... | 10,907 |
qemu | e49c63d5b3234da0debf53cab7ee67de3a4a6a80 | 1 | static void spapr_core_plug(HotplugHandler *hotplug_dev, DeviceState *dev,
Error **errp)
{
sPAPRMachineState *spapr = SPAPR_MACHINE(OBJECT(hotplug_dev));
MachineClass *mc = MACHINE_GET_CLASS(spapr);
sPAPRMachineClass *smc = SPAPR_MACHINE_CLASS(mc);
sPAPRCPUCore *core = ... | 10,908 |
FFmpeg | a34dfc93efe380dd9c2b147e227caa14b063d32f | 0 | static void do_video_out(AVFormatContext *s,
OutputStream *ost,
AVFrame *next_picture,
double sync_ipts)
{
int ret, format_video_sync;
AVPacket pkt;
AVCodecContext *enc = ost->enc_ctx;
AVCodecContext *mux_enc = ost->st->c... | 10,909 |
FFmpeg | 5a3a906ba29b53fa34d3047af78d9f8fd7678256 | 1 | static int vqa_decode_frame(AVCodecContext *avctx,
void *data, int *data_size,
AVPacket *avpkt)
{
const uint8_t *buf = avpkt->data;
int buf_size = avpkt->size;
VqaContext *s = avctx->priv_data;
s->buf = buf;
s->size = buf_size;
... | 10,910 |
qemu | 8b33d9eeba91422ee2d73b6936ad57262d18cf5a | 1 | static int check_write_unsafe(BlockDriverState *bs, int64_t sector_num,
const uint8_t *buf, int nb_sectors)
{
/* assume that if the user specifies the format explicitly, then assume
that they will continue to do so and provide no safety net */
if (!bs->probed) {
... | 10,911 |
FFmpeg | 32be264cea542b4dc721b10092bf1dfe511a28ee | 1 | static void search_for_quantizers_faac(AVCodecContext *avctx, AACEncContext *s,
SingleChannelElement *sce,
const float lambda)
{
int start = 0, i, w, w2, g;
float uplim[128], maxq[128];
int minq, maxsf;
float distfact =... | 10,913 |
FFmpeg | dcc39ee10e82833ce24aa57926c00ffeb1948198 | 0 | static av_cold int jpg_init(AVCodecContext *avctx, JPGContext *c)
{
int ret;
ret = build_vlc(&c->dc_vlc[0], avpriv_mjpeg_bits_dc_luminance,
avpriv_mjpeg_val_dc, 12, 0);
if (ret)
return ret;
ret = build_vlc(&c->dc_vlc[1], avpriv_mjpeg_bits_dc_chrominance,
... | 10,915 |
FFmpeg | a7a85dc4c2e3fa818573ab1adc547758fe95b539 | 0 | static int ffm_read_header(AVFormatContext *s, AVFormatParameters *ap)
{
FFMContext *ffm = s->priv_data;
AVStream *st;
ByteIOContext *pb = s->pb;
AVCodecContext *codec;
int i, nb_streams;
uint32_t tag;
/* header */
tag = get_le32(pb);
if (tag != MKTAG('F', 'F', 'M', '1'))... | 10,916 |
FFmpeg | 3b199d29cd597a3518136d78860e172060b9e83d | 0 | static av_cold int msvideo1_decode_init(AVCodecContext *avctx)
{
Msvideo1Context *s = avctx->priv_data;
s->avctx = avctx;
/* figure out the colorspace based on the presence of a palette */
if (s->avctx->bits_per_coded_sample == 8) {
s->mode_8bit = 1;
avctx->pix_fmt = AV_PIX_FM... | 10,917 |
FFmpeg | 2aab7c2dfaca4386c38e5d565cd2bf73096bcc86 | 0 | static void avc_luma_hv_qrt_16w_msa(const uint8_t *src_x, const uint8_t *src_y,
int32_t src_stride, uint8_t *dst,
int32_t dst_stride, int32_t height)
{
uint32_t multiple8_cnt;
for (multiple8_cnt = 2; multiple8_cnt--;) {
avc_... | 10,918 |
qemu | 242acf3af4605adce933906bdc053b2414181ec7 | 0 | int udp_output(struct socket *so, struct mbuf *m,
struct sockaddr_in *addr)
{
struct sockaddr_in saddr, daddr;
saddr = *addr;
if ((so->so_faddr.s_addr & htonl(0xffffff00)) == special_addr.s_addr) {
if ((so->so_faddr.s_addr & htonl(0x000000ff)) == htonl(0xff))
sa... | 10,919 |
qemu | da7d998bbb80f141ed5743418a4dfa5c1409e75f | 0 | void qemu_chr_add_handlers(CharDriverState *s,
IOCanReadHandler *fd_can_read,
IOReadHandler *fd_read,
IOEventHandler *fd_event,
void *opaque)
{
if (!opaque) {
/* chr driver being released. */
... | 10,920 |
qemu | f22d85e9e67262db34504f4079745f9843da6a92 | 0 | static void guest_fsfreeze_init(void)
{
guest_fsfreeze_state.status = GUEST_FSFREEZE_STATUS_THAWED;
}
| 10,921 |
qemu | 61007b316cd71ee7333ff7a0a749a8949527575f | 0 | static int bdrv_rw_co(BlockDriverState *bs, int64_t sector_num, uint8_t *buf,
int nb_sectors, bool is_write, BdrvRequestFlags flags)
{
QEMUIOVector qiov;
struct iovec iov = {
.iov_base = (void *)buf,
.iov_len = nb_sectors * BDRV_SECTOR_SIZE,
};
if (nb_sect... | 10,922 |
qemu | e3f5ec2b5e92706e3b807059f79b1fb5d936e567 | 0 | static uint32_t stellaris_enet_read(void *opaque, target_phys_addr_t offset)
{
stellaris_enet_state *s = (stellaris_enet_state *)opaque;
uint32_t val;
switch (offset) {
case 0x00: /* RIS */
DPRINTF("IRQ status %02x\n", s->ris);
return s->ris;
case 0x04: /* IM */
re... | 10,923 |
qemu | 41a2b9596c9ed2a827e16e749632752dd2686647 | 0 | static void ide_reset(IDEState *s)
{
if (s->is_cf)
s->mult_sectors = 0;
else
s->mult_sectors = MAX_MULT_SECTORS;
s->cur_drive = s;
s->select = 0xa0;
s->status = READY_STAT;
ide_set_signature(s);
/* init the transfer handler so that 0xffff is returned on data
... | 10,924 |
qemu | bcf5d19c59a527c91bc29704f3e4956119c050cf | 0 | int monitor_read_password(Monitor *mon, ReadLineFunc *readline_func,
void *opaque)
{
if (monitor_ctrl_mode(mon)) {
qerror_report(QERR_MISSING_PARAMETER, "password");
return -EINVAL;
} else if (mon->rs) {
readline_start(mon->rs, "Password: ", 1, readline_f... | 10,925 |
qemu | 13f1c773640171efa8175b1ba6dcd624c1ad68c1 | 0 | static void openrisc_sim_net_init(MemoryRegion *address_space,
hwaddr base,
hwaddr descriptors,
qemu_irq irq, NICInfo *nd)
{
DeviceState *dev;
SysBusDevice *s;
dev = qdev_create(NULL, "open_eth");
... | 10,926 |
qemu | 0e9b9edae7bebfd31fdbead4ccbbce03876a7edd | 0 | build_srat(GArray *table_data, GArray *linker, MachineState *machine)
{
AcpiSystemResourceAffinityTable *srat;
AcpiSratProcessorAffinity *core;
AcpiSratMemoryAffinity *numamem;
int i;
uint64_t curnode;
int srat_start, numa_start, slots;
uint64_t mem_len, mem_base, next_base;
M... | 10,927 |
qemu | a8170e5e97ad17ca169c64ba87ae2f53850dab4c | 0 | static MaltaFPGAState *malta_fpga_init(MemoryRegion *address_space,
target_phys_addr_t base, qemu_irq uart_irq, CharDriverState *uart_chr)
{
MaltaFPGAState *s;
s = (MaltaFPGAState *)g_malloc0(sizeof(MaltaFPGAState));
memory_region_init_io(&s->iomem, &malta_fpga_ops, s,
... | 10,929 |
qemu | 7dfd8c6aa1d0691d03c5ccc9b0c5a93bcf00f768 | 0 | static void tcg_reg_alloc_start(TCGContext *s)
{
int i;
TCGTemp *ts;
for(i = 0; i < s->nb_globals; i++) {
ts = &s->temps[i];
if (ts->fixed_reg) {
ts->val_type = TEMP_VAL_REG;
} else {
ts->val_type = TEMP_VAL_MEM;
}
}
for(i = s->nb_g... | 10,930 |
qemu | 08844473820c93541fc47bdfeae0f2cc88cfab59 | 0 | static int coroutine_fn bdrv_driver_preadv(BlockDriverState *bs,
uint64_t offset, uint64_t bytes,
QEMUIOVector *qiov, int flags)
{
BlockDriver *drv = bs->drv;
int64_t sector_num = offset >> BDRV_SECTOR_BITS;
unsigned... | 10,931 |
qemu | 4be746345f13e99e468c60acbd3a355e8183e3ce | 0 | SCSIDevice *scsi_bus_legacy_add_drive(SCSIBus *bus, BlockDriverState *bdrv,
int unit, bool removable, int bootindex,
const char *serial, Error **errp)
{
const char *driver;
DeviceState *dev;
Error *err = NULL;
driver = ... | 10,933 |
qemu | ffbb1705a33df8e2fb12b24d96663d63b22eaf8b | 0 | static void check_exception(PowerPCCPU *cpu, sPAPRMachineState *spapr,
uint32_t token, uint32_t nargs,
target_ulong args,
uint32_t nret, target_ulong rets)
{
uint32_t mask, buf, len, event_len;
uint64_t xinfo;
sPAPREv... | 10,934 |
qemu | bc7c08a2c375acb7ae4d433054415588b176d34c | 0 | static void test_qemu_strtoull_full_correct(void)
{
const char *str = "18446744073709551614";
uint64_t res = 999;
int err;
err = qemu_strtoull(str, NULL, 0, &res);
g_assert_cmpint(err, ==, 0);
g_assert_cmpint(res, ==, 18446744073709551614LLU);
}
| 10,935 |
qemu | 4e59b545868a5ee5f59b346337f0c44209929334 | 0 | QEMUBH *qemu_bh_new(QEMUBHFunc *cb, void *opaque)
{
QEMUBH *bh;
bh = qemu_malloc(sizeof(*bh));
bh->cb = cb;
bh->opaque = opaque;
return bh;
}
| 10,936 |
qemu | a89f364ae8740dfc31b321eed9ee454e996dc3c1 | 0 | static void omap_mcbsp_sink_tick(void *opaque)
{
struct omap_mcbsp_s *s = (struct omap_mcbsp_s *) opaque;
static const int bps[8] = { 0, 1, 1, 2, 2, 2, -255, -255 };
if (!s->tx_rate)
return;
if (s->tx_req)
printf("%s: Tx FIFO underrun\n", __FUNCTION__);
s->tx_req = s->tx_... | 10,937 |
FFmpeg | 1acd7d594c15aa491729c837ad3519d3469e620a | 0 | static av_always_inline void hl_decode_mb_idct_luma(H264Context *h, int mb_type,
int is_h264, int simple,
int transform_bypass,
int pixel_shift,
... | 10,939 |
qemu | a426e122173f36f05ea2cb72dcff77b7408546ce | 0 | int kvm_insert_breakpoint(CPUState *current_env, target_ulong addr,
target_ulong len, int type)
{
struct kvm_sw_breakpoint *bp;
CPUState *env;
int err;
if (type == GDB_BREAKPOINT_SW) {
bp = kvm_find_sw_breakpoint(current_env, addr);
if (bp) {
... | 10,940 |
qemu | ecf5e8eae8b0b5fa41f00b53d67747b42fd1b8b9 | 0 | static uint32_t nvic_readl(NVICState *s, uint32_t offset, MemTxAttrs attrs)
{
ARMCPU *cpu = s->cpu;
uint32_t val;
switch (offset) {
case 4: /* Interrupt Control Type. */
return ((s->num_irq - NVIC_FIRST_IRQ) / 32) - 1;
case 0xd00: /* CPUID Base. */
return cpu->midr;
... | 10,942 |
qemu | d66b969b0d9c8eefdcbff4b48535b0fe1501d139 | 0 | static gboolean vtd_hash_remove_by_page(gpointer key, gpointer value,
gpointer user_data)
{
VTDIOTLBEntry *entry = (VTDIOTLBEntry *)value;
VTDIOTLBPageInvInfo *info = (VTDIOTLBPageInvInfo *)user_data;
uint64_t gfn = info->gfn & info->mask;
return (entry->dom... | 10,943 |
qemu | 85c97ca7a10b93216bc95052e9dabe3a4bb8736a | 0 | int coroutine_fn bdrv_co_pwritev(BdrvChild *child,
int64_t offset, unsigned int bytes, QEMUIOVector *qiov,
BdrvRequestFlags flags)
{
BlockDriverState *bs = child->bs;
BdrvTrackedRequest req;
uint64_t align = bs->bl.request_alignment;
uint8_t *head_buf = NULL;
uint8_t *tail_buf = NULL... | 10,944 |
qemu | a426e122173f36f05ea2cb72dcff77b7408546ce | 0 | int kvm_init_vcpu(CPUState *env)
{
KVMState *s = kvm_state;
long mmap_size;
int ret;
DPRINTF("kvm_init_vcpu\n");
ret = kvm_vm_ioctl(s, KVM_CREATE_VCPU, env->cpu_index);
if (ret < 0) {
DPRINTF("kvm_create_vcpu failed\n");
goto err;
}
env->kvm_fd = ret;
... | 10,945 |
qemu | 61007b316cd71ee7333ff7a0a749a8949527575f | 0 | void bdrv_disable_copy_on_read(BlockDriverState *bs)
{
assert(bs->copy_on_read > 0);
bs->copy_on_read--;
}
| 10,946 |
qemu | 5b08fc106d3146ddc1447d82d4770fc402fc363b | 0 | void sdl_display_init(DisplayState *ds, int full_screen, int no_frame)
{
int flags;
uint8_t data = 0;
#if defined(__APPLE__)
/* always use generic keymaps */
if (!keyboard_layout)
keyboard_layout = "en-us";
#endif
if(keyboard_layout) {
kbd_layout = init_keyboard_layout(ke... | 10,947 |
qemu | adcf6302de40e50a8010e7f2c79b3dac2eea6e0c | 0 | int nbd_trip(BlockDriverState *bs, int csock, off_t size, uint64_t dev_offset,
off_t *offset, uint32_t nbdflags, uint8_t *data, int data_size)
{
struct nbd_request request;
struct nbd_reply reply;
TRACE("Reading request.");
if (nbd_receive_request(csock, &request) == -1)
... | 10,948 |
qemu | eabb7b91b36b202b4dac2df2d59d698e3aff197a | 0 | static inline void reloc_pc19(tcg_insn_unit *code_ptr, tcg_insn_unit *target)
{
ptrdiff_t offset = target - code_ptr;
assert(offset == sextract64(offset, 0, 19));
*code_ptr = deposit32(*code_ptr, 5, 19, offset);
}
| 10,949 |
qemu | 17b74b98676aee5bc470b173b1e528d2fce2cf18 | 0 | void json_end_object(QJSON *json)
{
qstring_append(json->str, " }");
json->omit_comma = false;
}
| 10,951 |
qemu | c2b38b277a7882a592f4f2ec955084b2b756daaa | 0 | void timerlist_free(QEMUTimerList *timer_list)
{
assert(!timerlist_has_timers(timer_list));
if (timer_list->clock) {
QLIST_REMOVE(timer_list, list);
}
qemu_mutex_destroy(&timer_list->active_timers_lock);
g_free(timer_list);
}
| 10,952 |
qemu | c2b38b277a7882a592f4f2ec955084b2b756daaa | 0 | static AioContext *thread_pool_get_aio_context(BlockAIOCB *acb)
{
ThreadPoolElement *elem = (ThreadPoolElement *)acb;
ThreadPool *pool = elem->pool;
return pool->ctx;
}
| 10,953 |
qemu | 6512a2a7106480c19183d6466a6845bc9bdf6ec0 | 0 | static BlockDriverAIOCB *dma_bdrv_io(
BlockDriverState *bs, QEMUSGList *sg, uint64_t sector_num,
BlockDriverCompletionFunc *cb, void *opaque,
int is_write)
{
DMABlockState *dbs = qemu_malloc(sizeof(*dbs));
dbs->bs = bs;
dbs->acb = qemu_aio_get(bs, cb, opaque);
dbs->sg = sg;
db... | 10,954 |
qemu | a8170e5e97ad17ca169c64ba87ae2f53850dab4c | 0 | static uint64_t watch_mem_read(void *opaque, target_phys_addr_t addr,
unsigned size)
{
check_watchpoint(addr & ~TARGET_PAGE_MASK, ~(size - 1), BP_MEM_READ);
switch (size) {
case 1: return ldub_phys(addr);
case 2: return lduw_phys(addr);
case 4: return ldl_phys(a... | 10,955 |
qemu | 962b289ef35087fcd8764e4e29808d8ac90157f7 | 1 | print_syscall_ret(int num, abi_long ret)
{
int i;
for(i=0;i<nsyscalls;i++)
if( scnames[i].nr == num ) {
if( scnames[i].result != NULL ) {
scnames[i].result(&scnames[i],ret);
} else {
if( ret < 0 ) {
gemu_log(" = -1 er... | 10,957 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.