ATSC Data Types





Starting with an mpeg 2 transport stream, we have packets of 188 bytes, composed of 187 bytes of data, and one sync byte of 71, or 0x47. 
>>> atsc.ATSC_MPEG_PKT_LENGTH
188
>>> atsc.MPEG_SYNC_BYTE
71
The first module in our transmit chain, atsc.randomizer(), takes the 188 byte packets, varifies the presence of and strips off the sync byte, emitting 187 byte packets called 
>>> atsc.MPEG_DATA_LENGTH
187
Notice, however that 
>>> atsc.sizeof_mpeg_packet
256
Explaination from gr-atsc/src/python/qa_atsc.py: 
An MPEG transport stream packet is 188 bytes long.  Internally we use a packet
that is 256 bytes long to help with buffer alignment.

>>> atsc.sizeof_atsc_mpeg_packet_pad
68
Which is the padding needed to fill a 188 byte mpeg packet out to 256 bytes.

From the randomizer, 187 byte packets flow into the Reed Solomon encoder where 20 bytes of forward error correction parity bytes are computed and appended. This allows up to 10 byte-errors per packet, and creates another data type to deal with. 
>>> atsc.ATSC_MPEG_RS_ENCODED_LENGTH
207
>>> atsc.sizeof_atsc_mpeg_packet_rs_encoded
256
>>> atsc.sizeof_atsc_mpeg_packet_rs_encoded_pad
45
The observant will notice the above does NOT add up: 256 - 45 is 211, not 207. It turns out, from atsc_types.h, there are 2 ints (4 bytes) that carry pipeline info along with the data.

The 207 byte RS-encoded packets (211 counting pipeline info) next flow into the atsci.interleaver() and exit still as 207 byte packets. The interleaver performes the function of spreading data over time so that a single burst of noise is broken up into smaller errors the Reed Solomon coding can, hopefully, recover from.

After the interleaver, 207 data-byte packets flow into the Trellis Encoder where things get really interesting. Here each byte is broken up into 4 2-bit symbols and convolutionally encoded into 3-bit, 8-level symbols, and the mpeg packet becomes a Data Segment or 4 * 207 or 828 symbols, each having a value from 0 to 7, or eight levels. gr-atsc makes use of another form of data segment, the "soft" data segment where the symbols are represented by the floating point numbers -7 -5 -3 -1 +1 +3 +5 +7. 
>>> atsc.ATSC_DATA_SEGMENT_LENGTH
832
>>> atsc.sizeof_atsc_data_segment
1024
>>> atsc.sizeof_atsc_data_segment_pad
188
>>> atsc.sizeof_atsc_soft_data_segment
4096
>>> atsc.sizeof_atsc_soft_data_segment_pad
764
A data segment is 828 ( 207 * 4 ) plus 4 sync symbols at the beginning (see gr-atsc/src/lib/atsc_consts.h). A ds pad of 188 from 1024 is 836, or 832 plus the 4 pipeline bytes. The 'soft' data segments are 4 times bigger since floating point entities are 4 bytes.

from gr-atsc/src/python/atsc_utils.py:
    FYI, each ATSC Data Frame contains two Data Fields, each of which contains
    312 data segments.  Each transport stream packet maps to a data segment.




