Recherche avancée
Médias (1)
-
Bug de détection d’ogg
22 mars 2013, par
Mis à jour : Avril 2013
Langue : français
Type : Video
Autres articles (53)
-
Configurer la prise en compte des langues
15 novembre 2010, parAccéder à la configuration et ajouter des langues prises en compte
Afin de configurer la prise en compte de nouvelles langues, il est nécessaire de se rendre dans la partie "Administrer" du site.
De là, dans le menu de navigation, vous pouvez accéder à une partie "Gestion des langues" permettant d’activer la prise en compte de nouvelles langues.
Chaque nouvelle langue ajoutée reste désactivable tant qu’aucun objet n’est créé dans cette langue. Dans ce cas, elle devient grisée dans la configuration et (...) -
Personnaliser en ajoutant son logo, sa bannière ou son image de fond
5 septembre 2013, parCertains thèmes prennent en compte trois éléments de personnalisation : l’ajout d’un logo ; l’ajout d’une bannière l’ajout d’une image de fond ;
-
Publier sur MédiaSpip
13 juin 2013Puis-je poster des contenus à partir d’une tablette Ipad ?
Oui, si votre Médiaspip installé est à la version 0.2 ou supérieure. Contacter au besoin l’administrateur de votre MédiaSpip pour le savoir
Sur d’autres sites (7009)
-
Encoding YUV file (uncompressed video) to mp4 playable file using H264 encoding with ffmpeg c++ (NOT command line)
20 avril 2023, par devprogMy goal is to encode a yuv file to a playable mp4 file (can be played with VLC) with ffmpeg c++ code.


First I have a source_1920x1080p30.mpg video (compressed) file.
Using ffmpeg CLI I created output_test.yuv file.

ffmpeg -i source_1920x1080p30.mpg -c:v rawvideo -pix_fmt yuv420p output_test.yuv

I used
ffplay -f rawvideo -pixel_format yuv420p -video_size 1920x1080 output_test.yuvwhich played well.
Also usedffmpeg -f rawvideo -pix_fmt yuv420p -s:v 1920x1080 -r 30 -i output_test.yuv -c:v libx264 vid.mp4
and the new vid.mp4 was playble.
So I have good yuv file.

I want to encode this output_test.yuv YUV file with ffmpeg by code.
I tested the ffmpeg site encode example ffmpeg site encode example and it was running good.


In that example, the frames are self made inside the code - But I want that the input would be my YUV file.


Becasue I used ffmpeg CLI to convert YUV to mp4 (as noted above) I am sure it can be done by code - but I dont how..


So, I tried to add to their example the use of the methods :
avformat_open_input() & avformat_find_stream_info()


#include 
#include 
#include 

extern "C" {
#include <libavformat></libavformat>avformat.h>
#include <libavcodec></libavcodec>avcodec.h>
 
#include <libavutil></libavutil>opt.h>
#include <libavutil></libavutil>imgutils.h>
} 
// ffmpeg method.
static void encode(AVCodecContext *enc_ctx, AVFrame *frame, AVPacket *pkt,
 FILE *outfile)
{
 int ret;
 
 /* send the frame to the encoder */
 if (frame)
 printf("Send frame %3" PRId64 "\n", frame->pts);
 
 ret = avcodec_send_frame(enc_ctx, frame);
 if (ret < 0) {
 fprintf(stderr, "Error sending a frame for encoding\n");
 exit(1);
 }
 
 while (ret >= 0) {
 ret = avcodec_receive_packet(enc_ctx, pkt);
 if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF)
 return;
 else if (ret < 0) {
 fprintf(stderr, "Error during encoding\n");
 exit(1);
 }
 
 printf("Write packet %3" PRId64 " (size=%5d)\n", pkt->pts, pkt->size);
 fwrite(pkt->data, 1, pkt->size, outfile);
 av_packet_unref(pkt);
 }
}

