avcc

I need some help to understand the avcC atom structure of a particular mp4 sample I am trying to analyze.

Hex dump:

00 00 00 38 61 76 63 43 01 64 00 1F FF E1 00 1C 67 64 00 1F AC D9 80 50 05 BB 01 6A 02 02 02 80 00 00 03 00 80 00 00 1E 07 8C 18 CD 01 00 05 68 E9 7B 2C 8B FD F8 F8 00 00 00 00 13 63 6F 6C 72

This is what I understand from the above:

00 00 00 38 Size of avcC atom

61 76 63 43 avcC signature

01 configurationVersion

64 AVCProfileIndication

00 profile_compatibility

1F AVCLevelIndication

FF 111111b + lengthSizeMinusOne

E1 111b + numOfSequenceParameterSets (in this case, 1 SPS)

00 1C SPS length (in this case, 28 bytes)

67 64 00 1F AC D9 80 50 05 BB 01 6A 02 02 02 80 00 00 03 00 80 00 00 1E 07 8C 18 CD SPS data (28 bytes as per above)

01 numOfPictureParameterSets (in this case, 1 PPS)

00 05 PPS length

This is where the problem begins. Based on the PPS length given by the previous bytes, the next 5 bytes should be the PPS data: 68 E9 7B 2C 8B

However according to the avcC header, the total length of the atom is 56 bytes (0x38), which means that the following 4 bytes should be included: FD F8 F8 00

But the problem is that the PPS length is given as 5 bytes (0x05). So what exactly are these final 4 bytes?

Then follows the header of the colr atom:

00 00 00 13 size of colr atom

63 6F 6C 72 colr signature

Which I have checked and is indeed 19 bytes in length (0x13).

The problem is with the avcC atom and with that particular mp4 sample I am analyzing (I've checked other samples too and they didn't have this peculiarity).

You can find the sample here.

EDIT

mp4info tool from the bento4 suite reports the following as the avcC atom's size: 8+48

And mp4dump reports:

The following code does not update initial adcValue. LEDs are working properly with different program, and they also work properly given the initial adcValue. They dont respond to potentiometer adjusting. The delay is there just to make it slower, it also doesnt work without it.

this is my first time asking something here, so I hope I am asking the following question the "correct way". If not, please let me know, and I will give more information.

I am using one Python script, to read and write 4000Hz of serial data to a CSV file.

The structure of the CSV file is as follows: (this example shows the beginning of the file)

I am trying to use libavformat to create a .mp4 video with a single h.264 video stream, but the final frame in the resulting file often has a duration of zero and is effectively dropped from the video. Strangely enough, whether the final frame is dropped or not depends on how many frames I try to add to the file. Some simple testing that I outline below makes me think that I am somehow misconfiguring either the AVFormatContext or the h.264 encoder, resulting in two edit lists that sometimes chop off the final frame. I will also post a simplified version of the code I am using, in case I'm making some obvious mistake. Any help would be greatly appreciated: I've been struggling with this issue for the past few days and have made little progress.

I can recover the dropped frame by creating a new mp4 container using ffmpeg binary with the copy codec if I use the -ignore_editlist option. Inspecting the file with a missing frame using ffprobe, mp4trackdump, or mp4file --dump, shows that the final frame is dropped if its sample time is exactly the same the end of the edit list. When I make a file that has no dropped frames, it still has two edit lists: the only difference is that the end time of the edit list is beyond all samples in files that do not have dropped frames. Though this is hardly a fair comparison, if I make a .png for each frame and then generate a .mp4 with ffmpeg using the image2 codec and similar h.264 settings, I produce a movie with all frames present, only one edit list, and similar PTS times as my mangled movies with two edit lists. In this case, the edit list always ends after the last frame/sample time.

I am using this command to determine the number of frames in the resulting stream, though I also get the same number with other utilities:

my goal is to encode the main framebuffer of my Windows machine using nvenc and stream its content to my iPad using the VideoToolbox API

The code I use to encode the h264 stream is basically a copy/paste of https://github.com/NVIDIA/video-sdk-samples/tree/master/nvEncDXGIOutputDuplicationSample the only change is that instead of writing to a file, I do send the data

For the decoding I do use https://github.com/zerdzhong/SwfitH264Demo/blob/master/SwiftH264/ViewController.swift#L71

The encoding work perfectly when I write all the contents to a file, I am able to use a h264->mp4 online converter without issue, the problem is that the decoder gives me the error kVTVideoDecoderBadDataErr in the function decompressionSessionDecodeFrameCallback

So for what I tried:

• Firsly using an h264 analyzer I found that the frame order are: 7/8/5/5/5/5/1...
• I found that nvenc does encode the frames 7/8/5/5/5/5 in only one packet
• I did try to separate this packet into multiple ones using the sequence (0x00 0x00 0x00 0x01), it gave me the frames 7/8/5 separately
• As you can see I only got one 5 frame which is around 100KB, the H264 analyzer said that there are four 5 frames (which are something like 40KB, 20KB, 30KB, 10KB)
• Using a hex file viewer I saw that the sequence separating those 5 frames were (0x00 0x00 0x01) instead, tried to also separate them but I got the exact same VideoToolbox error while decompressing

here is the code I use to separate and send the frames: The protocol is simply PACKET_SIZE->PACKET_DATA The swift code is able to read the NALU types so I am confident that this is not the issue

I'm trying to run two functions 'similtaniously' via interrupts:
1) Measure ADC via timing of timer 0 (100Hz) and show results on pin 0-5
2) Blink a led via timer 1 (10Hz) on pin 6.

Problem seems to be that the ISR of timer 1 blocks the function, so nothing else is executed. Here is the code:
(Please don't be offended by any styling mistakes, the code is under development)

I'm trying to write out an Annex B formatted h264 bitstream in an FLV container over RTMP in an Android app. After reading this SO answer and several more, I understand my Annex B bitstream first has to be converted to AVCC before being wrapped in an FLV container.

That said, the FLV container spec is a bit unclear in the wrapping of its video tags. It requires a FrameType which can be:

1. keyframe (For AVC a seekable frame)
2. interframe (For AVC a non seekable frame)
3. Disposable interframe (h263 only)
4. Generated keyframe (serverside only)
5. Video info / command frame (The message string contains a byte, 0 or 1 meaning either start of client seeking video frame sequence, or end of client seeking frame sequence)

When writing IDR or non-IDR AVC frames, i.e VCL NAL units, it's clear that options 1 and 2 should be used respectively. However, my h264 bitstream also contains non-VCL NAL units, specifically SEI payload type 47 (Display Orientation). It's not clear whether this fits when going from AVC to FLV per the spec. Do I simply consider the SEI a non seekable frame? What is a "frame" from FLV's point of view?

So I'm trying to build a personnal streaming platform and I've done my best to follow the recommandations I've found everywhere for better compatibility/quality when streaming.

So I'm systematically encoding my video to video codec h264 with mp4 container with ffmpeg using this command:

In my use-case I have to provide codec specification within the HTML5 video source's MIME type. But even a type="video/mp4; codecs=avc1" is not detailed enough for Firefox. Firefox needs the extra detail of for example type="video/mp4; codecs=avc1.64001E". My problem is that I don't know where to get this 64001E part from.

The whole identification happens on server side. So far I was using ffprobe and that's perfectly supplies me JSON format output, like so: