Recherche avancée
Autres articles (62)
-
La sauvegarde automatique de canaux SPIP
1er avril 2010, parDans le cadre de la mise en place d’une plateforme ouverte, il est important pour les hébergeurs de pouvoir disposer de sauvegardes assez régulières pour parer à tout problème éventuel.
Pour réaliser cette tâche on se base sur deux plugins SPIP : Saveauto qui permet une sauvegarde régulière de la base de donnée sous la forme d’un dump mysql (utilisable dans phpmyadmin) mes_fichiers_2 qui permet de réaliser une archive au format zip des données importantes du site (les documents, les éléments (...) -
Script d’installation automatique de MediaSPIP
25 avril 2011, parAfin de palier aux difficultés d’installation dues principalement aux dépendances logicielles coté serveur, un script d’installation "tout en un" en bash a été créé afin de faciliter cette étape sur un serveur doté d’une distribution Linux compatible.
Vous devez bénéficier d’un accès SSH à votre serveur et d’un compte "root" afin de l’utiliser, ce qui permettra d’installer les dépendances. Contactez votre hébergeur si vous ne disposez pas de cela.
La documentation de l’utilisation du script d’installation (...) -
Automated installation script of MediaSPIP
25 avril 2011, parTo overcome the difficulties mainly due to the installation of server side software dependencies, an "all-in-one" installation script written in bash was created to facilitate this step on a server with a compatible Linux distribution.
You must have access to your server via SSH and a root account to use it, which will install the dependencies. Contact your provider if you do not have that.
The documentation of the use of this installation script is available here.
The code of this (...)
Sur d’autres sites (6129)
-
Streaming Anki Vector's camera
25 novembre 2023, par Brendan GoodeI am trying to stream my robot to Remo.tv with my Vector robot. The website recognizes I am going live but does not stream what the robots camera is seeing. I have confirmed the camera works by a local application that runs the SDK. The very end of the code is what is giving issues, it appears somebody ripped code from Cozmo and attempted to paste it into a Vector file. The problem is it seems like the camera is taking pictures and we reach the point where it attempts to send photo but fails ?


# This is a dummy file to allow the automatic loading of modules without error on none.
import anki_vector
import atexit
import time
import _thread as thread
import logging
import networking

log = logging.getLogger('RemoTV.vector')
vector = None
reserve_control = None
robotKey = None
volume = 100 #this is stupid, but who cares
annotated = False

def connect():
 global vector
 global reserve_control

 log.debug("Connecting to Vector")
 vector = anki_vector.AsyncRobot()
 vector.connect()
 #reserve_control = anki_vector.behavior.ReserveBehaviorControl()
 
 atexit.register(exit)

 return(vector)

def exit():
 log.debug("Vector exiting")
 vector.disconnect()
 
def setup(robot_config):
 global forward_speed
 global turn_speed
 global volume
 global vector
 global charge_high
 global charge_low
 global stay_on_dock

 global robotKey
 global server
 global no_mic
 global no_camera
 global ffmpeg_location
 global v4l2_ctl_location
 global x_res
 global y_res
 
 robotKey = robot_config.get('robot', 'robot_key')

 if robot_config.has_option('misc', 'video_server'):
 server = robot_config.get('misc', 'video_server')
 else:
 server = robot_config.get('misc', 'server')
 
 no_mic = robot_config.getboolean('camera', 'no_mic')
 no_camera = robot_config.getboolean('camera', 'no_camera')

 ffmpeg_location = robot_config.get('ffmpeg', 'ffmpeg_location')
 v4l2_ctl_location = robot_config.get('ffmpeg', 'v4l2-ctl_location')

 x_res = robot_config.getint('camera', 'x_res')
 y_res = robot_config.getint('camera', 'y_res')


 if vector == None:
 vector = connect()

 #x mod_utils.repeat_task(30, check_battery, coz)

 if robot_config.has_section('cozmo'):
 forward_speed = robot_config.getint('cozmo', 'forward_speed')
 turn_speed = robot_config.getint('cozmo', 'turn_speed')
 volume = robot_config.getint('cozmo', 'volume')
 charge_high = robot_config.getfloat('cozmo', 'charge_high')
 charge_low = robot_config.getfloat('cozmo', 'charge_low')
 stay_on_dock = robot_config.getboolean('cozmo', 'stay_on_dock')

# if robot_config.getboolean('tts', 'ext_chat'): #ext_chat enabled, add motor commands
# extended_command.add_command('.anim', play_anim)
# extended_command.add_command('.forward_speed', set_forward_speed)
# extended_command.add_command('.turn_speed', set_turn_speed)
# extended_command.add_command('.vol', set_volume)
# extended_command.add_command('.charge', set_charging)
# extended_command.add_command('.stay', set_stay_on_dock)

 vector.audio.set_master_volume(volume) # set volume

 return
 
def move(args):
 global charging
 global low_battery
 command = args['button']['command']

 try:
 if vector.status.is_on_charger and not charging:
 if low_battery:
 print("Started Charging")
 charging = 1
 else:
 if not stay_on_dock:
 vector.drive_off_charger_contacts().wait_for_completed()

 if command == 'f':
 vector.behavior.say_text("Moving {}".format(command))

 #causes delays #coz.drive_straight(distance_mm(10), speed_mmps(50), False, True).wait_for_completed()
 vector.motors.set_wheel_motors(forward_speed, forward_speed, forward_speed*4, forward_speed*4 )
 time.sleep(0.7)
 vector.motors.set_wheel_motors(0, 0)
 elif command == 'b':
 #causes delays #coz.drive_straight(distance_mm(-10), speed_mmps(50), False, True).wait_for_completed()
 vector.motors.set_wheel_motors(-forward_speed, -forward_speed, -forward_speed*4, -forward_speed*4 )
 time.sleep(0.7)
 vector.motors.set_wheel_motors(0, 0)
 elif command == 'l':
 #causes delays #coz.turn_in_place(degrees(15), False).wait_for_completed()
 vector.motors.set_wheel_motors(-turn_speed, turn_speed, -turn_speed*4, turn_speed*4 )
 time.sleep(0.5)
 vector.motors.set_wheel_motors(0, 0)
 elif command == 'r':
 #causes delays #coz.turn_in_place(degrees(-15), False).wait_for_completed()
 vector.motors.set_wheel_motors(turn_speed, -turn_speed, turn_speed*4, -turn_speed*4 )
 time.sleep(0.5)
 vector.motors.set_wheel_motors(0, 0)

 #move lift
 elif command == 'w':
 vector.behavior.say_text("w")
 vector.set_lift_height(height=1).wait_for_completed()
 elif command == 's':
 vector.behavior.say_text("s")
 vector.set_lift_height(height=0).wait_for_completed()

 #look up down
 #-25 (down) to 44.5 degrees (up)
 elif command == 'q':
 #head_angle_action = coz.set_head_angle(degrees(0))
 #clamped_head_angle = head_angle_action.angle.degrees
 #head_angle_action.wait_for_completed()
 vector.behaviour.set_head_angle(45)
 time.sleep(0.35)
 vector.behaviour.set_head_angle(0)
 elif command == 'a':
 #head_angle_action = coz.set_head_angle(degrees(44.5))
 #clamped_head_angle = head_angle_action.angle.degrees
 #head_angle_action.wait_for_completed()
 vector.behaviour.set_head_angle(-22.0)
 time.sleep(0.35)
 vector.behaviour.set_head_angle(0)
 
 #things to say with TTS disabled
 elif command == 'sayhi':
 tts.say( "hi! I'm cozmo!" )
 elif command == 'saywatch':
 tts.say( "watch this" )
 elif command == 'saylove':
 tts.say( "i love you" )
 elif command == 'saybye':
 tts.say( "bye" )
 elif command == 'sayhappy':
 tts.say( "I'm happy" )
 elif command == 'saysad':
 tts.say( "I'm sad" )
 elif command == 'sayhowru':
 tts.say( "how are you?" )
 except:
 return(False)
 return

def start():
 log.debug("Starting Vector Video Process")
 try:
 thread.start_new_thread(video, ())
 except KeyboardInterrupt as e:
 pass 
 return
 
def video():
 global vector
 # Turn on image receiving by the camera
 vector.camera.init_camera_feed()

 vector.behavior.say_text("hey everyone, lets robot!")

 while True:
 time.sleep(0.25)

 from subprocess import Popen, PIPE
 from sys import platform

 log.debug("ffmpeg location : {}".format(ffmpeg_location))

# import os
# if not os.path.isfile(ffmpeg_location):
# print("Error: cannot find " + str(ffmpeg_location) + " check ffmpeg is installed. Terminating controller")
# thread.interrupt_main()
# thread.exit()

 while not networking.authenticated:
 time.sleep(1)

 p = Popen([ffmpeg_location, '-y', '-f', 'image2pipe', '-vcodec', 'png', '-r', '25', '-i', '-', '-vcodec', 'mpeg1video', '-r', '25', "-f", "mpegts", "-headers", "\"Authorization: Bearer {}\"".format(robotKey), "http://{}:1567/transmit?name={}-video".format(server, networking.channel_id)], stdin=PIPE)
 #p = Popen([ffmpeg_location, '-nostats', '-y', '-f', 'image2pipe', '-vcodec', 'png', '-r', '25', '-i', '-', '-vcodec', 'mpeg1video', '-r', '25','-b:v', '400k', "-f","mpegts", "-headers", "\"Authorization: Bearer {}\"".format(robotKey), "http://{}/transmit?name=rbot-390ddbe0-f1cc-4710-b3f1-9f477f4875f9-video".format(server)], stdin=PIPE)
 #p = Popen([ffmpeg_location, '-y', '-f', 'image2pipe', '-vcodec', 'png', '-r', '25', '-i', '-', '-vcodec', 'mpeg1video', '-r', '25', "-f", "mpegts", "-headers", "\"Authorization: Bearer {}\"".format(robotKey), "http://{}/transmit?name=rbot-390ddbe0-f1cc-4710-b3f1-9f477f4875f9-video".format(server, networking.channel_id)], stdin=PIPE)
 print(vector)
 image = vector.camera.latest_image
 image.raw_image.save("test.png", 'PNG')
 try:
 while True:
 if vector:
 image = vector.camera.latest_image
 if image:
 if annotated:
 image = image.annotate_image()
 else:
 image = image.raw_image
 print("attempting to write image")
 image.save(p.stdin, 'PNG')

 else:
 time.sleep(.1)
 log.debug("Lost Vector object, terminating video stream")
 p.stdin.close()
 p.wait()
 except Exception as e:
 log.debug("Vector Video Exception! {}".format(e))
 p.stdin.close()
 p.wait()
 pass 
 


Here is the error we get


[vost#0:0/mpeg1video @ 000001c7153c1cc0] Error submitting a packet to the muxer: Error number -10053 occurred
[out#0/mpegts @ 000001c713448480] Error muxing a packet
[out#0/mpegts @ 000001c713448480] Error writing trailer: Error number -10053 occurred
[http @ 000001c7134cab00] URL read error: Error number -10053 occurred
[out#0/mpegts @ 000001c713448480] Error closing file: Error number -10053 occurred
[out#0/mpegts @ 000001c713448480] video:56kB audio:0kB subtitle:0kB other streams:0kB global headers:0kB muxing overhead: unknown
frame= 25 fps=0.0 q=2.0 Lsize= 53kB time=00:00:01.32 bitrate= 325.9kbits/s speed=7.05x
Conversion failed!

attempting to write image


You can see our attempts to fix by commented out code in the #p section at the bottom.


-
Read existing MP4 File and write into a new MP4 file using libavcodec
4 octobre 2023, par TahfimulI am new to the libavcodec space.


I am trying to read video and audio streams from an existing mp4 file and take the data from the two streams and then mux the two streams and write the muxed data into a new mp4 file using libavcodec in C++. Essentially, I am aiming to split the original (existing) mp4 file into small chunks of 1 second clips that then can be played back using a video player. I would like to preserve the original mp4 video's video stream (i.e. preserve its color, resolution and etc.) and preserve the mp4 video's audio stream (i.e. preserve its bit rate and etc.). I am trying to achieve this using libavcodec in C++. But there does not seem to be any tutorial or documentation online that points me to that direction.


So far, I have looked at and tried to implement a solution using this tutorial (tutorial#1) : https://github.com/leandromoreira/ffmpeg-libav-tutorial/blob/master/0_hello_world.c


However, tutorial#1 aimed to save each video frame from the existing (original) mp4 video stream into individual .pgm files, which meant that the .pgm files would store a grayscale image of each video frame.


Since, I want to preserve the colors of the original (existing) mp4 file, I looked at this tutorial (tutorial#2) that aimed to convert the grayscale video frame into color using the swscale library : https://www.youtube.com/watch?v=Y7SUm7Xf1sc&ab_channel=Bartholomew
However, in tutorial#2, they exported the output from swscale library to a GUI library to be viewed in a GUI application and did not show hwo to write the output data into a new mp4 file that can be played back by a video player.


So then, I looked at this tutorial(tutorial#3) which showed how to create an MP4 file using libavcodec : C++ FFmpeg create mp4 file
However, the problem with that solution is that I was not able to take a video frame from the original mp4 video and store it into another mp4 file. I kept getting errors when attempting to do so and I did not succeed in taking the data from the original(existing) mp4 file and storing it into a new mp4 file.


Here is the code that I have written so far :


#include<fstream>
#include 
#include 
#include 
extern "C"
{
#include <libavcodec></libavcodec>avcodec.h>
#include <libavformat></libavformat>avformat.h>
#include <libavutil></libavutil>mathematics.h>
#include <libswscale></libswscale>swscale.h>
#include <libavfilter></libavfilter>buffersrc.h>
#include <libavfilter></libavfilter>buffersink.h>
#include <libavutil></libavutil>time.h>
#include <libavutil></libavutil>opt.h>
}
#pragma comment(lib, "avfilter.lib")
#ifdef av_err2str
#undef av_err2str
#include <string>
av_always_inline std::string av_err2string(int errnum) {
 char str[AV_ERROR_MAX_STRING_SIZE];
 return av_make_error_string(str, AV_ERROR_MAX_STRING_SIZE, errnum);
}
#define av_err2str(err) av_err2string(err).c_str()
#endif // av_err2str

#include <chrono>
#include <thread>


// decode packets into frames
static int decode_packet(AVPacket *pPacket, AVCodecContext *pCodecContext, AVFrame *pFrame);

static void pushFrame(AVFrame* frame, AVCodecContext* outputCodecContext, AVPacket * outputPacket, AVFormatContext* outputFormatContext, AVCodec *outputCodec) {
 
 std::cout<<"outputCodecContext: "<format = AV_PIX_FMT_YUV420P;
 frame->width = 800;
 frame->height = 800;
 if ((err = av_frame_get_buffer(frame, 32)) < 0) {
 std::cout << "Failed to allocate picture" << err << std::endl;
 return;
 }
 }
 SwsContext* swsCtx = nullptr;
 if (!swsCtx) {
 swsCtx = sws_getContext(800, 800, AV_PIX_FMT_RGB24, 800, 
 800, AV_PIX_FMT_YUV420P, SWS_BICUBIC, 0, 0, 0);
 }
 int inLinesize[1] = { 3 * 800 };
 // From RGB to YUV
 // sws_scale(swsCtx, (const uint8_t* const*)&data, inLinesize, 0, 800, 
 // frame->data, frame->linesize);
 std::cout<<"frame "<pts = (1.0 / 30.0) * 90000 * (1);
 // std::cout << videoFrame->pts << " " << cctx->time_base.num << " " << 
 // cctx->time_base.den << " " << 1 << std::endl;
 if ((err = avcodec_send_frame(outputCodecContext, frame)) < 0) {
 std::cout << "Failed to send frame" << err << std::endl;
 return;
 }
 AV_TIME_BASE;
 AVPacket pkt;
 av_init_packet(&pkt);
 pkt.data = NULL;
 pkt.size = 0;
 pkt.flags |= AV_PKT_FLAG_KEY;
 std::cout<<"here\n";
 if (avcodec_receive_packet(outputCodecContext, outputPacket) == 0) {
 static int counter = 0;
 if (counter == 0) {
 FILE* fp = fopen("dump_first_frame1.dat", "wb");
 fwrite(outputPacket->data, outputPacket->size, 1, fp);
 fclose(fp);
 }
 // std::cout << "pkt key: " << (pkt.flags & AV_PKT_FLAG_KEY) << " " << 
 // pkt.size << " " << (counter++) << std::endl;
 // uint8_t* size = ((uint8_t*)pkt.data);
 // std::cout << "first: " << (int)size[0] << " " << (int)size[1] << 
 // " " << (int)size[2] << " " << (int)size[3] << " " << (int)size[4] << 
 // " " << (int)size[5] << " " << (int)size[6] << " " << (int)size[7] << 
 // std::endl;
 av_interleaved_write_frame(outputFormatContext, outputPacket);
 av_packet_unref(outputPacket);
 }
}

int main()
{

 char* filename = "c++.mp4";

 AVFormatContext *pFormatContext = avformat_alloc_context();

 AVOutputFormat* outputFormat = NULL;

 AVFormatContext* outputFormatContext = nullptr;

 AVCodecContext* outputCodecContext = nullptr;

 if (!pFormatContext) {
 std::cerr<<"ERROR could not allocate memory for Format Context\n";
 return -1;
 }

 if (avformat_open_input(&pFormatContext, filename , NULL, NULL) != 0) {
 std::cerr<<"ERROR could not open the file\n";
 return -1;
 }

 std::cout<<"format: "<iformat->name<<" , duration:"<<(double)(pFormatContext->duration/AV_TIME_BASE)<<"seconds, bit_rate:"<bit_rate<video_codec);

 
 if (!outputCodec)
 {
 std::cout << "can't create output codec" << std::endl;
 return -1;
 } 
 

 AVStream* outputStream = avformat_new_stream(outputFormatContext, outputCodec);

 if (!outputStream)
 {
 std::cout << "can't find output format" << std::endl;
 return -1;
 }

 outputCodecContext = avcodec_alloc_context3(outputCodec);

 if (!outputCodecContext)
 {
 std::cout << "can't create output codec context" << std::endl;
 return -1;
 }

 AVCodec *pCodec = NULL;

 AVCodecParameters *pCodecParameters = NULL;

 int video_stream_index = -1;

 AVStream* stream = NULL;
 
 // loop though all the streams and print its main information
 for (int i = 0; i < pFormatContext->nb_streams; i++)
 {
 
 AVCodecParameters *pLocalCodecParameters = NULL;
 pLocalCodecParameters = pFormatContext->streams[i]->codecpar;

 AVCodec *pLocalCodec = NULL;
 pLocalCodec = avcodec_find_decoder(pLocalCodecParameters->codec_id);
 if (pLocalCodec==NULL) {
 std::cerr<<"ERROR unsupported codec!\n";
 // In this example if the codec is not found we just skip it
 continue;
 }


 if (pLocalCodecParameters->codec_type == AVMEDIA_TYPE_VIDEO) {
 if (video_stream_index == -1) {
 video_stream_index = i;
 pCodec = pLocalCodec;
 pCodecParameters = pLocalCodecParameters;
 stream = pFormatContext->streams[i];
 std::cout<<"codec id: "<codecpar->codec_id<codecpar->codec_type<codecpar->width<codecpar->height<codecpar->format<codecpar->bit_rate<codecpar->codec_id = outputFormat->video_codec;
 // outputStream->codecpar->codec_id = stream->codecpar->codec_id;
 outputStream->codecpar->codec_type = AVMEDIA_TYPE_VIDEO;
 outputStream->codecpar->width = stream->codecpar->width;
 outputStream->codecpar->height = stream->codecpar->height;
 outputStream->codecpar->format = AV_PIX_FMT_YUV420P;
 outputStream->codecpar->bit_rate = stream->codecpar->bit_rate;
 
 avcodec_parameters_to_context(outputCodecContext, outputStream->codecpar);
 } 

 std::cout<<"Video Codec: resolution " << pLocalCodecParameters->width << " x "<height<codec_type == AVMEDIA_TYPE_AUDIO) {
 std::cout<<"Audio Codec: "<channels<<" channels, sample rate "<sample_rate<name << " ID: " <id<< " bit_rate: "<bit_rate</ outputStream->codecpar->codec_id = outputFormat->video_codec;
 // outputStream->codecpar->codec_type = AVMEDIA_TYPE_VIDEO;
 // outputStream->codecpar->width = 300;
 // outputStream->codecpar->height = 300;
 // outputStream->codecpar->format = AV_PIX_FMT_YUV420P;
 // outputStream->codecpar->bit_rate = 200 * 1000;
 outputCodecContext->time_base = (AVRational){ 1, 1 };
 outputCodecContext->max_b_frames = 2;
 outputCodecContext->gop_size = 12;
 outputCodecContext->framerate = (AVRational){ 30, 1 };

 if (avcodec_parameters_to_context(pCodecContext, pCodecParameters) < 0)
 {
 std::cerr<<"failed to copy codec params to codec context\n";
 return -1;
 }

 // std::cout<<"pCodecContext->time_base: "<time_base)</ outputCodecContext->time_base = pCodecContext->time_base;
 // outputCodecContext->max_b_frames = pCodecContext->max_b_frames;
 // outputCodecContext->gop_size = pCodecContext->gop_size;
 // outputCodecContext->framerate = pCodecContext->framerate;

 if (outputStream->codecpar->codec_id == AV_CODEC_ID_H264) {
 // av_opt_set(pCodecContext, "preset", "ultrafast", 0);
 av_opt_set(outputCodecContext, "preset", "ultrafast", 0);
 }
 else if (outputStream->codecpar->codec_id == AV_CODEC_ID_H265)
 {
 // av_opt_set(pCodecContext, "preset", "ultrafast", 0);
 av_opt_set(outputCodecContext, "preset", "ultrafast", 0);
 }

 // avcodec_parameters_from_context(stream->codecpar, pCodecContext);
 avcodec_parameters_from_context(outputStream->codecpar, outputCodecContext);

 if (avcodec_open2(pCodecContext, pCodec, NULL) < 0)
 {
 std::cerr<<"failed to open codec through avcodec_open2\n";
 return -1;
 }

 if (avcodec_open2(outputCodecContext, outputCodec, NULL) < 0)
 {
 std::cerr<<"failed to open output codec through avcodec_open2\n";
 return -1;
 }


 if (!(outputFormat->flags & AVFMT_NOFILE)) {
 if (avio_open(&outputFormatContext->pb, "test.mp4", AVIO_FLAG_WRITE) < 0) {
 std::cout << "Failed to open file" << std::endl;
 return -1;
 }
 }

 if (avformat_write_header(outputFormatContext, NULL) < 0) {
 std::cout << "Failed to write header" << std::endl;
 return -1;
 }

 av_dump_format(outputFormatContext, 0, "test.mp4", 1);


 AVFrame *pFrame = av_frame_alloc();
 if (!pFrame)
 {
 std::cerr<<"failed to allocate memory for AVFrame\n";
 return -1;
 }
 
 // https://ffmpeg.org/doxygen/trunk/structAVPacket.html
 AVPacket *pPacket = av_packet_alloc();
 if (!pPacket)
 {
 std::cerr<<"failed to allocate memory for AVPacket\n";
 return -1;
 }

 int response = 0;
 int how_many_packets_to_process = 300;

 // fill the Packet with data from the Stream
 // https://ffmpeg.org/doxygen/trunk/group__lavf__decoding.html#ga4fdb3084415a82e3810de6ee60e46a61
 while (av_read_frame(pFormatContext, pPacket) >= 0)
 {
 // if it's the video stream
 if (pPacket->stream_index == video_stream_index) {
 std::cout<<"AVPacket->pts "<pts;
 // if(av_write_frame(outputFormatContext, pPacket)<0)
 // std::cout<<"error writing output frame\n";
 // pushFrame(pFrame, outputCodecContext, pPacket, outputFormatContext, outputCodec);
 response = decode_packet(pPacket, pCodecContext, pFrame);
 if (response < 0)
 break;
 // stop it, otherwise we'll be saving hundreds of frames
 if (--how_many_packets_to_process <= 0) break;
 }
 // https://ffmpeg.org/doxygen/trunk/group__lavc__packet.html#ga63d5a489b419bd5d45cfd09091cbcbc2
 av_packet_unref(pPacket);
 } 

 if(av_write_trailer(outputFormatContext)<0)
 std::cout <<"Error writing output trailer\n";


 return 0;
}

int save_frame_as_mpeg(AVCodecContext* pCodecCtx, AVFrame* pFrame, int FrameNo) {
 int ret = 0;

 const AVCodec* mpegCodec = avcodec_find_encoder(pCodecCtx->codec_id);
 if (!mpegCodec) {
 std::cout<<"failed to open mpegCodec\n";
 return -1;
 }
 AVCodecContext* mpegContext = avcodec_alloc_context3(mpegCodec);
 if (!mpegContext) {
 std::cout<<"failed to open mpegContext\n";
 return -1;
 }

 mpegContext->pix_fmt = pCodecCtx->pix_fmt;
 mpegContext->height = pFrame->height;
 mpegContext->width = pFrame->width;
 mpegContext->time_base = AVRational{ 1,10 };

 ret = avcodec_open2(mpegContext, mpegCodec, NULL);
 if (ret < 0) {
 return ret;
 }
 FILE* MPEGFile;
 char MPEGFName[256];

 AVPacket packet;
 packet.data = NULL;
 packet.size = 0;
 av_init_packet(&packet);

 int gotFrame;

 ret = avcodec_send_frame(mpegContext, pFrame);
 if (ret < 0) {
 std::cout<<"failed to send frame for mpegContext\n";
 return ret;
 }

 ret = avcodec_receive_packet(mpegContext, &packet);
 if (ret < 0) {
 std::cout<<"failed to receive packet for mpegContext\terrocode: "<pix_fmt = pCodecCtx->pix_fmt;
 jpegContext->height = pFrame->height;
 jpegContext->width = pFrame->width;
 jpegContext->time_base = AVRational{ 1,10 };

 ret = avcodec_open2(jpegContext, jpegCodec, NULL);
 if (ret < 0) {
 return ret;
 }
 FILE* JPEGFile;
 char JPEGFName[256];

 AVPacket packet;
 packet.data = NULL;
 packet.size = 0;
 av_init_packet(&packet);

 int gotFrame;

 ret = avcodec_send_frame(jpegContext, pFrame);
 if (ret < 0) {
 return ret;
 }

 ret = avcodec_receive_packet(jpegContext, &packet);
 if (ret < 0) {
 return ret;
 }

 sprintf(JPEGFName, "c:\\folder\\dvr-%06d.jpg", FrameNo);
 JPEGFile = fopen(JPEGFName, "wb");
 fwrite(packet.data, 1, packet.size, JPEGFile);
 fclose(JPEGFile);

 av_packet_unref(&packet);
 avcodec_close(jpegContext);
 return 0;
}

static int decode_packet(AVPacket *pPacket, AVCodecContext *pCodecContext, AVFrame *pFrame)
{
 // Supply raw packet data as input to a decoder
 // https://ffmpeg.org/doxygen/trunk/group__lavc__decoding.html#ga58bc4bf1e0ac59e27362597e467efff3
 int response = avcodec_send_packet(pCodecContext, pPacket);
 if (response < 0) {
 std::cerr<<"Error while sending a packet to the decoder: "<= 0)
 {
 // Return decoded output data (into a frame) from a decoder
 // https://ffmpeg.org/doxygen/trunk/group__lavc__decoding.html#ga11e6542c4e66d3028668788a1a74217c
 response = avcodec_receive_frame(pCodecContext, pFrame);
 if (response == AVERROR(EAGAIN) || response == AVERROR_EOF) {
 break;
 } else if (response < 0) {
 std::cerr<<"Error while receiving a frame from the decoder: "<= 0) {

 response = save_frame_as_jpeg(pCodecContext, pFrame, pCodecContext->frame_number);

 if(response<0)
 {
 std::cerr<<"Failed to save frame as jpeg\n";
 return -1;
 }

 response = save_frame_as_mpeg(pCodecContext, pFrame, pCodecContext->frame_number);

 if(response<0)
 {
 std::cerr<<"Failed to save frame as mpeg\n";
 return -1;
 }


 std::cout<<
 "Frame "<frame_number<< "type= "<pict_type)<<" size= "<pkt_size<<" bytes, format= "<format<<" "<pts<<"pts key_frame "<key_frame<< " [DTS"<coded_picture_number<<" ]\n";
 
 char frame_filename[1024];
 snprintf(frame_filename, sizeof(frame_filename), "%s-%d.pgm", "frame", pCodecContext->frame_number);
 // Check if the frame is a planar YUV 4:2:0, 12bpp
 // That is the format of the provided .mp4 file
 // RGB formats will definitely not give a gray image
 // Other YUV image may do so, but untested, so give a warning
 if (pFrame->format != AV_PIX_FMT_YUV420P)
 {
 std::cout<<"Warning: the generated file may not be a grayscale image, but could e.g. be just the R component if the video format is RGB\n";
 }
 
 }
 }
 return 0;
}
</thread></chrono></string></fstream>

The question that I am seeking an answer to is How can I use libavcodec to split an mp4 file into 1 second chunk clips (those clips will be in mp4 format) ?


-
Revision 33515 : Erreur dans la requête
4 décembre 2009, par kent1@… — LogErreur dans la requête
Syndiquer tout le site