int main(int argc, char **argv)
{
 
 int ret;
 char errbuf[100];

 AVFormatContext* ifmt_ctx = avformat_alloc_context();

 AVDictionary* options = NULL;
 //av_dict_set(&options, "framerate", "30", 0);
 av_dict_set(&options, "video_size", "1920x1080", 0);
 av_dict_set(&options,"pixel_format", "yuv420p",0);
 av_dict_set(&options, "vcodec", "rawvideo", 0);

 if ((ret = avformat_open_input(&ifmt_ctx, "output_test.yuv", NULL, &options)) < 0) {
 av_strerror(ret, errbuf, sizeof(errbuf));
 fprintf(stderr, "Unable to open err=%s\n", errbuf);
 }

 const AVCodec *pCodec = avcodec_find_decoder(AV_CODEC_ID_RAWVIDEO); //Get pointer to rawvideo codec.

 AVCodecContext *pCodecContext = avcodec_alloc_context3(pCodec); //Allocate codec context.

 //Fill the codec context based on the values from the codec parameters.
 AVStream *vid_stream = ifmt_ctx->streams[0];
 avcodec_parameters_to_context(pCodecContext, vid_stream->codecpar);

 avcodec_open2(pCodecContext, pCodec, NULL); //Open the codec

 //Allocate memory for packet and frame
 AVPacket *pPacket = av_packet_alloc();
 AVFrame *pFrame = av_frame_alloc();

 // For output use:
 
 const char *filename, *codec_name;
 const AVCodec *codec;
 AVCodecContext *c= NULL;
 int i, x, y;
 FILE *f;
 // origin ffmpeg code - AVFrame *frame;
 AVPacket *pkt;
 uint8_t endcode[] = { 0, 0, 1, 0xb7 };
 
 if (argc <= 2) {
 fprintf(stderr, "Usage: %s <output file="file"> <codec>\n", argv[0]);
 exit(0);
 }
 filename = argv[1];
 codec_name = argv[2];
 
 /* find the mpeg1video encoder */
 codec = avcodec_find_encoder_by_name(codec_name);
 if (!codec) {
 fprintf(stderr, "Codec '%s' not found\n", codec_name);
 exit(1);
 }
 
 c = avcodec_alloc_context3(codec);
 if (!c) {
 fprintf(stderr, "Could not allocate video codec context\n");
 exit(1);
 }
 
 pkt = av_packet_alloc();
 if (!pkt)
 exit(1);
 
 /* put sample parameters */
 c->bit_rate = 400000;
 /* resolution must be a multiple of two */
 c->width = 352;
 c->height = 288;
 /* frames per second */
 c->time_base = (AVRational){1, 25};
 c->framerate = (AVRational){25, 1};
 
 /* emit one intra frame every ten frames
 * check frame pict_type before passing frame
 * to encoder, if frame->pict_type is AV_PICTURE_TYPE_I
 * then gop_size is ignored and the output of encoder
 * will always be I frame irrespective to gop_size
 */
 c->gop_size = 10;
 c->max_b_frames = 1;
 c->pix_fmt = AV_PIX_FMT_YUV420P;
 
 if (codec->id == AV_CODEC_ID_H264)
 av_opt_set(c->priv_data, "preset", "slow", 0);
 
 /* open it */
 ret = avcodec_open2(c, codec, NULL);
 if (ret < 0) {
 //fprintf(stderr, "Could not open codec: %s\n", av_err2str(ret));
 exit(1);
 }
 
 f = fopen(filename, "wb");
 if (!f) {
 fprintf(stderr, "Could not open %s\n", filename);
 exit(1);
 }
// This is ffmpeg code that I removed 
// frame = av_frame_alloc();
// if (!frame) {
// fprintf(stderr, "Could not allocate video frame\n");
// exit(1);
// }
// frame->format = c->pix_fmt;
// frame->width = c->width;
// frame->height = c->height;
// 
// ret = av_frame_get_buffer(frame, 0);
// if (ret < 0) {
// fprintf(stderr, "Could not allocate the video frame data\n");
// exit(1);
// }

 pFrame->format = c->pix_fmt;
 pFrame->width = c->width;
 pFrame->height = c->height;
 

 //Read video frames and pass through the decoder.
 //Note: Since the video is rawvideo, we don't really have to pass it through the decoder.
 while (av_read_frame(ifmt_ctx, pPacket) >= 0) 
 {
 //The video is not encoded - passing through the decoder is simply copy the data.
 avcodec_send_packet(pCodecContext, pPacket); //Supply raw packet data as input to the "decoder".
 avcodec_receive_frame(pCodecContext, pFrame); //Return decoded output data from the "decoder".

 fflush(stdout);
// This is ffmpeg code that I removed 
// /* Make sure the frame data is writable.
// On the first round, the frame is fresh from av_frame_get_buffer()
// and therefore we know it is writable.
// But on the next rounds, encode() will have called
// avcodec_send_frame(), and the codec may have kept a reference to
// the frame in its internal structures, that makes the frame
// unwritable.
// av_frame_make_writable() checks that and allocates a new buffer
// for the frame only if necessary.
// */
// ret = av_frame_make_writable(frame);
// if (ret < 0)
// exit(1);
// 
// /* Prepare a dummy image.
// In real code, this is where you would have your own logic for
// filling the frame. FFmpeg does not care what you put in the
// frame.
// */
// /* Y */
// for (y = 0; y < c->height; y++) {
// for (x = 0; x < c->width; x++) {
// frame->data[0][y * frame->linesize[0] + x] = x + y + i * 3;
// }
// }
// 
// /* Cb and Cr */
// for (y = 0; y < c->height/2; y++) {
// for (x = 0; x < c->width/2; x++) {
// frame->data[1][y * frame->linesize[1] + x] = 128 + y + i * 2;
// frame->data[2][y * frame->linesize[2] + x] = 64 + x + i * 5;
// }
// }
 
 pFrame->pts = i;
 
 /* encode the image */
 encode(c, pFrame, pkt, f);
 }
 
 /* flush the encoder */
 encode(c, NULL, pkt, f);
 
 /* Add sequence end code to have a real MPEG file.
 It makes only sense because this tiny examples writes packets
 directly. This is called "elementary stream" and only works for some
 codecs. To create a valid file, you usually need to write packets
 into a proper file format or protocol; see mux.c.
 */
 if (codec->id == AV_CODEC_ID_MPEG1VIDEO || codec->id == AV_CODEC_ID_MPEG2VIDEO)
 fwrite(endcode, 1, sizeof(endcode), f);
 fclose(f);
 
 avcodec_free_context(&c);
 av_frame_free(&pFrame);
 av_packet_free(&pkt);
 
 return 0;
}
</codec></output>