Now lets look at some packets and find some features. Here is couple of fake trasport stream packets dumped to a file from qa_atsc.py: 
00000000  47 6d fd 22 57 9e 6f c5  37 d9 5f 5f 76 79 c0 6e  |Gm."W.o.7.__vy.n|
00000010  be c4 3f a2 04 89 06 9e  6d 6a c2 35 6a 3d 2a af  |..?.....mj.5j=*.|
00000020  95 1c 36 a9 8f 79 51 4e  b3 9b 89 3a df d0 b8 1f  |..6..yQN...:....|
00000030  cb be 69 af 92 56 fe 8c  d1 c9 ce 19 d6 8e 4d 06  |..i..V........M.|
00000040  a8 c7 58 89 b1 22 79 5f  3b ae fa fa e9 ef 8e 07  |..X.."y_;.......|
00000050  cb 27 e8 50 ec 75 37 e5  82 cc 38 dd d6 6e ba 44  |.'.P.u7...8..n.D|
00000060  9d 89 ad 9e d8 99 1e 78  28 c7 dd a2 cf 90 b3 56  |.......x(......V|
00000070  3a d4 32 12 c6 88 39 a1  bc 89 e4 14 95 08 95 c3  |:.2...9.........|
00000080  13 a8 ad 4a 66 16 7d c2  4d a4 61 13 1d e1 66 51  |...Jf.}.M.a...fQ|
00000090  4c e7 97 39 2b f2 ac 3f  54 a6 f4 63 ec 5e b4 91  |L..9+..?T..c.^..|
000000a0  64 19 e6 05 20 8a 4b 53  60 dd ca d8 0f f1 e0 84  |d... .KS`.......|
000000b0  7a b9 c6 42 b0 a4 93 60  c3 ac 06 06 00 00 00 00  |z..B...`........|
000000c0  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|
*
00000100  47 0d e6 bf 4e 3a cc 03  6c 36 57 3e 9d 1d ce 88  |G...N:..l6W>....|
00000110  f9 96 0c aa be cc 63 21  70 b8 e1 4f 92 91 0d b2  |......c!p..O....|
00000120  da 03 e4 93 07 10 95 4a  31 cd 84 2d 1f b9 06 44  |.......J1..-...D|
00000130  6e d4 33 6a c3 c9 13 fb  df 83 cc 3a a7 7f a5 af  |n.3j.......:....|
00000140  f0 95 40 dd ba a0 d4 72  a2 72 29 ae 6e 85 46 03  |..@....r.r).n.F.|
00000150  be cd 72 db b0 f2 54 6f  83 3a 5b b8 15 99 cb f9  |..r...To.:[.....|
00000160  9a 09 63 3a 36 9a 06 00  92 60 09 02 08 86 9e b4  |..c:6....`......|
00000170  45 87 98 ac fc 96 47 07  5e dd 08 67 dc 42 45 18  |E.....G.^..g.BE.|
00000180  f4 23 d9 54 2e 44 eb 78  4e 71 bc d3 68 e4 db 49  |.#.T.D.xNq..h..I|
00000190  1d 03 66 ea 48 04 dc ff  1a 7d b0 d6 7a bc a1 3d  |..f.H....}..z..=|
000001a0  60 fc b3 f1 d6 fb c8 d1  bd f6 a5 6e 84 59 1f 90  |`..........n.Y..|
000001b0  48 31 94 32 59 2b 79 90  38 39 33 e5 00 00 00 00  |H1.2Y+y.893.....|
000001c0  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|
*
The only thing significant in the above are the 0x47 mpeg sync bytes at the beginning of each packet, and it's following byte should never have the top transport-error bit on. Other than the sync byte, it's 187 random bytes, 188 total.

Running different data (seperate run, a different fake stream) thru the randomizer stage, we get this: 
00000000  09 00 00 00 da 3f 57 b0  5f 98 f8 9a d4 54 db bb  |.....?W._....T..|
00000010  a4 1d a9 4b fb 00 ba dd  ee c6 d0 8d 76 c5 f0 0e  |...K........v...|
00000020  f2 fc d7 61 28 be 92 49  2d 3a c4 9c 65 46 ff 16  |...a(..I-:..eF..|
00000030  da 4c 77 26 3b e7 e5 7e  43 55 1e fd e8 8f 45 65  |.Lw&;..~CU....Ee|
00000040  3c 15 f0 63 c2 9a f8 54  40 67 46 fd 22 ff 39 66  |<..c...T@gF.".9f|
00000050  93 92 35 21 c4 27 a6 8b  1a 6d f8 c3 4c d1 04 13  |..5!.'...m..L...|
00000060  3f bd 0f 3e 7b e7 97 90  15 c1 2b c4 13 45 39 6a  |?..>{.....+..E9j|
00000070  9f 6d c1 5a d7 ec 5e 7f  eb 83 6e 0e 47 f6 aa 5c  |.m.Z..^...n.G..\|
00000080  25 77 04 0f 94 63 fc c0  ce 31 78 de 2b 3b 31 c0  |%w...c...1x.+;1.|
00000090  73 09 eb f3 9e ce 91 b3  c1 2b 28 dc 15 91 08 17  |s........+(.....|
000000a0  a2 c9 d1 ff dd 28 28 bb  d1 c7 6d 1c 87 44 f0 59  |.....((...m..D.Y|
000000b0  cc 2c 08 1e f7 27 47 02  88 15 70 a2 47 fa 83 00  |.,...'G...p.G...|
000000c0  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|
*
00000100  01 00 01 00 ed 5d c5 34  57 fa 54 a5 82 b7 3a e4  |.....].4W.T...:.|
00000110  a5 13 ef 42 0a 12 fe f5  12 0d 81 58 6e a3 e0 fa  |...B.......Xn...|
00000120  ad 55 c8 63 0e 1e 6a 08  0d e2 ed 9c 8e 58 8f 69  |.U.c..j......X.i|
00000130  25 9d bf 1a f3 d9 58 02  36 a2 8d 4e b8 9f 47 7a  |%.....X.6..N..Gz|
00000140  de ec da 0b 70 d7 23 ce  30 6b a9 1a 45 73 67 d0  |....p.#.0k..Esg.|
00000150  82 82 be e2 78 cc e3 55  2b 59 d9 a8 27 b2 b4 a1  |....x..U+Y..'...|
00000160  13 a6 56 24 af 19 9a 65  e1 0c f6 aa 10 ea 1d 60  |..V$...e.......`|
00000170  34 c0 dc 9c 64 cd fc d7  60 b7 ba 7a 87 bd 6c 20  |4...d...`..z..l |
00000180  65 49 7b e2 5a cf 23 75  44 0c bc 03 b5 48 2a ec  |eI{.Z.#uD....H*.|
00000190  1c fc 17 82 22 99 88 d9  60 77 5d af e4 23 a5 df  |...."...`w]..#..|
000001a0  55 d0 31 9a cc bc a8 03  b2 ea 0c aa 7e e3 16 7d  |U.1.........~..}|
000001b0  26 64 9c f6 e4 b4 e6 ac  4f 6c fb 8d 37 ef 8c 00  |&d......Ol..7...|
000001c0  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|
*
Here we see the 0x47 mpeg sync bytes are stripped off, and in their place appear 4 pipeline control bytes - actually two ints in LO HI, LO HI format. 0009 0000 in the 1st packet, and 0001 and 0001 in the next. These are flags and a segment number. The Flags, from atsc_types.h are: 
  // these three are mutually exclusive
  //     This is a regular data segment.
  static const int      fl_regular_seg          = 0x0001;
  //     This is a field sync segment, for 1st half of a field.
  static const int      fl_field_sync1          = 0x0002;
  //     This is a field sync segment, for 2nd half of a field.
  static const int      fl_field_sync2          = 0x0004;

  // This bit is on ONLY when fl_regular_seg is set AND when this is
  // the first regular data segment AFTER a field sync segment.  This
  // segment causes various processing modules to reset.
  static const int      fl_first_regular_seg    = 0x0008;

  // which field are we in?
  static const int      fl_field2               = 0x0010;       // else field 1

  // This bit is set when Reed-Solomon decoding detects an error that it
  // can't correct.  Note that other error detection (e.g. Viterbi) do not
  // set it, since Reed-Solomon will correct many of those.  This bit is
  // then copied into the final Transport Stream packet so that MPEG
  // software can see that the 188-byte data segment has been corrupted.
  static const int      fl_transport_error      = 0x0020;
so in the two above we have fl_regular_segment + fl_first_regular_seg (0x0009) in segment 0000, and just fl_regular_segment (0x0001) in segment 0001. There are 187 + 4 bytes in each packet after the randomizer strips off sync and adds flags and segnos.

After the Reed-Solomon encoder: 
00000000  09 00 00 00 ab 1a b2 6d  56 58 da 82 87 eb 47 ad  |.......mVX....G.|
00000010  e3 3c 55 4f 7f 90 9c a2  28 e6 38 85 f0 40 3e ce  |..|
00000020  de 14 c2 3a 29 b9 ee 01  a2 51 42 ba da 43 69 5f  |...:)....QB..Ci_|
00000030  20 c2 0e d3 62 e0 5e 39  3b 0b 91 c0 20 81 22 df  | ...b.^9;... .".|
00000040  49 d6 33 9d 72 3c 89 ae  1f b0 75 11 4f 1d 02 ea  |I.3.r<....u.O...|
00000050  96 d3 ea 8d a3 0c 20 41  00 7f e5 29 f3 63 bc c7  |...... A...).c..|
00000060  5e 93 ca 07 8d 2f 78 7e  70 05 e0 21 e6 ca ad 35  |^..../x~p..!...5|
00000070  05 66 7b 9d 05 ca be d5  1a 5c 67 2e 4f 63 b8 c8  |.f{......\g.Oc..|
00000080  8d d7 77 89 de d6 54 3c  ed b4 3f 5d 6d a3 97 5e  |..w...T<..?]m..^|
00000090  32 b4 e3 b9 47 bb d3 af  b3 98 6b c2 82 38 d0 b7  |2...G.....k..8..|
000000a0  ce c8 53 fe a0 b4 69 05  cc 7f 72 30 d8 0e 3b 51  |..S...i...r0..;Q|
000000b0  f6 59 e0 8d 2a 64 51 e6  d0 90 61 40 a6 81 25 c7  |.Y..*dQ...a@..%.|
000000c0  8a ed 9a 8b 88 5d 1d 2d  09 0b 96 d4 26 3b c5 5d  |.....].-....&;.]|
000000d0  a3 90 43 00 00 00 00 00  00 00 00 00 00 00 00 00  |..C.............|
000000e0  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|
*
00000100  01 00 01 00 e3 1d 65 25  5a cd de ca b6 a5 8d 66  |......e%Z......f|
00000110  ef 40 ee df 95 c2 e5 78  d0 ac 62 25 a5 07 ef aa  |.@.....x..b%....|
00000120  d0 66 18 a1 f6 a6 b8 aa  5d 10 bc 05 03 94 33 f4  |.f......].....3.|
00000130  ae 8c 56 23 ce a0 ed 85  4d 2c c9 38 73 9e 93 22  |..V#....M,.8s.."|
00000140  cd 09 e4 e7 33 83 40 cf  3b 2a 4b ae 01 82 06 01  |....3.@.;*K.....|
00000150  13 bf ae 2f df 81 d1 92  ca 1c 88 e1 a9 00 5c c8  |.../..........\.|
00000160  c6 d4 12 1c 49 97 73 27  e6 5b 95 30 22 e1 10 51  |....I.s'.[.0"..Q|
00000170  ab 08 44 9b 08 8b a3 25  51 bd 34 25 d7 a3 82 d2  |..D....%Q.4%....|
00000180  e5 a8 7f 56 16 94 c2 23  59 d8 f0 4e d3 1b 15 a4  |...V...#Y..N....|
00000190  d7 e4 76 a5 28 04 bc ba  37 a3 e3 c5 61 90 a9 83  |..v.(...7...a...|
000001a0  7f 06 70 3e db 72 8e a1  3d e3 1d 33 13 63 19 da  |..p>.r..=..3.c..|
000001b0  83 d9 4f 34 e0 43 56 74  2c 85 d1 fd da e6 a1 09  |..O4.CVt,.......|
000001c0  8a 72 01 e0 83 ff 19 4a  87 b1 04 11 0a f8 f6 89  |.r.....J........|
000001d0  b7 1e 3f 00 00 00 00 00  00 00 00 00 00 00 00 00  |..?.............|
000001e0  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|
*
pretty much the same pipeline-info wise, just 20 more bytes per packet.

The next stage, the interleaver, takes 52 packets to fully load, untill then it emits lots of zeros, so after skipping 52 packets: 
00000000  01 00 34 00 d2 29 c8 a2  af 7e 94 01 48 6c ce d6  |..4..)...~..Hl..|
00000010  26 c3 e4 35 cb 78 a9 f7  83 6e 63 5c 8b c8 67 c4  |&..5.x...nc\..g.|
00000020  90 22 41 80 72 64 91 90  fb cf ff 4a 7f b3 cb 68  |."A.rd.....J...h|
00000030  5b 65 d3 29 50 e3 bf a4  2a 98 4d 63 2f b8 19 07  |[e.)P...*.Mc/...|
00000040  2e 92 91 d4 7f 5d 76 f8  57 6b ec 47 15 10 16 01  |.....]v.Wk.G....|
00000050  1f a5 3e 30 8c 34 47 dc  1e 43 86 90 e9 6f fb 3f  |..>0.4G..C...o.?|
00000060  63 72 01 5e ea 4d b2 f9  d2 7a d3 87 64 62 f4 6b  |cr.^.M...z..db.k|
00000070  3a 75 60 7e 6b c1 0b 1d  1e f0 c0 e0 0d 3e d4 85  |:u`~k........>..|
00000080  af 51 68 f4 87 f1 de ca  67 d2 db 48 9d 8a 15 19  |.Qh.....g..H....|
00000090  0e 77 9c 48 ba ac a9 90  32 b1 93 c0 d4 e3 57 3a  |.w.H....2.....W:|
000000a0  93 dc 28 66 9a 13 2b 59  0c 4c 81 89 a2 bf ca 3f  |..(f..+Y.L.....?|
000000b0  86 47 f5 2a fc af 1f 40  39 c8 c8 e4 79 fb 2f 99  |.G.*...@9...y./.|
000000c0  75 14 d4 c8 c7 70 06 33  2c ab 7a ab 92 2b 77 d3  |u....p.3,.z..+w.|
000000d0  ce 5a 1a 00 00 00 00 00  00 00 00 00 00 00 00 00  |.Z..............|
000000e0  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|
*
00000100  01 00 35 00 87 d8 83 87  6a bf 5c eb 62 89 db 02  |..5.....j.\.b...|
00000110  6c 39 eb 69 64 c9 76 7d  39 1f 5e 4a ef bb bb 78  |l9.id.v}9.^J...x|
00000120  88 67 51 8b f4 c6 5f 98  35 93 01 f9 ca 0c 13 9b  |.gQ..._.5.......|
00000130  12 70 6b b8 41 5d b3 f7  d2 58 f3 8d 59 5d 7b 10  |.pk.A]...X..Y]{.|
00000140  fa 04 2d a4 cc 34 c6 b8  13 d1 1d 4c ef d3 cb 14  |..-..4.....L....|
00000150  9a a5 80 a0 82 40 60 fb  c9 01 1e bc 03 b7 26 9b  |.....@`.......&.|
00000160  b8 69 17 f9 35 e4 06 9e  60 95 2e 81 45 f0 00 54  |.i..5...`...E..T|
00000170  a7 0d 3f 8a da 5a 5a 24  4a 63 cf d0 d7 09 86 47  |..?..ZZ$Jc.....G|
00000180  4b 26 f3 95 e0 51 76 7f  94 2c 27 76 0a 45 0c 7d  |K&...Qv..,'v.E.}|
00000190  70 5d 36 37 d7 b7 36 ec  26 14 54 91 35 3b c5 9c  |p]67..6.&.T.5;..|
000001a0  a8 cf 2e 6c 32 2f 76 56  7b 82 b7 e0 f2 d7 e1 29  |...l2/vV{......)|
000001b0  88 81 d0 32 84 80 cb 2d  35 9a 9e 14 62 3d 47 64  |...2...-5...b=Gd|
000001c0  3d 57 0d 40 84 be c9 26  6b cb 9a 6a 8b b8 fa 8f  |=W.@...&k..j....|
000001d0  61 84 d5 00 00 00 00 00  00 00 00 00 00 00 00 00  |a...............|
000001e0  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|
*
Same fl_regular_segment flag and the segnos start at 0x34 (52), then 207 random bytes.

Finally the Trellis encoder which takes the 207 bytes and emits 4 * 207 3-bit symbols, here one symbol per byte ranging from 0-7 
00000000  01 00 34 00 06 01 01 06  04 02 06 04 04 02 04 00  |..4.............|
00000010  02 02 06 04 06 03 07 06  00 01 06 06 07 03 07 02  |................|
00000020  03 03 01 05 04 00 05 07  07 01 05 05 07 00 07 06  |................|
00000030  02 05 06 07 00 05 03 00  04 05 00 06 05 06 02 02  |................|
00000040  05 07 00 03 05 02 05 07  06 06 07 00 02 06 05 01  |................|
00000050  04 00 00 05 02 03 05 02  00 04 04 01 03 00 07 05  |................|
00000060  07 01 01 03 06 04 05 01  07 04 07 03 01 03 01 07  |................|
00000070  05 04 02 07 06 04 00 06  03 06 03 02 00 00 00 06  |................|
00000080  06 04 05 06 06 02 02 04  01 00 00 00 07 04 00 07  |................|
  ...skipping...
000002d0  05 01 00 00 02 02 03 03  05 00 01 04 01 03 05 07  |................|
000002e0  05 02 07 00 02 06 03 00  01 02 06 03 02 07 02 07  |................|
000002f0  02 05 02 00 05 04 04 04  02 01 00 07 05 00 02 02  |................|
00000300  05 02 02 01 05 05 04 06  02 05 05 05 05 07 03 02  |................|
00000310  00 07 04 02 00 04 02 02  03 03 01 02 03 04 02 07  |................|
00000320  02 07 06 06 04 06 01 01  01 05 07 01 07 03 07 05  |................|
00000330  07 02 03 02 03 02 07 03  05 06 03 06 01 01 02 04  |................|
00000340  06 04 00 04 00 00 00 00  00 00 00 00 00 00 00 00  |................|
00000350  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|
*
00000400  01 00 35 00 06 01 01 06  01 04 06 00 02 02 03 05  |..5.............|
00000410  03 00 04 04 07 05 05 06  07 01 07 04 00 04 07 00  |................|
00000420  02 00 02 03 01 06 04 05  05 06 03 04 00 07 02 01  |................|
00000430  05 04 05 00 06 01 00 04  06 07 07 05 07 04 06 05  |................|
00000440  00 06 03 00 05 00 01 05  02 06 06 04 02 04 07 00  |................|
00000450  02 05 01 01 02 03 05 07  07 00 04 06 04 02 01 01  |................|
again our flags and segno starting at 0x34, then 4 sync symbols of 6-1-1-6 ( this will later become the +5 -5 -5 +5 you see in Fig. 6 of "Fundaments of 8VSB" and elsewhere) then the 828 (207 * 4) symbols.

Just for giggles and grins, lets look for other flags. There are 312 segments per field, so skipping ahead in rs encoded mpeg packets to segment 0x0138: 
00010300  01 00 37 01 c5 e4 a3 8b  67 02 50 0e b9 05 e5 c0  |..7.....g.P.....|
00010310  cc 4c aa 7d 24 8c ec 64  61 26 d8 d1 86 6e 33 a8  |.L.}$..da&...n3.|
00010320  80 0b cd c8 5c 62 dc c8  7c 09 4a 90 13 42 f8 6a  |....\b..|.J..B.j|
00010330  dc 56 82 21 92 60 78 2c  0a 7f 85 5d 6a 09 82 80  |.V.!.`x,...]j...|
   ....skipping....
