Recherche avancée
Autres articles (47)
-
Des sites réalisés avec MediaSPIP
2 mai 2011, parCette page présente quelques-uns des sites fonctionnant sous MediaSPIP.
Vous pouvez bien entendu ajouter le votre grâce au formulaire en bas de page. -
HTML5 audio and video support
13 avril 2011, parMediaSPIP uses HTML5 video and audio tags to play multimedia files, taking advantage of the latest W3C innovations supported by modern browsers.
The MediaSPIP player used has been created specifically for MediaSPIP and can be easily adapted to fit in with a specific theme.
For older browsers the Flowplayer flash fallback is used.
MediaSPIP allows for media playback on major mobile platforms with the above (...) -
De l’upload à la vidéo finale [version standalone]
31 janvier 2010, parLe chemin d’un document audio ou vidéo dans SPIPMotion est divisé en trois étapes distinctes.
Upload et récupération d’informations de la vidéo source
Dans un premier temps, il est nécessaire de créer un article SPIP et de lui joindre le document vidéo "source".
Au moment où ce document est joint à l’article, deux actions supplémentaires au comportement normal sont exécutées : La récupération des informations techniques des flux audio et video du fichier ; La génération d’une vignette : extraction d’une (...)
Sur d’autres sites (6643)
-
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 ?


