Recherche avancée
Médias (1)
-
Rennes Emotion Map 2010-11
19 octobre 2011, par
Mis à jour : Juillet 2013
Langue : français
Type : Texte
Autres articles (70)
-
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 ;
-
Submit bugs and patches
13 avril 2011Unfortunately a software is never perfect.
If you think you have found a bug, report it using our ticket system. Please to help us to fix it by providing the following information : the browser you are using, including the exact version as precise an explanation as possible of the problem if possible, the steps taken resulting in the problem a link to the site / page in question
If you think you have solved the bug, fill in a ticket and attach to it a corrective patch.
You may also (...) -
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 (9594)
-
iOS 17’s Impact on Marketing : Navigating Privacy Changes
22 septembre 2023, par Erin — Analytics Tips, MarketingIn the ever-evolving landscape of digital marketing, staying up-to-date with the latest changes is paramount. One such significant change came on 18 September 2023, in the form of iOS 17, Apple’s latest operating system update. With iOS 17, Apple has introduced new privacy features that are set to have a profound impact on marketers and how they track and analyse user behaviour.
In this blog, we will explore what iOS 17 is, how it affects tracking, which tracking parameters are impacted, what remains unaffected, and most importantly, how marketers can future-proof their campaign tracking URLs.
What is iOS 17 ?
iOS 17 is the latest update to Apple’s mobile operating system, used on millions of iPhones worldwide. While iOS updates often bring new features and improvements, iOS 17 has made waves in the digital marketing community due to its emphasis on user privacy.
How does iOS 17 affect tracking ?
One of the key features of iOS 17 that concerns marketers is its impact on tracking. Apple’s new update aims to enhance user privacy by limiting the information that can be tracked and collected by third-party entities, particularly through query parameters in URLs. This means that certain tracking mechanisms that marketers have relied on for years are now rendered ineffective on iOS 17 devices.
Campaign tracking URLs, also known as tracking parameters or UTM parameters, are special codes added to the end of URLs. They are used by marketers to track various aspects of a user’s interaction with a digital marketing campaign. These parameters provide valuable data, such as the source of traffic, the medium through which users arrived and specific campaign details.
For example, with Matomo (mtm) tracking parameters, a campaign tracking URL might look like this :
https://www.example.com/products/example_product?mtm_campaign=summer-sale
Understanding the impact of iOS 17 on campaign tracking URLs is essential for marketers who rely on this data to measure the effectiveness of their marketing campaigns.
Which campaign tracking parameters are affected by iOS 17 ?
Several tracking parameters commonly used by marketers will no longer work as expected on iOS 17. Some of these include :
- Facebook (fbclid) : Employed for tracking Facebook advertising campaigns.
- Instagram (igshid) : Used to track user interactions with Instagram ads.
- Google Ads (gclid) : Used to track Google Ads campaigns.
- Twitter (twclid) : Used to track user interactions with Twitter ads.
- Microsoft Ads (msclkid) : Employed for tracking Microsoft Ads campaigns.
- Mailchimp (mc_eid) : Used by Mailchimp for email campaign tracking.
These changes are significant, as they disrupt many of the common tracking methods that marketers rely on to measure the effectiveness of their campaigns.
Which campaign tracking parameters are not affected by iOS 17 ?
While many tracking parameters have been impacted, there are still some that remain unaffected on iOS 17. However, it’s important to note that the status of these parameters might change in the future as Apple continues to prioritise user privacy. Some of the tracking parameters that are still working as of now include :
- Matomo (mtm) : Matomo campaign tracking parameters.
- Google Analytics (UTMs) : Google Analytics campaign tracking parameters.
- Pinterest (epik) : Used for tracking Pinterest campaigns.
- Klaviyo (_kx) : Klaviyo for email marketing tracking.
- TikTok (tt-) : Used for tracking TikTok ad interactions.
- Hubspot (hsa) : Used for tracking Hubspot campaigns.
While these parameters offer some reprieve for marketers, it’s essential to keep a close eye on any potential changes in their functionality as Apple continues to roll out privacy-friendly features.
How are Matomo users impacted ?
Fortunately, Matomo, as a leading privacy-friendly web analytics solution, remains unaffected by the changes introduced by iOS 17. Specifically :
For Matomo users who rely on mtm or UTMs
If you’re using Matomo or GA tracking parameters, you can rest assured that iOS 17’s changes won’t affect your tracking capabilities in Matomo.
Attention to gclids (Google Ads) and msclkid (Bing Ads)
If you use Google Ads or Bing Ads tracking parameters with Matomo’s Advertising Conversion Export feature for tracking, iOS 17 presents a challenge. Your gclids and msclkids may not provide the same level of tracking accuracy on Apple mobile devices. This is a critical consideration, especially if your ad campaigns target mobile users.
To stay informed about changes in the digital marketing landscape, including updates related to iOS 17, sign up for our newsletter where we regularly provide updates and insights on adapting your tracking and marketing strategies to ensure compliance and respect user privacy.
How to future-proof your campaign tracking
Given the impact of iOS 17 on tracking, it’s crucial for marketers to adapt and future-proof their campaign tracking strategies. Here are some steps you can take to mitigate the affects of iOS 17 on your marketing campaigns :
Monitor platform updates
Expect updates from advertising and analytics platforms in response to Apple’s privacy changes. These platforms are likely to develop alternative tracking methods or adapt existing ones to comply with iOS 17’s restrictions. Stay informed about these updates and incorporate them into your tracking strategy.
Prioritise privacy-friendly tech stacks
In the ever-evolving digital marketing landscape, it’s crucial to prioritise privacy-friendly tech stacks. Privacy-friendly tracking tools like Matomo are essential for maintaining trust and respecting user privacy.
Matomo ensures the privacy of your users and analytics data. When using Matomo, you retain control of your data ; nobody else does. This commitment to user privacy aligns with the changing digital marketing landscape, where privacy is taking centre stage.
Transition from affected campaign tracking parameters
If you’ve been using tools like Mailchimp, whose campaign tracking URLs have been affected by iOS 17, consider transitioning to the campaign tracking URL parameters of your analytics solution. Whether you choose Matomo or Google Analytics, these solutions can help you understand how your email marketing campaigns are performing.
Focus on data privacy compliance
Embrace data privacy compliance practices. As privacy regulations evolve, it’s essential to prioritise transparency in data collection. Ensure that your tracking methods align with privacy standards to maintain trust with your audience.
Regularly review and adapt
The digital marketing landscape is dynamic, and iOS 17 is just one example of how quickly things can change. Regularly review your tracking methods and adapt to new developments in the industry. Staying agile and informed is key to long-term success.
Marketers’ path forward
iOS 17 has reshaped mobile user privacy, challenging marketers to adapt. While some tracking parameters are affected, savvy marketers can still thrive by embracing unique tracking solutions, staying informed about platform updates, and prioritising data privacy.
Explore Matomo for privacy-friendly analytics and navigate this evolving landscape successfully with our 21-day free trial – no credit card required.
-
How can I fix a segmentation fault in a C program ? [duplicate]
31 mars 2023, par ipegasus