000103c0  1c 18 4c 37 b4 ed 9f 51  f1 fe b6 78 aa e1 86 e4  |..L7...Q...x....|
000103d0  f4 df c7 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|
000103e0  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|
*
00010400  19 00 00 00 fb bb a8 2f  b3 90 02 fb 55 30 ea 32  |......./....U0.2|
00010410  6a 9b d5 2c 0b 6c 95 79  47 a9 ac 7c ea 2f 72 17  |j..,.l.yG..|./r.|
00010420  92 48 6c b6 80 0d ff 48  07 4f 4b 3d 76 f6 0f 5b  |.Hl....H.OK=v..[|
    ...skipping...
000104c0  c3 be 24 04 05 f1 fd 24  e3 ea 0a 46 67 a5 75 b4  |..$....$...Fg.u.|
000104d0  d5 b4 db 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|
000104e0  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|
*
00010500  11 00 01 00 44 e9 c5 f3  41 da 61 ab 56 50 ec ab  |....D...A.a.VP..|
00010510  9e 95 43 21 8f 2e 18 37  cc 87 7d ea d5 17 3e 4a  |..C!...7..}...>J|
00010520  02 18 b4 6a 5b 3f 66 4c  3f 52 58 b5 a0 a4 f5 e8  |...j[?fL?RX.....|
we find a fl_regular_seg flag on segment 0x0137, then segno rolls over back to 0x000, with 0x0019 flags, or fl_field2 + fl_regular_segment + fl_first_regular_segment. After that all segment flags are 0x0011, in field 2, regular segment. Since it takes 2 fields to make a frame, lets skip ahead another 312 segments to next segno 0x0138: 
00023ad0  d2 e0 bb 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|
00023ae0  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|
*
00023b00  11 00 37 01 1a d5 b3 a9  ac 34 e7 34 f6 aa 69 eb  |..7......4.4..i.|
00023b10  59 14 21 ca cc 36 15 e5  aa 20 fc 8a 85 8f 11 8d  |Y.!..6... ......|
     ...skipping...
00023bc0  c0 a4 e9 c5 83 97 32 bf  06 01 cf 3b 1f 08 4d 3f  |......2....;..M?|
00023bd0  d3 15 0c 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|
00023be0  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|
*
00023c00  09 00 00 00 cd d4 88 5d  b9 d1 52 f4 46 72 80 58  |.......]..R.Fr.X|
00023c10  6b e7 ce 36 5f 3d a7 2f  05 fd e7 29 b6 50 01 4b  |k..6_=./...).P.K|
     ...skiping...