EDIT : I added combined code of ffmpeg and reading/decoding from YUV file according @Rotem (thanks). Frame from decoder pushed right to encode() method of ffmpeg. The out video was not good... Should I manipulate the YUV input frame before send it to encode() method ? if yes how to do it ?


-
FFmpeg avcodec_open2 throws -22 ("Invalid Argument")
14 avril 2023, par stupidbutseekingI got stuck trying to write a simple video conversion using C++ and ffmpeg.


When trying to convert a video using FFmpeg, calling avcodec_open2 fails with the code "-22" which seems to be an "Invalid Argument"-error.


I can't figure out why it fails, nor what the invalid argument is. In the following snippet I create the output codec and pass its context the information from the source (code further down below).


The check for the "outputCodec" works and does not throw an error. As far as I know an "AVDictionary"-argument is optional. So I guess the reason for the error is the context.


const AVCodec* outputCodec = avcodec_find_encoder_by_name(codecName.c_str());

 if (!outputCodec)
 {
 std::cout << "Zielformat-Codec nicht gefunden" << std::endl;
 return -1;
 }

 AVCodecContext* outputCodecContext = avcodec_alloc_context3(outputCodec);
 outputCodecContext->bit_rate = bitRate;
 outputCodecContext->width = inputCodecContext->width;
 outputCodecContext->height = inputCodecContext->height;
 outputCodecContext->pix_fmt = outputCodec->pix_fmts[0];
 outputCodecContext->time_base = inputCodecContext->time_base;

 **int errorCode = avcodec_open2(outputCodecContext, outputCodec, NULL); //THIS RETURNS -22**
 if (errorCode != 0)
 {
 std::cout << "Fehler beim Öffnen des Zielformat-Codecs" << std::endl;
 return -1;
 }


Here is the code for getting the input file & context :


std::string inputFilename = "input_video.mp4";
 std::string outputFilename = "output.avi";
 std::string codecName = "mpeg4";
 int bitRate = 400000;

 AVFormatContext* inputFormatContext = NULL;
 if (avformat_open_input(&inputFormatContext, inputFilename.c_str(), NULL, NULL) != 0)
 {
 std::cout << "Fehler beim Öffnen der Eingabedatei" << std::endl;
 return -1;
 }

 [Do Video Stream Search)

 AVCodecParameters* inputCodecParameters = inputFormatContext->streams[videoStreamIndex]->codecpar;
 const AVCodec* inputCodec = avcodec_find_decoder(inputCodecParameters->codec_id);
 AVCodecContext* inputCodecContext = avcodec_alloc_context3(inputCodec);
 if (avcodec_parameters_to_context(inputCodecContext, inputCodecParameters) != 0)
 {
 std::cout << "Fehler beim Setzen des Eingabecodecs" << std::endl;
 return -1;
 }
 if (avcodec_open2(inputCodecContext, inputCodec, NULL) != 0)
 {
 std::cout << "Fehler beim Öffnen des Eingabecodecs" << std::endl;
 return -1;
 }


The purpose was simply to get started with ffmpeg in an own C++ project.


If it is of any need, I downloaded the ffmpeg libs from here. I used the gpl shared ones. The architecture is win x64. I referenced them through the project properties (additional libraries and so on).


I tried to convert a .mp4 video to an .avi video with an "mpeg4" compression.
I also tried other compressions like "libx264" but none worked.


I searched for the problem on stackoverflow but could not find the exact same problem. While its purpose is different this post is about the same error code when calling avcodec_open2. But its solution is not working for me. I inspected the watch for the "outputContext" while running the code and the codec_id, codec_type and format is set. I use the time_base from the input file. According to my understanding, this should be equal to the source. So I can not find out what I am missing.


Thanks in advance and sorry for my english.


And for completion, here is the whole method :