-
Subtitling Sierra VMD Files
1er juin 2016, par Multimedia Mike — Game HackingI was contacted by a game translation hobbyist from Spain (henceforth known as The Translator). He had set his sights on Sierra’s 7-CD Phantasmagoria. This mammoth game was driven by a lot of FMV files and animations that have speech. These require language translation in the form of video subtitling. He’s lucky that he found possibly the one person on the whole internet who has just the right combination of skill, time, and interest to pull this off. And why would I care about helping ? I guess I share a certain camaraderie with game hackers. Don’t act so surprised. You know what kind of stuff I like to work on.
The FMV format used in this game is VMD, which makes an appearance in numerous Sierra titles. FFmpeg already supports decoding this format. FFmpeg also supports subtitling video. So, ideally, all that’s necessary to support this goal is to add a muxer for the VMD format which can encode raw video and audio, which the format supports. Implement video compression as extra credit.
The pipeline that I envisioned looks like this :
VMD Subtitling Process
“Trivial !” I surmised. I just never learn, do I ?
The Plan
So here’s my initial pitch, outlining the work I estimated that I would need to do towards the stated goal :- Create a new file muxer that produces a syntactically valid VMD file with bogus video and audio data. Make sure it works with both FFmpeg’s playback system as well as the proper Phantasmagoria engine.
- Create a new video encoder that essentially operates in pass-through mode while correctly building a palette.
- Create a new basic encoder for the video frames.
A big unknown for me was exactly how subtitle handling operates in FFmpeg. Thanks to this project, I now know. I was concerned because I was pretty sure that font rendering entails anti-aliasing which bodes poorly for keeping the palette count under 256 unique colors.
Computer Science Puzzle
When pondering how to process the palette, I was excited for the opportunity to exercise actual computer science. FFmpeg converts frames from paletted frames to full RGB frames. Then it needs to convert them back to paletted frames. I had a vague recollection of solving this problem once before when I was experimenting with a new paletted video codec. I seem to recall that I did the palette conversion in a very naive manner. I just used a static 256-element array and processed each RGB pixel of the frame, seeing if the value already occurred in the table (O(n) lookup) and adding it otherwise.
There are more efficient algorithms, however, such as hash tables and trees. Somewhere along the line, FFmpeg helpfully acquired a rarely-used tree data structure, which was perfect for this project.
So I was pretty pleased with this optimization. Too bad this wouldn’t survive to the end of the effort.
Another palette-related challenge was the fact that a group of pictures would be accumulating a new palette but that palette needed to be recorded before the group. Thus, the muxer needed to have extra logic to rewind the file when the video encoder transmitted a palette change.
Video Compression
VMD has a few methods in its compression toolbox. It can use interframe differencing, it has some RLE, or it can code a frame raw. It can also use a custom LZ-like format on top of these. For early prototypes, I elected to leave each frame coded raw. After the concept was proved, I implemented the frame differencing.
Top frame compared with the middle frame yields the bottom frame : red pixels indicate changesEncoding only those red dots in between vast runs of unchanged pixels yielded a vast measurable improvement. The next step was to try wiring up FFmpeg’s existing LZ compression facilities to the encoder. This turned out to be implausible since VMD’s LZ variant has nothing to do with anything FFmpeg already provides. Fortunately, the LZ piece is not absolutely required and the frame differencing + RLE provides plenty of compression.
Subtitling
I’ve never done anything, multimedia programming-wise, concerning subtitles. I guess all the entertainment I care about has always been in my native tongue. What a good excuse to program outside of my comfort zone !First, I needed to know how to access FFmpeg’s subtitling facilities. Fortunately, The Translator did the legwork on this matter so I didn’t have to figure it out.
However, I intuitively had misgivings about this phase. I had heard that the subtitling process performs anti-aliasing. That means that the image would need to be promoted to a higher colorspace for this phase and that the anti-aliasing process would likely push the color count way past 256. Some quick tests revealed this to be the case, as the running color count would leap by several hundred colors as soon as the palette accounting algorithm encountered a subtitle.
So I dug into the subtitle subsystem. I discovered that the subtitle library operates by creating a linked list of subtitle bitmaps that the client app must render. The bitmaps are comprised of 8-bit alpha transparency values that must be composited onto the target frame (i.e., 0 = transparent, 255 = 100% opaque). For example, the letter ‘H’ :
(with 00s removed) 13 F8 41 00 00 00 00 68 E4 | 13 F8 41 68 E4 14 FF 44 00 00 00 00 6C EC | 14 FF 44 6C EC 14 FF 44 00 00 00 00 6C EC | 14 FF 44 6C EC 14 FF 44 00 00 00 00 6C EC | 14 FF 44 6C EC 14 FF DC D0 D0 D0 D0 E4 EC | 14 FF DC D0 D0 D0 D0 E4 EC 14 FF 7E 50 50 50 50 9A EC | 14 FF 7E 50 50 50 50 9A EC 14 FF 44 00 00 00 00 6C EC | 14 FF 44 6C EC 14 FF 44 00 00 00 00 6C EC | 14 FF 44 6C EC 14 FF 44 00 00 00 00 6C EC | 14 FF 44 6C EC 11 E0 3B 00 00 00 00 5E CE | 11 E0 3B 5E CETo get around the color explosion problem, I chose a threshold value and quantized values above and below to 255 and 0, respectively. Further, the process chooses an appropriate color from the existing palette rather than introducing any new colors.
Muxing Matters
In order to force VMD into a general purpose media framework, a lot of special information needs to be passed around. Like many paletted codecs, the palette needs to be transmitted from the file demuxer to the video decoder via some side channel. For re-encoding, this also implies that the palette needs to make the trip from the video encoder to the file muxer. As if this wasn’t enough, individual VMD frames have even more data that needs to be ferried between the muxer and codec levels, including frame change boundaries. FFmpeg provides methods to do these things, but I could not always rely on the systems to relay the data in all cases. I was probably doing something wrong ; I accept that. Instead, I just packed all the information at the front of an encoded frame and split it apart in the muxer.I could not quite figure out how to get the audio and video muxed correctly. As a result, neither FFmpeg nor the Phantasmagoria engine could replay the files correctly.
Plan B
Since I was having so much trouble creating an entirely new VMD file, likely due to numerous unknown bits of the file format, I thought of another angle : re-use the existing VMD file. For this approach, I kept the video encoder and file muxer that I created in the initial phase, but modified the file muxer to emit a special intermediate file. Then, I created a Python tool to repackage the original VMD file using compressed video data in the intermediate file.For this phase, I also implemented a command line switch for FFmpeg to disable subtitle blending, to make the feature feel like less of an unofficial hack, as though this nonsense would ever have a chance of being incorporated upstream.
At this point, I was seeing some success with the complete, albeit roundabout, subtitling process. I constructed a subtitle file using “Spanish I Learned From Mexican Telenovelas” and the frames turned out fairly readable :
“she cheated on him”
“he’s a scumbag” … these random subtitles could fit surprisingly well !
The few files that I tested appeared to work fine. But then I handed off my work to The Translator and he immediately found a bunch of problems. According to my notes, the problems mostly took the form of flashing, solid color frames. Further, I found tiny, mostly imperceptible flaws in my RLE compressor, usually only detectable by running strict comparison tools ; but I wasn’t satisfied.
At this point, I think I attempted to just encode the entire palette at the front of each frame, as allowed by the format, but that did not seem to fix any problems. My notes are not completely clear on this matter (likely because I was still trying to figure out the exact problem), but I think it had to do with FFmpeg inserting extra video frames in order to even out gaps in the video framerate.
Sigh, Plan C
At this point, I was getting tired of trying to force FFmpeg to do this. So I decided to minimize its involvement using lessons learned up to this point.The next pitch :
- Create a new C program that can open an existing VMD file and output an identical VMD file. I know this sounds easy, but the specific method of copying entails interpreting individual parts of the file and writing those individual parts to the new file. This is in preparation for…
- Import the VMD video decoder functions directly into the program to decode the individual video frames and re-encode them, replacing the video frames as the file is rewritten.
- Wire up the subtitle system. During the adventure to disable subtitle blending, I accidentally learned enough about interfacing to the subtitle library to just invoke it directly.
- Rewrite the RLE method so that it is 100% correct.
Off to work I went. That part about lifting the existing VMD decoder functions out of their libavcodec nest turned out to not be that straightforward. As an alternative, I modified the decoder to dump the raw frames to an intermediate file. In doing so, I think I was able to avoid the issue of the duplicated frames that plagued the previous efforts.
Also, remember how I was really pleased with the palette conversion technique in which I was able to leverage computer science big-O theory ? By this stage, I had no reason to convert the paletted video to RGB in the first place ; all of the decoding, subtitling and re-encoding operates in the paletted colorspace.
This approach seemed to work pretty well. The final program is subtitle-vmd.c. The process is still a little weird. The modifications in my own FFmpeg fork are necessary to create an intermediate file that the new C tool can operate with.
Next Steps
The Translator has found some assorted bugs and corner cases that still need to be ironed out. Further, for extra credit, I need find the change windows for each frame to improve compression just a little more. I don’t think I will be trying for LZ compression, though.However, almost as soon as I had this whole system working, The Translator informed me that there is another, different movie format in play in the Phantasmagoria engine called ROBOT, with an extension of RBT. Fortunately, enough of the algorithms have been reverse engineered and re-implemented in ScummVM that I was able to sort out enough details for another subtitling project. That will be the subject of a future post.
See Also :
- Subtitling Sierra RBT Files : The followup in which I discuss how to scribble text on the other animation format
-
ffmpeg error Error sending frames to consumers : No space left on device [closed]
4 août 2024, par Bernard Vatonen BernI do use a short funtion , to convert videos in a needed format ,, I used this function all the time , worked no problems ,
Lately I mado some chnages , and now geting an critical error : like : "no space left on device"

