project stringclasses 2
values | commit_id stringlengths 40 40 | target int64 0 1 | func stringlengths 26 142k | idx int64 0 27.3k |
|---|---|---|---|---|
FFmpeg | 13a099799e89a76eb921ca452e1b04a7a28a9855 | 0 | yuv2mono_2_c_template(SwsContext *c, const uint16_t *buf0,
const uint16_t *buf1, const uint16_t *ubuf0,
const uint16_t *ubuf1, const uint16_t *vbuf0,
const uint16_t *vbuf1, const uint16_t *abuf0,
const uint16_t *abuf1, uint8_t *... | 12,475 |
qemu | f9dc175d84802e9a00161bc8d4356b90d6c52125 | 0 | static void acpi_set_cpu_present_bit(AcpiCpuHotplug *g, CPUState *cpu,
Error **errp)
{
CPUClass *k = CPU_GET_CLASS(cpu);
int64_t cpu_id;
cpu_id = k->get_arch_id(cpu);
if ((cpu_id / 8) >= ACPI_GPE_PROC_LEN) {
error_setg(errp, "acpi: invalid cpu id: %"... | 12,476 |
qemu | 81bdde9dcdba5bbc358b2c6b8f776a05a751cc72 | 0 | uint32_t HELPER(get_cp15)(CPUARMState *env, uint32_t insn)
{
int op1;
int op2;
int crm;
op1 = (insn >> 21) & 7;
op2 = (insn >> 5) & 7;
crm = insn & 0xf;
switch ((insn >> 16) & 0xf) {
case 0: /* ID codes. */
switch (op1) {
case 0:
switch (crm) {
... | 12,478 |
qemu | b2bedb214469af55179d907a60cd67fed6b0779e | 0 | static void hpet_ram_writel(void *opaque, target_phys_addr_t addr,
uint32_t value)
{
int i;
HPETState *s = opaque;
uint64_t old_val, new_val, val, index;
DPRINTF("qemu: Enter hpet_ram_writel at %" PRIx64 " = %#x\n", addr, value);
index = addr;
old_val = hpet... | 12,479 |
qemu | b92ad3949bc9cacd1652b4e07e7f6003b9e512af | 0 | static void create_pcie(const VirtBoardInfo *vbi, qemu_irq *pic,
bool use_highmem)
{
hwaddr base_mmio = vbi->memmap[VIRT_PCIE_MMIO].base;
hwaddr size_mmio = vbi->memmap[VIRT_PCIE_MMIO].size;
hwaddr base_mmio_high = vbi->memmap[VIRT_PCIE_MMIO_HIGH].base;
hwaddr size_mmio_hig... | 12,480 |
qemu | b854bc196f5c4b4e3299c0b0ee63cf828ece9e77 | 0 | int omap_validate_emifs_addr(struct omap_mpu_state_s *s,
target_phys_addr_t addr)
{
return addr >= OMAP_EMIFS_BASE && addr < OMAP_EMIFF_BASE;
}
| 12,481 |
qemu | 91cda45b69e45a089f9989979a65db3f710c9925 | 0 | static int ppc_hash64_get_physical_address(CPUPPCState *env,
struct mmu_ctx_hash64 *ctx,
target_ulong eaddr, int rw,
int access_type)
{
bool real_mode = (access_type == ACCESS_CODE &... | 12,482 |
qemu | cea5f9a28faa528b6b1b117c9ab2d8828f473fef | 0 | void cpu_resume_from_signal(CPUState *env1, void *puc)
{
env = env1;
/* XXX: restore cpu registers saved in host registers */
env->exception_index = -1;
longjmp(env->jmp_env, 1);
}
| 12,483 |
qemu | 57407ea44cc0a3d630b9b89a2be011f1955ce5c1 | 0 | static void minimac2_cleanup(NetClientState *nc)
{
MilkymistMinimac2State *s = qemu_get_nic_opaque(nc);
s->nic = NULL;
}
| 12,484 |
FFmpeg | 76d4c62734fbb8a9f497712812f30ff5c27e787f | 0 | static int webp_decode_frame(AVCodecContext *avctx, void *data, int *got_frame,
AVPacket *avpkt)
{
AVFrame * const p = data;
WebPContext *s = avctx->priv_data;
GetByteContext gb;
int ret;
uint32_t chunk_type, chunk_size;
int vp8x_flags = 0;
s->avctx ... | 12,486 |
qemu | b9bec74bcb16519a876ec21cd5277c526a9b512d | 0 | static int find_hw_breakpoint(target_ulong addr, int len, int type)
{
int n;
for (n = 0; n < nb_hw_breakpoint; n++)
if (hw_breakpoint[n].addr == addr && hw_breakpoint[n].type == type &&
(hw_breakpoint[n].len == len || len == -1))
return n;
return -1;
}
| 12,487 |
qemu | a9fc37f6bc3f2ab90585cb16493da9f6dcfbfbcf | 1 | static void qobject_input_start_struct(Visitor *v, const char *name, void **obj,
size_t size, Error **errp)
{
QObjectInputVisitor *qiv = to_qiv(v);
QObject *qobj = qobject_input_get_object(qiv, name, true, errp);
if (obj) {
*obj = NULL;
}
if (... | 12,488 |
FFmpeg | 2b215b7f5af0ef9be79c697d8990e6958a134f98 | 1 | static int decode_nal_units(HEVCContext *s, const uint8_t *buf, int length)
{
int i, consumed, ret = 0;
s->ref = NULL;
s->last_eos = s->eos;
s->eos = 0;
/* split the input packet into NAL units, so we know the upper bound on the
* number of slices in the frame */
s->nb_nals = 0;... | 12,489 |
qemu | e638073c569e801ce9def2016a84f955cbbca779 | 1 | static uint64_t vfio_rom_read(void *opaque, hwaddr addr, unsigned size)
{
VFIODevice *vdev = opaque;
uint64_t val = ((uint64_t)1 << (size * 8)) - 1;
/* Load the ROM lazily when the guest tries to read it */
if (unlikely(!vdev->rom)) {
memcpy(&val, vdev->rom + addr,
(addr <... | 12,490 |
qemu | 8991c460be5a0811194fd4d2b49ba7146a23526b | 1 | static void vtd_handle_gcmd_qie(IntelIOMMUState *s, bool en)
{
uint64_t iqa_val = vtd_get_quad_raw(s, DMAR_IQA_REG);
trace_vtd_inv_qi_enable(en);
if (en) {
if (vtd_queued_inv_enable_check(s)) {
s->iq = iqa_val & VTD_IQA_IQA_MASK;
/* 2^(x+8) entries */
... | 12,491 |
FFmpeg | 64278039e55ffc88d231a8d760ecc257a120760a | 1 | static int get_qPy_pred(HEVCContext *s, int xC, int yC,
int xBase, int yBase, int log2_cb_size)
{
HEVCLocalContext *lc = s->HEVClc;
int ctb_size_mask = (1 << s->sps->log2_ctb_size) - 1;
int MinCuQpDeltaSizeMask = (1 << (s->sps->log2_ctb_size -
... | 12,492 |
qemu | 6cec5487990bf3f1f22b3fcb871978255e92ae0d | 1 | static void framebuffer_update_request(VncState *vs, int incremental,
int x_position, int y_position,
int w, int h)
{
if (x_position > ds_get_width(vs->ds))
x_position = ds_get_width(vs->ds);
if (y_position > ds_get_height(vs->ds))
y_position = ds_get_height(vs->ds);... | 12,494 |
qemu | 6baebed7698a37a0ac5168faf26023426b0ac940 | 1 | static void vnc_connect(VncDisplay *vd, int csock)
{
VncState *vs = qemu_mallocz(sizeof(VncState));
vs->csock = csock;
VNC_DEBUG("New client on socket %d\n", csock);
dcl->idle = 0;
socket_set_nonblock(vs->csock);
qemu_set_fd_handler2(vs->csock, NULL, vnc_client_read, NULL, vs);
v... | 12,495 |
qemu | 3efa9a672e4a5f7b2d35cf457ea277e997a0f8c6 | 1 | static uint32_t get_elf_hwcap(void)
{
CPUState *e = thread_env;
uint32_t features = 0;
/* We don't have to be terribly complete here; the high points are
Altivec/FP/SPE support. Anything else is just a bonus. */
#define GET_FEATURE(flag, feature) \
do {if (e->insns_flags &... | 12,496 |
FFmpeg | 7f526efd17973ec6d2204f7a47b6923e2be31363 | 1 | static inline void RENAME(rgb24tobgr24)(const uint8_t *src, uint8_t *dst, unsigned int src_size)
{
unsigned i;
#ifdef HAVE_MMX
long mmx_size= 23 - src_size;
asm volatile (
"movq "MANGLE(mask24r)", %%mm5 \n\t"
"movq "MANGLE(mask24g)", %%mm6 \n\t"
"movq "MANGLE(mask24b)", %%mm7 \n\t"
".balign 16 \n\... | 12,497 |
FFmpeg | ecb918e5f0a4395468862b5fbd11a51de9be3d4f | 1 | static void ff_amf_tag_contents(void *ctx, const uint8_t *data, const uint8_t *data_end)
{
int size;
char buf[1024];
if (data >= data_end)
return;
switch (*data++) {
case AMF_DATA_TYPE_NUMBER:
av_log(ctx, AV_LOG_DEBUG, " number %g\n", av_int2double(AV_RB64(data)));
... | 12,498 |
FFmpeg | a5cbf1991c3d04b0be3c23ee0a7096b5a365cc85 | 1 | static int mov_read_extradata(MOVContext *c, AVIOContext *pb, MOVAtom atom,
enum AVCodecID codec_id)
{
AVStream *st;
uint64_t size;
uint8_t *buf;
int err;
if (c->fc->nb_streams < 1) // will happen with jp2 files
return 0;
st= c->fc->streams[c->fc-... | 12,500 |
FFmpeg | e93d911e483ffcf3da3dd2cbac2895fa061d2f58 | 1 | int ff_h263_decode_picture_header(MpegEncContext *s)
{
int format, width, height, i;
uint32_t startcode;
align_get_bits(&s->gb);
startcode= get_bits(&s->gb, 22-8);
for(i= get_bits_left(&s->gb); i>24; i-=8) {
startcode = ((startcode << 8) | get_bits(&s->gb, 8)) & 0x003FFFFF;
... | 12,501 |
qemu | 5e5557d97026d1d3325e0e7b0ba593366da2f3dc | 1 | static uint64_t get_cluster_offset(BlockDriverState *bs,
uint64_t offset, int allocate,
int compressed_size,
int n_start, int n_end)
{
BDRVQcowState *s = bs->opaque;
int min_index, i, j, l1_index, l2_i... | 12,502 |
qemu | 44b6789299a8acca3f25331bc411055cafc7bb06 | 1 | static BlockAIOCB *blkverify_aio_flush(BlockDriverState *bs,
BlockCompletionFunc *cb,
void *opaque)
{
BDRVBlkverifyState *s = bs->opaque;
/* Only flush test file, the raw file is not important */
return bdrv_aio_flush(s->t... | 12,503 |
qemu | a89d89d3e65800fa4a8e00de7af0ea8272bef779 | 1 | static int del_existing_snapshots(Monitor *mon, const char *name)
{
BlockDriverState *bs;
QEMUSnapshotInfo sn1, *snapshot = &sn1;
int ret;
bs = NULL;
while ((bs = bdrv_next(bs))) {
if (bdrv_can_snapshot(bs) &&
bdrv_snapshot_find(bs, snapshot, name) >= 0)
{
... | 12,504 |
FFmpeg | 2c6cf1394096d08396faadc6e7c0b404fd6df006 | 1 | static void wavpack_decode_flush(AVCodecContext *avctx)
{
WavpackContext *s = avctx->priv_data;
int i;
for (i = 0; i < s->fdec_num; i++)
wv_reset_saved_context(s->fdec[i]);
}
| 12,505 |
FFmpeg | aa13b0fc55f5aec58fce24d1a047271b3e5727f1 | 1 | inline static void RENAME(hcscale)(SwsContext *c, uint16_t *dst, long dstWidth, uint8_t *src1, uint8_t *src2,
int srcW, int xInc, int flags, int canMMX2BeUsed, int16_t *hChrFilter,
int16_t *hChrFilterPos, int hChrFilterSize, void *funnyUVCode,
... | 12,506 |
qemu | 24530f3e060c71b6c57c7a70336f08a13a8b0a3d | 1 | static int qcow2_check(BlockDriverState *bs, BdrvCheckResult *result,
BdrvCheckMode fix)
{
int ret = qcow2_check_refcounts(bs, result, fix);
if (ret < 0) {
return ret;
}
if (fix && result->check_errors == 0 && result->corruptions == 0) {
return qcow2_mark... | 12,507 |
qemu | 0c53d7342b4e8412f3b81eed67f053304813dc5d | 1 | static inline void gen_sync_flags(DisasContext *dc)
{
/* Sync the tb dependent flag between translate and runtime. */
if (dc->tb_flags != dc->synced_flags) {
tcg_gen_movi_tl(env_flags, dc->tb_flags);
dc->synced_flags = dc->tb_flags;
}
}
| 12,508 |
FFmpeg | d1cf45911935cc4fed9afd3a37d99616d31eb9da | 1 | void avcodec_flush_buffers(AVCodecContext *avctx)
{
if(HAVE_PTHREADS && avctx->active_thread_type&FF_THREAD_FRAME)
ff_thread_flush(avctx);
if(avctx->codec->flush)
avctx->codec->flush(avctx);
}
| 12,509 |
FFmpeg | 80ca19f766aea8f4724aac1b3faa772d25163c8a | 0 | static int ipvideo_decode_block_opcode_0x5(IpvideoContext *s)
{
signed char x, y;
/* copy a block from the previous frame using an expanded range;
* need 2 more bytes */
CHECK_STREAM_PTR(2);
x = *s->stream_ptr++;
y = *s->stream_ptr++;
debug_interplay (" motion bytes = %d, %... | 12,510 |
qemu | b946a1533209f61a93e34898aebb5b43154b99c3 | 1 | void smc91c111_init(NICInfo *nd, uint32_t base, qemu_irq irq)
{
smc91c111_state *s;
int iomemtype;
qemu_check_nic_model(nd, "smc91c111");
s = (smc91c111_state *)qemu_mallocz(sizeof(smc91c111_state));
iomemtype = cpu_register_io_memory(0, smc91c111_readfn,
... | 12,511 |
FFmpeg | dc0481f2fbae4d5942ccabf2061900da3ee85f30 | 0 | static av_cold int vc2_encode_frame(AVCodecContext *avctx, AVPacket *avpkt,
const AVFrame *frame, int *got_packet_ptr)
{
int ret;
int max_frame_bytes, sig_size = 256;
VC2EncContext *s = avctx->priv_data;
const char aux_data[] = "FFmpeg version "FFMPEG_VERSION;... | 12,512 |
FFmpeg | aa241229891173b0357eee04e6ca78f806cc9c0c | 0 | static int estimate_best_b_count(MpegEncContext *s)
{
AVCodec *codec = avcodec_find_encoder(s->avctx->codec_id);
AVCodecContext *c = avcodec_alloc_context3(NULL);
AVFrame input[FF_MAX_B_FRAMES + 2];
const int scale = s->avctx->brd_scale;
int i, j, out_size, p_lambda, b_lambda, lambda2;
... | 12,513 |
FFmpeg | 0491a2a07a44f6e5e6f34081835e402c07025fd2 | 0 | static void show_stream(WriterContext *w, AVFormatContext *fmt_ctx, int stream_idx)
{
AVStream *stream = fmt_ctx->streams[stream_idx];
AVCodecContext *dec_ctx;
AVCodec *dec;
char val_str[128];
AVRational display_aspect_ratio;
struct print_buf pbuf = {.s = NULL};
print_section_heade... | 12,514 |
qemu | f3c75d42adbba553eaf218a832d4fbea32c8f7b8 | 1 | static void spapr_cpu_reset(void *opaque)
{
PowerPCCPU *cpu = opaque;
CPUState *cs = CPU(cpu);
CPUPPCState *env = &cpu->env;
cpu_reset(cs);
/* All CPUs start halted. CPU0 is unhalted from the machine level
* reset code and the rest are explicitly started up by the guest
* usin... | 12,515 |
qemu | 522fccbe71e35efc96f66cb475f778c2ce02e9fc | 1 | static void exynos4210_fimd_update(void *opaque)
{
Exynos4210fimdState *s = (Exynos4210fimdState *)opaque;
DisplaySurface *surface = qemu_console_surface(s->console);
Exynos4210fimdWindow *w;
int i, line;
hwaddr fb_line_addr, inc_size;
int scrn_height;
int first_line = -1, last_line ... | 12,516 |
qemu | c5a49c63fa26e8825ad101dfe86339ae4c216539 | 1 | static void gen_waiti(DisasContext *dc, uint32_t imm4)
{
TCGv_i32 pc = tcg_const_i32(dc->next_pc);
TCGv_i32 intlevel = tcg_const_i32(imm4);
if (dc->tb->cflags & CF_USE_ICOUNT) {
gen_io_start();
}
gen_helper_waiti(cpu_env, pc, intlevel);
if (dc->tb->cflags & CF_USE_ICOUNT) {
... | 12,517 |
qemu | c5a49c63fa26e8825ad101dfe86339ae4c216539 | 1 | static void spr_read_hdecr(DisasContext *ctx, int gprn, int sprn)
{
if (ctx->tb->cflags & CF_USE_ICOUNT) {
gen_io_start();
}
gen_helper_load_hdecr(cpu_gpr[gprn], cpu_env);
if (ctx->tb->cflags & CF_USE_ICOUNT) {
gen_io_end();
gen_stop_exception(ctx);
}
}
| 12,519 |
qemu | 67d6abff605064317d1922745b2e99ffc57b4a77 | 1 | static int get_physical_address (CPUState *env, target_ulong *physical,
int *prot, target_ulong address,
int rw, int access_type)
{
/* User mode can only access useg/xuseg */
int user_mode = (env->hflags & MIPS_HFLAG_MODE) == MIPS_HFLAG_UM;
... | 12,521 |
FFmpeg | 7f526efd17973ec6d2204f7a47b6923e2be31363 | 1 | void palette8tobgr32(const uint8_t *src, uint8_t *dst, unsigned num_pixels, const uint8_t *palette)
{
unsigned i;
for(i=0; i<num_pixels; i++)
{
#ifdef WORDS_BIGENDIAN
dst[3]= palette[ src[i]*4+0 ];
dst[2]= palette[ src[i]*4+1 ];
dst[1]= palette[ src[i]*4+2 ];
#else
//FIXME slow?
dst[0]= pale... | 12,523 |
FFmpeg | b593f7fdef3448ea0fadfccc0bd7e4fde3df84aa | 1 | int av_seek_frame_binary(AVFormatContext *s, int stream_index, int64_t target_ts, int flags){
AVInputFormat *avif= s->iformat;
int64_t av_uninit(pos_min), av_uninit(pos_max), pos, pos_limit;
int64_t ts_min, ts_max, ts;
int index;
AVStream *st;
if (stream_index < 0)
return -1;
... | 12,524 |
qemu | ee8e76141b4dd00f8e97fda274876a17f9a46bbe | 1 | static abi_long do_ipc(unsigned int call, abi_long first,
abi_long second, abi_long third,
abi_long ptr, abi_long fifth)
{
int version;
abi_long ret = 0;
version = call >> 16;
call &= 0xffff;
switch (call) {
case IPCOP_semop:
re... | 12,525 |
qemu | f61eddcb2bb5cbbdd1d911b7e937db9affc29028 | 0 | static int virtcon_parse(const char *devname)
{
QemuOptsList *device = qemu_find_opts("device");
static int index = 0;
char label[32];
QemuOpts *bus_opts, *dev_opts;
if (strcmp(devname, "none") == 0)
return 0;
if (index == MAX_VIRTIO_CONSOLES) {
fprintf(stderr, "qemu: ... | 12,526 |
qemu | 4a1418e07bdcfaa3177739e04707ecaec75d89e1 | 0 | void helper_lcall_protected(int new_cs, target_ulong new_eip,
int shift, int next_eip_addend)
{
int new_stack, i;
uint32_t e1, e2, cpl, dpl, rpl, selector, offset, param_count;
uint32_t ss = 0, ss_e1 = 0, ss_e2 = 0, sp, type, ss_dpl, sp_mask;
uint32_t val, limit, old_s... | 12,527 |
qemu | 2e6fc7eb1a4af1b127df5f07b8bb28af891946fa | 0 | static void raw_reopen_abort(BDRVReopenState *state)
{
g_free(state->opaque);
state->opaque = NULL;
}
| 12,528 |
qemu | 85b3ed1db5e50b66016ef59ca2afce10e753cbc6 | 0 | void err (const char *s)
{
perror (s);
abort ();
}
| 12,529 |
qemu | a89f364ae8740dfc31b321eed9ee454e996dc3c1 | 0 | static void hda_audio_command(HDACodecDevice *hda, uint32_t nid, uint32_t data)
{
HDAAudioState *a = HDA_AUDIO(hda);
HDAAudioStream *st;
const desc_node *node = NULL;
const desc_param *param;
uint32_t verb, payload, response, count, shift;
if ((data & 0x70000) == 0x70000) {
/* ... | 12,530 |
FFmpeg | c89658008705d949c319df3fa6f400c481ad73e1 | 0 | static void sdp_parse_fmtp_config(AVCodecContext * codec, void *ctx,
char *attr, char *value)
{
switch (codec->codec_id) {
case CODEC_ID_MPEG4:
case CODEC_ID_AAC:
if (!strcmp(attr, "config")) {
/* decode the hexa encoded parameter ... | 12,531 |
qemu | 90f998f5f4267a0c22e983f533d19b9de1849283 | 0 | static void mux_print_help(CharDriverState *chr)
{
int i, j;
char ebuf[15] = "Escape-Char";
char cbuf[50] = "\n\r";
if (term_escape_char > 0 && term_escape_char < 26) {
snprintf(cbuf, sizeof(cbuf), "\n\r");
snprintf(ebuf, sizeof(ebuf), "C-%c", term_escape_char - 1 + 'a');
}... | 12,532 |
qemu | 72cf2d4f0e181d0d3a3122e04129c58a95da713e | 0 | void net_slirp_hostfwd_remove(Monitor *mon, const QDict *qdict)
{
struct in_addr host_addr = { .s_addr = INADDR_ANY };
int host_port;
char buf[256] = "";
const char *src_str, *p;
SlirpState *s;
int is_udp = 0;
int err;
const char *arg1 = qdict_get_str(qdict, "arg1");
const ... | 12,533 |
qemu | c54616608af442edf4cfb7397a1909c2653efba0 | 0 | static QObject *parse_object(JSONParserContext *ctxt, va_list *ap)
{
QDict *dict = NULL;
QObject *token, *peek;
JSONParserContext saved_ctxt = parser_context_save(ctxt);
token = parser_context_pop_token(ctxt);
if (token == NULL) {
goto out;
}
if (!token_is_operator(token... | 12,534 |
qemu | 32bafa8fdd098d52fbf1102d5a5e48d29398c0aa | 0 | static void qemu_chr_parse_mux(QemuOpts *opts, ChardevBackend *backend,
Error **errp)
{
const char *chardev = qemu_opt_get(opts, "chardev");
ChardevMux *mux;
if (chardev == NULL) {
error_setg(errp, "chardev: mux: no chardev given");
return;
}
... | 12,535 |
qemu | 51b19ebe4320f3dcd93cea71235c1219318ddfd2 | 0 | static void do_flush_queued_data(VirtIOSerialPort *port, VirtQueue *vq,
VirtIODevice *vdev)
{
VirtIOSerialPortClass *vsc;
assert(port);
assert(virtio_queue_ready(vq));
vsc = VIRTIO_SERIAL_PORT_GET_CLASS(port);
while (!port->throttled) {
unsigned... | 12,536 |
qemu | bf937a7965c1d1a6dce4f615d0ead2e2ab505004 | 0 | static void l2cap_command(struct l2cap_instance_s *l2cap, int code, int id,
const uint8_t *params, int len)
{
int err;
#if 0
/* TODO: do the IDs really have to be in sequence? */
if (!id || (id != l2cap->last_id && id != l2cap->next_id)) {
fprintf(stderr, "%s: out of sequen... | 12,537 |
qemu | 0d1460226fb05c92fa3ad869ca39090ff13cf6bc | 0 | static int curl_aio_flush(void *opaque)
{
BDRVCURLState *s = opaque;
int i, j;
for (i=0; i < CURL_NUM_STATES; i++) {
for(j=0; j < CURL_NUM_ACB; j++) {
if (s->states[i].acb[j]) {
return 1;
}
}
}
return 0;
}
| 12,538 |
qemu | b3ce84fea466f3bca2ff85d158744f00c0f429bd | 0 | static void test_dynamic_globalprop_subprocess(void)
{
MyType *mt;
static GlobalProperty props[] = {
{ TYPE_DYNAMIC_PROPS, "prop1", "101", true },
{ TYPE_DYNAMIC_PROPS, "prop2", "102", true },
{ TYPE_DYNAMIC_PROPS"-bad", "prop3", "103", true },
/* .not_used=false to emulat... | 12,539 |
qemu | c07a9008ac6985cd5a15909c2b9977d982defc12 | 0 | void bdrv_aio_cancel(BlockDriverAIOCB *acb)
{
if (acb->cb == bdrv_aio_rw_vector_cb) {
VectorTranslationState *s = acb->opaque;
acb = s->aiocb;
}
acb->pool->cancel(acb);
}
| 12,540 |
qemu | a89f364ae8740dfc31b321eed9ee454e996dc3c1 | 0 | static void omap_mcbsp_writeh(void *opaque, hwaddr addr,
uint32_t value)
{
struct omap_mcbsp_s *s = (struct omap_mcbsp_s *) opaque;
int offset = addr & OMAP_MPUI_REG_MASK;
switch (offset) {
case 0x00: /* DRR2 */
case 0x02: /* DRR1 */
OMAP_RO_REG(addr);
retu... | 12,541 |
qemu | 384acbf46b70edf0d2c1648aa1a92a90bcf7057d | 0 | BlockDriverAIOCB *paio_ioctl(BlockDriverState *bs, int fd,
unsigned long int req, void *buf,
BlockDriverCompletionFunc *cb, void *opaque)
{
struct qemu_paiocb *acb;
acb = qemu_aio_get(&raw_aio_pool, bs, cb, opaque);
if (!acb)
return NULL;
acb->aio_type = QEMU_AIO_IOCTL;... | 12,543 |
qemu | 9561fda8d90e176bef598ba87c42a1bd6ad03ef7 | 1 | static void object_get_link_property(Object *obj, Visitor *v, void *opaque,
const char *name, Error **errp)
{
Object **child = opaque;
gchar *path;
if (*child) {
path = object_get_canonical_path(*child);
visit_type_str(v, &path, name, errp);
... | 12,546 |
FFmpeg | c23acbaed40101c677dfcfbbfe0d2c230a8e8f44 | 1 | void FUNCC(ff_h264_idct_dc_add)(uint8_t *_dst, DCTELEM *block, int stride){
int i, j;
int dc = (((dctcoef*)block)[0] + 32) >> 6;
INIT_CLIP
pixel *dst = (pixel*)_dst;
stride /= sizeof(pixel);
for( j = 0; j < 4; j++ )
{
for( i = 0; i < 4; i++ )
dst[i] = CLIP( dst[i... | 12,547 |
FFmpeg | 88d4ff4b5f4c28fe38fa257b1d19b8fede4c35cc | 1 | int av_read_frame(AVFormatContext *s, AVPacket *pkt)
{
const int genpts = s->flags & AVFMT_FLAG_GENPTS;
int eof = 0;
int ret;
AVStream *st;
if (!genpts) {
ret = s->packet_buffer ?
read_from_packet_buffer(&s->packet_buffer, &s->packet_buffer_end, pkt) :
... | 12,549 |
qemu | 60fe637bf0e4d7989e21e50f52526444765c63b4 | 1 | static int buf_get_buffer(void *opaque, uint8_t *buf, int64_t pos, int size)
{
QEMUBuffer *s = opaque;
ssize_t len = qsb_get_length(s->qsb) - pos;
if (len <= 0) {
return 0;
}
if (len > size) {
len = size;
}
return qsb_get_buffer(s->qsb, pos, len, buf);
}
| 12,550 |
qemu | 8be7e7e4c72c048b90e3482557954a24bba43ba7 | 1 | int unix_listen(const char *str, char *ostr, int olen)
{
QemuOpts *opts;
char *path, *optstr;
int sock, len;
opts = qemu_opts_create(&dummy_opts, NULL, 0);
optstr = strchr(str, ',');
if (optstr) {
len = optstr - str;
if (len) {
path = g_malloc(len+1);
... | 12,551 |
FFmpeg | a466e345e41253aa2c8cf9d62ff32be8d2cde0fa | 0 | static void render_fragments(Vp3DecodeContext *s,
int first_fragment,
int width,
int height,
int plane /* 0 = Y, 1 = U, 2 = V */)
{
int x, y;
int m, n;
int i = first_fragment;
in... | 12,552 |
FFmpeg | de0587739011b7636743251a86d48bcd10ab7c22 | 0 | static av_cold int color_init(AVFilterContext *ctx, const char *args, void *opaque)
{
ColorContext *color = ctx->priv;
char color_string[128] = "black";
char frame_size [128] = "320x240";
char frame_rate [128] = "25";
AVRational frame_rate_q;
char *colon = 0, *equal = 0;
int ret = ... | 12,553 |
FFmpeg | 1642ee4337988523207ee8f30be9281e6919d95a | 0 | static int parse_ffconfig(const char *filename)
{
FILE *f;
char line[1024];
char cmd[64];
char arg[1024];
const char *p;
int val, errors, line_num;
FFStream **last_stream, *stream, *redirect;
FFStream **last_feed, *feed, *s;
AVCodecContext audio_enc, video_enc;
enum Co... | 12,554 |
FFmpeg | 6796a1dd8c14843b77925cb83a3ef88706ae1dd0 | 0 | void ff_put_h264_qpel16_mc03_msa(uint8_t *dst, const uint8_t *src,
ptrdiff_t stride)
{
avc_luma_vt_qrt_16w_msa(src - (stride * 2), stride, dst, stride, 16, 1);
}
| 12,555 |
qemu | 62a2554ec2630896d1299e1a282a64c7f3b00da0 | 1 | static int ccw_dstream_rw_noflags(CcwDataStream *cds, void *buff, int len,
CcwDataStreamOp op)
{
int ret;
ret = cds_check_len(cds, len);
if (ret <= 0) {
return ret;
if (op == CDS_OP_A) {
goto incr;
ret = address_space_rw(&address_spac... | 12,557 |
qemu | 6ab3fc32ea640026726bc5f9f4db622d0954fb8a | 1 | static void grlib_apbuart_write(void *opaque, hwaddr addr,
uint64_t value, unsigned size)
{
UART *uart = opaque;
unsigned char c = 0;
addr &= 0xff;
/* Unit registers */
switch (addr) {
case DATA_OFFSET:
case DATA_OFFSET + 3: /* ... | 12,559 |
FFmpeg | 25ef43bb289a3a3a717a684902c0a310e292beba | 1 | static int mpeg_decode_slice(Mpeg1Context *s1, int mb_y,
const uint8_t **buf, int buf_size)
{
MpegEncContext *s = &s1->mpeg_enc_ctx;
AVCodecContext *avctx= s->avctx;
int ret;
const int field_pic= s->picture_structure != PICT_FRAME;
s->resync_mb_x=
s->resync... | 12,560 |
FFmpeg | 220b24c7c97dc033ceab1510549f66d0e7b52ef1 | 1 | av_cold void ff_schro_queue_init(FFSchroQueue *queue)
{
queue->p_head = queue->p_tail = NULL;
queue->size = 0;
}
| 12,561 |
FFmpeg | 3cffbe090a5168dcfe580de8d662a32e7ad1d911 | 1 | static int ffm_write_header(AVFormatContext *s)
{
FFMContext *ffm = s->priv_data;
AVStream *st;
ByteIOContext *pb = s->pb;
AVCodecContext *codec;
int bit_rate, i;
ffm->packet_size = FFM_PACKET_SIZE;
/* header */
put_le32(pb, MKTAG('F', 'F', 'M', '1'));
put_be32(pb, ffm-... | 12,562 |
qemu | 639973a4740f38789057744b550df3a175bc49ad | 1 | static int assigned_device_pci_cap_init(PCIDevice *pci_dev, Error **errp)
{
AssignedDevice *dev = DO_UPCAST(AssignedDevice, dev, pci_dev);
PCIRegion *pci_region = dev->real_device.regions;
int ret, pos;
Error *local_err = NULL;
/* Clear initial capabilities pointer and status copied from hw ... | 12,563 |
FFmpeg | c0323b9c9bcebe029df0b19a19a6f81deef94b3a | 1 | int avfilter_graph_send_command(AVFilterGraph *graph, const char *target, const char *cmd, const char *arg, char *res, int res_len, int flags)
{
int i, r = AVERROR(ENOSYS);
if(!graph)
return r;
if((flags & AVFILTER_CMD_FLAG_ONE) && !(flags & AVFILTER_CMD_FLAG_FAST)) {
r=avfilter_gr... | 12,564 |
FFmpeg | d7e9533aa06f4073a27812349b35ba5fede11ca1 | 1 | static void dct_unquantize_mpeg2_c(MpegEncContext *s,
DCTELEM *block, int n, int qscale)
{
int i, level, nCoeffs;
const UINT16 *quant_matrix;
if(s->alternate_scan) nCoeffs= 64;
else nCoeffs= s->block_last_index[n]+1;
if (s->mb_intra) {
if (... | 12,565 |
qemu | 058bc4b57f9d6b39d9a6748b4049e1be3fde3dac | 1 | static void destroy_l2_mapping(PhysPageEntry *lp, unsigned level)
{
unsigned i;
PhysPageEntry *p;
if (lp->ptr == PHYS_MAP_NODE_NIL) {
return;
}
p = phys_map_nodes[lp->ptr];
for (i = 0; i < L2_SIZE; ++i) {
if (!p[i].is_leaf) {
destroy_l2_mapping(&p[i], le... | 12,566 |
FFmpeg | 34c52005605d68f7cd1957b169b6732c7d2447d9 | 1 | static int apply_window_and_mdct(vorbis_enc_context *venc,
float **audio, int samples)
{
int channel;
const float * win = venc->win[0];
int window_len = 1 << (venc->log2_blocksize[0] - 1);
float n = (float)(1 << venc->log2_blocksize[0]) / 4.0;
AVFloatDSPContex... | 12,568 |
FFmpeg | 25e87fc5f61bd9b85ecf52c6082a18d7e7c8506b | 0 | static int transcode(void)
{
int ret, i;
AVFormatContext *is, *os;
OutputStream *ost;
InputStream *ist;
uint8_t *no_packet;
int no_packet_count = 0;
int64_t timer_start;
int key;
if (!(no_packet = av_mallocz(nb_input_files)))
exit_program(1);
ret = transco... | 12,569 |
FFmpeg | a8475bbdb64e638bd8161df9647876fd23f8a29a | 0 | static int rtsp_write_packet(AVFormatContext *s, AVPacket *pkt)
{
RTSPState *rt = s->priv_data;
RTSPStream *rtsp_st;
fd_set rfds;
int n, tcp_fd;
struct timeval tv;
AVFormatContext *rtpctx;
int ret;
tcp_fd = url_get_file_handle(rt->rtsp_hd);
while (1) {
FD_ZERO(... | 12,570 |
qemu | 7d1b0095bff7157e856d1d0e6c4295641ced2752 | 1 | static inline TCGv load_reg(DisasContext *s, int reg)
{
TCGv tmp = new_tmp();
load_reg_var(s, tmp, reg);
return tmp;
}
| 12,571 |
qemu | caae58cba07efec5f0616f568531c9dfaf1e9179 | 1 | static void ppc_spapr_init(QEMUMachineInitArgs *args)
{
ram_addr_t ram_size = args->ram_size;
const char *cpu_model = args->cpu_model;
const char *kernel_filename = args->kernel_filename;
const char *kernel_cmdline = args->kernel_cmdline;
const char *initrd_filename = args->initrd_filename;
... | 12,572 |
qemu | 854e67fea6a6f181163a5467fc9ba04de8d181bb | 1 | static void hmp_info_cpustats(Monitor *mon, const QDict *qdict)
{
cpu_dump_statistics(mon_get_cpu(), (FILE *)mon, &monitor_fprintf, 0);
}
| 12,573 |
FFmpeg | ca488ad480360dfafcb5766f7bfbb567a0638979 | 1 | static int read_decode_block(ALSDecContext *ctx, ALSBlockData *bd)
{
int ret;
ret = read_block(ctx, bd);
if (ret)
return ret;
ret = decode_block(ctx, bd);
return ret;
}
| 12,574 |
qemu | e0dadc1e9ef1f35208e5d2af9c7740c18a0b769f | 1 | DeviceState *aux_create_slave(AUXBus *bus, const char *type, uint32_t addr)
{
DeviceState *dev;
dev = DEVICE(object_new(type));
assert(dev);
qdev_set_parent_bus(dev, &bus->qbus);
qdev_init_nofail(dev);
aux_bus_map_device(AUX_BUS(qdev_get_parent_bus(dev)), AUX_SLAVE(dev), addr);
ret... | 12,575 |
qemu | d2164ad35c411d97abd2aa5c6f160283d215e214 | 1 | static int get_uint64_equal(QEMUFile *f, void *pv, size_t size,
VMStateField *field)
{
uint64_t *v = pv;
uint64_t v2;
qemu_get_be64s(f, &v2);
if (*v == v2) {
return 0;
error_report("%" PRIx64 " != %" PRIx64, *v, v2);
return -EINVAL;
| 12,576 |
qemu | 950d94ba0671e7f154a9e87a277f8efbddcee28f | 1 | static void vhost_net_stop_one(struct vhost_net *net,
VirtIODevice *dev)
{
struct vhost_vring_file file = { .fd = -1 };
if (net->nc->info->type == NET_CLIENT_DRIVER_TAP) {
for (file.index = 0; file.index < net->dev.nvqs; ++file.index) {
const VhostOps *... | 12,577 |
qemu | 133e9b228df16d11de01529c217417e78d1d9370 | 1 | static int pci_init_multifunction(PCIBus *bus, PCIDevice *dev)
{
uint8_t slot = PCI_SLOT(dev->devfn);
uint8_t func;
if (dev->cap_present & QEMU_PCI_CAP_MULTIFUNCTION) {
dev->config[PCI_HEADER_TYPE] |= PCI_HEADER_TYPE_MULTI_FUNCTION;
}
/*
* multifunction bit is interpreted in... | 12,578 |
FFmpeg | 24dc7776ff4452764d0365b12d0728153f879cf8 | 0 | static int mpeg_mux_init(AVFormatContext *ctx)
{
MpegMuxContext *s = ctx->priv_data;
int bitrate, i, mpa_id, mpv_id, mps_id, ac3_id, dts_id, lpcm_id, j;
AVStream *st;
StreamInfo *stream;
int audio_bitrate;
int video_bitrate;
s->packet_number = 0;
s->is_vcd = (CONFIG_MPEG1VC... | 12,580 |
FFmpeg | 1895d414aaacece3b57d7bf19502305e9a064fae | 0 | static av_cold int initFilter(int16_t **outFilter, int32_t **filterPos,
int *outFilterSize, int xInc, int srcW,
int dstW, int filterAlign, int one,
int flags, int cpu_flags,
SwsVector *srcFilter, ... | 12,581 |
FFmpeg | be8d812c9635f31f69c30dff9ebf565a07a7dab7 | 1 | static av_cold int vorbis_encode_init(AVCodecContext *avccontext)
{
vorbis_enc_context *venc = avccontext->priv_data;
if (avccontext->channels != 2) {
av_log(avccontext, AV_LOG_ERROR, "Current Libav Vorbis encoder only supports 2 channels.\n");
return -1;
}
create_vorbis_conte... | 12,582 |
qemu | b45c03f585ea9bb1af76c73e82195418c294919d | 1 | struct omap_gp_timer_s *omap_gp_timer_init(struct omap_target_agent_s *ta,
qemu_irq irq, omap_clk fclk, omap_clk iclk)
{
struct omap_gp_timer_s *s = (struct omap_gp_timer_s *)
g_malloc0(sizeof(struct omap_gp_timer_s));
s->ta = ta;
s->irq = irq;
s->clk = fclk;
s-... | 12,583 |
qemu | 675463d9b6b2c2b65a713a6d906aeebe9e6750ae | 1 | ISADevice *isa_try_create(ISABus *bus, const char *name)
{
DeviceState *dev;
if (!bus) {
hw_error("Tried to create isa device %s with no isa bus present.",
name);
}
dev = qdev_try_create(BUS(bus), name);
return ISA_DEVICE(dev);
}
| 12,584 |
qemu | 12fd28535891572be7aaf862a03019257dafa425 | 1 | static int spapr_tce_table_realize(DeviceState *dev)
{
sPAPRTCETable *tcet = SPAPR_TCE_TABLE(dev);
if (kvm_enabled()) {
tcet->table = kvmppc_create_spapr_tce(tcet->liobn,
tcet->nb_table <<
tcet->page_shif... | 12,586 |
qemu | 8638f1ad7403b63db880dadce38e6690b5d82b64 | 1 | static bool get_phys_addr_pmsav7(CPUARMState *env, uint32_t address,
MMUAccessType access_type, ARMMMUIdx mmu_idx,
hwaddr *phys_ptr, int *prot,
ARMMMUFaultInfo *fi)
{
ARMCPU *cpu = arm_env_get_cpu(env);
int ... | 12,587 |
qemu | 5ad4a2b75f85dd854a781a6e03b90320cb3441d3 | 1 | bool address_space_access_valid(AddressSpace *as, hwaddr addr, int len, bool is_write)
{
MemoryRegion *mr;
hwaddr l, xlat;
rcu_read_lock();
while (len > 0) {
l = len;
mr = address_space_translate(as, addr, &xlat, &l, is_write);
if (!memory_access_is_direct(mr, is_write)... | 12,588 |
qemu | 016d2e1dfa21b64a524d3629fdd317d4c25bc3b8 | 1 | static int restore_sigcontext(CPUAlphaState *env,
struct target_sigcontext *sc)
{
uint64_t fpcr;
int i, err = 0;
__get_user(env->pc, &sc->sc_pc);
for (i = 0; i < 31; ++i) {
__get_user(env->ir[i], &sc->sc_regs[i]);
}
for (i = 0; i < 31; ++i) {
... | 12,589 |
qemu | f8ed85ac992c48814d916d5df4d44f9a971c5de4 | 1 | static void qxl_realize_secondary(PCIDevice *dev, Error **errp)
{
static int device_id = 1;
PCIQXLDevice *qxl = PCI_QXL(dev);
qxl->id = device_id++;
qxl_init_ramsize(qxl);
memory_region_init_ram(&qxl->vga.vram, OBJECT(dev), "qxl.vgavram",
qxl->vga.vram_size, &erro... | 12,590 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.