[第4波]幽魂系列汉化的有关资料

shane007

4 P2 e4 l% U7 P, p( t
4 q& p# `. K- i. J最近找到了一些和幽魂系列Phantasmagoria 有关的资料，
. p/ {; j* L# y1 Q0 Q, B也许将来可以用于汉化。

' d4 _7 N8 l1 b, k! c和日文版有关的信息
http://anthonylarme.tripod.com/phantas/phintgtp.html

相关工具
http://anthonylarme.tripod.com/phantas/phcheats.html
9 G* A) E0 I: t3 Y. R% M2 |-----------------------------------------------------------------------
2012/1/2  更新
8 q: v' k) E$ }$ i; P' \/ t3 v关于幽魂游戏的字幕
Phantasmagoria subtitles function discovered - ScummVM :: Forums

5 K5 D0 t2 K( s; @) Z. XVMD文件
; T% ?. H4 e8 A! R4 qSubtitling Sierra VMD Files | Breaking Eggs And Making Omelettes (multimedia.cx)VMD - MultimediaWiki
5 k1 X. r" b' r4 K! z( `7 u
字幕
' S( C4 ~' k7 f: D/ ZSubtitling Sierra RBT Files | Breaking Eggs And Making Omelettes (multimedia.cx)

FFmpeg/subtitle-rbt.c at feature/VMD_encoder · multimediamike/FFmpeg · GitHub

1. /*
   5 B1 I5 i1 ~( m! l& z
2. * subtitle-rbt.c
   
3. *  by Mike Melanson (mike -at- multimedia.cx)
   - w# \1 P6 b( u
4. *
   
5. * build with this command:
   . |  G9 b; S  P' ^& U) N9 p. `
6. *   gcc -g -Wall subtitle-rbt.c -o subtitle-rbt -lm -lass
   ; B' K2 Q" q1 j: H
7. */
   - g) u( f+ q" T( Q5 E
8. 
   
9. #include <inttypes.h>
   / ~; C0 W+ `* n8 y; E
10. #include <math.h>
    
11. #include <stdio.h>
    
12. #include <stdlib.h>
    $ v6 W0 Z0 {8 @! f- P1 z' a
13. #include <string.h>
    9 w/ D3 M5 x( o3 l1 p9 U- b
14. 
    & V" V( ?6 S: @
15. #include <ass/ass.h>
    0 f. l" P& d# `! ~
16. 
    ; s  @3 W1 B) L( Q- v& s
17. #define LE_16(x) ((((uint8_t*)(x))[1] <<  8) | ((uint8_t*)(x))[0])
    
18. 
    5 u/ j; z0 P) K8 F4 _) K
19. #define LE_32(x) (((uint32_t)(((uint8_t*)(x))[3]) << 24) |  \
    
20.                              (((uint8_t*)(x))[2]  << 16) |  \
    
21.                              (((uint8_t*)(x))[1]  <<  8) |  \
    
22.                               ((uint8_t*)(x))[0])
    
23. 
    " k# {2 n0 T: [
24. /*********************************************************************/
    
25. 
    * l3 Z4 O  G9 z/ Y! |- f
26. /* Bit reader stuff */
    " R; n* O) a& Z% {
27. 
    ; }5 d, V/ n+ `& r0 J, U
28. typedef struct
    
29. {
    % [5 y* X; j3 G* c3 G- n
30.     uint8_t *bytestream;
    6 g+ _! t, q% J; X: N$ G6 z( X/ n
31.     int bytestream_size;
    ) X9 S% z1 M1 I+ {. U  ?# O4 k! }
32.     int index;
    
33.     uint32_t bits;
    
34.     int bits_in_buffer;
    
35. } get_bits_context;
    
36. 
    " T: ]# x+ W& `$ H4 J' {7 o, u
37. static inline void reload_bits(get_bits_context *gb)
    9 o0 u8 g& \: S% y+ p
38. {
    5 @# F+ V, e0 B' V' t
39.     while (gb->bits_in_buffer <= 24)
    
40.     {
    % [5 A; }* b& \1 n
41.         if (gb->index < gb->bytestream_size)
    
42.             gb->bits |= (gb->bytestream[gb->index++] << (24 - gb->bits_in_buffer));
    
43.         gb->bits_in_buffer += 8;
    8 V8 I5 D; C* U# t. k
44.     }
    " w4 n4 B$ W! N- M
45. }
    
46. 
    8 C+ `% `. B( C6 j/ J$ T
47. static void init_get_bits(get_bits_context *gb, uint8_t *bytestream, int size)
    ) v8 C- ~' W8 O8 [% y
48. {
    
49.     gb->bytestream = malloc(size);
    
50.     memcpy(gb->bytestream, bytestream, size);
    , K! J; L7 ]7 A$ l8 _+ ~
51.     gb->bytestream_size = size;
    
52.     gb->index = 0;
    
53.     gb->bits = 0;
    ! v+ ]* |/ u* K; b
54.     gb->bits_in_buffer = 0;
    ) D+ }- Q8 j: O: Z! A
55. 
    3 h# e$ r7 ~2 S! K. ~3 t5 t
56.     reload_bits(gb);
    
57. }
    * p$ D  Y4 h4 [4 k$ |8 U" n
58. 
    
59. /* read bits without consuming them from the stream */
    9 T! X' g0 e7 z( D1 F) C
60. static int view_bits(get_bits_context *gb, int count)
    
61. {
    8 l. o/ G5 c! f, |1 a* Z; p$ ?
62.     if (count >= 24)
    & `+ q: {! |. {# |
63.         return -1;
    
64.     if (gb->bits_in_buffer < count)
    ; P0 X$ W: q6 Z* T
65.         reload_bits(gb);
    ) c3 m( {" n8 q2 W) T# P
66.     return (gb->bits >> (32 - count));
    
67. }
    + T$ B0 R& v" R2 e+ V
68. 
    4 p; P; o" a# b+ x2 r$ d
69. /* read and consume bits from the stream */
    8 g: N4 V/ G" r6 t
70. static int read_bits(get_bits_context *gb, int count)
    
71. {
    
72.     int value;
    
73. 
    ! c1 N. R# Y( p6 v+ {1 N% t
74.     if (count >= 24)
    
75.         return -1;
    
76. 
    
77.     value = view_bits(gb, count);
    
78.     gb->bits <<= count;
    7 \2 i0 u# q$ `- h8 @. C
79.     gb->bits_in_buffer -= count;
    
80. 
    ! o3 v! [* I, l; n
81.     return value;
    & H* |/ X) j! q  Y
82. }
    7 U0 c7 b& n0 C; n" G& K+ j5 @& s
83. 
    ' ?& Z0 ~8 N: R4 q  j/ G
84. static void delete_get_bits(get_bits_context *gb)
    1 S+ i8 a/ D6 r1 ~
85. {
    
86.     free(gb->bytestream);
    % `9 ]! {$ f& t/ L4 t* q: N9 h' ~
87. }
    
88. 
    . ~5 R) U! g" i1 q: F$ j$ F
89. /*********************************************************************/
    
90. 
    / c' C" c+ G- h$ t
91. /* Bit writer stuff */
    
92. 
    - _1 c' R% }, G2 \1 k! e+ R7 `& Q
93. #define MAX_PUT_BITS_BYTES 63000
    
94. typedef struct
    
95. {
    
96.     uint8_t bytes[MAX_PUT_BITS_BYTES];
    
97.     int byte_index;
    9 s* O4 U' F' f6 U+ H* I; o- c
98.     uint32_t bit_buffer;
    
99.     int bits_buffered;
    
100. } put_bits_context;
     
101. 
     
102. static void reset_put_bits(put_bits_context *pb)
     
103. {
     
104.     memset(pb->bytes, 0, MAX_PUT_BITS_BYTES);
     
105.     pb->byte_index = 0;
     
106.     pb->bit_buffer = 0;
     5 m: p, m6 Z8 A) x, @' U
107.     pb->bits_buffered = 0;
     
108. }
     4 L: s5 D& G' d8 z- i
109. 
     
110. static put_bits_context *init_put_bits()
     - E9 z( I- r1 q( R; y  K2 N5 X
111. {
     . |( F4 t: w! B5 j9 c
112.     put_bits_context *pb;
     
113. 
     6 E' ^* ^1 {9 L* q
114.     pb = malloc(sizeof(put_bits_context));
       M* }$ C2 i; g5 B+ F& I0 h
115.     reset_put_bits(pb);
     ; I2 W; e8 ]" X+ ^
116. 
     
117.     return pb;
     
118. }
     " f5 ^. z1 n8 `+ K: I" V( \
119. 
     , d8 I, g4 p& {3 `5 ~
120. static void put_bits(put_bits_context *pb, int bits, int count)
     " s$ D% D# K1 ?
121. {
     + l0 k9 i* ~/ l* {# {
122.     pb->bit_buffer <<= count;
     
123.     pb->bit_buffer |= (bits & (~(0xFFFFFFFF << count)));
     
124.     pb->bits_buffered += count;
     
125. 
     
126.     while (pb->bits_buffered >= 8)
     & s! @7 F. W$ X0 d6 t  t
127.     {
     
128.         pb->bytes[pb->byte_index++] = pb->bit_buffer >> (pb->bits_buffered - 8);
     8 P* ?- T0 i8 s. X4 [
129.         pb->bit_buffer &= (~(0xFFFFFFFF << (pb->bits_buffered - 8)));
     
130.         pb->bits_buffered -= 8;
       d' S2 s0 o- A3 V
131.     }
     
132. 
     
133.     if (pb->byte_index >= MAX_PUT_BITS_BYTES)
     & `% K) s$ C  j* Q' c% @
134.     {
     ; h+ ?. @7 s+ o8 K! T5 ~1 A
135.         printf("HELP! Bit overflow\n");
     : x' b7 g2 C. K# @
136.         exit(1);
     + G- q0 b8 C3 |6 H7 k% m& d. B
137.     }
     
138. }
     2 a5 t. ]  G9 O) q2 J