" \[af#0:1 @ 0x600001ad9cb0\] Error sending frames to consumers: No space left on device \[af#0:1 @ 0x600001ad9cb0\] Task finished with error code: -28 (No space left on device) \[af#0:1 @ 0x600001ad9cb0\] Terminating thread with return code -28 (No space left on device)"

I do have this function saved in my file : .zshrc




function indianull() 
ffmpeg -i movies/$1.* -i /Documents/indianul3.png -filter_complex "[1][0]scale2ref=w=ohmdar:h=ih0.1[logo][video] ;[video][logo]overlay=x=main_w-overlay_w-(main_w0.04):y=main_h0.14,subtitles=subs/$1.srt:force_style='FontSize=22,WrapStyle=0,MarginV=35" -preset fast -s 720x480 -vcodec libx264 -shortest output/$1-sub.mp4






\`indianull tt0066763




\[Parsed_subtitles_2 @ 0x600001fd8bb0\] libass API version: 0x1703000
\[Parsed_subtitles_2 @ 0x600001fd8bb0\] libass source: tarball: 0.17.3
\[Parsed_subtitles_2 @ 0x600001fd8bb0\] Shaper: FriBidi 1.0.15 (SIMPLE) HarfBuzz-ng 9.0.0 (COMPLEX)
\[Parsed_subtitles_2 @ 0x600001fd8bb0\] Using font provider coretext`


