Recherche avancée

Sur d’autres sites (6399)

• ffmpeg API muxing h264 endoced frames to mkv

  24 mars 2017, par Pawel K

  Hi I’m having some problems with muxing h264 encoded frames into mkv container using code of ffmpeg-3.2.4.
  I have ended up with the following code that is a mashup of code found on SO and muxing.c example of ffmpeg :
  (and yes I am aware that it is ugly, no errors checked etc. it is meant to be like that for clarity :) )

  char *filename = "out.mkv";
  
  const uint8_t SPS[] = { 0x67, 0x42, 0x40, 0x1F, 0x96, 0x54, 0x02, 0x80, 0x2D, 0xD0, 0x0F, 0x39, 0xEA };
  
  const uint8_t PPS[] = { 0x68, 0xCE, 0x38, 0x80 };
  
  int fps = 5;
  
  
  
  typedef struct OutputStream
  
  {
  
     AVStream *st;
  
     AVCodecContext *enc;
  
  
  
     /* pts of the next frame that will be generated */
  
     int64_t next_pts;
  
     int samples_count;
  
     AVFrame *frame;
  
     AVFrame *tmp_frame;
  
     float t, tincr, tincr2;
  
     struct SwsContext *sws_ctx;
  
     struct SwrContext *swr_ctx;
  
  } OutputStream;
  
  
  
  static void avlog_cb(void *s, int level, const char *szFmt, va_list varg)
  
  {
  
     vprintf(szFmt, varg);
  
  }
  
  
  
  void main()
  
  {
  
     AVOutputFormat *fmt;
  
     AVFormatContext *formatCtx;
  
     AVCodec *audio_codec;
  
     AVCodec *video_codec;
  
     OutputStream video_st = { 0 };
  
     OutputStream audio_st = { 0 };
  
     av_register_all();
  
  
  
     av_log_set_level(AV_LOG_TRACE);
  
     //av_log_set_callback(avlog_cb);
  
  
  
     //allocate output and format ctxs
  
     avformat_alloc_output_context2(&formatCtx, NULL, NULL, filename);
  
     fmt = formatCtx->oformat;
  
  
  
     //allocate streams
  
     video_codec = avcodec_find_encoder(fmt->video_codec);
  
     video_st.st = avformat_new_stream(formatCtx, NULL);
  
     video_st.st->id = 0;
  
  
  
     AVCodecContext *codecCtx =  avcodec_alloc_context3(video_codec);
  
     fmt->video_codec = AV_CODEC_ID_H264;
  
     video_st.enc = codecCtx;
  
  
  
     codecCtx->codec_id = fmt->video_codec;
  
     codecCtx->bit_rate = 400000;
  
     codecCtx->width  = 1080;
  
     codecCtx->height = 720;
  
     codecCtx->profile = FF_PROFILE_H264_CONSTRAINED_BASELINE;
  
     codecCtx->level = 31;
  
  
  
     video_st.st->time_base = (AVRational){ 1, fps };
  
     codecCtx->time_base = video_st.st->time_base;
  
     codecCtx->gop_size = 4;
  
     codecCtx->pix_fmt = AV_PIX_FMT_YUV420P;
  
  
  
     //open video codec
  
     codecCtx->extradata_size = 24;
  
     codecCtx->extradata = (uint8_t *)av_malloc(codecCtx->extradata_size);
  
     uint8_t extra_data_array[] = { 0x01, SPS[1], SPS[2], SPS[3], 0xFF, 0xE1, 0xc0, 0, 0x42, 0x40, 0x1F, 0x96, 0x54, 0x02, 0x80, 0x2D, 0xD0, 0x0F, 0x39, 0xEA, 0x03, 0xCE, 0x38, 0x80 };
  
     memcpy(codecCtx->extradata, extra_data_array, codecCtx->extradata_size);
  
  
  
     AVCodecContext *c = video_st.enc;
  
     AVDictionary *opt = NULL;
  
     avcodec_open2(c, video_codec, &opt);
  
     avcodec_parameters_from_context(video_st.st->codecpar, c);
  
  
  
     //open output file
  
     avio_open(&formatCtx->pb, filename, AVIO_FLAG_WRITE);
  
  
  
     //write header
  
     int res = avformat_write_header(formatCtx, NULL);
  
  
  
     //write frames
  
  
  
     // get the frames from file
  
     uint32_t u32frameCnt = 0;
  
  
  
     do
  
     {
  
        int8_t i8frame_name[64] = "";
  
  
  
        uint8_t  *pu8framePtr = NULL;
  
        AVPacket pkt = { 0 };
  
  
  
        av_init_packet(&pkt);
  
        sprintf(i8frame_name, "frames/frame%d.bin", u32frameCnt++);
  
        //reading frames from files
  
        FILE *ph264Frame = fopen(i8frame_name, "r");
  
        if(NULL == ph264Frame)
  
        {
  
           goto leave;
  
        }
  
  
  
        //get file size
  
        fseek(ph264Frame, 0L, SEEK_END);
  
        uint32_t u32file_size = 0;
  
        u32file_size = ftell(ph264Frame);
  
        fseek(ph264Frame, 0L, SEEK_SET);
  
  
  
        pu8framePtr = malloc(u32file_size);
  
        uint32_t u32readout = fread(pu8framePtr, 1, u32file_size, ph264Frame);
  
  
  
        //if the read frame is a key frame i.e. nalu hdr type = 5 set it as a key frame
  
        if(0x65 == pu8framePtr[4])
  
        {
  
           pkt.flags = AV_PKT_FLAG_KEY;
  
        }
  
        pkt.data = (uint8_t *)pu8framePtr;
  
        pkt.size = u32readout;
  
        pkt.pts  = u32frameCnt;
  
        pkt.dts  = pkt.pts;
  
  
  
        av_packet_rescale_ts(&pkt, c->time_base, video_st.st->time_base);
  
        pkt.stream_index = video_st.st->index;
  
        av_interleaved_write_frame(formatCtx, &pkt);
  
        free(pu8framePtr);
  
        fclose(ph264Frame);
  
     }
  
     while(1);
  
  leave:
  
  
  
     av_write_trailer(formatCtx);
  
     av_dump_format(formatCtx, 0, filename, 1);
  
     avcodec_free_context(&video_st.enc);
  
     avio_closep(&formatCtx->pb);
  
     avformat_free_context(formatCtx);
  
  }

  It can be compiled with the following command line (after adding headers) :

  gcc file.c -o test_app -I/usr/local/include -L/usr/local/lib -lxcb-shm -lxcb -lX11 -lx264 -lm -lz -pthread -lswresample -lswscale -lavcodec -lavformat -lavdevice -lavutil

  The files that are read are valid annexB stream (valid as in it’s playable in vlc after concatenating into file) it is a Constrained Baseline 3.1 profile H264 and it comes from an IPcam’s interleaved RTCP/RTP stream (demuxed)

  The result is ... well I don’t see the picture. I get only black screen with the progress bar and timer running. I don’t know if I do something wrong with setting up the codecs and streams, or it’s just wrong timestamps.
  I know I got them wrong in some manner but I don’t understand that fully yet (how to calculate the correct presentation times), i.e. the stream and the codec both contain time_base field, and then I know that the sample rate of the video is 90kHz and the frame rate is 5 fps

  On top of it all the examples I’ve found have to some extend deprecated parts that change the flow/meaning of the application and that doesn’t help at all so thus If anyone could help I would appreciate it (I think not only me I would guess)

  Regards, Pawel