139. 
     
140. static void put_bits_flush(put_bits_context *pb)
     
141. {
     7 z3 P- I- }: g- |
142.     if (pb->bits_buffered > 0)
     
143.         pb->bytes[pb->byte_index++] = pb->bit_buffer << (8 - pb->bits_buffered);
     
144. }
     
145. 
     
146. static void delete_put_bits(put_bits_context *pb)
     
147. {
     . a$ t( T3 r, C' G& f( W: q* |
148.     free(pb->bytes);
     . x# b7 T3 ], _5 _
149. }
     & |4 ]  q7 m9 y# p* f5 b
150. 
     , k/ c2 ?' j$ T
151. /*********************************************************************/
     ' p1 a9 ^+ n0 m
152. 
     ; q" b+ {: T9 q
153. /* RBT functions */
     
154. 
     
155. #define PALETTE_COUNT 256
     1 i, T& C5 M1 {2 T3 J, P
156. #define RBT_HEADER_SIZE 60
     * C, m; s' o/ }: A6 J  [+ D
157. #define UNKNOWN_TABLE_SIZE (1024+512)
     
158. #define SUBTITLE_THRESHOLD 0x70
     
159. #define MILLISECONDS_PER_FRAME 100
     1 c1 m9 S3 g6 w2 a! C  M
160. 
     1 K1 U& e; z% S0 l3 c, E' [( x( i
161. /* VLC table */
     ) Z1 P# N9 q3 x) U/ Q6 l, |' ^6 x
162. #define VLC_SIZE 4
     
163. static struct
     
164. {
     
165.     int count;
     
166.     int value;
     7 H6 i& ]0 Y2 Q4 T# K# M
167. } lzs_vlc_table[] =
     4 B9 C8 o9 ~# k$ e* X# C
168. {
     * Q1 J2 W1 O& V* n
169.     /* code length = 2 bits; value = 2 */
     
170.     /* 0000 */ { 2, 2 },
     
171.     /* 0001 */ { 2, 2 },
     ( t" u) O; s" _( X* T; n: l
172.     /* 0010 */ { 2, 2 },
     3 O4 I7 l0 ?! r9 w8 x9 `' h
173.     /* 0011 */ { 2, 2 },
     4 ?* O3 w$ ^5 l8 j
174. 
     - R3 z5 H' y" B& u) r
175.     /* code length = 2 bits; value = 3 */
     : q* r1 ^; L  c
176.     /* 0100 */ { 2, 3 },
     
177.     /* 0101 */ { 2, 3 },
     
178.     /* 0110 */ { 2, 3 },
     ; p: q5 c, `! r
179.     /* 0111 */ { 2, 3 },
     1 H8 A% }# ~( T* ]% G
180. 
     5 E4 w6 h2 Z! g( j: W+ ~0 i
181.     /* code length = 2 bits; value = 4 */
     3 l' L  T+ l; L
182.     /* 1000 */ { 2, 4 },
     
183.     /* 1001 */ { 2, 4 },
     2 F# {" M$ O. a0 K( C# n1 U
184.     /* 1010 */ { 2, 4 },
       _) [4 ]" n, t
185.     /* 1011 */ { 2, 4 },
     
186. 
     / S+ [7 H0 f# F7 o, A3 Z
187.     /* code length = 4 bits; value = 5 */
       h7 M" m& j! n$ Q5 B5 V9 n
188.     /* 1100 */ { 4, 5 },
     
189. 
     
190.     /* code length = 4 bits; value = 6 */
     
191.     /* 1101 */ { 4, 6 },
     + ^! N: g( B6 F0 ]" |
192. 
     " y5 r# Y# n2 [$ j' _, Y
193.     /* code length = 4 bits; value = 7 */
     
194.     /* 1110 */ { 4, 7 },
     
195. 
     6 H3 H# O9 X+ g% S2 H
196.     /* special case */
     9 i" G' H. F9 W" Z
197.     /* 1111 */ { 4, 8 }
     
198. };
     
199. 
     $ ?; {" b7 E1 b6 x1 u
200. typedef struct
     1 G: e9 I$ C8 n, f- ^
201. {
     # _/ j/ s3 ?( H4 Q& K+ q6 f. Q
202.     int version;
     
203.     int width;
     8 h5 y/ s2 Y. g
204.     int height;
     8 \+ h) d: U8 Z4 S
205.     int frame_count;
     ) [9 ]! Q5 y4 l. s1 J% y  m
206.     int audio_chunk_size;
     
207.     uint8_t palette[PALETTE_COUNT * 3];
       A0 I9 I0 V& c% o* T& u  K' F
208.     off_t video_frame_size_table_offset;
     
209.     uint8_t *video_frame_size_table;
     
210.     off_t frame_size_table_offset;
     , J' @8 S! \( s- W  e
211.     uint8_t *frame_size_table;
     8 [, U$ f4 F" |8 R* [
212.     uint8_t *frame_load_buffer;
     
213.     int dump_frames;
     $ i6 p# B/ ^; U% [& h$ F* `& Q
214. 
     7 c5 P5 ~6 V" X' e; y
215.     /* subtitle library */
     
216.     ASS_Library *ass_lib;
     
217.     ASS_Renderer *ass_renderer;
     ' D# c/ `. q! Q# Q! h
218.     ASS_Track *ass_track;
     
219. } rbt_dec_context;
     
220. 
     
221. static void dump_pnm_file(char *filename, rbt_dec_context *rbt,
     
222.     uint8_t *image, int width, int height)
     3 Y# ^) K/ Y4 B  y! |8 b  p
223. {
     " r# ^1 Q( I$ k% N6 w5 p# Y- j) l
224.     FILE *outfile;
     
225.     uint8_t bytes[3];
     ( s- i5 h$ ?- x0 x& g) d
226.     int p;
     , _+ r9 Q$ o1 |8 q' N
227.     uint8_t pixel;
     % c& d( P3 e6 v+ g
228. 
     ) P0 t( S$ N  e6 R9 w
229.     outfile = fopen(filename, "wb");
     / v) u, }: m, H4 \2 `) D
230.     fprintf(outfile, "P6\n%d %d\n255\n", width, height);
     4 I& c: L0 T9 R5 ^
231.     for (p = 0; p < width * height; p++)
     
232.     {
     1 u, h+ h6 z5 l% s; k7 X# X# H7 e; C
233.         pixel = image[p];
     6 A: s/ b0 j3 B4 n' ?
234.         bytes[0] = rbt->palette[pixel*3+0];
     : F7 {7 I- V  F
235.         bytes[1] = rbt->palette[pixel*3+1];
     
236.         bytes[2] = rbt->palette[pixel*3+2];
     3 @7 g8 k0 L) h# \( ]5 T
237.         fwrite(bytes, 3, 1, outfile);
     
238.     }
     
239.     fclose(outfile);
     8 b  C. `; f3 W$ A0 h
240. }
     ! t0 [" n( q! B
241. 
     1 T, {( @$ k- q& T0 L+ r) Z6 }
242. static int load_and_copy_rbt_header(rbt_dec_context *rbt, FILE *inrbt_file, FILE *outrbt_file)
     4 F1 z& L1 y: G9 t* X0 K
243. {
     6 a$ w: D1 }, k3 [- m% l% N
244.     uint8_t header[RBT_HEADER_SIZE];
     , D# i# q3 w; r" V: }
245.     int palette_data_size;
     , ?' r. u" o1 i* X; I7 t  Q2 F
246.     uint8_t *palette_chunk;
     % \, \- Z4 t5 L1 D
247.     int unknown_chunk_size;
     5 P& O$ q0 n) L. e
248.     uint8_t *unknown_chunk;
     6 B' T: H9 Q! a% r& r+ X
249.     uint8_t unknown_table[UNKNOWN_TABLE_SIZE];
     : w: l* n: X; [
250.     off_t padding_size;
     + R1 i0 z* Q/ _5 j9 q4 [4 m
251.     uint8_t *padding;
     
252.     int i;
     ' A. @$ H3 ]' }
253.     int frame_size;
     
254.     int max_frame_size;
     6 u$ A. X) R  r2 ]9 _/ h1 x
255.     int first_palette_index;
     5 s* l4 D  W5 g8 B$ b( ~
256.     int palette_count;
     6 w) ?5 o7 X: M4 d
257.     int palette_type;
     
258.     int palette_index;
     
259. 
     
260.     fseek(inrbt_file, 0, SEEK_SET);
     
261.     fseek(outrbt_file, 0, SEEK_SET);
     5 l! a% v) K  l' |8 X0 M