Input #0, mov,mp4,m4a,3gp,3g2,mj2, from 'movies/tt0066763.mp4':
Metadata:
major_brand : isom
minor_version : 512
compatible_brands: isomiso2avc1mp41
title : Anand.1971.720p.BluRay.x264-x0r
encoder : Lavf57.83.100
Duration: 02:02:08.08, start: 0.000000, bitrate: 1212 kb/s
Chapters:
Chapter #0:0: start 0.000000, end 209.375000
Stream #0:0\[0x1\](hin): Video: h264 (High) (avc1 / 0x31637661), yuv420p(progressive), 1280x720 \[SAR 1:1 DAR 16:9\], 1079 kb/s, 24 fps, 24 tbr, 12288 tbn (default)
Metadata:
handler_name : VideoHandler
vendor_id : \[0\]\[0\]\[0\]\[0\]
Stream #0:1\[0x2\](hin): Audio: aac (LC) (mp4a / 0x6134706D), 44100 Hz, stereo, fltp, 127 kb/s (default)
Metadata:
handler_name : SoundHandler
vendor_id : \[0\]\[0\]\[0\]\[0\]
Stream #0:2\[0x3\](eng): Data: bin_data (text / 0x74786574)
Metadata:
handler_name : SubtitleHandler
Input #1, png_pipe, from '/Users/bv2004/Documents/indianul3.png':
Duration: N/A, bitrate: N/A
Stream #1:0: Video: png, rgba(pc, gbr/unknown/unknown), 630x124, 25 fps, 25 tbr, 25 tbn
File 'output/tt0066763-sub.mp4' already exists. Overwrite? \[y/N\] y
Stream mapping:
Stream #0:0 (h264) -\> scale2ref (graph 0)
Stream #1:0 (png) -\> scale2ref (graph 0)
subtitles:default (graph 0) -\> Stream #0:0 (libx264)
Stream #0:1 -\> #0:1 (aac (native) -\> aac (native))
Press \[q\] to stop, \[?\] for help
\[Parsed_subtitles_2 @ 0x600001fcc420\] libass API version: 0x1703000
\[Parsed_subtitles_2 @ 0x600001fcc420\] libass source: tarball: 0.17.3
\[Parsed_subtitles_2 @ 0x600001fcc420\] Shaper: FriBidi 1.0.15 (SIMPLE) HarfBuzz-ng 9.0.0 (COMPLEX)
\[Parsed_subtitles_2 @ 0x600001fcc420\] Using font provider coretext
\[vost#0:0/libx264 @ 0x128e07bb0\] No filtered frames for output stream, trying to initialize anyway.
\[libx264 @ 0x128e084e0\] using SAR=32/27
\[libx264 @ 0x128e084e0\] using cpu capabilities: ARMv8 NEON
\[libx264 @ 0x128e084e0\] profile High, level 3.0, 4:2:0, 8-bit
\[libx264 @ 0x128e084e0\] 264 - core 164 r3108 31e19f9 - H.264/MPEG-4 AVC codec - Copyleft 2003-2023 - http://www.videolan.org/x264.html - options: cabac=1 ref=2 deblock=1:0:0 analyse=0x3:0x113 me=hex subme=6 psy=1 psy_rd=1.00:0.00 mixed_ref=1 me_range=16 chroma_me=1 trellis=1 8x8dct=1 cqm=0 deadzone=21,11 fast_pskip=1 chroma_qp_offset=-2 threads=15 lookahead_threads=2 sliced_threads=0 nr=0 decimate=1 interlaced=0 bluray_compat=0 constrained_intra=0 bframes=3 b_pyramid=2 b_adapt=1 b_bias=0 direct=1 weightb=1 open_gop=0 weightp=1 keyint=250 keyint_min=24 scenecut=40 intra_refresh=0 rc_lookahead=30 rc=crf mbtree=1 crf=23.0 qcomp=0.60 qpmin=0 qpmax=69 qpstep=4 ip_ratio=1.40 aq=1:1.00
Output #0, mp4, to 'output/tt0066763-sub.mp4':
Metadata:
major_brand : isom
minor_version : 512
compatible_brands: isomiso2avc1mp41
title : Anand.1971.720p.BluRay.x264-x0r
encoder : Lavf61.1.100

 encoder : Lavc61.3.100 aac


\[af#0:1 @ 0x600001ad9cb0\] Error sending frames to consumers: No space left on device
\[af#0:1 @ 0x600001ad9cb0\] Task finished with error code: -28 (No space left on device)
\[af#0:1 @ 0x600001ad9cb0\] Terminating thread with return code -28 (No space left on device)
\[out#0/mp4 @ 0x600001dd8540\] video:0KiB audio:0KiB subtitle:0KiB other streams:0KiB global headers:0KiB muxing overhead: unknown
\[out#0/mp4 @ 0x600001dd8540\] Output file is empty, nothing was encoded(check -ss / -t / -frames parameters if used)
frame= 0 fps=0.0 q=0.0 Lsize= 2KiB time=N/A bitrate=N/A speed=N/A
\[aac @ 0x128e09070\] Qavg: nan
Conversion failed!`


df -h
Filesystem Size Used Avail Capacity iused ifree %iused Mounted on
/dev/disk3s3s1 926Gi 9.6Gi 539Gi 2% 404k 4.3G 0% /
devfs 200Ki 200Ki 0Bi 100% 693 0 100% /dev
/dev/disk3s6 926Gi 1.0Gi 539Gi 1% 1 5.7G 0% /System/Volumes/VM
/dev/disk3s4 926Gi 5.7Gi 539Gi 2% 1.1k 5.7G 0% /System/Volumes/Preboot
/dev/disk3s2 926Gi 89Mi 539Gi 1% 53 5.7G 0% /System/Volumes/Update
/dev/disk1s2 500Mi 6.0Mi 479Mi 2% 1 4.9M 0% /System/Volumes/xarts
/dev/disk1s1 500Mi 6.1Mi 479Mi 2% 31 4.9M 0% /System/Volumes/iSCPreboot
/dev/disk1s3 500Mi 3.9Mi 479Mi 1% 57 4.9M 0% /System/Volumes/Hardware
/dev/disk3s1 926Gi 370Gi 539Gi 41% 778k 5.7G 0% /System/Volumes/Data
map auto_home 0Bi 0Bi 0Bi 100% 0 0 - /System/Volumes/Data/home\`


I run the funtion indianull and expected it to convert a video , in my desired format + add logo + add subtitles ! Takes the original Video from on folder , Subtitles from another folder , and converts the video , and saves it in another folder ..


the issue i see only is :

"\[af#0:1 @ 0x600001ad9cb0\] Error sending frames to consumers: No space left on device \[af#0:1 @ 0x600001ad9cb0\] Task finished with error code: -28 (No space left on device) \[af#0:1 @ 0x600001ad9cb0\] Terminating thread with return code -28 (No space left on device) \[out#0/mp4 @ 0x600001dd8540\] video:0KiB audio:0KiB subtitle:0KiB other streams:0KiB global headers:0KiB muxing overhead: unknown"

I do defenitly have over 400GB free on My SSD !
Is an an speciffic folder that is full ? and can not hold any files ?


Any idea how to solve this ? or any suggestion how to try to solve ?


Syndiquer tout le site