Possible Duplicate :

Segmentation fault



Currently I am upgrading an open source program used for HTTP streaming. It needs to support the latest FFmpeg.
The code compiles fine without any warnings, although I am getting a segmentation fault error.


How can I fix the issue ? And / or, what is the best way to debug ? Please find attached a portion of the code due to size. I will try to add the project to GitHub :)


Sample Usage


# segmenter --i out.ts --l 10 --o stream.m3u8 --d segments --f stream


Makefile


FFLIBS=`pkg-config --libs libavformat libavcodec libavutil`
FFFLAGS=`pkg-config --cflags libavformat libavcodec libavutil`

all:
 gcc -Wall -g segmenter.c -o segmenter ${FFFLAGS} ${FFLIBS}


segmenter.c


/*
 * Copyright (c) 2009 Chase Douglas
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License version 2
 * as published by the Free Software Foundation.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
 */
#include 
#include 
#include 
#include 
#include 
#include "libavformat/avformat.h"

#include "libavformat/avio.h"

#include <sys></sys>stat.h>

#include "segmenter.h"
#include "libavformat/avformat.h"

#define IMAGE_ID3_SIZE 9171

void printUsage() {
 fprintf(stderr, "\nExample: segmenter --i infile --d baseDir --f baseFileName --o playListFile.m3u8 --l 10 \n");
 fprintf(stderr, "\nOptions: \n");
 fprintf(stderr, "--i <infile>.\n");
 fprintf(stderr, "--o <outfile>.\n");
 fprintf(stderr, "--d basedir, the base directory for files.\n");
 fprintf(stderr, "--f baseFileName, output files will be baseFileName-#.\n");
 fprintf(stderr, "--l segment length, the length of each segment.\n");
 fprintf(stderr, "--a, audio only decode for < 64k streams.\n");
 fprintf(stderr, "--v, video only decode for < 64k streams.\n");
 fprintf(stderr, "--version, print version details and exit.\n");
 fprintf(stderr, "\n\n");
}