int TestConvert()
{
 std::string inputFilename = "input_video.mp4";
 std::string outputFilename = "output.avi";
 std::string codecName = "mpeg4";
 int bitRate = 400000;

 AVFormatContext* inputFormatContext = NULL;
 if (avformat_open_input(&inputFormatContext, inputFilename.c_str(), NULL, NULL) != 0)
 {
 std::cout << "Fehler beim Öffnen der Eingabedatei" << std::endl;
 return -1;
 }

 int videoStreamIndex = -1;
 for (unsigned int i = 0; i < inputFormatContext->nb_streams; i++)
 {
 if (inputFormatContext->streams[i]->codecpar->codec_type == AVMEDIA_TYPE_VIDEO)
 {
 videoStreamIndex = i;
 break;
 }
 }

 AVCodecParameters* inputCodecParameters = inputFormatContext->streams[videoStreamIndex]->codecpar;
 const AVCodec* inputCodec = avcodec_find_decoder(inputCodecParameters->codec_id);
 AVCodecContext* inputCodecContext = avcodec_alloc_context3(inputCodec);
 if (avcodec_parameters_to_context(inputCodecContext, inputCodecParameters) != 0)
 {
 std::cout << "Fehler beim Setzen des Eingabecodecs" << std::endl;
 return -1;
 }
 if (avcodec_open2(inputCodecContext, inputCodec, NULL) != 0)
 {
 std::cout << "Fehler beim Öffnen des Eingabecodecs" << std::endl;
 return -1;
 }

 const AVCodec* outputCodec = avcodec_find_encoder_by_name(codecName.c_str());

 if (!outputCodec)
 {
 std::cout << "Zielformat-Codec nicht gefunden" << std::endl;
 return -1;
 }

 AVCodecContext* outputCodecContext = avcodec_alloc_context3(outputCodec);
 outputCodecContext->bit_rate = bitRate;
 outputCodecContext->width = inputCodecContext->width;
 outputCodecContext->height = inputCodecContext->height;
 outputCodecContext->pix_fmt = outputCodec->pix_fmts[0];
 outputCodecContext->time_base = inputCodecContext->time_base;

 int errorCode = avcodec_open2(outputCodecContext, outputCodec, NULL);
 if (errorCode != 0)
 {
 std::cout << "Fehler beim Öffnen des Zielformat-Codecs" << std::endl;
 return -1;
 }

 AVFormatContext* outputFormatContext = NULL;
 if (avformat_alloc_output_context2(&outputFormatContext, NULL, NULL, outputFilename.c_str()) != 0)
 {
 std::cout << "Fehler beim Erstellen des Ausgabe-Formats" << std::endl;
 return -1;
 }

 AVStream* outputVideoStream = avformat_new_stream(outputFormatContext, outputCodec);
 if (outputVideoStream == NULL)
 {
 std::cout << "Fehler beim Hinzufügen des Video-Streams zum Ausgabe-Format" << std::endl;
 return -1;
 }
 outputVideoStream->id = outputFormatContext->nb_streams - 1;
 AVCodecParameters* outputCodecParameters = outputVideoStream->codecpar;
 if (avcodec_parameters_from_context(outputCodecParameters, outputCodecContext) != 0)
 {
 std::cout << "Fehler beim Setzen des Ausgabe-Codecs" << std::endl;
 return -1;
 }

 if (!(outputFormatContext->oformat->flags & AVFMT_NOFILE))
 {
 if (avio_open(&outputFormatContext->pb, outputFilename.c_str(), AVIO_FLAG_WRITE) != 0)
 {
 std::cout << "Fehler beim Öffnen der Ausgabedatei" << std::endl;
 return -1;
 }
 }

 if (avformat_write_header(outputFormatContext, NULL) != 0)
 {
 std::cout << "Fehler beim Schreiben des Ausgabe-Formats in die Ausgabedatei" << std::endl;
 return -1;
 }

 AVPacket packet;
 int response;
 AVFrame* frame = av_frame_alloc();
 AVFrame* outputFrame = av_frame_alloc();
 while (av_read_frame(inputFormatContext, &packet) == 0)
 {
 if (packet.stream_index == videoStreamIndex)
 {
 response = avcodec_send_packet(inputCodecContext, &packet);
 while (response >= 0)
 {
 response = avcodec_receive_frame(inputCodecContext, frame);
 if (response == AVERROR(EAGAIN) || response == AVERROR_EOF)
 {
 break;
 }
 else if (response < 0)
 {
 std::cout << "Fehler beim Dekodieren des Video-Pakets" << std::endl;
 return -1;
 }

 struct SwsContext* swsContext = sws_getContext(inputCodecContext->width, inputCodecContext->height, inputCodecContext->pix_fmt, outputCodecContext->width, outputCodecContext->height, outputCodecContext->pix_fmt, SWS_BILINEAR, NULL, NULL, NULL); if (!swsContext)
 {
 std::cout << "Fehler beim Erstellen des SwsContext" << std::endl;
 return -1;
 }
 sws_scale(swsContext, frame->data, frame->linesize, 0, inputCodecContext->height, outputFrame->data, outputFrame->linesize);
 sws_freeContext(swsContext);

 outputFrame->pts = frame->pts;
 outputFrame->pkt_dts = frame->pkt_dts;
 //outputFrame->pkt_duration = frame->pkt_duration;
 response = avcodec_send_frame(outputCodecContext, outputFrame);
 while (response >= 0)
 {
 response = avcodec_receive_packet(outputCodecContext, &packet);
 if (response == AVERROR(EAGAIN) || response == AVERROR_EOF)
 {
 break;
 }
 else if (response < 0)
 {
 std::cout << "Fehler beim Kodieren des Ausgabe-Frames" << std::endl;
 return -1;
 }

 packet.stream_index = outputVideoStream->id;
 av_packet_rescale_ts(&packet, outputCodecContext->time_base, outputVideoStream->time_base);
 if (av_interleaved_write_frame(outputFormatContext, &packet) != 0)
 {
 std::cout << "Fehler beim Schreiben des Ausgabe-Pakets" << std::endl;
 return -1;
 }
 av_packet_unref(&packet);
 }
 }
 }
 av_packet_unref(&packet);
 }

 av_write_trailer(outputFormatContext);
 avcodec_free_context(&inputCodecContext);
 avcodec_free_context(&outputCodecContext);
 avformat_close_input(&inputFormatContext);
 avformat_free_context(inputFormatContext);
 avformat_free_context(outputFormatContext);
 av_frame_free(&frame);
 av_frame_free(&outputFrame);

 return 0;

}