• Survey of CD Image Formats

  30 avril 2013, par Multimedia Mike — General

  In the course of exploring and analyzing the impressive library of CD images curated at the Internet Archive’s Shareware CD collection, one encounters a wealth of methods for copying a complete CD image onto other media for transport. In researching the formats, I have found that many of them are native to various binary, proprietary CD programs that operate under Windows. Since I have an interest in interpreting these image formats and I would also like to do so outside of Windows, I thought to conduct a survey to determine if enough information exists to write processing tools of my own.

  Remember from my Grand Unified Theory of Compact Disc that CDs, from a high enough level of software abstraction, are just strings of 2352-byte sectors broken up into tracks. The difference among various types of CDs comes down to the specific meaning of these 2352 bytes.

  Most imaging formats rip these strings of sectors into a giant file and then record some metadata information about the tracks and sectors.

  ISO
  This is perhaps the most common method for storing CD images. It’s generally only applicable to data CD-ROMs. File images generally end with a .iso extension. This refers to ISO-9660 which is the standard CD filesystem.

  Sometimes, disc images ripped from other types of discs (like Xbox/360 or GameCube discs) bear the extension .iso, which is a bit of a misnomer since they aren’t formatted using the ISO-9660 filesystem. But the extension sort of stuck.

  BIN / CUE
  I see the BIN & CUE file format combination quite frequently. Reportedly, a program named CDRWIN deployed this format first. This format can handle a mixed mode CD (e.g., starts with a data track and is followed by a series of audio tracks), whereas ISO can only handle the data track. The BIN file contains the raw data while the CUE file is a text file that defines how the BIN file is formatted (how many bytes in a sector, how many sectors to each individual track).

  CDI
  This originates from a program called DiscJuggler. This is extremely prevalent in the Sega Dreamcast hobbyist community for some reason. I studied the raw hex dumps of some sample CDI files but there was no obvious data (mostly 0s). There is an open source utility called cdi2iso which is able to extract an ISO image from a CDI file. The program’s source clued me in that the metadata is actually sitting at the end of the image file. This makes sense when you consider how a ripping program needs to operate– copy tracks, sector by sector, and then do something with the metadata after the fact. Options include : 1) Write metadata at the end of the file (as seen here) ; 2) write metadata into a separate file (seen in other formats on this list) ; 3) write the data at the beginning of the file which would require a full rewrite of the entire (usually large) image file (I haven’t seen this yet).

  Anyway, I believe I have enough information to write a program that can interpret a CDI file. The reason this format is favored for Dreamcast disc images is likely due to the extreme weirdness of Dreamcast discs (it’s complicated, but eventually fits into my Grand Unified Theory of CDs, if you look at it from a high level).

  MDF / MDS
  MDF and MDS pairs come from a program called Alcohol 120%. The MDF file has the data while the MDS file contains the metadata. The metadata is in an opaque binary format, though. Thankfully, the Wikipedia page links to a description of the format. That’s another image format down.

  CCD / SUB / IMG
  The CloneCD Control File is one I just ran across today thanks to a new image posted at the IA Shareware Archive (see Super Duke Volume 2). I haven’t found any definitive documentation on this, but it also doesn’t seen too complicated. The .ccd file is a text file that is pretty self-explanatory. The sample linked above, however, only has a .ccd file and a .sub file. I’m led to believe that the .sub file contains subchannel information while a .img file is supposed to contain the binary data. So this rip might be incomplete (nope, the .img file is on the page, in the sidebar ; thanks to Phil in the comments for pointing this out). The .sub file is a bit short compared to the Archive’s description of the disc’s contents (only about 4.6 MB of data) and when I briefly scrolled through, it didn’t look like it contains any real computer data. So it probably is just the disc’s subchannel data (something I glossed over in my Grand Unified Theory).

  CSO
  I have dealt with the CISO (compressed ISO) format before. It’s basically the same as a .iso file described above except that each individual 2048-byte data sector is compressed using zlib. The format boasts up to 9 compression levels, which shouldn’t be a big surprise since that correlates to zlib’s own compression tiers.

  Others
  Wikipedia has a category for optical disc image formats. Of course, there are numerous others. However, I haven’t encountered them in the wild for the purpose of broad image distribution.

