/* * Get frame from file for file_list operation */ static pj_status_t file_list_get_frame(pjmedia_port *this_port, pjmedia_frame *frame) { struct playlist_port *fport = (struct playlist_port*)this_port; unsigned frame_size; pj_status_t status; pj_assert(fport->base.info.signature == SIGNATURE); //frame_size = fport->base.info.bytes_per_frame; //pj_assert(frame->size == frame_size); frame_size = frame->size; /* Copy frame from buffer. */ frame->type = PJMEDIA_FRAME_TYPE_AUDIO; frame->size = frame_size; frame->timestamp.u64 = 0; if (fport->readpos + frame_size <= fport->buf + fport->bufsize) { /* Read contiguous buffer. */ pj_memcpy(frame->buf, fport->readpos, frame_size); /* Fill up the buffer if all has been read. */ fport->readpos += frame_size; if (fport->readpos == fport->buf + fport->bufsize) { fport->readpos = fport->buf; status = file_fill_buffer(fport); if (status != PJ_SUCCESS) { frame->type = PJMEDIA_FRAME_TYPE_NONE; frame->size = 0; return status; } } } else { unsigned endread; /* Split read. * First stage: read until end of buffer. */ endread = (fport->buf+fport->bufsize) - fport->readpos; pj_memcpy(frame->buf, fport->readpos, endread); /* Second stage: fill up buffer, and read from the start of buffer. */ status = file_fill_buffer(fport); if (status != PJ_SUCCESS) { pj_bzero(((char*)frame->buf)+endread, frame_size-endread); return status; } pj_memcpy(((char*)frame->buf)+endread, fport->buf, frame_size-endread); fport->readpos = fport->buf + (frame_size - endread); } return PJ_SUCCESS; }
int create_files(void) { unsigned int i; int fd; char file_name[512]; long long offset; log_text(LOG_INFO, "%d files, %ldKb each, %ldMb total", num_files, (long)(file_size / 1024), (long)((file_size * num_files) / (1024 * 1024))); log_text(LOG_INFO, "Creating files for the test..."); for (i=0; i < num_files; i++) { snprintf(file_name, sizeof(file_name), "test_file.%d",i); unlink(file_name); fd = open(file_name, O_CREAT | O_WRONLY, S_IRUSR | S_IWUSR); if (fd < 0) { log_errno(LOG_FATAL, "Can't open file"); return 1; } for (offset = 0; offset < file_size; offset += file_block_size) { /* If in validation mode, fill buffer with random values and write checksum */ if (sb_globals.validate) file_fill_buffer(buffer, file_block_size, offset); if (write(fd, buffer, file_block_size) < 0) goto error; } /* fsync files to prevent cache flush from affecting test results */ #ifndef _WIN32 fsync(fd); #else _commit(fd); #endif close(fd); } return 0; error: log_errno(LOG_FATAL, "Failed to write file!"); close(fd); return 1; }
int file_execute_request(sb_request_t *sb_req, int thread_id) { FILE_DESCRIPTOR fd; sb_file_request_t *file_req = &sb_req->u.file_request; log_msg_t msg; log_msg_oper_t op_msg; if (sb_globals.debug) { log_text(LOG_DEBUG, "Executing request, operation: %d, file_id: %d, pos: %d, " "size: %d", file_req->operation, file_req->file_id, (int)file_req->pos, (int)file_req->size); } /* Check request parameters */ if (file_req->file_id > num_files) { log_text(LOG_FATAL, "Incorrect file discovered in request"); return 1; } if (file_req->pos + file_req->size > file_size) { log_text(LOG_FATAL, "Too large position discovered in request!"); return 1; } fd = files[file_req->file_id]; /* Prepare log message */ msg.type = LOG_MSG_TYPE_OPER; msg.data = &op_msg; switch (file_req->operation) { case FILE_OP_TYPE_NULL: log_text(LOG_FATAL, "Execute of NULL request called !, aborting"); return 1; case FILE_OP_TYPE_WRITE: /* Store checksum and offset in a buffer when in validation mode */ if (sb_globals.validate) file_fill_buffer(buffer, file_req->size, file_req->pos); LOG_EVENT_START(msg, thread_id); if(file_pwrite(file_req->file_id, buffer, file_req->size, file_req->pos, thread_id) != (ssize_t)file_req->size) { log_errno(LOG_FATAL, "Failed to write file! file: " FD_FMT " pos: %lld", fd, (long long)file_req->pos); return 1; } /* Check if we have to fsync each write operation */ if (file_fsync_all) { if (file_fsync(file_req->file_id, thread_id)) { log_errno(LOG_FATAL, "Failed to fsync file! file: " FD_FMT, fd); return 1; } } LOG_EVENT_STOP(msg, thread_id); SB_THREAD_MUTEX_LOCK(); write_ops++; real_write_ops++; bytes_written += file_req->size; if (file_fsync_all) other_ops++; SB_THREAD_MUTEX_UNLOCK(); break; case FILE_OP_TYPE_READ: LOG_EVENT_START(msg, thread_id); if(file_pread(file_req->file_id, buffer, file_req->size, file_req->pos, thread_id) != (ssize_t)file_req->size) { log_errno(LOG_FATAL, "Failed to read file! file: " FD_FMT " pos: %lld", fd, (long long)file_req->pos); return 1; } LOG_EVENT_STOP(msg, thread_id); /* Validate block if run with validation enabled */ if (sb_globals.validate && file_validate_buffer(buffer, file_req->size, file_req->pos)) { log_text(LOG_FATAL, "Validation failed on file " FD_FMT ", block offset 0x%x, exiting...", file_req->file_id, file_req->pos); return 1; } SB_THREAD_MUTEX_LOCK(); read_ops++; real_read_ops++; bytes_read += file_req->size; SB_THREAD_MUTEX_UNLOCK(); break; case FILE_OP_TYPE_FSYNC: /* Ignore fsync requests if we are already fsync'ing each operation */ if (file_fsync_all) break; if(file_fsync(file_req->file_id, thread_id)) { log_errno(LOG_FATAL, "Failed to fsync file! file: " FD_FMT, fd); return 1; } SB_THREAD_MUTEX_LOCK(); other_ops++; SB_THREAD_MUTEX_UNLOCK(); break; default: log_text(LOG_FATAL, "Execute of UNKNOWN file request type called (%d)!, " "aborting", file_req->operation); return 1; } return 0; }
/* * Create wave list player. */ PJ_DEF(pj_status_t) pjmedia_wav_playlist_create(pj_pool_t *pool, const pj_str_t *port_label, const pj_str_t file_list[], int file_count, unsigned ptime, unsigned options, pj_ssize_t buff_size, pjmedia_port **p_port) { struct playlist_port *fport; pj_off_t pos; pj_status_t status; int index; pj_bool_t has_wave_info = PJ_FALSE; pj_str_t tmp_port_label; char filename[PJ_MAXPATH]; /* filename for open operations. */ /* Check arguments. */ PJ_ASSERT_RETURN(pool && file_list && file_count && p_port, PJ_EINVAL); /* Normalize port_label */ if (port_label == NULL || port_label->slen == 0) { tmp_port_label = pj_str("WAV playlist"); port_label = &tmp_port_label; } /* Be sure all files exist */ for (index=0; index<file_count; index++) { PJ_ASSERT_RETURN(file_list[index].slen < PJ_MAXPATH, PJ_ENAMETOOLONG); pj_memcpy(filename, file_list[index].ptr, file_list[index].slen); filename[file_list[index].slen] = '\0'; /* Check the file really exists. */ if (!pj_file_exists(filename)) { PJ_LOG(4,(THIS_FILE, "WAV playlist error: file '%s' not found", filename)); return PJ_ENOTFOUND; } } /* Normalize ptime */ if (ptime == 0) ptime = 20; /* Create fport instance. */ fport = create_file_list_port(pool, port_label); if (!fport) { return PJ_ENOMEM; } /* start with the first file. */ fport->current_file = 0; fport->max_file = file_count; /* Create file descriptor list */ fport->fd_list = pj_pool_zalloc(pool, sizeof(pj_oshandle_t)*file_count); if (!fport->fd_list) { return PJ_ENOMEM; } /* Create file size list */ fport->fsize_list = pj_pool_alloc(pool, sizeof(pj_off_t)*file_count); if (!fport->fsize_list) { return PJ_ENOMEM; } /* Create start of WAVE data list */ fport->start_data_list = pj_pool_alloc(pool, sizeof(unsigned)*file_count); if (!fport->start_data_list) { return PJ_ENOMEM; } /* Create file position list */ fport->fpos_list = pj_pool_alloc(pool, sizeof(pj_off_t)*file_count); if (!fport->fpos_list) { return PJ_ENOMEM; } /* Create file buffer once for this operation. */ if (buff_size < 1) buff_size = PJMEDIA_FILE_PORT_BUFSIZE; fport->bufsize = buff_size; /* Create buffer. */ fport->buf = pj_pool_alloc(pool, fport->bufsize); if (!fport->buf) { return PJ_ENOMEM; } /* Initialize port */ fport->options = options; fport->readpos = fport->buf; /* ok run this for all files to be sure all are good for playback. */ for (index=file_count-1; index>=0; index--) { pjmedia_wave_hdr wavehdr; pj_ssize_t size_to_read, size_read; /* we end with the last one so we are good to go if still in function*/ pj_memcpy(filename, file_list[index].ptr, file_list[index].slen); filename[file_list[index].slen] = '\0'; /* Get the file size. */ fport->current_file = index; fport->fsize_list[index] = pj_file_size(filename); /* Size must be more than WAVE header size */ if (fport->fsize_list[index] <= sizeof(pjmedia_wave_hdr)) { status = PJMEDIA_ENOTVALIDWAVE; goto on_error; } /* Open file. */ status = pj_file_open( pool, filename, PJ_O_RDONLY, &fport->fd_list[index]); if (status != PJ_SUCCESS) goto on_error; /* Read the file header plus fmt header only. */ size_read = size_to_read = sizeof(wavehdr) - 8; status = pj_file_read( fport->fd_list[index], &wavehdr, &size_read); if (status != PJ_SUCCESS) { goto on_error; } if (size_read != size_to_read) { status = PJMEDIA_ENOTVALIDWAVE; goto on_error; } /* Normalize WAVE header fields values from little-endian to host * byte order. */ pjmedia_wave_hdr_file_to_host(&wavehdr); /* Validate WAVE file. */ if (wavehdr.riff_hdr.riff != PJMEDIA_RIFF_TAG || wavehdr.riff_hdr.wave != PJMEDIA_WAVE_TAG || wavehdr.fmt_hdr.fmt != PJMEDIA_FMT_TAG) { TRACE_((THIS_FILE, "actual value|expected riff=%x|%x, wave=%x|%x fmt=%x|%x", wavehdr.riff_hdr.riff, PJMEDIA_RIFF_TAG, wavehdr.riff_hdr.wave, PJMEDIA_WAVE_TAG, wavehdr.fmt_hdr.fmt, PJMEDIA_FMT_TAG)); status = PJMEDIA_ENOTVALIDWAVE; goto on_error; } /* Must be PCM with 16bits per sample */ if (wavehdr.fmt_hdr.fmt_tag != 1 || wavehdr.fmt_hdr.bits_per_sample != 16) { status = PJMEDIA_EWAVEUNSUPP; goto on_error; } /* Block align must be 2*nchannels */ if (wavehdr.fmt_hdr.block_align != wavehdr.fmt_hdr.nchan * BYTES_PER_SAMPLE) { status = PJMEDIA_EWAVEUNSUPP; goto on_error; } /* If length of fmt_header is greater than 16, skip the remaining * fmt header data. */ if (wavehdr.fmt_hdr.len > 16) { size_to_read = wavehdr.fmt_hdr.len - 16; status = pj_file_setpos(fport->fd_list[index], size_to_read, PJ_SEEK_CUR); if (status != PJ_SUCCESS) { goto on_error; } } /* Repeat reading the WAVE file until we have 'data' chunk */ for (;;) { pjmedia_wave_subchunk subchunk; size_read = 8; status = pj_file_read(fport->fd_list[index], &subchunk, &size_read); if (status != PJ_SUCCESS || size_read != 8) { status = PJMEDIA_EWAVETOOSHORT; goto on_error; } /* Normalize endianness */ PJMEDIA_WAVE_NORMALIZE_SUBCHUNK(&subchunk); /* Break if this is "data" chunk */ if (subchunk.id == PJMEDIA_DATA_TAG) { wavehdr.data_hdr.data = PJMEDIA_DATA_TAG; wavehdr.data_hdr.len = subchunk.len; break; } /* Otherwise skip the chunk contents */ size_to_read = subchunk.len; status = pj_file_setpos(fport->fd_list[index], size_to_read, PJ_SEEK_CUR); if (status != PJ_SUCCESS) { goto on_error; } } /* Current file position now points to start of data */ status = pj_file_getpos(fport->fd_list[index], &pos); fport->start_data_list[index] = (unsigned)pos; /* Validate length. */ if (wavehdr.data_hdr.len != fport->fsize_list[index] - fport->start_data_list[index]) { status = PJMEDIA_EWAVEUNSUPP; goto on_error; } if (wavehdr.data_hdr.len < 400) { status = PJMEDIA_EWAVETOOSHORT; goto on_error; } /* It seems like we have a valid WAVE file. */ /* Update port info if we don't have one, otherwise check * that the WAV file has the same attributes as previous files. */ if (!has_wave_info) { fport->base.info.channel_count = wavehdr.fmt_hdr.nchan; fport->base.info.clock_rate = wavehdr.fmt_hdr.sample_rate; fport->base.info.bits_per_sample = wavehdr.fmt_hdr.bits_per_sample; fport->base.info.samples_per_frame = fport->base.info.clock_rate * wavehdr.fmt_hdr.nchan * ptime / 1000; fport->base.info.bytes_per_frame = fport->base.info.samples_per_frame * fport->base.info.bits_per_sample / 8; has_wave_info = PJ_TRUE; } else { /* Check that this file has the same characteristics as the other * files. */ if (wavehdr.fmt_hdr.nchan != fport->base.info.channel_count || wavehdr.fmt_hdr.sample_rate != fport->base.info.clock_rate || wavehdr.fmt_hdr.bits_per_sample != fport->base.info.bits_per_sample) { /* This file has different characteristics than the other * files. */ PJ_LOG(4,(THIS_FILE, "WAV playlist error: file '%s' has differrent number" " of channels, sample rate, or bits per sample", filename)); status = PJMEDIA_EWAVEUNSUPP; goto on_error; } } /* Set initial position of the file. */ fport->fpos_list[index] = fport->start_data_list[index]; } /* Fill up the buffer. */ status = file_fill_buffer(fport); if (status != PJ_SUCCESS) { goto on_error; } /* Done. */ *p_port = &fport->base; PJ_LOG(4,(THIS_FILE, "WAV playlist '%.*s' created: samp.rate=%d, ch=%d, bufsize=%uKB", (int)port_label->slen, port_label->ptr, fport->base.info.clock_rate, fport->base.info.channel_count, fport->bufsize / 1000)); return PJ_SUCCESS; on_error: for (index=0; index<file_count; ++index) { if (fport->fd_list[index] != 0) pj_file_close(fport->fd_list[index]); } return status; }