-
Sending raw h264 video and aac audio frames to an RTMP server using ffmpeg
7 décembre 2022, par codeimpalerI am receiving raw h264 and aac audio frames from an even driven source. I am trying to send these frames to an rtmp server. 
I started working from the ffmpeg example muxing.c which successfully sends a custom stream to the rtmp server. I figure I just need to replace their frame data with my own.I found this suggestion online. I have tried How to pack raw h264 stream to flv container and send over rtmp using ffmpeg (not command) 
and
How to publish selfmade stream with ffmpeg and c++ to rtmp server ?
and a few other suggestions but none have worked for me. 
I have tried to directly memcpy my byte buffer but my code keeps failing
at ret = avcodec_encode_video2(c, &pkt, frame, &got_packet).
Specifically, I get an invalid access error.
For a little more context, anytime I receive a frame (which is event driven), void RTMPWriter::WriteVideoFrame(...) is called. Assume the constructor has already been called before the first frame is received. 
I am not that familiar with ffmpeg and there could be several things wrong with the code. Any input will be really appreciated.



#define STREAM_FRAME_RATE 25 /* 25 images/s */
 #define STREAM_PIX_FMT AV_PIX_FMT_YUV420P /* default pix_fmt */
 #define SCALE_FLAGS SWS_BICUBIC
 RTMPWriter::RTMPWriter()
 : seenKeyFrame(false),
 video_st({ 0 }), 
 audio_st({ 0 }),
 have_video(0), 
 have_audio(0)
 {

 const char *filename;
 AVCodec *audio_codec = NULL, *video_codec = NULL;
 int ret;

 int encode_video = 0, encode_audio = 0;
 AVDictionary *opt = NULL;
 int i;

 /* Initialize libavcodec, and register all codecs and formats. */
 av_register_all();

 avformat_network_init();

 String^ StreamURL = "StreamURL";
 String^ out_uri = safe_cast(ApplicationData::Current->LocalSettings->Values->Lookup(StreamURL));
 std::wstring out_uriW(out_uri->Begin());
 std::string out_uriA(out_uriW.begin(), out_uriW.end());
 filename = out_uriA.c_str(); 

 /* allocate the output media context */
 avformat_alloc_output_context2(&oc, NULL, "flv", filename);
 if (!oc)
 {
 OutputDebugString(L"Could not deduce output format from file extension: using MPEG.\n");
 avformat_alloc_output_context2(&oc, NULL, "mpeg", filename);
 }
 if (!oc)
 {
 OutputDebugString(L"Could not allocate using MPEG.\n");
 }


 fmt = oc->oformat;

 /* Add the audio and video streams using the default format codecs
 * and initialize the codecs. */
 if (fmt->video_codec != AV_CODEC_ID_NONE) {
 add_stream(&video_st, oc, &video_codec, fmt->video_codec);
 have_video = 1;
 encode_video = 1;
 }
 if (fmt->audio_codec != AV_CODEC_ID_NONE) {
 add_stream(&audio_st, oc, &audio_codec, fmt->audio_codec);
 have_audio = 1;
 encode_audio = 1;
 }

 /* Now that all the parameters are set, we can open the audio and
 * video codecs and allocate the necessary encode buffers. */
 if (have_video)
 {
 open_video(oc, video_codec, &video_st, opt);
 }

 if (have_audio)
 {
 open_audio(oc, audio_codec, &audio_st, opt);
 }

 av_dump_format(oc, 0, filename, 1);

 /* open the output file, if needed */
 if (!(fmt->flags & AVFMT_NOFILE))
 {
 ret = avio_open(&oc->pb, filename, AVIO_FLAG_WRITE);
 if (ret < 0)
 {
 OutputDebugString(L"Could not open ");
 OutputDebugString(out_uri->Data());
 }
 }

 /* Write the stream header, if any. */
 ret = avformat_write_header(oc, &opt);
 if (ret < 0)
 {
 OutputDebugString(L"Error occurred when writing stream header \n");
 }

 }

 void RTMPWriter::WriteVideoFrame(
 boolean isKeyFrame,
 boolean hasDiscontinuity,
 UINT64 frameId,
 UINT32 videoBufferLength,
 BYTE *videoBytes)
 {

 int ret;
 AVCodecContext *c;
 AVFrame* frame;
 int got_packet = 0;
 AVPacket pkt = { 0 };

 c = video_st.enc;

 frame = get_video_frame(videoBufferLength, videoBytes);

 /* encode the image */
 ret = avcodec_encode_video2(c, &pkt, frame, &got_packet);
 if (ret < 0) {
 OutputDebugString(L"Error encoding video frame: \n")
 }

 if (got_packet) 
 {
 ret = write_frame(oc, &c->time_base, video_st.st, &pkt);
 }
 else {
 ret = 0;
 }

 if (ret < 0) {
 OutputDebugString(L"Error while writing video frame: %s\n");
 }
 }

 AVFrame * RTMPWriter::get_video_frame(
 UINT32 videoBufferLength,
 BYTE *videoBytes)
 {
 AVCodecContext *c = video_st.enc;

 if (c->pix_fmt != AV_PIX_FMT_YUV420P) {
 /* as we only generate a YUV420P picture, we must convert it
 * to the codec pixel format if needed */
 if (!video_st.sws_ctx) {
 video_st.sws_ctx = sws_getContext(c->width, c->height,
 AV_PIX_FMT_YUV420P,
 c->width, c->height,
 c->pix_fmt,
 SCALE_FLAGS, NULL, NULL, NULL);
 if (!video_st.sws_ctx) {
 fprintf(stderr,
 "Could not initialize the conversion context\n");
 exit(1);
 }
 }
 fill_yuv_image(video_st.tmp_frame, video_st.next_pts, c->width, c->height, videoBufferLength, videoBytes);
 sws_scale(video_st.sws_ctx,
 (const uint8_t * const *)video_st.tmp_frame->data, video_st.tmp_frame->linesize,
 0, c->height, video_st.frame->data, video_st.frame->linesize);
 }
 else {
 fill_yuv_image(video_st.frame, video_st.next_pts, c->width, c->height, videoBufferLength, videoBytes);
 }

 video_st.frame->pts = video_st.next_pts++;

 return video_st.frame;
 }

 /* Prepare a dummy image. */
 void RTMPWriter::fill_yuv_image(
 AVFrame *pict, 
 int frame_index,
 int width, 
 int height, 
 UINT32 videoBufferLength,
 BYTE *videoBytes)
 {
 //int x, y, i, ret;

 /* when we pass a frame to the encoder, it may keep a reference to it
 * internally;
 * make sure we do not overwrite it here
 */
 ret = av_frame_make_writable(pict);
 if (ret < 0) 
 {
 OutputDebugString(L"Unable to make piture writable");
 }

 memcpy(pict->data, videoBytes, videoBufferLength);

 //i = frame_index;

 ///* Y */
 //for (y = 0; y < height; y++)
 // for (x = 0; x < width; x++)
 // pict->data[0][y * pict->linesize[0] + x] = x + y + i * 3;

 ///* Cb and Cr */
 //for (y = 0; y < height / 2; y++) {
 // for (x = 0; x < width / 2; x++) {
 // pict->data[1][y * pict->linesize[1] + x] = 128 + y + i * 2;
 // pict->data[2][y * pict->linesize[2] + x] = 64 + x + i * 5;
 // }
 //}
 }

 void RTMPWriter::WriteAudioFrame()
 {

 }

 /* Add an output stream. */
 void RTMPWriter::add_stream(
 OutputStream *ost, 
 AVFormatContext *oc,
 AVCodec **codec,
 enum AVCodecID codec_id)
 {
 AVCodecContext *c;
 int i;

 /* find the encoder */
 *codec = avcodec_find_encoder(codec_id);
 if (!(*codec)) {
 OutputDebugString(L"Could not find encoder for '%s'\n");
 //avcodec_get_name(codec_id));
 exit(1);
 }

 ost->st = avformat_new_stream(oc, NULL);
 if (!ost->st) {
 OutputDebugString(L"Could not allocate stream\n");
 exit(1);
 }
 ost->st->id = oc->nb_streams - 1;
 c = avcodec_alloc_context3(*codec);
 if (!c) {
 OutputDebugString(L"Could not alloc an encoding context\n");
 exit(1);
 }
 ost->enc = c;

 switch ((*codec)->type) {
 case AVMEDIA_TYPE_AUDIO:
 c->sample_fmt = (*codec)->sample_fmts ?
 (*codec)->sample_fmts[0] : AV_SAMPLE_FMT_FLTP;
 c->bit_rate = 64000;
 c->sample_rate = 44100;
 if ((*codec)->supported_samplerates) {
 c->sample_rate = (*codec)->supported_samplerates[0];
 for (i = 0; (*codec)->supported_samplerates[i]; i++) {
 if ((*codec)->supported_samplerates[i] == 44100)
 c->sample_rate = 44100;
 }
 }
 c->channels = av_get_channel_layout_nb_channels(c->channel_layout);
 c->channel_layout = AV_CH_LAYOUT_STEREO;
 if ((*codec)->channel_layouts) {
 c->channel_layout = (*codec)->channel_layouts[0];
 for (i = 0; (*codec)->channel_layouts[i]; i++) {
 if ((*codec)->channel_layouts[i] == AV_CH_LAYOUT_STEREO)
 c->channel_layout = AV_CH_LAYOUT_STEREO;
 }
 }
 c->channels = av_get_channel_layout_nb_channels(c->channel_layout);
 ost->st->time_base = /*(AVRational)*/{ 1, c->sample_rate };
 break;

 case AVMEDIA_TYPE_VIDEO:
 c->codec_id = codec_id;

 c->bit_rate = 400000;
 /* Resolution must be a multiple of two. */
 c->width = 352;
 c->height = 288;
 /* timebase: This is the fundamental unit of time (in seconds) in terms
 * of which frame timestamps are represented. For fixed-fps content,
 * timebase should be 1/framerate and timestamp increments should be
 * identical to 1. */
 ost->st->time_base = /*(AVRational)*/{ 1, STREAM_FRAME_RATE };
 c->time_base = ost->st->time_base;

 c->gop_size = 12; /* emit one intra frame every twelve frames at most */
 c->pix_fmt = STREAM_PIX_FMT;
 if (c->codec_id == AV_CODEC_ID_MPEG2VIDEO) {
 /* just for testing, we also add B-frames */
 c->max_b_frames = 2;
 }
 if (c->codec_id == AV_CODEC_ID_MPEG1VIDEO) {
 /* Needed to avoid using macroblocks in which some coeffs overflow.
 * This does not happen with normal video, it just happens here as
 * the motion of the chroma plane does not match the luma plane. */
 c->mb_decision = 2;
 }
 break;

 default:
 break;
 }

 /* Some formats want stream headers to be separate. */
 if (oc->oformat->flags & AVFMT_GLOBALHEADER)
 c->flags |= AV_CODEC_FLAG_GLOBAL_HEADER;
 }

