Projectname large_stringclasses 15
values | Filepath large_stringlengths 4 106 ⌀ | Function large_stringlengths 11 3.45k | Label list |
|---|---|---|---|
FFmpeg | libavformat/4xm.c | static int idcin_probe(AVProbeData *p)
{
unsigned int number;
/*
* This is what you could call a "probabilistic" file check: Id CIN
* files don't have a definite file signature. In lieu of such a marker,
* perform sanity checks on the 5 32-bit header fields:
* width, height: greater than 0, less... | [
0,
0
] |
qemu | migration.c | ssize_t migrate_fd_put_buffer(void *opaque, const void *data, size_t size)
{
FdMigrationState *s = opaque;
ssize_t ret;
do {
ret = s->write(s, data, size);
} while (ret == -1 &&
((s->get_error(s)) == EINTR || (s->get_error(s)) == EWOULDBLOCK));
if (ret == -1)
ret = -(s->get_error(s)... | [
0,
0
] |
FFmpeg | libavformat/avformat.h | static void av_build_index_raw(AVFormatContext *s)
{
AVPacket pkt1, *pkt = &pkt1;
int ret;
AVStream *st;
st = s->streams[0];
av_read_frame_flush(s);
url_fseek(&s->pb, s->data_offset, SEEK_SET);
for (;;) {
ret = av_read_frame(s, pkt);
if (ret < 0)
break;
if (pkt->stream_index ... | [
1,
0
] |
qemu | hw/ppc/spapr_pci.c | static int spapr_create_pci_child_dt(sPAPRPHBState *phb, PCIDevice *dev,
void *fdt, int node_offset)
{
int offset, ret;
char nodename[FDT_NAME_MAX];
pci_get_node_name(nodename, FDT_NAME_MAX, dev);
offset = fdt_add_subnode(fdt, node_offset, nodename);
ret = spapr_pop... | [
0,
0
] |
qemu | hw/slavio_timer.c | static void slavio_timer_irq(void *opaque)
{
TimerContext *tc = opaque;
SLAVIO_TIMERState *s = tc->s;
CPUTimerState *t = &s->cputimer[tc->timer_index];
slavio_timer_get_out(t);
DPRINTF("callback: count %x%08x\n", t->counthigh, t->count);
t->reached = TIMER_REACHED;
/* there is no interrupt if user... | [
1,
0
] |
qemu | target-ppc/op_helper.c | uint64_t helper_fre(uint64_t arg)
{
CPU_DoubleU fone, farg;
fone.ll = 0x3FF0000000000000ULL; /* 1.0 */
farg.ll = arg;
if (unlikely(float64_is_signaling_nan(farg.d))) {
/* sNaN reciprocal */
farg.ll = fload_invalid_op_excp(POWERPC_EXCP_FP_VXSNAN);
} else if (unlikely(float64_is_zero(farg.d))) {... | [
1,
0
] |
qemu | qemu-img.c | static int convert_iteration_sectors(ImgConvertState *s, int64_t sector_num)
{
int64_t ret;
int n;
convert_select_part(s, sector_num);
assert(s->total_sectors > sector_num);
n = MIN(s->total_sectors - sector_num, BDRV_REQUEST_MAX_SECTORS);
if (s->sector_next_status <= sector_num) {
BlockDriverSt... | [
1,
1
] |
qemu | target-s390x/cpu.h | int mmu_translate(CPUS390XState *env, target_ulong vaddr, int rw, uint64_t asc,
target_ulong *raddr, int *flags)
{
int r = -1;
uint8_t *sk;
*flags = PAGE_READ | PAGE_WRITE | PAGE_EXEC;
vaddr &= TARGET_PAGE_MASK;
if (!(env->psw.mask & PSW_MASK_DAT)) {
*raddr = vaddr;
r = 0;
... | [
1,
0
] |
qemu | Makefile.objs | void os_host_main_loop_wait(int *timeout)
{
int ret, ret2, i;
PollingEntry *pe;
/* XXX: need to suppress polling by better using win32 events */
ret = 0;
for (pe = first_polling_entry; pe != NULL; pe = pe->next) {
ret |= pe->func(pe->opaque);
}
if (ret == 0) {
int err;
WaitObjects *w... | [
1,
1
] |
qemu | tests/libqtest.h | static void test_commands(void)
{
char *response;
int i;
for (i = 0; hmp_cmds[i] != NULL; i++) {
if (verbose) {
fprintf(stderr, "\t%s\n", hmp_cmds[i]);
}
response = hmp(hmp_cmds[i]);
g_free(response);
}
} | [
0,
0
] |
qemu | tcg/aarch64/tcg-target.c | static void tcg_out_movi(TCGContext *s, TCGType type, TCGReg rd,
tcg_target_long value)
{
AArch64Insn insn;
if (type == TCG_TYPE_I32) {
value = (uint32_t)value;
}
/* count trailing zeros in 16 bit steps, mapping 64 to 0. Emit the
first MOVZ with the half-word immediate s... | [
1,
0
] |
qemu | tests/acpi-test.c | static void load_asl(GArray *sdts, AcpiSdtTable *sdt)
{
AcpiSdtTable *temp;
GError *error = NULL;
GString *command_line = g_string_new(iasl);
gint fd;
gchar *out, *out_err;
gboolean ret;
int i;
fd = g_file_open_tmp("asl-XXXXXX.dsl", &sdt->asl_file, &error);
g_assert_no_error(error);
close... | [
1,
0
] |
qemu | hw/ppc/ppc.c | static int timebase_post_load(void *opaque, int version_id)
{
PPCTimebase *tb_remote = opaque;
CPUState *cpu;
PowerPCCPU *first_ppc_cpu = POWERPC_CPU(first_cpu);
int64_t tb_off_adj, tb_off, ns_diff;
int64_t migration_duration_ns, migration_duration_tb, guest_tb, host_ns;
unsigned long freq;
if (!f... | [
1,
0
] |
qemu | hw/msix.c | static void msix_mmio_writel(void *opaque, target_phys_addr_t addr,
uint32_t val)
{
PCIDevice *dev = opaque;
unsigned int offset = addr & (MSIX_PAGE_SIZE - 1);
int vector = offset / MSIX_ENTRY_SIZE;
memcpy(dev->msix_table_page + offset, &val, 4);
if (!msix_is_masked(dev, ve... | [
1,
0
] |
qemu | Makefile.objs | QEMUFile *qemu_fopen_ops(void *opaque, const QEMUFileOps *ops)
{
QEMUFile *f;
f = g_malloc0(sizeof(QEMUFile));
f->opaque = opaque;
f->ops = ops;
return f;
} | [
1,
0
] |
qemu | translate-all.c | void tcg_exec_init(unsigned long tb_size)
{
cpu_gen_init();
code_gen_alloc(tb_size);
page_init();
#if defined(CONFIG_SOFTMMU)
/* There's no guest base to take into account, so go ahead and
initialize the prologue now. */
tcg_prologue_init(&tcg_ctx);
#endif
} | [
1,
0
] |
qemu | tests/test-qmp-input-strict.c | static Visitor *validate_test_init_internal(TestInputVisitorData *data,
const char *json_string,
va_list *ap) {
Visitor *v;
data->obj = qobject_from_jsonv(json_string, ap);
g_assert(data->obj);
data->qiv = qmp_input_visitor_... | [
1,
0
] |
qemu | hw/ppc/spapr.c | static void spapr_core_pre_plug(HotplugHandler *hotplug_dev, DeviceState *dev,
Error **errp)
{
MachineState *machine = MACHINE(OBJECT(hotplug_dev));
MachineClass *mc = MACHINE_GET_CLASS(hotplug_dev);
Error *local_err = NULL;
CPUCore *cc = CPU_CORE(dev);
char *base_core_t... | [
1,
1
] |
FFmpeg | libavfilter/asrc_abuffer.c | int av_asrc_buffer_add_buffer(AVFilterContext *ctx,
uint8_t *buf, int buf_size, int sample_rate,
int sample_fmt, int64_t channel_layout,
int planar,
int64_t pts, int av_unused flags)
{
uint8_t ... | [
1,
0
] |
qemu | hw/block/nand.c | void nand_setpins(DeviceState *dev, uint8_t cle, uint8_t ale,
uint8_t ce, uint8_t wp, uint8_t gnd)
{
NANDFlashState *s = (NANDFlashState *)dev;
s->cle = cle;
s->ale = ale;
s->ce = ce;
s->wp = wp;
s->gnd = gnd;
if (wp)
s->status |= NAND_IOSTATUS_UNPROTCT;
else
s->sta... | [
1,
0
] |
FFmpeg | libavcodec/dnxhdenc.c | static av_cold int dnxhd_init_rc(DNXHDEncContext *ctx)
{
FF_ALLOCZ_OR_GOTO(ctx->m.avctx, ctx->mb_rc,
8160 * ctx->m.avctx->qmax * sizeof(RCEntry), fail);
if (ctx->m.avctx->mb_decision != FF_MB_DECISION_RD)
FF_ALLOCZ_OR_GOTO(ctx->m.avctx, ctx->mb_cmp,
ctx->m.mb_num * ... | [
1,
0
] |
qemu | hw/spapr_llan.c | static char *vio_format_dev_name(VIOsPAPRDevice *dev)
{
VIOsPAPRDeviceInfo *info = (VIOsPAPRDeviceInfo *)qdev_get_info(&dev->qdev);
char *name;
/* Device tree style name device@reg */
if (asprintf(&name, "%s@%x", info->dt_name, dev->reg) < 0) {
return NULL;
}
return name;
} | [
0,
0
] |
qemu | hw/elf_ops.h | static int load_option_rom(const char *oprom, target_phys_addr_t start,
target_phys_addr_t end)
{
int size;
char *filename;
filename = qemu_find_file(QEMU_FILE_TYPE_BIOS, oprom);
if (filename) {
size = get_image_size(filename);
if (size > 0 && start + size > end) {
... | [
1,
0
] |
qemu | exec-all.h | void tlb_fill(target_ulong addr, int is_write, int mmu_idx, void *retaddr)
{
TranslationBlock *tb;
CPUState *saved_env;
unsigned long pc;
int ret;
/* XXX: hack to restore env in all cases, even if not called from
generated code */
saved_env = env;
env = cpu_single_env;
D_LOG("%s pc=%x tpc... | [
0,
1
] |
qemu | target-lm32/cpu.c | static void lm32_cpu_reset(CPUState *s)
{
LM32CPU *cpu = LM32_CPU(s);
LM32CPUClass *lcc = LM32_CPU_GET_CLASS(cpu);
CPULM32State *env = &cpu->env;
if (qemu_loglevel_mask(CPU_LOG_RESET)) {
qemu_log("CPU Reset (CPU %d)\n", s->cpu_index);
log_cpu_state(env, 0);
}
lcc->parent_reset(s);
tlb_flu... | [
1,
0
] |
qemu | block/qapi.c | static void test_visitor_in_wrong_type(TestInputVisitorData *data,
const void *unused)
{
TestStruct *p = NULL;
Visitor *v;
strList *q = NULL;
int64_t i;
Error *err = NULL;
/* Make sure arrays and structs cannot be confused */
v = visitor_input_test_init(data... | [
0,
0
] |
FFmpeg | ffmpeg.c | static int opt_default(const char *opt, const char *arg) {
int type;
const AVOption *o = NULL;
int opt_types[] = {AV_OPT_FLAG_VIDEO_PARAM, AV_OPT_FLAG_AUDIO_PARAM, 0,
AV_OPT_FLAG_SUBTITLE_PARAM, 0};
for (type = 0; type < CODEC_TYPE_NB; type++) {
const AVOption *o2 =
av_find... | [
1,
1
] |
qemu | tests/test-cutils.c | static void test_qemu_strtoul_overflow(void)
{
const char *str = "99999999999999999999999999999999999999999999";
char f = 'X';
const char *endptr = &f;
unsigned long res = 999;
int err;
err = qemu_strtoul(str, &endptr, 0, &res);
g_assert_cmpint(err, ==, -ERANGE);
g_assert_cmpint(res, ==, ULONG_... | [
1,
0
] |
qemu | hw/vfio_pci.c | static void vfio_pci_reset(DeviceState *dev)
{
PCIDevice *pdev = DO_UPCAST(PCIDevice, qdev, dev);
VFIODevice *vdev = DO_UPCAST(VFIODevice, pdev, pdev);
if (!vdev->reset_works) {
return;
}
if (ioctl(vdev->fd, VFIO_DEVICE_RESET)) {
error_report("vfio: Error unable to reset physical device "
... | [
0,
0
] |
FFmpeg | libswscale/Makefile | static inline void
RENAME(yuv422ptoyuy2)(const uint8_t *ysrc, const uint8_t *usrc,
const uint8_t *vsrc, uint8_t *dst,
long width, long height,
long lumStride, long chromStride, long dstStride)
{
RENAME(yuvPlanartoyuy2)(ysrc, usrc, vsrc, dst, width,... | [
0,
0
] |
qemu | hw/vfio/common.c | static void vfio_exitfn(PCIDevice *pdev)
{
VFIOPCIDevice *vdev = DO_UPCAST(VFIOPCIDevice, pdev, pdev);
VFIOGroup *group = vdev->vbasedev.group;
vfio_unregister_err_notifier(vdev);
pci_device_set_intx_routing_notifier(&vdev->pdev, NULL);
vfio_disable_interrupts(vdev);
if (vdev->intx.mmap_timer) {
... | [
1,
0
] |
FFmpeg | libavcodec/dcadec.c | static av_cold void dcadec_flush(AVCodecContext *avctx)
{
DCAContext *s = avctx->priv_data;
ff_dca_core_flush(&s->core);
ff_dca_xll_flush(&s->xll);
ff_dca_lbr_flush(&s->lbr);
s->core_residual_valid = 0;
} | [
0,
0
] |
FFmpeg | libavcodec/libmp3lame.c | static int check(AVIOContext *pb, int64_t pos, int64_t *out_pos)
{
MPADecodeHeader mh = {0};
int i;
uint32_t header;
int64_t off = 0;
for (i = 0; i < SEEK_PACKETS; i++) {
off = avio_seek(pb, pos + mh.frame_size, SEEK_SET);
if (off < 0)
break;
header = avio_rb32(pb);
if (ff_mpa... | [
1,
0
] |
qemu | Makefile.objs | static void put_uint16(QEMUFile *f, void *pv, size_t size)
{
uint16_t *v = pv;
qemu_put_be16s(f, v);
} | [
1,
0
] |
FFmpeg | libavformat/img2dec.c | static int dpx_probe(AVProbeData *p)
{
const uint8_t *b = p->buf;
if (AV_RN32(b) == AV_RN32("SDPX") || AV_RN32(b) == AV_RN32("XPDS"))
return AVPROBE_SCORE_EXTENSION + 1;
return 0;
} | [
1,
0
] |
FFmpeg | libavformat/yop.c | static int yop_read_seek(AVFormatContext *s, int stream_index,
int64_t timestamp, int flags)
{
YopDecContext *yop = s->priv_data;
int64_t frame_pos, pos_min, pos_max;
int frame_count;
av_free_packet(&yop->video_packet);
if (!stream_index)
return -1;
pos_min = s->data_of... | [
1,
0
] |
qemu | target/s390x/cpu.h | uint32_t HELPER(tprot)(CPUS390XState *env, uint64_t a1, uint64_t a2)
{
S390CPU *cpu = s390_env_get_cpu(env);
CPUState *cs = CPU(cpu);
/*
* TODO: we currently don't handle all access protection types
* (including access-list and key-controlled) as well as AR mode.
*/
if (!s390_cpu_virt_mem_check... | [
1,
1
] |
qemu | include/monitor/monitor.h | static int monitor_fdset_dup_fd_find_remove(int dup_fd, bool remove)
{
MonFdset *mon_fdset;
MonFdsetFd *mon_fdset_fd_dup;
QLIST_FOREACH(mon_fdset, &mon_fdsets, next) {
QLIST_FOREACH(mon_fdset_fd_dup, &mon_fdset->dup_fds, next) {
if (mon_fdset_fd_dup->fd == dup_fd) {
if (remove) {
... | [
1,
0
] |
qemu | block/qcow.c | static void qcow_close(BlockDriverState *bs)
{
BDRVQcowState *s = bs->opaque;
g_free(s->l1_table);
g_free(s->l2_cache);
g_free(s->cluster_cache);
g_free(s->cluster_data);
migrate_del_blocker(s->migration_blocker);
error_free(s->migration_blocker);
} | [
1,
0
] |
qemu | block/iscsi.c | iscsi_readv_writev_bh_cb(void *p)
{
IscsiAIOCB *acb = p;
qemu_bh_delete(acb->bh);
if (!acb->canceled) {
acb->common.cb(acb->common.opaque, acb->status);
}
qemu_aio_release(acb);
if (acb->canceled) {
return;
}
scsi_free_scsi_task(acb->task);
acb->task = NULL;
} | [
1,
0
] |
FFmpeg | postproc/rgb2rgb.c | static inline void RENAME(yuv2yuv1)(int16_t *lumSrc, int16_t *chrSrc,
uint8_t *dest, uint8_t *uDest,
uint8_t *vDest, int dstW, int chrDstW)
{
#ifdef HAVE_MMX
if (uDest != NULL)
{
asm volatile(
YSCALEYUV2YV121
::"r"(c... | [
1,
0
] |
FFmpeg | libavformat/assdec.c | static int read_dialogue(ASSContext *ass, AVBPrint *dst, const uint8_t *p,
int64_t *start, int *duration)
{
int pos;
int64_t end;
int hh1, mm1, ss1, ms1;
int hh2, mm2, ss2, ms2;
if (sscanf(p, "Dialogue: %*[^,],%d:%d:%d%*c%d,%d:%d:%d%*c%d,%n",
&hh1, &mm1, &ss1, &ms... | [
1,
0
] |
FFmpeg | libavcodec/wavpack.c | static inline int wv_get_value_integer(WavpackFrameContext *s, uint32_t *crc,
int S)
{
unsigned bit;
if (s->extra_bits) {
S <<= s->extra_bits;
if (s->got_extra_bits &&
get_bits_left(&s->gb_extra_bits) >= s->extra_bits) {
S |= get_bits_long(&s->gb_... | [
1,
0
] |
qemu | qemu-char.c | static int qemu_chr_open_pty(QemuOpts *opts, CharDriverState **_chr)
{
CharDriverState *chr;
PtyCharDriver *s;
struct termios tty;
int slave_fd, len;
#if defined(__OpenBSD__) || defined(__DragonFly__)
char pty_name[PATH_MAX];
#define q_ptsname(x) pty_name
#else
char *pty_name = NULL;
#define q_pt... | [
1,
0
] |
FFmpeg | libavformat/rtsp.c | static void rtsp_parse_rtp_info(RTSPState *rt, const char *p)
{
int read = 0;
char key[20], value[1024], url[1024] = "";
uint32_t seq = 0, rtptime = 0;
for (;;) {
p += strspn(p, SPACE_CHARS);
if (!*p)
break;
get_word_sep(key, sizeof(key), "=", &p);
if (*p != '=')
break;
... | [
1,
0
] |
FFmpeg | libavformat/utils.c | void avpriv_set_pts_info(AVStream *s, int pts_wrap_bits,
unsigned int pts_num, unsigned int pts_den)
{
AVRational new_tb;
if (av_reduce(&new_tb.num, &new_tb.den, pts_num, pts_den, INT_MAX)) {
if (new_tb.num != pts_num)
av_log(NULL, AV_LOG_DEBUG,
"st:%d removing ... | [
1,
0
] |
qemu | hw/pci_bridge.c | static void pci_bridge_region_init(PCIBridge *br)
{
PCIBus *parent = br->dev.bus;
uint16_t cmd = pci_get_word(br->dev.config + PCI_COMMAND);
pci_bridge_init_alias(br, &br->alias_pref_mem,
PCI_BASE_ADDRESS_MEM_PREFETCH,
"pci_bridge_pref_mem",
... | [
1,
1
] |
FFmpeg | libavcodec/mpeg12.c | static int load_matrix(MpegEncContext *s, uint16_t matrix0[64],
uint16_t matrix1[64], int intra)
{
int i;
for (i = 0; i < 64; i++) {
int j = s->dsp.idct_permutation[ff_zigzag_direct[i]];
int v = get_bits(&s->gb, 8);
if (v == 0) {
av_log(s->avctx, AV_LOG_ERROR, "matrix... | [
1,
0
] |
qemu | qemu-ga.c | static void child_handler(int sig)
{
int status;
while (waitpid(-1, &status, WNOHANG) > 0) /* NOTHING */
;
} | [
1,
0
] |
qemu | block/block-backend.c | static void ide_atapi_cmd_read_dma(IDEState *s, int lba, int nb_sectors,
int sector_size)
{
s->lba = lba;
s->packet_transfer_size = nb_sectors * sector_size;
s->io_buffer_index = 0;
s->io_buffer_size = 0;
s->cd_sector_size = sector_size;
block_acct_start(bdrv_get_s... | [
0,
1
] |
FFmpeg | avconv.c | static int copy_from(IpvideoContext *s, AVFrame *src, AVFrame *dst, int delta_x,
int delta_y)
{
int current_offset = s->pixel_ptr - dst->data[0];
int motion_offset = current_offset + delta_y * dst->linesize[0]
+ delta_x * (1 + s->is_16bpp);
if (motion_offset < 0) {
... | [
1,
0
] |
qemu | target-s390x/kvm.c | static int kvm_sclp_service_call(CPUS390XState *env, struct kvm_run *run,
uint16_t ipbh0)
{
uint32_t sccb;
uint64_t code;
int r = 0;
cpu_synchronize_state(env);
sccb = env->regs[ipbh0 & 0xf];
code = env->regs[(ipbh0 & 0xf0) >> 4];
r = sclp_service_call(env, sccb, ... | [
0,
0
] |
qemu | hw/timer/imx_epit.c | static void imx_epit_reset(DeviceState *dev)
{
IMXEPITState *s = IMX_EPIT(dev);
/*
* Soft reset doesn't touch some bits; hard reset clears them
*/
s->cr &= (CR_EN | CR_ENMOD | CR_STOPEN | CR_DOZEN | CR_WAITEN | CR_DBGEN);
s->sr = 0;
s->lr = TIMER_MAX;
s->cmp = 0;
s->cnt = 0;
/* stop bot... | [
1,
0
] |
qemu | target-ppc/cpu.h | static int pte32_check(mmu_ctx_t *ctx,
target_ulong pte0, target_ulong pte1, int h, int rw)
{
return _pte_check(ctx, 0, pte0, pte1, h, rw);
} | [
0,
0
] |
FFmpeg | libavformat/r3d.c | static int r3d_read_redv(AVFormatContext *s, AVPacket *pkt, Atom *atom)
{
AVStream *st = s->streams[0];
int tmp, tmp2;
uint64_t pos = url_ftell(s->pb);
unsigned dts;
dts = get_be32(s->pb);
tmp = get_be32(s->pb);
dprintf(s, "frame num %d\n", tmp);
tmp = get_byte(s->pb); // major version
tmp2 ... | [
1,
0
] |
FFmpeg | libavcodec/mjpegdec.c | static int decode_block_refinement(MJpegDecodeContext *s, int16_t *block,
uint8_t *last_nnz,
int ac_index, int16_t *quant_matrix,
int ss, int se, int Al, int *EOBRUN)
{
int code, i = ss, j, sign, val, run;
... | [
1,
0
] |
qemu | fpu/softfloat-specialize.h | float64 helper_sub_cmpf64(CPUM68KState *env, float64 src0, float64 src1)
{
/* ??? This may incorrectly raise exceptions. */
/* ??? Should flush denormals to zero. */
float64 res;
res = float64_sub(src0, src1, &env->fp_status);
if (float64_is_nan(res)) {
/* +/-inf compares equal against itself, bu... | [
0,
0
] |
qemu | block/ssh.c | check_host_key_hash(BDRVSSHState *s, const char *hash,
int hash_type, size_t fingerprint_len)
{
const char *fingerprint;
fingerprint = libssh2_hostkey_hash(s->session, hash_type);
if (!fingerprint) {
session_error_report(s, "failed to read remote host key");
return -EINVAL;
}
... | [
0,
0
] |
FFmpeg | libavcodec/vc9.c | static int decode_hrd(VC9Context *v, GetBitContext *gb)
{
int i, num;
num = get_bits(gb, 5);
if (v->hrd_rate || num != v->hrd_num_leaky_buckets)
{
av_freep(&v->hrd_rate);
}
if (!v->hrd_rate)
v->hrd_rate = av_malloc(num);
if (!v->hrd_rate)
return -1;
if (v->hrd_buffer || num != v->hr... | [
1,
0
] |
qemu | configure | static int handle_utimensat(FsContext *ctx, V9fsPath *fs_path,
const struct timespec *buf)
{
int fd, ret;
struct handle_data *data = (struct handle_data *)ctx->private;
fd = open_by_handle(data->mountfd, fs_path->data, O_NONBLOCK);
if (fd < 0) {
return fd;
}
ret = fut... | [
0,
0
] |
qemu | include/exec/gen-icount.h | static void gen_conditional_jump(DisasContext *ctx,
target_ulong ift, target_ulong ifnott)
{
int l1;
TCGv sr;
l1 = gen_new_label();
sr = tcg_temp_new();
tcg_gen_andi_i32(sr, cpu_sr, SR_T);
tcg_gen_brcondi_i32(TCG_COND_NE, sr, 0, l1);
gen_goto_tb(ctx, 0, ifnott);
... | [
0,
0
] |
qemu | Makefile.objs | static void sigchld_handler(int signal)
{
qemu_bh_schedule(sigchld_bh);
} | [
0,
0
] |
qemu | fpu/softfloat-native.c | int float64_is_nan(float64 a1)
{
float64u u;
uint64_t a;
u.f = a1;
a = u.i;
return (LIT64(0xFFF0000000000000) < (bits64)(a << 1));
} | [
0,
0
] |
qemu | fpu/softfloat-native.c | uint32_t helper_efdctsf(uint64_t val)
{
CPU_DoubleU u;
float64 tmp;
u.ll = val;
/* NaN are not treated the same way IEEE 754 does */
if (unlikely(float64_is_nan(u.d)))
return 0;
tmp = uint64_to_float64(1ULL << 32, &env->vec_status);
u.d = float64_mul(u.d, tmp, &env->vec_status);
return flo... | [
0,
0
] |
qemu | block/nbd.c | static void char_socket_class_init(ObjectClass *oc, void *data)
{
ChardevClass *cc = CHARDEV_CLASS(oc);
cc->parse = qemu_chr_parse_socket;
cc->open = qmp_chardev_open_socket;
cc->chr_wait_connected = tcp_chr_wait_connected;
cc->chr_write = tcp_chr_write;
cc->chr_sync_read = tcp_chr_sync_read;
cc->... | [
0,
0
] |
qemu | net/socket.c | static ssize_t net_socket_receive(NetClientState *nc, const uint8_t *buf,
size_t size)
{
NetSocketState *s = DO_UPCAST(NetSocketState, nc, nc);
uint32_t len;
len = htonl(size);
send_all(s->fd, (const uint8_t *)&len, sizeof(len));
return send_all(s->fd, buf, size);
} | [
1,
1
] |
qemu | HACKING | static uint64_t mv88w8618_wlan_read(void *opaque, target_phys_addr_t offset,
unsigned size)
{
switch (offset) {
/* Workaround to allow loading the binary-only wlandrv.ko crap
* from the original Freecom firmware. */
case MP_WLAN_MAGIC1:
return ~3;
case MP_W... | [
0,
0
] |
FFmpeg | libavcodec/dxtory.c | static int dxtory_decode_v2_565(AVCodecContext *avctx, AVFrame *pic,
const uint8_t *src, int src_size, int is_565)
{
GetByteContext gb;
GetBitContext gb2;
int nslices, slice, slice_height;
uint32_t off, slice_size;
uint8_t *dst;
int ret;
bytestream2_init(&gb, src, ... | [
1,
0
] |
qemu | linux-user/main.c | static void gen_icread(DisasContext *ctx)
{
#if defined(CONFIG_USER_ONLY)
gen_inval_exception(ctx, POWERPC_EXCP_PRIV_OPC);
#else
if (unlikely(ctx->pr)) {
gen_inval_exception(ctx, POWERPC_EXCP_PRIV_OPC);
return;
}
/* interpreted as no-op */
#endif
} | [
1,
0
] |
qemu | hw/usb/dev-serial.c | static void usb_serial_event(void *opaque, int event)
{
USBSerialState *s = opaque;
switch (event) {
case CHR_EVENT_BREAK:
s->event_trigger |= FTDI_BI;
break;
case CHR_EVENT_FOCUS:
break;
case CHR_EVENT_OPENED:
usb_serial_reset(s);
/* TODO: Reset USB port */
break;
}
} | [
1,
1
] |
qemu | target/i386/translate.c | static void gen_exception(DisasContext *s, int trapno, target_ulong cur_eip)
{
gen_update_cc_op(s);
gen_jmp_im(cur_eip);
gen_helper_raise_exception(cpu_env, tcg_const_i32(trapno));
s->is_jmp = DISAS_TB_JUMP;
} | [
0,
0
] |
qemu | hw/pci-bridge/pci_expander_bridge.c | static uint16_t pxb_bus_numa_node(PCIBus *bus)
{
PXBDev *pxb = PXB_DEV(bus->parent_dev);
return pxb->numa_node;
} | [
0,
0
] |
qemu | tcg/aarch64/tcg-target.inc.c | static uint16_t reloc_pc14_val(tcg_insn_unit *pc, tcg_insn_unit *target)
{
ptrdiff_t disp = tcg_ptr_byte_diff(target, pc);
assert(disp == (int16_t)disp);
return disp & 0xfffc;
} | [
0,
0
] |
FFmpeg | libavcodec/dsputil.c | static inline void h264_loop_filter_luma_c(uint8_t *pix, int xstride,
int ystride, int alpha, int beta,
int8_t *tc0)
{
int i, d;
for (i = 0; i < 4; i++) {
if (tc0[i] < 0) {
pix += 4 * ystride;
continue;
}... | [
1,
0
] |
FFmpeg | libavformat/movenc.c | static int mov_write_udta_tag(ByteIOContext *pb, MOVContext *mov,
AVFormatContext *s)
{
offset_t pos = url_ftell(pb);
int i;
put_be32(pb, 0); /* size */
put_tag(pb, "udta");
/* iTunes meta data */
mov_write_meta_tag(pb, mov, s);
if (mov->mode == MODE_MOV) { // the ti... | [
1,
0
] |
FFmpeg | configure | int ffurl_alloc(URLContext **puc, const char *filename, int flags,
const AVIOInterruptCB *int_cb)
{
URLProtocol *up = NULL;
char proto_str[128], proto_nested[128], *ptr;
size_t proto_len = strspn(filename, URL_SCHEME_CHARS);
if (filename[proto_len] != ':' || is_dos_path(filename))
str... | [
1,
0
] |
qemu | hw/pci-host/bonito.c | static uint64_t bonito_ldma_readl(void *opaque, hwaddr addr, unsigned size) {
uint32_t val;
PCIBonitoState *s = opaque;
val = ((uint32_t *)(&s->bonldma))[addr / sizeof(uint32_t)];
return val; | [
1,
0
] |
FFmpeg | libavcodec/amrwbdec.c | static void decode_pitch_lag_high(int *lag_int, int *lag_frac, int pitch_index,
uint8_t *base_lag_int, int subframe)
{
if (subframe == 0 || subframe == 2) {
if (pitch_index < 376) {
*lag_int = (pitch_index + 137) >> 2;
*lag_frac = pitch_index - (*lag_int << 2) +... | [
1,
1
] |
qemu | hw/net/e1000.c | e1000_autoneg_timer(void *opaque)
{
E1000State *s = opaque;
if (!qemu_get_queue(s->nic)->link_down) {
e1000_link_up(s);
}
s->phy_reg[PHY_STATUS] |= MII_SR_AUTONEG_COMPLETE;
DBGOUT(PHY, "Auto negotiation is completed\n");
} | [
0,
0
] |
qemu | linux-user/cris/target_signal.h | void cpu_loop(CPUCRISState *env)
{
CPUState *cs = CPU(cris_env_get_cpu(env));
int trapnr, ret;
target_siginfo_t info;
while (1) {
cpu_exec_start(cs);
trapnr = cpu_cris_exec(cs);
cpu_exec_end(cs);
switch (trapnr) {
case 0xaa:
{
info.si_signo = TARGET_SIGSEGV;
info... | [
0,
1
] |
qemu | HACKING | void mcf_uart_write(void *opaque, target_phys_addr_t addr,
uint64_t val, unsigned size)
{
mcf_uart_state *s = (mcf_uart_state *)opaque;
switch (addr & 0x3f) {
case 0x00:
s->mr[s->current_mr] = val;
s->current_mr = 1;
break;
case 0x04:
/* CSR is ignored. */
bre... | [
0,
0
] |
qemu | hw/9pfs/cofs.c | static int mp_user_setxattr(FsContext *ctx, const char *path, const char *name,
void *value, size_t size, int flags)
{
char buffer[PATH_MAX];
if (strncmp(name, "user.virtfs.", 12) == 0) {
/*
* Don't allow fetch of user.virtfs namesapce
* in case of mapped security
... | [
0,
0
] |
qemu | hw/s390x/virtio-ccw.c | static void virtio_crypto_initfn(Object *obj)
{
VirtIOCryptoPCI *dev = VIRTIO_CRYPTO_PCI(obj);
virtio_instance_init_common(obj, &dev->vdev, sizeof(dev->vdev),
TYPE_VIRTIO_CRYPTO);
object_property_add_alias(obj, "cryptodev", OBJECT(&dev->vdev),
"crypt... | [
1,
0
] |
qemu | monitor.c | static void gen_spr_ne_601(CPUPPCState *env)
{
/* Exception processing */
spr_register(env, SPR_DSISR, "DSISR",
SPR_NOACCESS, SPR_NOACCESS,
&spr_read_generic, &spr_write_generic,
0x00000000);
spr_register(env, SPR_DAR, "DAR",
SPR_NOACCESS, SPR_NO... | [
0,
0
] |
qemu | docs/specs/acpi_mem_hotplug.txt | static void nvdimm_class_init(ObjectClass *oc, void *data)
{
DeviceClass *dc = DEVICE_CLASS(oc);
PCDIMMDeviceClass *ddc = PC_DIMM_CLASS(oc);
NVDIMMClass *nvc = NVDIMM_CLASS(oc);
/* nvdimm hotplug has not been supported yet. */
dc->hotpluggable = false;
ddc->realize = nvdimm_realize;
ddc->get_memor... | [
0,
0
] |
qemu | hw/qdev-monitor.c | static BusState *qbus_find_recursive(BusState *bus, const char *name,
const char *bus_typename)
{
BusChild *kid;
BusState *child, *ret;
int match = 1;
if (name && (strcmp(bus->name, name) != 0)) {
match = 0;
}
if (bus_typename &&
(strcmp(object_get_typ... | [
1,
0
] |
qemu | linux-user/elfload.c | static bool elf_check_ehdr(struct elfhdr *ehdr)
{
return (elf_check_arch(ehdr->e_machine)
&& ehdr->e_ehsize == sizeof(struct elfhdr)
&& ehdr->e_phentsize == sizeof(struct elf_phdr)
&& ehdr->e_shentsize == sizeof(struct elf_shdr)
&& (ehdr->e_type == ET_EXEC || ehdr->e_type... | [
1,
0
] |
qemu | include/qapi/qmp/json-streamer.h | static QObject *parse_keyword(JSONParserContext *ctxt)
{
QObject *token;
const char *val;
token = parser_context_pop_token(ctxt);
assert(token && token_get_type(token) == JSON_KEYWORD);
val = token_get_value(token);
if (!strcmp(val, "true")) {
return QOBJECT(qbool_from_bool(true));
} else if ... | [
0,
0
] |
qemu | hw/omap.h | static uint32_t omap_l4_io_readb(void *opaque, target_phys_addr_t addr)
{
unsigned int i = (addr - OMAP2_L4_BASE) >> TARGET_PAGE_BITS;
return omap_l4_io_readb_fn[i](omap_l4_io_opaque[i], addr);
} | [
1,
0
] |
qemu | target-arm/helper.c | static void par_write(CPUARMState *env, const ARMCPRegInfo *ri, uint64_t value)
{
if (arm_feature(env, ARM_FEATURE_LPAE)) {
env->cp15.par_el1 = value;
} else if (arm_feature(env, ARM_FEATURE_V7)) {
env->cp15.par_el1 = value & 0xfffff6ff;
} else {
env->cp15.par_el1 = value & 0xfffff1ff;
}
} | [
1,
0
] |
qemu | qemu-char.c | static int sockaddr_to_str(char *dest, int max_len,
struct sockaddr_storage *ss, socklen_t ss_len,
struct sockaddr_storage *ps, socklen_t ps_len,
bool is_listen, bool is_telnet)
{
char shost[NI_MAXHOST], sserv[NI_MAXSERV];
char p... | [
1,
0
] |
qemu | hw/intc/s390_flic.c | static void s390_flic_common_realize(DeviceState *dev, Error **errp)
{
S390FLICState *fs = S390_FLIC_COMMON(dev);
uint32_t max_batch = fs->adapter_routes_max_batch;
if (max_batch > ADAPTER_ROUTES_MAX_GSI) {
error_setg(errp,
"flic property adapter_routes_max_batch too big"
"... | [
1,
0
] |
FFmpeg | libavformat/ftp.c | static int ftp_retrieve(FTPContext *s)
{
char command[CONTROL_BUFFER_SIZE];
const int retr_codes[] = {150, 550, 0}; /* 550 is incorrect code */
snprintf(command, sizeof(command), "RETR %s\r\n", s->path);
if (ftp_send_command(s, command, retr_codes, NULL) != 150)
return AVERROR(EIO);
s->state = DOWN... | [
1,
0
] |
FFmpeg | libavcodec/huffyuvenc.c | static inline int sub_left_prediction(HYuvContext *s, uint8_t *dst,
const uint8_t *src, int w, int left)
{
int i;
if (s->bps <= 8) {
if (w < 32) {
for (i = 0; i < w; i++) {
const int temp = src[i];
dst[i] = temp - left;
left = temp;
... | [
0,
0
] |
qemu | hw/ppc/xics.c | static uint32_t icp_accept(struct icp_server_state *ss)
{
uint32_t xirr = ss->xirr;
qemu_irq_lower(ss->output);
ss->xirr = ss->pending_priority << 24;
trace_xics_icp_accept(xirr, ss->xirr);
return xirr;
} | [
1,
0
] |
qemu | hw/ppc/Makefile.objs | VIOsPAPRBus *spapr_vio_bus_init(void)
{
VIOsPAPRBus *bus;
BusState *qbus;
DeviceState *dev;
/* Create bridge device */
dev = qdev_create(NULL, "spapr-vio-bridge");
qdev_init_nofail(dev);
/* Create bus on bridge device */
qbus = qbus_create(TYPE_SPAPR_VIO_BUS, dev, "spapr-vio");
bus = DO_UPCA... | [
1,
0
] |
qemu | hw/misc/vfio.c | static void vfio_msi_interrupt(void *opaque)
{
VFIOMSIVector *vector = opaque;
VFIODevice *vdev = vector->vdev;
int nr = vector - vdev->msi_vectors;
if (!event_notifier_test_and_clear(&vector->interrupt)) {
return;
}
DPRINTF("%s(%04x:%02x:%02x.%x) vector %d\n", __func__,
vdev->host.dom... | [
1,
0
] |
FFmpeg | libavformat/4xm.c | static int avi_probe(AVProbeData *p)
{
/* check file header */
if (p->buf_size <= 32)
return 0;
if (p->buf[0] == 'R' && p->buf[1] == 'I' &&
p->buf[2] == 'F' && p->buf[3] == 'F' &&
p->buf[8] == 'A' && p->buf[9] == 'V' &&
p->buf[10] == 'I' && (p->buf[11] == ' ' || p->buf[11] == 0x19))
... | [
1,
0
] |
FFmpeg | libavcodec/vp8.c | static void vp8_decode_mb_row_no_filter(AVCodecContext *avctx, void *tdata,
int jobnr, int threadnr)
{
decode_mb_row_no_filter(avctx, tdata, jobnr, threadnr, 0);
} | [
1,
0
] |
qemu | hw/s390x/s390-pci-bus.c | static void s390_pci_generate_event(uint8_t cc, uint16_t pec, uint32_t fh,
uint32_t fid, uint64_t faddr, uint32_t e)
{
SeiContainer *sei_cont;
S390pciState *s = S390_PCI_HOST_BRIDGE(
object_resolve_path(TYPE_S390_PCI_HOST_BRIDGE, NULL));
if (!s) {
return;
}
... | [
0,
0
] |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.