id int32 0 27.3k | func stringlengths 26 142k | target bool 2
classes | project stringclasses 2
values | commit_id stringlengths 40 40 |
|---|---|---|---|---|
3,300 | static always_inline void gen_arith3 (void *helper,
int ra, int rb, int rc,
int islit, uint8_t lit)
{
if (unlikely(rc == 31))
return;
if (ra != 31) {
if (islit) {
TCGv tmp = tcg_const_i64(lit);
... | false | qemu | a7812ae412311d7d47f8aa85656faadac9d64b56 |
3,301 | int cpu_get_dump_info(ArchDumpInfo *info,
const struct GuestPhysBlockList *guest_phys_blocks)
{
PowerPCCPU *cpu = POWERPC_CPU(first_cpu);
PowerPCCPUClass *pcc = POWERPC_CPU_GET_CLASS(cpu);
info->d_machine = PPC_ELF_MACHINE;
info->d_class = ELFCLASS;
if ((*pcc->interr... | false | qemu | b1fde1ef5106c92dd12f1f0cfcb8c76e57d7f681 |
3,303 | static CharDriverState *qemu_chr_open_pty(QemuOpts *opts)
{
CharDriverState *chr;
PtyCharDriver *s;
struct termios tty;
const char *label;
int master_fd, slave_fd, len;
#if defined(__OpenBSD__) || defined(__DragonFly__)
char pty_name[PATH_MAX];
#define q_ptsname(x) pty_name
#else
... | false | qemu | e68c5958668596a5023e30ddf8368410878f7682 |
3,304 | static void put_frame(
AVFormatContext *s,
ASFStream *stream,
int timestamp,
const uint8_t *buf,
int m_obj_size
)
{
ASFContext *asf = s->priv_data;
int m_obj_offset, payload_len, frag_len1;
... | false | FFmpeg | 3c895fc098f7637f6d5ec3a9d6766e724a8b9e41 |
3,305 | static char *print_drive(void *ptr)
{
return g_strdup(bdrv_get_device_name(ptr));
}
| false | qemu | 4be746345f13e99e468c60acbd3a355e8183e3ce |
3,306 | static int disas_neon_data_insn(CPUState * env, DisasContext *s, uint32_t insn)
{
int op;
int q;
int rd, rn, rm;
int size;
int shift;
int pass;
int count;
int pairwise;
int u;
uint32_t imm, mask;
TCGv tmp, tmp2, tmp3, tmp4, tmp5;
TCGv_i64 tmp64;
if (!s... | false | qemu | fc2a9b37849d25d21d161c1319581420499ab4b2 |
3,307 | static void rtas_nvram_store(PowerPCCPU *cpu, sPAPREnvironment *spapr,
uint32_t token, uint32_t nargs,
target_ulong args,
uint32_t nret, target_ulong rets)
{
sPAPRNVRAM *nvram = spapr->nvram;
hwaddr offset, buffer, len;... | false | qemu | 4be746345f13e99e468c60acbd3a355e8183e3ce |
3,308 | int coroutine_fn qed_find_cluster(BDRVQEDState *s, QEDRequest *request,
uint64_t pos, size_t *len,
uint64_t *img_offset)
{
uint64_t l2_offset;
uint64_t offset = 0;
unsigned int index;
unsigned int n;
int ret;
/* Limit... | false | qemu | 1f01e50b8330c24714ddca5841fdbb703076b121 |
3,310 | static int send_solid_rect(VncState *vs)
{
size_t bytes;
vnc_write_u8(vs, VNC_TIGHT_FILL << 4); /* no flushing, no filter */
if (vs->tight_pixel24) {
tight_pack24(vs, vs->tight.buffer, 1, &vs->tight.offset);
bytes = 3;
} else {
bytes = vs->clientds.pf.bytes_per_pixel;... | false | qemu | 245f7b51c0ea04fb2224b1127430a096c91aee70 |
3,311 | int DMA_read_memory (int nchan, void *buf, int pos, int len)
{
struct dma_regs *r = &dma_controllers[nchan > 3].regs[nchan & 3];
target_phys_addr_t addr = ((r->pageh & 0x7f) << 24) | (r->page << 16) | r->now[ADDR];
if (r->mode & 0x20) {
int i;
uint8_t *p = buf;
cpu_physica... | false | qemu | a8170e5e97ad17ca169c64ba87ae2f53850dab4c |
3,313 | static ssize_t nc_sendv_compat(NetClientState *nc, const struct iovec *iov,
int iovcnt)
{
uint8_t buffer[4096];
size_t offset;
offset = iov_to_buf(iov, iovcnt, 0, buffer, sizeof(buffer));
return nc->info->receive(nc, buffer, offset);
}
| false | qemu | d32fcad366e5f45d33dab2ee4de0e5729439680b |
3,314 | static uint32_t gic_dist_readl(void *opaque, target_phys_addr_t offset)
{
uint32_t val;
val = gic_dist_readw(opaque, offset);
val |= gic_dist_readw(opaque, offset + 2) << 16;
return val;
}
| false | qemu | a8170e5e97ad17ca169c64ba87ae2f53850dab4c |
3,315 | static int ftp_flush_control_input(FTPContext *s)
{
char buf[CONTROL_BUFFER_SIZE];
int err, ori_block_flag = s->conn_control_block_flag;
s->conn_control_block_flag = 1;
do {
err = ftp_get_line(s, buf, sizeof(buf));
} while (!err);
s->conn_control_block_flag = ori_block_flag;
... | false | FFmpeg | 247e658784ead984f96021acb9c95052ba599f26 |
3,316 | static void virtio_rng_device_realize(DeviceState *dev, Error **errp)
{
VirtIODevice *vdev = VIRTIO_DEVICE(dev);
VirtIORNG *vrng = VIRTIO_RNG(dev);
Error *local_err = NULL;
if (!vrng->conf.period_ms > 0) {
error_setg(errp, "'period' parameter expects a positive integer");
return... | false | qemu | a3a292c420d2fec3c07a7ca56fbb064cd57a298a |
3,317 | void arm_sysctl_init(uint32_t base, uint32_t sys_id)
{
DeviceState *dev;
dev = qdev_create(NULL, "realview_sysctl");
qdev_prop_set_uint32(dev, "sys_id", sys_id);
qdev_init_nofail(dev);
sysbus_mmio_map(sysbus_from_qdev(dev), 0, base);
}
| false | qemu | 26e92f65525ef4446a500d85e185cf78835922aa |
3,318 | fdctrl_t *sun4m_fdctrl_init (qemu_irq irq, target_phys_addr_t io_base,
BlockDriverState **fds)
{
fdctrl_t *fdctrl;
fdctrl = fdctrl_init(irq, 0, 1, io_base, fds);
fdctrl->sun4m = 1;
return fdctrl;
}
| false | qemu | 7c560456707bfe53eb1728fcde759be7d9418b62 |
3,319 | void cpu_loop(CPUUniCore32State *env)
{
CPUState *cs = CPU(uc32_env_get_cpu(env));
int trapnr;
unsigned int n, insn;
target_siginfo_t info;
for (;;) {
cpu_exec_start(cs);
trapnr = uc32_cpu_exec(cs);
cpu_exec_end(cs);
switch (trapnr) {
case UC32_EX... | false | qemu | 120a9848c2f667bf8f1a06772dc9cde064d92a7d |
3,321 | static int tm2_read_stream(TM2Context *ctx, const uint8_t *buf, int stream_id, int buf_size)
{
int i;
int cur = 0;
int skip = 0;
int len, toks;
TM2Codes codes;
/* get stream length in dwords */
len = AV_RB32(buf); buf += 4; cur += 4;
skip = len * 4 + 4;
if(len == 0)
... | true | FFmpeg | 65f0f9183b99881af58e90e3ae2ad8b0181d52f1 |
3,323 | int64_t av_gcd(int64_t a, int64_t b)
{
if (b)
return av_gcd(b, a % b);
else
return a;
}
| true | FFmpeg | 971d12b7f9d7be3ca8eb98e6c04ed521f83cbd3c |
3,324 | static inline int ape_decode_value_3900(APEContext *ctx, APERice *rice)
{
unsigned int x, overflow;
int tmpk;
overflow = range_get_symbol(ctx, counts_3970, counts_diff_3970);
if (overflow == (MODEL_ELEMENTS - 1)) {
tmpk = range_decode_bits(ctx, 5);
overflow = 0;
} else
... | true | FFmpeg | ebfe154bd52204a4da19d26d8d5ae0f8003558ac |
3,325 | int avcodec_decode_video(AVCodecContext *avctx, AVPicture *picture,
int *got_picture_ptr,
UINT8 *buf, int buf_size)
{
int ret;
ret = avctx->codec->decode(avctx, picture, got_picture_ptr,
buf, buf_size);
avctx->frame_... | true | FFmpeg | 1cb0edb40b8e94e1a50ad40c40d43e34ed8435fe |
3,326 | static void nbd_teardown_connection(NbdClientSession *client)
{
struct nbd_request request = {
.type = NBD_CMD_DISC,
.from = 0,
.len = 0
};
nbd_send_request(client->sock, &request);
/* finish any pending coroutines */
shutdown(client->sock, 2);
nbd_recv_coro... | true | qemu | 4a41a2d68a684241aca96dba066e0699941b730d |
3,329 | static void do_bit_allocation(AC3DecodeContext *ctx, int flags)
{
ac3_audio_block *ab = &ctx->audio_block;
int i, snroffst = 0;
if (!flags) /* bit allocation is not required */
return;
if (ab->flags & AC3_AB_SNROFFSTE) { /* check whether snroffsts are zero */
snroffst += ab->c... | false | FFmpeg | 486637af8ef29ec215e0e0b7ecd3b5470f0e04e5 |
3,331 | static int adx_decode_header(AVCodecContext *avctx, const uint8_t *buf,
int bufsize)
{
int offset;
if (buf[0] != 0x80)
return 0;
offset = (AV_RB32(buf) ^ 0x80000000) + 4;
if (bufsize < offset || memcmp(buf + offset - 6, "(c)CRI", 6))
return 0;
... | false | FFmpeg | e2d1eace00a80c4b53998397d38ea4e08c5d47f0 |
3,332 | static void scsi_write_complete(void * opaque, int ret)
{
SCSIDiskReq *r = (SCSIDiskReq *)opaque;
SCSIDiskState *s = DO_UPCAST(SCSIDiskState, qdev, r->req.dev);
uint32_t n;
if (r->req.aiocb != NULL) {
r->req.aiocb = NULL;
block_acct_done(bdrv_get_stats(s->qdev.conf.bs), &r->acct... | false | qemu | 3df9caf88f5c0859ae380101fea47609ba1dbfbd |
3,334 | static void mark_request_serialising(BdrvTrackedRequest *req, uint64_t align)
{
int64_t overlap_offset = req->offset & ~(align - 1);
unsigned int overlap_bytes = ROUND_UP(req->offset + req->bytes, align)
- overlap_offset;
if (!req->serialising) {
req->bs->seria... | false | qemu | 61007b316cd71ee7333ff7a0a749a8949527575f |
3,335 | STATIC void DEF(avg, pixels8_xy2)(uint8_t *block, const uint8_t *pixels,
ptrdiff_t line_size, int h)
{
MOVQ_ZERO(mm7);
SET_RND(mm6); // =2 for rnd and =1 for no_rnd version
__asm__ volatile(
"movq (%1), %%mm0 \n\t"
"movq 1(%1), %%mm4... | false | FFmpeg | 308e7484a3b1954072871a4090e5c672d1097fa5 |
3,336 | start_list(Visitor *v, const char *name, Error **errp)
{
StringInputVisitor *siv = to_siv(v);
if (parse_str(siv, name, errp) < 0) {
return;
}
siv->cur_range = g_list_first(siv->ranges);
if (siv->cur_range) {
Range *r = siv->cur_range->data;
if (r) {
... | false | qemu | d9f62dde1303286b24ac8ce88be27e2b9b9c5f46 |
3,337 | static int check_arg(const CmdArgs *cmd_args, QDict *args)
{
QObject *value;
const char *name;
name = qstring_get_str(cmd_args->name);
if (!args) {
return check_opt(cmd_args, name, args);
}
value = qdict_get(args, name);
if (!value) {
return check_opt(cmd_args... | false | qemu | f6b4fc8b23b1154577c72937b70e565716bb0a60 |
3,338 | static void blkdebug_refresh_filename(BlockDriverState *bs)
{
QDict *opts;
const QDictEntry *e;
bool force_json = false;
for (e = qdict_first(bs->options); e; e = qdict_next(bs->options, e)) {
if (strcmp(qdict_entry_key(e), "config") &&
strcmp(qdict_entry_key(e), "x-image") ... | false | qemu | 4cdd01d32ee6fe04f8d909bfd3708be6864873a2 |
3,340 | static void memory_region_initfn(Object *obj)
{
MemoryRegion *mr = MEMORY_REGION(obj);
ObjectProperty *op;
mr->ops = &unassigned_mem_ops;
mr->enabled = true;
mr->romd_mode = true;
mr->global_locking = true;
mr->destructor = memory_region_destructor_none;
QTAILQ_INIT(&mr->subre... | false | qemu | b61359781958759317ee6fd1a45b59be0b7dbbe1 |
3,341 | static void curl_setup_preadv(BlockDriverState *bs, CURLAIOCB *acb)
{
CURLState *state;
int running;
BDRVCURLState *s = bs->opaque;
uint64_t start = acb->offset;
uint64_t end;
qemu_mutex_lock(&s->mutex);
// In case we have the requested data already (e.g. read-ahead),
//... | false | qemu | 2bb5c936c5827e1d831002f7a7517cb8c2c2201d |
3,342 | static int local_rename(FsContext *ctx, const char *oldpath,
const char *newpath)
{
char *tmp;
int err;
tmp = qemu_strdup(rpath(ctx, oldpath));
if (tmp == NULL) {
return -1;
}
err = rename(tmp, rpath(ctx, newpath));
if (err == -1) {
int ... | false | qemu | f143efa60c44c65c22aeeb04217f3501e3d04b22 |
3,343 | static Visitor *validate_test_init_raw(TestInputVisitorData *data,
const char *json_string)
{
return validate_test_init_internal(data, json_string, NULL);
}
| false | qemu | b3db211f3c80bb996a704d665fe275619f728bd4 |
3,345 | static void gen_compute_branch (DisasContext *ctx, uint32_t opc,
int insn_bytes,
int rs, int rt, int32_t offset)
{
target_ulong btgt = -1;
int blink = 0;
int bcond_compute = 0;
TCGv t0 = tcg_temp_new();
TCGv t1 = tcg_temp_new();... | false | qemu | 620e48f66350991918dd78e9a686a9b159fec111 |
3,346 | static int tak_read_header(AVFormatContext *s)
{
TAKDemuxContext *tc = s->priv_data;
AVIOContext *pb = s->pb;
GetBitContext gb;
AVStream *st;
uint8_t *buffer = NULL;
int ret;
st = avformat_new_stream(s, 0);
if (!st)
return AVERROR(ENOMEM);
st->codec->codec_... | false | FFmpeg | 4977e467a50a690a46af5988d568eaab2e5933c7 |
3,347 | int bdrv_make_zero(BdrvChild *child, BdrvRequestFlags flags)
{
int64_t target_size, ret, bytes, offset = 0;
BlockDriverState *bs = child->bs;
int n; /* sectors */
target_size = bdrv_getlength(bs);
if (target_size < 0) {
return target_size;
}
for (;;) {
bytes = M... | false | qemu | 237d78f8fc62e62f62246883ecf62e44ed35fb80 |
3,349 | void HELPER(wsr_ibreaka)(uint32_t i, uint32_t v)
{
if (env->sregs[IBREAKENABLE] & (1 << i) && env->sregs[IBREAKA + i] != v) {
tb_invalidate_phys_page_range(
env->sregs[IBREAKA + i], env->sregs[IBREAKA + i] + 1, 0);
tb_invalidate_phys_page_range(v, v + 1, 0);
}
env->sre... | false | qemu | 3d0be8a5c135dadcfbd68ed354007a8cece98849 |
3,350 | static unsigned syborg_virtio_get_features(void *opaque)
{
unsigned ret = 0;
ret |= (1 << VIRTIO_F_NOTIFY_ON_EMPTY);
return ret;
}
| false | qemu | 8172539d21a03e982aa7f139ddc1607dc1422045 |
3,351 | static int check_strtox_error(const char *p, char *endptr, const char **next,
int err)
{
if (err == 0 && endptr == p) {
err = EINVAL;
}
if (!next && *endptr) {
return -EINVAL;
}
if (next) {
*next = endptr;
}
return -err;
}
| false | qemu | 717adf960933da0650d995f050d457063d591914 |
3,352 | void spapr_setup_hpt_and_vrma(sPAPRMachineState *spapr)
{
int hpt_shift;
if ((spapr->resize_hpt == SPAPR_RESIZE_HPT_DISABLED)
|| (spapr->cas_reboot
&& !spapr_ovec_test(spapr->ov5_cas, OV5_HPT_RESIZE))) {
hpt_shift = spapr_hpt_shift_for_ramsize(MACHINE(spapr)->maxram_size);
... | false | qemu | ee4d9ecc3675af1e68a9c00a8b338641898d613e |
3,353 | static CharDriverState *qmp_chardev_open_udp(const char *id,
ChardevBackend *backend,
ChardevReturn *ret,
Error **errp)
{
ChardevUdp *udp = backend->u.udp;
ChardevCommon *... | false | qemu | 32bafa8fdd098d52fbf1102d5a5e48d29398c0aa |
3,354 | static inline int vec_reg_offset(int regno, int element, TCGMemOp size)
{
int offs = offsetof(CPUARMState, vfp.regs[regno * 2]);
#ifdef HOST_WORDS_BIGENDIAN
/* This is complicated slightly because vfp.regs[2n] is
* still the low half and vfp.regs[2n+1] the high half
* of the 128 bit vector, eve... | false | qemu | 90e496386fe7fd32c189561f846b7913f95b8cf4 |
3,355 | static void gen_doz(DisasContext *ctx)
{
int l1 = gen_new_label();
int l2 = gen_new_label();
tcg_gen_brcond_tl(TCG_COND_GE, cpu_gpr[rB(ctx->opcode)], cpu_gpr[rA(ctx->opcode)], l1);
tcg_gen_sub_tl(cpu_gpr[rD(ctx->opcode)], cpu_gpr[rB(ctx->opcode)], cpu_gpr[rA(ctx->opcode)]);
tcg_gen_br(l2);
... | false | qemu | 42a268c241183877192c376d03bd9b6d527407c7 |
3,357 | static av_cold int nvenc_alloc_surface(AVCodecContext *avctx, int idx)
{
NvencContext *ctx = avctx->priv_data;
NvencDynLoadFunctions *dl_fn = &ctx->nvenc_dload_funcs;
NV_ENCODE_API_FUNCTION_LIST *p_nvenc = &dl_fn->nvenc_funcs;
NVENCSTATUS nv_status;
NV_ENC_CREATE_BITSTREAM_BUFFER allocOut = ... | false | FFmpeg | 8de3458a07376b0a96772e586b6dba5e93432f52 |
3,358 | void host_cpuid(uint32_t function, uint32_t count,
uint32_t *eax, uint32_t *ebx, uint32_t *ecx, uint32_t *edx)
{
#if defined(CONFIG_KVM)
uint32_t vec[4];
#ifdef __x86_64__
asm volatile("cpuid"
: "=a"(vec[0]), "=b"(vec[1]),
"=c"(vec[2]), "=d"(vec[3])
... | false | qemu | c1f412260b4e0f309dba8da99482fb32d6098719 |
3,359 | int qemu_add_child_watch(pid_t pid)
{
ChildProcessRecord *rec;
if (!sigchld_bh) {
qemu_init_child_watch();
}
QLIST_FOREACH(rec, &child_watches, next) {
if (rec->pid == pid) {
return 1;
}
}
rec = g_malloc0(sizeof(ChildProcessRecord));
rec->p... | false | qemu | c2b38b277a7882a592f4f2ec955084b2b756daaa |
3,360 | static void bitband_writew(void *opaque, target_phys_addr_t offset,
uint32_t value)
{
uint32_t addr;
uint16_t mask;
uint16_t v;
addr = bitband_addr(opaque, offset) & ~1;
mask = (1 << ((offset >> 2) & 15));
mask = tswap16(mask);
cpu_physical_memory_read(add... | false | qemu | a8170e5e97ad17ca169c64ba87ae2f53850dab4c |
3,361 | static int write_console_data(SCLPEvent *event, const uint8_t *buf, int len)
{
int ret = 0;
const uint8_t *buf_offset;
SCLPConsoleLM *scon = SCLPLM_CONSOLE(event);
if (!scon->chr) {
/* If there's no backend, we can just say we consumed all data. */
return len;
}
bu... | false | qemu | 7983e829336f68b6df6952dd4b03493b1486fcf5 |
3,362 | static int mirror_do_read(MirrorBlockJob *s, int64_t sector_num,
int nb_sectors)
{
BlockBackend *source = s->common.blk;
int sectors_per_chunk, nb_chunks;
int ret;
MirrorOp *op;
int max_sectors;
sectors_per_chunk = s->granularity >> BDRV_SECTOR_BITS;
max_... | false | qemu | b436982f04fb33bb29fcdea190bd1fdc97dc65ef |
3,363 | static void tcg_target_init(TCGContext *s)
{
#ifdef CONFIG_GETAUXVAL
unsigned long hwcap = getauxval(AT_HWCAP);
if (hwcap & PPC_FEATURE_ARCH_2_06) {
have_isa_2_06 = true;
}
#endif
tcg_regset_set32(tcg_target_available_regs[TCG_TYPE_I32], 0, 0xffffffff);
tcg_regset_set32(tcg_target... | false | qemu | 5e1702b0742b7cc88e85dfe76c3ba5d1432312aa |
3,364 | static void test_validate_alternate(TestInputVisitorData *data,
const void *unused)
{
UserDefAlternate *tmp = NULL;
Visitor *v;
v = validate_test_init(data, "42");
visit_type_UserDefAlternate(v, NULL, &tmp, &error_abort);
qapi_free_UserDefAlternate(tmp)... | false | qemu | b3db211f3c80bb996a704d665fe275619f728bd4 |
3,366 | static void parse_chap(struct iscsi_context *iscsi, const char *target,
Error **errp)
{
QemuOptsList *list;
QemuOpts *opts;
const char *user = NULL;
const char *password = NULL;
const char *secretid;
char *secret = NULL;
list = qemu_find_opts("iscsi");
... | false | qemu | 4317142020921c6dcdcfda7a349a91088d969f14 |
3,367 | static void mips_fulong2e_init(MachineState *machine)
{
ram_addr_t ram_size = machine->ram_size;
const char *cpu_model = machine->cpu_model;
const char *kernel_filename = machine->kernel_filename;
const char *kernel_cmdline = machine->kernel_cmdline;
const char *initrd_filename = machine->init... | false | qemu | 5039d6e23586fe6bbedc5e4fe302b48a66890ade |
3,369 | static inline void downmix_dualmono_to_stereo(float *samples)
{
int i;
float tmp;
for (i = 0; i < 256; i++) {
tmp = samples[i] + samples[i + 256];
samples[i] = samples[i + 256] = tmp;
}
}
| false | FFmpeg | 0058584580b87feb47898e60e4b80c7f425882ad |
3,370 | static int64_t mmsh_read_seek(URLContext *h, int stream_index,
int64_t timestamp, int flags)
{
MMSHContext *mmsh = h->priv_data;
MMSContext *mms = &mmsh->mms;
int ret;
ret= mmsh_open_internal(h, mmsh->location, 0, timestamp, 0);
if(ret>=0){
if (mms->mms_hd... | false | FFmpeg | 8af4ac5272e8eaff90c3102b9473bb09cc6f4201 |
3,371 | static int get_current_cpu(void)
{
return cpu_single_env->cpu_index;
}
| true | qemu | c3203fa5b2c17a1c446e44c87788fef21b4af5f4 |
3,372 | static void bonito_cop_writel(void *opaque, hwaddr addr,
uint64_t val, unsigned size)
{
PCIBonitoState *s = opaque;
((uint32_t *)(&s->boncop))[addr/sizeof(uint32_t)] = val & 0xffffffff; | true | qemu | 58d479786b11a7e982419c1e0905b8490ef9a787 |
3,373 | static int mxf_read_local_tags(MXFContext *mxf, KLVPacket *klv, MXFMetadataReadFunc *read_child, int ctx_size, enum MXFMetadataSetType type)
{
AVIOContext *pb = mxf->fc->pb;
MXFMetadataSet *ctx = ctx_size ? av_mallocz(ctx_size) : mxf;
uint64_t klv_end = avio_tell(pb) + klv->length;
if (!ctx)
... | true | FFmpeg | 4373a25d94dba2cb361aa18e8d70806e1894df81 |
3,374 | static int vhost_client_migration_log(CPUPhysMemoryClient *client,
int enable)
{
struct vhost_dev *dev = container_of(client, struct vhost_dev, client);
int r;
if (!!enable == dev->log_enabled) {
return 0;
}
if (!dev->started) {
dev->log... | true | qemu | 04097f7c5957273c578f72b9bd603ba6b1d69e33 |
3,376 | long do_rt_sigreturn(CPUS390XState *env)
{
rt_sigframe *frame;
abi_ulong frame_addr = env->regs[15];
sigset_t set;
trace_user_do_rt_sigreturn(env, frame_addr);
if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1)) {
goto badframe;
}
target_to_host_sigset(&set, &frame->... | true | qemu | c599d4d6d6e9bfdb64e54c33a22cb26e3496b96d |
3,377 | static int no_init_out (HWVoiceOut *hw, struct audsettings *as)
{
audio_pcm_init_info (&hw->info, as);
hw->samples = 1024;
return 0;
}
| true | qemu | 5706db1deb061ee9affdcea81e59c4c2cad7c41e |
3,378 | static int protocol_client_vencrypt_init(VncState *vs, uint8_t *data, size_t len)
{
if (data[0] != 0 ||
data[1] != 2) {
VNC_DEBUG("Unsupported VeNCrypt protocol %d.%d\n", (int)data[0], (int)data[1]);
vnc_write_u8(vs, 1); /* Reject version */
vnc_flush(vs);
vnc_client_e... | true | qemu | 7364dbdabb7824d5bde1e341bb6d928282f01c83 |
3,379 | static always_inline int _pte_check (mmu_ctx_t *ctx, int is_64b,
target_ulong pte0, target_ulong pte1,
int h, int rw, int type)
{
target_ulong ptem, mmask;
int access, ret, pteh, ptev, pp;
access = 0;
ret = -1;
/* Ch... | true | qemu | 6f2d8978728c48ca46f5c01835438508aace5c64 |
3,380 | static int h264_slice_header_parse(const H264Context *h, H264SliceContext *sl,
const H2645NAL *nal)
{
const SPS *sps;
const PPS *pps;
int ret;
unsigned int slice_type, tmp, i;
int field_pic_flag, bottom_field_flag;
int droppable, picture_structure;
... | false | FFmpeg | 5c2fb561d94fc51d76ab21d6f7cc5b6cc3aa599c |
3,381 | static int nut_read_header(AVFormatContext * avf, AVFormatParameters * ap) {
NUTContext * priv = avf->priv_data;
ByteIOContext * bc = &avf->pb;
nut_demuxer_opts_t dopts = {
.input = {
.priv = bc,
.seek = av_seek,
.read = av_read,
.eof = NULL,
... | false | FFmpeg | e4bb70838f0c3092a9b893f2210e7c303f0f2a4a |
3,382 | static int read_huffman_tables(HYuvContext *s, const uint8_t *src, int length)
{
GetBitContext gb;
int i;
init_get_bits(&gb, src, length * 8);
for (i = 0; i < 3; i++) {
if (read_len_table(s->len[i], &gb) < 0)
return -1;
if (ff_huffyuv_generate_bits_table(s->bits[i... | false | FFmpeg | f67a0d115254461649470452058fa3c28c0df294 |
3,384 | static int h264_slice_header_init(H264Context *h, int reinit)
{
int nb_slices = (HAVE_THREADS &&
h->avctx->active_thread_type & FF_THREAD_SLICE) ?
h->avctx->thread_count : 1;
int i, ret;
h->avctx->sample_aspect_ratio = h->sps.sar;
av_assert0(h->avctx->sa... | false | FFmpeg | 9e500efdbe0deeff1602500ebc229a0a6b6bb1a2 |
3,385 | static unsigned tget_long(GetByteContext *gb, int le)
{
unsigned v = le ? bytestream2_get_le32u(gb) : bytestream2_get_be32u(gb);
return v;
}
| false | FFmpeg | ce1ebb31a9a0e556a89cd7681082af19fbc1cced |
3,386 | static int ir2_decode_plane(Ir2Context *ctx, int width, int height, uint8_t *dst,
int pitch, const uint8_t *table)
{
int i;
int j;
int out = 0;
if (width & 1)
return AVERROR_INVALIDDATA;
/* first line contain absolute values, other lines contain deltas... | true | FFmpeg | 159fb8ff7e4038edf13e91d3c08bc7b8abc369b9 |
3,387 | void hmp_change(Monitor *mon, const QDict *qdict)
{
const char *device = qdict_get_str(qdict, "device");
const char *target = qdict_get_str(qdict, "target");
const char *arg = qdict_get_try_str(qdict, "arg");
const char *read_only = qdict_get_try_str(qdict, "read-only-mode");
BlockdevChangeRea... | true | qemu | 788cf9f8c8cbda53843e060540f3e91a060eb744 |
3,388 | 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... | true | qemu | afff2b15e89ac81c113f2ebfd729aaa02b40edb6 |
3,389 | static int codec_reinit(AVCodecContext *avctx, int width, int height, int quality) {
NuvContext *c = avctx->priv_data;
width = (width + 1) & ~1;
height = (height + 1) & ~1;
if (quality >= 0)
get_quant_quality(c, quality);
if (width != c->width || height != c->height) {
if (av_... | true | FFmpeg | e7b95918fca1c3d057d35f77ba58ee2d00d03151 |
3,390 | int av_open_input_stream(AVFormatContext **ic_ptr,
ByteIOContext *pb, const char *filename,
AVInputFormat *fmt, AVFormatParameters *ap)
{
int err;
AVFormatContext *ic;
AVFormatParameters default_ap;
if(!ap){
ap=&default_ap;
mem... | true | FFmpeg | ec973f45a3afd82fd53313b0b570645c03b2b178 |
3,391 | static void network_to_control(RDMAControlHeader *control)
{
control->type = ntohl(control->type);
control->len = ntohl(control->len);
control->repeat = ntohl(control->repeat);
}
| true | qemu | 60fe637bf0e4d7989e21e50f52526444765c63b4 |
3,393 | void ff_get_wav_header(AVIOContext *pb, AVCodecContext *codec, int size)
{
int id;
id = avio_rl16(pb);
codec->codec_type = AVMEDIA_TYPE_AUDIO;
codec->codec_tag = id;
codec->channels = avio_rl16(pb);
codec->sample_rate = avio_rl32(pb);
codec->bit_rate = avio_rl32(pb) * 8;
codec... | true | FFmpeg | ca402f32e392590a81a1381dab41c4f9c2c2f98a |
3,395 | static int read_restart_header(MLPDecodeContext *m, GetBitContext *gbp,
const uint8_t *buf, unsigned int substr)
{
SubStream *s = &m->substream[substr];
unsigned int ch;
int sync_word, tmp;
uint8_t checksum;
uint8_t lossless_check;
int start_count = get_bit... | false | FFmpeg | a9cd12ee2afb3f3aad783c396816b23d8513f472 |
3,396 | static void init_blk_migration(Monitor *mon, QEMUFile *f)
{
BlkMigDevState *bmds;
BlockDriverState *bs;
block_mig_state.submitted = 0;
block_mig_state.read_done = 0;
block_mig_state.transferred = 0;
block_mig_state.total_sector_sum = 0;
block_mig_state.prev_progress = -1;
fo... | true | qemu | 792773b2255d25c6f5fe9dfa0ae200debab92de4 |
3,400 | static void vmgenid_device_class_init(ObjectClass *klass, void *data)
{
DeviceClass *dc = DEVICE_CLASS(klass);
dc->vmsd = &vmstate_vmgenid;
dc->realize = vmgenid_realize;
dc->hotpluggable = false;
dc->props = vmgenid_properties;
set_bit(DEVICE_CATEGORY_MISC, dc->categories);
obje... | true | qemu | c8389550dedc65892fba9c3df29423efd802f544 |
3,402 | static void run_block_job(BlockJob *job, Error **errp)
{
AioContext *aio_context = blk_get_aio_context(job->blk);
/* FIXME In error cases, the job simply goes away and we access a dangling
* pointer below. */
aio_context_acquire(aio_context);
do {
aio_poll(aio_context, true);
... | true | qemu | 4172a00373b2c81374293becc02b16b7f8c76659 |
3,403 | static int dxtory_decode_v1_420(AVCodecContext *avctx, AVFrame *pic,
const uint8_t *src, int src_size)
{
int h, w;
uint8_t *Y1, *Y2, *U, *V;
int ret;
if (src_size < avctx->width * avctx->height * 3 / 2) {
av_log(avctx, AV_LOG_ERROR, "packet too small\n");... | true | FFmpeg | a392bf657015c9a79a5a13adfbfb15086c1943b9 |
3,404 | int attribute_align_arg avcodec_encode_video2(AVCodecContext *avctx,
AVPacket *avpkt,
const AVFrame *frame,
int *got_packet_ptr)
{
int ret;
AVPacket user_pkt = *avpkt;
in... | true | FFmpeg | 3393cd85459cb9c23dec90373da91559987000ee |
3,405 | static int dxva2_hevc_start_frame(AVCodecContext *avctx,
av_unused const uint8_t *buffer,
av_unused uint32_t size)
{
const HEVCContext *h = avctx->priv_data;
AVDXVAContext *ctx = avctx->hwaccel_context;
struct hevc_dxva2_picture_conte... | false | FFmpeg | ab28108a361196134704071b7b34c42fc7d747c7 |
3,406 | static uint8_t *ogg_write_vorbiscomment(int offset, int bitexact,
int *header_len, AVDictionary **m, int framing_bit)
{
const char *vendor = bitexact ? "ffmpeg" : LIBAVFORMAT_IDENT;
int size;
uint8_t *p, *p0;
ff_metadata_conv(m, ff_vorbiscomment_metadata_c... | false | FFmpeg | 0db5b2b9f8a96298eeba7988d43c4eb44220fab3 |
3,407 | static void envelope_peak16(WaveformContext *s, AVFrame *out, int plane, int component)
{
const int dst_linesize = out->linesize[component] / 2;
const int bg = s->bg_color[component] * (s->size / 256);
const int limit = s->size - 1;
const int is_chroma = (component == 1 || component == 2);
con... | false | FFmpeg | db592f3b03a21d5bd5237021c00af3ce0431fc60 |
3,408 | int sws_setColorspaceDetails(SwsContext *c, const int inv_table[4], int srcRange, const int table[4], int dstRange, int brightness, int contrast, int saturation)
{
int64_t crv = inv_table[0];
int64_t cbu = inv_table[1];
int64_t cgu = -inv_table[2];
int64_t cgv = -inv_table[3];
int64_t cy = ... | false | FFmpeg | f684f3c58a77a20f18b80f888d69c2bacb53ca9b |
3,409 | static int decode_mb_info(IVI5DecContext *ctx, IVIBandDesc *band,
IVITile *tile, AVCodecContext *avctx)
{
int x, y, mv_x, mv_y, mv_delta, offs, mb_offset,
mv_scale, blks_per_mb;
IVIMbInfo *mb, *ref_mb;
int row_offset = band->mb_size * band->p... | false | FFmpeg | c855ece101cd960ddd20eabd5f295e0b02b71dcc |
3,410 | void ff_imdct_calc(MDCTContext *s, FFTSample *output,
const FFTSample *input, FFTSample *tmp)
{
int k, n8, n4, n2, n, j;
const uint16_t *revtab = s->fft.revtab;
const FFTSample *tcos = s->tcos;
const FFTSample *tsin = s->tsin;
const FFTSample *in1, *in2;
FFTComplex *z ... | true | FFmpeg | b9fa32082c71013e90eab9e9997967d2939cf4a6 |
3,411 | ISADevice *isa_create(const char *name)
{
DeviceState *dev;
if (!isabus) {
fprintf(stderr, "Tried to create isa device %s with no isa bus present.\n", name);
return NULL;
}
dev = qdev_create(&isabus->qbus, name);
return DO_UPCAST(ISADevice, qdev, dev);
}
| true | qemu | 3f66aa9c07d6392757f9d7b83849c7f791981725 |
3,412 | static int applehttp_read_seek(AVFormatContext *s, int stream_index,
int64_t timestamp, int flags)
{
AppleHTTPContext *c = s->priv_data;
int i, j, ret;
if ((flags & AVSEEK_FLAG_BYTE) || !c->variants[0]->finished)
return AVERROR(ENOSYS);
timestamp = av_re... | true | FFmpeg | 6f20921deec135a68f78cb327472ea6cf28644a5 |
3,413 | int coroutine_fn qemu_co_recvv(int sockfd, struct iovec *iov,
int len, int iov_offset)
{
int total = 0;
int ret;
while (len) {
ret = qemu_recvv(sockfd, iov, len, iov_offset + total);
if (ret < 0) {
if (errno == EAGAIN) {
qem... | true | qemu | 3e80bf9351f8fec9085c46df6da075efd5e71003 |
3,414 | static void vc1_decode_p_blocks(VC1Context *v)
{
MpegEncContext *s = &v->s;
int apply_loop_filter;
/* select codingmode used for VLC tables selection */
switch (v->c_ac_table_index) {
case 0:
v->codingset = (v->pqindex <= 8) ? CS_HIGH_RATE_INTRA : CS_LOW_MOT_INTRA;
break;
... | true | FFmpeg | 22ce78a95efb5d67dcd925285ad8c836b67d2c19 |
3,415 | static int get_metadata(AVFormatContext *s,
const char *const tag,
const unsigned data_size)
{
uint8_t *buf = ((data_size + 1) == 0) ? NULL : av_malloc(data_size + 1);
if (!buf)
return AVERROR(ENOMEM);
if (avio_read(s->pb, buf, data_size) < ... | true | FFmpeg | 8e90c7285d1cbf62a9c9a5f9e6efda998dc0d454 |
3,417 | static int set_sps(HEVCContext *s, const HEVCSPS *sps)
{
int ret;
int num = 0, den = 0;
pic_arrays_free(s);
ret = pic_arrays_init(s, sps);
if (ret < 0)
goto fail;
s->avctx->coded_width = sps->width;
s->avctx->coded_height = sps->height;
s->avctx->widt... | false | FFmpeg | ed06e5d92b4c67b49068d538461fbbe0a53a8c5e |
3,418 | yuv2mono_2_c_template(SwsContext *c, const int16_t *buf[2],
const int16_t *ubuf[2], const int16_t *vbuf[2],
const int16_t *abuf[2], uint8_t *dest, int dstW,
int yalpha, int uvalpha, int y,
enum AVPixelFormat target)
{
cons... | false | FFmpeg | 1e0e193240a8e47a980ac76b8b5af831b17b7928 |
3,419 | static double eval_expr(Parser * p, AVEvalExpr * e) {
switch (e->type) {
case e_value: return e->value;
case e_const: return e->value * p->const_value[e->a.const_index];
case e_func0: return e->value * e->a.func0(eval_expr(p, e->param[0]));
case e_func1: return e->value * e-... | false | FFmpeg | 63a547eabc3ec874ca0f732d141eb2b2e95224a8 |
3,420 | static int build_filter(ResampleContext *c, void *filter, double factor, int tap_count, int alloc, int phase_count, int scale,
int filter_type, int kaiser_beta){
int ph, i;
double x, y, w;
double *tab = av_malloc_array(tap_count, sizeof(*tab));
const int center= (tap_count-... | true | FFmpeg | 9bec6d71a22ab42908f900f3b3289fa1edfcea6e |
3,421 | void avcodec_get_context_defaults2(AVCodecContext *s, enum CodecType codec_type){
int flags=0;
memset(s, 0, sizeof(AVCodecContext));
s->av_class= &av_codec_context_class;
s->codec_type = codec_type;
if(codec_type == CODEC_TYPE_AUDIO)
flags= AV_OPT_FLAG_AUDIO_PARAM;
else if(cod... | true | FFmpeg | 3cffbe090a5168dcfe580de8d662a32e7ad1d911 |
3,422 | static void dec_float(DisasContext *dc, uint32_t insn)
{
uint32_t op0;
uint32_t ra, rb, rd;
op0 = extract32(insn, 0, 8);
ra = extract32(insn, 16, 5);
rb = extract32(insn, 11, 5);
rd = extract32(insn, 21, 5);
switch (op0) {
case 0x00: /* lf.add.s */
LOG_DIS("lf.add.... | true | qemu | 6597c28d618a3d16d468770b7c30a0237a8c8ea9 |
3,423 | void rng_backend_open(RngBackend *s, Error **errp)
{
object_property_set_bool(OBJECT(s), true, "opened", errp);
}
| true | qemu | 57d3e1b3f52d07d215ed96df946ee01f8d9f9526 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.