AVFrame * RTMPWriter::alloc_audio_frame(
 enum AVSampleFormat sample_fmt,
 uint64_t channel_layout,
 int sample_rate, int nb_samples)
{
 AVFrame *frame = av_frame_alloc();
 int ret;

 if (!frame) {
 OutputDebugString(L"Error allocating an audio frame\n");
 exit(1);
 }

 frame->format = sample_fmt;
 frame->channel_layout = channel_layout;
 frame->sample_rate = sample_rate;
 frame->nb_samples = nb_samples;

 if (nb_samples) {
 ret = av_frame_get_buffer(frame, 0);
 if (ret < 0) {
 OutputDebugString(L"Error allocating an audio buffer\n");
 exit(1);
 }
 }

 return frame;
 }




void RTMPWriter::open_audio(
 AVFormatContext *oc, 
 AVCodec *codec, 
 OutputStream *ost, 
 AVDictionary *opt_arg)
{
 AVCodecContext *c;
 int nb_samples;
 int ret;
 AVDictionary *opt = NULL;

 c = ost->enc;

 /* open it */
 av_dict_copy(&opt, opt_arg, 0);
 ret = avcodec_open2(c, codec, &opt);
 av_dict_free(&opt);
 if (ret < 0) {
 OutputDebugString(L"Could not open audio codec: %s\n");// , av_err2str(ret));
 exit(1);
 }

 /* init signal generator */
 ost->t = 0;
 ost->tincr = 2 * M_PI * 110.0 / c->sample_rate;
 /* increment frequency by 110 Hz per second */
 ost->tincr2 = 2 * M_PI * 110.0 / c->sample_rate / c->sample_rate;

 if (c->codec->capabilities & AV_CODEC_CAP_VARIABLE_FRAME_SIZE)
 nb_samples = 10000;
 else
 nb_samples = c->frame_size;

 ost->frame = alloc_audio_frame(c->sample_fmt, c->channel_layout,
 c->sample_rate, nb_samples);
 ost->tmp_frame = alloc_audio_frame(AV_SAMPLE_FMT_S16, c->channel_layout,
 c->sample_rate, nb_samples);

 /* copy the stream parameters to the muxer */
 ret = avcodec_parameters_from_context(ost->st->codecpar, c);
 if (ret < 0) {
 OutputDebugString(L"Could not copy the stream parameters\n");
 exit(1);
 }

 /* create resampler context */
 ost->swr_ctx = swr_alloc();
 if (!ost->swr_ctx) {
 OutputDebugString(L"Could not allocate resampler context\n");
 exit(1);
 }

 /* set options */
 av_opt_set_int(ost->swr_ctx, "in_channel_count", c->channels, 0);
 av_opt_set_int(ost->swr_ctx, "in_sample_rate", c->sample_rate, 0);
 av_opt_set_sample_fmt(ost->swr_ctx, "in_sample_fmt", AV_SAMPLE_FMT_S16, 0);
 av_opt_set_int(ost->swr_ctx, "out_channel_count", c->channels, 0);
 av_opt_set_int(ost->swr_ctx, "out_sample_rate", c->sample_rate, 0);
 av_opt_set_sample_fmt(ost->swr_ctx, "out_sample_fmt", c->sample_fmt, 0);

 /* initialize the resampling context */
 if ((ret = swr_init(ost->swr_ctx)) < 0) {
 OutputDebugString(L"Failed to initialize the resampling context\n");
 exit(1);
 }
}