void ffmpeg_version() {
 // output build and version numbers
 fprintf(stderr, " libavutil version: %s\n", AV_STRINGIFY(LIBAVUTIL_VERSION));
 fprintf(stderr, " libavutil build: %d\n", LIBAVUTIL_BUILD);
 fprintf(stderr, " libavcodec version: %s\n", AV_STRINGIFY(LIBAVCODEC_VERSION));
 fprintf(stdout, " libavcodec build: %d\n", LIBAVCODEC_BUILD);
 fprintf(stderr, " libavformat version: %s\n", AV_STRINGIFY(LIBAVFORMAT_VERSION));
 fprintf(stderr, " libavformat build: %d\n", LIBAVFORMAT_BUILD);
 fprintf(stderr, " built on " __DATE__ " " __TIME__);
#ifdef __GNUC__
 fprintf(stderr, ", gcc: " __VERSION__ "\n");
#else
 fprintf(stderr, ", using a non-gcc compiler\n");
#endif
}


static AVStream *add_output_stream(AVFormatContext *output_format_context, AVStream *input_stream) {
 AVCodecContext *input_codec_context;
 AVCodecContext *output_codec_context;
 AVStream *output_stream;

 output_stream = avformat_new_stream(output_format_context, 0);
 if (!output_stream) {
 fprintf(stderr, "Segmenter error: Could not allocate stream\n");
 exit(1);
 }

 input_codec_context = input_stream->codec;
 output_codec_context = output_stream->codec;

 output_codec_context->codec_id = input_codec_context->codec_id;
 output_codec_context->codec_type = input_codec_context->codec_type;
 output_codec_context->codec_tag = input_codec_context->codec_tag;
 output_codec_context->bit_rate = input_codec_context->bit_rate;
 output_codec_context->extradata = input_codec_context->extradata;
 output_codec_context->extradata_size = input_codec_context->extradata_size;

 if (av_q2d(input_codec_context->time_base) * input_codec_context->ticks_per_frame > av_q2d(input_stream->time_base) && av_q2d(input_stream->time_base) < 1.0 / 1000) {
 output_codec_context->time_base = input_codec_context->time_base;
 output_codec_context->time_base.num *= input_codec_context->ticks_per_frame;
 } else {
 output_codec_context->time_base = input_stream->time_base;
 }

 switch (input_codec_context->codec_type) {
#ifdef USE_OLD_FFMPEG
 case CODEC_TYPE_AUDIO:
#else
 case AVMEDIA_TYPE_AUDIO:
#endif
 output_codec_context->channel_layout = input_codec_context->channel_layout;
 output_codec_context->sample_rate = input_codec_context->sample_rate;
 output_codec_context->channels = input_codec_context->channels;
 output_codec_context->frame_size = input_codec_context->frame_size;
 if ((input_codec_context->block_align == 1 && input_codec_context->codec_id == CODEC_ID_MP3) || input_codec_context->codec_id == CODEC_ID_AC3) {
 output_codec_context->block_align = 0;
 } else {
 output_codec_context->block_align = input_codec_context->block_align;
 }
 break;
#ifdef USE_OLD_FFMPEG
 case CODEC_TYPE_VIDEO:
#else
 case AVMEDIA_TYPE_VIDEO:
#endif
 output_codec_context->pix_fmt = input_codec_context->pix_fmt;
 output_codec_context->width = input_codec_context->width;
 output_codec_context->height = input_codec_context->height;
 output_codec_context->has_b_frames = input_codec_context->has_b_frames;

 if (output_format_context->oformat->flags & AVFMT_GLOBALHEADER) {
 output_codec_context->flags |= CODEC_FLAG_GLOBAL_HEADER;
 }
 break;
 default:
 break;
 }

 return output_stream;
}