• Protecting consumer privacy : How to ensure CCPA compliance

  18 août 2023, par Erin — CCPA, Privacy

  The California Consumer Privacy Act (CCPA) is a state law that enhances privacy rights and consumer protection for residents of California. 

  It grants consumers six rights, like the right to know what personal information is being collected about them by businesses and others. 

  CCPA also requires businesses to provide notice of data collection practices. Consumers can choose to opt out of the sale of their data. 

  In this article, we’ll learn more about the scope of CCPA, the penalties for non-compliance and how our web analytics tool, Matomo, can help you create a CCPA-compliant framework.

  What is the CCPA ? 

  CCPA was implemented on January 1, 2020. It ensures that businesses securely handle individuals’ personal information and respect their privacy in the digital ecosystem. 

  

  CCPA addresses the growing concerns over privacy and data protection ; 40% of US consumers share that they’re worried about digital privacy. With the increasing amount of personal information being collected and shared by businesses, there was a need to establish regulations to provide individuals with more control and transparency over their data. 

  CCPA aims to protect consumer privacy rights and promote greater accountability from businesses when handling personal information.

  Scope of CCPA 

  The scope of CCPA includes for-profit businesses that collect personal information from California residents, regardless of where you run the business from.

  It defines three thresholds that determine the inclusion criteria for businesses subject to CCPA regulations. 

  Businesses need to abide by CCPA if they meet any of the three options :

  1. Revenue threshold : Have an annual gross revenue of over $25 million.
  2. Consumer threshold : Businesses that purchase, sell or distribute the personal information of 100,000 or more consumers, households or devices.
  3. Data threshold : Businesses that earn at least half of their revenue annually from selling the personal information of California residents.

  What are the six consumer rights under the CCPA ? 

  Here’s a short description of the six consumer rights. 

  

  1. Right to know : Under this right, you can ask a business to disclose specific personal information they collect about you and the categories of sources of the information. You can also know the purpose of collection and to which third-party the business will disclose this info. This allows consumers to understand what information is being held and how it is used. You can request this info for free twice a year.
  2. Right to delete : Consumers can request the deletion of their personal information. Companies must comply with some exceptions.
  3. Right to opt-out : Consumers can deny the sale of their personal information. Companies must provide a link on their homepage for users to exercise this right. After you choose this, companies can’t sell your data unless you authorise them to do so later.
  4. Right to non-discrimination : Consumers cannot be discriminated against for exercising their CCPA rights. For instance, a company cannot charge different prices, provide a different quality of service or deny services.
  5. Right to correct : Consumers can request to correct inaccurate personal information.

  6. Right to limit use : Consumers can specify how they want the businesses to use their sensitive personal information. This includes social security numbers, financial account details, precise geolocation data or genetic data. Consumers can direct businesses to use this sensitive information only for specific purposes, such as providing the requested services.

  Penalties for CCPA non-compliance 

  52% of organisations have yet to adopt CCPA principles as of 2022. Non-compliance can attract penalties.

  

  Section 1798.155 of the CCPA states that any business that doesn’t comply with CCPA’s terms can face penalties based on the consumer’s private right to action. Consumers can directly take the company to the civil court and don’t need prosecutors’ interventions. 

  Businesses get a chance of 30 days to make amends for their actions. 

  If that’s also not possible, the business may receive a civil penalty of up to $2,500 per violation. Violations can be of any kind, even accidental. An intentional violation can attract a fine of $7,500. 

  Consumers can also initiate private lawsuits to claim damages that range from $100 to $750, or actual damages (whichever is higher), for each occurrence of their unredacted and unencrypted data being breached on a business’s server.

  CCPA vs. GDPR 

  Both CCPA and GDPR aim to enhance individuals’ control over their personal information and provide transparency about how their data is collected, used and shared. The comparison between the CCPA and GDPR is crucial in understanding the regulatory framework of data protection laws.

  Here’s how CCPA and GDPR differ :

  Scope

  • CCPA is for businesses that meet specific criteria and collect personal information from California residents. 
  • GDPR (General Data Protection Regulation) applies to businesses that process the personal data of citizens and residents of the European Union.

  Definition of personal information

  • CCPA includes personal information broadly, including identifiers such as IP addresses and households. Examples include name, email id, location and browsing history. However, it excludes HIPAA-protected medical data, clinical trial data and other personal information from government records.
  • GDPR covers any personal data relating to an identified or identifiable individual, excluding households. Examples include the phone number, email address and personal identification number. It excludes anonymous and deceased person’s data.

  

  Consent

  • Under the CCPA, consumers can opt out of the sale of their personal information.
  • GDPR states that organisations should obtain explicit consent from individuals for processing their personal data.

  Rights

  • CCPA grants the right to know what personal information is being collected and the right to request deletion of their personal information.
  • GDPR also gives individuals various rights, such as the right to access and rectify their personal data, the right to erasure (also known as the right to be forgotten) and also the right to data portability. 

  Enforcement

  • For CCPA, businesses may have to pay $7,500 for each violation. 
  • GDPR has stricter penalties for non-compliance, with fines of up to 4% of the global annual revenue of a company or €20 million, whichever is higher.

  A 5-step CCPA compliance framework 

  Here’s a simple framework you can follow to ensure compliance with CCPA. Alongside this, we’ll also share how Matomo can help. 

  Matomo is an open-source web analytics platform trusted by organisations like the United Nations, NASA and more. It provides valuable insights into website traffic, visitor behaviour and marketing effectiveness. More than 1 million websites and apps (approximately 1% of the internet !) use our solution, and it’s available in 50+ languages. Below, we’ll share how you can use Matomo to be CCPA compliant.

  1. Assess data

  First, familiarise yourself with the California Consumer Privacy Act and check your eligibility for CCPA compliance. 

  For example, as mentioned earlier, one threshold is : purchases, receives or sells the personal data of 100,000 or more individuals or households. 

  But how do you know if you have crossed 100K ? With Matomo ! 

  Go to last year’s calendar, select visitors, then go to locations and under the “Region” option, check for California. If you’ve crossed 100K visitors, you know you have to become CCPA compliant.

  

  Identify and assess the personal information you collect with Matomo.

  2. Evaluate privacy practices

  Review the current state of your privacy policies and practices. Conduct a thorough assessment of data sharing and third-party agreements. Then, update policies and procedures to align with CCPA requirements.

  For example, you can anonymise IP addresses with Matomo to ensure that user data collected for web analytics purposes cannot be used to trace back to specific individuals.

  

  If you have a consent management solution to honour user requests for data privacy, you can also integrate Matomo with it. 

  3. Communicate 

  Inform consumers about their CCPA rights and how you handle their data.

  Establish procedures for handling consumer requests and obtaining consent. For example, you can add an opt-out form on your website with Matomo. Or you can also use Matomo to disable cookies from your website.

  

  Documenting your compliance efforts, including consumer requests and how you responded to them, is a good idea. Finally, educate staff on CCPA compliance and their responsibilities to work collaboratively.

  4. Review vendor contracts

  Assessing vendor contracts allows you to determine if they include necessary data processing agreements. You can also identify if vendors are sharing personal information with third parties, which could pose a compliance risk. Verify if vendors have adequate security measures in place to protect the personal data they handle.

  That’s why you can review and update agreements to include provisions for data protection, privacy and CCPA requirements.

  Establish procedures to monitor and review vendor compliance with CCPA regularly. This may include conducting audits, requesting certifications and implementing controls to mitigate risks associated with vendors handling personal data.

  5. Engage legal counsel

  Consider consulting with legal counsel to ensure complete understanding and compliance with CCPA regulations.

  Finally, stay updated on any changes or developments related to CCPA and adjust your compliance efforts accordingly.

  Matomo and CCPA compliance 

  There’s an increasing emphasis on privacy regulations like CCPA. Matomo offers a robust solution that allows businesses to be CCPA-compliant without sacrificing the ability to track and analyse crucial data.

  You can gain in-depth insights into user behaviour and website performance — all while prioritising data protection and privacy. 

  Request a demo or sign up for a free 21-day trial to get started with our powerful CCPA-compliant web analytics platform — no credit card required. 

  Disclaimer

  We are not lawyers and don’t claim to be. The information provided here is to help give an introduction to CCPA. We encourage every business and website to take data privacy seriously and discuss these issues with your lawyer if you have any concerns.