int RTMPWriter::write_frame(
 AVFormatContext *fmt_ctx, 
 const AVRational *time_base, 
 AVStream *st, 
 AVPacket *pkt)
{
 /* rescale output packet timestamp values from codec to stream timebase */
 av_packet_rescale_ts(pkt, *time_base, st->time_base);
 pkt->stream_index = st->index;

 /* Write the compressed frame to the media file. */
 //log_packet(fmt_ctx, pkt);
 OutputDebugString(L"Actually sending video frame: %s\n");
 return av_interleaved_write_frame(fmt_ctx, pkt);
}


AVFrame *RTMPWriter::alloc_picture(
 enum AVPixelFormat pix_fmt, 
 int width, 
 int height)
{
 AVFrame *picture;
 int ret;

 picture = av_frame_alloc();
 if (!picture)
 return NULL;

 picture->format = pix_fmt;
 picture->width = width;
 picture->height = height;

 /* allocate the buffers for the frame data */
 ret = av_frame_get_buffer(picture, 32);
 if (ret < 0) {
 fprintf(stderr, "Could not allocate frame data.\n");
 exit(1);
 }

 return picture;
}

void RTMPWriter::open_video(
 AVFormatContext *oc, 
 AVCodec *codec, 
 OutputStream *ost, 
 AVDictionary *opt_arg)
{
 int ret;
 AVCodecContext *c = ost->enc;
 AVDictionary *opt = NULL;

 av_dict_copy(&opt, opt_arg, 0);

 /* open the codec */
 ret = avcodec_open2(c, codec, &opt);
 av_dict_free(&opt);
 if (ret < 0) {
 OutputDebugString(L"Could not open video codec: %s\n");// , av_err2str(ret));
 exit(1);
 }

 /* allocate and init a re-usable frame */
 ost->frame = alloc_picture(c->pix_fmt, c->width, c->height);
 if (!ost->frame) {
 OutputDebugString(L"Could not allocate video frame\n");
 exit(1);
 }

 /* If the output format is not YUV420P, then a temporary YUV420P
 * picture is needed too. It is then converted to the required
 * output format. */
 ost->tmp_frame = NULL;
 if (c->pix_fmt != AV_PIX_FMT_YUV420P) {
 ost->tmp_frame = alloc_picture(AV_PIX_FMT_YUV420P, c->width, c->height);
 if (!ost->tmp_frame) {
 OutputDebugString(L"Could not allocate temporary picture\n");
 exit(1);
 }
 }

 /* copy the stream parameters to the muxer */
 ret = avcodec_parameters_from_context(ost->st->codecpar, c);
 if (ret < 0) {
 OutputDebugString(L"Could not copy the stream parameters\n");
 exit(1);
 }
}

void RTMPWriter::close_stream(AVFormatContext *oc, OutputStream *ost)
{
 avcodec_free_context(&ost->enc);
 av_frame_free(&ost->frame);
 av_frame_free(&ost->tmp_frame);
 sws_freeContext(ost->sws_ctx);
 swr_free(&ost->swr_ctx);
}

RTMPWriter::~RTMPWriter()
{
 av_write_trailer(oc);
 /* Close each codec. */
 if (have_video)
 close_stream(oc, &video_st);
 if (have_audio)
 close_stream(oc, &audio_st);

 if (!(fmt->flags & AVFMT_NOFILE))
 /* Close the output file. */
 avio_closep(&oc->pb);

 /* free the stream */
 avformat_free_context(oc);
}


Syndiquer tout le site