00023c20  97 40 19 e4 aa 7e a8 2f  54 60 76 69 0b 9a 5f 34  |.@...~./T`vi.._4|
00023c30  92 7b b5 20 a9 16 7c 0d  18 d5 6d b2 d2 05 a4 98  |.{. ..|...m.....|
00023ce0  00 00 00 00 00 00 00 00  00 00 00 00 00 00 00 00  |................|
*
00023d00  01 00 01 00 cf fd 23 0e  1e 72 e9 87 e1 ae 97 b6  |......#..r......|
00023d10  df 2e 5b f8 04 29 27 90  e8 62 80 ae df e2 b1 2b  |..[..)'..b.....+|
00023d20  e5 7f dd 90 3f 9e 54 b7  4b 31 6a 03 36 c4 91 57  |....?.T.K1j.6..W|
there's 0x0011 flags on segment 0x0137, 0x0009 at next field 0x0000, then back to 0x0001 on segment 0x0001.

Where are flags fl_field_sync1 and fl_field_sync2 used? Perhaps after the field sync multiplexor.

Moving on, the next stage is the Field Sync Multiplexor, which adds a segment sync symbol pattern of 06 01 01 06 (+5 -5 -5 +5) to the beginning of each segement, and also every 312 segments adds a complete data segment with special pseudo-noise and mode bites. The pseudo-noise bits of a segment are made of predefined pn511 and pn63 symbol blocks. Doing a hexdump and skipping ahead 312 1024-byte segments (312 * 1024 = 4E400) 
0004e000  00 00 00 00 06 01 01 06  01 01 01 01 01 01 01 06  |................|
where there's no pipeline flags set, the 6-1-1-6 seg sync, then follows 511 symbols that match those found in atsci_pnXXX.cc. From 4e207 to 4e245 inclusive is a pn63 block, from 4e246 to 4e284 another pn63 block, and from 4e285 4e2c3 a pn63 block. The 2nd pn63 block is invetered on FIELD2's. Then comes 24 symbols of VSB mode info, here 8VSB, from 4e2c4 to 4e2db. Then 92 reserved symbols from 4e2dc to 4e337, made up of more pn63 symbols. The 12 symbols from 4e338 to 4e343 are the last 12 symbols of the previous segment. After that atsc_field_sync_mux.cc spits out random data outside of symbol limits of 0 to 6.