std::shared_ptr<AVPacket> alloc_packet()
{
const auto packet = std::shared_ptr<AVPacket>(av_packet_alloc(), [](AVPacket* ptr) { av_packet_free(&ptr); });
if (!packet)
FF_RET(AVERROR(ENOMEM), "av_packet_alloc");
return packet;
}
void StreamReceiver::ReceiveFrame(uint8_t *data)
{
AVPacket *pkt = av_packet_alloc();
av_init_packet(pkt);
if (av_read_frame(avfmt, pkt) < 0)
return;
int got_picture;
if (avcodec_decode_video2(avctx, avframe, &got_picture, pkt) < 0)
return;
av_packet_unref(pkt);
av_packet_free(&pkt);
if (got_picture == 0)
return;
int linesize_align[AV_NUM_DATA_POINTERS];
avcodec_align_dimensions2(
avctx, &avframe->width, &avframe->height, linesize_align);
uint8_t *const dstSlice[] = { data };
int dstStride[] = { width * 4 };
if (data != nullptr)
sws_scale(
swctx,
avframe->data, avframe->linesize,
0, STREAM_HEIGHT,
dstSlice, dstStride);
av_frame_unref(avframe);
}
int Packet::SetPacket(AVPacket *pkt)
{
ASSERT(!m_Packet);
m_Packet = av_packet_alloc();
if (!m_Packet)
return -1;
return av_packet_ref(m_Packet, pkt);
}
AVPacket *av_packet_clone(AVPacket *src)
{
AVPacket *ret = av_packet_alloc();
if (!ret)
return ret;
if (av_packet_ref(ret, src))
av_packet_free(&ret);
return ret;
}
int av_bsf_alloc(const AVBitStreamFilter *filter, AVBSFContext **pctx)
{
AVBSFContext *ctx;
int ret;
ctx = av_mallocz(sizeof(*ctx));
if (!ctx)
return AVERROR(ENOMEM);
ctx->av_class = &bsf_class;
ctx->filter = filter;
ctx->par_in = avcodec_parameters_alloc();
ctx->par_out = avcodec_parameters_alloc();
if (!ctx->par_in || !ctx->par_out) {
ret = AVERROR(ENOMEM);
goto fail;
}
ctx->internal = av_mallocz(sizeof(*ctx->internal));
if (!ctx->internal) {
ret = AVERROR(ENOMEM);
goto fail;
}
ctx->internal->buffer_pkt = av_packet_alloc();
if (!ctx->internal->buffer_pkt) {
ret = AVERROR(ENOMEM);
goto fail;
}
av_opt_set_defaults(ctx);
/* allocate priv data and init private options */
if (filter->priv_data_size) {
ctx->priv_data = av_mallocz(filter->priv_data_size);
if (!ctx->priv_data) {
ret = AVERROR(ENOMEM);
goto fail;
}
if (filter->priv_class) {
*(const AVClass **)ctx->priv_data = filter->priv_class;
av_opt_set_defaults(ctx->priv_data);
}
}
*pctx = ctx;
return 0;
fail:
av_bsf_free(&ctx);
return ret;
}
int ff_bsf_get_packet(AVBSFContext *ctx, AVPacket **pkt)
{
AVBSFInternal *in = ctx->internal;
AVPacket *tmp_pkt;
if (in->eof)
return AVERROR_EOF;
if (!ctx->internal->buffer_pkt->data &&
!ctx->internal->buffer_pkt->side_data_elems)
return AVERROR(EAGAIN);
tmp_pkt = av_packet_alloc();
if (!tmp_pkt)
return AVERROR(ENOMEM);
*pkt = ctx->internal->buffer_pkt;
ctx->internal->buffer_pkt = tmp_pkt;
return 0;
}
struct mp_image *load_image_png_buf(void *buffer, size_t buffer_size, int imgfmt)
{
const AVCodec *codec = avcodec_find_decoder(AV_CODEC_ID_PNG);
if (!codec)
return NULL;
AVCodecContext *avctx = avcodec_alloc_context3(codec);
if (!avctx)
return NULL;
if (avcodec_open2(avctx, codec, NULL) < 0) {
avcodec_free_context(&avctx);
return NULL;
}
AVPacket *pkt = av_packet_alloc();
if (pkt) {
if (av_new_packet(pkt, buffer_size) >= 0)
memcpy(pkt->data, buffer, buffer_size);
}
// (There is only 1 outcome: either it takes it and decodes it, or not.)
avcodec_send_packet(avctx, pkt);
avcodec_send_packet(avctx, NULL);
av_packet_free(&pkt);
struct mp_image *res = NULL;
AVFrame *frame = av_frame_alloc();
if (frame && avcodec_receive_frame(avctx, frame) >= 0) {
struct mp_image *r = mp_image_from_av_frame(frame);
if (r)
res = convert_image(r, imgfmt, mp_null_log);
talloc_free(r);
}
av_frame_free(&frame);
avcodec_free_context(&avctx);
return res;
}
int Packet::SetDataSize(int len)
{
if (len < 0)
return -1;
if (len <= GetDataSize()) {
av_shrink_packet(m_Packet, len);
return 0;
}
if (!m_Packet) {
m_Packet = av_packet_alloc();
if (av_new_packet(m_Packet, len) < 0)
return -1;
}
else
{
if (av_grow_packet(m_Packet, (len - m_Packet->size)) < 0)
return -1;
}
return 0;
}
static BOOL ffmpeg_open_context(FREERDP_DSP_CONTEXT* context)
{
int ret;
int layout;
const AUDIO_FORMAT* format;
if (!context || context->isOpen)
return FALSE;
format = &context->format;
if (!format)
return FALSE;
layout = av_get_default_channel_layout(format->nChannels);
context->id = ffmpeg_get_avcodec(format);
if (ffmpeg_codec_is_filtered(context->id, context->encoder))
goto fail;
if (context->encoder)
context->codec = avcodec_find_encoder(context->id);
else
context->codec = avcodec_find_decoder(context->id);
if (!context->codec)
goto fail;
context->context = avcodec_alloc_context3(context->codec);
if (!context->context)
goto fail;
switch (context->id)
{
/* We need support for multichannel and sample rates != 8000 */
case AV_CODEC_ID_GSM_MS:
context->context->strict_std_compliance = FF_COMPLIANCE_UNOFFICIAL;
break;
default:
break;
}
context->context->channels = format->nChannels;
context->context->channel_layout = layout;
context->context->sample_rate = format->nSamplesPerSec;
context->context->block_align = format->nBlockAlign;
context->context->bit_rate = format->nAvgBytesPerSec * 8;
context->context->sample_fmt = ffmpeg_sample_format(format);
context->context->time_base = av_make_q(1, context->context->sample_rate);
if ((ret = avcodec_open2(context->context, context->codec, NULL)) < 0)
{
const char* err = av_err2str(ret);
WLog_ERR(TAG, "Error avcodec_open2 %s [%d]", err, ret);
goto fail;
}
context->packet = av_packet_alloc();
if (!context->packet)
goto fail;
context->frame = av_frame_alloc();
if (!context->frame)
goto fail;
context->resampled = av_frame_alloc();
if (!context->resampled)
goto fail;
context->buffered = av_frame_alloc();
if (!context->buffered)
goto fail;
context->rcontext = avresample_alloc_context();
if (!context->rcontext)
goto fail;
context->frame->channel_layout = layout;
context->frame->channels = format->nChannels;
context->frame->sample_rate = format->nSamplesPerSec;
context->frame->format = AV_SAMPLE_FMT_S16;
if (context->encoder)
{
context->resampled->format = context->context->sample_fmt;
context->resampled->sample_rate = context->context->sample_rate;
}
else
{
context->resampled->format = AV_SAMPLE_FMT_S16;
context->resampled->sample_rate = format->nSamplesPerSec;
}
context->resampled->channel_layout = layout;
context->resampled->channels = format->nChannels;
if (context->context->frame_size > 0)
{
context->buffered->channel_layout = context->resampled->channel_layout;
context->buffered->channels = context->resampled->channels;
context->buffered->format = context->resampled->format;
context->buffered->nb_samples = context->context->frame_size;
if ((ret = av_frame_get_buffer(context->buffered, 1)) < 0)
goto fail;
}
context->isOpen = TRUE;
return TRUE;
fail:
ffmpeg_close_context(context);
return FALSE;
}
FFMPEGWriter::FFMPEGWriter(std::string filename, DeviceSpecs specs, Container format, Codec codec, unsigned int bitrate) :
m_position(0),
m_specs(specs),
m_formatCtx(nullptr),
m_codecCtx(nullptr),
m_stream(nullptr),
m_packet(nullptr),
m_frame(nullptr),
m_input_samples(0),
m_deinterleave(false)
{
static const char* formats[] = { nullptr, "ac3", "flac", "matroska", "mp2", "mp3", "ogg", "wav" };
if(avformat_alloc_output_context2(&m_formatCtx, nullptr, formats[format], filename.c_str()) < 0)
AUD_THROW(FileException, "File couldn't be written, format couldn't be found with ffmpeg.");
AVOutputFormat* outputFmt = m_formatCtx->oformat;
if(!outputFmt) {
avformat_free_context(m_formatCtx);
AUD_THROW(FileException, "File couldn't be written, output format couldn't be found with ffmpeg.");
}
outputFmt->audio_codec = AV_CODEC_ID_NONE;
switch(codec)
{
case CODEC_AAC:
outputFmt->audio_codec = AV_CODEC_ID_AAC;
break;
case CODEC_AC3:
outputFmt->audio_codec = AV_CODEC_ID_AC3;
break;
case CODEC_FLAC:
outputFmt->audio_codec = AV_CODEC_ID_FLAC;
break;
case CODEC_MP2:
outputFmt->audio_codec = AV_CODEC_ID_MP2;
break;
case CODEC_MP3:
outputFmt->audio_codec = AV_CODEC_ID_MP3;
break;
case CODEC_OPUS:
outputFmt->audio_codec = AV_CODEC_ID_OPUS;
break;
case CODEC_PCM:
switch(specs.format)
{
case FORMAT_U8:
outputFmt->audio_codec = AV_CODEC_ID_PCM_U8;
break;
case FORMAT_S16:
outputFmt->audio_codec = AV_CODEC_ID_PCM_S16LE;
break;
case FORMAT_S24:
outputFmt->audio_codec = AV_CODEC_ID_PCM_S24LE;
break;
case FORMAT_S32:
outputFmt->audio_codec = AV_CODEC_ID_PCM_S32LE;
break;
case FORMAT_FLOAT32:
outputFmt->audio_codec = AV_CODEC_ID_PCM_F32LE;
break;
case FORMAT_FLOAT64:
outputFmt->audio_codec = AV_CODEC_ID_PCM_F64LE;
break;
default:
outputFmt->audio_codec = AV_CODEC_ID_NONE;
break;
}
break;
case CODEC_VORBIS:
outputFmt->audio_codec = AV_CODEC_ID_VORBIS;
break;
default:
outputFmt->audio_codec = AV_CODEC_ID_NONE;
break;
}
uint64_t channel_layout = 0;
switch(m_specs.channels)
{
case CHANNELS_MONO:
channel_layout = AV_CH_LAYOUT_MONO;
break;
case CHANNELS_STEREO:
channel_layout = AV_CH_LAYOUT_STEREO;
break;
case CHANNELS_STEREO_LFE:
channel_layout = AV_CH_LAYOUT_2POINT1;
break;
case CHANNELS_SURROUND4:
channel_layout = AV_CH_LAYOUT_QUAD;
break;
case CHANNELS_SURROUND5:
channel_layout = AV_CH_LAYOUT_5POINT0_BACK;
break;
case CHANNELS_SURROUND51:
channel_layout = AV_CH_LAYOUT_5POINT1_BACK;
break;
case CHANNELS_SURROUND61:
channel_layout = AV_CH_LAYOUT_6POINT1_BACK;
break;
case CHANNELS_SURROUND71:
channel_layout = AV_CH_LAYOUT_7POINT1;
break;
default:
AUD_THROW(FileException, "File couldn't be written, channel layout not supported.");
}
try
{
if(outputFmt->audio_codec == AV_CODEC_ID_NONE)
AUD_THROW(FileException, "File couldn't be written, audio codec not found with ffmpeg.");
AVCodec* codec = avcodec_find_encoder(outputFmt->audio_codec);
if(!codec)
AUD_THROW(FileException, "File couldn't be written, audio encoder couldn't be found with ffmpeg.");
m_stream = avformat_new_stream(m_formatCtx, codec);
if(!m_stream)
AUD_THROW(FileException, "File couldn't be written, stream creation failed with ffmpeg.");
m_stream->id = m_formatCtx->nb_streams - 1;
#ifdef FFMPEG_OLD_CODE
m_codecCtx = m_stream->codec;
#else
m_codecCtx = avcodec_alloc_context3(codec);
#endif
if(!m_codecCtx)
AUD_THROW(FileException, "File couldn't be written, context creation failed with ffmpeg.");
switch(m_specs.format)
{
case FORMAT_U8:
m_convert = convert_float_u8;
m_codecCtx->sample_fmt = AV_SAMPLE_FMT_U8;
break;
case FORMAT_S16:
m_convert = convert_float_s16;
m_codecCtx->sample_fmt = AV_SAMPLE_FMT_S16;
break;
case FORMAT_S32:
m_convert = convert_float_s32;
m_codecCtx->sample_fmt = AV_SAMPLE_FMT_S32;
break;
case FORMAT_FLOAT64:
m_convert = convert_float_double;
m_codecCtx->sample_fmt = AV_SAMPLE_FMT_DBL;
break;
default:
m_convert = convert_copy<sample_t>;
m_codecCtx->sample_fmt = AV_SAMPLE_FMT_FLT;
break;
}
if(m_formatCtx->oformat->flags & AVFMT_GLOBALHEADER)
m_codecCtx->flags |= AV_CODEC_FLAG_GLOBAL_HEADER;
bool format_supported = false;
for(int i = 0; codec->sample_fmts[i] != -1; i++)
{
if(av_get_alt_sample_fmt(codec->sample_fmts[i], false) == m_codecCtx->sample_fmt)
{
m_deinterleave = av_sample_fmt_is_planar(codec->sample_fmts[i]);
m_codecCtx->sample_fmt = codec->sample_fmts[i];
format_supported = true;
}
}
if(!format_supported)
{
int chosen_index = 0;
auto chosen = av_get_alt_sample_fmt(codec->sample_fmts[chosen_index], false);
for(int i = 1; codec->sample_fmts[i] != -1; i++)
{
auto fmt = av_get_alt_sample_fmt(codec->sample_fmts[i], false);
if((fmt > chosen && chosen < m_codecCtx->sample_fmt) || (fmt > m_codecCtx->sample_fmt && fmt < chosen))
{
chosen = fmt;
chosen_index = i;
}
}
m_codecCtx->sample_fmt = codec->sample_fmts[chosen_index];
m_deinterleave = av_sample_fmt_is_planar(m_codecCtx->sample_fmt);
switch(av_get_alt_sample_fmt(m_codecCtx->sample_fmt, false))
{
case AV_SAMPLE_FMT_U8:
specs.format = FORMAT_U8;
m_convert = convert_float_u8;
break;
case AV_SAMPLE_FMT_S16:
specs.format = FORMAT_S16;
m_convert = convert_float_s16;
break;
case AV_SAMPLE_FMT_S32:
specs.format = FORMAT_S32;
m_convert = convert_float_s32;
break;
case AV_SAMPLE_FMT_FLT:
specs.format = FORMAT_FLOAT32;
m_convert = convert_copy<sample_t>;
break;
case AV_SAMPLE_FMT_DBL:
specs.format = FORMAT_FLOAT64;
m_convert = convert_float_double;
break;
default:
AUD_THROW(FileException, "File couldn't be written, sample format not supported with ffmpeg.");
}
}
m_codecCtx->sample_rate = 0;
if(codec->supported_samplerates)
{
for(int i = 0; codec->supported_samplerates[i]; i++)
{
if(codec->supported_samplerates[i] == m_specs.rate)
{
m_codecCtx->sample_rate = codec->supported_samplerates[i];
break;
}
else if((codec->supported_samplerates[i] > m_codecCtx->sample_rate && m_specs.rate > m_codecCtx->sample_rate) ||
(codec->supported_samplerates[i] < m_codecCtx->sample_rate && m_specs.rate < codec->supported_samplerates[i]))
{
m_codecCtx->sample_rate = codec->supported_samplerates[i];
}
}
}
if(m_codecCtx->sample_rate == 0)
m_codecCtx->sample_rate = m_specs.rate;
m_specs.rate = m_codecCtx->sample_rate;
#ifdef FFMPEG_OLD_CODE
m_codecCtx->codec_id = outputFmt->audio_codec;
#endif
m_codecCtx->codec_type = AVMEDIA_TYPE_AUDIO;
m_codecCtx->bit_rate = bitrate;
m_codecCtx->channel_layout = channel_layout;
m_codecCtx->channels = m_specs.channels;
m_stream->time_base.num = m_codecCtx->time_base.num = 1;
m_stream->time_base.den = m_codecCtx->time_base.den = m_codecCtx->sample_rate;
if(avcodec_open2(m_codecCtx, codec, nullptr) < 0)
AUD_THROW(FileException, "File couldn't be written, encoder couldn't be opened with ffmpeg.");
#ifndef FFMPEG_OLD_CODE
if(avcodec_parameters_from_context(m_stream->codecpar, m_codecCtx) < 0)
AUD_THROW(FileException, "File couldn't be written, codec parameters couldn't be copied to the context.");
#endif
int samplesize = std::max(int(AUD_SAMPLE_SIZE(m_specs)), AUD_DEVICE_SAMPLE_SIZE(m_specs));
if((m_input_size = m_codecCtx->frame_size))
m_input_buffer.resize(m_input_size * samplesize);
if(avio_open(&m_formatCtx->pb, filename.c_str(), AVIO_FLAG_WRITE))
AUD_THROW(FileException, "File couldn't be written, file opening failed with ffmpeg.");
if(avformat_write_header(m_formatCtx, nullptr) < 0)
AUD_THROW(FileException, "File couldn't be written, writing the header failed.");
}
catch(Exception&)
{
#ifndef FFMPEG_OLD_CODE
if(m_codecCtx)
avcodec_free_context(&m_codecCtx);
#endif
avformat_free_context(m_formatCtx);
throw;
}
#ifdef FFMPEG_OLD_CODE
m_packet = new AVPacket({});
#else
m_packet = av_packet_alloc();
#endif
m_frame = av_frame_alloc();
}
int h265_encode(struct videnc_state *st, bool update,
const struct vidframe *frame, uint64_t timestamp)
{
AVFrame *pict = NULL;
AVPacket *pkt = NULL;
uint64_t rtp_ts;
int i, ret, got_packet = 0, err = 0;
if (!st || !frame)
return EINVAL;
if (!st->ctx || !vidsz_cmp(&st->size, &frame->size) ||
st->fmt != frame->fmt) {
enum AVPixelFormat pix_fmt;
pix_fmt = vidfmt_to_avpixfmt(frame->fmt);
if (pix_fmt == AV_PIX_FMT_NONE) {
warning("h265: encode: pixel format not supported"
" (%s)\n", vidfmt_name(frame->fmt));
return ENOTSUP;
}
debug("h265: encoder: reset %u x %u (%s)\n",
frame->size.w, frame->size.h, vidfmt_name(frame->fmt));
err = open_encoder(st, &frame->size, pix_fmt);
if (err)
return err;
st->size = frame->size;
st->fmt = frame->fmt;
}
pict = av_frame_alloc();
if (!pict) {
err = ENOMEM;
goto out;
}
pict->format = st->ctx->pix_fmt;
pict->width = frame->size.w;
pict->height = frame->size.h;
pict->pts = timestamp;
for (i=0; i<4; i++) {
pict->data[i] = frame->data[i];
pict->linesize[i] = frame->linesize[i];
}
if (update) {
debug("h265: encoder picture update\n");
pict->key_frame = 1;
pict->pict_type = AV_PICTURE_TYPE_I;
}
#if LIBAVUTIL_VERSION_MAJOR >= 55
pict->color_range = AVCOL_RANGE_MPEG;
#endif
#if LIBAVCODEC_VERSION_INT >= AV_VERSION_INT(57, 37, 100)
pkt = av_packet_alloc();
if (!pkt) {
err = ENOMEM;
goto out;
}
ret = avcodec_send_frame(st->ctx, pict);
if (ret < 0) {
err = EBADMSG;
goto out;
}
/* NOTE: packet contains 4-byte startcode */
ret = avcodec_receive_packet(st->ctx, pkt);
if (ret < 0) {
info("h265: no packet yet ..\n");
err = 0;
goto out;
}
got_packet = 1;
#else
pkt = av_malloc(sizeof(*pkt));
if (!pkt) {
err = ENOMEM;
goto out;
}
av_init_packet(pkt);
av_new_packet(pkt, 65536);
ret = avcodec_encode_video2(st->ctx, pkt, pict, &got_packet);
if (ret < 0) {
err = EBADMSG;
goto out;
}
#endif
if (!got_packet)
goto out;
rtp_ts = video_calc_rtp_timestamp_fix(pkt->dts);
err = packetize_annexb(rtp_ts, pkt->data, pkt->size,
st->pktsize, st->pkth, st->arg);
if (err)
goto out;
out:
if (pict)
av_free(pict);
if (pkt)
av_packet_free(&pkt);
return err;
}
int main(int argc, char **argv)
{
const char *filename, *outfilename;
const AVCodec *codec;
AVCodecParserContext *parser;
AVCodecContext *c= NULL;
FILE *f;
AVFrame *picture;
uint8_t inbuf[INBUF_SIZE + AV_INPUT_BUFFER_PADDING_SIZE];
uint8_t *data;
size_t data_size;
int ret;
AVPacket *pkt;
if (argc <= 2) {
fprintf(stderr, "Usage: %s <input file> <output file>\n", argv[0]);
exit(0);
}
filename = argv[1];
outfilename = argv[2];
avcodec_register_all();
pkt = av_packet_alloc();
if (!pkt)
exit(1);
/* set end of buffer to 0 (this ensures that no overreading happens for damaged MPEG streams) */
memset(inbuf + INBUF_SIZE, 0, AV_INPUT_BUFFER_PADDING_SIZE);
/* find the MPEG-1 video decoder */
codec = avcodec_find_decoder(AV_CODEC_ID_MPEG1VIDEO);
if (!codec) {
fprintf(stderr, "codec not found\n");
exit(1);
}
parser = av_parser_init(codec->id);
if (!parser) {
fprintf(stderr, "parser not found\n");
exit(1);
}
c = avcodec_alloc_context3(codec);
picture = av_frame_alloc();
/* For some codecs, such as msmpeg4 and mpeg4, width and height
MUST be initialized there because this information is not
available in the bitstream. */
/* open it */
if (avcodec_open2(c, codec, NULL) < 0) {
fprintf(stderr, "could not open codec\n");
exit(1);
}
f = fopen(filename, "rb");
if (!f) {
fprintf(stderr, "could not open %s\n", filename);
exit(1);
}
while (!feof(f)) {
/* read raw data from the input file */
data_size = fread(inbuf, 1, INBUF_SIZE, f);
if (!data_size)
break;
/* use the parser to split the data into frames */
data = inbuf;
while (data_size > 0) {
ret = av_parser_parse2(parser, c, &pkt->data, &pkt->size,
data, data_size, AV_NOPTS_VALUE, AV_NOPTS_VALUE, 0);
if (ret < 0) {
fprintf(stderr, "Error while parsing\n");
exit(1);
}
data += ret;
data_size -= ret;
if (pkt->size)
decode(c, picture, pkt, outfilename);
}
}
/* flush the decoder */
decode(c, picture, NULL, outfilename);
fclose(f);
av_parser_close(parser);
avcodec_free_context(&c);
av_frame_free(&picture);
av_packet_free(&pkt);
return 0;
}
MediaPacket::MediaPacket()
{
pAvPacket_ = av_packet_alloc();
av_init_packet(pAvPacket_);
}
MediaPacket::MediaPacket(IN FeedFrame & feedFrame) {
AVCodecParameters *param = avcodec_parameters_alloc();
shouldFreeAvCodecParameters = true;
enum AVCodecID codecId;
switch(feedFrame.type_) {
case ReceiverType::H264 :
stream_ = AVMEDIA_TYPE_VIDEO;
codecId = AV_CODEC_ID_H264;
break;
case ReceiverType::H265 :
stream_ = AVMEDIA_TYPE_VIDEO;
codecId = AV_CODEC_ID_HEVC;
break;
case ReceiverType::G711A :
stream_ = AVMEDIA_TYPE_AUDIO;
codecId = AV_CODEC_ID_PCM_ALAW;
break;
case ReceiverType::G711U :
stream_ = AVMEDIA_TYPE_AUDIO;
codecId = AV_CODEC_ID_PCM_MULAW;
break;
case ReceiverType::PCMS16E :
stream_ = AVMEDIA_TYPE_AUDIO;
codecId = AV_CODEC_ID_PCM_S16LE;
break;
case ReceiverType::AACNoAdts :
case ReceiverType::AACAdts :
stream_ = AVMEDIA_TYPE_AUDIO;
codecId = AV_CODEC_ID_AAC;
break;
default:
codecId = AV_CODEC_ID_NONE;
}
SetCodec(codecId);
switch(feedFrame.type_) {
case ReceiverType::G711A :
case ReceiverType::PCMS16E :
case ReceiverType::G711U :
param->channels = 1;
param->channel_layout = AV_CH_LAYOUT_MONO;
param->sample_rate = 8000;
param->codec_id = codecId;
param->codec_type = AVMEDIA_TYPE_AUDIO;
param->format = AV_SAMPLE_FMT_S16;
param->bits_per_coded_sample = 8;
param->bits_per_raw_sample = 16;
if (ReceiverType::PCMS16E == feedFrame.type_)
param->bits_per_coded_sample = 16;
break;
default:
codecId = AV_CODEC_ID_NONE;
}
pAvCodecPar_ = param;
AVPacket* pAvPacket = av_packet_alloc();
av_init_packet(pAvPacket);
pAvPacket->data = reinterpret_cast<uint8_t *>(feedFrame.data_.data());
pAvPacket->size = feedFrame.data_.size();
pAvPacket->pts = feedFrame.nPts_;
pAvPacket->dts = feedFrame.nDts_;
pAvPacket_ = const_cast<AVPacket*>(pAvPacket);
}
int main(int argc, char **argv)
{
const char *filename;
const AVCodec *codec;
AVCodecContext *c = NULL;
AVFrame *frame;
AVPacket *pkt;
int i, j, k, ret;
FILE *f;
uint16_t *samples;
float t, tincr;
if (argc <= 1) {
fprintf(stderr, "Usage: %s <output file>\n", argv[0]);
return 0;
}
filename = argv[1];
/* find the MP2 encoder */
codec = avcodec_find_encoder(AV_CODEC_ID_MP2);
if (!codec) {
fprintf(stderr, "Codec not found\n");
exit(1);
}
c = avcodec_alloc_context3(codec);
if (!c) {
fprintf(stderr, "Could not allocate audio codec context\n");
exit(1);
}
/* put sample parameters */
c->bit_rate = 64000;
/* check that the encoder supports s16 pcm input */
c->sample_fmt = AV_SAMPLE_FMT_S16;
if (!check_sample_fmt(codec, c->sample_fmt)) {
fprintf(stderr, "Encoder does not support sample format %s",
av_get_sample_fmt_name(c->sample_fmt));
exit(1);
}
/* select other audio parameters supported by the encoder */
c->sample_rate = select_sample_rate(codec);
c->channel_layout = select_channel_layout(codec);
c->channels = av_get_channel_layout_nb_channels(c->channel_layout);
/* open it */
if (avcodec_open2(c, codec, NULL) < 0) {
fprintf(stderr, "Could not open codec\n");
exit(1);
}
f = fopen(filename, "wb");
if (!f) {
fprintf(stderr, "Could not open %s\n", filename);
exit(1);
}
/* packet for holding encoded output */
pkt = av_packet_alloc();
if (!pkt) {
fprintf(stderr, "could not allocate the packet\n");
exit(1);
}
/* frame containing input raw audio */
frame = av_frame_alloc();
if (!frame) {
fprintf(stderr, "Could not allocate audio frame\n");
exit(1);
}
frame->nb_samples = c->frame_size;
frame->format = c->sample_fmt;
frame->channel_layout = c->channel_layout;
/* allocate the data buffers */
ret = av_frame_get_buffer(frame, 0);
if (ret < 0) {
fprintf(stderr, "Could not allocate audio data buffers\n");
exit(1);
}
/* encode a single tone sound */
t = 0;
tincr = 2 * M_PI * 440.0 / c->sample_rate;
for (i = 0; i < 200; i++) {
/* make sure the frame is writable -- makes a copy if the encoder
* kept a reference internally */
ret = av_frame_make_writable(frame);
if (ret < 0)
exit(1);
samples = (uint16_t*)frame->data[0];
for (j = 0; j < c->frame_size; j++) {
samples[2 * j] = (int)(sin(t) * 10000);
for (k = 1; k < c->channels; k++)
samples[2 * j + k] = samples[2 * j];
t += tincr;
}
encode(c, frame, pkt, f);
}
/* flush the encoder */
encode(c, NULL, pkt, f);
fclose(f);
av_frame_free(&frame);
av_packet_free(&pkt);
avcodec_free_context(&c);
return 0;
}
bool FormatContext::open(const QString &_url, const QString ¶m)
{
static const QStringList disabledDemuxers {
"ass",
"tty", //txt files
"srt",
};
const QByteArray scheme = Functions::getUrlScheme(_url).toUtf8();
if (scheme.isEmpty() || scheme == "sftp")
return false;
const Settings &settings = QMPlay2Core.getSettings();
artistWithTitle = !settings.getBool("HideArtistMetadata");
bool limitedLength = false;
qint64 oggOffset = -1, oggSize = -1;
int oggTrack = -1;
QString url;
if (param.startsWith("CUE:")) //For CUE files
{
const QStringList splitted = param.split(':');
if (splitted.count() != 3)
return false;
bool ok1 = false, ok2 = false;
startTime = splitted[1].toDouble(&ok1);
lengthToPlay = splitted[2].toDouble(&ok2);
if (!ok1 || !ok2 || startTime < 0.0 || (!qFuzzyCompare(lengthToPlay, -1.0) && lengthToPlay <= 0.0))
return false;
if (lengthToPlay > 0.0)
lengthToPlay -= startTime;
limitedLength = true;
}
else if (param.startsWith("OGG:")) //For chained OGG files
{
const QStringList splitted = param.split(':');
if (splitted.count() != 4)
return false;
oggTrack = splitted[1].toInt();
oggOffset = splitted[2].toLongLong();
oggSize = splitted[3].toLongLong();
if (oggTrack <= 0 || oggOffset < 0 || (oggSize != -1 && oggSize <= 0))
return false;
}
AVInputFormat *inputFmt = nullptr;
if (scheme == "file")
isLocal = true;
else
{
inputFmt = av_find_input_format(scheme);
if (inputFmt)
url = _url.right(_url.length() - scheme.length() - 3);
isLocal = false;
}
AVDictionary *options = nullptr;
if (!inputFmt)
{
url = Functions::prepareFFmpegUrl(_url, options);
if (!isLocal && reconnectStreamed)
av_dict_set(&options, "reconnect_streamed", "1", 0);
}
formatCtx = avformat_alloc_context();
formatCtx->interrupt_callback.callback = (int(*)(void *))interruptCB;
formatCtx->interrupt_callback.opaque = &abortCtx->isAborted;
if (oggOffset >= 0)
{
oggHelper = new OggHelper(url, oggTrack, oggSize, formatCtx->interrupt_callback);
if (!oggHelper->pb)
return false;
formatCtx->pb = oggHelper->pb;
av_dict_set(&options, "skip_initial_bytes", QString::number(oggOffset).toLatin1(), 0);
}
// Useful, e.g. CUVID decoder needs valid PTS
formatCtx->flags |= AVFMT_FLAG_GENPTS;
OpenFmtCtxThr *openThr = new OpenFmtCtxThr(formatCtx, url.toUtf8(), inputFmt, options, abortCtx);
formatCtx = openThr->getFormatCtx();
openThr->drop();
if (!formatCtx || disabledDemuxers.contains(name()))
return false;
if (name().startsWith("image2") || name().endsWith("_pipe"))
{
if (!settings.getBool("StillImages"))
return false;
stillImage = true;
}
if (name() == "mp3")
formatCtx->flags |= AVFMT_FLAG_FAST_SEEK; //This should be set before "avformat_open_input", but seems to be working for MP3...
if (avformat_find_stream_info(formatCtx, nullptr) < 0)
return false;
isStreamed = !isLocal && formatCtx->duration <= 0; //QMPLAY2_NOPTS_VALUE is negative
#ifdef QMPlay2_libavdevice
forceCopy = name().contains("v4l2"); //Workaround for v4l2 - if many buffers are referenced demuxer doesn't produce proper timestamps (FFmpeg BUG?).
#else
forceCopy = false;
#endif
if (!limitedLength && (startTime = formatCtx->start_time / (double)AV_TIME_BASE) < 0.0)
startTime = 0.0;
if (limitedLength && lengthToPlay < 0.0)
{
lengthToPlay = length() - startTime;
if (lengthToPlay <= 0.0)
return false;
}
index_map.resize(formatCtx->nb_streams);
streamsTS.resize(formatCtx->nb_streams);
streamsOffset.resize(formatCtx->nb_streams);
nextDts.resize(formatCtx->nb_streams);
for (unsigned i = 0; i < formatCtx->nb_streams; ++i)
{
fixFontsAttachment(formatCtx->streams[i]);
StreamInfo *streamInfo = getStreamInfo(formatCtx->streams[i]);
if (!streamInfo)
index_map[i] = -1;
else
{
index_map[i] = streamsInfo.count();
streamsInfo += streamInfo;
}
if (!fixMkvAss && formatCtx->streams[i]->codecpar->codec_id == AV_CODEC_ID_ASS && !strncasecmp(formatCtx->iformat->name, "matroska", 8))
fixMkvAss = true;
formatCtx->streams[i]->event_flags = 0;
streams += formatCtx->streams[i];
streamsTS[i] = 0.0;
}
if (streamsInfo.isEmpty())
return false;
isOneStreamOgg = (name() == "ogg" && streamsInfo.count() == 1); //Workaround for OGG network streams
if (isStreamed && streamsInfo.count() == 1 && streamsInfo.at(0)->type == QMPLAY2_TYPE_SUBTITLE && formatCtx->pb && avio_size(formatCtx->pb) > 0)
isStreamed = false; //Allow subtitles streams to be non-streamed if size is known
formatCtx->event_flags = 0;
packet = av_packet_alloc();
if (lengthToPlay > 0.0)
return seek(0.0, false);
return true;
}