262. 
     
263.     /* load the header */
     
264.     if (fread(header, RBT_HEADER_SIZE, 1, inrbt_file) != 1)
     
265.     {
     1 J7 L$ V0 R& N1 g9 y. y' e
266.         printf("problem reading initial RBT header\n");
     
267.         return 0;
     ' j. m1 B% Y% J* R3 i5 U0 E8 a% \( m& L
268.     }
     
269. 
     
270.     /* copy header to the output */
     % L; h9 A/ @* S% i9 K) C' i8 Q. K
271.     if (fwrite(header, RBT_HEADER_SIZE, 1, outrbt_file) != 1)
     
272.     {
     
273.         printf("problem writing initial RBT header\n");
     : j; `; }0 f1 ]7 X9 ~: f
274.         return 0;
     
275.     }
     
276. 
     ' D1 O1 X! N$ G* h. r( v; w5 t+ D/ h" K
277.     rbt->version = LE_16(&header[6]);
     
278.     rbt->audio_chunk_size = LE_16(&header[8]);
     
279.     rbt->frame_count = LE_16(&header[14]);
     
280. 
     ' }' H3 O" M* L# r- s6 h
281.     /* transfer the unknown data, if it's there */
     
282.     unknown_chunk_size = LE_16(&header[18]);
     * k2 o! B( W% E5 t/ w
283.     if (unknown_chunk_size > 0)
     
284.     {
     
285.         unknown_chunk = malloc(unknown_chunk_size);
     ) X( s/ B0 @. C7 \+ Y
286.         if (fread(unknown_chunk, unknown_chunk_size, 1, inrbt_file) != 1)
     
287.         {
     ) S4 {. ]* B' c* L
288.             printf("problem reading unknown data\n");
     4 N% ~7 \. i/ [5 H+ T% }8 F
289.             return 0;
     
290.         }
     ; B! b: M' B, O% z
291.         if (fwrite(unknown_chunk, unknown_chunk_size, 1, outrbt_file) != 1)
     0 M8 G* k( E# [' _/ m" M
292.         {
     
293.             printf("problem writing unknown data\n");
     2 E' i1 g$ d* c! E0 g
294.             return 0;
     / P# O: ?5 k3 T6 j5 ?6 C# E& g$ s4 ^
295.         }
     
296.         free(unknown_chunk);
     : C- N8 g. n6 m, }% S& Y$ E# x% x
297.     }
     
298. 
     
299.     /* transfer the palette chunk */
     8 d; @# t5 v; e1 |
300.     palette_data_size = LE_16(&header[16]);
     2 W: W4 F5 w: m
301.     palette_chunk = malloc(palette_data_size);
     , V4 C8 U8 s( t  }* T! C3 V7 H3 ~
302.     if (fread(palette_chunk, palette_data_size, 1, inrbt_file) != 1)
     
303.     {
     
304.         printf("problem reading palette\n");
       m8 ^1 l; T- V, ^
305.         return 0;
     9 f7 ~5 j& `$ M
306.     }
     . S( P, ?$ P; W1 _2 I- M% M3 v: O3 Y2 v
307.     if (fwrite(palette_chunk, palette_data_size, 1, outrbt_file) != 1)
     / R. g; [3 _7 P5 p- d9 G- j
308.     {
     . a: E/ \2 d5 }* S8 U$ d$ M" x- h
309.         printf("problem writing palette\n");
     ; k: @# i! G# l9 S  R
310.         return 0;
     : Q0 M; j% _5 _3 c% t
311.     }
     
312.     /* load the palette into the internal context */
     
313.     memset(rbt->palette, 0, PALETTE_COUNT * 3);
     1 R- n" g  d6 F# G8 i
314.     first_palette_index = palette_chunk[25];
     
315.     palette_count = LE_16(&palette_chunk[29]);
     : h8 @" U1 q; \. l7 O
316.     palette_type = palette_chunk[32];
     3 i9 H6 {( M# c( Q
317.     palette_index = (palette_type == 0) ? 38 : 37;
     
318.     for (i = first_palette_index; i < first_palette_index + palette_count; i++)
     8 {3 O3 J# c  e  n
319.     {
     8 {! w# |' Y9 k. f9 `. @
320.         rbt->palette[i*3+0] = palette_chunk[palette_index++];
     * F( m6 z- E& ]
321.         rbt->palette[i*3+1] = palette_chunk[palette_index++];
     
322.         rbt->palette[i*3+2] = palette_chunk[palette_index++];
     + B0 k$ u/ P  ]  P
323.     }
     
324.     free(palette_chunk);
     5 i# A3 O# q$ r
325. 
     : V$ N4 J7 U: ^; n
326.     /* copy the video frame size table (2 bytes per frame), as a placeholder */
     
327.     rbt->video_frame_size_table = malloc(rbt->frame_count * sizeof(uint16_t));
     
328.     if (fread(rbt->video_frame_size_table, rbt->frame_count * sizeof(uint16_t), 1, inrbt_file) != 1)
     
329.     {
     
330.         printf("problem reading frame table\n");
     4 L& ]+ ?+ A0 M0 N# X+ z# k
331.         return 0;
     
332.     }
     # k3 X2 }# D5 ~. Z1 c
333.     rbt->video_frame_size_table_offset = ftell(outrbt_file);
     
334.     if (fwrite(rbt->video_frame_size_table, rbt->frame_count * sizeof(uint16_t), 1, outrbt_file) != 1)
     $ E2 V) H7 x! }
335.     {
     + f) Z8 _# h* B- f0 v  b8 ]
336.         printf("problem writing frame table\n");
     % u7 u, W+ U4 b4 \9 c
337.         return 0;
     
338.     }
     
339. 
       Q8 @  a, l" T  g5 R- {
340.     /* copy the frame size table (2 bytes per frame), as a placeholder */
     
341.     rbt->frame_size_table = malloc(rbt->frame_count * sizeof(uint16_t));
     1 L/ h) o! f, g0 m* \, x' ~
342.     if (fread(rbt->frame_size_table, rbt->frame_count * sizeof(uint16_t), 1, inrbt_file) != 1)
     
343.     {
     
344.         printf("problem reading frame table\n");
     
345.         return 0;
     6 S# {8 i4 z" S" k. X: U9 e+ i
346.     }
     
347.     rbt->frame_size_table_offset = ftell(outrbt_file);
     8 I/ a+ J" z( b/ v
348.     if (fwrite(rbt->frame_size_table, rbt->frame_count * sizeof(uint16_t), 1, outrbt_file) != 1)
     
349.     {
     % ?* C8 l5 ^8 r1 B
350.         printf("problem writing frame table\n");
     / K; b$ u' j) h" K0 z7 ~
351.         return 0;
     9 O# A3 C# p7 @5 s# c5 u! b" q
352.     }
     
353. 
     
354.     /* find the max frame size */
     / [* ]2 c( t5 s; H  j
355.     max_frame_size = 0;
     
356.     for (i = 0; i < rbt->frame_count; i++)
     " U" r0 l( Y6 A5 i
357.     {
     & n! J* x8 U; Z0 c/ `
358.         frame_size = LE_16(&rbt->frame_size_table[i*2]);
     
359.         if (frame_size > max_frame_size)
     
360.             max_frame_size = frame_size;
     
361.     }
     
362.     rbt->frame_load_buffer = malloc(max_frame_size);
     
363. 
     
364.     /* transfer the unknown table(s) */
     3 o' R* L" [3 T& S  Q
365.     if (fread(unknown_table, UNKNOWN_TABLE_SIZE, 1, inrbt_file) != 1)
     
366.     {
     
367.         printf("problem reading unknown table\n");
     1 A9 |9 q8 b+ e. {- M
368.         return 0;
     $ f% B% e/ }1 o$ q6 r: T
369.     }
     5 v8 ?1 S4 @/ O$ Z! F
370.     if (fwrite(unknown_table, UNKNOWN_TABLE_SIZE, 1, outrbt_file) != 1)
     
371.     {
     ; S7 |) o' K6 |2 H
372.         printf("problem writing unknown table\n");
     
373.         return 0;
     4 c. N8 X- c6 ^* B; D6 {* ~- e
374.     }
     - J' v2 u  `  I% Q" m% \8 _$ O
375. 
     
376.     /* copy over padding */
     
377.     padding_size = 0x800 - (ftell(inrbt_file) & 0x7FF);
     6 ?$ V8 |) p' s! m
378.     if (padding_size)
     
379.     {
     9 e+ }- \* P2 o& ~
380.         padding = malloc(padding_size);
     
381.         if (fread(padding, padding_size, 1, inrbt_file) != 1)
     : u" t  d- n1 C6 y1 ?% c/ n5 O& h
382.         {
     8 f( W. ~0 y/ W7 \9 Z; Z
383.             printf("problem reading padding\n");
     
384.             return 0;
     
385.         }
     
386.         if (fwrite(padding, padding_size, 1, outrbt_file) != 1)
     3 _! I4 ?5 X+ [* h; K2 z
387.         {
     5 o" s. W- Z( V( j$ f$ t9 `
388.             printf("problem writing padding\n");
     
389.             return 0;
     
390.         }
     ) h( a: v+ M5 t
391.         free(padding);
       f0 s( l; C* z  a2 G2 U/ T
392.     }
     
393. 
     1 i8 r5 c) R3 x" d( G
394.     return 1;
     
395. }
     8 _+ z+ |8 l& W
396. 
     ' Q2 m7 E) j+ o: X
397. static int get_lzs_back_ref_length(get_bits_context *gb)
     
398. {
     0 v/ l& O/ c2 K6 p
399.     int vlc;
     5 ]0 X. Y- C/ @% U
400.     int count;
     
401.     int value;
     # w. k& ^1 h$ z  T
402. 
     
403.     vlc = view_bits(gb, VLC_SIZE);
     / P$ p& r" {. z& a, g
404.     count = lzs_vlc_table[vlc].count;
     ) }3 @# {1 Z7 Z4 ^
405.     value = lzs_vlc_table[vlc].value;
     . w' r9 {- K& p. j4 @- F4 Q
406. 
     
407.     read_bits(gb, count);
     . Z& G+ b9 d4 ?& }
408.     if (value == 8)
     $ X" P9 o* K$ j6 F; u0 c( `
409.     {
     
410.         do
     
411.         {
     
412.             vlc = read_bits(gb, VLC_SIZE);
     % k! `5 o) k$ i  k1 G5 x# k& h
413.             value += vlc;
     " `6 v# s6 }7 i) N
414.         }
     
415.         while (vlc == 0xF);
     ! o+ o  W6 P; a3 T3 b! [4 K# V8 K
416.     }
     8 b3 {2 g+ {4 q9 `2 _& u7 `5 M1 M
417. 
     ! Z0 s/ i' l( [4 t
418.     return value;
     
419. }
     ; m5 w: g& }3 R7 Z
420. 
     . t) l% J4 S3 P; H6 {0 B; z
421. static void compress_window(put_bits_context *pb, uint8_t *full_window,
     - y+ x7 j9 q+ S' D. `. }+ L( a: b
422.     int full_window_stride,
     1 F  i! N4 ]  d
423.     int window_top, int window_bottom, int window_left, int window_right)
     
