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; }