project string | commit_id string | target int64 | func string | idx int64 |
|---|---|---|---|---|
FFmpeg | 1c010fd035c1a14dc73827b84f21f593e969a5d6 | 0 | static int mxf_read_header(AVFormatContext *s)
{
MXFContext *mxf = s->priv_data;
KLVPacket klv;
int64_t essence_offset = 0;
int ret;
mxf->last_forward_tell = INT64_MAX;
mxf->edit_units_per_packet = 1;
if (!mxf_read_sync(s->pb, mxf_header_partition_pack_key, 14)) {
av_log... | 24,500 |
qemu | 062ba099e01ff1474be98c0a4f3da351efab5d9d | 1 | static bool arm_cpu_has_work(CPUState *cs)
{
ARMCPU *cpu = ARM_CPU(cs);
return !cpu->powered_off
&& cs->interrupt_request &
(CPU_INTERRUPT_FIQ | CPU_INTERRUPT_HARD
| CPU_INTERRUPT_VFIQ | CPU_INTERRUPT_VIRQ
| CPU_INTERRUPT_EXITTB);
}
| 24,501 |
qemu | a8170e5e97ad17ca169c64ba87ae2f53850dab4c | 0 | exynos4210_combiner_read(void *opaque, target_phys_addr_t offset, unsigned size)
{
struct Exynos4210CombinerState *s =
(struct Exynos4210CombinerState *)opaque;
uint32_t req_quad_base_n; /* Base of registers quad. Multiply it by 4 and
get a start of corresp... | 24,502 |
FFmpeg | 4cb6964244fd6c099383d8b7e99731e72cc844b9 | 0 | static void int8x8_fmul_int32_c(float *dst, const int8_t *src, int scale)
{
float fscale = scale / 16.0;
int i;
for (i = 0; i < 8; i++)
dst[i] = src[i] * fscale;
}
| 24,503 |
qemu | 42a268c241183877192c376d03bd9b6d527407c7 | 0 | static inline void gen_movcf_d (DisasContext *ctx, int fs, int fd, int cc, int tf)
{
int cond;
TCGv_i32 t0 = tcg_temp_new_i32();
TCGv_i64 fp0;
int l1 = gen_new_label();
if (tf)
cond = TCG_COND_EQ;
else
cond = TCG_COND_NE;
tcg_gen_andi_i32(t0, fpu_fcr31, 1 << get... | 24,504 |
qemu | b131c74a0e485b084ddaffc8214c8a19af492be7 | 0 | int kvm_irqchip_remove_irqfd(KVMState *s, int fd, int virq)
{
return -ENOSYS;
}
| 24,505 |
qemu | 1ea879e5580f63414693655fcf0328559cdce138 | 0 | static void noop_conv (st_sample_t *dst, const void *src,
int samples, volume_t *vol)
{
(void) src;
(void) dst;
(void) samples;
(void) vol;
}
| 24,506 |
qemu | 9bb34eac8b89f624776ce6604c22d7c3097a1e24 | 0 | static void vga_ioport_write(void *opaque, uint32_t addr, uint32_t val)
{
CirrusVGAState *s = opaque;
int index;
/* check port range access depending on color/monochrome mode */
if ((addr >= 0x3b0 && addr <= 0x3bf && (s->msr & MSR_COLOR_EMULATION))
|| (addr >= 0x3d0 && addr <= 0x3df
&& !(... | 24,507 |
qemu | 81b23ef82cd1be29ca3d69ab7e98b5b5e55926ce | 1 | static int xen_pt_cmd_reg_read(XenPCIPassthroughState *s, XenPTReg *cfg_entry,
uint16_t *value, uint16_t valid_mask)
{
XenPTRegInfo *reg = cfg_entry->reg;
uint16_t valid_emu_mask = 0;
uint16_t emu_mask = reg->emu_mask;
if (s->is_virtfn) {
emu_mask |= PCI_C... | 24,508 |
qemu | 06b1297017415ae6a07a0e97ad7d8e90b2d95823 | 1 | static int virtio_net_has_buffers(VirtIONet *n, int bufsize)
{
if (virtio_queue_empty(n->rx_vq) ||
(n->mergeable_rx_bufs &&
!virtqueue_avail_bytes(n->rx_vq, bufsize, 0))) {
virtio_queue_set_notification(n->rx_vq, 1);
return 0;
}
virtio_queue_set_notification(n->rx_... | 24,509 |
FFmpeg | 697400eac07c0614f6b9f2e7615563982dbcbe4a | 0 | static int mov_read_chap(MOVContext *c, AVIOContext *pb, MOVAtom atom)
{
c->chapter_track = avio_rb32(pb);
return 0;
}
| 24,510 |
qemu | 9561fda8d90e176bef598ba87c42a1bd6ad03ef7 | 1 | static void qbus_initfn(Object *obj)
{
BusState *bus = BUS(obj);
QTAILQ_INIT(&bus->children);
object_property_add_link(obj, QDEV_HOTPLUG_HANDLER_PROPERTY,
TYPE_HOTPLUG_HANDLER,
(Object **)&bus->hotplug_handler, NULL);
object_property_add... | 24,511 |
FFmpeg | f863bee841670384fc46f4f99f511b27eb89a216 | 0 | static void final(Real144_internal *glob, short *i1, short *i2, void *out,
int *statbuf, int len)
{
int x, sum;
int buffer[10];
short *ptr;
short *ptr2;
memcpy(glob->work, statbuf,20);
memcpy(glob->work + 10, i2, len * 2);
buffer[9] = i1[0];
buffer[8] = i1... | 24,512 |
qemu | 3af9187fc6caaf415ab9c0c6d92c9678f65cb17f | 1 | static ssize_t mipsnet_receive(NetClientState *nc, const uint8_t *buf, size_t size)
{
MIPSnetState *s = qemu_get_nic_opaque(nc);
trace_mipsnet_receive(size);
if (!mipsnet_can_receive(nc))
s->busy = 1;
/* Just accept everything. */
/* Write packet data. */
memcpy(s->rx_buf... | 24,513 |
FFmpeg | c8241e730f116f1c9cfc0b34110aa7f052e05332 | 0 | static AVBufferRef *vaapi_encode_alloc_output_buffer(void *opaque,
int size)
{
AVCodecContext *avctx = opaque;
VAAPIEncodeContext *ctx = avctx->priv_data;
VABufferID buffer_id;
VAStatus vas;
AVBufferRef *ref;
// The output buffer s... | 24,514 |
qemu | a8170e5e97ad17ca169c64ba87ae2f53850dab4c | 0 | static struct omap_tipb_bridge_s *omap_tipb_bridge_init(
MemoryRegion *memory, target_phys_addr_t base,
qemu_irq abort_irq, omap_clk clk)
{
struct omap_tipb_bridge_s *s = (struct omap_tipb_bridge_s *)
g_malloc0(sizeof(struct omap_tipb_bridge_s));
s->abort = abort_irq;
omap_tipb_... | 24,515 |
qemu | c2b38b277a7882a592f4f2ec955084b2b756daaa | 0 | void thread_pool_submit(ThreadPool *pool, ThreadPoolFunc *func, void *arg)
{
thread_pool_submit_aio(pool, func, arg, NULL, NULL);
}
| 24,516 |
qemu | 61007b316cd71ee7333ff7a0a749a8949527575f | 0 | int bdrv_writev_vmstate(BlockDriverState *bs, QEMUIOVector *qiov, int64_t pos)
{
BlockDriver *drv = bs->drv;
if (!drv) {
return -ENOMEDIUM;
} else if (drv->bdrv_save_vmstate) {
return drv->bdrv_save_vmstate(bs, qiov, pos);
} else if (bs->file) {
return bdrv_writev_vmsta... | 24,517 |
qemu | 4fa4ce7107c6ec432f185307158c5df91ce54308 | 0 | static int local_statfs(FsContext *s, V9fsPath *fs_path, struct statfs *stbuf)
{
char buffer[PATH_MAX];
char *path = fs_path->data;
return statfs(rpath(s, path, buffer), stbuf);
}
| 24,518 |
FFmpeg | 5d20f19be25c973fe10d0d17db9245002585710d | 1 | static void init_multbl2(uint8_t tbl[1024], const int c[4],
const uint8_t *log8, const uint8_t *alog8,
const uint8_t *sbox)
{
int i, j;
for (i = 0; i < 1024; i++) {
int x = sbox[i >> 2];
if (x)
tbl[i] = alog8[log8[x] + log8[... | 24,519 |
qemu | c34d440a728fd3b5099d11dec122d440ef092c23 | 0 | static int kvm_get_msr(CPUState *env, struct kvm_msr_entry *msrs, int n)
{
struct kvm_msrs *kmsrs = qemu_malloc(sizeof *kmsrs + n * sizeof *msrs);
int r;
kmsrs->nmsrs = n;
memcpy(kmsrs->entries, msrs, n * sizeof *msrs);
r = kvm_vcpu_ioctl(env, KVM_GET_MSRS, kmsrs);
memcpy(msrs, kmsrs->e... | 24,520 |
qemu | cfdf2c40577ed99bb19cdc05d0537e2808d77a78 | 0 | static void do_balloon(Monitor *mon, const QDict *qdict, QObject **ret_data)
{
int value = qdict_get_int(qdict, "value");
ram_addr_t target = value;
qemu_balloon(target << 20);
}
| 24,521 |
FFmpeg | 9bff052b51f27f6cce04e8d7d8b405c710d7ad67 | 0 | static void blur(uint8_t *dst, const int dst_linesize,
const uint8_t *src, const int src_linesize,
const int w, const int h, FilterParam *fp)
{
int x, y;
FilterParam f = *fp;
const int radius = f.dist_width/2;
const uint8_t * const src2[NB_PLANES] = { src... | 24,522 |
qemu | f8ed85ac992c48814d916d5df4d44f9a971c5de4 | 1 | FWCfgState *pc_memory_init(PCMachineState *pcms,
MemoryRegion *system_memory,
MemoryRegion *rom_memory,
MemoryRegion **ram_memory,
PcGuestInfo *guest_info)
{
int linux_boot, i;
MemoryRegion *ram, *... | 24,523 |
qemu | 1d2acc3162d9c7772510c973f446353fbdd1f9a8 | 1 | static void migrate_fd_cancel(MigrationState *s)
{
int old_state ;
QEMUFile *f = migrate_get_current()->to_dst_file;
trace_migrate_fd_cancel();
if (s->rp_state.from_dst_file) {
/* shutdown the rp socket, so causing the rp thread to shutdown */
qemu_file_shutdown(s->rp_state.from_dst_file... | 24,524 |
FFmpeg | bd737b5178f361a9b592691848f29a7a79603a7e | 0 | static int decode_init_thread_copy(AVCodecContext *avctx)
{
H264Context *h = avctx->priv_data;
int ret;
if (!avctx->internal->is_copy)
return 0;
memset(h->sps_buffers, 0, sizeof(h->sps_buffers));
memset(h->pps_buffers, 0, sizeof(h->pps_buffers));
ret = h264_init_context(avctx... | 24,525 |
qemu | bf55b7afce53718ef96f4e6616da62c0ccac37dd | 0 | static IOMMUTLBEntry vtd_iommu_translate(MemoryRegion *iommu, hwaddr addr,
bool is_write)
{
VTDAddressSpace *vtd_as = container_of(iommu, VTDAddressSpace, iommu);
IntelIOMMUState *s = vtd_as->iommu_state;
IOMMUTLBEntry ret = {
.target_as = &address_spac... | 24,526 |
qemu | d185c094b404b4ff392b77d1244c0233da7d53bd | 0 | static gboolean io_watch_poll_check(GSource *source)
{
IOWatchPoll *iwp = io_watch_poll_from_source(source);
if (iwp->max_size == 0) {
return FALSE;
}
return g_io_watch_funcs.check(source);
}
| 24,527 |
FFmpeg | 488a0fa68973d48e264d54f1722f7afb18afbea7 | 0 | static int configure_input_audio_filter(FilterGraph *fg, InputFilter *ifilter,
AVFilterInOut *in)
{
AVFilterContext *last_filter;
const AVFilter *abuffer_filt = avfilter_get_by_name("abuffer");
InputStream *ist = ifilter->ist;
InputFile *f = input_files[... | 24,528 |
FFmpeg | 8dca0877e3e1457e9ec79ffa1ead1135aabb791c | 0 | static int mpegts_write_packet_internal(AVFormatContext *s, AVPacket *pkt)
{
AVStream *st = s->streams[pkt->stream_index];
int size = pkt->size;
uint8_t *buf = pkt->data;
uint8_t *data = NULL;
MpegTSWrite *ts = s->priv_data;
MpegTSWriteStream *ts_st = st->priv_data;
const uint64_t de... | 24,529 |
qemu | 240f64b6dc3346d044d7beb7cc3a53668ce47384 | 0 | void qmp_object_add(const char *type, const char *id,
bool has_props, QObject *props, Error **errp)
{
const QDict *pdict = NULL;
QmpInputVisitor *qiv;
Object *obj;
if (props) {
pdict = qobject_to_qdict(props);
if (!pdict) {
error_setg(errp, QERR... | 24,530 |
qemu | f6bb84d53110398f4899c19dab4e0fe9908ec060 | 1 | static inline TranslationBlock *tb_find(CPUState *cpu,
TranslationBlock *last_tb,
int tb_exit)
{
CPUArchState *env = (CPUArchState *)cpu->env_ptr;
TranslationBlock *tb;
target_ulong cs_base, pc;
uint32_t flags;
b... | 24,531 |
FFmpeg | c3ab0004ae4dffc32494ae84dd15cfaa909a7884 | 1 | static inline void RENAME(hyscale_fast)(SwsContext *c, int16_t *dst,
int dstWidth, const uint8_t *src, int srcW,
int xInc)
{
#if ARCH_X86
#if COMPILE_TEMPLATE_MMX2
int32_t *filterPos = c->hLumFilterPos;
int16_t *filter = c... | 24,532 |
FFmpeg | 9d0b45ade864f3d2ccd8610149fe1fff53c4e937 | 1 | static int decrypt_init(AVFormatContext *s, ID3v2ExtraMeta *em, uint8_t *header)
{
OMAContext *oc = s->priv_data;
ID3v2ExtraMetaGEOB *geob = NULL;
uint8_t *gdata;
oc->encrypted = 1;
av_log(s, AV_LOG_INFO, "File is encrypted\n");
/* find GEOB metadata */
while (em) {
if (... | 24,533 |
qemu | 73479c5c87bf431c6344a80ab01456ed979447f1 | 1 | void superh_cpu_do_interrupt(CPUState *cs)
{
SuperHCPU *cpu = SUPERH_CPU(cs);
CPUSH4State *env = &cpu->env;
int do_irq = cs->interrupt_request & CPU_INTERRUPT_HARD;
int do_exp, irq_vector = cs->exception_index;
/* prioritize exceptions over interrupts */
do_exp = cs->exception_index !... | 24,534 |
FFmpeg | ee16a0ced01e6a33b7b01a0b21a0e07c1e1c7884 | 0 | static int smacker_read_packet(AVFormatContext *s, AVPacket *pkt)
{
SmackerContext *smk = s->priv_data;
int flags;
int ret;
int i;
int frame_size = 0;
int palchange = 0;
if (s->pb->eof_reached || smk->cur_frame >= smk->frames)
return AVERROR_EOF;
/* if we demuxed al... | 24,535 |
qemu | f332e830e38b3ff3953ef02ac04e409ae53769c5 | 1 | static void parse_type_size(Visitor *v, const char *name, uint64_t *obj,
Error **errp)
{
StringInputVisitor *siv = to_siv(v);
Error *err = NULL;
uint64_t val;
if (siv->string) {
parse_option_size(name, siv->string, &val, &err);
} else {
error_se... | 24,536 |
FFmpeg | 9f61abc8111c7c43f49ca012e957a108b9cc7610 | 0 | static int parse_fragment(AVFormatContext *s, const char *filename, int64_t *start_ts, int64_t *duration, int64_t *moof_size, int64_t size)
{
AVIOContext *in;
int ret;
uint32_t len;
if ((ret = avio_open2(&in, filename, AVIO_FLAG_READ, &s->interrupt_callback, NULL)) < 0)
return ret;
re... | 24,537 |
qemu | da98c8eb4c35225049cad8cf767647eb39788b5d | 0 | void acpi_pm1_cnt_init(ACPIREGS *ar, qemu_irq cmos_s3)
{
ar->pm1.cnt.cmos_s3 = cmos_s3;
}
| 24,538 |
qemu | 4083733db5e4120939acee57019ff52db1f45b9d | 0 | static void console_refresh(QemuConsole *s)
{
DisplaySurface *surface = qemu_console_surface(s);
TextCell *c;
int x, y, y1;
if (s->ds->have_text) {
s->text_x[0] = 0;
s->text_y[0] = 0;
s->text_x[1] = s->width - 1;
s->text_y[1] = s->height - 1;
s->cursor... | 24,539 |
qemu | c2b38b277a7882a592f4f2ec955084b2b756daaa | 0 | static void qemu_init_child_watch(void)
{
struct sigaction act;
sigchld_bh = qemu_bh_new(sigchld_bh_handler, NULL);
memset(&act, 0, sizeof(act));
act.sa_handler = sigchld_handler;
act.sa_flags = SA_NOCLDSTOP;
sigaction(SIGCHLD, &act, NULL);
}
| 24,540 |
FFmpeg | 240fd8c96f59ebe9dcfc4152a1086cd3f63400c0 | 0 | int av_packet_split_side_data(AVPacket *pkt){
if (!pkt->side_data_elems && pkt->size >12 && AV_RB64(pkt->data + pkt->size - 8) == FF_MERGE_MARKER){
int i;
unsigned int size, orig_pktsize = pkt->size;
uint8_t *p;
p = pkt->data + pkt->size - 8 - 5;
for (i=1; ; i++){
... | 24,541 |
qemu | 3e305e4a4752f70c0b5c3cf5b43ec957881714f7 | 1 | int vnc_tls_client_setup(VncState *vs,
int needX509Creds) {
VNC_DEBUG("Do TLS setup\n");
if (vnc_tls_initialize() < 0) {
VNC_DEBUG("Failed to init TLS\n");
vnc_client_error(vs);
return -1;
}
if (vs->tls.session == NULL) {
if (gnutls_init(... | 24,542 |
FFmpeg | f6b7f72461673e4d398b1edf9ed2a7fe70d99c47 | 0 | static void av_always_inline filter_mb_edgech( uint8_t *pix, int stride, const int16_t bS[4], unsigned int qp, H264Context *h, int intra ) {
const int qp_bd_offset = 6 * (h->sps.bit_depth_luma - 8);
const unsigned int index_a = qp - qp_bd_offset + h->slice_alpha_c0_offset;
const int alpha = alpha_table[i... | 24,543 |
qemu | a89f364ae8740dfc31b321eed9ee454e996dc3c1 | 0 | static inline void bt_hci_lmp_acl_data(struct bt_hci_s *hci, uint16_t handle,
const uint8_t *data, int start, int len)
{
struct hci_acl_hdr *pkt = (void *) hci->acl_buf;
/* TODO: packet flags */
/* TODO: avoid memcpy'ing */
if (len + HCI_ACL_HDR_SIZE > sizeof(hci->acl_buf)) {
... | 24,544 |
qemu | 42bb9c9178ae7ac4c439172b1ae99cc29188a5c6 | 0 | static void xilinx_enet_init(Object *obj)
{
XilinxAXIEnet *s = XILINX_AXI_ENET(obj);
SysBusDevice *sbd = SYS_BUS_DEVICE(obj);
Error *errp = NULL;
object_property_add_link(obj, "axistream-connected", TYPE_STREAM_SLAVE,
(Object **) &s->tx_dev, &errp);
assert_no_er... | 24,545 |
qemu | 23326164ae6fe8d94b7eff123e03f97ca6978d33 | 0 | bool address_space_rw(AddressSpace *as, hwaddr addr, uint8_t *buf,
int len, bool is_write)
{
hwaddr l;
uint8_t *ptr;
uint64_t val;
hwaddr addr1;
MemoryRegion *mr;
bool error = false;
while (len > 0) {
l = len;
mr = address_space_translate(as... | 24,546 |
qemu | 5c55ff99fa88158871d5b9f619c485deae5f3d5b | 0 | static int create_ppc_opcodes (CPUPPCState *env, const ppc_def_t *def)
{
opcode_t *opc, *start, *end;
fill_new_table(env->opcodes, 0x40);
if (&opc_start < &opc_end) {
start = &opc_start;
end = &opc_end;
} else {
start = &opc_end;
end = &opc_start;
}
f... | 24,547 |
qemu | b7f43fe46029d8fd0594cd599fa2599dcce0f553 | 1 | Object *object_dynamic_cast_assert(Object *obj, const char *typename)
{
Object *inst;
inst = object_dynamic_cast(obj, typename);
if (!inst) {
fprintf(stderr, "Object %p is not an instance of type %s\n",
obj, typename);
abort();
}
return inst;
}
| 24,548 |
qemu | 6658ffb81ee56a510d7d77025872a508a9adce3a | 1 | static inline int gen_intermediate_code_internal(CPUState *env,
TranslationBlock *tb,
int search_pc)
{
DisasContext dc1, *dc = &dc1;
uint16_t *gen_opc_end;
int j, lj;
target_ulong pc_start;
ui... | 24,549 |
qemu | 1c46efaa0a175e468772405385ca26a1e35dd94c | 0 | static void qcow_aio_read_cb(void *opaque, int ret)
{
QCowAIOCB *acb = opaque;
BlockDriverState *bs = acb->common.bs;
BDRVQcowState *s = bs->opaque;
int index_in_cluster, n1;
acb->hd_aiocb = NULL;
if (ret < 0)
goto done;
/* post process the read buffer */
if (!acb->... | 24,550 |
qemu | d8754f40acb2d30e4735cdcd21a16e7ac29264a3 | 0 | opts_end_list(Visitor *v, Error **errp)
{
OptsVisitor *ov = DO_UPCAST(OptsVisitor, visitor, v);
assert(ov->list_mode == LM_STARTED || ov->list_mode == LM_IN_PROGRESS);
ov->repeated_opts = NULL;
ov->list_mode = LM_NONE;
}
| 24,551 |
qemu | 1ea879e5580f63414693655fcf0328559cdce138 | 0 | static CaptureVoiceOut *audio_pcm_capture_find_specific (
AudioState *s,
audsettings_t *as
)
{
CaptureVoiceOut *cap;
for (cap = s->cap_head.lh_first; cap; cap = cap->entries.le_next) {
if (audio_pcm_info_eq (&cap->hw.info, as)) {
return cap;
}
}
retur... | 24,552 |
FFmpeg | fbd6c97f9ca858140df16dd07200ea0d4bdc1a83 | 1 | AVBufferRef *av_buffer_pool_get(AVBufferPool *pool)
{
AVBufferRef *ret;
BufferPoolEntry *buf;
/* check whether the pool is empty */
buf = get_pool(pool);
if (!buf)
return pool_alloc_buffer(pool);
/* keep the first entry, return the rest of the list to the pool */
add_to_... | 24,553 |
qemu | c599d4d6d6e9bfdb64e54c33a22cb26e3496b96d | 1 | static void QEMU_NORETURN force_sig(int target_sig)
{
CPUState *cpu = thread_cpu;
CPUArchState *env = cpu->env_ptr;
TaskState *ts = (TaskState *)cpu->opaque;
int host_sig, core_dumped = 0;
struct sigaction act;
host_sig = target_to_host_signal(target_sig);
trace_user_force_sig(env,... | 24,554 |
FFmpeg | 20035fa24103da9199de3515ca75ba1f6bb275aa | 1 | static int scale_vector(int16_t *dst, const int16_t *vector, int length)
{
int bits, max = 0;
int i;
for (i = 0; i < length; i++)
max |= FFABS(vector[i]);
bits = normalize_bits(max, 15);
if (bits == 15)
for (i = 0; i < length; i++)
dst[i] = vector[i] * 0x7... | 24,555 |
qemu | 8dfbaa6ac450c4ec2646b1ca08a4017052a90c1d | 0 | static int virtio_ccw_hcall_notify(const uint64_t *args)
{
uint64_t subch_id = args[0];
uint64_t queue = args[1];
SubchDev *sch;
int cssid, ssid, schid, m;
if (ioinst_disassemble_sch_ident(subch_id, &m, &cssid, &ssid, &schid)) {
return -EINVAL;
}
sch = css_find_subch(m, cs... | 24,556 |
FFmpeg | c04643a2c24564aed96a5b0760de8bf02eb305c6 | 0 | void prepare_grab(void)
{
int has_video, has_audio, i, j;
AVFormatContext *oc;
AVFormatContext *ic;
AVFormatParameters ap1, *ap = &ap1;
/* see if audio/video inputs are needed */
has_video = 0;
has_audio = 0;
memset(ap, 0, sizeof(*ap));
for(j=0;j<nb_output_files;j++) {
... | 24,557 |
FFmpeg | 9156a5ad72e989e0fa2735741edf894fffad33b9 | 0 | static void ipvideo_decode_opcodes(IpvideoContext *s)
{
int x, y;
unsigned char opcode;
int ret;
static int frame = 0;
GetBitContext gb;
debug_interplay("------------------ frame %d\n", frame);
frame++;
/* this is PAL8, so make the palette available */
memcpy(s->current... | 24,558 |
qemu | 21ce148c7ec71ee32834061355a5ecfd1a11f90f | 1 | static inline void cris_fidx_i(unsigned int x)
{
register unsigned int v asm("$r10") = x;
asm ("fidxi\t[%0]\n" : : "r" (v) );
}
| 24,559 |
qemu | b6fcf32d9b851a83dedcb609091236b97cc4a985 | 0 | static void test_nested_struct_list(gconstpointer opaque)
{
TestArgs *args = (TestArgs *) opaque;
const SerializeOps *ops = args->ops;
UserDefNestedList *listp = NULL, *tmp, *tmp_copy, *listp_copy = NULL;
Error *err = NULL;
void *serialize_data;
int i = 0;
for (i = 0; i < 8; i++) {... | 24,560 |
FFmpeg | 229843aa359ae0c9519977d7fa952688db63f559 | 0 | static void handle_char(CCaptionSubContext *ctx, char hi, char lo, int64_t pts)
{
struct Screen *screen = get_writing_screen(ctx);
char *row = screen->characters[ctx->cursor_row];
int ret;
SET_FLAG(screen->row_used,ctx->cursor_row);
ret = write_char(ctx, row, ctx->cursor_column, hi);
... | 24,561 |
qemu | 12d4536f7d911b6d87a766ad7300482ea663cea2 | 1 | int qemu_cpu_is_self(void *env)
{
return 1;
}
| 24,562 |
qemu | 71d0770c4cec9f1dc04f4dadcbf7fd6c335030a9 | 1 | BlockDriverAIOCB *bdrv_aio_writev(BlockDriverState *bs, int64_t sector_num,
QEMUIOVector *iov, int nb_sectors,
BlockDriverCompletionFunc *cb, void *opaque)
{
return bdrv_aio_rw_vector(bs, sector_num, iov, nb_sectors,
c... | 24,563 |
qemu | a8170e5e97ad17ca169c64ba87ae2f53850dab4c | 0 | static void omap_mcbsp_writeh(void *opaque, target_phys_addr_t 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);
... | 24,564 |
FFmpeg | 1f630b97178cdf1637c96f0eecd0975cde30bb7c | 0 | static inline void h264_loop_filter_luma_mmx2(uint8_t *pix, int stride, int alpha1, int beta1, int8_t *tc0)
{
DECLARE_ALIGNED_8(uint64_t, tmp0[2]);
__asm__ volatile(
"movq (%1,%3), %%mm0 \n\t" //p1
"movq (%1,%3,2), %%mm1 \n\t" //p0
"movq (%2), %%mm2 \n\t" //q0
... | 24,565 |
FFmpeg | 4c55144ee969a63bb5e469e3ebd7179b7b3616e8 | 0 | static int filter_frame(AVFilterLink *inlink, AVFrame *buf)
{
AVFilterContext *ctx = inlink->dst;
AVFilterLink *outlink = ctx->outputs[0];
DeflickerContext *s = ctx->priv;
AVDictionary **metadata;
AVFrame *out, *in;
float f;
int y;
if (s->q.available < s->size && !s->eof) {
... | 24,566 |
qemu | ec9c10d29c6bb5613a680af62f5825d3bb2d31d4 | 1 | static DriveInfo *blockdev_init(QDict *bs_opts,
BlockInterfaceType type,
Error **errp)
{
const char *buf;
const char *file = NULL;
const char *serial;
int ro = 0;
int bdrv_flags = 0;
int on_read_error, on_write_error;
... | 24,567 |
FFmpeg | 4bff9ef9d0781c4de228bf1f85634d2706fc589b | 0 | inline static void RENAME(hcscale)(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,
int srcFormat, uint8_t *formatConvBuffer, int16_t *mmx2Filter,
... | 24,568 |
FFmpeg | ffa1de8a3b93139097214bc600d356ab62bfdf05 | 1 | static void dequantization_int_97(int x, int y, Jpeg2000Cblk *cblk,
Jpeg2000Component *comp,
Jpeg2000T1Context *t1, Jpeg2000Band *band)
{
int i, j;
int w = cblk->coord[0][1] - cblk->coord[0][0];
for (j = 0; j < (cblk->coord[1][1] - cblk->co... | 24,569 |
FFmpeg | bdcd36a4c81c50254f6204e83e0c14adc1391e66 | 0 | yuv2rgb_full_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 AVPixelFormat target,
int hasAlpha)
{
const ... | 24,570 |
FFmpeg | 3fd2d1c4bc43aab583f97afbb63ab91145f9e7ba | 1 | void Process(void *ctx, AVPicture *picture, enum PixelFormat pix_fmt, int width, int height, int64_t pts)
{
int err = 0;
ContextInfo *ci = (ContextInfo *) ctx;
AVPicture picture1;
AVPicture picture2;
AVPicture *pict = picture;
int out_width;
int out_height;
int i;
uint8_t *... | 24,571 |
FFmpeg | b6db385922b79939b0dc124d53ddb4824afac040 | 0 | static int v4l2_set_parameters(AVFormatContext *s1, AVFormatParameters *ap)
{
struct video_data *s = s1->priv_data;
struct v4l2_input input;
struct v4l2_standard standard;
struct v4l2_streamparm streamparm = { 0 };
struct v4l2_fract *tpf = &streamparm.parm.capture.timeperframe;
int i, ret... | 24,572 |
FFmpeg | 38c48be213b86baa04e64762622afefbba1afa70 | 0 | static int mpegts_read_packet(AVFormatContext *s,
AVPacket *pkt)
{
MpegTSContext *ts = s->priv_data;
if (!ts->mpeg2ts_raw) {
ts->pkt = pkt;
return handle_packets(ts, 0);
} else {
return mpegts_raw_read_packet(s, pkt);
}
}
| 24,573 |
qemu | 7e84c2498f0ff3999937d18d1e9abaa030400000 | 0 | static inline int load_segment(uint32_t *e1_ptr, uint32_t *e2_ptr,
int selector)
{
SegmentCache *dt;
int index;
uint8_t *ptr;
if (selector & 0x4)
dt = &env->ldt;
else
dt = &env->gdt;
index = selector & ~7;
if ((index + 7) > dt->limi... | 24,574 |
FFmpeg | 1dc42050185d63c1de5d16146fbaee92640af187 | 0 | static int start_frame(AVFilterLink *link, AVFilterBufferRef *picref)
{
AVFilterContext *ctx = link->dst;
YADIFContext *yadif = ctx->priv;
if (yadif->frame_pending)
return_frame(ctx, 1);
if (yadif->prev)
avfilter_unref_buffer(yadif->prev);
yadif->prev = yadif->cur;
y... | 24,575 |
FFmpeg | f6b7f72461673e4d398b1edf9ed2a7fe70d99c47 | 0 | static void av_always_inline filter_mb_edgeh( uint8_t *pix, int stride, const int16_t bS[4], unsigned int qp, H264Context *h, int intra ) {
const int qp_bd_offset = 6 * (h->sps.bit_depth_luma - 8);
const unsigned int index_a = qp - qp_bd_offset + h->slice_alpha_c0_offset;
const int alpha = alpha_table[in... | 24,576 |
FFmpeg | ca203e9985cd2dcf42a0c0853940850d3a8edf3a | 1 | static void calc_thr_3gpp(const FFPsyWindowInfo *wi, const int num_bands, AacPsyChannel *pch,
const uint8_t *band_sizes, const float *coefs)
{
int i, w, g;
int start = 0;
for (w = 0; w < wi->num_windows*16; w += 16) {
for (g = 0; g < num_bands; g++) {
Aac... | 24,577 |
qemu | c2b38b277a7882a592f4f2ec955084b2b756daaa | 0 | void aio_bh_schedule_oneshot(AioContext *ctx, QEMUBHFunc *cb, void *opaque)
{
QEMUBH *bh;
bh = g_new(QEMUBH, 1);
*bh = (QEMUBH){
.ctx = ctx,
.cb = cb,
.opaque = opaque,
};
qemu_lockcnt_lock(&ctx->list_lock);
bh->next = ctx->first_bh;
bh->scheduled = 1;
... | 24,578 |
qemu | 51b19ebe4320f3dcd93cea71235c1219318ddfd2 | 0 | static int32_t virtio_net_flush_tx(VirtIONetQueue *q)
{
VirtIONet *n = q->n;
VirtIODevice *vdev = VIRTIO_DEVICE(n);
VirtQueueElement elem;
int32_t num_packets = 0;
int queue_index = vq2q(virtio_get_queue_index(q->tx_vq));
if (!(vdev->status & VIRTIO_CONFIG_S_DRIVER_OK)) {
return ... | 24,579 |
qemu | 8be487d8f184f2f721cabeac559fb7a6cba18c95 | 1 | static void sdhci_data_transfer(void *opaque)
{
SDHCIState *s = (SDHCIState *)opaque;
if (s->trnmod & SDHC_TRNS_DMA) {
switch (SDHC_DMA_TYPE(s->hostctl)) {
case SDHC_CTRL_SDMA:
if ((s->blkcnt == 1) || !(s->trnmod & SDHC_TRNS_MULTI)) {
sdhci_sdma_transfer_sing... | 24,580 |
qemu | 2637c754ccdb286890ed2a8d0d1da775dbd062af | 0 | void cpu_dump_state(CPUState *env, FILE *f,
int (*cpu_fprintf)(FILE *f, const char *fmt, ...),
int flags)
{
int eflags, i, nb;
char cc_op_name[32];
static const char *seg_name[6] = { "ES", "CS", "SS", "DS", "FS", "GS" };
if (kvm_enabled())
kvm_ar... | 24,581 |
qemu | 9012a53f067a78022947e18050b145c34a3dc599 | 0 | static void rtas_start_cpu(PowerPCCPU *cpu_, sPAPRMachineState *spapr,
uint32_t token, uint32_t nargs,
target_ulong args,
uint32_t nret, target_ulong rets)
{
target_ulong id, start, r3;
PowerPCCPU *cpu;
if (nargs != 3 ... | 24,582 |
qemu | ad196a9d0c14f681f010bb4b979030ec125ba976 | 0 | void net_slirp_redir(Monitor *mon, const char *redir_str, const char *redir_opt2)
{
struct slirp_config_str *config;
if (!slirp_inited) {
if (mon) {
monitor_printf(mon, "user mode network stack not in use\n");
} else {
config = qemu_malloc(sizeof(*config));
... | 24,583 |
qemu | a6152b52bc50c5cf1cd118a74b483dd3f0748ebd | 0 | int ppc_hash64_handle_mmu_fault(PowerPCCPU *cpu, vaddr eaddr,
int rwx, int mmu_idx)
{
CPUState *cs = CPU(cpu);
CPUPPCState *env = &cpu->env;
ppc_slb_t *slb;
unsigned apshift;
hwaddr ptex;
ppc_hash_pte64_t pte;
int pp_prot, amr_prot, prot;
uint64_... | 24,584 |
qemu | 196a778428989217b82de042725dc8eb29c8f8d8 | 1 | static void qxl_reset_surfaces(PCIQXLDevice *d)
{
dprint(d, 1, "%s:\n", __FUNCTION__);
d->mode = QXL_MODE_UNDEFINED;
qemu_mutex_unlock_iothread();
d->ssd.worker->destroy_surfaces(d->ssd.worker);
qemu_mutex_lock_iothread();
memset(&d->guest_surfaces.cmds, 0, sizeof(d->guest_surfaces.cmds))... | 24,585 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.