project stringclasses 2
values | commit_id stringlengths 40 40 | target int64 0 1 | func stringlengths 26 142k | idx int64 0 27.3k |
|---|---|---|---|---|
qemu | 37f51384ae05bd50f83308339dbffa3e78404874 | 0 | static inline uint64_t vtd_get_slpte_addr(uint64_t slpte)
{
return slpte & VTD_SL_PT_BASE_ADDR_MASK(VTD_HOST_ADDRESS_WIDTH);
}
| 18,237 |
qemu | 57407ea44cc0a3d630b9b89a2be011f1955ce5c1 | 0 | static void open_eth_cleanup(NetClientState *nc)
{
}
| 18,239 |
qemu | 3d0be8a5c135dadcfbd68ed354007a8cece98849 | 0 | void HELPER(wsr_lbeg)(uint32_t v)
{
if (env->sregs[LBEG] != v) {
tb_invalidate_phys_page_range(
env->sregs[LEND] - 1, env->sregs[LEND], 0);
env->sregs[LBEG] = v;
}
}
| 18,240 |
qemu | 89777fd10fc3dd573c3b4d1b2efdd10af823c001 | 0 | void mips_cpu_do_interrupt(CPUState *cs)
{
#if !defined(CONFIG_USER_ONLY)
MIPSCPU *cpu = MIPS_CPU(cs);
CPUMIPSState *env = &cpu->env;
bool update_badinstr = 0;
target_ulong offset;
int cause = -1;
const char *name;
if (qemu_loglevel_mask(CPU_LOG_INT)
&& cs->exception_inde... | 18,241 |
qemu | afb30dde3ad71349fc65726946d58e5d3c61f8af | 0 | uri_resolve_relative (const char *uri, const char * base)
{
char *val = NULL;
int ret;
int ix;
int pos = 0;
int nbslash = 0;
int len;
URI *ref = NULL;
URI *bas = NULL;
char *bptr, *uptr, *vptr;
int remove_path = 0;
if ((uri == NULL) || (*uri == 0))
return NULL... | 18,242 |
qemu | a8170e5e97ad17ca169c64ba87ae2f53850dab4c | 0 | static uint64_t omap_sti_fifo_read(void *opaque, target_phys_addr_t addr,
unsigned size)
{
OMAP_BAD_REG(addr);
return 0;
}
| 18,243 |
qemu | 4f61927a41a098d06e642ffdea5fc285dc3a0e6b | 0 | static inline uint64_t hpet_calculate_diff(HPETTimer *t, uint64_t current)
{
if (t->config & HPET_TN_32BIT) {
uint32_t diff, cmp;
cmp = (uint32_t)t->cmp;
diff = cmp - (uint32_t)current;
diff = (int32_t)diff > 0 ? diff : (uint32_t)0;
return (uint64_t)diff;
} el... | 18,244 |
FFmpeg | bb321245777a89426aa2131887497bd5eead1d2e | 0 | static int mpc8_decode_frame(AVCodecContext * avctx, void *data,
int *got_frame_ptr, AVPacket *avpkt)
{
const uint8_t *buf = avpkt->data;
int buf_size = avpkt->size;
MPCContext *c = avctx->priv_data;
GetBitContext gb2, *gb = &gb2;
int i, j, k, ch, cnt, res, t;
... | 18,245 |
qemu | bdc3f61dec2f9c227235bb5f677a0272e1184c82 | 0 | int configure_accelerator(MachineState *ms)
{
const char *p;
char buf[10];
int ret;
bool accel_initialised = false;
bool init_failed = false;
AccelClass *acc = NULL;
p = qemu_opt_get(qemu_get_machine_opts(), "accel");
if (p == NULL) {
/* Use the default "accelerator",... | 18,246 |
qemu | 70a5afedd64c3f0d3b5feae6b40b30f3e8d13e4b | 0 | int bdrv_snapshot_goto(BlockDriverState *bs,
const char *snapshot_id,
Error **errp)
{
BlockDriver *drv = bs->drv;
int ret, open_ret;
int64_t len;
if (!drv) {
error_setg(errp, "Block driver is closed");
return -ENOMEDIUM;
}
... | 18,247 |
qemu | bc7c08a2c375acb7ae4d433054415588b176d34c | 0 | static void test_qemu_strtoull_negative(void)
{
const char *str = " \t -321";
char f = 'X';
const char *endptr = &f;
uint64_t res = 999;
int err;
err = qemu_strtoull(str, &endptr, 0, &res);
g_assert_cmpint(err, ==, 0);
g_assert_cmpint(res, ==, -321);
g_assert(endptr ==... | 18,248 |
qemu | a8170e5e97ad17ca169c64ba87ae2f53850dab4c | 0 | static void omap_clkdsp_write(void *opaque, target_phys_addr_t addr,
uint64_t value, unsigned size)
{
struct omap_mpu_state_s *s = (struct omap_mpu_state_s *) opaque;
uint16_t diff;
if (size != 2) {
return omap_badwidth_write16(opaque, addr, value);
}
... | 18,249 |
qemu | 6c01bf6c7ba7539460fcaeb99fbe1776ba137aa8 | 0 | uint64_t helper_frsqrte (uint64_t arg)
{
CPU_DoubleU fone, farg;
fone.ll = 0x3FF0000000000000ULL; /* 1.0 */
farg.ll = arg;
if (unlikely(float64_is_signaling_nan(farg.d))) {
/* sNaN reciprocal square root */
farg.ll = fload_invalid_op_excp(POWERPC_EXCP_FP_VXSNAN);
} else if ... | 18,250 |
qemu | 42a268c241183877192c376d03bd9b6d527407c7 | 0 | static void gen_compute_compact_branch(DisasContext *ctx, uint32_t opc,
int rs, int rt, int32_t offset)
{
int bcond_compute = 0;
TCGv t0 = tcg_temp_new();
TCGv t1 = tcg_temp_new();
if (ctx->hflags & MIPS_HFLAG_BMASK) {
#ifdef MIPS_DEBUG_DISAS
LOG_... | 18,251 |
qemu | 33577b47c64435fcc2a1bc01c7e82534256f1fc3 | 0 | int qemu_chr_fe_get_msgfd(CharDriverState *s)
{
int fd;
return (qemu_chr_fe_get_msgfds(s, &fd, 1) == 1) ? fd : -1;
}
| 18,252 |
qemu | 8e9b0d24fb986d4241ae3b77752eca5dab4cb486 | 0 | static void vnc_client_write_locked(void *opaque)
{
VncState *vs = opaque;
#ifdef CONFIG_VNC_SASL
if (vs->sasl.conn &&
vs->sasl.runSSF &&
!vs->sasl.waitWriteSSF) {
vnc_client_write_sasl(vs);
} else
#endif /* CONFIG_VNC_SASL */
{
#ifdef CONFIG_VNC_WS
if (vs->... | 18,253 |
qemu | 1dde716ed6719c341c1bfa427781f0715af90cbc | 0 | iscsi_aio_write16_cb(struct iscsi_context *iscsi, int status,
void *command_data, void *opaque)
{
IscsiAIOCB *acb = opaque;
trace_iscsi_aio_write16_cb(iscsi, status, acb, acb->canceled);
g_free(acb->buf);
acb->buf = NULL;
if (acb->canceled != 0) {
return;
... | 18,255 |
qemu | e1833e1f96456fd8fc17463246fe0b2050e68efb | 0 | static void spr_write_40x_sler (void *opaque, int sprn)
{
DisasContext *ctx = opaque;
gen_op_store_40x_sler();
/* We must stop the translation as we may have changed
* some regions endianness
*/
RET_STOP(ctx);
}
| 18,256 |
qemu | 80b7a265362c870f95fb5ca1f7e7a02c0fa0db3e | 0 | static void sclp_execute(SCLPDevice *sclp, SCCB *sccb, uint32_t code)
{
SCLPDeviceClass *sclp_c = SCLP_GET_CLASS(sclp);
SCLPEventFacility *ef = sclp->event_facility;
SCLPEventFacilityClass *efc = EVENT_FACILITY_GET_CLASS(ef);
switch (code & SCLP_CMD_CODE_MASK) {
case SCLP_CMDW_READ_SCP_INFO:... | 18,258 |
qemu | 6e5c4540d18d1e9a5253104df161a7e0d408ca95 | 0 | static void smbios_build_type_0_fields(const char *t)
{
char buf[1024];
unsigned char major, minor;
if (get_param_value(buf, sizeof(buf), "vendor", t))
smbios_add_field(0, offsetof(struct smbios_type_0, vendor_str),
buf, strlen(buf) + 1);
if (get_param_value(buf... | 18,259 |
qemu | 0923c577f993d61eeaf41f66db1e1010fa113976 | 0 | truncate_f(int argc, char **argv)
{
int64_t offset;
int ret;
offset = cvtnum(argv[1]);
if (offset < 0) {
printf("non-numeric truncate argument -- %s\n", argv[1]);
return 0;
}
ret = bdrv_truncate(bs, offset);
if (ret < 0) {
printf("truncate: %s", strerror(ret));
return 0;
}
return 0;... | 18,260 |
qemu | e3dd74934f2d2c8c67083995928ff68e8c1d0030 | 0 | static inline void *host_from_stream_offset(QEMUFile *f,
ram_addr_t offset,
int flags)
{
static RAMBlock *block = NULL;
char id[256];
uint8_t len;
if (flags & RAM_SAVE_FLAG_CONTINUE) {
if (!block ||... | 18,261 |
qemu | 5d1abf234462d13bef3617cc2c55b6815703ddf2 | 0 | int mpcifc_service_call(S390CPU *cpu, uint8_t r1, uint64_t fiba, uint8_t ar)
{
CPUS390XState *env = &cpu->env;
uint8_t oc, dmaas;
uint32_t fh;
ZpciFib fib;
S390PCIBusDevice *pbdev;
uint64_t cc = ZPCI_PCI_LS_OK;
if (env->psw.mask & PSW_MASK_PSTATE) {
program_interrupt(env, ... | 18,262 |
qemu | ca5c1457d614fec718aaec7bdf3663dec37e1e50 | 0 | static void s390_cpu_plug(HotplugHandler *hotplug_dev,
DeviceState *dev, Error **errp)
{
gchar *name;
S390CPU *cpu = S390_CPU(dev);
CPUState *cs = CPU(dev);
name = g_strdup_printf("cpu[%i]", cpu->env.cpu_num);
object_property_set_link(OBJECT(hotplug_dev), OBJECT(cs),... | 18,263 |
qemu | 42a268c241183877192c376d03bd9b6d527407c7 | 0 | static void gen_maskg(DisasContext *ctx)
{
int l1 = gen_new_label();
TCGv t0 = tcg_temp_new();
TCGv t1 = tcg_temp_new();
TCGv t2 = tcg_temp_new();
TCGv t3 = tcg_temp_new();
tcg_gen_movi_tl(t3, 0xFFFFFFFF);
tcg_gen_andi_tl(t0, cpu_gpr[rB(ctx->opcode)], 0x1F);
tcg_gen_andi_tl(t1, ... | 18,264 |
qemu | 1c46efaa0a175e468772405385ca26a1e35dd94c | 0 | uint64_t qcow2_get_cluster_offset(BlockDriverState *bs, uint64_t offset,
int *num)
{
BDRVQcowState *s = bs->opaque;
unsigned int l1_index, l2_index;
uint64_t l2_offset, *l2_table, cluster_offset;
int l1_bits, c;
unsigned int index_in_cluster, nb_clusters;
uint64_t nb_available, nb_ne... | 18,265 |
qemu | 2bcf018340cbf233f7145e643fc1bb367f23fd90 | 0 | static bool lowprot_enabled(const CPUS390XState *env)
{
if (!(env->cregs[0] & CR0_LOWPROT)) {
return false;
}
if (!(env->psw.mask & PSW_MASK_DAT)) {
return true;
}
/* Check the private-space control bit */
switch (env->psw.mask & PSW_MASK_ASC) {
case PSW_ASC_PRIMA... | 18,266 |
qemu | ad196a9d0c14f681f010bb4b979030ec125ba976 | 0 | static int net_slirp_init(VLANState *vlan, const char *model, const char *name,
int restricted, const char *ip)
{
if (slirp_in_use) {
/* slirp only supports a single instance so far */
return -1;
}
if (!slirp_inited) {
slirp_inited = 1;
slir... | 18,269 |
qemu | a8170e5e97ad17ca169c64ba87ae2f53850dab4c | 0 | static uint64_t hpdmc_read(void *opaque, target_phys_addr_t addr,
unsigned size)
{
MilkymistHpdmcState *s = opaque;
uint32_t r = 0;
addr >>= 2;
switch (addr) {
case R_SYSTEM:
case R_BYPASS:
case R_TIMING:
case R_IODELAY:
r = s->regs[addr];
... | 18,270 |
qemu | c2b38b277a7882a592f4f2ec955084b2b756daaa | 0 | int qemu_init_main_loop(Error **errp)
{
int ret;
GSource *src;
Error *local_error = NULL;
init_clocks();
ret = qemu_signal_init();
if (ret) {
return ret;
}
qemu_aio_context = aio_context_new(&local_error);
if (!qemu_aio_context) {
error_propagate(err... | 18,271 |
qemu | 48ce11ff972c733afaed3e2a2613a2e56081ec92 | 0 | static int os_host_main_loop_wait(uint32_t timeout)
{
int ret;
glib_select_fill(&nfds, &rfds, &wfds, &xfds, &timeout);
if (timeout > 0) {
qemu_mutex_unlock_iothread();
}
/* We'll eventually drop fd_set completely. But for now we still have
* *_fill() and *_poll() function... | 18,273 |
qemu | ef29a70d18c2d551cf4bb74b8aa9638caac3391b | 0 | static int cris_mmu_segmented_addr(int seg, uint32_t rw_mm_cfg)
{
return (1 << seg) & rw_mm_cfg;
}
| 18,274 |
qemu | a8170e5e97ad17ca169c64ba87ae2f53850dab4c | 0 | static uint64_t pfpu_read(void *opaque, target_phys_addr_t addr,
unsigned size)
{
MilkymistPFPUState *s = opaque;
uint32_t r = 0;
addr >>= 2;
switch (addr) {
case R_CTL:
case R_MESHBASE:
case R_HMESHLAST:
case R_VMESHLAST:
case R_CODEPAGE:
... | 18,275 |
qemu | ec990eb622ad46df5ddcb1e94c418c271894d416 | 0 | static void qdev_reset(void *opaque)
{
DeviceState *dev = opaque;
if (dev->info->reset)
dev->info->reset(dev);
}
| 18,276 |
qemu | 42a268c241183877192c376d03bd9b6d527407c7 | 0 | static void disas_cond_b_imm(DisasContext *s, uint32_t insn)
{
unsigned int cond;
uint64_t addr;
if ((insn & (1 << 4)) || (insn & (1 << 24))) {
unallocated_encoding(s);
return;
}
addr = s->pc + sextract32(insn, 5, 19) * 4 - 4;
cond = extract32(insn, 0, 4);
if (c... | 18,277 |
qemu | e82d5a2460b0e176128027651ff9b104e4bdf5cc | 0 | void tcg_gen_atomic_cmpxchg_i64(TCGv_i64 retv, TCGv addr, TCGv_i64 cmpv,
TCGv_i64 newv, TCGArg idx, TCGMemOp memop)
{
memop = tcg_canonicalize_memop(memop, 1, 0);
if (!parallel_cpus) {
TCGv_i64 t1 = tcg_temp_new_i64();
TCGv_i64 t2 = tcg_temp_new_i64();
... | 18,280 |
qemu | e48e84ea80cb2e7fe6e48196ce187cfba6e3eb2c | 0 | static void scsi_disk_unit_attention_reported(SCSIDevice *dev)
{
SCSIDiskState *s = DO_UPCAST(SCSIDiskState, qdev, dev);
if (s->media_changed) {
s->media_changed = false;
s->qdev.unit_attention = SENSE_CODE(MEDIUM_CHANGED);
}
}
| 18,281 |
qemu | 5c6c0e513600ba57c3e73b7151d3c0664438f7b5 | 1 | static void lsi_command_complete(SCSIBus *bus, int reason, uint32_t tag,
uint32_t arg)
{
LSIState *s = DO_UPCAST(LSIState, dev.qdev, bus->qbus.parent);
int out;
out = (s->sstat1 & PHASE_MASK) == PHASE_DO;
if (reason == SCSI_REASON_DONE) {
DPRINTF("Comman... | 18,284 |
qemu | 33876dfad64bc481f59c5e9ccf60db78624c4b93 | 1 | static void xenstore_record_dm_state(struct xs_handle *xs, const char *state)
{
char path[50];
if (xs == NULL) {
fprintf(stderr, "xenstore connection not initialized\n");
exit(1);
}
snprintf(path, sizeof (path), "/local/domain/0/device-model/%u/state", xen_domid);
if (!xs... | 18,286 |
FFmpeg | b9c8388710a06544812739eedc0a40d3451491dc | 1 | static void *ff_realloc_static(void *ptr, unsigned int size)
{
int i;
if(!ptr)
return av_mallocz_static(size);
/* Look for the old ptr */
for(i = 0; i < last_static; i++) {
if(array_static[i] == ptr) {
array_static[i] = av_realloc(array_static[i], size);
re... | 18,287 |
qemu | a67e128a4f40cf07abd86f92d0d3c913db2ad885 | 1 | static int vhdx_log_read_desc(BlockDriverState *bs, BDRVVHDXState *s,
VHDXLogEntries *log, VHDXLogDescEntries **buffer,
bool convert_endian)
{
int ret = 0;
uint32_t desc_sectors;
uint32_t sectors_read;
VHDXLogEntryHeader hdr;
VHDXLo... | 18,288 |
qemu | 7b53f2940e3bf43ae50c929330a4837ca4da7a94 | 1 | static int irq_cpu_hotplug_init(SCLPEvent *event)
{
irq_cpu_hotplug = *qemu_allocate_irqs(trigger_signal, event, 1);
return 0;
}
| 18,289 |
FFmpeg | e494f44c051d7dccc038a603ab22532b87dd1705 | 0 | static int escape124_decode_frame(AVCodecContext *avctx,
void *data, int *got_frame,
AVPacket *avpkt)
{
int buf_size = avpkt->size;
Escape124Context *s = avctx->priv_data;
AVFrame *frame = data;
GetBitContext gb;
unsigned ... | 18,291 |
FFmpeg | e2d1eace00a80c4b53998397d38ea4e08c5d47f0 | 0 | static int adx_decode_frame(AVCodecContext *avctx, void *data, int *data_size,
AVPacket *avpkt)
{
const uint8_t *buf0 = avpkt->data;
int buf_size = avpkt->size;
ADXContext *c = avctx->priv_data;
int16_t *samples = data;
const uint8_t *buf = buf0;
... | 18,292 |
FFmpeg | b956373b6f62bfc72b71070b50f1f053225cab8a | 1 | static int vc1_decode_i_block_adv(VC1Context *v, DCTELEM block[64], int n, int coded, int codingset, int mquant)
{
GetBitContext *gb = &v->s.gb;
MpegEncContext *s = &v->s;
int dc_pred_dir = 0; /* Direction of the DC prediction used */
int run_diff, i;
int16_t *dc_val;
int16_t *ac_val, *ac... | 18,293 |
qemu | f24423bd902bce29bc546cf8d030bfa369726ab1 | 1 | int qcow2_alloc_clusters_at(BlockDriverState *bs, uint64_t offset,
int nb_clusters)
{
BDRVQcowState *s = bs->opaque;
uint64_t cluster_index;
uint64_t old_free_cluster_index;
int i, refcount, ret;
/* Check how many clusters there are free */
cluster_index = offset >> s->cluster_bits;
for(... | 18,294 |
FFmpeg | 8acab7ae5bbcb589c556425453ac3d851d35021f | 1 | static void oledate_to_iso8601(char *buf, int buf_size, int64_t value)
{
time_t t = 631112400LL + 86400*av_int2dbl(value);
strftime(buf, buf_size, "%Y-%m-%d %H:%M:%S", gmtime(&t));
}
| 18,295 |
qemu | 31ccdde298d98b08526dc23059071c9086dec6c2 | 1 | const char *get_register_name_32(unsigned int reg)
{
if (reg > CPU_NB_REGS32) {
return NULL;
}
return x86_reg_info_32[reg].name;
}
| 18,296 |
qemu | 187337f8b0ec0813dd3876d1efe37d415fb81c2e | 1 | struct pxa2xx_state_s *pxa255_init(unsigned int sdram_size,
DisplayState *ds)
{
struct pxa2xx_state_s *s;
struct pxa2xx_ssp_s *ssp;
int iomemtype, i;
s = (struct pxa2xx_state_s *) qemu_mallocz(sizeof(struct pxa2xx_state_s));
s->env = cpu_init();
cpu_arm_set_model(s->env... | 18,297 |
FFmpeg | af122d6a80686d9c786b4b46213ef1f5a9699b3e | 0 | int av_read_packet(AVFormatContext *s, AVPacket *pkt)
{
int ret, i;
AVStream *st;
for(;;){
AVPacketList *pktl = s->raw_packet_buffer;
if (pktl) {
*pkt = pktl->pkt;
if(s->streams[pkt->stream_index]->codec->codec_id != CODEC_ID_PROBE ||
!s->s... | 18,299 |
qemu | d6268348493f32ecc096caa637620757472a1196 | 1 | void nbd_export_close(NBDExport *exp)
{
NBDClient *client, *next;
nbd_export_get(exp);
QTAILQ_FOREACH_SAFE(client, &exp->clients, next, next) {
client_close(client);
}
nbd_export_set_name(exp, NULL);
nbd_export_put(exp);
if (exp->blk) {
blk_remove_aio_context_noti... | 18,301 |
qemu | 2362a28ea11c145e1a13ae79342d76dc118a72a6 | 1 | void iothread_stop(IOThread *iothread)
{
if (!iothread->ctx || iothread->stopping) {
return;
}
iothread->stopping = true;
aio_notify(iothread->ctx);
if (atomic_read(&iothread->main_loop)) {
g_main_loop_quit(iothread->main_loop);
}
qemu_thread_join(&iothread->thread)... | 18,302 |
qemu | 1e9981465f05a0f103d7e09afd975c9c0ff6d132 | 1 | void qmp_stop(Error **errp)
{
vm_stop(RUN_STATE_PAUSED);
}
| 18,303 |
FFmpeg | 29ba091136a5e04574f7bfc1b17536c923958f6f | 0 | const char *postproc_configuration(void)
{
return FFMPEG_CONFIGURATION;
}
| 18,305 |
FFmpeg | f929ab0569ff31ed5a59b0b0adb7ce09df3fca39 | 0 | static void qdm2_decode_fft_packets(QDM2Context *q)
{
int i, j, min, max, value, type, unknown_flag;
GetBitContext gb;
if (q->sub_packet_list_B[0].packet == NULL)
return;
/* reset minimum indexes for FFT coefficients */
q->fft_coefs_index = 0;
for (i = 0; i < 5; i++)
... | 18,306 |
FFmpeg | 1181d93231e9b807965724587d363c1cfd5a1d0d | 0 | void ff_avg_h264_qpel16_mc22_msa(uint8_t *dst, const uint8_t *src,
ptrdiff_t stride)
{
avc_luma_mid_and_aver_dst_16x16_msa(src - (2 * stride) - 2,
stride, dst, stride);
}
| 18,307 |
FFmpeg | 0699dbb8478886826dedb1c33a0b74142a1cd863 | 0 | int avfilter_open(AVFilterContext **filter_ctx, AVFilter *filter, const char *inst_name)
{
AVFilterContext *ret;
*filter_ctx = NULL;
if (!filter)
return AVERROR(EINVAL);
ret = av_mallocz(sizeof(AVFilterContext));
ret->av_class = &avfilter_class;
ret->filter = filter;
... | 18,308 |
qemu | dc491fead04a92a612df93b85b0ebf9dcc3f6684 | 1 | static void test_panic(void)
{
uint8_t val;
QDict *response, *data;
val = inb(0x505);
g_assert_cmpuint(val, ==, 1);
outb(0x505, 0x1);
response = qmp_receive();
g_assert(qdict_haskey(response, "event"));
g_assert_cmpstr(qdict_get_str(response, "event"), ==, "GUEST_PANICKED"... | 18,309 |
qemu | c5a49c63fa26e8825ad101dfe86339ae4c216539 | 1 | static void spr_write_decr(DisasContext *ctx, int sprn, int gprn)
{
if (ctx->tb->cflags & CF_USE_ICOUNT) {
gen_io_start();
}
gen_helper_store_decr(cpu_env, cpu_gpr[gprn]);
if (ctx->tb->cflags & CF_USE_ICOUNT) {
gen_io_end();
gen_stop_exception(ctx);
}
}
| 18,310 |
qemu | d9bce9d99f4656ae0b0127f7472db9067b8f84ab | 1 | PPC_OP(b_T1)
{
regs->nip = T1 & ~3;
RETURN();
}
| 18,312 |
FFmpeg | e45226adc46e513a1bb39ec2b09fb7c77515ab14 | 1 | static int make_cdt15_entry(int p1, int p2, int16_t *cdt)
{
int r, b, lo;
b = cdt[p2];
r = cdt[p1] * 1024;
lo = b + r;
return (lo + (lo * (1 << 16))) * 2;
}
| 18,313 |
FFmpeg | e9a32230c3e05deff257cbfa1e5e3d86dc0e94e6 | 1 | static int ogg_build_flac_headers(AVCodecContext *avctx,
OGGStreamContext *oggstream, int bitexact)
{
const char *vendor = bitexact ? "ffmpeg" : LIBAVFORMAT_IDENT;
enum FLACExtradataFormat format;
uint8_t *streaminfo;
uint8_t *p;
if (!ff_flac_is_extradata_val... | 18,314 |
qemu | 645c9496f7083c105ecd32f32532496af6aadf62 | 1 | void qmp_netdev_del(const char *id, Error **errp)
{
NetClientState *nc;
nc = qemu_find_netdev(id);
if (!nc) {
error_set(errp, QERR_DEVICE_NOT_FOUND, id);
return;
}
qemu_del_net_client(nc);
qemu_opts_del(qemu_opts_find(qemu_find_opts_err("netdev", errp), id));
}
| 18,315 |
qemu | f68945d42bab700d95b87f62e0898606ce2421ed | 1 | int qemu_savevm_state_iterate(QEMUFile *f)
{
SaveStateEntry *se;
int ret = 1;
trace_savevm_state_iterate();
QTAILQ_FOREACH(se, &savevm_state.handlers, entry) {
if (!se->ops || !se->ops->save_live_iterate) {
continue;
}
if (se->ops && se->ops->is_active) {
... | 18,316 |
FFmpeg | e751481cd82d610cf93c6104a41396bd6338d073 | 1 | yuv2rgba64_2_c_template(SwsContext *c, const int32_t *buf[2],
const int32_t *ubuf[2], const int32_t *vbuf[2],
const int32_t *abuf[2], uint16_t *dest, int dstW,
int yalpha, int uvalpha, int y,
enum AVPixelFormat target, int h... | 18,317 |
FFmpeg | e46ab997506e8aa84344c29553ebacca7993904c | 1 | static int ogg_restore(AVFormatContext *s)
{
struct ogg *ogg = s->priv_data;
AVIOContext *bc = s->pb;
struct ogg_state *ost = ogg->state;
int i, err;
if (!ost)
return 0;
ogg->state = ost->next;
for (i = 0; i < ogg->nstreams; i++)
av_freep(&ogg->streams... | 18,318 |
FFmpeg | 5cddfc53570fe10fa7fe6d0f166f6f0e090466f6 | 1 | static int commit_bitstream_and_slice_buffer(AVCodecContext *avctx,
DECODER_BUFFER_DESC *bs,
DECODER_BUFFER_DESC *sc)
{
const H264Context *h = avctx->priv_data;
const unsigned mb_count = h->mb_width * h->mb_height;
... | 18,319 |
FFmpeg | 7d196f2a5a48faf25fd904b33b1fd239daae9840 | 0 | static int qtrle_decode_frame(AVCodecContext *avctx,
void *data, int *got_frame,
AVPacket *avpkt)
{
QtrleContext *s = avctx->priv_data;
int header, start_line;
int height, row_ptr;
int has_palette = 0;
int ret;
bytestream2_in... | 18,321 |
FFmpeg | 1dba8371d93cf1c83bcd5c432d921905206a60f3 | 0 | int ffio_open2_wrapper(struct AVFormatContext *s, AVIOContext **pb, const char *url, int flags,
const AVIOInterruptCB *int_cb, AVDictionary **options)
{
return avio_open2(pb, url, flags, int_cb, options);
}
| 18,322 |
qemu | e04fb07fd1676e9facd7f3f878c1bbe03bccd26b | 1 | static void rbd_finish_aiocb(rbd_completion_t c, RADOSCB *rcb)
{
int ret;
rcb->ret = rbd_aio_get_return_value(c);
rbd_aio_release(c);
ret = qemu_rbd_send_pipe(rcb->s, rcb);
if (ret < 0) {
error_report("failed writing to acb->s->fds");
g_free(rcb);
}
}
| 18,325 |
qemu | ba737541edddf9d0026460eb7b1d1c599b4c8ae9 | 1 | static void pcihotplug_write(void *opaque, uint32_t addr, uint32_t val)
{
struct pci_status *g = opaque;
switch (addr) {
case PCI_BASE:
g->up = val;
break;
case PCI_BASE + 4:
g->down = val;
break;
}
PIIX4_DPRINTF("pcihotplug wri... | 18,327 |
FFmpeg | c23acbaed40101c677dfcfbbfe0d2c230a8e8f44 | 1 | static void put_pixels_clamped2_c(const DCTELEM *block, uint8_t *restrict pixels,
int line_size)
{
int i;
uint8_t *cm = ff_cropTbl + MAX_NEG_CROP;
/* read the pixels */
for(i=0;i<2;i++) {
pixels[0] = cm[block[0]];
pixels[1] = cm[block[1]];
... | 18,330 |
qemu | 60fe637bf0e4d7989e21e50f52526444765c63b4 | 1 | bool qemu_file_is_writable(QEMUFile *f)
{
return f->ops->writev_buffer || f->ops->put_buffer;
}
| 18,331 |
FFmpeg | f6774f905fb3cfdc319523ac640be30b14c1bc55 | 1 | static int encode_thread(AVCodecContext *c, void *arg){
MpegEncContext *s= *(void**)arg;
int mb_x, mb_y, pdif = 0;
int chr_h= 16>>s->chroma_y_shift;
int i, j;
MpegEncContext best_s, backup_s;
uint8_t bit_buf[2][MAX_MB_BYTES];
uint8_t bit_buf2[2][MAX_MB_BYTES];
uint8_t bit_buf_tex... | 18,332 |
qemu | 8f4754ede56e3f9ea3fd7207f4a7c4453e59285b | 1 | static int bdrv_check_request(BlockDriverState *bs, int64_t sector_num,
int nb_sectors)
{
return bdrv_check_byte_request(bs, sector_num * BDRV_SECTOR_SIZE,
nb_sectors * BDRV_SECTOR_SIZE); | 18,333 |
FFmpeg | c55427f8c8348af12b77b9601479769d701d8c99 | 1 | int oggvorbis_init_encoder(vorbis_info *vi, AVCodecContext *avccontext) {
if(avccontext->coded_frame->quality) /* VBR requested */
return vorbis_encode_init_vbr(vi, avccontext->channels,
avccontext->sample_rate, (float)avccontext->coded_frame->quality / 1000) ;
return vorbis_encode_init(vi, avccontex... | 18,334 |
qemu | d3afacc7269fee45d54d1501a46b51f12ea7bb15 | 1 | static void gt_ctl_write(CPUARMState *env, const ARMCPRegInfo *ri,
uint64_t value)
{
ARMCPU *cpu = arm_env_get_cpu(env);
int timeridx = ri->crm & 1;
uint32_t oldval = env->cp15.c14_timer[timeridx].ctl;
env->cp15.c14_timer[timeridx].ctl = value & 3;
if ((oldval ^ val... | 18,335 |
FFmpeg | bfa0f96586fe2c257cfa574ffb991da493a54da1 | 1 | static av_cold int vp8_decode_free(AVCodecContext *avctx)
{
vp8_decode_flush_impl(avctx, 0, 1);
release_queued_segmaps(avctx->priv_data, 1);
return 0;
}
| 18,336 |
FFmpeg | 0528226a05cc08b74197547fba0b1939bf68990d | 0 | static int a64_write_header(AVFormatContext *s)
{
AVCodecContext *avctx = s->streams[0]->codec;
uint8_t header[5] = {
0x00, //load
0x40, //address
0x00, //mode
0x00, //charset_lifetime (multi only)
0x00 //fps in 50/fps;
};
if (avctx->extradata_size < ... | 18,337 |
qemu | e1b42f456fad6e797eaf795ed2e400c4e47d5eb4 | 0 | static int64_t seek_to_sector(BlockDriverState *bs, int64_t sector_num)
{
BDRVBochsState *s = bs->opaque;
uint64_t offset = sector_num * 512;
uint64_t extent_index, extent_offset, bitmap_offset;
char bitmap_entry;
// seek to sector
extent_index = offset / s->extent_size;
extent_off... | 18,338 |
qemu | eb5d4f5329df83ea15244b47f7fbca21adaae41b | 0 | static void slirp_bootp_save(QEMUFile *f, Slirp *slirp)
{
int i;
for (i = 0; i < NB_BOOTP_CLIENTS; i++) {
qemu_put_be16(f, slirp->bootp_clients[i].allocated);
qemu_put_buffer(f, slirp->bootp_clients[i].macaddr, 6);
}
}
| 18,339 |
qemu | f5bebbbb28dc7a149a891f0f1e112fb50bb72664 | 0 | int qemu_opts_id_wellformed(const char *id)
{
int i;
if (!qemu_isalpha(id[0])) {
return 0;
}
for (i = 1; id[i]; i++) {
if (!qemu_isalnum(id[i]) && !strchr("-._", id[i])) {
return 0;
}
}
return 1;
}
| 18,340 |
qemu | cf1d078e4ea094e516faab49678fbea3a34b7848 | 0 | ssize_t slirp_send(struct socket *so, const void *buf, size_t len, int flags)
{
if (so->s == -1 && so->extra) {
qemu_chr_fe_write(so->extra, buf, len);
return len;
}
return send(so->s, buf, len, flags);
}
| 18,341 |
qemu | 185b43386ad999c80bdc58e41b87f05e5b3e8463 | 0 | int nbd_init(int fd, int csock, uint32_t flags, off_t size, size_t blocksize)
{
TRACE("Setting NBD socket");
if (ioctl(fd, NBD_SET_SOCK, csock) < 0) {
int serrno = errno;
LOG("Failed to set NBD socket");
errno = serrno;
return -1;
}
TRACE("Setting block size ... | 18,343 |
FFmpeg | 7e7e59409294af9caa63808e56c5cc824c98b4fc | 0 | static void rgb24_to_yuvj420p(AVPicture *dst, AVPicture *src,
int width, int height)
{
int wrap, wrap3, width2;
int r, g, b, r1, g1, b1, w;
uint8_t *lum, *cb, *cr;
const uint8_t *p;
lum = dst->data[0];
cb = dst->data[1];
cr = dst->data[2];
widt... | 18,346 |
qemu | c20fd872257fb9abd2ce99741937c0f65aa162b7 | 0 | static void do_multiwrite(BlockDriverState *bs, BlockRequest *blkreq,
int num_writes)
{
int i, ret;
ret = bdrv_aio_multiwrite(bs, blkreq, num_writes);
if (ret != 0) {
for (i = 0; i < num_writes; i++) {
if (blkreq[i].error) {
virtio_blk_rw_complete(blkreq[i].... | 18,348 |
qemu | 17b74b98676aee5bc470b173b1e528d2fce2cf18 | 0 | static void qjson_register_types(void)
{
type_register_static(&qjson_type_info);
}
| 18,350 |
qemu | 5c8d6f008c0555b54cf10550fa86199a2cfabbca | 0 | void css_generate_sch_crws(uint8_t cssid, uint8_t ssid, uint16_t schid,
int hotplugged, int add)
{
uint8_t guest_cssid;
bool chain_crw;
if (add && !hotplugged) {
return;
}
if (channel_subsys.max_cssid == 0) {
/* Default cssid shows up as 0. */
... | 18,352 |
qemu | 7e2515e87c41e2e658aaed466e11cbdf1ea8bcb1 | 0 | static void term_insert_char(int ch)
{
if (term_cmd_buf_index < TERM_CMD_BUF_SIZE) {
memmove(term_cmd_buf + term_cmd_buf_index + 1,
term_cmd_buf + term_cmd_buf_index,
term_cmd_buf_size - term_cmd_buf_index);
term_cmd_buf[term_cmd_buf_index] = ch;
term_c... | 18,354 |
qemu | e634b89c6ed2309814de7a89bd7c5ced96f59291 | 0 | static void spapr_phb_add_pci_device(sPAPRDRConnector *drc,
sPAPRPHBState *phb,
PCIDevice *pdev,
Error **errp)
{
sPAPRDRConnectorClass *drck = SPAPR_DR_CONNECTOR_GET_CLASS(drc);
DeviceState *dev ... | 18,355 |
FFmpeg | 3176217c60ca7828712985092d9102d331ea4f3d | 0 | static void decode_scaling_matrices(H264Context *h, SPS *sps,
PPS *pps, int is_sps,
uint8_t(*scaling_matrix4)[16],
uint8_t(*scaling_matrix8)[64])
{
int fallback_sps = !is_sps && sps->scaling_matrix_prese... | 18,357 |
qemu | a8170e5e97ad17ca169c64ba87ae2f53850dab4c | 0 | static void macio_nvram_writeb(void *opaque, target_phys_addr_t addr,
uint64_t value, unsigned size)
{
MacIONVRAMState *s = opaque;
addr = (addr >> s->it_shift) & (s->size - 1);
s->data[addr] = value;
NVR_DPRINTF("writeb addr %04x val %x\n", (int)addr, value);
}
| 18,358 |
qemu | 991f8f0c91d65cebf51fa931450e02b0d5209012 | 0 | static void fill_prstatus(struct target_elf_prstatus *prstatus,
const TaskState *ts, int signr)
{
(void) memset(prstatus, 0, sizeof (*prstatus));
prstatus->pr_info.si_signo = prstatus->pr_cursig = signr;
prstatus->pr_pid = ts->ts_tid;
prstatus->pr_ppid = getppid();
p... | 18,359 |
qemu | b4e237aae774a6dd3de2c3db9f87012d48ab6716 | 0 | static int usb_host_read_file(char *line, size_t line_size, const char *device_file, const char *device_name)
{
FILE *f;
int ret = 0;
char filename[PATH_MAX];
snprintf(filename, PATH_MAX, device_file, device_name);
f = fopen(filename, "r");
if (f) {
fgets(line, line_size, f);
... | 18,360 |
qemu | d368ba4376b2c1c24175c74b3733b8fe64dbe8a6 | 0 | static uint32_t sdhci_read_dataport(SDHCIState *s, unsigned size)
{
uint32_t value = 0;
int i;
/* first check that a valid data exists in host controller input buffer */
if ((s->prnsts & SDHC_DATA_AVAILABLE) == 0) {
ERRPRINT("Trying to read from empty buffer\n");
return 0;
... | 18,362 |
qemu | 2d0d2837dcf786da415cf4165d37f4ddd684ff57 | 0 | static void pc_fw_add_pflash_drv(void)
{
QemuOpts *opts;
QEMUMachine *machine;
char *filename;
if (bios_name == NULL) {
bios_name = BIOS_FILENAME;
}
filename = qemu_find_file(QEMU_FILE_TYPE_BIOS, bios_name);
opts = drive_add(IF_PFLASH, -1, filename, "readonly=on");
... | 18,363 |
qemu | a8170e5e97ad17ca169c64ba87ae2f53850dab4c | 0 | static void escc_mem_write(void *opaque, target_phys_addr_t addr,
uint64_t val, unsigned size)
{
SerialState *serial = opaque;
ChannelState *s;
uint32_t saddr;
int newreg, channel;
val &= 0xff;
saddr = (addr >> serial->it_shift) & 1;
channel = (addr >> (... | 18,364 |
FFmpeg | 476d301316aa5436c1d26cfc4858f36875637853 | 0 | int ff_cbs_write_packet(CodedBitstreamContext *ctx,
AVPacket *pkt,
CodedBitstreamFragment *frag)
{
int err;
err = ff_cbs_write_fragment_data(ctx, frag);
if (err < 0)
return err;
av_new_packet(pkt, frag->data_size);
if (err < 0)
... | 18,365 |
FFmpeg | d6604b29ef544793479d7fb4e05ef6622bb3e534 | 0 | static av_cold int sunrast_encode_close(AVCodecContext *avctx)
{
av_frame_free(&avctx->coded_frame);
return 0;
}
| 18,367 |
FFmpeg | 480178a29587df8ed6d5e93bfe79e4a08a61f9e1 | 0 | static void RENAME(yadif_filter_line)(uint8_t *dst, uint8_t *prev, uint8_t *cur,
uint8_t *next, int w, int prefs,
int mrefs, int parity, int mode)
{
DECLARE_ALIGNED(16, uint8_t, tmp0)[16];
DECLARE_ALIGNED(16, uint8_t, tmp1)[16];
... | 18,368 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.