id int64 80 27.2k | text stringlengths 48 60.4k | label bool 2
classes | project stringclasses 2
values | commit_id stringlengths 40 40 |
|---|---|---|---|---|
6,707 | static int roq_probe(AVProbeData *p)
{
if (p->buf_size < 6)
return 0;
if ((AV_RL16(&p->buf[0]) != RoQ_MAGIC_NUMBER) ||
(AV_RL32(&p->buf[2]) != 0xFFFFFFFF))
return 0;
return AVPROBE_SCORE_MAX;
}
| false | FFmpeg | 87e8788680e16c51f6048af26f3f7830c35207a5 |
8,119 | static av_cold int che_configure(AACContext *ac,
enum ChannelPosition che_pos,
int type, int id, int *channels)
{
if (*channels >= MAX_CHANNELS)
return AVERROR_INVALIDDATA;
if (che_pos) {
if (!ac->che[type][id]) {
... | true | FFmpeg | b99ca863506f0630514921b740b78364de67a3ff |
6,593 | void pci_device_hot_add(Monitor *mon, const QDict *qdict, QObject **ret_data)
{
PCIDevice *dev = NULL;
const char *pci_addr = qdict_get_str(qdict, "pci_addr");
const char *type = qdict_get_str(qdict, "type");
const char *opts = qdict_get_try_str(qdict, "opts");
/* strip legacy tag */
if... | false | qemu | ba14414174b72fa231997243a9650feaa520d054 |
11,491 | void tcg_target_qemu_prologue(TCGContext *s)
{
/* stmdb sp!, { r9 - r11, lr } */
tcg_out32(s, (COND_AL << 28) | 0x092d4e00);
tcg_out_bx(s, COND_AL, TCG_REG_R0);
tb_ret_addr = s->code_ptr;
/* ldmia sp!, { r9 - r11, pc } */
tcg_out32(s, (COND_AL << 28) | 0x08bd8e00);
}
| true | qemu | 4e17eae9f2ee49833698aae2753c5bb041510870 |
23,579 | static void vp8_decode_mb_row_no_filter(AVCodecContext *avctx, void *tdata,
int jobnr, int threadnr)
{
decode_mb_row_no_filter(avctx, tdata, jobnr, threadnr, 0);
}
| true | FFmpeg | 7b5ff7d57355dc608f0fd86e3ab32a2fda65e752 |
21,557 | static void v9fs_synth_fill_statbuf(V9fsSynthNode *node, struct stat *stbuf)
{
stbuf->st_dev = 0;
stbuf->st_ino = node->attr->inode;
stbuf->st_mode = node->attr->mode;
stbuf->st_nlink = node->attr->nlink;
stbuf->st_uid = 0;
stbuf->st_gid = 0;
stbuf->st_rdev = 0;
stbuf->st_size =... | false | qemu | 364031f17932814484657e5551ba12957d993d7e |
4,554 | int ff_intel_h263_decode_picture_header(MpegEncContext *s)
{
int format;
/* picture header */
if (get_bits_long(&s->gb, 22) != 0x20) {
av_log(s->avctx, AV_LOG_ERROR, "Bad picture start code\n");
return -1;
}
s->picture_number = get_bits(&s->gb, 8); /* picture timestamp */
... | false | FFmpeg | cc229d4e83889d1298f1a0863b55feec6c5c339a |
11,730 | static int write_skip_frames(AVFormatContext *s, int stream_index, int64_t dts)
{
AVIStream *avist = s->streams[stream_index]->priv_data;
AVCodecContext *enc = s->streams[stream_index]->codec;
av_dlog(s, "dts:%s packet_count:%d stream_index:%d\n", av_ts2str(dts), avist->packet_count, stream_index);... | false | FFmpeg | 229843aa359ae0c9519977d7fa952688db63f559 |
17,840 | static void body(uint32_t ABCD[4], uint32_t X[16])
{
int i av_unused;
uint32_t t;
uint32_t a = ABCD[3];
uint32_t b = ABCD[2];
uint32_t c = ABCD[1];
uint32_t d = ABCD[0];
#if HAVE_BIGENDIAN
for (i = 0; i < 16; i++)
X[i] = av_bswap32(X[i]);
#endif
#if CONFIG_SMALL
... | false | FFmpeg | a67304d05f11b2377bf157a356d7ebb00f3e06dd |
2,441 | static void vp6_build_huff_tree(VP56Context *s, uint8_t coeff_model[],
const uint8_t *map, unsigned size, VLC *vlc)
{
Node nodes[2*size], *tmp = &nodes[size];
int a, b, i;
/* first compute probabilities from model */
tmp[0].count = 256;
for (i=0; i<size-1; i+... | true | FFmpeg | 0a41faa9a77dc83d8d933e99f1ba902ecd146e79 |
17,847 | static bool ohci_eof_timer_needed(void *opaque)
{
OHCIState *ohci = opaque;
return ohci->eof_timer != NULL;
}
| true | qemu | fa1298c2d623522eda7b4f1f721fcb935abb7360 |
15,741 | static void cirrus_mem_writeb_mode4and5_16bpp(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-... | true | qemu | b2eb849d4b1fdb6f35d5c46958c7f703cf64cfef |
7,544 | void vnc_jobs_consume_buffer(VncState *vs)
{
bool flush;
vnc_lock_output(vs);
if (vs->jobs_buffer.offset) {
if (vs->ioc != NULL && buffer_empty(&vs->output)) {
if (vs->ioc_tag) {
g_source_remove(vs->ioc_tag);
vs->ioc_tag = qio_channel_add_watch(
... | true | qemu | ada8d2e4369ea49677d8672ac81bce73eefd5b54 |
24,487 | static int sdp_parse_rtpmap(AVFormatContext *s,
AVStream *st, RTSPStream *rtsp_st,
int payload_type, const char *p)
{
AVCodecContext *codec = st->codec;
char buf[256];
int i;
AVCodec *c;
const char *c_name;
/* See if we can handl... | true | FFmpeg | 078d43e23a7a3d64aafee8a58b380d3e139b3020 |
20,278 | static int execute_command(BlockDriverState *bdrv,
SCSIRequest *r, int direction,
BlockDriverCompletionFunc *complete)
{
r->io_header.interface_id = 'S';
r->io_header.dxfer_direction = direction;
r->io_header.dxferp = r->buf;
r->io_header.dxfer_len = r->buflen;
... | false | qemu | 7d78066926b68afe28a1948c64618ee085d9ab02 |
12,313 | static long do_sigreturn_v2(CPUARMState *env)
{
abi_ulong frame_addr;
struct sigframe_v2 *frame = NULL;
/*
* Since we stacked the signal on a 64-bit boundary,
* then 'sp' should be word aligned here. If it's
* not, then the user is trying to mess with us.
*/
frame_addr = ... | false | qemu | f0267ef7115656119bf00ed77857789adc036bda |
27,093 | static uint64_t imx_timerp_read(void *opaque, target_phys_addr_t offset,
unsigned size)
{
IMXTimerPState *s = (IMXTimerPState *)opaque;
DPRINTF("p-read(offset=%x)", offset >> 2);
switch (offset >> 2) {
case 0: /* Control Register */
DPRINTF("cr %x\n", s->... | false | qemu | a8170e5e97ad17ca169c64ba87ae2f53850dab4c |
6,676 | static QList *get_cpus(QDict **resp)
{
*resp = qmp("{ 'execute': 'query-cpus' }");
g_assert(*resp);
g_assert(qdict_haskey(*resp, "return"));
return qdict_get_qlist(*resp, "return");
}
| true | qemu | 5e39d89d20b17cf6fb7f09d181d34f17b2ae2160 |
19,349 | int tlb_set_page_exec(CPUState *env, target_ulong vaddr,
target_phys_addr_t paddr, int prot,
int mmu_idx, int is_softmmu)
{
PhysPageDesc *p;
unsigned long pd;
unsigned int index;
target_ulong address;
target_ulong code_address;
target_phys_add... | false | qemu | 72cf2d4f0e181d0d3a3122e04129c58a95da713e |
23,628 | yuv2rgb_1_c_template(SwsContext *c, const int16_t *buf0,
const int16_t *ubuf[2], const int16_t *vbuf[2],
const int16_t *abuf0, uint8_t *dest, int dstW,
int uvalpha, int y, enum PixelFormat target,
int hasAlpha)
{
const int16_t *ubuf... | true | FFmpeg | 9487fb4dea3498eb4711eb023f43199f68701b1e |
11,426 | 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;
const int field_pic= s->picture_structure != PICT_FRAME;
const int lowres= s->avctx->lowres;
s->... | false | FFmpeg | 52069c4d3c92f68605fadf012ab0da594ee9bae4 |
9,818 | long do_rt_sigreturn(CPUARMState *env)
{
struct target_rt_sigframe *frame = NULL;
abi_ulong frame_addr = env->xregs[31];
trace_user_do_rt_sigreturn(env, frame_addr);
if (frame_addr & 15) {
goto badframe;
}
if (!lock_user_struct(VERIFY_READ, frame, frame_addr, 1)) {
... | false | qemu | f0267ef7115656119bf00ed77857789adc036bda |
26,931 | static inline void vring_used_flags_set_bit(VirtQueue *vq, int mask)
{
VRingMemoryRegionCaches *caches = atomic_rcu_read(&vq->vring.caches);
VirtIODevice *vdev = vq->vdev;
hwaddr pa = offsetof(VRingUsed, flags);
uint16_t flags = virtio_lduw_phys_cached(vq->vdev, &caches->used, pa);
virtio_st... | true | qemu | e0e2d644096c79a71099b176d08f465f6803a8b1 |
9,288 | static int mov_read_keys(MOVContext *c, AVIOContext *pb, MOVAtom atom)
{
uint32_t count;
uint32_t i;
if (atom.size < 8)
return 0;
avio_skip(pb, 4);
count = avio_rb32(pb);
if (count > UINT_MAX / sizeof(*c->meta_keys)) {
av_log(c->fc, AV_LOG_ERROR,
"The... | true | FFmpeg | 347cb14b7cba7560e53f4434b419b9d8800253e7 |
19,920 | static void flat_print_int(WriterContext *wctx, const char *key, long long int value)
{
flat_print_key_prefix(wctx);
printf("%s=%lld\n", key, value);
}
| false | FFmpeg | 01e4537f66c6d054f8c7bdbdd5b3cfb4220d12fe |
9,188 | int kvmppc_get_hypercall(CPUPPCState *env, uint8_t *buf, int buf_len)
{
uint32_t *hc = (uint32_t*)buf;
struct kvm_ppc_pvinfo pvinfo;
if (!kvmppc_get_pvinfo(env, &pvinfo)) {
memcpy(buf, pvinfo.hcall, buf_len);
return 0;
}
/*
* Fallback to always fail hypercalls regar... | true | qemu | 0ddbd0536296f5a36c8f225edd4d14441be6b153 |
20,756 | STATIC void DEF(put, 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 |
15,824 | void cris_mmu_flush_pid(CPUState *env, uint32_t pid)
{
target_ulong vaddr;
unsigned int idx;
uint32_t lo, hi;
uint32_t tlb_vpn;
int tlb_pid, tlb_g, tlb_v, tlb_k;
unsigned int set;
unsigned int mmu;
pid &= 0xff;
for (mmu = 0; mmu < 2; mmu++) {
for (set = 0; set < 4; set++)
{
for (idx = 0; ... | false | qemu | 80e1b265f4505149ba256ab6e18be942830072d0 |
2,779 | static void free_ahci_device(QPCIDevice *dev)
{
QPCIBus *pcibus = dev ? dev->bus : NULL;
/* libqos doesn't have a function for this, so free it manually */
g_free(dev);
qpci_free_pc(pcibus);
}
| true | qemu | 9a75b0a037e3a8030992244353f17b62f6daf2ab |
10,702 | float64 HELPER(ucf64_subd)(float64 a, float64 b, CPUUniCore32State *env)
{
return float64_sub(a, b, &env->ucf64.fp_status);
}
| false | qemu | e8ede0a8bb5298a6979bcf7ed84ef64a64a4e3fe |
15,412 | static void pc_xen_hvm_init(QEMUMachineInitArgs *args)
{
if (xen_hvm_init() != 0) {
hw_error("xen hardware virtual machine initialisation failed");
}
pc_init_pci(args);
}
| false | qemu | a97d6fe6fbb97630d77253d20bdce78f76d01850 |
5,814 | Visitor *qmp_output_visitor_new(QObject **result)
{
QmpOutputVisitor *v;
v = g_malloc0(sizeof(*v));
v->visitor.type = VISITOR_OUTPUT;
v->visitor.start_struct = qmp_output_start_struct;
v->visitor.end_struct = qmp_output_end_struct;
v->visitor.start_list = qmp_output_start_list;
v... | false | qemu | 7d5e199ade76c53ec316ab6779800581bb47c50a |
7,801 | i2c_bus *i2c_init_bus(DeviceState *parent, const char *name)
{
i2c_bus *bus;
bus = FROM_QBUS(i2c_bus, qbus_create(BUS_TYPE_I2C, sizeof(i2c_bus),
parent, name));
register_savevm("i2c_bus", -1, 1, i2c_bus_save, i2c_bus_load, bus);
return bus;
}
| false | qemu | 10c4c98ab7dc18169b37b76f6ea5e60ebe65222b |
11,835 | static void entropy_decode(APEContext *ctx, int blockstodecode, int stereo)
{
int32_t *decoded0 = ctx->decoded[0];
int32_t *decoded1 = ctx->decoded[1];
while (blockstodecode--) {
*decoded0++ = ape_decode_value(ctx, &ctx->riceY);
if (stereo)
*decoded1++ = ape_decode_value... | false | FFmpeg | b164d66e35d349de414e2f0d7365a147aba8a620 |
10,318 | static void gen_mtc0 (DisasContext *ctx, int reg, int sel)
{
const char *rn = "invalid";
switch (reg) {
case 0:
switch (sel) {
case 0:
gen_op_mtc0_index();
rn = "Index";
break;
case 1:
// gen_op_mtc0_mvpcontrol(); /* MT ASE *... | false | qemu | 3a95e3a7d9a6fd7610fe483778ff7016d23be5ec |
16,564 | static uint64_t memory_region_dispatch_read1(MemoryRegion *mr,
hwaddr addr,
unsigned size)
{
uint64_t data = 0;
if (!memory_region_access_valid(mr, addr, size, false)) {
return -1U; /* FIXME: better signall... | false | qemu | b018ddf633f77195e9ae859c6d940a334e68879f |
24,383 | static int sofalizer_convolute(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
{
SOFAlizerContext *s = ctx->priv;
ThreadData *td = arg;
AVFrame *in = td->in, *out = td->out;
int offset = jobnr;
int *write = &td->write[jobnr];
const int *const delay = td->delay[jobnr];
const ... | true | FFmpeg | 21234c835d2d003d390d462b6e1b2622e7b02c39 |
27,022 | static av_cold int twin_decode_close(AVCodecContext *avctx)
{
TwinContext *tctx = avctx->priv_data;
int i;
for (i = 0; i < 3; i++) {
ff_mdct_end(&tctx->mdct_ctx[i]);
av_free(tctx->cos_tabs[i]);
}
av_free(tctx->curr_frame);
av_free(tctx->spectrum);
av_free(tctx... | true | FFmpeg | a8a6da4a0e059b2aab66627a96b63c3632c477c2 |
2,479 | static void img_copy(uint8_t *dst, int dst_wrap,
uint8_t *src, int src_wrap,
int width, int height)
{
for(;height > 0; height--) {
memcpy(dst, src, width);
dst += dst_wrap;
src += src_wrap;
}
}
| false | FFmpeg | 7e7e59409294af9caa63808e56c5cc824c98b4fc |
2,170 | static uint64_t exynos4210_pwm_read(void *opaque, target_phys_addr_t offset,
unsigned size)
{
Exynos4210PWMState *s = (Exynos4210PWMState *)opaque;
uint32_t value = 0;
int index;
switch (offset) {
case TCFG0: case TCFG1:
index = (offset - TCFG0) >> 2;
value = s->re... | false | qemu | a8170e5e97ad17ca169c64ba87ae2f53850dab4c |
26,500 | static inline void gen_neon_widen(TCGv_i64 dest, TCGv src, int size, int u)
{
if (u) {
switch (size) {
case 0: gen_helper_neon_widen_u8(dest, src); break;
case 1: gen_helper_neon_widen_u16(dest, src); break;
case 2: tcg_gen_extu_i32_i64(dest, src); break;
default: abor... | true | qemu | 7d1b0095bff7157e856d1d0e6c4295641ced2752 |
14,784 | static void rng_egd_free_requests(RngEgd *s)
{
GSList *i;
for (i = s->parent.requests; i; i = i->next) {
rng_egd_free_request(i->data);
}
g_slist_free(s->parent.requests);
s->parent.requests = NULL;
}
| false | qemu | 9f14b0add1dcdbfa2ee61051d068211fb0a1fcc9 |
23,139 | static void simple_whitespace(void)
{
int i;
struct {
const char *encoded;
LiteralQObject decoded;
} test_cases[] = {
{
.encoded = " [ 43 , 42 ]",
.decoded = QLIT_QLIST(((LiteralQObject[]){
QLIT_QINT(43),
... | false | qemu | 9eaaf971683c99ed197fa1b7d1a3ca9baabfb3ee |
23,989 | static int rocker_msix_init(Rocker *r)
{
PCIDevice *dev = PCI_DEVICE(r);
int err;
err = msix_init(dev, ROCKER_MSIX_VEC_COUNT(r->fp_ports),
&r->msix_bar,
ROCKER_PCI_MSIX_BAR_IDX, ROCKER_PCI_MSIX_TABLE_OFFSET,
&r->msix_bar,
... | true | qemu | ee640c625e190a0c0e6b8966adc0e4720fb75200 |
14,649 | static int coroutine_enter_func(void *arg)
{
Coroutine *co = arg;
qemu_coroutine_enter(co, NULL);
return 0;
}
| true | qemu | 0b8b8753e4d94901627b3e86431230f2319215c4 |
7,421 | static ssize_t qio_channel_file_writev(QIOChannel *ioc,
const struct iovec *iov,
size_t niov,
int *fds,
size_t nfds,
Err... | false | qemu | 30fd3e27907dfd1c0c66cc1339657af1a2ce1d4b |
16,589 | bool vfio_blacklist_opt_rom(VFIOPCIDevice *vdev)
{
PCIDevice *pdev = &vdev->pdev;
uint16_t vendor_id, device_id;
int count = 0;
vendor_id = pci_get_word(pdev->config + PCI_VENDOR_ID);
device_id = pci_get_word(pdev->config + PCI_DEVICE_ID);
while (count < ARRAY_SIZE(romblacklist)) {
... | false | qemu | 056dfcb695cde3c62b7dc1d5ed6d2e38b3a73e29 |
16,671 | Object *container_get(Object *root, const char *path)
{
Object *obj, *child;
gchar **parts;
int i;
parts = g_strsplit(path, "/", 0);
assert(parts != NULL && parts[0] != NULL && !parts[0][0]);
obj = root;
for (i = 1; parts[i] != NULL; i++, obj = child) {
child = object_re... | true | qemu | f8df5f922152a47b3889921d249e00dab766d950 |
24,840 | void audio_init(ISABus *isa_bus, PCIBus *pci_bus)
{
}
| false | qemu | ffa48cf5ab719e1e181e51b87bc0f5d397b791fa |
27,191 | abi_ulong mmap_find_vma(abi_ulong start, abi_ulong size)
{
void *ptr, *prev;
abi_ulong addr;
int wrapped, repeat;
/* If 'start' == 0, then a default start address is used. */
if (start == 0) {
start = mmap_next_start;
} else {
start &= qemu_host_page_mask;
}
... | false | qemu | d0b3e4f5f4a29d48250887e5c0b3c65bc4dc6d13 |
19,578 | static void test_visitor_out_any(TestOutputVisitorData *data,
const void *unused)
{
QObject *qobj;
QInt *qint;
QBool *qbool;
QString *qstring;
QDict *qdict;
QObject *obj;
qobj = QOBJECT(qint_from_int(-42));
visit_type_any(data->ov, NULL, &qobj... | false | qemu | 0abfc4b885566eb41c3a4e1de5e2e105bdc062d9 |
80 | void bdrv_error_action(BlockDriverState *bs, BlockErrorAction action,
bool is_read, int error)
{
assert(error >= 0);
bdrv_emit_qmp_error_event(bs, QEVENT_BLOCK_IO_ERROR, action, is_read);
if (action == BDRV_ACTION_STOP) {
vm_stop(RUN_STATE_IO_ERROR);
bdrv_iostat... | true | qemu | 2bd3bce8efebe86b031beab5c0e3b9bbaec0b502 |
20,276 | static void exynos4210_fimd_reset(DeviceState *d)
{
Exynos4210fimdState *s = EXYNOS4210_FIMD(d);
unsigned w;
DPRINT_TRACE("Display controller reset\n");
/* Set all display controller registers to 0 */
memset(&s->vidcon, 0, (uint8_t *)&s->window - (uint8_t *)&s->vidcon);
for (w = 0; w < ... | false | qemu | ef1e1e0782e99c9dcf2b35e5310cdd8ca9211374 |
3,247 | static int vp8_packet(AVFormatContext *s, int idx)
{
struct ogg *ogg = s->priv_data;
struct ogg_stream *os = ogg->streams + idx;
uint8_t *p = os->buf + os->pstart;
if ((!os->lastpts || os->lastpts == AV_NOPTS_VALUE) &&
!(os->flags & OGG_FLAG_EOS)) {
int seg;
int duratio... | true | FFmpeg | c5fd57f483d2ad8e34551b78509f1e14136f73c0 |
16,525 | static void blend_image_rgb_pm(AVFilterContext *ctx, AVFrame *dst, const AVFrame *src, int x, int y)
{
blend_image_packed_rgb(ctx, dst, src, 0, x, y, 1);
}
| false | FFmpeg | 6260ab60a80fd8baebf79f9ce9299b0db72333b5 |
3,937 | static void dp8393x_writew(void *opaque, target_phys_addr_t addr, uint32_t val)
{
dp8393xState *s = opaque;
int reg;
if ((addr & ((1 << s->it_shift) - 1)) != 0) {
return;
}
reg = addr >> s->it_shift;
write_register(s, reg, (uint16_t)val);
}
| false | qemu | a8170e5e97ad17ca169c64ba87ae2f53850dab4c |
9,500 | static float voice_factor(float *p_vector, float p_gain,
float *f_vector, float f_gain,
CELPMContext *ctx)
{
double p_ener = (double) ctx->dot_productf(p_vector, p_vector,
AMRWB_SFR_SIZE) *
... | true | FFmpeg | 1d0817d56b66797118880358ea7d7a2acfdca429 |
254 | static inline void h264_loop_filter_chroma_c(uint8_t *pix, int xstride, int ystride, int alpha, int beta, int8_t *tc0)
{
int i, d;
for( i = 0; i < 4; i++ ) {
const int tc = tc0[i];
if( tc <= 0 ) {
pix += 2*ystride;
continue;
}
for( d = 0; d < 2; d... | false | FFmpeg | 3f50965b28d0c4ef10dde0bf2f7a9f78fa36b378 |
17,298 | static int kvm_irqchip_get_virq(KVMState *s)
{
uint32_t *word = s->used_gsi_bitmap;
int max_words = ALIGN(s->gsi_count, 32) / 32;
int i, zeroes;
bool retry = true;
again:
/* Return the lowest unused GSI in the bitmap */
for (i = 0; i < max_words; i++) {
zeroes = ctz32(~word[i]... | true | qemu | bdf026317daa3b9dfa281f29e96fbb6fd48394c8 |
21,154 | static void flash_sync_page(Flash *s, int page)
{
QEMUIOVector *iov = g_new(QEMUIOVector, 1);
if (!s->blk || blk_is_read_only(s->blk)) {
return;
}
qemu_iovec_init(iov, 1);
qemu_iovec_add(iov, s->storage + page * s->pi->page_size,
s->pi->page_size);
blk_aio... | true | qemu | eef9f19eea26cd8b4553459118f87d7150b53c5a |
21,494 | char* qdev_get_fw_dev_path(DeviceState *dev)
{
char path[128];
int l;
l = qdev_get_fw_dev_path_helper(dev, path, 128);
path[l-1] = '\0';
return strdup(path);
}
| false | qemu | a5cf8262e4eb9c4646434e2c6211ef8608db3233 |
18,389 | static void skip_block (uint8_t *current, uint8_t *previous, int pitch, int x, int y) {
uint8_t *src;
uint8_t *dst;
int i;
src = &previous[x + y*pitch];
dst = current;
for (i=0; i < 16; i++) {
memcpy (dst, src, 16);
src += pitch;
dst += pitch;
}
}
| false | FFmpeg | 82dd7d0dec29ee59af91ce18c29eb151b363ff37 |
3,524 | static int hda_audio_post_load(void *opaque, int version)
{
HDAAudioState *a = opaque;
HDAAudioStream *st;
int i;
dprint(a, 1, "%s\n", __FUNCTION__);
if (version == 1) {
/* assume running_compat[] is for output streams */
for (i = 0; i < ARRAY_SIZE(a->running_compat); i++)
... | false | qemu | a89f364ae8740dfc31b321eed9ee454e996dc3c1 |
23,817 | static int v9fs_synth_truncate(FsContext *ctx, V9fsPath *path, off_t offset)
{
errno = ENOSYS;
return -1;
}
| false | qemu | 364031f17932814484657e5551ba12957d993d7e |
17,533 | void sws_freeContext(SwsContext *c)
{
int i;
if (!c) return;
if (c->lumPixBuf) {
for (i=0; i<c->vLumBufSize; i++)
av_freep(&c->lumPixBuf[i]);
av_freep(&c->lumPixBuf);
}
if (c->chrPixBuf) {
for (i=0; i<c->vChrBufSize; i++)
av_freep(&c->ch... | false | FFmpeg | f684f3c58a77a20f18b80f888d69c2bacb53ca9b |
23,080 | static int roq_decode_init(AVCodecContext *avctx)
{
RoqContext *s = avctx->priv_data;
s->avctx = avctx;
s->width = avctx->width;
s->height = avctx->height;
s->last_frame = &s->frames[0];
s->current_frame = &s->frames[1];
avctx->pix_fmt = PIX_FMT_YUV444P;
dsputil_init(&s->ds... | false | FFmpeg | 32c3047cac9294bb56d23c89a40a22409db5cc70 |
27,004 | static void kzm_init(MachineState *machine)
{
IMX31KZM *s = g_new0(IMX31KZM, 1);
unsigned int ram_size;
unsigned int alias_offset;
unsigned int i;
object_initialize(&s->soc, sizeof(s->soc), TYPE_FSL_IMX31);
object_property_add_child(OBJECT(machine), "soc", OBJECT(&s->soc),
... | false | qemu | 3dc6f8693694a649a9c83f1e2746565b47683923 |
19,708 | static void gen_exception(int excp)
{
TCGv tmp = new_tmp();
tcg_gen_movi_i32(tmp, excp);
gen_helper_exception(tmp);
dead_tmp(tmp);
}
| true | qemu | 7d1b0095bff7157e856d1d0e6c4295641ced2752 |
5,245 | static void uart_write(void *opaque, target_phys_addr_t addr, uint64_t value,
unsigned size)
{
MilkymistUartState *s = opaque;
unsigned char ch = value;
trace_milkymist_uart_memory_write(addr, value);
addr >>= 2;
switch (addr) {
case R_RXTX:
if (s->chr... | false | qemu | a8170e5e97ad17ca169c64ba87ae2f53850dab4c |
6,747 | static ssize_t mp_dacl_getxattr(FsContext *ctx, const char *path,
const char *name, void *value, size_t size)
{
char buffer[PATH_MAX];
return lgetxattr(rpath(ctx, path, buffer), MAP_ACL_DEFAULT, value, size);
}
| false | qemu | 4fa4ce7107c6ec432f185307158c5df91ce54308 |
11,938 | void qemu_add_balloon_handler(QEMUBalloonEvent *func, void *opaque)
{
balloon_event_fn = func;
balloon_opaque = opaque;
}
| true | qemu | 30fb2ca603e8b8d0f02630ef18bc0d0637a88ffa |
9,906 | static void virtio_queue_host_notifier_read(EventNotifier *n)
{
VirtQueue *vq = container_of(n, VirtQueue, host_notifier);
if (event_notifier_test_and_clear(n)) {
virtio_queue_notify_vq(vq);
}
}
| true | qemu | 344dc16fae0cb6a011aa5befffc8e7d520b11d5d |
27,035 | static void coroutine_fn wait_serialising_requests(BdrvTrackedRequest *self)
{
BlockDriverState *bs = self->bs;
BdrvTrackedRequest *req;
bool retry;
if (!bs->serialising_in_flight) {
return;
}
do {
retry = false;
QLIST_FOREACH(req, &bs->tracked_requests, lis... | true | qemu | 6460440f34c709461b84375cfd8a86b27d433225 |
12,683 | static void register_subpage(AddressSpaceDispatch *d, MemoryRegionSection *section)
{
subpage_t *subpage;
hwaddr base = section->offset_within_address_space
& TARGET_PAGE_MASK;
MemoryRegionSection *existing = phys_page_find(d->phys_map, base,
... | false | qemu | 53cb28cbfea038f8ad50132dc8a684e638c7d48b |
15,797 | static inline void gen_bcond(DisasContext *ctx, int type)
{
uint32_t bo = BO(ctx->opcode);
int l1;
TCGv target;
ctx->exception = POWERPC_EXCP_BRANCH;
if (type == BCOND_LR || type == BCOND_CTR || type == BCOND_TAR) {
target = tcg_temp_local_new();
if (type == BCOND_CTR)
... | false | qemu | 42a268c241183877192c376d03bd9b6d527407c7 |
13,174 | static inline void dv_decode_video_segment(DVVideoContext *s,
uint8_t *buf_ptr1,
const uint16_t *mb_pos_ptr)
{
int quant, dc, dct_mode, class1, j;
int mb_index, mb_x, mb_y, v, last_index;
DCTELEM *block, *block1;
... | false | FFmpeg | c619ff6daf93a8f3c03decf2d3345d2474c3db91 |
26,046 | static int QEMU_WARN_UNUSED_RESULT update_refcount(BlockDriverState *bs,
int64_t offset,
int64_t length,
uint64_t addend,
... | true | qemu | 7453c96b78c2b09aa72924f933bb9616e5474194 |
8,882 | void ff_rtp_send_h264(AVFormatContext *s1, const uint8_t *buf1, int size)
{
const uint8_t *r, *end = buf1 + size;
RTPMuxContext *s = s1->priv_data;
s->timestamp = s->cur_timestamp;
s->buf_ptr = s->buf;
if (s->nal_length_size)
r = ff_avc_mp4_find_startcode(buf1, end, s->nal_length_... | true | FFmpeg | c82bf15dca00f67a701d126e47ea9075fc9459cb |
6,542 | static void qxl_spice_destroy_surface_wait(PCIQXLDevice *qxl, uint32_t id,
qxl_async_io async)
{
if (async) {
#if SPICE_INTERFACE_QXL_MINOR < 1
abort();
#else
spice_qxl_destroy_surface_async(&qxl->ssd.qxl, id,
... | false | qemu | 4295e15aa730a95003a3639d6dad2eb1e65a59e2 |
7,175 | void tcg_dump_ops(TCGContext *s)
{
char buf[128];
TCGOp *op;
int oi;
for (oi = s->gen_op_buf[0].next; oi != 0; oi = op->next) {
int i, k, nb_oargs, nb_iargs, nb_cargs;
const TCGOpDef *def;
TCGOpcode c;
int col = 0;
op = &s->gen_op_buf[oi];
c... | true | qemu | 15fa08f8451babc88d733bd411d4c94976f9d0f8 |
23,205 | static inline void RENAME(rgb32to16)(const uint8_t *src, uint8_t *dst, unsigned src_size)
{
const uint8_t *s = src;
const uint8_t *end;
#ifdef HAVE_MMX
const uint8_t *mm_end;
#endif
uint16_t *d = (uint16_t *)dst;
end = s + src_size;
#ifdef HAVE_MMX
mm_end = end - 15;
#if 1 //is faster only if multiplie... | true | FFmpeg | 7f526efd17973ec6d2204f7a47b6923e2be31363 |
5,518 | static int gdb_handle_vcont(GDBState *s, const char *p)
{
int res, idx, signal = 0;
char cur_action;
char *newstates;
unsigned long tmp;
CPUState *cpu;
#ifdef CONFIG_USER_ONLY
int max_cpus = 1; /* global variable max_cpus exists only in system mode */
CPU_FOREACH(cpu) {
m... | true | qemu | 95a5befc2f8b359e72926f89cd661d063c2cf06c |
26,851 | static av_cold int v410_encode_close(AVCodecContext *avctx)
{
av_freep(&avctx->coded_frame);
return 0;
}
| false | FFmpeg | d6604b29ef544793479d7fb4e05ef6622bb3e534 |
23,445 | static void gen_exception(DisasContext *s, int trapno, target_ulong cur_eip)
{
gen_update_cc_op(s);
gen_jmp_im(cur_eip);
gen_helper_raise_exception(cpu_env, tcg_const_i32(trapno));
s->is_jmp = DISAS_TB_JUMP;
}
| false | qemu | 1e39d97af086d525cd0408eaa5d19783ea165906 |
1,327 | static int parse_times(void *log_ctx, int64_t **times, int *nb_times,
const char *times_str)
{
char *p;
int i, ret = 0;
char *times_str1 = av_strdup(times_str);
char *saveptr = NULL;
if (!times_str1)
return AVERROR(ENOMEM);
#define FAIL(err) ret = err; got... | true | FFmpeg | ad47ac20ae3e8ac52fa23f6fa520a3124cc515cd |
8,872 | static int synth_frame(AVCodecContext *ctx, GetBitContext *gb, int frame_idx,
float *samples,
const double *lsps, const double *prev_lsps,
float *excitation, float *synth)
{
WMAVoiceContext *s = ctx->priv_data;
int n, n_blocks_x2, log_n_... | true | FFmpeg | 96a08d8627301dae41a7697ea4346cc9981df17c |
26,786 | SocketAddress *socket_address_crumple(SocketAddressFlat *addr_flat)
{
SocketAddress *addr = g_new(SocketAddress, 1);
switch (addr_flat->type) {
case SOCKET_ADDRESS_FLAT_TYPE_INET:
addr->type = SOCKET_ADDRESS_KIND_INET;
addr->u.inet.data = QAPI_CLONE(InetSocketAddress,
... | false | qemu | dfd100f242370886bb6732f70f1f7cbd8eb9fedc |
23,081 | static inline void helper_ret_protected(CPUX86State *env, int shift,
int is_iret, int addend)
{
uint32_t new_cs, new_eflags, new_ss;
uint32_t new_es, new_ds, new_fs, new_gs;
uint32_t e1, e2, ss_e1, ss_e2;
int cpl, dpl, rpl, eflags_mask, iopl;
target_ulo... | false | qemu | 7848c8d19f8556666df25044bbd5d8b29439c368 |
351 | static void qdm2_fft_decode_tones (QDM2Context *q, int duration, GetBitContext *gb, int b)
{
int channel, stereo, phase, exp;
int local_int_4, local_int_8, stereo_phase, local_int_10;
int local_int_14, stereo_exp, local_int_20, local_int_28;
int n, offset;
local_int_4 = 0;
local_int_... | false | FFmpeg | 14db3af4f26dad8e6ddf2147e96ccc710952ad4d |
5,872 | int qemu_read_password(char *buf, int buf_size)
{
uint8_t ch;
int i, ret;
printf("password: ");
fflush(stdout);
term_init();
i = 0;
for (;;) {
ret = read(0, &ch, 1);
if (ret == -1) {
if (errno == EAGAIN || errno == EINTR) {
continue;
... | true | qemu | 788cf9f8c8cbda53843e060540f3e91a060eb744 |
16,998 | static av_cold int movie_common_init(AVFilterContext *ctx)
{
MovieContext *movie = ctx->priv;
AVInputFormat *iformat = NULL;
int64_t timestamp;
int nb_streams, ret, i;
char default_streams[16], *stream_specs, *spec, *cursor;
char name[16];
AVStream *st;
if (!*movie->file_name)... | false | FFmpeg | c679a1c358c30ec38ae3b1ac3ee2c62efc2f32e2 |
10,769 | static int flac_probe(AVProbeData *p)
{
uint8_t *bufptr = p->buf;
if(ff_id3v2_match(bufptr))
bufptr += ff_id3v2_tag_len(bufptr);
if(memcmp(bufptr, "fLaC", 4)) return 0;
else return AVPROBE_SCORE_MAX / 2;
}
| false | FFmpeg | 16f753f43fba3b9b16cb9fa62e99f481aaa29ae9 |
4,339 | static int audio_pcm_info_eq (struct audio_pcm_info *info, audsettings_t *as)
{
int bits = 8, sign = 0;
switch (as->fmt) {
case AUD_FMT_S8:
sign = 1;
case AUD_FMT_U8:
break;
case AUD_FMT_S16:
sign = 1;
case AUD_FMT_U16:
bits = 16;
break;
... | false | qemu | 1ea879e5580f63414693655fcf0328559cdce138 |
16,096 | const char *path(const char *name)
{
/* Only do absolute paths: quick and dirty, but should mostly be OK.
Could do relative by tracking cwd. */
if (!base || name[0] != '/')
return name;
return follow_path(base, name) ?: name;
}
| true | qemu | a516e72d60803cac3b81b3330db55983b080d8da |
25,211 | static QObject *parse_literal(JSONParserContext *ctxt, QList **tokens)
{
QObject *token, *obj;
QList *working = qlist_copy(*tokens);
token = qlist_pop(working);
if (token == NULL) {
goto out;
}
switch (token_get_type(token)) {
case JSON_STRING:
obj = QOBJECT(qst... | false | qemu | 65c0f1e9558c7c762cdb333406243fff1d687117 |
7,003 | static void virtio_gpu_resource_create_2d(VirtIOGPU *g,
struct virtio_gpu_ctrl_command *cmd)
{
pixman_format_code_t pformat;
struct virtio_gpu_simple_resource *res;
struct virtio_gpu_resource_create_2d c2d;
VIRTIO_GPU_FILL_CMD(c2d);
trace_virtio_gpu... | true | qemu | 9b7621bca2f70dc1a9815d50f05261296a8ae932 |
1,402 | static int av_read_frame_internal(AVFormatContext *s, AVPacket *pkt)
{
AVStream *st;
int len, ret;
for(;;) {
/* select current input stream component */
st = s->cur_st;
if (st) {
if (!st->parser) {
/* no parsing needed: we just output the packet... | true | FFmpeg | bcbecff13f2d9c8af19039fa82703efd4c04eb97 |
26,135 | uint8_t* ff_AMediaCodec_getOutputBuffer(FFAMediaCodec* codec, size_t idx, size_t *out_size)
{
uint8_t *ret = NULL;
JNIEnv *env = NULL;
jobject buffer = NULL;
JNI_GET_ENV_OR_RETURN(env, codec, NULL);
if (codec->has_get_i_o_buffer) {
buffer = (*env)->CallObjectMethod(env, codec->o... | true | FFmpeg | 224bb46fb857dab589597bdab302ba8ba012008c |
23,120 | static void pc_compat_2_0(MachineState *machine)
{
pc_compat_2_1(machine);
smbios_legacy_mode = true;
has_reserved_memory = false;
pc_set_legacy_acpi_data_size();
}
| false | qemu | 7102fa7073b2cefb33ab4012a11f15fbf297a74b |
19,672 | void visit_start_implicit_struct(Visitor *v, void **obj, size_t size,
Error **errp)
{
if (!error_is_set(errp) && v->start_implicit_struct) {
v->start_implicit_struct(v, obj, size, errp);
}
}
| true | qemu | 297a3646c2947ee64a6d42ca264039732c6218e0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.