int write_index_file(const char index[], const char tmp_index[], const unsigned int planned_segment_duration, const unsigned int actual_segment_duration[],
 const char output_directory[], const char output_prefix[], const char output_file_extension[],
 const unsigned int first_segment, const unsigned int last_segment) {
 FILE *index_fp;
 char *write_buf;
 unsigned int i;

 index_fp = fopen(tmp_index, "w");
 if (!index_fp) {
 fprintf(stderr, "Could not open temporary m3u8 index file (%s), no index file will be created\n", tmp_index);
 return -1;
 }

 write_buf = malloc(sizeof (char) * 1024);
 if (!write_buf) {
 fprintf(stderr, "Could not allocate write buffer for index file, index file will be invalid\n");
 fclose(index_fp);
 return -1;
 }

 unsigned int maxDuration = planned_segment_duration;

 for (i = first_segment; i <= last_segment; i++)
 if (actual_segment_duration[i] > maxDuration)
 maxDuration = actual_segment_duration[i];



 snprintf(write_buf, 1024, "#EXTM3U\n#EXT-X-TARGETDURATION:%u\n", maxDuration);

 if (fwrite(write_buf, strlen(write_buf), 1, index_fp) != 1) {
 fprintf(stderr, "Could not write to m3u8 index file, will not continue writing to index file\n");
 free(write_buf);
 fclose(index_fp);
 return -1;
 }

 for (i = first_segment; i <= last_segment; i++) {
 snprintf(write_buf, 1024, "#EXTINF:%u,\n%s-%u%s\n", actual_segment_duration[i], output_prefix, i, output_file_extension);
 if (fwrite(write_buf, strlen(write_buf), 1, index_fp) != 1) {
 fprintf(stderr, "Could not write to m3u8 index file, will not continue writing to index file\n");
 free(write_buf);
 fclose(index_fp);
 return -1;
 }
 }

 snprintf(write_buf, 1024, "#EXT-X-ENDLIST\n");
 if (fwrite(write_buf, strlen(write_buf), 1, index_fp) != 1) {
 fprintf(stderr, "Could not write last file and endlist tag to m3u8 index file\n");
 free(write_buf);
 fclose(index_fp);
 return -1;
 }

 free(write_buf);
 fclose(index_fp);

 return rename(tmp_index, index);
}

