project stringclasses 2
values | commit_id stringlengths 40 40 | target int64 0 1 | func stringlengths 26 142k | idx int64 0 27.3k |
|---|---|---|---|---|
FFmpeg | eca2a49716ae1f42804dd3545da2f740edf03250 | 1 | int64_t avio_seek(AVIOContext *s, int64_t offset, int whence)
{
int64_t offset1;
int64_t pos;
int force = whence & AVSEEK_FORCE;
int buffer_size;
int short_seek;
whence &= ~AVSEEK_FORCE;
if(!s)
buffer_size = s->buf_end - s->buffer;
// pos is the absolute position that ... | 741 |
qemu | 49dd946bb5419681c8668b09a6d10f42bc707b78 | 1 | static void coroutine_fn v9fs_rename(void *opaque)
{
int32_t fid;
ssize_t err = 0;
size_t offset = 7;
V9fsString name;
int32_t newdirfid;
V9fsFidState *fidp;
V9fsPDU *pdu = opaque;
V9fsState *s = pdu->s;
v9fs_string_init(&name);
err = pdu_unmarshal(pdu, offset, "dds"... | 742 |
FFmpeg | 3a6ded7cfcb33e06ade98c5791eae06453f65668 | 1 | AVVDPAUContext *av_vdpau_alloc_context(void)
{
return av_mallocz(sizeof(AVVDPAUContext));
}
| 743 |
FFmpeg | cea3a63ba3d89d8403eef008f7a7c54d645cff70 | 1 | static AVBufferRef *pool_alloc_buffer(AVBufferPool *pool)
{
BufferPoolEntry *buf;
AVBufferRef *ret;
ret = pool->alloc(pool->size);
if (!ret)
return NULL;
buf = av_mallocz(sizeof(*buf));
if (!buf) {
av_buffer_unref(&ret);
return NULL;
}
buf->d... | 744 |
FFmpeg | 1677155df8ee2dbf6c99738b289e27c2237506bd | 1 | static void compute_frame_duration(int *pnum, int *pden, AVStream *st,
AVCodecParserContext *pc, AVPacket *pkt)
{
int frame_size;
*pnum = 0;
*pden = 0;
switch(st->codec.codec_type) {
case CODEC_TYPE_VIDEO:
if(st->time_base.num*1000 > st->time_bas... | 745 |
qemu | 9ac228e02cf16202547e7025ef300369e0db7781 | 1 | static int vdi_check(BlockDriverState *bs)
{
/* TODO: additional checks possible. */
BDRVVdiState *s = (BDRVVdiState *)bs->opaque;
int n_errors = 0;
uint32_t blocks_allocated = 0;
uint32_t block;
uint32_t *bmap;
logout("\n");
bmap = qemu_malloc(s->header.blocks_in_image * size... | 746 |
qemu | 5c3234c6c037943bd4c2d643a1b8cc35f563dbdb | 1 | static void submit_pdu(V9fsState *s, V9fsPDU *pdu)
{
pdu_handler_t *handler;
if (debug_9p_pdu) {
pprint_pdu(pdu);
}
BUG_ON(pdu->id >= ARRAY_SIZE(pdu_handlers));
handler = pdu_handlers[pdu->id];
BUG_ON(handler == NULL);
handler(s, pdu);
}
| 749 |
qemu | 2958620f67dcfd11476e62b4ca704dae0b978ea3 | 1 | uint64_t helper_addqv (uint64_t op1, uint64_t op2)
{
uint64_t tmp = op1;
op1 += op2;
if (unlikely((tmp ^ op2 ^ (-1ULL)) & (tmp ^ op1) & (1ULL << 63))) {
arith_excp(env, GETPC(), EXC_M_IOV, 0);
}
return op1;
}
| 750 |
qemu | b2eb849d4b1fdb6f35d5c46958c7f703cf64cfef | 1 | static void cirrus_mem_writeb_mode4and5_8bpp(CirrusVGAState * s,
unsigned mode,
unsigned offset,
uint32_t mem_value)
{
int x;
unsigned val = mem_value;
uint8_t *dst;
dst = s->vram_ptr + offset;
for (x = 0; x < 8; x++) {
if (val & 0x80) {
*dst = s->cir... | 751 |
qemu | c5a49c63fa26e8825ad101dfe86339ae4c216539 | 1 | void translator_loop(const TranslatorOps *ops, DisasContextBase *db,
CPUState *cpu, TranslationBlock *tb)
{
int max_insns;
/* Initialize DisasContext */
db->tb = tb;
db->pc_first = tb->pc;
db->pc_next = db->pc_first;
db->is_jmp = DISAS_NEXT;
db->num_insns = 0;... | 752 |
FFmpeg | 631fa0432be8968e0fd372595749b918224946df | 1 | static int load_apply_palette(FFFrameSync *fs)
{
AVFilterContext *ctx = fs->parent;
AVFilterLink *inlink = ctx->inputs[0];
PaletteUseContext *s = ctx->priv;
AVFrame *master, *second, *out = NULL;
int ret;
// writable for error diffusal dithering
ret = ff_framesync_dualinput_get_wri... | 753 |
FFmpeg | fa2a34cd40d124161c748bb0f430dc63c94dd0da | 0 | void avfilter_uninit(void)
{
memset(registered_avfilters, 0, sizeof(registered_avfilters));
next_registered_avfilter_idx = 0;
}
| 755 |
FFmpeg | d701934bef6ff6868c0a2179b7b9105c7a49b41f | 0 | int pcm_read_seek(AVFormatContext *s,
int stream_index, int64_t timestamp, int flags)
{
AVStream *st;
int block_align, byte_rate;
int64_t pos;
st = s->streams[0];
block_align = st->codec->block_align ? st->codec->block_align :
(av_get_bits_per_sample(st->codec->... | 756 |
FFmpeg | 9cb5c760d73e08bcd5d441d261abe67d472e98ee | 0 | void show_pix_fmts(void)
{
list_fmts(avcodec_pix_fmt_string, PIX_FMT_NB);
}
| 758 |
FFmpeg | f86387b6c2b11650cb9d5a8fd886be76e48c665b | 0 | static int spdif_get_offset_and_codec(AVFormatContext *s,
enum IEC61937DataType data_type,
const char *buf, int *offset,
enum AVCodecID *codec)
{
AACADTSHeaderInfo aac_hdr;
GetBitContext gbc;
... | 759 |
FFmpeg | 3b199d29cd597a3518136d78860e172060b9e83d | 0 | static av_cold int seqvideo_decode_init(AVCodecContext *avctx)
{
SeqVideoContext *seq = avctx->priv_data;
seq->avctx = avctx;
avctx->pix_fmt = AV_PIX_FMT_PAL8;
seq->frame.data[0] = NULL;
return 0;
}
| 760 |
FFmpeg | d319064465e148b8adb53d1ea5d38c09f987056e | 0 | void set_context_opts(void *ctx, void *opts_ctx, int flags, AVCodec *codec)
{
int i;
void *priv_ctx=NULL;
if(!strcmp("AVCodecContext", (*(AVClass**)ctx)->class_name)){
AVCodecContext *avctx= ctx;
if(codec && codec->priv_class && avctx->priv_data){
priv_ctx= avctx->priv_dat... | 761 |
FFmpeg | 7bf9e3391fa21d90ff283fc03a12287fe73db9e8 | 0 | int av_vsrc_buffer_add_frame(AVFilterContext *buffer_filter, AVFrame *frame,
int64_t pts, AVRational pixel_aspect)
{
BufferSourceContext *c = buffer_filter->priv;
AVFilterBufferRef *buf;
int ret;
if (!buf) {
c->eof = 1;
return 0;
} else if (c->... | 762 |
FFmpeg | 4843227b2ca6876d07caddddd62e58e52d67e94f | 1 | static int decode_byterun(uint8_t *dst, int dst_size,
const uint8_t *buf, const uint8_t *const buf_end)
{
const uint8_t *const buf_start = buf;
unsigned x;
for (x = 0; x < dst_size && buf < buf_end;) {
unsigned length;
const int8_t value = *buf++;
if... | 763 |
qemu | 60fe637bf0e4d7989e21e50f52526444765c63b4 | 1 | uint64_t blk_mig_bytes_total(void)
{
BlkMigDevState *bmds;
uint64_t sum = 0;
QSIMPLEQ_FOREACH(bmds, &block_mig_state.bmds_list, entry) {
sum += bmds->total_sectors;
}
return sum << BDRV_SECTOR_BITS;
}
| 764 |
FFmpeg | 11d058b7b351db8fb73104c847c5cc43b91735c6 | 1 | theora_header (AVFormatContext * s, int idx)
{
struct ogg *ogg = s->priv_data;
struct ogg_stream *os = ogg->streams + idx;
AVStream *st = s->streams[idx];
struct theora_params *thp = os->private;
int cds = st->codec->extradata_size + os->psize + 2;
uint8_t *cdp;
if(!(os->buf[os->ps... | 765 |
qemu | b946a1533209f61a93e34898aebb5b43154b99c3 | 1 | static TAPState *net_tap_fd_init(VLANState *vlan,
const char *model,
const char *name,
int fd)
{
TAPState *s;
s = qemu_mallocz(sizeof(TAPState));
s->fd = fd;
s->vc = qemu_new_vlan_client(vlan, mo... | 766 |
qemu | 8b3b720620a1137a1b794fc3ed64734236f94e06 | 1 | static int write_refcount_block_entries(BlockDriverState *bs,
int64_t refcount_block_offset, int first_index, int last_index)
{
BDRVQcowState *s = bs->opaque;
size_t size;
int ret;
if (cache_refcount_updates) {
return 0;
}
if (first_index < 0) {
return 0;
}... | 769 |
FFmpeg | 14e4e26559697cfdea584767be4e68474a0a9c7f | 1 | static int t15(InterplayACMContext *s, unsigned ind, unsigned col)
{
GetBitContext *gb = &s->gb;
unsigned i, b;
int n1, n2, n3;
for (i = 0; i < s->rows; i++) {
/* b = (x1) + (x2 * 3) + (x3 * 9) */
b = get_bits(gb, 5);
n1 = (mul_3x3[b] & 0x0F) - 1;
n2 = (... | 770 |
qemu | d9bce9d99f4656ae0b0127f7472db9067b8f84ab | 1 | void do_load_6xx_tlb (int is_code)
{
target_ulong RPN, CMP, EPN;
int way;
RPN = env->spr[SPR_RPA];
if (is_code) {
CMP = env->spr[SPR_ICMP];
EPN = env->spr[SPR_IMISS];
} else {
CMP = env->spr[SPR_DCMP];
EPN = env->spr[SPR_DMISS];
}
way = (env-... | 773 |
qemu | c9f82d013be0d8d9c5d9f51bb76e337a0a5a5cac | 1 | void helper_dcbz(CPUPPCState *env, target_ulong addr, uint32_t is_dcbzl)
{
int dcbz_size = env->dcache_line_size;
#if defined(TARGET_PPC64)
if (!is_dcbzl &&
(env->excp_model == POWERPC_EXCP_970) &&
((env->spr[SPR_970_HID5] >> 7) & 0x3) == 1) {
dcbz_size = 32;
}
#endif
... | 774 |
qemu | ec45bbe5f1921c6553fbf9c0c76b358b0403c22d | 1 | envlist_create(void)
{
envlist_t *envlist;
if ((envlist = malloc(sizeof (*envlist))) == NULL)
return (NULL);
QLIST_INIT(&envlist->el_entries);
envlist->el_count = 0;
return (envlist);
}
| 775 |
qemu | b68e60e6f0d2865e961a800fb8db96a7fc6494c4 | 1 | static void gen_ori(DisasContext *ctx)
{
target_ulong uimm = UIMM(ctx->opcode);
if (rS(ctx->opcode) == rA(ctx->opcode) && uimm == 0) {
/* NOP */
/* XXX: should handle special NOPs for POWER series */
return;
}
tcg_gen_ori_tl(cpu_gpr[rA(ctx->opcode)], cpu_gpr[rS(ctx->opc... | 776 |
FFmpeg | 15861962a7a9e64fbe75f5cc0dc7d1c032db8dd5 | 1 | static void close(AVCodecParserContext *s)
{
H264Context *h = s->priv_data;
ParseContext *pc = &h->s.parse_context;
av_free(pc->buffer);
} | 777 |
qemu | 6b7741c2bedeae2e8c54fffce81723ca0a0c25c0 | 1 | static void sch_handle_start_func(SubchDev *sch, ORB *orb)
{
PMCW *p = &sch->curr_status.pmcw;
SCSW *s = &sch->curr_status.scsw;
int path;
int ret;
/* Path management: In our simple css, we always choose the only path. */
path = 0x80;
if (!(s->ctrl & SCSW_ACTL_SUSP)) {
... | 778 |
qemu | 0a73336d96397c80881219d080518fac6f1ecacb | 1 | static int net_vhost_chardev_opts(void *opaque,
const char *name, const char *value,
Error **errp)
{
VhostUserChardevProps *props = opaque;
if (strcmp(name, "backend") == 0 && strcmp(value, "socket") == 0) {
props->is_socket = t... | 779 |
FFmpeg | fea714ecd9de557054b2540119f6b5635ba0e636 | 1 | static int decode_frame(AVCodecContext *avctx,
void *data,
int *data_size,
AVPacket *avpkt)
{
const uint8_t *buf = avpkt->data;
const uint8_t *buf_end = avpkt->data + avpkt->size;
int buf_size = avpkt->size;
DPXContext... | 780 |
FFmpeg | 71434945f20c6d340b4c942de7746e6ea46ec74b | 1 | static int mpeg_decode_mb(MpegEncContext *s,
DCTELEM block[12][64])
{
int i, j, k, cbp, val, mb_type, motion_type;
const int mb_block_count = 4 + (1<< s->chroma_format)
dprintf("decode_mb: x=%d y=%d\n", s->mb_x, s->mb_y);
assert(s->mb_skiped==0);
if (s->mb_skip... | 783 |
qemu | 76e050c2e62995f1d6905e28674dea3a7fcff1a5 | 1 | void op_subo (void)
{
target_ulong tmp;
tmp = T0;
T0 = (int32_t)T0 - (int32_t)T1;
if (!((T0 >> 31) ^ (T1 >> 31) ^ (tmp >> 31))) {
CALL_FROM_TB1(do_raise_exception_direct, EXCP_OVERFLOW);
}
RETURN();
}
| 784 |
qemu | 12de9a396acbc95e25c5d60ed097cc55777eaaed | 1 | int get_physical_address (CPUState *env, mmu_ctx_t *ctx, target_ulong eaddr,
int rw, int access_type, int check_BATs)
{
int ret;
#if 0
if (loglevel != 0) {
fprintf(logfile, "%s\n", __func__);
}
#endif
if ((access_type == ACCESS_CODE && msr_ir == 0) ||
... | 785 |
qemu | 4a9f9cb24de52e93aae7539a004dd20314ca1c0c | 0 | uint32_t HELPER(neon_min_f32)(uint32_t a, uint32_t b)
{
float32 f0 = make_float32(a);
float32 f1 = make_float32(b);
return (float32_compare_quiet(f0, f1, NFS) == -1) ? a : b;
}
| 786 |
qemu | 3f66f764ee25f10d3e1144ebc057a949421b7728 | 0 | static void test_primitive_lists(gconstpointer opaque)
{
TestArgs *args = (TestArgs *) opaque;
const SerializeOps *ops = args->ops;
PrimitiveType *pt = args->test_data;
PrimitiveList pl = { .value = { NULL } };
PrimitiveList pl_copy = { .value = { NULL } };
PrimitiveList *pl_copy_ptr = &p... | 787 |
qemu | a8170e5e97ad17ca169c64ba87ae2f53850dab4c | 0 | static struct omap_pwl_s *omap_pwl_init(MemoryRegion *system_memory,
target_phys_addr_t base,
omap_clk clk)
{
struct omap_pwl_s *s = g_malloc0(sizeof(*s));
omap_pwl_reset(s);
memory_region_init_io(&s->iomem, &omap_pwl_... | 788 |
qemu | a8170e5e97ad17ca169c64ba87ae2f53850dab4c | 0 | static void gem_transmit(GemState *s)
{
unsigned desc[2];
target_phys_addr_t packet_desc_addr;
uint8_t tx_packet[2048];
uint8_t *p;
unsigned total_bytes;
/* Do nothing if transmit is not enabled. */
if (!(s->regs[GEM_NWCTRL] & GEM_NWCTRL_TXENA)) {
return;
... | 789 |
qemu | ef1e1e0782e99c9dcf2b35e5310cdd8ca9211374 | 0 | static void rx_init_frame(eTSEC *etsec, const uint8_t *buf, size_t size)
{
uint32_t fcb_size = 0;
uint8_t prsdep = (etsec->regs[RCTRL].value >> RCTRL_PRSDEP_OFFSET)
& RCTRL_PRSDEP_MASK;
if (prsdep != 0) {
/* Prepend FCB (FCB size + RCTRL[PAL]) */
fcb_size = 8 + ((etsec->r... | 790 |
qemu | 8360544a6d3a54df1fce80f55ba4ad075a8ded54 | 0 | static uint32_t qpci_spapr_io_readl(QPCIBus *bus, void *addr)
{
QPCIBusSPAPR *s = container_of(bus, QPCIBusSPAPR, bus);
uint64_t port = (uintptr_t)addr;
uint32_t v;
if (port < s->pio.size) {
v = readl(s->pio_cpu_base + port);
} else {
v = readl(s->mmio_cpu_base + port);
... | 791 |
qemu | 9b990ee5a3cc6aa38f81266fb0c6ef37a36c45b9 | 0 | void cpu_io_recompile(CPUState *cpu, uintptr_t retaddr)
{
#if defined(TARGET_MIPS) || defined(TARGET_SH4)
CPUArchState *env = cpu->env_ptr;
#endif
TranslationBlock *tb;
uint32_t n, cflags;
target_ulong pc, cs_base;
uint32_t flags;
tb_lock();
tb = tb_find_pc(retaddr);
if (!tb... | 792 |
qemu | ef76dc59fa5203d146a2acf85a0ad5a5971a4824 | 0 | START_TEST(unterminated_array)
{
QObject *obj = qobject_from_json("[32");
fail_unless(obj == NULL);
}
| 793 |
qemu | ccdb81d3274d281d770703417257bd40bcdf4c0e | 0 | static void imx_fec_reset(DeviceState *d)
{
IMXFECState *s = IMX_FEC(d);
/* Reset the FEC */
s->eir = 0;
s->eimr = 0;
s->rx_enabled = 0;
s->ecr = 0;
s->mscr = 0;
s->mibc = 0xc0000000;
s->rcr = 0x05ee0001;
s->tcr = 0;
s->tfwr = 0;
s->frsr = 0x500;
s->mi... | 796 |
qemu | 4be746345f13e99e468c60acbd3a355e8183e3ce | 0 | struct omap_mmc_s *omap2_mmc_init(struct omap_target_agent_s *ta,
BlockDriverState *bd, qemu_irq irq, qemu_irq dma[],
omap_clk fclk, omap_clk iclk)
{
struct omap_mmc_s *s = (struct omap_mmc_s *)
g_malloc0(sizeof(struct omap_mmc_s));
s->irq = irq;
s->dma =... | 798 |
qemu | 72cf2d4f0e181d0d3a3122e04129c58a95da713e | 0 | int vmstate_register(int instance_id, const VMStateDescription *vmsd,
void *opaque)
{
SaveStateEntry *se;
se = qemu_malloc(sizeof(SaveStateEntry));
pstrcpy(se->idstr, sizeof(se->idstr), vmsd->name);
se->version_id = vmsd->version_id;
se->section_id = global_section_id++... | 799 |
qemu | c2b38b277a7882a592f4f2ec955084b2b756daaa | 0 | bool qemu_clock_expired(QEMUClockType type)
{
return timerlist_expired(
main_loop_tlg.tl[type]);
}
| 800 |
qemu | 494a8ebe713055d3946183f4b395f85a18b43e9e | 0 | static int proxy_opendir(FsContext *ctx,
V9fsPath *fs_path, V9fsFidOpenState *fs)
{
int serrno, fd;
fs->dir = NULL;
fd = v9fs_request(ctx->private, T_OPEN, NULL, "sd", fs_path, O_DIRECTORY);
if (fd < 0) {
errno = -fd;
return -1;
}
fs->dir = fd... | 801 |
qemu | 4be746345f13e99e468c60acbd3a355e8183e3ce | 0 | static sd_rsp_type_t sd_normal_command(SDState *sd,
SDRequest req)
{
uint32_t rca = 0x0000;
uint64_t addr = (sd->ocr & (1 << 30)) ? (uint64_t) req.arg << 9 : req.arg;
/* Not interpreting this as an app command */
sd->card_status &= ~APP_CMD;
if (sd_c... | 802 |
qemu | d9429b84af2302b6e28bec3c52710cf67eda3cee | 0 | static void amdvi_mmio_trace(hwaddr addr, unsigned size)
{
uint8_t index = (addr & ~0x2000) / 8;
if ((addr & 0x2000)) {
/* high table */
index = index >= AMDVI_MMIO_REGS_HIGH ? AMDVI_MMIO_REGS_HIGH : index;
trace_amdvi_mmio_read(amdvi_mmio_high[index], addr, size, addr & ~0x07);
... | 803 |
qemu | c611c76417f52b335ecaab01c61743e3b705eb7c | 0 | void virtio_cleanup(VirtIODevice *vdev)
{
qemu_del_vm_change_state_handler(vdev->vmstate);
g_free(vdev->config);
g_free(vdev->vq);
g_free(vdev->vector_queues);
}
| 804 |
qemu | b00c72180c36510bf9b124e190bd520e3b7e1358 | 0 | static void gen_pool32axf (CPUMIPSState *env, DisasContext *ctx, int rt, int rs)
{
int extension = (ctx->opcode >> 6) & 0x3f;
int minor = (ctx->opcode >> 12) & 0xf;
uint32_t mips32_op;
switch (extension) {
case TEQ:
mips32_op = OPC_TEQ;
goto do_trap;
case TGE:
... | 805 |
FFmpeg | 2f300f8965793c3bb9f9d753fcd4542f94f4c58a | 0 | void ff_fix_long_mvs(MpegEncContext * s, uint8_t *field_select_table, int field_select,
int16_t (*mv_table)[2], int f_code, int type, int truncate)
{
MotionEstContext * const c= &s->me;
int y, h_range, v_range;
// RAL: 8 in MPEG-1, 16 in MPEG-4
int range = (((s->out_format ... | 806 |
qemu | c2b38b277a7882a592f4f2ec955084b2b756daaa | 0 | ThreadPool *thread_pool_new(AioContext *ctx)
{
ThreadPool *pool = g_new(ThreadPool, 1);
thread_pool_init_one(pool, ctx);
return pool;
}
| 807 |
qemu | 4e9e9d6e0a68f1691bcdcc80601a9a1bc2954736 | 0 | static int parse_bootdevices(char *devices)
{
/* We just do some generic consistency checks */
const char *p;
int bitmap = 0;
for (p = devices; *p != '\0'; p++) {
/* Allowed boot devices are:
* a-b: floppy disk drives
* c-f: IDE disk drives
* g-m: machine im... | 808 |
qemu | bec1631100323fac0900aea71043d5c4e22fc2fa | 0 | static void tcg_out_brcond(TCGContext *s, TCGCond cond, TCGReg arg1,
TCGReg arg2, int label_index)
{
static const MIPSInsn b_zero[16] = {
[TCG_COND_LT] = OPC_BLTZ,
[TCG_COND_GT] = OPC_BGTZ,
[TCG_COND_LE] = OPC_BLEZ,
[TCG_COND_GE] = OPC_BGEZ,
};
... | 809 |
qemu | a7812ae412311d7d47f8aa85656faadac9d64b56 | 0 | static unsigned int dec_move_rp(DisasContext *dc)
{
TCGv t[2];
DIS(fprintf (logfile, "move $r%u, $p%u\n", dc->op1, dc->op2));
cris_cc_mask(dc, 0);
t[0] = tcg_temp_new(TCG_TYPE_TL);
if (dc->op2 == PR_CCS) {
cris_evaluate_flags(dc);
t_gen_mov_TN_reg(t[0], dc->op1);
if (dc->tb_flags & U_FLAG) {
t... | 810 |
qemu | ad6919dc0ab3b8ae26d772e883aa8e709785d249 | 0 | static uint32_t get_elf_hwcap(void)
{
ARMCPU *cpu = ARM_CPU(thread_cpu);
uint32_t hwcaps = 0;
hwcaps |= ARM_HWCAP_ARM_SWP;
hwcaps |= ARM_HWCAP_ARM_HALF;
hwcaps |= ARM_HWCAP_ARM_THUMB;
hwcaps |= ARM_HWCAP_ARM_FAST_MULT;
/* probe for the extra features */
#define GET_FEATURE(feat,... | 811 |
qemu | b3db211f3c80bb996a704d665fe275619f728bd4 | 0 | static void test_visitor_out_native_list_uint64(TestOutputVisitorData *data,
const void *unused)
{
test_native_list(data, unused, USER_DEF_NATIVE_LIST_UNION_KIND_U64);
}
| 812 |
qemu | 61007b316cd71ee7333ff7a0a749a8949527575f | 0 | BlockAIOCB *bdrv_aio_flush(BlockDriverState *bs,
BlockCompletionFunc *cb, void *opaque)
{
trace_bdrv_aio_flush(bs, opaque);
Coroutine *co;
BlockAIOCBCoroutine *acb;
acb = qemu_aio_get(&bdrv_em_co_aiocb_info, bs, cb, opaque);
acb->need_bh = true;
acb->req.error = -EINPROGRESS;... | 813 |
qemu | 7d08c73e7bdc39b10e5f2f5acdce700f17ffe962 | 0 | xmit_seg(E1000State *s)
{
uint16_t len;
unsigned int frames = s->tx.tso_frames, css, sofar;
struct e1000_tx *tp = &s->tx;
if (tp->props.tse && tp->props.cptse) {
css = tp->props.ipcss;
DBGOUT(TXSUM, "frames %d size %d ipcss %d\n",
frames, tp->size, css);
... | 816 |
FFmpeg | 0846719dd11ab3f7a7caee13e7af71f71d913389 | 0 | int ff_ivi_decode_blocks(GetBitContext *gb, IVIBandDesc *band, IVITile *tile)
{
int mbn, blk, num_blocks, num_coeffs, blk_size, scan_pos, run, val,
pos, is_intra, mc_type, mv_x, mv_y, col_mask;
uint8_t col_flags[8];
int32_t prev_dc, trvec[64];
uint32_t cbp, sym, ... | 817 |
qemu | a8170e5e97ad17ca169c64ba87ae2f53850dab4c | 0 | static void assigned_dev_ioport_write(void *opaque, target_phys_addr_t addr,
uint64_t data, unsigned size)
{
assigned_dev_ioport_rw(opaque, addr, size, &data);
}
| 818 |
qemu | b9bec74bcb16519a876ec21cd5277c526a9b512d | 0 | static int kvm_put_fpu(CPUState *env)
{
struct kvm_fpu fpu;
int i;
memset(&fpu, 0, sizeof fpu);
fpu.fsw = env->fpus & ~(7 << 11);
fpu.fsw |= (env->fpstt & 7) << 11;
fpu.fcw = env->fpuc;
for (i = 0; i < 8; ++i)
fpu.ftwx |= (!env->fptags[i]) << i;
memcpy(fpu.fpr, env->fpregs, ... | 819 |
qemu | e612a1f7256bb3546cf3e9ae6cad3997c4153663 | 1 | target_read_memory (bfd_vma memaddr,
bfd_byte *myaddr,
int length,
struct disassemble_info *info)
{
int i;
for(i = 0; i < length; i++) {
myaddr[i] = ldub_code(memaddr + i);
}
return 0;
}
| 820 |
FFmpeg | d176f9038711e497b32f1431e60e4e3da94179d1 | 1 | static int http_connect(URLContext *h, const char *path, const char *hoststr,
const char *auth, int *new_location)
{
HTTPContext *s = h->priv_data;
int post, err, ch;
char line[1024], *q;
char *auth_b64;
int auth_b64_len = strlen(auth)* 4 / 3 + 12;
int64_t off = s... | 821 |
qemu | bce6261eb2d879625126485d4ddd28cacb93152e | 1 | static void set_guest_connected(VirtIOSerialPort *port, int guest_connected)
{
VirtConsole *vcon = VIRTIO_CONSOLE(port);
DeviceState *dev = DEVICE(port);
if (vcon->chr) {
qemu_chr_fe_set_open(vcon->chr, guest_connected);
}
if (dev->id) {
qapi_event_send_vserport_change(de... | 822 |
qemu | 1e9b65bb1bad51735cab6c861c29b592dccabf0e | 1 | void error_setg_errno(Error **errp, int os_errno, const char *fmt, ...)
{
va_list ap;
char *msg;
int saved_errno = errno;
if (errp == NULL) {
return;
}
va_start(ap, fmt);
error_setv(errp, ERROR_CLASS_GENERIC_ERROR, fmt, ap);
va_end(ap);
if (os_errno != 0) {
... | 823 |
qemu | e12ed72e5c00dd3375b8bd107200e4d7e950276a | 1 | void bitmap_set(unsigned long *map, long start, long nr)
{
unsigned long *p = map + BIT_WORD(start);
const long size = start + nr;
int bits_to_set = BITS_PER_LONG - (start % BITS_PER_LONG);
unsigned long mask_to_set = BITMAP_FIRST_WORD_MASK(start);
while (nr - bits_to_set >= 0) {
*p |= mask_... | 824 |
qemu | b3c0bfb6f949d8f1c97f390f951c0bab3e703810 | 1 | static void vmdk_free_extents(BlockDriverState *bs)
{
int i;
BDRVVmdkState *s = bs->opaque;
for (i = 0; i < s->num_extents; i++) {
g_free(s->extents[i].l1_table);
g_free(s->extents[i].l2_cache);
g_free(s->extents[i].l1_backup_table);
}
g_free(s->extents);
}
| 825 |
qemu | 3eea5498ca501922520b3447ba94815bfc109743 | 1 | static void console_putchar(TextConsole *s, int ch)
{
TextCell *c;
int y1, i;
int x, y;
switch(s->state) {
case TTY_STATE_NORM:
switch(ch) {
case '\r': /* carriage return */
s->x = 0;
break;
case '\n': /* newline */
console_... | 826 |
qemu | 687db4ed2ecd5fd74c94fbb420482823cca4ab7e | 1 | static void blkverify_err(BlkverifyAIOCB *acb, const char *fmt, ...)
{
va_list ap;
va_start(ap, fmt);
fprintf(stderr, "blkverify: %s sector_num=%ld nb_sectors=%d ",
acb->is_write ? "write" : "read", acb->sector_num,
acb->nb_sectors);
vfprintf(stderr, fmt, ap);
fprin... | 827 |
FFmpeg | 258dfff8394d383beaa639d19912b3f068f67e16 | 1 | static void format_line(void *ptr, int level, const char *fmt, va_list vl,
char part[3][512], int part_size, int *print_prefix, int type[2])
{
AVClass* avc = ptr ? *(AVClass **) ptr : NULL;
part[0][0] = part[1][0] = part[2][0] = 0;
if(type) type[0] = type[1] = AV_CLASS_CATEGORY_... | 828 |
FFmpeg | dff5a8353266641311827a4bbdd940f7ad08c8b6 | 0 | find_c_packed_planar_out_funcs(SwsContext *c,
yuv2planar1_fn *yuv2yuv1, yuv2planarX_fn *yuv2yuvX,
yuv2packed1_fn *yuv2packed1, yuv2packed2_fn *yuv2packed2,
yuv2packedX_fn *yuv2packedX)
{
enum PixelFormat dstFormat =... | 829 |
FFmpeg | f777504f640260337974848c7d5d7a3f064bbb45 | 0 | static av_always_inline void h264_filter_mb_fast_internal(H264Context *h,
int mb_x, int mb_y,
uint8_t *img_y,
uint8_t *img_cb,
... | 830 |
FFmpeg | d7e9533aa06f4073a27812349b35ba5fede11ca1 | 1 | static int h263_decode_init(AVCodecContext *avctx)
{
MpegEncContext *s = avctx->priv_data;
int i;
s->avctx = avctx;
s->out_format = FMT_H263;
s->width = avctx->width;
s->height = avctx->height;
/* select sub codec */
switch(avctx->codec->id) {
case CODEC_ID_H263:
... | 831 |
FFmpeg | 4b6bfbe2b70ea87831fa9a42a2ac112ee8a386d2 | 1 | static int spdif_write_packet(struct AVFormatContext *s, AVPacket *pkt)
{
IEC958Context *ctx = s->priv_data;
int ret, padding;
ctx->out_bytes = pkt->size;
ctx->length_code = FFALIGN(pkt->size, 2) << 3;
ret = ctx->header_info(s, pkt);
if (ret < 0)
return -1;
if (!ctx->pk... | 832 |
qemu | 05cc758a3dfc79488d0a8eb7f5830a41871e78d0 | 1 | static void blkverify_refresh_filename(BlockDriverState *bs, QDict *options)
{
BDRVBlkverifyState *s = bs->opaque;
/* bs->file->bs has already been refreshed */
bdrv_refresh_filename(s->test_file->bs);
if (bs->file->bs->full_open_options
&& s->test_file->bs->full_open_options)
{
... | 833 |
FFmpeg | b84675d63aaede8f6944b901250a10456c5477e6 | 0 | static int ffmmal_read_frame(AVCodecContext *avctx, AVFrame *frame, int *got_frame)
{
MMALDecodeContext *ctx = avctx->priv_data;
MMAL_BUFFER_HEADER_T *buffer = NULL;
MMAL_STATUS_T status = 0;
int ret = 0;
if (ctx->eos_received)
goto done;
while (1) {
// To ensure dec... | 834 |
FFmpeg | e0c6cce44729d94e2a5507a4b6d031f23e8bd7b6 | 0 | void ff_sbrdsp_init_x86(SBRDSPContext *s)
{
if (HAVE_YASM) {
int mm_flags = av_get_cpu_flags();
if (mm_flags & AV_CPU_FLAG_SSE) {
s->sum_square = ff_sbr_sum_square_sse;
s->hf_g_filt = ff_sbr_hf_g_filt_sse;
}
}
}
| 835 |
qemu | c4c0e236beabb9de5ff472f77aeb811ec5484615 | 1 | static int usb_host_handle_control(USBHostDevice *s, USBPacket *p)
{
struct usbdevfs_urb *urb;
AsyncURB *aurb;
int ret, value, index;
/*
* Process certain standard device requests.
* These are infrequent and are processed synchronously.
*/
value = le16_to_cpu(s->ctrl.req.w... | 836 |
qemu | 2ba154cf4eb8636cdd3aa90f392ca9e77206ca39 | 1 | static void pc_init1(MachineState *machine)
{
PCMachineState *pc_machine = PC_MACHINE(machine);
MemoryRegion *system_memory = get_system_memory();
MemoryRegion *system_io = get_system_io();
int i;
ram_addr_t below_4g_mem_size, above_4g_mem_size;
PCIBus *pci_bus;
ISABus *isa_bus;
... | 839 |
qemu | 74f24cb6306d065045d0e2215a7d10533fa59c57 | 1 | static void parse_type_int64(Visitor *v, const char *name, int64_t *obj,
Error **errp)
{
StringInputVisitor *siv = to_siv(v);
if (!siv->string) {
error_setg(errp, QERR_INVALID_PARAMETER_TYPE, name ? name : "null",
"integer");
return;
... | 840 |
qemu | ac3107340fbb9422ea63ee5d6729775965e121fd | 1 | void qemu_chr_be_write(CharDriverState *s, uint8_t *buf, int len)
{
s->chr_read(s->handler_opaque, buf, len);
}
| 841 |
qemu | c9262e8a84a29f22fbb5edde5d17f4f6166d5ae1 | 1 | static void virtio_set_status(struct subchannel_id schid,
unsigned long dev_addr)
{
unsigned char status = dev_addr;
if (run_ccw(schid, CCW_CMD_WRITE_STATUS, &status, sizeof(status))) {
virtio_panic("Could not write status to host!\n");
}
}
| 842 |
qemu | 206ae74aea5593f5f5bad769a6b4f101f17bc6fd | 1 | uint32_t do_arm_semihosting(CPUState *env)
{
target_ulong args;
char * s;
int nr;
uint32_t ret;
uint32_t len;
#ifdef CONFIG_USER_ONLY
TaskState *ts = env->opaque;
#else
CPUState *ts = env;
#endif
nr = env->regs[0];
args = env->regs[1];
switch (nr) {
case SYS_... | 843 |
qemu | 233aa5c2d1cf4655ffe335025a68cf5454f87dad | 1 | int inet_connect(const char *str, Error **errp)
{
QemuOpts *opts;
int sock = -1;
opts = qemu_opts_create(&dummy_opts, NULL, 0, NULL);
if (inet_parse(opts, str) == 0) {
sock = inet_connect_opts(opts, true, NULL, errp);
} else {
error_set(errp, QERR_SOCKET_CREATE_FAILED);
... | 844 |
qemu | 885b7c44e4f8b7a012a92770a0dba8b238662caa | 1 | static void do_interrupt_user(CPUX86State *env, int intno, int is_int,
int error_code, target_ulong next_eip)
{
SegmentCache *dt;
target_ulong ptr;
int dpl, cpl, shift;
uint32_t e2;
dt = &env->idt;
if (env->hflags & HF_LMA_MASK) {
shift = 4;
... | 845 |
qemu | 3ad9fd5a257794d516db515c217c78a5806112fe | 1 | static int64_t load_kernel(void)
{
int64_t entry, kernel_high;
long kernel_size, initrd_size, params_size;
ram_addr_t initrd_offset;
uint32_t *params_buf;
int big_endian;
#ifdef TARGET_WORDS_BIGENDIAN
big_endian = 1;
#else
big_endian = 0;
#endif
kernel_size = load_elf(loade... | 846 |
FFmpeg | 48d6556dd46d4f4fac10d0f4a819e314887cd50e | 1 | static int cin_read_frame_header(CinDemuxContext *cin, AVIOContext *pb) {
CinFrameHeader *hdr = &cin->frame_header;
hdr->video_frame_type = avio_r8(pb);
hdr->audio_frame_type = avio_r8(pb);
hdr->pal_colors_count = avio_rl16(pb);
hdr->video_frame_size = avio_rl32(pb);
hdr->audio_frame_siz... | 847 |
qemu | 2ad645d2854746b55ddfd1d8e951f689cca5d78f | 1 | static void test_endianness_combine(gconstpointer data)
{
const TestCase *test = data;
char *args;
args = g_strdup_printf("-display none -M %s%s%s -device pc-testdev",
test->machine,
test->superio ? " -device " : "",
t... | 849 |
FFmpeg | 210461c0a83a5625560fa1d92229200dc7fb869b | 0 | int avpicture_deinterlace(AVPicture *dst, const AVPicture *src,
enum AVPixelFormat pix_fmt, int width, int height)
{
int i;
if (pix_fmt != AV_PIX_FMT_YUV420P &&
pix_fmt != AV_PIX_FMT_YUVJ420P &&
pix_fmt != AV_PIX_FMT_YUV422P &&
pix_fmt != AV_PIX_FMT_YUV... | 851 |
FFmpeg | a1926a29fb4325afa46842883f197c74d4535c36 | 0 | static void chroma_mc(HEVCContext *s, int16_t *dst1, int16_t *dst2,
ptrdiff_t dststride, AVFrame *ref, const Mv *mv,
int x_off, int y_off, int block_w, int block_h)
{
HEVCLocalContext *lc = &s->HEVClc;
uint8_t *src1 = ref->data[1];
uint8_t *src2 ... | 852 |
FFmpeg | ec23a47286a9be0ca67b78f4d8b9d87220c18286 | 0 | static void mpegts_push_data(void *opaque,
const uint8_t *buf, int buf_size, int is_start)
{
PESContext *pes = opaque;
MpegTSContext *ts = pes->stream->priv_data;
AVStream *st;
const uint8_t *p;
int len, code, codec_type, codec_id;
if (is_start) {
... | 853 |
qemu | 0280b3eb7c0519b43452c05cf51f8777d9e38975 | 1 | static bool gscb_needed(void *opaque)
{
return kvm_s390_get_gs();
}
| 856 |
qemu | e864cabdc0a38bb598ddcf88b264896dc6f3e3b2 | 1 | void do_fctiw (void)
{
union {
double d;
uint64_t i;
} p;
/* XXX: higher bits are not supposed to be significant.
* to make tests easier, return the same as a real PowerPC 750 (aka G3)
*/
p.i = float64_to_int32(FT0, &env->fp_status);
p.i |= 0xFFF80000ULL << ... | 857 |
qemu | b45c03f585ea9bb1af76c73e82195418c294919d | 1 | static struct omap_mpu_timer_s *omap_mpu_timer_init(MemoryRegion *system_memory,
hwaddr base,
qemu_irq irq, omap_clk clk)
{
struct omap_mpu_timer_s *s = (struct omap_mpu_timer_s *)
g_malloc0(sizeof(struct omap_mpu_timer_s));
s->irq = irq;
s->clk = clk;
... | 858 |
FFmpeg | 97af2faaba70c866ae4c11459a79a16d4a014530 | 1 | static int libopenjpeg_encode_frame(AVCodecContext *avctx, AVPacket *pkt,
const AVFrame *frame, int *got_packet)
{
LibOpenJPEGContext *ctx = avctx->priv_data;
opj_cinfo_t *compress = ctx->compress;
opj_image_t *image = ctx->image;
opj_cio_t *stream = ctx-... | 861 |
qemu | 23994a5f524aa575c7a4b2e5250f17b127d2cf2f | 1 | static void termsig_handler(int signum)
{
state = TERMINATE;
qemu_notify_event();
}
| 862 |
qemu | 9de68637dff05a18d0eafcff2737e551b70bc490 | 1 | static int qxl_post_load(void *opaque, int version)
{
PCIQXLDevice* d = opaque;
uint8_t *ram_start = d->vga.vram_ptr;
QXLCommandExt *cmds;
int in, out, newmode;
assert(d->last_release_offset < d->vga.vram_size);
if (d->last_release_offset == 0) {
d->last_release = NULL;
} ... | 864 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.