424. {
     
425.     int last_pixel;
     
426.     int run_size;
     * \5 K8 x! d( I5 W) K* R
427.     int x;
     ! f& T: i* g' `
428.     int y;
     
429.     int start_index;
     ( Z1 X: O! L/ c( }6 r
430.     int end_index;
     1 d8 Y: p* z: I, o" _) i
431.     int encode_last_run;
     4 X. h5 P. D2 z% ~
432. 
     5 ^3 [* b0 U9 Y' v. c
433.     last_pixel = full_window[0];
     
434.     run_size = 1;
     
435.     for (y = window_top; y <= window_bottom; y++)
     % S& \  j$ S/ R0 O6 H6 l: ]
436.     {
     2 [0 ~( L  N) x' N9 k2 T8 F
437.         start_index = y * full_window_stride + window_left;
     9 S. |! S+ z* P6 r0 K+ ]+ p7 e( [( m  V1 o
438.         if (y == window_top)
     " a* `: y. u+ R# F/ F- v
439.             start_index += 1;
     6 }5 g0 O- q5 [; B- r
440.         end_index = y * full_window_stride + window_right;
     / [! x) V3 ~# a5 [! E: {
441.         if (y == window_bottom)
     
442.             encode_last_run = 1;
     
443.         else
     
444.             encode_last_run = 0;
     5 E5 q/ J' G9 c# V0 x
445.         for (x = start_index; x < end_index; x++)
     
446.         {
     
447.             if (!encode_last_run && full_window[x] == last_pixel)
     9 B" l* }2 P* D) ~) {
448.                 run_size++;
     3 O2 C  P! B& w/ P, K
449.             else
     
450.             {
     
451.                 if (run_size == 1)
     $ Z; T( d, v# x. a
452.                 {
     ; x( X; I0 T* j5 x
453.                     /* encode a 0 bit followed by raw pixel byte */
     ( T, _3 j4 j! e7 S) `
454.                     put_bits(pb, 0, 1);
     * I& ?4 ]8 N3 _3 [9 Q
455.                     put_bits(pb, last_pixel, 8);
     
456.                 }
     
457.                 else if (run_size == 2)
     6 i3 C$ U' o. F  }
458.                 {
     5 W) I* e: R5 v4 i, I
459.                     /* encode a 0 bit followed by raw pixel byte */
     
460.                     put_bits(pb, 0, 1);
     ; H: A$ u/ W% D6 U. ?: J& c5 z
461.                     put_bits(pb, last_pixel, 8);
     8 Q9 R6 C0 `: _) F+ e
462.                     put_bits(pb, 0, 1);
     
463.                     put_bits(pb, last_pixel, 8);
     
464.                 }
     9 p% e# O6 R! ]* v. p
465.                 else
     
466.                 {
     ) L: W" P7 {/ O" R: P5 w! Y3 H+ K
467.                     /* encode a 0 bit followed by raw pixel byte */
     ' p' @; {! l9 p7 i+ U0 R6 k9 o
468.                     put_bits(pb, 0, 1);
     
469.                     put_bits(pb, last_pixel, 8);
     
470.                     run_size--;
     
471.                     /* encode a run: a 1 bit, followed by a back reference
     3 W& |$ ]9 w( x9 M* s( A
472.                      * offset (-1), followed by a length */
     8 z( T5 a; w: w5 K, B( V
473.                     put_bits(pb, 1, 1);
     
474.                     put_bits(pb, 1, 1);  /* 1 = 7-bit offset */
     * ~, P1 u5 P- f% Y' B0 ^% S
475.                     put_bits(pb, 1, 7);
     
476.                     if (run_size <= 4)
     
477.                     {
     5 }% q6 d. C* n% c, P
478.                         /* lengths 2, 3, and 4 are 2 bits */
     
479.                         put_bits(pb, run_size - 2, 2);
     8 E' r) M/ A2 c  j
480.                     }
     1 C0 b8 Y* \3 \) q; I1 a
481.                     else if (run_size <= 7)
     
482.                     {
     . @3 U+ k0 ^1 _+ a  l. s6 p. @
483.                         /* lengths 5, 6, and 7 are 4 bits */
     
484.                         put_bits(pb, run_size + 7, 4);
     
485.                     }
     
486.                     else
     
487.                     {
     
488.                         /* arbitrary length; start by encoding 0xF which
     
489.                          * stands in for an initial version of 8 */
     ! O2 C$ M  Q0 w
490.                         put_bits(pb, 0xF, 4);
     
491.                         run_size -= 8;
     " R4 p% h' ]' E2 w$ M' L
492. 
     
493.                         /* encode blocks of 4 bits until run_size is 0 */
     
494.                         while (run_size >= 0)
     
495.                         {
     
496.                             if (run_size >= 15)
     
497.                             {
     
498.                                 put_bits(pb, 0xF, 4);
     
499.                                 run_size -= 0xF;
     
500.                             }
     
501.                             else
     
502.                             {
     
503.                                 put_bits(pb, run_size, 4);
     
504.                                 run_size = -1;
     & Z! S7 f# T: C& P
505.                             }
     ; z' R5 d3 G9 P
506.                         }
     9 P) @5 `0 b7 V0 Y; d; ~0 A
507.                     }
     " K0 O1 J2 ^1 d0 p3 p( P* V/ {" |
508.                 }
     & q6 E/ P+ @; v* U7 k
509. 
     
510.                 last_pixel = full_window[x];
     + [$ i0 H0 E" e( o! g
511.                 run_size = 1;
     & W8 e6 E8 l& u# J5 I
512. 
     
513.                 /* this single x iteration was only here to close the final run */
     
514.                 if (y == window_bottom)
     9 b4 q' P$ [" i
515.                     break;
     
516.             }
     
517.         }
     
518.     }
     $ S1 q9 p/ ^+ _8 ]. B- _5 m# J$ q
519. 
     
520.     /* close the bitstream by encoding a back reference with length 0 */
     
521.     put_bits(pb, 1, 1);  /* back reference run */
     
522.     put_bits(pb, 1, 1);  /* 1 = 7-bit offset */
     
523.     put_bits(pb, 0, 7);  /* length 0 */
     
524. 
     0 ]3 _3 ~' K$ q0 @8 T; J% h$ U
525.     put_bits_flush(pb);
     , K$ M8 ]9 w+ c! L; f& n
526. }
     8 M9 y8 Q2 Y" o( m1 f
527. 
     + T9 L' r3 [4 d
528. /* compute Euclidean distance between an RGB color and the desired target */
     7 K9 t! d! T9 y1 C) h
529. static int compute_rgb_distance(int r1, int r2, int g1, int g2, int b1, int b2)
     
530. {
     $ _' f9 R: W7 Y
531.     return sqrt((r1 - r2) * (r1 - r2) +
     + ?$ V# H7 R8 i- b; t( [* V) |9 a
532.                 (g1 - g2) * (g1 - g2) +
     ) W5 H8 C- \# S, C; A
533.                 (b1 - b2) * (b1 - b2));
     0 e9 Z! v" Y) n* Y
534. }
     , ~# X( [8 s8 Y  O" F4 y. o
535. 
     / m* g" A/ M% ^& I, m' [( m, {1 r
536. static uint8_t find_nearest_color(rbt_dec_context *rbt, int r, int g, int b)
     7 _7 Z! b& Z% s' G) C/ i$ W! B% E
537. {
     8 D. k; C- E( w& Y# B" H
538.     int i;
     9 z% Y' s2 p. `$ f
539.     int nearest_distance;
     4 e* x% q  [; a9 C3 D& _
540.     int distance;
     + V6 @% b; ?; e) `0 r4 u9 m) f, \
541.     int rp;
     
542.     int gp;
     
543.     int bp;
     
544.     uint8_t palette_index;
     
545. 
     
546.     nearest_distance = 999999999;
     8 i; b7 b$ B; I  H
547.     palette_index = 0;
     7 Q: O/ o- r# u9 G9 M
548.     for (i = 0; i < 256; i++)
     4 P, j. q/ P; b3 i' g1 N
549.     {
     
550.         rp = rbt->palette[i * 3 + 0];
     - s! `$ ^  F# h( P* Y2 h$ C
551.         gp = rbt->palette[i * 3 + 1];
     
552.         bp = rbt->palette[i * 3 + 2];
     7 v$ u" K( R& _! L) l, f0 j
553.         distance = compute_rgb_distance(r, rp, g, gp, b, bp);
     9 `; z& J6 k0 J0 D  ^. u
554.         if (distance < nearest_distance)
     ( o6 g9 ^* _) G* u( t: g
555.         {
     
556.             nearest_distance = distance;
     
557.             palette_index = i;
     
558.         }
     
559.         /* can't get closer than 0; break early */
     
560.         if (distance == 0)
     ; L% ]4 g9 n" x
561.             break;
     # }9 C) J9 v+ n' |0 j
562.     }
     
563. 
     & V% F" F" q' l
564.     return palette_index;
     8 U) M: N( E2 l  @" Z- E
565. }
     
566. 
     
567. static void subtitle_frame(rbt_dec_context *rbt, uint8_t *frame,
     + }2 x* k/ {! H. ?6 ]: G  ]& _
568.     int width, int height, int timestamp)
     
569. {
     
570.     ASS_Image *subtitles;
     3 S% \/ }7 }3 P3 U8 ]
571.     int detect_change;
     % Q6 }& D) ^( c# s: ~0 v7 Y! f
572.     uint8_t subtitle_pixel;
     
573.     int x, y;
       n! o# E3 \5 h: I/ Y* M+ s% Y" V
574.     uint8_t *frame_ptr;
     
575.     uint8_t *subtitle_ptr;
     1 J. `! b4 Y; X, S% S9 n# G/ m  f
576. 
     $ p4 V5 t6 k* F% ?6 k% q* [
577.     /* ask library for the subtitle for this timestamp */
     * d% V( {( _( @7 v! y6 U: g, l' r
578.     subtitles = ass_render_frame(rbt->ass_renderer, rbt->ass_track,
     , t  x% V4 ^: \. q" x' l
579.         timestamp, &detect_change);
     
580. 
     5 L: Z- B2 Z3 I
581.     /* render the list of subtitles onto the decoded frame */
     
582.     while (subtitles)
     ! e$ o: S& `" c8 ~' [. x  e0 J
583.     {
     
584.         /* palette components are only 6 bits, so shift an extra 2
     / }) J# I5 z2 p: |) t+ s9 E* r5 `
585.          * bits off each component */
     
586.         subtitle_pixel = find_nearest_color(rbt,
     
587.             (subtitles->color >> 10) & 0xFF,
     
588.             (subtitles->color >> 18) & 0xFF,
     4 S" a0 D' [: z" Z7 |
589.             (subtitles->color >> 26) & 0xFF);
     
590.         for (y = 0; y < subtitles->h; y++)
     ; ]+ N6 W: H( S$ {( e
591.         {
     4 b9 s; _& B; z: X0 @
592.             subtitle_ptr = &subtitles->bitmap[y * subtitles->stride];
     & Q  A& H. \  T( n0 y
593.             frame_ptr = &frame[(subtitles->dst_y + y) * width + subtitles->dst_x];
     
594.             for (x = 0; x < subtitles->w; x++, frame_ptr++, subtitle_ptr++)
     # f: I, C5 R) k1 M7 @' f' b
595.             {
     
596.                 if (*subtitle_ptr >= SUBTITLE_THRESHOLD)
     ! E* |1 t. Y. u/ N
597.                     *frame_ptr = subtitle_pixel;
     7 ]6 C0 ~2 \7 g4 W2 [
598.             }
     $ o4 m3 V4 W5 n  v: C
599.         }
     0 u- ~9 A2 Z8 u! e' K+ Y% x3 d/ ]
600.         subtitles = subtitles->next;
     
601.     }
     1 w+ E3 K3 Y; j/ ?
602. }
     
603. 
     0 a% X( t; s" u9 X7 ?$ j6 L0 x
604. static int copy_frames(rbt_dec_context *rbt, FILE *inrbt_file, FILE *outrbt_file,
     . D: n4 q" V- F/ Y
605.     int origin_x, int origin_y, int window_width, int window_height)
     3 c: _( f; T6 E# j: O# I) V6 l
606. {
     7 X' L, l0 ^5 |7 g+ b
607.     int i;
     + W" }  ?% [3 m. C7 p6 K# F
608.     int j;
     
609.     int scale;
     
610.     int width;
     + L$ o' U3 Q7 ^8 J. T
611.     int height;
     / X& D0 q& j3 w8 G8 D" h
612.     int max_width;
     
613.     int max_height;
     
614.     int frame_x;
     6 }. K+ h* _# o- |$ t9 h8 j% x
615.     int frame_y;
       {+ r; U8 P3 Y. c. I
616.     int fragment_count;
     
617.     int decoded_size;
     
618.     uint8_t *decoded_frame;
     
619.     int fragment;
     
620.     int fragment_compressed_size;
     
621.     int fragment_decompressed_size;
     
622.     int compression_type;
     
623.     int index;
     ( _# `" V7 B7 Y9 u/ m6 c+ E
624.     int out_index;
     
625.     get_bits_context gb;
     ' D% |3 a  O. b7 d
626.     int frame_size;
     
627.     int video_frame_size;
     # ~6 H7 D) ], H" x
628.     int audio_frame_size;
     0 ?, A+ p/ ~) X7 V$ x! I
629. 
     
630.     int back_ref_offset_type;
     
631.     int back_ref_offset;
     . E! c. @0 v" M2 s5 J' T
632.     int back_ref_length;
     - Y; m: r; a0 g' c% n9 v3 L& L
633.     int back_ref_start;
     
634.     int back_ref_end;
     ( L/ s; j8 j2 ?$ U7 K+ f+ s
635. 
     * l" I; n8 `( P: x; `+ K
636.     uint8_t *full_window;
     - e! O4 J  d+ l" y
637.     int full_window_size;
     : [) r4 r1 ]( w% O
638.     int y;
     
639.     int window_top;
     % e- Z* g0 d, ^* [
640.     int window_bottom;
     
641.     int window_left;
     
642.     int window_right;
     ( S0 Q/ ~+ H  e: `
643.     int window_size;
     
644. 
     8 J, z9 E8 X( a+ V: B
645.     char filename[30];
     
646. 
     5 _0 {1 `$ q0 w+ i6 D7 P
647.     put_bits_context *pb;
     
648. 
     " M4 j5 A) G+ U& X
649.     full_window_size = window_width * window_height;
     
650.     full_window = malloc(full_window_size);
     3 ], m( t8 D7 |$ m
651.     pb = init_put_bits();
     
652. 
     & G$ F. v7 F5 S: p  R7 q* r
653.     max_width = 0;
     1 C* z7 e6 g% J4 ]! x! B0 ?
654.     max_height = 0;
     - U; Y5 C( T+ w7 b
655. 
     
656.     for (i = 0; i < rbt->frame_count; i++)
     7 n# n" k6 Y! P
657.     {
     , u$ ~' E4 |$ w5 q
658.         /* read the entire frame (includes audio and video) */
     
659.         frame_size = LE_16(&rbt->frame_size_table[i*2]);
     & R1 f0 @+ G9 W
660.         video_frame_size = LE_16(&rbt->video_frame_size_table[i*2]);
     / [; q- ~5 o8 c  `
661.         audio_frame_size = frame_size - video_frame_size;
     7 d; D5 q" O$ \& g( Y
662.         if (fread(rbt->frame_load_buffer, frame_size, 1, inrbt_file) != 1)
     
663.         {
     + U' _) I- ]0 k! L' K& P* `7 C& Z
664.             printf("problem reading frame %d\n", i);
     
665.             return 0;
     % g  E3 J  T+ }2 `
666.         }
     9 r9 L8 t; X2 i6 v% D- d" P
667. 
     7 h7 }/ _% I3 V
668.         scale = rbt->frame_load_buffer[3];
     $ N! x) {( H, c, G" f1 ^
669.         width = LE_16(&rbt->frame_load_buffer[4]);
     ; r# C/ u0 ]4 `" s- y9 P8 A0 f1 `
670.         if (max_width < width)
     
671.             max_width = width;
     , R1 P/ i; ?  L3 M
672.         if (max_height < height)
     ! C) L7 E# z6 q
673.             max_height = height;
     
674.         height = LE_16(&rbt->frame_load_buffer[6]);
     / N# v  \* f( v
675.         frame_x = LE_16(&rbt->frame_load_buffer[12]);
     3 G. [/ {7 c# f, B
676.         frame_y = LE_16(&rbt->frame_load_buffer[14]);
     
677.         fragment_count = LE_16(&rbt->frame_load_buffer[18]);
     
678.         decoded_size = width * height;
     ) b' J" C( t9 e" }
679. 
     / I+ ^, g5 H* Z
680.         printf("processing frame %d: %d%%, %dx%d, origin @ (%d, %d), %d fragments\n", i, scale, width, height, frame_x, frame_y, fragment_count);
     
681. 
     
682.         /* decode the frame */
     
683.         decoded_frame = malloc(decoded_size);
       z( U) q3 s+ \) ^
684.         index = 24;
     
685.         out_index = 0;
     
686.         for (fragment = 0; fragment < fragment_count; fragment++)
     & p) c! a/ q( ?. [& m+ J
687.         {
     
688.             fragment_compressed_size = LE_32(&rbt->frame_load_buffer[index]);
     
689.             index += 4;
     
690.             fragment_decompressed_size = LE_32(&rbt->frame_load_buffer[index]);
     
691.             index += 4;
     1 j" Z" }5 }: l, r+ m  v. I5 d# D
692.             compression_type = LE_16(&rbt->frame_load_buffer[index]);
     & _6 a2 x) E2 o/ N2 }; z, Z) j
693.             index += 2;
     $ j4 ^' k7 ^4 B- F* o
694. 
     7 c% m$ m, f& O- @, O; n
695.             if (compression_type == 0)
     . i$ t' R  L4 p5 Z8 m( R: p
696.             {
     
697.                 init_get_bits(&gb, &rbt->frame_load_buffer[index],
     3 y/ l3 e9 T  L) T0 Y, i
698.                     fragment_compressed_size);
     
699. 
     . R5 m4 a5 L; O1 d1 l
700.                 while (out_index < fragment_decompressed_size)
     4 m% H/ d5 J" c8 |/ J) ~9 O+ L0 j
701.                 {
     
702.                     if (read_bits(&gb, 1))
     ( z1 R5 [3 n% e) _0 w
703.                     {
     4 ]7 l0 A) U! T% m
704.                         /* decode back reference offset type */
     
705.                         back_ref_offset_type = read_bits(&gb, 1);
     
706. 
     6 m& q9 x9 a- U% a4 m; o) n
707.                         /* back reference offset is 7 or 11 bits */
     4 |' _! u$ @/ V, v4 B& \# T. L2 ^% d
708.                         back_ref_offset = read_bits(&gb,
     
709.                             (back_ref_offset_type) ? 7 : 11);
     ; I% k' w" X9 w( K+ ], Z) P
710. 
     
711.                         /* get the length of the back reference */
     
712.                         back_ref_length = get_lzs_back_ref_length(&gb);
     
713.                         back_ref_start = out_index - back_ref_offset;
     / r- f1 N! }' j8 i
714.                         back_ref_end = back_ref_start + back_ref_length;
     ) g9 k. `* u/ T" L/ `9 G8 m: z6 o
715. 
     ! X( k9 Q& G% v& L7 K" ^5 M
716.                         /* copy the back reference, byte by byte */
     " b9 H# _) Y4 t2 a
717.                         for (j = back_ref_start; j < back_ref_end; j++)
     
718.                             decoded_frame[out_index++] = decoded_frame[j];
     
719.                     }
     
720.                     else
     . n' @! a$ j6 J0 Q- t: D
721.                     {
     & M, N7 B) k, {, I! g7 a. N
722.                         /* read raw pixel byte */
     
723.                         decoded_frame[out_index++] = read_bits(&gb, 8) & 0xFF;
       M# u+ u! p# `, q/ V  D+ X
724.                     }
     ! U* v6 }' _) P; ]! ~! T, `
725.                 }
     $ S9 {0 [5 C; w
726. 
     
727.                 delete_get_bits(&gb);
     1 M, Z- g8 F& Y) r6 g: N/ E
728.             }
     4 F" q! }) X+ D; b
729. 
     
730.             /* next fragment */
     0 I6 {! E! S8 f. G  g
731.             index += fragment_compressed_size;
     3 a$ J) M' ^6 s- H0 t$ T& T% A
732.         }
     
733. 
     $ a% U% ?# }4 y/ g: }3 r( ]# D
734.         if (rbt->dump_frames)
     # v+ [' |& _8 \: O) ?
735.         {
     
736.             /* dump the original frame */
     
737.             sprintf(filename, "original-frame-%03d.pnm", i);
     . @* K- K( q/ v$ u
738.             dump_pnm_file(filename, rbt, decoded_frame, width, height);
     
739.         }
     
740. 
     0 S6 r6 ?2 g, {# D8 }# `5 Y
741.         /* transfer the image onto the frame window */
     
742.         memset(full_window, 0xFF, full_window_size);
     
743.         index = 0;
     
744.         for (y = 0; y < height; y++)
     6 ?, [0 F) z4 c( c# q
745.         {
     
746.             out_index = window_width * (frame_y + y) + frame_x;
     
747.             memcpy(&full_window[out_index], &decoded_frame[index], width);
       D* y$ F) u: k2 x# x. s
748.             index += width;
     : T; s9 m- E9 B  p/ F
749.         }
     : g6 P" e1 E5 B8 K3 v$ E
750. 
     
751.         /* write the subtitle */
     % ~  T( |( I9 Z  L& N  w" }
752.         subtitle_frame(rbt, full_window, window_width, window_height,
     2 s2 |/ F" {9 u( l5 ^
753.             i * MILLISECONDS_PER_FRAME);
     
754. 
     + ^4 l8 |" d6 f, B1 [( g
755.         /* figure out the smallest change window */
     
756.         window_top = frame_y;
     
757.         window_bottom = window_height;
     ( {4 Z: n9 T+ @0 `
758.         window_left = 0;
     $ I6 w1 R3 R( W  u- E, s& ]' s
759.         window_right = window_width;
     
760.         window_size = (window_right - window_left) * (window_bottom - window_top);
     
761. 
     9 t! B+ `9 i, q# ]( R  r* H
762.         /* compress the frame */
     
763.         reset_put_bits(pb);
     
764.         compress_window(pb, full_window, window_width, window_top,
     % B! @/ T" R* I- S+ f1 h
765.             window_bottom, window_left, window_right);
     3 {5 `+ k/ q1 z
766. 
     7 L0 y! C% S. q" e0 P; \
767.         if (rbt->dump_frames)
     & D, P2 M* m1 P* v/ l2 g+ q9 c. W
768.         {
     ! }1 o7 B2 V: X$ Y" P$ w) ?" M
769.             /* dump the frame plotted onto the full window prior to encoding,
     : A" y" g/ H6 ^$ M
770.              * with subtitle */
     3 _4 l' I' K& y" O% |
771.             sprintf(filename, "pre-encoding-frame-%03d.pnm", i);
     ' j; m* Y1 u) ?
772.             dump_pnm_file(filename, rbt, full_window, window_width, window_height);
     3 i5 e+ z' c! M4 E) e
773.         }
     ( H2 g2 r+ \3 n* C
774. 
     " G' m4 W4 x3 r
775.         free(decoded_frame);
     ( {8 U& F2 m% V% P4 V3 x
776. 
     
777.         /* update the frame header */
     
778.         /* width */
     
779.         rbt->frame_load_buffer[4] = (window_right - window_left) & 0xFF;
     0 [1 v( k' K/ _
780.         rbt->frame_load_buffer[5] = (window_right - window_left) >> 8;
     
781.         /* height */
     
782.         rbt->frame_load_buffer[6] = (window_bottom - window_top) & 0xFF;
     
783.         rbt->frame_load_buffer[7] = (window_bottom - window_top) >> 8;
     + P' Y0 K( p% v: O" f2 M- _
784.         /* origin X */
     % m% P- J% M3 ^$ U" V- d  L6 {% D
785.         rbt->frame_load_buffer[12] = window_left & 0xFF;
     ) b2 w: G' L6 C, }- \6 m
786.         rbt->frame_load_buffer[13] = window_left >> 8;
     
787.         /* origin Y */
     
788.         rbt->frame_load_buffer[14] = window_top & 0xFF;
     4 {& Y& t6 U+ a
789.         rbt->frame_load_buffer[15] = window_top >> 8;
     
790.         /* fragment payload size */
     # k% z/ D2 k7 n! [
791.         rbt->frame_load_buffer[16] = (pb->byte_index + 10) & 0xFF;
     3 u$ ^9 x6 ?, R5 y
792.         rbt->frame_load_buffer[17] = (pb->byte_index + 10) >> 8;
     
793.         /* fragment count (1) */
     . E; @# W9 k* E1 }
794.         rbt->frame_load_buffer[18] = 1;
     / u" M" z' ], j1 i2 ~& m
795.         rbt->frame_load_buffer[19] = 0;
     % L/ _2 M5 F) M
796. 
     : ?& G/ P" R! W3 r- U$ s" K& _
797.         /* update the fragment header */
     6 _  P. n- @# Q- B
798.         /* compressed size */
     
799.         rbt->frame_load_buffer[24 + 0] = (pb->byte_index >>  0) & 0xFF;
     
800.         rbt->frame_load_buffer[24 + 1] = (pb->byte_index >>  8) & 0xFF;
     ! N! z/ G% C9 f2 b! H3 a3 h! d: t6 P
801.         rbt->frame_load_buffer[24 + 2] = (pb->byte_index >> 16) & 0xFF;
     
802.         rbt->frame_load_buffer[24 + 3] = (pb->byte_index >> 24) & 0xFF;
     
803.         /* decompressed size */
     $ V9 U5 T' b# F& j3 d5 C
804.         rbt->frame_load_buffer[24 + 4] = (window_size >>  0) & 0xFF;
     
805.         rbt->frame_load_buffer[24 + 5] = (window_size >>  8) & 0xFF;
     " h+ l0 D* m% O9 H5 V: K2 m9 f9 O
806.         rbt->frame_load_buffer[24 + 6] = (window_size >> 16) & 0xFF;
     
807.         rbt->frame_load_buffer[24 + 7] = (window_size >> 24) & 0xFF;
     
808.         /* compression format 0 */
     
809.         rbt->frame_load_buffer[24 + 8] = 0;
     5 ?! G  |" E+ {- S8 e0 i
810.         rbt->frame_load_buffer[24 + 9] = 0;
     
811. 
     
812.         /* write the 24-byte frame header and the 10-byte fragment header */
     
813.         if (fwrite(rbt->frame_load_buffer, 24 + 10, 1, outrbt_file) != 1)
     
814.         {
     
815.             printf("problem writing frame %d\n", i);
     & b1 M/ W1 b# r2 m
816.             return 0;
     
817.         }
     / Q6 w4 j- u) H0 R
818. 
     ) L. q1 B* [+ k: d* v
819.         /* write the new compressed frame data */
     ( X6 _+ U& F2 ~3 U- e
820.         if (fwrite(pb->bytes, pb->byte_index, 1, outrbt_file) != 1)
     
821.         {
     
822.             printf("problem writing frame %d\n", i);
     
823.             return 0;
     
824.         }
     
825. 
     ' M! J3 u/ E' v+ a! O1 N
826.         /* write the audio data */
     ( u; V0 a# v8 s6 U8 K
827.         if (fwrite(&rbt->frame_load_buffer[video_frame_size], frame_size - video_frame_size, 1, outrbt_file) != 1)
     
828.         {
     . J' t' z" n: t; b
829.             printf("problem writing frame %d\n", i);
     . j% E; F9 e# a8 `: h3 F. t
830.             return 0;
     
831.         }
     
832. 
     
833.         /* update the table entries */
     % l5 v) A' f2 @) r
834.         video_frame_size = pb->byte_index + 24 + 10;
     ' N& \+ E- @3 E/ q% g- A/ A& P
835.         frame_size = video_frame_size + audio_frame_size;
     
836.         rbt->frame_size_table[i*2+0] = frame_size & 0xFF;
     & q& z8 `# p( Z3 y. y" r8 x! V
837.         rbt->frame_size_table[i*2+1] = frame_size >> 8;
     # o+ n0 E. X* v9 e1 ]! Q* R6 y
838.         rbt->video_frame_size_table[i*2+0] = video_frame_size & 0xFF;
     
839.         rbt->video_frame_size_table[i*2+1] = video_frame_size >> 8;
     
840.     }
     
841. 
     ) E9 [3 j7 Z# v
842.     printf("maximum dimensions seen are %dx%d\n", max_width, max_height);
     ' v- `+ J- T) I7 x
843. 
     ' N; a+ m$ s5 \0 o$ m6 T9 l0 U
844.     delete_put_bits(pb);
     . d# P& y+ N) s$ e/ x, j
845.     free(full_window);
     + {9 Y9 I, Y" \0 X
846. 
     : t0 P8 }  g( G2 v+ D  D2 ~+ m
847.     return 1;
     * T$ h% r! r9 a8 m
848. }
     
849. 
     
850. int main(int argc, char *argv[])
     
851. {
     5 A, l& G1 K( f! f* b" t* G5 a
852.     char *subtitle_filename;
     
853.     FILE *subtitle_file;
     
854.     char *inrbt_filename;
     
855.     FILE *inrbt_file;
     0 V7 }- ]3 Z- H& h* `& E
856.     char *outrbt_filename;
     6 |7 H4 [% E% Z% e8 {) F3 L
857.     FILE *outrbt_file;
     
858.     rbt_dec_context rbt;
     9 W/ }4 ~' X: T: |
859.     int origin_x;
     
860.     int origin_y;
     
861.     int window_width;
     % }( K8 G5 G/ k- G/ _' O
862.     int window_height;
     
863. 
     
864.     /* testing the bit functions */
     9 E% h' e5 A8 @2 |4 u. _6 Q
865. #if 0
     ) @6 i/ {) E( j4 V
866.     int i;
     
867.     uint8_t bytestream[] = { 0x55, 0xAA, 0x00, 0xAA, 0x55, 0x77, 0xFF, 0x1B, 0x70, 0x8F };
     
868.     int bytestream_size = 10;
     % N( f4 r- [9 z, o
869.     get_bits_context gb;
     ! O, P0 @+ K4 f) h/ [  S
870.     put_bits_context *pb;
     
871.     int bits;
     
872. 
     
873.     init_get_bits(&gb, bytestream, bytestream_size);
     
874.     pb = init_put_bits();
     / c* j+ W& F) S# b# @2 S* n' Q
875. 
     
876.     for (i = 1; i <= 12; i++)
     
877.     {
     6 a4 d5 t: {  d4 N1 G, l
878.         bits = view_bits(&gb, i);
     
879.         printf("view %d bits: %d\n", i, bits);
     
880.         printf("read %d bits: %d\n", i, read_bits(&gb, i));
     ) P: n  ?" P3 k
881.         put_bits(pb, bits, i);
     
882.     }
     
883.     put_bits_flush(pb);
     - j( q0 a* y7 u" k  q8 u
884. 
     % c% Q3 C* P' g6 I
885.     printf("original bytestream:\n");
     , K% k4 Q& u6 e% f
886.     for (i = 0; i < bytestream_size; i++)
     # z- X3 U2 E9 S  h0 ^
887.         printf(" %02X", bytestream[i]);
     
888.     printf("\nnewbytestream:\n");
     
889.     for (i = 0; i < pb->byte_index; i++)
     
890.         printf(" %02X", pb->bytes[i]);
     # M) B& ]6 {7 w5 `+ v
891.     printf("\n");
     
892. 
     
893.     delete_get_bits(&gb);
     
894.     free(pb);
     
895. #endif
     9 W3 g; M; I# s( A/ i
896. 
     # e$ K( b/ W  h
897.     /* validate the number of arguments */
     
898.     if (argc != 8 && argc != 9)
       U0 ?/ w. ~. J  I5 I
899.     {
     
900.         printf("USAGE: subtitle-rbt <subtitles.ass> <in.rbt> <out.rbt> <origin X> <origin Y> <width> <height> [dump_frames]\n");
     ! s4 U" h' _' }. H
901.         return 1;
     " S1 g7 ~& E0 h& L. ^; @
902.     }
     1 E, C0 Q/ i, ^! F: t
903.     subtitle_filename = argv[1];
     
904.     inrbt_filename = argv[2];
     7 [0 I' ^: U& w0 Y
905.     outrbt_filename = argv[3];
     
906.     origin_x = atoi(argv[4]);
       G8 m( E( \! w/ Q: Y1 D4 ?  D
907.     origin_y = atoi(argv[5]);
     
908.     window_width = atoi(argv[6]);
     
909.     window_height = atoi(argv[7]);
     
910.     rbt.dump_frames = 0;
     
911.     if (argc == 9)
     
912.         rbt.dump_frames = 1;
     
913. 
     ( |9 M2 F" F' j. u6 i" h8 u$ H
914.     /* verify that the specified input files are valid */
     # H$ [+ y" I+ _+ X5 ]2 t
915.     subtitle_file = fopen(subtitle_filename, "r");
     & C5 b. R, @) x: [
916.     if (!subtitle_file)
     1 u" i- k6 d9 Q1 Y( f  a6 _
917.     {
     : Z* J/ J" n$ k) I  f4 i* w
918.         perror(subtitle_filename);
     ! [2 ~, C  n! C, |' b3 v) u
919.         return 1;
     9 r8 |+ x0 j/ t# A2 }/ h
920.     }
       p# a5 e7 Z5 h8 `: s0 t  S- O- e  K% D
921.     fclose(subtitle_file);
     
922.     inrbt_file = fopen(inrbt_filename, "rb");
     
923.     if (!inrbt_file)
     2 d! J9 n! X9 \  l
924.     {
     0 c9 f4 X$ X; P% x3 }
925.         perror(inrbt_filename);
     & o0 ]6 D( X% i. i8 \; H
926.         return 1;
     
927.     }
     - x0 K/ i- [. r- R5 y4 s
928. 
     
929.     /* initialize the subtitle support */
     6 y: U9 f5 ~9 s/ c2 g& X3 ]
930.     rbt.ass_lib = ass_library_init();
     3 y( N3 O1 ]. A2 }, ]4 t$ M, a$ ~
931.     rbt.ass_renderer = ass_renderer_init(rbt.ass_lib);
     
932.     rbt.ass_track = ass_read_file(rbt.ass_lib, subtitle_filename, "UTF-8");
     
933.     ass_set_frame_size(rbt.ass_renderer, window_width, window_height);
     
934.     ass_set_fonts(rbt.ass_renderer, NULL, NULL, 1, NULL, 1);
     / |0 R% o" X- O
935. 
     
936.     /* open the output file */
     ! r0 O$ h6 i2 Y
937.     outrbt_file = fopen(outrbt_filename, "wb");
     
938.     if (!outrbt_file)
       u+ x; L) m8 {) L/ O
939.     {
     + h$ E$ v( A2 v4 @: B) D
940.         perror(outrbt_filename);
     
941.         return 1;
     
942.     }
     " a3 a5 U* F# Y( D
943. 
     ! {2 \0 N! w* D4 c/ G. N
944.     /* transfer header from input to output */
     
945.     if (!load_and_copy_rbt_header(&rbt, inrbt_file, outrbt_file))
     & Y4 U6 {# Z/ H9 N
946.         return 1;
     " k, g& e0 j" H( L- L. G
947. 
     / t6 H6 j9 [+ m, R3 T
948.     /* rewrite the frames */
     
949.     if (!copy_frames(&rbt, inrbt_file, outrbt_file, origin_x, origin_y,
     
950.         window_width, window_height))
     " ^  L( K1 @0 }$ g. A2 `
951.         return 1;
     
952. 
     ! q1 M( R4 A) J( r5 ]: ]+ u. r
953.     /* write the modified frame size tables back to the file */
     
954.     fseek(outrbt_file, rbt.video_frame_size_table_offset, SEEK_SET);
     
955.     fwrite(rbt.video_frame_size_table, rbt.frame_count * sizeof(uint16_t), 1, outrbt_file);
     ! `$ A$ W  d( x1 T8 J, x
956.     fseek(outrbt_file, rbt.frame_size_table_offset, SEEK_SET);
     3 \, V: h1 L4 I0 @
957.     fwrite(rbt.frame_size_table, rbt.frame_count * sizeof(uint16_t), 1, outrbt_file);
     
958. 
     
959.     /* finished with files */
     
960.     fclose(inrbt_file);
     " c8 Z' y1 l( O. g3 q
961.     fclose(outrbt_file);
     ! p4 Z0 \! m1 D4 f" f7 h
962. 
     8 b6 _+ H$ u9 |) A
963.     /* clean up subtitle library */
     
964.     ass_free_track(rbt.ass_track);
     ' V& u3 Z9 x* e9 R( `5 T
965.     ass_renderer_done(rbt.ass_renderer);
     
966.     ass_library_done(rbt.ass_lib);
     
967. 
     
968.     /* clean up */
     5 o* T' p3 [& e, ?
969.     free(rbt.frame_load_buffer);
     # O' G6 E8 X- o- |! a, p, w" H+ Q
970.     free(rbt.video_frame_size_table);
     ; I7 R5 h0 u8 Y) C
971.     free(rbt.frame_size_table);
     
972. 
     
973.     return 0;
     
974. }

复制代码

  W/ T9 i# }- c: ^( K) s8 d

soring123

这游戏有字幕吗？

shane007

引用第1楼soring123于2009-11-19 11:09发表的  :
# X+ A) }. T9 h- |0 E这游戏有字幕吗？

3 n2 S: W. j8 J2 X! F好像没有字幕，我说的是给视频外挂字幕方式的汉化。
1 u1 a% n0 D" J9 S( ~就像syberia2汉化版下面那行字一样。

soring123

我记得是没字幕的 比较麻烦 都是视频的

shane007

引用第3楼soring123于2009-11-19 17:07发表的  :
7 Q, z( @) y! I& p; N& y我记得是没字幕的 比较麻烦 都是视频的

给视频外挂字幕方式汉化也许能行。
( }- o' b) W/ X9 d要结合dosbox和代理dll技术。

宿矢

求汉化啊！

shane007

顶上来