int main(int argc, const char *argv[]) {
 //input parameters
 char inputFilename[MAX_FILENAME_LENGTH], playlistFilename[MAX_FILENAME_LENGTH], baseDirName[MAX_FILENAME_LENGTH], baseFileName[MAX_FILENAME_LENGTH];
 char baseFileExtension[5]; //either "ts", "aac" or "mp3"
 int segmentLength, outputStreams, verbosity, version;



 char currentOutputFileName[MAX_FILENAME_LENGTH];
 char tempPlaylistName[MAX_FILENAME_LENGTH];


 //these are used to determine the exact length of the current segment
 double prev_segment_time = 0;
 double segment_time;
 unsigned int actual_segment_durations[2048];
 double packet_time = 0;

 //new variables to keep track of output size
 double output_bytes = 0;

 unsigned int output_index = 1;
 AVOutputFormat *ofmt;
 AVFormatContext *ic = NULL;
 AVFormatContext *oc;
 AVStream *video_st = NULL;
 AVStream *audio_st = NULL;
 AVCodec *codec;
 int video_index;
 int audio_index;
 unsigned int first_segment = 1;
 unsigned int last_segment = 0;
 int write_index = 1;
 int decode_done;
 int ret;
 int i;

 unsigned char id3_tag[128];
 unsigned char * image_id3_tag;

 size_t id3_tag_size = 73;
 int newFile = 1; //a boolean value to flag when a new file needs id3 tag info in it

 if (parseCommandLine(inputFilename, playlistFilename, baseDirName, baseFileName, baseFileExtension, &outputStreams, &segmentLength, &verbosity, &version, argc, argv) != 0)
 return 0;

 if (version) {
 ffmpeg_version();
 return 0;
 }


 fprintf(stderr, "%s %s\n", playlistFilename, tempPlaylistName);


 image_id3_tag = malloc(IMAGE_ID3_SIZE);
 if (outputStreams == OUTPUT_STREAM_AUDIO)
 build_image_id3_tag(image_id3_tag);
 build_id3_tag((char *) id3_tag, id3_tag_size);

 snprintf(tempPlaylistName, strlen(playlistFilename) + strlen(baseDirName) + 1, "%s%s", baseDirName, playlistFilename);
 strncpy(playlistFilename, tempPlaylistName, strlen(tempPlaylistName));
 strncpy(tempPlaylistName, playlistFilename, MAX_FILENAME_LENGTH);
 strncat(tempPlaylistName, ".", 1);

 //decide if this is an aac file or a mpegts file.
 //postpone deciding format until later
 /* ifmt = av_find_input_format("mpegts");
 if (!ifmt)
 {
 fprintf(stderr, "Could not find MPEG-TS demuxer.\n");
 exit(1);
 } */

 av_log_set_level(AV_LOG_DEBUG);

 av_register_all();
 ret = avformat_open_input(&ic, inputFilename, NULL, NULL);
 if (ret != 0) {
 fprintf(stderr, "Could not open input file %s. Error %d.\n", inputFilename, ret);
 exit(1);
 }

 if (avformat_find_stream_info(ic, NULL) < 0) {
 fprintf(stderr, "Could not read stream information.\n");
 exit(1);
 }

 oc = avformat_alloc_context();
 if (!oc) {
 fprintf(stderr, "Could not allocate output context.");
 exit(1);
 }

 video_index = -1;
 audio_index = -1;

 for (i = 0; i < ic->nb_streams && (video_index < 0 || audio_index < 0); i++) {
 switch (ic->streams[i]->codec->codec_type) {

#ifdef USE_OLD_FFMPEG
 case CODEC_TYPE_VIDEO:
#else
 case AVMEDIA_TYPE_VIDEO:
#endif
 video_index = i;
 ic->streams[i]->discard = AVDISCARD_NONE;
 if (outputStreams & OUTPUT_STREAM_VIDEO)
 video_st = add_output_stream(oc, ic->streams[i]);
 break;
#ifdef USE_OLD_FFMPEG
 case CODEC_TYPE_AUDIO:
#else
 case AVMEDIA_TYPE_AUDIO:
#endif
 audio_index = i;
 ic->streams[i]->discard = AVDISCARD_NONE;
 if (outputStreams & OUTPUT_STREAM_AUDIO)
 audio_st = add_output_stream(oc, ic->streams[i]);
 break;
 default:
 ic->streams[i]->discard = AVDISCARD_ALL;
 break;
 }
 }

 if (video_index == -1) {
 fprintf(stderr, "Stream must have video component.\n");
 exit(1);
 }

 //now that we know the audio and video output streams
 //we can decide on an output format.
 if (outputStreams == OUTPUT_STREAM_AUDIO) {
 //the audio output format should be the same as the audio input format
 switch (ic->streams[audio_index]->codec->codec_id) {
 case CODEC_ID_MP3:
 fprintf(stderr, "Setting output audio to mp3.");
 strncpy(baseFileExtension, ".mp3", strlen(".mp3"));
 ofmt = av_guess_format("mp3", NULL, NULL);
 break;
 case CODEC_ID_AAC:
 fprintf(stderr, "Setting output audio to aac.");
 ofmt = av_guess_format("adts", NULL, NULL);
 break;
 default:
 fprintf(stderr, "Codec id %d not supported.\n", ic->streams[audio_index]->id);
 }
 if (!ofmt) {
 fprintf(stderr, "Could not find audio muxer.\n");
 exit(1);
 }
 } else {
 ofmt = av_guess_format("mpegts", NULL, NULL);
 if (!ofmt) {
 fprintf(stderr, "Could not find MPEG-TS muxer.\n");
 exit(1);
 }
 }
 oc->oformat = ofmt;

 if (outputStreams & OUTPUT_STREAM_VIDEO && oc->oformat->flags & AVFMT_GLOBALHEADER) {
 oc->flags |= CODEC_FLAG_GLOBAL_HEADER;
 }


 /* Deprecated: pass the options to avformat_write_header directly.
 if (av_set_parameters(oc, NULL) < 0) {
 fprintf(stderr, "Invalid output format parameters.\n");
 exit(1);
 }
 */

 av_dump_format(oc, 0, baseFileName, 1);


 //open the video codec only if there is video data
 if (video_index != -1) {
 if (outputStreams & OUTPUT_STREAM_VIDEO)
 codec = avcodec_find_decoder(video_st->codec->codec_id);
 else
 codec = avcodec_find_decoder(ic->streams[video_index]->codec->codec_id);
 if (!codec) {
 fprintf(stderr, "Could not find video decoder, key frames will not be honored.\n");
 }

 if (outputStreams & OUTPUT_STREAM_VIDEO)
 ret = avcodec_open2(video_st->codec, codec, NULL);
 else
 avcodec_open2(ic->streams[video_index]->codec, codec, NULL);
 if (ret < 0) {
 fprintf(stderr, "Could not open video decoder, key frames will not be honored.\n");
 }
 }

 snprintf(currentOutputFileName, strlen(baseDirName) + strlen(baseFileName) + strlen(baseFileExtension) + 10, "%s%s-%u%s", baseDirName, baseFileName, output_index++, baseFileExtension);

 if (avio_open(&oc->pb, currentOutputFileName, URL_WRONLY) < 0) {
 fprintf(stderr, "Could not open '%s'.\n", currentOutputFileName);
 exit(1);
 }
 newFile = 1;

 int r = avformat_write_header(oc,NULL);
 if (r) {
 fprintf(stderr, "Could not write mpegts header to first output file.\n");
 debugReturnCode(r);
 exit(1);
 }

 //no segment info is written here. This just creates the shell of the playlist file
 write_index = !write_index_file(playlistFilename, tempPlaylistName, segmentLength, actual_segment_durations, baseDirName, baseFileName, baseFileExtension, first_segment, last_segment);

 do {
 AVPacket packet;

 decode_done = av_read_frame(ic, &packet);

 if (decode_done < 0) {
 break;
 }

 if (av_dup_packet(&packet) < 0) {
 fprintf(stderr, "Could not duplicate packet.");
 av_free_packet(&packet);
 break;
 }

 //this time is used to check for a break in the segments
 // if (packet.stream_index == video_index && (packet.flags & PKT_FLAG_KEY))
 // {
 // segment_time = (double)video_st->pts.val * video_st->time_base.num / video_st->time_base.den;
 // }
#if USE_OLD_FFMPEG
 if (packet.stream_index == video_index && (packet.flags & PKT_FLAG_KEY))
#else
 if (packet.stream_index == video_index && (packet.flags & AV_PKT_FLAG_KEY))
#endif
 {
 segment_time = (double) packet.pts * ic->streams[video_index]->time_base.num / ic->streams[video_index]->time_base.den;
 }
 // else if (video_index < 0)
 // {
 // segment_time = (double)audio_st->pts.val * audio_st->time_base.num / audio_st->time_base.den;
 // }

 //get the most recent packet time
 //this time is used when the time for the final segment is printed. It may not be on the edge of
 //of a keyframe!
 if (packet.stream_index == video_index)
 packet_time = (double) packet.pts * ic->streams[video_index]->time_base.num / ic->streams[video_index]->time_base.den; //(double)video_st->pts.val * video_st->time_base.num / video_st->time_base.den;
 else if (outputStreams & OUTPUT_STREAM_AUDIO)
 packet_time = (double) audio_st->pts.val * audio_st->time_base.num / audio_st->time_base.den;
 else
 continue;
 //start looking for segment splits for videos one half second before segment duration expires. This is because the
 //segments are split on key frames so we cannot expect all segments to be split exactly equally.
 if (segment_time - prev_segment_time >= segmentLength - 0.5) {
 fprintf(stderr, "looking to print index file at time %lf\n", segment_time);
 avio_flush(oc->pb);
 avio_close(oc->pb);

 if (write_index) {
 actual_segment_durations[++last_segment] = (unsigned int) rint(segment_time - prev_segment_time);
 write_index = !write_index_file(playlistFilename, tempPlaylistName, segmentLength, actual_segment_durations, baseDirName, baseFileName, baseFileExtension, first_segment, last_segment);
 fprintf(stderr, "Writing index file at time %lf\n", packet_time);
 }

 struct stat st;
 stat(currentOutputFileName, &st);
 output_bytes += st.st_size;

 snprintf(currentOutputFileName, strlen(baseDirName) + strlen(baseFileName) + strlen(baseFileExtension) + 10, "%s%s-%u%s", baseDirName, baseFileName, output_index++, baseFileExtension);
 if (avio_open(&oc->pb, currentOutputFileName, URL_WRONLY) < 0) {
 fprintf(stderr, "Could not open '%s'\n", currentOutputFileName);
 break;
 }

 newFile = 1;
 prev_segment_time = segment_time;
 }

 if (outputStreams == OUTPUT_STREAM_AUDIO && packet.stream_index == audio_index) {
 if (newFile && outputStreams == OUTPUT_STREAM_AUDIO) {
 //add id3 tag info
 //fprintf(stderr, "adding id3tag to file %s\n", currentOutputFileName);
 //printf("%lf %lld %lld %lld %lld %lld %lf\n", segment_time, audio_st->pts.val, audio_st->cur_dts, audio_st->cur_pkt.pts, packet.pts, packet.dts, packet.dts * av_q2d(ic->streams[audio_index]->time_base) );
 fill_id3_tag((char*) id3_tag, id3_tag_size, packet.dts);
 avio_write(oc->pb, id3_tag, id3_tag_size);
 avio_write(oc->pb, image_id3_tag, IMAGE_ID3_SIZE);
 avio_flush(oc->pb);
 newFile = 0;
 }

 packet.stream_index = 0; //only one stream in audio only segments
 ret = av_interleaved_write_frame(oc, &packet);
 } else if (outputStreams & OUTPUT_STREAM_VIDEO) {
 if (newFile) {
 //fprintf(stderr, "New File: %lld %lld %lld\n", packet.pts, video_st->pts.val, audio_st->pts.val);
 //printf("%lf %lld %lld %lld %lld %lld %lf\n", segment_time, audio_st->pts.val, audio_st->cur_dts, audio_st->cur_pkt.pts, packet.pts, packet.dts, packet.dts * av_q2d(ic->streams[audio_index]->time_base) );
 newFile = 0;
 }
 if (outputStreams == OUTPUT_STREAM_VIDEO)
 ret = av_write_frame(oc, &packet);
 else
 ret = av_interleaved_write_frame(oc, &packet);
 }

 if (ret < 0) {
 fprintf(stderr, "Warning: Could not write frame of stream.\n");
 } else if (ret > 0) {
 fprintf(stderr, "End of stream requested.\n");
 av_free_packet(&packet);
 break;
 }

 av_free_packet(&packet);
 } while (!decode_done);

 //make sure all packets are written and then close the last file.
 avio_flush(oc->pb);
 av_write_trailer(oc);

 if (video_st && video_st->codec)
 avcodec_close(video_st->codec);

 if (audio_st && audio_st->codec)
 avcodec_close(audio_st->codec);

 for (i = 0; i < oc->nb_streams; i++) {
 av_freep(&oc->streams[i]->codec);
 av_freep(&oc->streams[i]);
 }

 avio_close(oc->pb);
 av_free(oc);

 struct stat st;
 stat(currentOutputFileName, &st);
 output_bytes += st.st_size;


 if (write_index) {
 actual_segment_durations[++last_segment] = (unsigned int) rint(packet_time - prev_segment_time);

 //make sure that the last segment length is not zero
 if (actual_segment_durations[last_segment] == 0)
 actual_segment_durations[last_segment] = 1;

 write_index_file(playlistFilename, tempPlaylistName, segmentLength, actual_segment_durations, baseDirName, baseFileName, baseFileExtension, first_segment, last_segment);

 }

 write_stream_size_file(baseDirName, baseFileName, output_bytes * 8 / segment_time);

 return 0;
}
</outfile></infile>

-
Localization : Add Hindi translation (#2453)
11 novembre 2022, par saurabhsharma2uLocalization : Add Hindi translation (#2453)
* Localisation : Update Hindi (India) translation
* Hindi Translation for Step Method
* HIndi-India Local messages for additional method
* file rename as per ISO 639-1 format
* removed duplicate message, causing the test fail
* removed duplicate "cifES" error message
Syndiquer tout le site
